Not logged in | Login
Java One 2009
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
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.
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
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
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. PAN-5366 Cloud Computing: Show Me the Money Is cloud computing more of a myth than a reality? Is it old wine in new bottles and merely a glorified term for "the network is the computer"? What do "infrastructure as a service," "database as a service," "platform as a service," and "software as a service" really mean? What about the technologies and the monetization from a Java™ technology developer perspective?
In this session, a panel of experts from various companies that have cloud offerings attempts to tout the benefits of the respective technologies to Java technology developers, demystify the terminology associated with cloud computing, and discuss the challenges ahead. Each panelist gives a minimal presentation, followed by a "new and cool " demonstration.
After attending this panel, attendees will walk away with a good understanding of the differences in technologies of the different cloud offerings and what it means to them as Java technology developers.
A group of four or five panelists from among Amazon, Google, Intuit, Microsoft, salesforce.com, and Sun Microsystems is expected to participate.
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.
Apache Camel: http://activemq.apache.org/camel/ Project Fuji: https://fuji.dev.java.net/
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.
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
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.
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