book

BEA® WebLogic Platform 7

Name: BEA® WebLogic Platform 7
ISBN: 0789727129

by Jatinder Prem, Bernard Ciconte, Peter Go, Scott Dunbar, Manish Devgan

August 2003

Intermediate to advanced

1464 pages

32h 2m

English

Sams

Read now

Unlock full access

Copyright
Dedication
About the Author
About the Co-Authors
Acknowledgments
We Want to Hear from You!
Introduction
About This BookWho Should Read This Book?How This Book Is OrganizedPart I: J2EE Application Development EssentialsPart II: Introducing the BEA WebLogic Platform 7Part III: WebLogic and J2EE Services SupportPart IV: Developing Presentation Logic—JSPs and ServletsPart V: Developing Business Logic—Enterprise JavaBeansPart VI: BEA WebLogic Server AdministrationPart VII: Web ServicesPart VIII: Integration Services Provided by WebLogic Server 7Case Study: A Sample End-to-End Example Using The WebLogic PlatformSource Code for This Book
I. J2EE Application Development Essentials
1. Understanding the Java 2 Platform, Enterprise Edition
OverviewJava Technology TodayThe Challenges of Today’s eSystemsThe Java 2 Platform, Enterprise EditionThe J2EE Platform—Technology Component and Service APIsJava Servlet Technology 2.3JavaServer Pages Technology 1.2Enterprise JavaBeans Technology 2.0JDBC 2.0 APIJava Message Service 1.0Java Transaction API 1.0JavaMail Technology 1.2JavaBeans Activation Framework 1.0J2EE Java Connector Architecture API 1.0Java Naming and Directory Services APIJava API for XML 1.1Java Authentication and Authorization Service 1.0J2EE Application Programming ModelThe Benefits of J2EE ComponentsMulti-Tiered ArchitectureJ2EE Compatibility Test SuiteJ2EE Reference Implementation (RI)J2EE Application Development RolesPresentation Content DevelopersWeb Component DevelopersBusiness Component DevelopersEIS IntegratorsJ2EE Application Deployment RolesJ2EE Product ProviderJ2EE Tool ProviderApplication Component ProviderApplication AssemblerApplication DeployerSystem Administrator
2. J2EE Software Development Methodologies
(Not) Gaining a Competitive Edge in Internet TimeWhy J2EE Projects FailRecognizing Mission Impossible ProjectsLack of Executive SponsorshipLack of User Involvement in the ProjectThe Initial Project Objectives Are WrongChanging Project Requirements and Specifications—“Scope Creep”Lack of or Excessive PlanningLack of IT Management and Technical DirectionObject-Oriented Analysis, Design, and Development IlliteracyThe Warning Signs of a Failing J2EE ProjectMissed MilestonesMiscommunicationToo Many Decision MakersThe Top Ten Checklist for Initiating J2EE ProjectsOrganizational Frameworks for Supporting Enterprise J2EE ProjectsCommunities of PracticeNon-Technical (End-User) CommunitiesTechnical CommunitiesTechnical Centers of Excellence—The J2EE Architecture GroupJ2EE Architectural Guidance to IT ProjectsSoftware Development MethodologiesWhat Is an Object-Oriented (OO) Methodology?Major Motivations for Using OO Methodologies in J2EE System DevelopmentsObject-Oriented Approaches Produce Solutions Which Closely Resemble Their Problem DomainsObject-Oriented Approaches Promote OO ThinkingObjects and Components Are “Black Boxes”AbstractionEncapsulationConcurrencyObject-Oriented Approaches Promote ReusabilityObject-Oriented Approaches Support InteroperabilityObject-Oriented Approaches Possess Traceability CapabilitiesThe Challenges of Using OO Methodologies—“Object Blindness”The Traditional Waterfall MethodologyFeedback Failure Between the PhasesRequirements, Analysis, and Design MilestonesJ2EE Software Development Methodologies UnveiledSelecting a Software Development MethodologyBEA Systems Accelerated Process (Project Initiation Phase)The Participators of the Accelerated ProcessAccelerated Project InitiationAccelerated Requirements MethodAccelerated Technical Feasibility AssessmentCustomer Validation MeetingAccelerated Risk Reduction PlanningRisk Validation MeetingAccelerated Project PlanningRefactoring the Project Plan into Binary DeliverablesIterative and Incremental Software Development PracticesContinuous Project Control Through FeedbackRealistic Deadlines on MilestonesProject Commitment MeetingBEA Systems SteelThread (Architectural Prototyping)SteelThread PrerequisiteseXtreme ProgrammingThe 12 Core Practices of eXtreme ProgrammingThe Planning GameInitial Release PlanningIteration PlanningSmall ReleasesCustomer Tests (Acceptance Testing)Simple DesignPair ProgrammingTest-First Development (Unit Testing)Design Improvement (Refactoring)Continuous IntegrationCollective Code OwnershipCoding StandardMetaphorsSustainable PaceeXtreme Programming ResourcesThe Rational Unified ProcessThe Rational Unified Process ProductThe Principles of the Rational Unified ProcessThe Organization of the Unified ProcessThe Phases of a Rational Unified ProcessInceptionElaborationConstruction PhaseTransition PhaseThe Process Workflows of a Rational Unified ProcessRational Unified Process Resources
3. A Developer’s Guide to the Unified Modeling Language (UML)
The Challenge of Object-Oriented Analysis and DesignWhat Is the Unified Modeling Language?The Relationship Between UML and Software Development MethodologiesUML Modeling ToolsThe Elements of the Unified Modeling LanguageThe Structural Elements of UMLThe Behavioral Elements of UMLThe Grouping Elements of UMLThe Annotational Elements of UMLDeveloping Use Case Diagrams (Analysis Phase)The Features of a Use Case DiagramLinking UML DiagramsDeveloping Class Diagrams (Analysis)The Features of a Conceptual ModelDeveloping Class Diagrams (Design)The Features of a Class DiagramAssociation RelationshipsGeneralization RelationshipsDeveloping Interaction Diagrams (Design)The Features of a Sequence DiagramDeveloping Statechart Diagrams (Design)The Features of a Statechart diagramDeveloping Activity Diagrams (Analysis and Design)The Features of an Activity DiagramDeveloping Component and Deployment Diagrams (Design)Component DiagramsDeployment DiagramsUML By Example—The Book StoreDeriving the Book Store Use Case DiagramDeriving the Book Store Activity DiagramDeriving the Book Store Class DiagramDeriving the Book Store Interaction Diagrams

4. Best Practices for Java Development
Project StandardsDelivery ExpectationsJava-Oriented Software ProductsSource Code Control and Software Build SystemsDirectory Structures and Environment VariablesThe Runtime Environment for Java Software DevelopmentJava Namespaces and Directory StructureJava Style GuidelinesNaming rulesFormattingComments and DocumentationUsing Javadoc CommentsJava Source File LayoutJava Programming GuidelinesGeneral Coding PracticesPerformance and Optimization GuidelinesCollectionsSynchronizationMemory AllocationStorage EfficiencyMethodsObjectsArraysLoopsStringsString Are ImmutableCreating a String Using LiteralsPre-Allocate Your String BuffersSwitch Statements for StringsSynchronizationSerializationGarbage CollectionJava Compiler and JVM OptimizationsThe Java Development ProcessIntroduction to Incremental DevelopmentPreparing for Java DevelopmentCreating the Common ComponentsWhat the Developer Should Do FirstApplication DevelopmentGetting StartedThe Design-Coding-Testing-Delivery CycleProgram DesignPhilosophyDesign Versus CodingCodingWrite the Code Correctly the First TimeUse ExamplesRefactoringCoding PracticeTestingDeliveryReferenceEndnotes
5. The J2EE Architecture and APIs
Understanding the Java 2 Platform, Enterprise EditionThe Logical Tiers of the J2EE ArchitectureThe J2EE Application Programming ModelThe J2EE Application Server LayerThe Operating System LayerJava Virtual Machine (JVM) LayerThe J2EE Application Server Execution EnvironmentThe J2EE Services LayerThe Remote Method Invocation (RMI) ServiceWhere Is RMI Used in J2EE?How Is RMI Used in J2EE?The Details of an RMI Method CallThe Java Naming and Directory Interface (JNDI) APIWhere Is JNDI Used in J2EE?How Is JNDI Used in J2EE?The Java Database Connection (JDBC) APIWhere Is JDBC Used in J2EE?How Is JDBC Used in J2EE?The Java Transaction (JTA) APIWhere Are Transactions Used in J2EE?The Java Messaging Service (JMS)Where JMS Is Used in J2EE?How JMS Is Used in J2EE?J2EE SecurityThe JavaMail APIJava Connector Architecture (J2C)How Connectors Are Used in J2EEThe EJB ContainerEnterprise JavaBeans (EJB)Session BeansThe Session Bean ClassEntity BeansBean-Managed Persistence (BMP)Container-Managed Persistence (CMP)The Entity Bean ClassMessage-Driven Beans (MDB)The Message-Driven Bean ClassThe Web ContainerServletsServlet Session ManagementServlet Context InformationServlet LifecycleServlet Request FilteringServlet Dispatch ControlServlet SecurityServlets and Persistent Client Information (Cookies)Invoking Servlets Through URL Query StringsDeclaring and Configuring ServletsJavaServer Pages (JSP)JavaServer Page Request ProcessingThe JSP Language Syntax
6. Transitioning from Software Design to J2EE Technology Components and Services
Specifying and Visualizing J2EE Components with UMLThe Need for J2EE Software DesignAnalyzing Requirements for a J2EE Solution with UMLIdentifying and Applying Design PatternsThe Model-View-Controller Architecture (MVC)The Gang of Four Design PatternsDesigning for Enterprise Java BeansStateful and Stateless Session BeansContainer Managed Persistence (CMP) and Bean Managed Persistence (BMP) Entity BeansJ2EE Deployment to WebLogic Server 7.0From Design to J2EE By Example: A Truck Rental BusinessTruck Rental Business RequirementsTruck Rental Use CasesUse Case 1: Edit RequestUse Case 2: Search for VehicleUse Case 3: View Search ResultsUse Case 4: Update InventoryTruck Rental Activity DiagramsTruck Rental Class DiagramsTruck Rental Sequence DiagramsTruck Rental Java ImplementationSummary
7. An Introduction to Web Services
The Message and Medium ParadigmWhat Is a Web Service?The Characteristics of Web ServicesWeb Services Standard ProtocolsSimple Object Access Protocol (SOAP)The Web Services Description Language (WSDL)Universal Discovery Description and IntegrationA Service-Oriented Architecture of Web ServicesThe Value Proposition of Web Services
II. Introducing the BEA WebLogic Platform 7
8. Deriving Application Infrastructure
Introducing Application InfrastructureUnderstanding the Need for Application InfrastructureExamining an Organization’s Application Infrastructure RealityDeriving an Application Infrastructure StrategyRecognizing Infrastructure PatternsCataloging Organizational Infrastructure PatternsThe Advantages of Cataloging Infrastructure PatternsDeveloping a Technology TaxonomyIdentifying Enterprise Application Integration (EAI) TypesImplementing the Software Platform Solution to Application InfrastructureEmploying BEA’s Unified, Simplified, and Extensible Formula for Application Infrastructure: WebLogic Platform 7.0Summary
9. Introducing BEA WebLogic Platform 7
What Is Technical Agility?The WebLogic Platform—A Single, Unified, and Extensible Application InfrastructureThe Featured Benefits of WebLogic PlatformIntroducing BEA WebLogic Server 7WebLogic Server’s Competitive EdgeThe Technical Architecture of WebLogic ServerThe Presentation LayerThe Business LayerThe Integration LayerDatabase ConnectivityJ2EE Connector ArchitectureInteroperability with Microsoft Software ComponentsBEA Tuxedo InteroperabilityEnterprise MessagingWeb ServicesInteroperability with MainframesIntroducing WebLogic WorkshopThe Primary WebLogic Workshop ComponentsA High-Level Architecture of WebLogic WorkshopIntroducing BEA WebLogic PortalA High-Level Architecture of WebLogic PortalPersonalization ServicesPortal ServicesCommerce ServicesThe EBusiness Control Center (EBCC)Introducing WebLogic IntegrationWLI Functional AreasSummary
10. Installing and Configuring WebLogic Server 7
WebLogic Server 7 EditionsThe WebLogic ExpressThe WebLogic Server Advantage EditionThe WebLogic Server Premium EditionPreliminary WebLogic Server Installation ConsiderationsSystem and Software Requirements for Installing WebLogic ServerThe New WebLogic Server Development Licensing ModelInstalling WebLogic ServerStep 1: Download and Execute the Net Installer ProgramStep 2: Select the BEA Home DirectoryStep 3: Select the Installation TypeStep 4: Select the WebLogic Platform Products and ComponentsStep 5: Select the Download OptionStep 6: The Auto Installation OptionStep 7: Select the WebLogic Server Product DirectoryStep 8: The Domain Configuration WizardStep 9: Create Your WebLogic DomainStep 10: Select the WebLogic Server TypeStep 11: Select Your Domain Container DirectoryStep 12: Configure Your Single ServerStep 13: Create Your System User Name and PasswordStep 14: Create the WebLogic Server As a Windows ServiceStep 14: Create a Start Menu Entry for Your WebLogic ServerStep 15: Review and Create Your Specified WebLogic Server ConfigurationValidate Your CLASSPATH and PATH Environmental VariablesNavigating the WebLogic Platform Directory StructureThe BEA Home DirectoryThe Domain Container DirectoryThe WebLogic Home DirectoryStartup Methods for WebLogic Server in Windows 2000The startWebLogic Script FileImportant startWebLogic Script OptionsDweblogic.management.discoverDweblogic.ProductionModeEnabled-Xms and -XmxStarting the Default WebLogic ServerBypassing the Username and Password Prompt Using the Boot Identity FileStarting the Pet Store Sample ApplicationShutdown Methods for WebLogic Server in Windows 2000Shutting Down WebLogic Server Using the Administration ConsoleShutting Down WebLogic Server Using the weblogic.Admin UtilityUnderstanding the New WebLogic Server Lifecycle StatesUsing WebLogic Server with the WebLogic JRockit JVMThe Benefits of Using the JRockit JVMInstalling and Using JRockit with WebLogic ServerUsing the JRockit Management ConsoleSummary
11. Working with the WebLogic Server Tools
The WebLogic Server System Administration ToolsThe WebLogic Administration ConsoleStarting the Administration ConsoleNavigating the Administration ConsoleA Simple Example of Using the Administration ConsoleThe weblogic.Admin Command-Line UtilityThe weblogic.Admin Utility CommandsPINGThe WebLogic Server Deployment ToolsThe WebLogic BuilderThe EJBGen UtilityThe weblogic.Deployer UtilityThe WebLogic Server Administration ConsoleDeploying Your First Web Application Using WebLogic BuilderStep 1: Creating the Web Application Directory StructureStep 2: Creating Your Welcome PageStep 3: Creating and Compiling Your Hello World ServletStep 4: Starting the WebLogic BuilderStep 5: Assembling the HelloWorldApp Web ApplicationStep 6: Deploying Your Web ApplicationStep 7: Testing Your Web ApplicationSummary
III. WebLogic and J2EE Services Support
12. Distributed Processing Using RMI
Understanding Distributed ProcessingThe RMI Design ModelRMI Package NamesCreating an RMI ApplicationRMI Registry Naming ServiceRMI Registry APIJava 2 Standard Edition RMI RegistryWebLogic RMI RegistryThe Remote InterfaceJava 2 Standard Edition Remote InterfaceWebLogic Remote InterfaceRemote ObjectJava 2 Standard Edition Remote ObjectWebLogic Remote ObjectRMI Client ApplicationGenerating Stubs and Skeletons Using rmicJava 2 Standard Edition rmicWebLogic rmicSample RMI ApplicationWebLogic Optimizations for RMIWebLogic RMI over IIOPSummary
13. Accessing Data Repositories Using JDBC
The Java Database Connectivity APIThe Basics of Database Programming in JavaUnderstanding Relational DatabasesDesigning the Data ModelUnderstanding SQLSQL DatatypesSQL CommandsSQL TransactionsUnderstanding JDBCUsing the DriverManagerJDBC Drivers from BEA WebLogicThird-Party Drivers for WebLogic ServerThe Connection ObjectThe Statement ObjectThe PreparedStatement ObjectThe ResultSet ObjectWorking with BLOB and CLOB Data TypesThe Bookstore JDBC ExampleJDBC and BEA WebLogic ServerConfiguring and Using Connection PoolsConfiguring and Using MultiPoolsConfiguring and Using Data SourcesConfiguring and Using TxDataSourcesConfiguring and Using JDBC DataSource FactoriesUsing JDBC in a BMP Entity BeanAdvanced JDBC TopicsStored ProceduresBatch ProcessingMeta-DataSummary
14. Locating Named Services through JNDI
An Introduction to the Java Naming and Directory InterfaceThe JNDI Architectural FrameworkUnderstanding Naming and Directory ServicesLDAP ServerRMI RegistryCOS Name ServerThe WebLogic Naming ServiceThe Structure of the WebLogic Naming Service—The JNDI TreeUsing JNDI in a WebLogic Server ClusterThe JNDI Service Provider InterfaceUsing the LDAP SPILDAP Security ConsiderationsUsing the RMI SPIRMI Security ConsiderationsUsing the COS SPICOS Security ConsiderationsUsing the WebLogic SPIWebLogic Security ConsiderationsCreating the Context Environment for WebLogicThe JNDI Application Programming InterfaceLooking Up an Object Using the JNDI ContextClosing the JNDI ContextBinding an Object Using the JNDI ContextExamples of Using JNDI in J2EE ApplicationsLooking Up the EJB Home InterfaceLooking Up JMS Connection Factories and Distributed DestinationsLooking Up JDBC DataSourcesLooking Up JTA UserTransactionsSummary
15. The Java Messaging Service (JMS)
What Is the Java Message Service API?JMS Messaging Versus Tightly Coupled Communication APIsAn Overview of the JMS Architecture and MessagingMessaging DomainsThe Point-to-Point Messaging DomainThe Publish/Subscribe Messaging DomainMessaging Consumption and DeliveryMessaging Domain InterfacesThe Structure of a JMS MessageMessage Header FieldsMessage Property Fields (Optional)Message BodyThe JMS API Programming ModelConnectionFactoryConnectionsSessionsDestinationsMessageProducerMessageConsumerThe WebLogic JMS ServerThe Basic Configuration of WebLogic JMSConfiguring Persistent MessagingConfiguring a JMS ServerCreating a JMS Destination—Queue or a TopicUsing JMS TemplatesConfiguring JMS Server and Destination ThresholdsImplementing Messaging Service Continuity with Distributed DestinationsConfiguring Connection FactoriesMonitoring Your JMS ServerDeveloping a WebLogic JMS ApplicationPoint-to-Point ClientA Point-to-Point ProducerA Point-to-Point ConsumerA Point-to-Point Client with an Asynchronous ListenerA Publish/Subscribe ProducerA Publish/Subscribe ConsumerMessage SelectorsSummary
16. Managing Java Transactions Using JTA
The Java Transaction APIUsing Transactions to Ensure Data IntegrityUnderstanding Distributed TransactionsACID-Compliant DatabasesThe JDBC Optional Package and JTAUsing the DataSource InterfaceUsing Connection PoolsUsing a DataSource for Distributed TransactionsUsing the RowSet InterfaceUsing the UserTransaction InterfaceConfiguring WebLogic JDBC Connection PoolsConfiguring WebLogic JDBC Tx DataSourcesPerforming Distributed Transactions with a Transaction ManagerXA-Compliant ResourcesTwo-Phase Commit (2PC)Transaction Isolation LevelsUsing the WebLogic JTA DriverThe BookStore Servlet ExampleSummary
IV. Developing Presentation Logic—JSPs and Servlets
17. Introduction to Servlets
CGI—The First Generation of Dynamic Content Generation ToolsA Better Way—ServletsWhat Is a Servlet?Handling HTTP Clients—The HttpServlet ClassServlet TechnologiesThe Servlet API—Commonly Used MethodsThe Servlet ContainerThe Servlet LifecycleServlets and ThreadsCreating Your First ServletA doGet() Servlet ExampleAdding doPost() to the ServletJ2EE Packaging for Servlets—Web ApplicationsWeb Application HierarchyRunning Your First Servlet in WebLogic 7.0Servlet Advanced FeaturesInitialization Parameters for ServletsDatabase Access Using WebLogic Server 7.0 ServicesUsing WebLogic 7.0 Connection PoolsUsing a DataSource for Database ConnectionsServlet Implementation LimitationsSummary
18. JavaServer Pages and Tag Libraries
Understanding JavaServer Pages (JSPs)JSP ElementsPredefined VariablesExpressionsDeclarationsScriptletsOther Scripting ElementsUsing JavaBeansInstantiating JavaBeans in JSPManipulating JavaBean Properties in a JSPSetting Bean Properties from the RequestCreating the JavaBean ClassJavaBean ExampleTag LibrariesParts of a Tag LibraryImplementing a Custom Tag LibraryUsing the Custom Tag in a JSPPutting It All Together: Using the Tag Library in WebLogicSummary
19. Servlets and JavaServer Pages—Best Practices
What Is the MVC Pattern?The MVC Model with Servlets and JSPsA Simple MVC Example: Login ManagementJSP Login HandlerServlet Login HandlerServlet Login Handler with a JSP Front EndImplementing the ModelThe EJB-to-JSP Integration ToolManaging Page-to-Page Relationships and TransitionsSummary
V. Developing Business Logic—Enterprise JavaBeans
20. Developing Business Logic—Session Beans
Introducing Session BeansThe Value Proposition of Session BeansSession Bean TypesStateless Session BeansWhen to Use Stateless Session BeansStateful Session BeansWhen to Use Stateful Session BeansDifferences Between Stateless and Stateful Session BeansA Practitioner’s Approach to Understanding Session BeansThe Development Elements of a Session BeanThe Remote InterfaceThe Home InterfaceThe Implementation ClassThe Stubs and Skeletons of Session Bean InterfacesUsing a Local View to Access a Session BeanDeveloping a Test Java Client for Your Session BeanDeveloping Deployment DescriptorsThe ejb-jar.xml FileThe weblogic-ejb-jar.xml FileBuilding a Session Bean Deployment UnitDeploying Your Session BeanThe Life Cycle of Stateless Session BeansThe Does Not Exist StateThe Method Ready Pool StateThe Busy or Active StateThe Life Cycle of Stateful Session BeansThe Does Not Exist StateThe Method Ready StateThe Passivated StateTesting the Life Cycle of Stateful Session BeansProgramming Transactions in Session BeansContainer-Managed TransactionsBean-Managed TransactionsSummary
21. Managing Persistence—Entity Beans
Persistence: The Final TierWhat Are Entity Beans?Using the EJB ContainerContainer-Managed Persistence Versus Bean-Managed PersistenceContainer-Managed RelationshipsContainer-Managed TransactionsRolling Back Container-Managed TransactionsThe Lifecycle of Entity BeansDeveloping the Components of Entity EJBsEJB Remote InterfaceEJB Local InterfaceUsing the EJB Value ObjectEJB Remote Home InterfaceEJB Local Home InterfaceWriting the Entity EJB ClassWriting the Primary Key ClassCreating the BookEntityPK Primary Key ClassDeployment DescriptorsEJB Name TagAdditional XML Tags in the Deployment DescriptorEJB Home Interface TagEJB Remote Interface TagEJB Class TagPersistence Type TagCMP Field TagsEJB Primary Key FieldQuery TagWriting Finder MethodsEnterprise JavaBean Query LanguageBean-Managed Persistence ExampleCreating a Connection with a Data SourceCreating the BookEntityBMPBeanCreating the BMP Style Deployment DescriptorContainer-Managed Persistence ExampleCreating the BookEntityCMPBeanContainer-Managed Relationship ExampleCreating the ShoppingCart Remote InterfaceCreating the ShoppingCart Home InterfaceCreating the ShoppingCart CMP Entity BeanThe ShoppingCart Primary KeyTesting the Book StoreCreating the Deployment DescriptorDeployment on WebLogic ServerThe weblogic-ejb-jar.xml Deployment DescriptorThe weblogic-cmp-rdbms-jar.xml Persistence DescriptorDeploying Entity Beans to WebLogic ServerStep 1: Start and Configure Your Target DatabaseStep 2: Configure the JDBC Connection Pools Tx DataSource in Your WebLogic ServerStep 3: Deploying the ShoppingCart EJB Example to Your WebLogic ServerTesting the Deployment of the ShoppingCart ModuleSummary
22. Asynchronous Message Processing—Message-Driven Beans
What Is a Message-Driven Bean?The Characteristics of Message-Driven BeansThe Value Proposition of Message-Driven BeansDifferences Between MDBs and Other Bean TypesThe Message-Driven Bean ClassThe ejbCreate() MethodThe setMessageDrivenContext() MethodThe onMessage() MethodThe ejbRemove() MethodHandling ExceptionsThe Life Cycle of a Message-Driven BeanDeveloping a Simple Message-Driven Bean ExampleStep 1: Writing the Message-Driven Bean CodeStep 2: Writing the Associated Deployment DescriptorsThe ejb-jar.xml Deployment DescriptorThe weblogic-ejb-jar.xml Deployment DescriptorStep 3: Building Your MDB ExampleStep 4: Configuring the JMS Destination for the MDB ExampleStep 5: Deploying the MDB Example to Your WebLogic ServerStep 6: Testing Your Message-Driven BeanAn Overview of Message-Driven Bean TransactionsSpecifying an MDB’s Transaction Demarcation TypeContainer-Managed TransactionsAvoiding Poison Messages with Container-Managed MDBsBean-Managed TransactionsSummary
23. EJB Best Practices
Best Practices for Session BeansOptimizing JNDI LookupsWhen Not to Use Stateful Session BeansScalability Issues with Stateful Session BeansThe SessionSynchronization InterfaceSession Beans As a Facade to Entity BeansBest Practices for Entity BeansConsider Writing CMP Entity Beans Instead of BMP Entity BeansDebug Flags to Instrument BMP CodeWriting an Efficient Primary Key ClassImplementing the hashCode MethodImplementing the equals() MethodChoose the Right Concurrency StrategyOptimize Database Access CallsLoading Related CMP FieldsOptimizing FindersOptimizing CMP Entity BeansOptimizing BMP Entity BeansOptimizing Database Writes for BMP Entity BeansConsider Using Tuned Updates for CMP 1.1 BeansConsider Using Read-Only/Read-Mostly Entity BeansHandling Transactions in EJBsUse Container Managed Transactions Instead of Bean Managed TransactionsDo Not Use the Supports Transaction AttributeConsider Using the Mandatory Transaction AttributeConsider Using Transactional DataSources for Entity BeansAlways Demarcate Transactions at the WLS or Database LevelBest Practices for EJB SecurityBest Practices for Coding Standard InterfacesMDB Best PracticesException Handling in MDBsConsider Using a Separate JMS Destination to Handle Poison MessagesConsider Using DUPS_OK_ACKNOWLEDGE ModeSummary
VI. BEA WebLogic Server Administration
24. Administering and Monitoring Your WebLogic Domain
Understanding WebLogic DomainsThe Relationship Between Administration and Managed ServersAdministering a WebLogic Domain from an Infrastructure PerspectiveCreating and Extending WebLogic DomainsCreating a WebLogic Domain and Standalone WebLogic Server Using the Configuration WizardExtending a WebLogic Domain with a Remote Managed Server Using the Configuration WizardConfiguring a New Machine Definition within a WebLogic DomainConfiguring a New Server Definition within a WebLogic DomainConfiguring the Network Resources for a WebLogic DomainAn Introduction to Network ChannelsViewing Your Default Network ConfigurationEnabling the Administration PortConfiguring a Network ChannelUnderstanding Network Access PointsLeveraging Network Access Points in Your Network ChannelManaging Your WebLogic Servers Using the Node ManagerConfiguring the Node Manager on a Machine NodeStep 1: Configuring Your Trusted HostsStep 2: Configuring SSL Communication Between the Administration Server and Managed ServersStep 3: Configuring the Node Manager MachinesStep 4: Specifying the Managed Server’s Startup InformationStarting the Node Manager ProcessStarting the Node Manager Using a Startup ScriptCreating a Node Manager Windows ServiceRemotely Starting the Managed ServersReviewing the Node Manager–Associated Log FilesThe Node Manager Startup Log FilesThe Managed Server Log FilesMonitoring the Health of Your WebLogic Domain Using the Node ManagerUnderstanding the WebLogic Server LogsModifying the Logging Behavior of the Local Log FileThe General TabThe Rotation TabModifying the Logging Behavior of the Domainwide Log FileSummary
25. Implementing Highly Available and Scalable Solutions Using the WebLogic Cluster
The Motivations for Clustered Infrastructure Solutions: Scalability and High AvailabilityScalabilityHigh AvailabilityAdditional Factors Affecting High AvailabilityLoad BalancingUnderstanding WebLogic ClustersUnderstanding Which Objects Can Be ClusteredExamining Deployment Restrictions to the WebLogic ClusterUnderstanding How WebLogic Servers Communicate Within a ClusterIP Multicast CommunicationIP Socket Communication (Peer-to-Peer)Designing the Architecture of a WebLogic ClusterUnderstanding a Typical Clustering EnvironmentThe Load BalancerThe Web Proxy ServerWebLogic ServerThe DeMilitarized Zone (DMZ)Recommended WebLogic Clustering ArchitecturesThe Combined-Tier ArchitectureThe Multi-Tier ArchitectureCreating and Configuring a WebLogic ClusterThe Tools for Creating and Configuring a WebLogic ClusterGuidelines for Configuring Your WebLogic ClusterConfiguring a Cluster Using the Administration ConsoleStarting Your WebLogic ClusterStarting a WebLogic Cluster Using the Command ShellStarting a WebLogic Cluster Using the Administration ConsoleMonitoring Server Participation in Your WebLogic ClusterImplementing a Load-Balancing Mechanism for Your Clustered Servlets and JSPsUsing a WebLogic Proxy Plug-in Load-Balancing SolutionConfiguring the HttpClusterServlet As a Load-Balancing SolutionUsing a Hardware Appliance Load-Balancing SolutionImplementing a Failover Mechanism for Your Clustered Servlets and JSPsIn-Memory ReplicationConfiguring In-Memory ReplicationConfiguring Replication Groups to Specify Replica Object ServersDemonstrating the In-Memory Replication of Session StateFile-Based Persistent StorageJDBC-Based Persistent StorageClustering Enterprise JavaBeansThe Replica-Aware Home and Remote StubsThe Load-Balancing and Failover Algorithms Employed by the Replica-Aware StubsThe Load-Balancing and Failover Mechanisms of Stateless Session BeansThe Load-Balancing and Failover Mechanisms of Stateful Session BeansThe Load-Balancing and Failover Mechanisms of Entity BeansSummary
26. Managing the WebLogic Security Service
The Challenges of Web Application SecurityThe Formation of Social Infrastructures to Support a Security EcosystemThe Functional Abstraction of Security from Application CodeAn Introduction to the WebLogic Server Security ServiceA Basic Security Setup Using the WebLogic Server Security ServiceThe Demilitarized ZoneThe FirewallThe Web ServerConnection FiltersLightweight Directory Access ProtocolThe Architecture of the WebLogic Security ServiceThe WebLogic Security FrameworkThe Security Service Provider InterfacesThe Security Provider DatabaseSecurity ProvidersAuthentication ProvidersThe Authentication ProcessThe LoginModuleThe PrincipalValidatorThe IdentityAsserterRole Mapping ProvidersAuthorization ProvidersAuditing ProviderCredential Mapping ProviderKeystore ProvidersRealm Adapter ProvidersUnderstanding Your WebLogic Security RealmManaging Your Security RealmThe General TabThe User Lockout TabThe Contents TabThe Providers TabConfiguring New User AccountsThe Guest and Anonymous UsersConfiguring New GroupsAdding Users to GroupsConfiguring RolesCreating a Global RoleCreating a Scoped RoleConfiguring Security PoliciesSecuring Your WebLogic ApplicationsSecuring a Web Application Through the Administration ConsoleSummary
27. Packaging, Assembling, and Deploying J2EE Applications
Introducing the WebLogic Server ClassLoadersWhat Are Java ClassLoaders?J2EE Application Classloading in WebLogic ServerUnderstanding the WebLogic Server ClassLoader HierarchyMaking Use of the PreferWebInfClasses ElementApplication Classloading Optimization in WebLogic ServerBest Practices for Packaging Shared Utility ClassesMaking Use of the Manifest Class-PathPackaging Applications Targeted for WebLogic ServerWeb ApplicationsThe Web Application Directory StructureWeb Application Deployment DescriptorsGenerating Web Application Deployment Descriptors AutomaticallyPackaging Web ApplicationsEnterprise JavaBean ApplicationsThe Enterprise JavaBean Application Directory StructureEJB Application Deployment DescriptorsGenerating EJB Application Deployment Descriptors AutomaticallyPackaging EJB ApplicationsEnterprise ApplicationsThe Enterprise Application Directory StructureEnterprise Application Deployment DescriptorsPackaging Enterprise ApplicationsDeploying Applications to WebLogic ServerTwo-Phase DeploymentApplication StagingSetting the Staging Mode and Staging DirectoryThe Deployment Order for Services and Applications in WebLogic ServerThe WebLogic Server Deployment ToolsUsing the Administration Console to Deploy ApplicationsConfiguring and Deploying J2EE Applications Using the Administration ConsoleUndeploying Components with the Administration ConsoleDeleting Applications and Components with the Administration ConsoleViewing a List of Components Through the Administration ConsoleUsing the weblogic.Deployer Utility to Deploy ApplicationsDeploying a New Application to the Administration ServerDeploying a New Application to Managed ServersRedeploying an Application to Targeted WebLogic ServersDeploying a New Module to a Deployed EAR ApplicationDeactivating an Application on Active TargetsDeactivating an Application on All Deployed WebLogic ServersReactivating a Deactivated ApplicationRemoving a Deployed ApplicationRefreshing Parts of an Exploded ApplicationListing All Deployment TasksCanceling a Deployment TaskUsing WebLogic Builder to Build and Deploy J2EE ApplicationsStarting WebLogic BuilderOpening a J2EE Application Using WebLogic BuilderEditing Web Application Deployment Descriptors with WebLogic BuilderEditing EJB Deployment Descriptors with WebLogic BuilderOther Useful Features Provided by WebLogic BuilderConnecting to WebLogic ServerValidating a ComponentViewing Deployment Descriptor XML FilesDeploying an Application Using WebLogic BuilderUsing Auto-DeploymentDevelopment ModeProduction ModeDeploying Applications in the Auto-Deployment ModeUndeploying Applications in Auto-Deployment ModeRedeploying Archived Applications in Auto-Deployment ModeRedeploying Exploded Applications in Auto-Deployment ModeUsing Ant for Building J2EE ApplicationsAnt Basic ConceptsUnderstanding the Ant Build FileBuilt-in Ant TasksjavacjavajarThe File and Directory Manipulation Ant TasksCreating a Web Application Archive Using the war Ant TaskCreating an Enterprise Application Archive Using the ear Ant TaskDeployment Best Practices
28. Performance Tuning WebLogic Server
Performance Tuning Goals for WebLogic ServerA WebLogic Server Performance Tuning RoadmapStep 1: Understand Your WebLogic Server EnvironmentStep 2: Document Your WebLogic Server EnvironmentStep 3: Develop Test Scenarios for Your WebLogic Server EnvironmentStep 4: Benchmark Your Test ScenariosStep 5: Identify the Potential Bottlenecks Affecting the Performance of Your Test ScenariosStep 6: Resolve the Performance Bottlenecks in Your Test ScenariosTuning the Core Server Performance: The Thread PoolThe Socket Reader Implementation in WebLogic ServerTuning the Java Socket Reader ThreadsWebLogic Server Execute QueuesDetermining the Appropriate Thread Count for an Execute QueueStep 1: Start the Administration ServerStep 2: Run and Monitor a Load Test Against Your WebLogic Server ApplicationStep 3: Modifying the Thread Count in the Default Execute QueueTuning Execute Queues for Overflow ConditionsDetermining Stuck ThreadsConfiguring Custom Execute QueuesAssigning Applications to Specific Execute QueuesAssigning Servlets and JSPs to Execute QueuesAssigning RMI Objects and EJBs to Execute QueuesMonitoring Execute Queues and Execute ThreadsTuning the Connection BacklogTuning JDBC Connection Pools in WebLogic ServerCaching Prepared SQL StatementsTuning EJB ApplicationsStateless Session BeansStateful Session BeansEntity BeansTuning Pool Size for Entity BeansUsing the Appropriate Concurrency StrategyUsing the Appropriate Transaction Isolation LevelUsing Delay-Database-Insert-UntilOptimizing HTTP SessionsTuning the Java Virtual Machine (JVM)Tuning the JVM Heap SizeDetermining Heap Size for the WebLogic ServerSetting the JVM Heap Size OptionsMonitoring the WebLogic Server Heap and Forcing Garbage CollectionDetecting Low Memory Conditions in WebLogic ServerSummary
VII. Web Services
29. Web Services and the WebLogic Platform
IntroductionThe Architectural Framework of Web ServicesSupported StandardsWhy WebLogic Web Services?Roadmap to WebLogic Web ServicesCreating Local Web ServicesThrough WebLogic ServerThrough WebLogic WorkshopWeb Service Runtime EnvironmentsLocal Web Service Advertised with UDDIThe Portlet WizardWeb Services Included with WebLogic CommerceWeb Service Examples in WebLogicWeb Service Design QuestionsWeb Service TypesSynchronous Web ServicesAsynchronous Web ServicesSynchronous or Asynchronous?Back-End Provider ComponentsEJBsJava ClassesSecurityAnatomy of a WebLogic Web ServiceThe JAX-RPC ModelSerializers and DeserializersSupported or Built-in TypesSOAP HandlersInside a Synchronous (RPC) Web ServiceInside an Asynchronous Web ServiceWebLogic Web Service ClientsWeb Service Client ModelsStaticDynamic (with WSDL)More on QNamesDynamic (Without WSDL)InOut ParametersSummary
30. Developing Web Services for WebLogic Server
Introduction to Web Service DevelopmentUnderstanding Design ConsiderationsIntroducing the WebLogic Build ToolsThe Web Service Home PageAnatomy of an Assembled Web ServiceThe Client JAR FileDeveloping Your Own Web ServiceWebLogic Ant TasksServiceGenLetting ClientGen Generate UDTs for YouCommand-Line UtilitiesUnderstanding Web Service Packaging ConsiderationsBuilding WebLogic Web Services ManuallyThe Web Service Deployment DescriptorA Sample web-services.xml FileUsing User-Defined Data TypesSpecifying XML Schema for UDTsDefining Types in web-services.xmlWriting Serializers and DeserializersDefining Type Mappings in web-services.xmlWriting Back-End ComponentsStateless Session EJBsJava ClassesUsing Output ParametersThe Holder InterfaceInOut Back-End ComponentInOut in WSDL and web-services.xmlRunning the InOut SampleInOut User-Defined TypesWriting Message HandlersHandlersThe GenericHandler ClassHandler ChainsFlow of ControlShared ContextConfiguring Handlers into web-services.xmlDefining Your Handlers and Handler ChainsSpecifying Handler UseUnderstanding Exception HandlingWriting Asynchronous Web ServicesJMS and Message-Driven Beans ExampleThe ProcessorMDB BeanSetting Up JMS Factory and DestinationsRunning the Asynchronous Web Service SampleExamining How the Asynchronous Sample Is BuiltUsing the Asynchronous Web Service with Multiple OperationsSecuring Your Web ServicesUsing SSLRestricting Your Web Service to Use HTTPSSecuring Your Web Service URLSecuring Your EJB Back-End Componentejb-jar.xmlweblogic-ejb-jar.xmlDebugging Your WebLogic Web ServicesChecking Out the Web Service Home PageExamining the Web Service Through the WebLogic Administration ConsoleLooking at the Generated web-services.xml FileRuntime DiagnosticsWebLogic Log FilesBest PracticesEmploying Coarse-Grained InteractionsPromoting Loose CouplingDeciding What Service Mode Is ImportantAvoiding Method OverloadingKnowing That Web Services Are Not Always the AnswerNew Features in WLS 7.0 Service PacksSummary
31. Discovering Web Services
IntroductionWhat Is UDDI?How Does UDDI Work?The UDDI API at a GlanceUDDI Usage PatternsA Sample Use CaseThe Inquiry APIThe Publish APIWhat a UDDI SOAP Call Looks LikeUDDI Features in WebLogic ServerThe WebLogic UDDI Client ProxyUDDI Data Structures Implementation: weblogic.uddi.client.structures.datatypesAPI Request Data Objects: weblogic.uddi.client.structures.requestAPI Response Data Objects: weblogic.uddi.client.structures.responseThe Inquiry Class: weblogic.uddi.client.service.InquiryThe Publish Class: weblogic.uddi.client.service.PublishSample Client Code (Tasks)Finding a BusinessFinding a ServiceCreating a New BusinessThe WebLogic UDDI Directory ExplorerRunning UDDI ExplorerCreating Entries in a Private RegistrySummary
32. Web Services Made Easy—WebLogic Workshop
OverviewThe Need for WebLogic WorkshopSimplify J2EE for the Application DeveloperSolve Integration Problems with Enterprise-Class Web ServicesWhat Is a Framework?Why WebLogic Workshop?WebLogic Workshop ArchitectureJWS FilesJWS SyntaxAsynchrony: Conversations, Callbacks, and BufferingConversationsCallbacksClient CallbackControl HandlerBufferingJWS ControlsXML MapsHow to MapSimple MappingScript MappingMapping from XML to JavaMapping from Java to XMLECMAScriptWhere to MapControls—A Closer LookDatabase ControlWeb Service DeploymentThe Visual Development EnvironmentProject TreeOperationsMain Work Area—The CanvasThe Test HarnessOverview PageConsole PageTest Form PageTest XML PageWarnings PageA Short TutorialPreliminariesCreate the creditCheck Web ServiceCreate the Bankruptcies Database ControlCreate the Validate Credit EJB ControlMake Investigate.jws Call These ControlsTest the ServiceSummary
VIII. Integration Services Provided by WebLogic Server 7
33. Introducing WebLogic Integration (WLI)
Introducing IntegrationChallenges in Application IntegrationStandards in Application IntegrationBEA WebLogic Integration: A Platform for Application IntegrationBEA WebLogic Integration Functional AreasBusiness Process ManagementApplication IntegrationB2B and Data Integration
34. Business and Workflow Process Management Using WLI
IntroductionBusiness Process Management (BPM)Process TypesStages in Business Process ManagementProcess DesignProcess ExecutionProcess MonitoringHelloWorld Workflow: A Workflow Which Triggers on an XML EventDesigning Business ProcessesBPM ToolsStudioWorklistProgramming Using BPM APIsAn Example of Using BPM APIsBPM Plug-in FrameworkWorkflow PatternsParallel ExecutionChoice of EventsEvent with TimeoutCancellation via EventExecution TimeoutSummary
35. Understanding J2CA Through the WLI Application Integration Framework
Introduction to Application IntegrationWhat Is J2EE Connector Architecture (J2CA)?Resource AdapterConnection Management ContractTransaction Management ContractSecurity Management ContractCommon Client Interface (CCI)Components of Application IntegrationIntegration FrameworkAdapter DevelopmentApplication ViewsDefining an Application ViewUsing Application Views in WorkflowsUsing Application Views ProgrammaticallyDeploying Application ViewsAdapter Development Kit (ADK)Service AdaptersEvent AdaptersADK FrameworksDesign-Time FrameworkRuntime FrameworkLogging FrameworkPackaging FrameworkSummary
36. Data Integration and B2Bi
Introduction to IntegrationData IntegrationTranslationTransformationData Integration Support in WebLogic IntegrationThe Design-Time ComponentThe Runtime ComponentPlug-in to BPMData Integration ToolsXML Instance EditorXML RepositoryXPath WizardFormat BuilderConverting Binary Data to XML Using Format BuilderContivo AnalystData Integration and BPMAdvanced Data Integration Using the Data Integration Plug-inBusiness-to-Business Integration (B2Bi)B2B Integration Support in WLIB2Bi ConfigurationsPeer-to-PeerHub-and-SpokeBusiness ProtocolsConversationCollaboration AgreementUsing Workflows for B2BiebXML Workflow ExampleThe B2Bi Plug-in for BPMAdministration Using the B2Bi ConsoleBusiness ConnectSummary
IX. Appendixes
A. Platform End-to-End Example
IntroductionInstallationRestrictionsStarting the ServerUse Case One: WebLogic Portal FeaturesCapturing the SaleAdding a Web Service–Based PortletUse Case Two: WebLogic Workshop FeaturesUnder the Covers of the Order-Tracking Web ServiceUsing the New Web ServiceUse Case Three: WebLogic Integration FeaturesUnder the Covers of the Third Use CaseSummary

Overview

BEA® WebLogic Platform 7 is a fast-paced introduction to the new WebLogic Platform. The focus of this book is to provide you with an in-depth knowledge of the WebLogic Platform 7.0 product and how you can leverage its capabilities and new features to create, configure, manage, and monitor an optimal operational environment for your J2EE applications. Hence, the primary technical topics discussed in this book fall under the realm of WebLogic Server Administration. This book covers in J2EE concepts and how to develop J2EE applications targeted for the WebLogic Platform.

Become versed on the capabilities, new features and technical architecture of the WebLogic Server 7.0.

Master how to install and efficiently configure a WebLogic Server.

Configure the WebLogic Server to use BEAÂ¿s performance-based JRockit JVM.

Leverage the WebLogic ServerÂ¿s administration and deployment tools.

Extend a WebLogic Server domain through the introduction of remote managed servers.

Configure network resources for your WebLogic Servers.

Implement an administration and monitoring framework using Node Manager in conjunction with the WebLogic ServerÂ¿s new Self-Health Monitoring System.

Activate and configure your WebLogic ServerÂ¿s logging capabilities.

Architect and implement highly available and scalable application deployment solutions using the WebLogic Server cluster.

Optimally package J2EE Web and Enterprise applications and deploy them to your WebLogic Server.

Performance tune the WebLogic ServerÂ¿s internal subsystems.

Optimize the WebLogic ServerÂ¿s default HotSpot JVM.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 0789727129Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills