BEA WebLogic Server® 10 - IT World Canada

BEA White PaperBEA WebLogic Server ® 10The Rock-Solid Foundation for SOA

CopyrightCopyright © 1995–2007 BEA Systems, Inc. All Rights Reserved.Restricted Rights LegendThis software is protected by copyright, and may be protected by patent laws. No copying or other use of this softwareis permitted unless you have entered into a license agreement with BEA authorizing such use. This document isprotected by copyright and may not be copied photocopied, reproduced, translated, or reduced to any electronicmedium or machine readable form, in whole or in part, without prior consent, in writing, from BEA Systems, Inc.Information in this document is subject to change without notice and does not represent a commitment on the part ofBEA Systems. THE DOCUMENTATION IS PROVIDED “AS IS” WITHOUT WARRANTY OF ANY KIND INCLUDINGWITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.FURTHER, BEA SYSTEMS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY REPRESENTATIONS REGARDINGTHE USE, OR THE RESULTS OF THE USE, OF THE DOCUMENT IN TERMS OF CORRECTNESS, ACCURACY,RELIABILITY, OR OTHERWISE.Trademarks and Service MarksCopyright © 1995–2007 BEA Systems, Inc. All Rights Reserved. BEA, BEA AquaLogic, BEA eLink, BEA WebLogic,BEA WebLogic Portal, BEA WebLogic Server, Connectera, Compoze Software, Jolt, JoltBeans, JRockit, SteelThread,Think Liquid, Top End, Tuxedo, and WebLogic are registered trademarks of BEA Systems, Inc. BEA BlendedApplication Development, BEA Blended Development Model, BEA Blended Strategy, BEA Builder, BEA Guardian,BEA Manager, BEA MessageQ, BEA microServices Architecture, BEA SOA 360, BEA Workshop, BEA Workspace360, Signature Editor, Signature Engine, Signature Patterns, Support Patterns, Arch2Arch, Arch2Arch Advisor,Dev2Dev, Dev2Dev Dispatch, Exec2Exec, Exec2Exec Voice, IT2IT, IT2IT Insight, Business LiquidITy, and LiquidThinker are trademarks of BEA Systems, Inc. BEA Mission Critical Support, BEA Mission Critical Support Continuum,BEA SOA Self Assessment, and Fluid Framework are service marks of BEA Systems, Inc. All other company andproduct names may be the subject of intellectual property rights reserved by third parties. All other trademarks arethe property of their respective companies.CWP1547E0407-1A

BEA White Paper – BEA WebLogic Server 10IntroductionService-Oriented Architecture (SOA) has sparked an IT revolution. Deploying coherent packages of software functionalityas loosely coupled, coarse-grained services delivers dramatically improved application flexibility. Enterprisescan continuously adapt constellations of these services to keep IT capabilities aligned with business goals.BEA is the leader in helping enterprises realize the benefits of SOA with Java. According to both Gartner and IDC,the company leads in worldwide Java application server market share. 1 It also leads in developer satisfaction,according to the latest Evans Data Corporation Survey, 2 and in SPECjAppServer2004 benchmark performance. 3BEA has built this leadership on years of relentless SOA innovation.One of BEA’s latest innovations is the Java Platform, Enterprise Edition (Java EE) 5. This standard deliversradical improvements in both business logic and object persistence. Enterprise JavaBean (EJB) 3.0 simplifiesthe programming of rich business logic, while the Java Persistence API (JPA) makes it easier to connect thislogic to the corresponding data of record. Enhancement to Web services and Web application stacks makescomposing useful applications from services easier than ever before. As a whole, Java EE 5 simplifies SOAdevelopment without sacrificing power.As shown in Figure 1, BEA played a crucial role in delivering the enhancements to Java EE 5, reviewingcustomer needs and identifying the need for simplification. BEA then made key contributions during developmentof the EJB 3.0 specification, and contributed to improvements in Web services processing throughmechanisms such as the Streaming API for XML (StAX). Most important, BEA was the first commercial vendorto deliver a production-ready implementation of Java EE 5.Figure 1Applet ContainerWeb ContainerEJB ContainerNew developer productivity tools inJava EE5.AppletHTTPSSLJSPServletEJBHTTPSSLJ2SEJAX-RPCJAX-WSSAAJJAXRJACCWeb ServicesWS MetadataManagementJMSConnectorsJTAJava PersistenceStAXJSFJSTLJavaMailJAFJAX-RPCJAX-WSSAAJJAXRJACCWeb ServicesWS MetadataManagementJMSConnectorsJTAJava PersistenceStAXJavaMailJAFJ2SEJ2SEApplication ClientContainerApplicationClientJAX-RPCJAX-WSSAAJJAXRJMSWeb ServicesWS MetadataManagementJava PersistenceStAXDatabaseJ2SENew in Java EE 51. Gartner research note: “Market Share: AIM and Portal Software, Worldwide 2005,” June 2006IDC: Worldwide Application Server Software 2006–2010 Forecast and 2005 Vendor Shares, December 20062. Evans Data Corporation: Developers’ Choice Application Servers—2006 User Rankings, October 20063. SPEC and the benchmark SPECjAppServer are registered trademarks of the Standard Performance Evaluation Corp. (SPEC). Competitivenumbers shown reflect results published on spec.org as of March 25, 2007. For the latest SPECjAppServer2004 results, seespec.org/osg/jAppServer20041

BEA White Paper – BEA WebLogic Server 10BEA WebLogic Server 10 is this implementation—a solid foundation for SOA based on Java EE 5. As with allversions of BEA WebLogic Server, it is extremely easy to use right out of the box and delivers industrial-gradereliability, availability, scalability, and performance. Customers can rapidly upgrade existing services and managethem with powerful configuration, deployment, and management tools. They can also leverage integration withother products in the BEA AquaLogic ® , Tuxedo ® , and WebLogic ® families as well as their developers’ experiencewith Open Source technologies such as the Spring framework.Existing customers already value BEA’s commitment to supporting mission-critical SOA initiatives. The latestversion of BEA WebLogic Server offers even more from this proven platform: customers can build services morequickly, compose them more easily, and manage them more effectively. Organizations that want this industrialgradecapability have a clear choice of the most modern, robust, and powerful Java-based SOA platform.Better business logic for SOAIn SOA, different services can operate at different levels of abstraction. For enterprises, top-level services,which usually correspond closely to tasks in the business domain, might include “Check Credit Score” in theloan processing domain, “Provision Account” in the mobile telephony domain, and “Submit Invoice” in theaccounts receivable domain. Obviously, implementing such services requires some kind of software model forthe corresponding domain.The original goal of EJB was to provide the infrastructure for building rich domain models that could supportsophisticated business processes. Entity Beans manipulated data and implemented the behavior of domainentities such as “Loan Application,” “Customer,” and “Purchase Order.” A portfolio of Session Beans coordinatedthe interactions of entities to execute each domain’s processes—for example, “Evaluate Loan,” “Enroll Customer,”and “Pay Suppliers.”In many cases, earlier versions of EJB proved too complex to support this approach. The API exposed too manyof the mechanisms necessary to ensure the robust execution of domain processes. Building effective domainmodels typically requires many trips through a cycle of prototyping, testing, and refinement. Forcing developersto worry about the underlying “plumbing” during this cycle made EJBs too cumbersome for many projects.In contrast, EJB 3.0 completely insulates developers from the plumbing; in large part, EJBs can be treated asregular Java objects, dramatically simplifying development. With this streamlined approach, developers canfinally use EJB to implement a wide variety of domain models that support top-level enterprise services.2

BEA White Paper – BEA WebLogic Server 10EJB 3.0 eliminates choresThe changes in EJB 3.0 primarily affect how developers interact with container facilities. (With the exception ofpersistence, these changes do not significantly affect the facilities themselves.)In previous versions of EJB, developers had to perform some onerous chores in order to interact with thecontainer. The first big chore was implementing all necessary interfaces, which required creating home, local,and remote interfaces as well as implementing the interface corresponding to the type of EJB. For the homeand remote interfaces, a developer needed to handle all necessary exceptions. Entity Beans also required findermethods. The final step was implementing all life cycle methods for the applicable EJB interface.The second big chore was writing JNDI lookups to acquire resource references. Rich domain models naturallyhave a lot of relationships among their elements. Each relationship, as well as any reference to infrastructureresources, required lookup code.EJB 3.0 eliminates both of these chores. Developers write EJBs as plain old Java objects (POJOs). They interactwith container facilities by adding simple, declarative annotations to the POJO code. The container takescare of the necessary chores; developers can focus on building domain models.Figure 2BEA WebLogic Server 10administration console.3

BEA White Paper – BEA WebLogic Server 10Annotations do the workAs mentioned above, annotations are the key innovation that improves the developer experience of EJB 3.0.BEA helped pioneer annotations and has worked to broaden their use within Java EE. If a developer canunambiguously specify what is to be done, why not just take care of it automatically? For example, suppose adeveloper working in the loan processing domain wants to write a client for a stateless session bean thatperforms loan processing. Instead of all the interface implementation and JNDI lookup code necessary withprevious version of EJB, the developer would simply write:import loanprocessor.LoanProcessor@Stateless public class LoanProcessorClient {@Inject LoanProcessor…}The @Stateless notation takes the place of manually defining the remote interface while the @Inject-annotation takes the place of a manual JNDI lookup.Java EE 5 includes corresponding annotations for other types of EJBs. In addition, instead of implementing lifecycle methods, developers can create new instances as with any other POJO. For Entity Beans, there are evenannotation for the common case of specifying an automatically generated identifier as the primary key and thenperforming lookups using this key. Beyond controlling EJBs, Java EE 5 also includes a variety of annotationsfor simplifying access to security, persistence, and Web services facilities.Simplified deployment descriptorsAs if the programming chores associated with previous versions of EJB weren’t enough, developers also hadto contend with complicated deployment descriptors. After doing the chores and writing the actual businesslogic, deploying and running an EJB required writing a deployment descriptor using XML. For Session Beans,the descriptor contained mostly redundant information such as the class, the names of associated interfaces,and the type of EJB. Then there were directives to infrastructure services such as transaction management andsecurity. For Entity Beans with Container Managed Persistence, the deployment descriptor might containdozens of entries specifying its abstract data schema and various queries against that schema.Most production implementations, such as BEA WebLogic Server, included tools for generating deploymentdescriptors and putting them in the correct location. But these became one more thing the developer had toworry about instead of the business problem at hand. In EJB 3.0, deployment descriptors are optional. Adeveloper can write and execute any type of EJB without a descriptor; the annotations and a set of defaultsprovide enough information to execute the EJB. Moreover, a developer who does want to specify a descriptorneeds specify only entries that override the defaults. In EJB 3.0, implementing a sophisticated service that usesa group of cooperating EJBs requires far fewer files, each with far fewer entries.4

BEA White Paper – BEA WebLogic Server 10BEA WebLogic Server 10 implements EJB 3.0 with PitchforkAs noted earlier, EJB 3.0 does not significantly change the facilities provided by EJB containers; it just makesthese facilities much easier to use. BEA WebLogic Server 10 implements EJB 3.0 as an extension to its provencontainer, one that provides the intelligence necessary to run more streamlined EJBs by translating annotationsinto specific instructions and resolving declaratively specified dependencies.To create this extension, BEA worked with the developers of the Open Source Spring Framework to create aspecial version of Spring, called Pitchfork. (Spring is a popular framework that helped pioneer simplification ofJava application development through the use of dependency injection.) Adding Pitchfork to the BEA WebLogicServer 10 EJB container creates a best-of-breed solution—a proven industrial-grade container and a provenproductivity-enhancing framework.Two side-effects of this approach are backwards compatibility and forward thinking. Because Pitchfork acts asa broker between EJB 3.0 code and traditional container facilities, BEA WebLogic Server 10 is fully backwardscompatiblewith EJB 2.1; EJBs simply bypass Pitchfork and use container facilities directly. Moreover, customerscan run 3.0 EJBs and 2.1 EJBs side by side. In addition to backwards compatibility, Pitchfork facilities forwardthinking. Many developers have adopted advanced programming approaches such as Aspect-OrientedProgramming using Spring. Pitchfork allows those same approaches with EJB 3.0.Streamlined persistance for SOABy shielding developers from complexity, EJB 3.0 allows them to focus on building representative domainmodels. Persistence is the next challenge. Executing business processes requires manipulating the data ofrecord. The “Loan Application,” “Customer,” and “Purchase Order” entities mentioned previously as an exampleall have Java representations that execute in the EJB container. However, performing real work requires loadingand saving the corresponding representations stored in back-end databases, which ensure that there is onlyone “true” copy of each fine-grained unit of data and that different services manipulating the same units of datadon’t interfere with each other.In theory, a multi-tier approach such as SOA makes the application layer independent of the data layer. Inpractice, a large proportion of application layer code gets devoted to data management tasks. The fundamentalproblem rests in how the application layer adds value. Most services provide reasonably unique value within aparticular domain—they execute an assigned set of tasks within broader processes. This specificity requiresthem to manipulate business entity data in a particular way. Unsurprisingly, they want to arrange the requireddata in the most convenient form.Therefore, each service must map fine-grained units of back-end data to its coarser-grained entity models.Manually writing and debugging the mapping code is extremely time-consuming and error-prone. Automatedmapping approaches are not a panacea. They must trade off flexibility and complexity. Not enough flexibilitymeans that developers must manually write a lot of code to meet the requirements. Too much complexity anddevelopers feel like using the automated tool is equivalent to writing a lot of code. Finding the sweet spotrequired a large body of BEA field experience—based on this experience, BEA WebLogic Server 10 incorporatesBEA Kodo, which seamlessly integrates both JPA and Java Data Objects (JDO). Developers can choosethe optimal mechanism for particular domain models.5

BEA White Paper – BEA WebLogic Server 10Support for both JPA and JDOAs discussed previously, EJB 3.0 uses annotations to reduce coding of interface implementations and entriesin deployment descriptors. The latter advantage is most clear for Entity Beans with Container ManagedPersistence. Abstract coding plus verbose deployment descriptors made for cumbersome usage in EJB 2.1.Moreover, while EJB 2.1 made some effort to make its persistence facilities independent of database technology,it tended to make the typical case of using relational databases far more complicated than necessary.JPA addresses all these shortcomings. Developers simply provide code annotations instructing the container how toaccess the appropriate relational database data. An @Id annotation before a set of accessor methods defines theprimary key. There are even annotations for specifying composite keys. A @OneToMany annotation before a collectiondefinition defines a one-to-many relation. For many-to-many relationships, a @JoinTable notation provides themeans to set up a join table. More sophisticated annotations such as @Transaction and @NamedQueries includea large set of attributes for precisely controlling specialized interactions with relational databases.JPA does more than just simplifying persistence features from EJB 2.1. It also includes much-needed enhancements.Most important, developers no longer have to specify life cycle methods for Entity Beans. The containerautomatically provides an EntityManager object for controlling the life cycle of instances. JPA also enables Javaclasses to specify strategies for handling inheritance when mapping to the database. Compared to the EJBquery language from 2.1, the JPA query language includes several new features such as bulk operations, outerjoins, and subqueries. Together, the ease of use and functional enhancements give developers the ability toquickly implement persistence for most common SOA data access requirements.Despite JPA’s improvements, many developers will still want to use JDO. Because JPA focuses on relationaldatabase persistence, it adopts a very relational style. When working with advanced object-oriented models,JDO’s more object-oriented syntax may be attractive. In many cases, the choice will simply be a matter oftaste. With BEA WebLogic Server 10, developers can use Container Managed Persistence with JPA or BeanManagement Persistence with JDO. While JPA and JDO share much underlying functionality, each does havecapabilities the other lacks; BEA WebLogic Server 10 provides extensions to both APIs so they are functionallyequivalent. Developers don’t have to sacrifice capabilities when choosing one or the other.High-performance implementationBEA’s commitment to building high-value services with Java EE 5 goes beyond giving developers a choice ofpersistence API. It includes delivering high performance no matter which alternative a developer prefers. Asmentioned above, the same persistence engine executes both JPA and JDO functions. The Kodo enginecomes to BEA via its acquisition of SolarMetric, whose extensive list of enterprise customers prize this enginefor its performance and robustness.Kodo includes a long list of industrial-grade features. Perhaps the biggest challenge in providing persistence fortop-level business services is supporting large and long-running transactions. Completing a significant step in abusiness process can result in extensive updates to many different pieces of data. Kodo supports transactionsof unlimited size. Guaranteeing the coordination of complex business processes can require transactions thatremain in progress for minutes, hours, or even days. Kodo efficiently manages connections to data sourcesduring such long-running transactions.6

BEA White Paper – BEA WebLogic Server 10An advanced caching engine improves performance for services that access the same data repeatedly. Basedon extensive customer experience, Kodo provides a wide variety of caching configuration options to supportparticular data access patterns; administrators can optimize the cache for batch operations, tasks that affectmany instances of the same class, and processes tied to particular points in time. A data access profiler willactually make recommendations for tuning the configuration, so enterprises get performance and scalabilityalong with ease of use.Improved Web services processingEJB 3.0’s use of regular Java objects and Kodo’s combined support of JPA and JDO make it quick and easy fordevelopers to build rich domain models and connect them to back-end databases. Of course, these modelsmust then be made available as services within the larger business processes supported by the enterprise SOA.Seamless cooperation among all services requires a solid foundation for Web services protocol processing.There are two primary protocol processing issues. First, interoperability requires implementation of an entireprotocol stack and verified compatibility with stacks from different vendors. BEA WebLogic Server 10 includessupport for the latest security- and performance-oriented Web services protocols. In the security area,updates support WS-Security 1.1 and WS-SecurityPolicy 1.1 and 1.2. There is new support for WS-Trust andWS-SecureConversation, which enable services to establish a shared security context and maintain long-termtrusted relationships.In the performance area, there is new support for XML-Binary Optimized Packaging (XOP) and MessageTransmission Optimization Mechanism (MTOM). XOP lets services transmit binary data as is, without base 64encoding, and put it in the same MIME package as the rest of an XML document. This approach reduces bothrequired bandwidth and encoding overhead. MTOM describes how to use XOP to optimize the transmission ofSOAP messages. BEA has participated in several interoperability events to ensure that its implementations ofthese protocols, as well as others in the BEA WebLogic Server 10 stack, work well with those of other vendors.The second protocol processing issue is more subtle. The JAX-RPC processing API from past versions of JavaEE supports only the remote procedure call (RPC) style. Unfortunately, this is the least flexible of all Web servicesinteraction styles. Java EE 5 introduces a new processing API, JAX-WS, that supports the more flexibledocument-oriented style. BEA WebLogic Server 10 also provides basic support for a third style, RepresentationState Transfer (REST), that can simplify certain interactions. The processing infrastructure for multiple Webservices styles allows developers to tailor interactions within an SOA to meet different enterprise requirements.While not strictly a protocol processing issue, client-only Web services stacks are a practical issue for customerswho want to build lightweight applications that act only as consumers of services, without the burden of serverorientedfunctionality. BEA WebLogic Server 10 provides a special Java library that implements only the clientportions of the protocols defined in the WS-I Basic Profile.7

BEA White Paper – BEA WebLogic Server 10Industrial-grade SOA deployment and managementBy making it easier to write business services and their interfaces, Java EE 5 promotes a much richer SOAecology. Actually building up this ecology within enterprises requires keeping individual service instances andthe broader SOA environment healthy. An API specification alone cannot meet this requirement. Enterprisesneed an industrial-grade implementation—one with the deployment, management, and robustness required ofany mission-critical IT component.BEA WebLogic Server has proven its ability to operate in an enterprise environment; version 10 extends thissuccess to cover Java EE 5, so customers can manage all the new features from the familiar console, whilemaking it as easy as possible to upgrade existing services. Upgrading means simply redeploying an existingservice to the new platform—no porting necessary.Enterprises also face the challenge of upgrading clients to new versions of a service. Several features ease thisnatural consequence of a mature SOA. Multiple versions of the same services can run in the same server orcluster. Administrators can segment version access by client population—for example, making newer versionsavailable only to clients coming from local or internal network segments. Finally, administrators can declarativelyspecify the client migration policy.BEA WebLogic Server 10 addresses several other customer issues. Certain enterprise networks don’t supportmulticast; version 10 has unicast clustering. When running a cluster, migrating the JMS and JTA services fromone machine to another used to require several manual steps; version 10 has automatic service migration. Italso enables recording and scripting of console operations.As BEA WebLogic Server 10 becomes a standard part of the IT infrastructure, many enterprises want to monitorit as part of their SNMP consoles. Version 10 supports SNMP 3, including an SNMP view of JMX RuntimeMBeans. Moreover, the SNMP agent for the Admin Server now provides a view for the entire WebLogic domain.These improvements demonstrate BEA’s commitment to making SOA a benefit for the entire IT organization, notjust architects and developers.Figure 3BEA WebLogic Serverdiagnostic framework.9

BEA White Paper – BEA AquaLogic Data Services Platform PerformanceConclusionJava EE 5 dramatically speeds development of SOA applications. EJB 3.0 simplifies business logic by enablingdevelopers to focus more on the domain model and less on the middleware plumbing. JPA simplifies the mostcommon persistence management tasks associated with mapping domain objects to back-end relational databases.The Web interface APIs enable richer and more flexible user interaction with SOAs, while JAX-WSenables richer and more flexible cooperation among services in an SOA.BEA WebLogic Server 10 is one of the first production-ready implementations of Java EE 5. It not only adheresto the letter of the standard but embraces its spirit—simplicity without sacrifice. It delivers EJB 3.0 by integratingSpring’s Pitchfork into the existing container. Developers get the advantage of a simplified API without giving upany of the proven infrastructure at the foundation of BEA WebLogic Server. Kodo enables developers to use thestraightforward JPA persistent mechanisms where appropriate, as well as the more flexible JDO features wherenecessary. Helping customers make their businesses run better is the ultimate goal, and BEA WebLogic Server10 delivers Java EE 5 capabilities in the way that best supports it.BEA WebLogic Server is the Java EE platform with the most popularity, productivity, and performance. Now itis one of the first to put the power of a production-ready Java EE 5 implementation in the hands of enterprisedevelopers. Existing customers can take immediate advantage of the improved APIs, while new customers getthe confidence of alignment with a proven leader.About BEABEA Systems, Inc. (Nasdaq: BEAS) is a world leader in enterprise infrastructure software. The BEA SOA 360 TMplatform, the industry’s most unified SOA platform for business transformation and optimization, is designed toimprove cost structures and grow new revenue streams. Information about how BEA is enabling customers toachieve Business LiquidITy TM can be found at bea.com.Join the BEA communityAt BEA, we understand that developers need different kinds of resources than IT managers. And that architectsface different challenges than executives. That’s why we’ve created four unique communities that give youexclusive access to a formidable group of your peers, to a world of shared thinking, and to the kind of meaningfulinformation that can make you more effective and more competitive. To join one or more of the BEAcommunities, simply register online at bea.com/register.10

BEA Systems, Inc.2315 North First StreetSan Jose, CA 95131+1.800.817.4232+1.408.570.8000bea.comCWP1547E0407-1A