Index Changes
This is version 7. It is not the current version, and thus it cannot be edited.
[Back to current version]   [Restore this version]
Where will YOU be June 2?

OpenESB at JavaOne 2009

OpenESB will again have a strong presence at JavaOne this year! There will be the following events:

Community events


  • What is it? "An unconference is a conference where the content of the sessions is created and managed by the participants rather than by one or more organizers in advance of the event". We'll have a round table discussion between OpenESB users and OpenESB developers. The agenda is (per definition) open, but topics likely to be discussed are experiences with OpenESB and the future of OpenESB.
  • When: Sunday May 31th 2009, 1pm-7pm
  • Where: Moscone Center (Unconference space, Hall A)
  • Cost: Free Event
  • More info... (please sign up if you intend to attend)

OpenESB Community BOF

  • Title: BOF-6730: What Is and Will Be New in OpenESB?
  • In this BOF, the OpenESB community reviews features added in the past year (the GlassFish ESB release, normalized message properties, message tracking, SOAP header access, and so on) and discusses what's going to be focused on next.
    If you're new to OpenESB, this will be a good opportunity to learn what OpenESB is all about. Whether you're using or are developing OpenESB, you can meet other community members here and influence the future direction of OpenESB.
  • When: Tuesday June 2dn, 07:30 PM-08:20 PM
  • Where: Moscone Center, Esplanade 304-306
  • Conference access required

Conference sessions

In addition to the aforementioned Community BOF, OpenESB is mentioned in the following conference sessions, BOFs and labs:

BOF-4413 Integration of Web Services Stack in an Enterprise Service Bus

Web services support, especially support for Web services based on the Java™ API for XML Web Services (JAX-WS) specification, is a basic requirement for an enterprise service bus (ESB). An ESB typically fulfills this requirement by integrating a Web services stack, such as the Metro project or Apache CXF. Using three open-source ESBs (OpenESB, ServiceMix, and JBossESB) as examples, this session covers options for integrating an ESB with a Web service stack and the implications for services deployed on the ESB. ESB/Web-services-stack integration can be challenging, because although a Web services stack provides both an external HTTP endpoint and a container for the Java technology-based Web service implementation, those responsibilities are typically separated in an ESB. How an ESB can address this challenge is the focus of this presentation, whose goal is to help architects and developers understand how JAX-WS and ESB technologies work together in a SOA and how, as composite application designers, they can leverage Web service support in a particular ESB platform.

This session is intended for architects and developers involved in developing enterprise SOA solutions.

Key points:

  • Web service stack as part of BC: OpenESB-Metro integration approach
  • Web service stack in both BC and SE: ServiceMix-CXF integration approach
  • External Web service stacks: JBossESB-JBossWS integration approach
  • Application design implications
  • WS-* Support in ESB

BOF-4738 Medical Instrument Systems Middleware with SOA, OpenESB, and GlassFish™ V2 Application Server

Clinical data exchange and middleware system integration involves clinical service providers, instrument vendors, and clinical software solution providers. This demands a framework for a patient-record-result exchange infrastructure that can support interconnections among these components and enable them to collaborate in an efficient and effective manner. The project this session discusses implements a middleware application for medical instruments, using service-oriented architecture (SOA) that enables device data exchange from various instruments with multiple data standards. The middleware application runs on the GlassFish™ V2 application server and takes full advantages of the OpenESB platform and Java™ 2 Platform, Enterprise Edition (J2EE™ platform) technologies.

The session brings out the following key points:

  • The project explores the potential benefits of using OpenESB and J2EE technologies in medical/hospital labs' middleware systems.
  • Use of SOA for building laboratory information systems can have a significant impact on the cost of clinical data delivery and exchange by preserving and extending current system investments.
  • The project addresses some of the key issues for establishing an interoperability framework or creating a building block that uses vendor-independent technologies, with a combination of XML and Java Architecture for XML Binding (JAXB) technologies.

BOF-5004 OSGi and the Enterprise Service Bus: Friend or Foe?

Both OSGi and enterprise service buses (ESBs) promote themselves as flexible, dynamic platforms for hosting enterprise services. OSGi provides a robust modularity framework, tight encapsulation, and a service registry that encourages separation of service contract and implementation. ESBs focus on extensible component frameworks to add connectivity and application engines; standard service definitions and communication contracts; and asynchronous, message-based communication. Both platforms aim to provide a modular, extensible architecture that promotes loose coupling of deployed services.

Are these two separate paths to the same goal or complementary solutions that can be leveraged together? Recent activity in the marketplace suggests the latter. More and more enterprise service platforms are adopting OSGi: JBoss ESB, OpenESB, Service Mix -- to name just a few. So what is the value that OSGi and ESBs bring to the table, and how do they align or overlap?

This session, an open discussion spearheaded by ESB and SOA platform architects, covers

  • When OSGi alone is the right answer and when a service platform on top of such an application server or ESB can add value
  • How OSGi enables a new level of modularity and dynamism for service platforms
  • Whether we all need to become OSGi experts, now that many application servers and ESBs are leveraging it
  • How the evolving OSGi Enterprise extensions might fit into an ESB

BOF-5159 Kick-Start Your SOA with Open-Source Tools

There's been an explosion of products and tools in the SOA space, and you've never had more options at your fingertips. This session reviews many of the key open-source options: Java™ Architecture for XML Binding (JAXB), SOAP and REST (CXF, Axis), ESBs (OpenESB, Mule, ServiceMix, JBossESB), messaging (ActiveMQ), governance (Galaxy), BPEL (ActiveBPEL, ODE), and more. It includes a quick overview of each product, backed by real-world experience, highlighting some of the criteria that might make you pick one or the other or lean toward a commercial alternative. You'll leave with the knowledge you need in order to start building out an SOA with no money down!

The session is for architects considering how to implement an SOA and looking for an introduction to the many available tools and options.

The session provides

  • An introduction to key tools in many SOA-related categories
  • A brief analysis of each tool, with real-world capabilities and differentiating factors
  • Insight into where open-source tools fall short compared to commercial options
  • A big-picture view of how you can rapidly start building an SOA with low-cost and easily available tools and some guidance on when to step up to commercial SOA stacks

LAB-6264 Implementing Enterprise Integration Patterns with GlassFish ESB and OpenESB v3

The Enterprise Integration Patterns (EIP) catalog provides a set of blueprints for solving the most common integration problems in your enterprise. Although the blueprints are great, you still have to come up with an implementation, and this is where most developers look for help. Do you need to implement the patterns along with your business logic? What can your application infrastructure do to help, and how do EIP concepts map to your existing architecture (service-oriented architecture SOA, message-oriented middleware MOM, enterprise service bus ESB)?

This Hands-on Lab provides a hands-on approach to selecting and implementing the right EIPs for a variety of real-world integration scenarios. Participants will use the first-class EIP support available in OpenESB v3 to define, configure, and deploy pattern-based applications to their GlassFish ESB runtime. The lab also covers the relationship of EIP to existing SOA and Web services standards and technologies. Expect to come away with a new level of understanding of how you can leverage EIPs in your enterprise.

TS-4389 Enhancing the Role of a Large US Federal Agency as an Intermediary in the Federal Supply Chain via a Service Registry and a JBI-based ESB: A Case Study

This presentation is a case study conducted in a large US Federal Agency which involved a Service Registry and JBI-Based Enterprise Service Bus to enhance the role of this agency as a reliable intermediary in the Federal supply chain. First, we will present the environment where this study was conducted. Then, we will discuss the main drivers, the outstanding challenges (technical and non-technical), and the benefits a service registry combined with an ESB has on inter- and intra-government business operations. In addition, we will discuss how Government policies can be published, discovered, and enforced among partners in the Federal supply chain ecosystem. We will show how a JBI-based ESB and JAX-WS can be used to enforce these policies. We will also show how OMB FEA SRM can be used for service classification, publication, and reuse of services. We will demonstrate how these services can be composed into executable service architectures using the OMG SoaML Standard, an Open Source provisioning capabilities, ModelPro, and a JBI-based ESB. Finally, we will discuss how SOA governance and higher level of SOA maturity can be achieved incrementally. We will show how these open source technologies and products can address the full lifecycle of SOA solutions from modeling to producing executable solutions. We conclude this presentation by highlighting lessons learned and outlining future work.

TS-4839 Enterprise Integration Patterns In Practice

This session explores enterprise integration patterns from both a practitioner's and implementer's perspective, providing guidance on where patterns fit in your application architecture, along with insight into how the patterns are best implemented. The presentation includes a broad survey of the EIP catalog, followed by in-depth analysis of common use cases and application of patterns in the real world. It covers deployment considerations for a variety of deployment environments, including MOM, SOA, and ESBs, and also addresses the relationship between EIP and integration standards such as SCA, JBI, and WS-*. It includes multiple demonstrations using Apache Camel and OpenESB to show patterns in practice.

Attendees with no experience with integration or enterprise integration patterns will benefit from the broad coverage of the subject and hands-on demonstrations. Seasoned integration developers will appreciate the implementation tips and tricks learned in the trenches while putting EIP into practice.

TS-4856 GlassFish ESB: Get Your Apps on the Bus

You're writing Java™ Platform, Enterprise Edition (Java EE platform) apps with ease and boosting productivity and efficiency with annotations, dependency injection, and simple persistence APIs. What more could your manager want? Well, what about orchestrating the beautiful business logic you've written in the Java EE programming language? Sprinkle a little workflow into your Web-based front end? Hook your logic up to your stack of legacy apps? Maybe it's time to consider what an enterprise service bus (ESB) can offer you.

This session introduces the latest addition to the GlassFish™ project family, GlassFish ESB, and highlights how application developers can open their business logic to completely new domains in the enterprise. It includes several common use cases, with concrete examples of how to address them with an ESB:

  • Coordinating business logic via orchestration and workflow management
  • Consuming resources offered by legacy applications and information resources
  • Decoupling business logic from protocol details
  • Leveraging bus services to enrich applications

You will learn how existing applications can be adapted to leverage an ESB's power, focusing on minimizing change to existing business logic and maximizing the ESB's value-add. Sun GlassFish Enterprise Service Bus is used for demo purposes, but the lessons of this session apply to any ESB environment.

TS-5025 Java™ Platform, Enterprise Edition 5 in a National Electronic Health Record System Implementation

This presentation illustrates the speaker's experience in developing a national electronic health record system. After a brief introduction of an electronic healthcare records domain problem and a concise overview of usage scenarios and system features, it explains (and illustrates with the actual code samples) how Java™ Platform, Enterprise Edition 5 (Java EE platform) features were used to reach several concurrent goals:
  • High security and data privacy protection
  • International standards compliance
  • Integration with numerous vendors that have implementations in different technologies
  • Testing and integration procedures

The presentation includes explanations of decisions the development team made in respect to system design and performance trade-offs it experienced, as well as lessons learned. Attendees should have intermediate to advanced Java technology programming skills. TS-5036 Using REST and WS-* in the Cloud REST and WS-* services have made the software behind our applications more flexible, and cloud computing promises to do the same for the hardware. This session looks at deploying, using, and managing services in the cloud. It starts by using REST (JSR 311) to work with code and data in the cloud and then looks at some of the more advanced features of the WS-* stack, including encryption and authentication. You'll leave with an understanding of how these two major trends complement each other.

The intended audience is developers and architects, and programming experience and some knowledge of SOA are recommended.

What you will learn in this session:

  • How cloud computing and service-oriented architectures work together
  • How to use JSR 311 to deploy and access services in the cloud
  • How to use WS-Security and other WS-* standards in the cloud
TS-5123 SOA at Enterprise Scale: Solving Real Challenges with GlassFish ESB This session, for developers (Web services, BPEL, JBI) and analysts with SOA experience, covers SOA in a Fortune 100 company. The large scale of the project demands a technical infrastructure that best fits the firm's needs, both technologically and in terms of TCO/ROI. The firm chose GlassFish ESB, based on a proof of concept. The session gives an impression of the project's size and the scope: It involves approximately 200 interfaces, used by 50+ interoperating business processes. The system spans many countries, with local services connected to a local ESB and global ones through a global ESB. Such a distributed ESB has special deployment considerations: Each process needs to be modifiable individually but needs different -- country-specific or global -- privileges.

The company achieved this by leveraging the Java™ Business Integration (JBI) model of service units and service assemblies. Naturally, it faced challenges along the way: The session presents these and provides patterns for implementers of similar real-life projects. One example is how it measures and evaluates the coverage of business processes, based on the BPEL monitoring API. The session includes some impressive BPEL process and composite application (CASA) diagrams; performance test results; and, at the end, the code coverage evaluation.

The session covers

  • SOA in real life, enterprise-scale integration
  • Challenges and proposed patterns
  • Using and extending open-source JBI

TS-5173 Resource-Oriented Architecture (ROA) and REST

Google quietly deprecated its SOAP search API at the end of 2006. Although this doesn't mean that you should abandon SOAP, it does reflect a growing trend toward simpler dialects of Web services. Google joins several popular Web sites (Yahoo!, Amazon, eBay, and others) that offer all the benefits of Web services without all of the complexity of SOAP.

This session looks at the semantic differences between a service-oriented architecture and a resource-oriented architecture. It contrasts RPC-centric interfaces with object-oriented interfaces. It discusses HTTP-RPC services that call themselves RESTful and compares them with fully RESTful Web services that leverage HTTP verbs such as GET, POST, PUT, and DELETE. And it looks at RESTful implementations using Java™ Servlet APIs and exploiting Grails' native REST support. TS-5341 Rethinking the ESB: Lessons Learned from Challenging the Limitations and Pitfalls Traditionally, commercial integration and enterprise service bus (ESB) platforms have a reputation of being

  • Big, heavy, and expensive
  • Difficult to install
  • Difficult to set up
  • Complicated to learn and use
  • A haven for lock-in

Over the last few years, a new breed of open-source, lightweight ESB contenders such as Mule, ServiceMix, and OpenESB has attempted to redefine what a productive ESB offering should look like. Although the current generation of these platforms has made significant inroads into addressing these concerns, this session details and demonstrates how the next-generation platforms are pushing the envelope further and trying to achieve the feat of simplicity and productivity while becoming more versatile.

Attendees will learn

  • When using an ESB is appropriate
  • What properties to look for in an ESB and how to use it to avoid common limitations
  • How open-source offerings are innovating to become highly competitive service platforms
  • How these service platforms are adding distribution and topology choices to go beyond the traditional understanding of ESBs

For this session, a basic knowledge of SOA and Web services is desirable.

TS-6766 Real-World Processes with WS-BPEL

Most real-world business processes involve one or more interactions with partners, and they span a few hours to several days and have various outcomes. To implement these long-lived processes, a Web Services Business Process Execution Language (WS-BPEL) offering should support functional features such as correlation, dynamic addressing, and compensation. In addition, it should offer nonfunctional systemic quality features such as recovery, redelivery, throttling, and scalability.

Even though WS-BPEL is a powerful language for orchestrating Web services, it falls short for implementing real-world processes.

This session shows how to model a real-world long-lived process. It illustrates this with the open-source BPEL implementation in GlassFish ESB. It deep-dives into the aforementioned functional and nonfunctional features that are crucial in designing a long-running business process. And it also presents the challenges faced by GlassFish ESB users and the extensions Sun has added to support them, namely

  • Access to headers - SOAP( or protocol-specific) and security credentials (subject, principal, and credentials)
  • Attachments
  • Dynamic addressing
  • Extensions to assignment and XPath expressions

JSPWiki v2.4.100
« Home Index Changes Prefs
This particular version was published on 10-Apr-09 10:59 AM, -0700 by FrankKieviet