III. WebLogic and J2EE Services Support
by Bernard Ciconte, Scott Dunbar, Peter Go, Manish Devgan, Jatinder Prem
BEA® WebLogic Platform 7
- Copyright
- About the Author
- About the Co-Authors
- Acknowledgments
- We Want to Hear from You!
- Introduction
- About This Book
- Who Should Read This Book?
- How This Book Is Organized
- Part I: J2EE Application Development Essentials
- Part II: Introducing the BEA WebLogic Platform 7
- Part III: WebLogic and J2EE Services Support
- Part IV: Developing Presentation Logic—JSPs and Servlets
- Part V: Developing Business Logic—Enterprise JavaBeans
- Part VI: BEA WebLogic Server Administration
- Part VII: Web Services
- Part VIII: Integration Services Provided by WebLogic Server 7
- Case Study: A Sample End-to-End Example Using The WebLogic Platform
- Source Code for This Book
- I. J2EE Application Development Essentials
- 1. Understanding the Java 2 Platform, Enterprise Edition
- Overview
- Java Technology Today
- The Challenges of Today’s eSystems
- The Java 2 Platform, Enterprise Edition
- The J2EE Platform—Technology Component and Service APIs
- Java Servlet Technology 2.3
- JavaServer Pages Technology 1.2
- Enterprise JavaBeans Technology 2.0
- JDBC 2.0 API
- Java Message Service 1.0
- Java Transaction API 1.0
- JavaMail Technology 1.2
- JavaBeans Activation Framework 1.0
- J2EE Java Connector Architecture API 1.0
- Java Naming and Directory Services API
- Java API for XML 1.1
- Java Authentication and Authorization Service 1.0
- J2EE Application Programming Model
- J2EE Compatibility Test Suite
- J2EE Reference Implementation (RI)
- The J2EE Platform—Technology Component and Service APIs
- J2EE Application Development Roles
- J2EE Application Deployment Roles
- 2. J2EE Software Development Methodologies
- (Not) Gaining a Competitive Edge in Internet Time
- Why J2EE Projects Fail
- Recognizing Mission Impossible Projects
- Lack of Executive Sponsorship
- Lack of User Involvement in the Project
- The Initial Project Objectives Are Wrong
- Changing Project Requirements and Specifications—“Scope Creep”
- Lack of or Excessive Planning
- Lack of IT Management and Technical Direction
- Object-Oriented Analysis, Design, and Development Illiteracy
- The Warning Signs of a Failing J2EE Project
- Recognizing Mission Impossible Projects
- The Top Ten Checklist for Initiating J2EE Projects
- Organizational Frameworks for Supporting Enterprise J2EE Projects
- Software Development Methodologies
- What Is an Object-Oriented (OO) Methodology?
- Major Motivations for Using OO Methodologies in J2EE System Developments
- Object-Oriented Approaches Produce Solutions Which Closely Resemble Their Problem Domains
- Object-Oriented Approaches Promote OO Thinking
- Objects and Components Are “Black Boxes”
- Object-Oriented Approaches Promote Reusability
- Object-Oriented Approaches Support Interoperability
- Object-Oriented Approaches Possess Traceability Capabilities
- The Challenges of Using OO Methodologies—“Object Blindness”
- The Traditional Waterfall Methodology
- J2EE Software Development Methodologies Unveiled
- Selecting a Software Development Methodology
- BEA Systems Accelerated Process (Project Initiation Phase)
- BEA Systems SteelThread (Architectural Prototyping)
- eXtreme Programming
- The 12 Core Practices of eXtreme Programming
- The Planning Game
- Small Releases
- Customer Tests (Acceptance Testing)
- Simple Design
- Pair Programming
- Test-First Development (Unit Testing)
- Design Improvement (Refactoring)
- Continuous Integration
- Collective Code Ownership
- Coding Standard
- Metaphors
- Sustainable Pace
- eXtreme Programming Resources
- The Rational Unified Process
- 3. A Developer’s Guide to the Unified Modeling Language (UML)
- The Challenge of Object-Oriented Analysis and Design
- What Is the Unified Modeling Language?
- The Relationship Between UML and Software Development Methodologies
- UML Modeling Tools
- The Elements of the Unified Modeling Language
- Developing Use Case Diagrams (Analysis Phase)
- Developing Class Diagrams (Analysis)
- Developing Class Diagrams (Design)
- Developing Interaction Diagrams (Design)
- Developing Statechart Diagrams (Design)
- Developing Activity Diagrams (Analysis and Design)
- Developing Component and Deployment Diagrams (Design)
- UML By Example—The Book Store
- 4. Best Practices for Java Development
- Project Standards
- Java Style Guidelines
- Java Programming Guidelines
- The Java Development Process
- Endnotes
- 5. The J2EE Architecture and APIs
- Understanding the Java 2 Platform, Enterprise Edition
- The Logical Tiers of the J2EE Architecture
- The J2EE Application Programming Model
- The J2EE Application Server Layer
- The Operating System Layer
- Java Virtual Machine (JVM) Layer
- The J2EE Application Server Execution Environment
- The J2EE Services Layer
- The EJB Container
- Enterprise JavaBeans (EJB)
- The Web Container
- Servlets
- JavaServer Pages (JSP)
- 6. Transitioning from Software Design to J2EE Technology Components and Services
- 7. An Introduction to Web Services
- 1. Understanding the Java 2 Platform, Enterprise Edition
- II. Introducing the BEA WebLogic Platform 7
- 8. Deriving Application Infrastructure
- Introducing Application Infrastructure
- Understanding the Need for Application Infrastructure
- Examining an Organization’s Application Infrastructure Reality
- Deriving an Application Infrastructure Strategy
- Implementing the Software Platform Solution to Application Infrastructure
- Employing BEA’s Unified, Simplified, and Extensible Formula for Application Infrastructure: WebLogic Platform 7.0
- Summary
- 9. Introducing BEA WebLogic Platform 7
- What Is Technical Agility?
- The WebLogic Platform—A Single, Unified, and Extensible Application Infrastructure
- Introducing BEA WebLogic Server 7
- WebLogic Server’s Competitive Edge
- The Technical Architecture of WebLogic Server
- Introducing WebLogic Workshop
- Introducing BEA WebLogic Portal
- Introducing WebLogic Integration
- Summary
- 10. Installing and Configuring WebLogic Server 7
- WebLogic Server 7 Editions
- Preliminary WebLogic Server Installation Considerations
- Installing WebLogic Server
- Step 1: Download and Execute the Net Installer Program
- Step 2: Select the BEA Home Directory
- Step 3: Select the Installation Type
- Step 4: Select the WebLogic Platform Products and Components
- Step 5: Select the Download Option
- Step 6: The Auto Installation Option
- Step 7: Select the WebLogic Server Product Directory
- Step 8: The Domain Configuration Wizard
- Step 9: Create Your WebLogic Domain
- Step 10: Select the WebLogic Server Type
- Step 11: Select Your Domain Container Directory
- Step 12: Configure Your Single Server
- Step 13: Create Your System User Name and Password
- Step 14: Create the WebLogic Server As a Windows Service
- Step 14: Create a Start Menu Entry for Your WebLogic Server
- Step 15: Review and Create Your Specified WebLogic Server Configuration
- Validate Your CLASSPATH and PATH Environmental Variables
- Navigating the WebLogic Platform Directory Structure
- Startup Methods for WebLogic Server in Windows 2000
- Starting the Default WebLogic Server
- Shutdown Methods for WebLogic Server in Windows 2000
- Understanding the New WebLogic Server Lifecycle States
- Using WebLogic Server with the WebLogic JRockit JVM
- Summary
- 11. Working with the WebLogic Server Tools
- The WebLogic Server System Administration Tools
- The WebLogic Server Deployment Tools
- Deploying Your First Web Application Using WebLogic Builder
- Step 1: Creating the Web Application Directory Structure
- Step 2: Creating Your Welcome Page
- Step 3: Creating and Compiling Your Hello World Servlet
- Step 4: Starting the WebLogic Builder
- Step 5: Assembling the HelloWorldApp Web Application
- Step 6: Deploying Your Web Application
- Step 7: Testing Your Web Application
- Summary
- 8. Deriving Application Infrastructure
- III. WebLogic and J2EE Services Support
- 12. Distributed Processing Using RMI
- 13. Accessing Data Repositories Using JDBC
- 14. Locating Named Services through JNDI
- 15. The Java Messaging Service (JMS)
- What Is the Java Message Service API?
- An Overview of the JMS Architecture and Messaging
- The Structure of a JMS Message
- The JMS API Programming Model
- The WebLogic JMS Server
- The Basic Configuration of WebLogic JMS
- Developing a WebLogic JMS Application
- Summary
- 16. Managing Java Transactions Using JTA
- The Java Transaction API
- Using Transactions to Ensure Data Integrity
- Understanding Distributed Transactions
- ACID-Compliant Databases
- The JDBC Optional Package and JTA
- Configuring WebLogic JDBC Connection Pools
- Configuring WebLogic JDBC Tx DataSources
- Performing Distributed Transactions with a Transaction Manager
- Using the WebLogic JTA Driver
- The BookStore Servlet Example
- Summary
- IV. Developing Presentation Logic—JSPs and Servlets
- 17. Introduction to Servlets
- 18. JavaServer Pages and Tag Libraries
- 19. Servlets and JavaServer Pages—Best Practices
- V. Developing Business Logic—Enterprise JavaBeans
- 20. Developing Business Logic—Session Beans
- Introducing Session Beans
- Session Bean Types
- A Practitioner’s Approach to Understanding Session Beans
- The Life Cycle of Stateless Session Beans
- The Life Cycle of Stateful Session Beans
- Testing the Life Cycle of Stateful Session Beans
- Programming Transactions in Session Beans
- Summary
- 21. Managing Persistence—Entity Beans
- Persistence: The Final Tier
- What Are Entity Beans?
- Using the EJB Container
- The Lifecycle of Entity Beans
- Developing the Components of Entity EJBs
- Writing the Entity EJB Class
- Writing the Primary Key Class
- Deployment Descriptors
- Writing Finder Methods
- Bean-Managed Persistence Example
- Container-Managed Persistence Example
- Container-Managed Relationship Example
- Deployment on WebLogic Server
- Summary
- 22. Asynchronous Message Processing—Message-Driven Beans
- What Is a Message-Driven Bean?
- The Message-Driven Bean Class
- The Life Cycle of a Message-Driven Bean
- Developing a Simple Message-Driven Bean Example
- An Overview of Message-Driven Bean Transactions
- Summary
- 23. EJB Best Practices
- Best Practices for Session Beans
- Best Practices for Entity Beans
- Consider Writing CMP Entity Beans Instead of BMP Entity Beans
- Debug Flags to Instrument BMP Code
- Writing an Efficient Primary Key Class
- Choose the Right Concurrency Strategy
- Optimize Database Access Calls
- Loading Related CMP Fields
- Optimizing Finders
- Optimizing CMP Entity Beans
- Optimizing BMP Entity Beans
- Optimizing Database Writes for BMP Entity Beans
- Consider Using Tuned Updates for CMP 1.1 Beans
- Consider Using Read-Only/Read-Mostly Entity Beans
- Handling Transactions in EJBs
- Best Practices for EJB Security
- Best Practices for Coding Standard Interfaces
- MDB Best Practices
- Summary
- 20. Developing Business Logic—Session Beans
- VI. BEA WebLogic Server Administration
- 24. Administering and Monitoring Your WebLogic Domain
- Understanding WebLogic Domains
- Creating and Extending WebLogic Domains
- Configuring the Network Resources for a WebLogic Domain
- Managing Your WebLogic Servers Using the Node Manager
- Understanding the WebLogic Server Logs
- Summary
- 25. Implementing Highly Available and Scalable Solutions Using the WebLogic Cluster
- The Motivations for Clustered Infrastructure Solutions: Scalability and High Availability
- Understanding WebLogic Clusters
- Understanding How WebLogic Servers Communicate Within a Cluster
- Designing the Architecture of a WebLogic Cluster
- Creating and Configuring a WebLogic Cluster
- Implementing a Load-Balancing Mechanism for Your Clustered Servlets and JSPs
- Implementing a Failover Mechanism for Your Clustered Servlets and JSPs
- Clustering Enterprise JavaBeans
- The Replica-Aware Home and Remote Stubs
- The Load-Balancing and Failover Algorithms Employed by the Replica-Aware Stubs
- The Load-Balancing and Failover Mechanisms of Stateless Session Beans
- The Load-Balancing and Failover Mechanisms of Stateful Session Beans
- The Load-Balancing and Failover Mechanisms of Entity Beans
- Summary
- 26. Managing the WebLogic Security Service
- The Challenges of Web Application Security
- An Introduction to the WebLogic Server Security Service
- The Architecture of the WebLogic Security Service
- Security Providers
- Understanding Your WebLogic Security Realm
- Securing Your WebLogic Applications
- Summary
- 27. Packaging, Assembling, and Deploying J2EE Applications
- Introducing the WebLogic Server ClassLoaders
- What Are Java ClassLoaders?
- J2EE Application Classloading in WebLogic Server
- Understanding the WebLogic Server ClassLoader Hierarchy
- Making Use of the PreferWebInfClasses Element
- Application Classloading Optimization in WebLogic Server
- Best Practices for Packaging Shared Utility Classes
- Making Use of the Manifest Class-Path
- Packaging Applications Targeted for WebLogic Server
- Deploying Applications to WebLogic Server
- The WebLogic Server Deployment Tools
- Using the Administration Console to Deploy Applications
- Using the weblogic.Deployer Utility to Deploy Applications
- Deploying a New Application to the Administration Server
- Deploying a New Application to Managed Servers
- Redeploying an Application to Targeted WebLogic Servers
- Deploying a New Module to a Deployed EAR Application
- Deactivating an Application on Active Targets
- Deactivating an Application on All Deployed WebLogic Servers
- Reactivating a Deactivated Application
- Removing a Deployed Application
- Refreshing Parts of an Exploded Application
- Listing All Deployment Tasks
- Canceling a Deployment Task
- Using WebLogic Builder to Build and Deploy J2EE Applications
- Starting WebLogic Builder
- Opening a J2EE Application Using WebLogic Builder
- Editing Web Application Deployment Descriptors with WebLogic Builder
- Editing EJB Deployment Descriptors with WebLogic Builder
- Other Useful Features Provided by WebLogic Builder
- Deploying an Application Using WebLogic Builder
- Using Auto-Deployment
- Undeploying Applications in Auto-Deployment Mode
- Redeploying Archived Applications in Auto-Deployment Mode
- Redeploying Exploded Applications in Auto-Deployment Mode
- Using Ant for Building J2EE Applications
- Deployment Best Practices
- Introducing the WebLogic Server ClassLoaders
- 28. Performance Tuning WebLogic Server
- Performance Tuning Goals for WebLogic Server
- A WebLogic Server Performance Tuning Roadmap
- Step 1: Understand Your WebLogic Server Environment
- Step 2: Document Your WebLogic Server Environment
- Step 3: Develop Test Scenarios for Your WebLogic Server Environment
- Step 4: Benchmark Your Test Scenarios
- Step 5: Identify the Potential Bottlenecks Affecting the Performance of Your Test Scenarios
- Step 6: Resolve the Performance Bottlenecks in Your Test Scenarios
- Tuning the Core Server Performance: The Thread Pool
- The Socket Reader Implementation in WebLogic Server
- WebLogic Server Execute Queues
- Configuring Custom Execute Queues
- Monitoring Execute Queues and Execute Threads
- Tuning the Connection Backlog
- Tuning JDBC Connection Pools in WebLogic Server
- Tuning EJB Applications
- Optimizing HTTP Sessions
- Tuning the Java Virtual Machine (JVM)
- Summary
- 24. Administering and Monitoring Your WebLogic Domain
- VII. Web Services
- 29. Web Services and the WebLogic Platform
- 30. Developing Web Services for WebLogic Server
- Introduction to Web Service Development
- Understanding Design Considerations
- Introducing the WebLogic Build Tools
- Developing Your Own Web Service
- Understanding Web Service Packaging Considerations
- Building WebLogic Web Services Manually
- Using User-Defined Data Types
- Writing Back-End Components
- Using Output Parameters
- Writing Message Handlers
- Debugging Your WebLogic Web Services
- Best Practices
- New Features in WLS 7.0 Service Packs
- Summary
- 31. Discovering Web Services
- Introduction
- What Is UDDI?
- How Does UDDI Work?
- The UDDI API at a Glance
- UDDI Features in WebLogic Server
- The WebLogic UDDI Client Proxy
- UDDI Data Structures Implementation: weblogic.uddi.client.structures.datatypes
- API Request Data Objects: weblogic.uddi.client.structures.request
- API Response Data Objects: weblogic.uddi.client.structures.response
- The Inquiry Class: weblogic.uddi.client.service.Inquiry
- The Publish Class: weblogic.uddi.client.service.Publish
- Sample Client Code (Tasks)
- The WebLogic UDDI Directory Explorer
- Summary
- 32. Web Services Made Easy—WebLogic Workshop
- VIII. Integration Services Provided by WebLogic Server 7
- 33. Introducing WebLogic Integration (WLI)
- 34. Business and Workflow Process Management Using WLI
- 35. Understanding J2CA Through the WLI Application Integration Framework
- 36. Data Integration and B2Bi
- IX. Appendixes
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.