Cover image for Building Java Enterprise Applications

Book description

What are the key decisions and tradeoffs you face as you design and develop enterprise applications? How do you build the back end so that it not only handles your current needs but is flexible enough to allow your system to evolve as your needs expand? Answer these questions and many more with Building Java Enterprise Applications, an advanced guide to building complex Java Enterprise Applications from the ground up that addresses design issues along the way. These practical books take a step back from detailed examination of the APIs and focus on the entire picture, so you can put the pieces together and build something that works! This book explores the infrastructure issues so important to good application design. It isn't just a book about doing things with Entity Beans, JDBC and JMS and JNDI. It takes you step by step through building the back end, designing the data store so that it gives you convenient access to the data your application needs; designing a directory; figuring out how to handle security and where to store security credentials you need; and so on. On top of this, it shows -- as easily as possible --how to build the entity bean layer that makes information available to the rest of the application. Throughout this guide, author Brett McLaughlin uses his wealth of real-world experience with enterprise development to show you one step at a time how to design and build a comprehensive enterprise application from the ground up, starting with the back end.

Table of Contents

  1. Building Java Enterprise Applications Volume I: Architecture
    1. Preface
      1. Organization
      2. Software and Versions
      3. Conventions Used in This Book
      4. Comments and Questions
      5. Acknowledgments
    2. 1. Introduction
      1. Building Java Enterprise Applications
        1. Volume I: Architecture
        2. Volume II: Web Applications
        3. Volume III: Web Services
      2. Architecture
        1. Databases
        2. Directory Servers
        3. Enterprise JavaBeans
      3. What You’ll Need
        1. APIs
        2. Tools and Utilities
        3. Related Works
    3. 2. Blueprints
      1. Forethought Brokerage
        1. The Company
        2. Identified Needs
          1. Online accessibility
          2. Supports wireless devices
          3. Handles scheduling
          4. Stores information about employees as well as clients
          5. “Fast performance and standards compliance”
        3. Proposed Solutions
          1. Java and J2EE for web delivery
          2. JSP, XML, and XSL for content and presentation
          3. Services architecture
          4. Storing data
          5. Servlets, EJB, caching, and performance
      2. The Data Layer
        1. Databases
        2. Directory Servers
        3. Data Access
          1. Java Database Connectivity (JDBC)
          2. EJB entity beans
          3. Java Naming and Directory Interface (JNDI)
      3. The Business Layer
        1. Business Logic
          1. Stateless session beans
          2. Stateful session beans
        2. Messaging
      4. The Presentation Layer
      5. Finalizing the Plans
      6. What’s Next?
    4. 3. Foundation
      1. Designing the Data Stores
        1. Users
          1. Data constraints
          2. User types
          3. Unique keys, characters, and IDs
        2. Permissions
          1. Granularity
          2. Groups, roles, and permissions
        3. Accounts
        4. Scheduling and Events
        5. Odds and Ends
      2. Databases
        1. User Storage
        2. Accounts Storage
        3. Scheduling and Events Storage
        4. Connecting the Dots
        5. Seed Data
        6. Cleaning Up
      3. Directory Servers
        1. Users and Passwords
          1. Structural constraints versus programmatic constraints
        2. Permissions and Roles
          1. Addition versus extension
        3. Directory Hierarchy
      4. What’s Next?
    5. 4. Entity Basics
      1. Basic Design Patterns
      2. Coding the Bean
        1. Adapters and Entity Beans
        2. The Remote Interface
        3. The Local Interface
        4. The Primary Key
        5. The Home Interface
        6. The Local Home Interface
        7. The Bean Implementation
      3. Deploying the Bean
        1. Deployment Descriptors
        2. Wrapping It Up
      4. What’s Next?
    6. 5. Advanced Entities
      1. IDs, Sequences, and CMP
        1. Making It Work
          1. Adapters and session beans
          2. The application exception
          3. The local interface
          4. The home interface
          5. The bean
        2. Deploying the Sequence Bean
        3. Integrating the Changes
      2. Details, Details, Details
        1. The OfficeInfo Class
        2. Modifying the Entity Bean
        3. Leaving Out Details
      3. Data Modeling
        1. Independent and Dependent Data Objects
        2. When Entity Beans Don’t Make Sense
      4. Filling in the Blanks
      5. What’s Next?
    7. 6. Managers
      1. Managers and Entities
        1. Managers as Session Beans
        2. Managers as Java Classes
      2. The LDAPManager Class
        1. Skeletons and Outlines
        2. Naming in Detail
        3. Users
          1. Getting the distinguished name
          2. Adding and deleting
          3. Authenticating the user
        4. Groups
          1. Getting the distinguished name
          2. Adding and deleting
        5. Permissions
          1. Getting the distinguished name
          2. Adding and deleting
        6. Tying It Together
          1. Addition and removal of users
          2. Verification of group memberships
          3. Assignment and revocation of permissions
          4. Verification of permissions
      3. What’s Next?
    8. 7. Completing the Data Layer
      1. Odds and Ends
        1. Connection Sharing
        2. Synchronization
        3. Multiple Directory Servers
        4. Error Reporting
      2. Checkpoint
      3. Populating the Data Stores
      4. What’s Next?
    9. 8. Business Logic
      1. The Façade Pattern
        1. Data Schema Exposure
        2. Performance Penalties
      2. The UserManager
        1. Data Source Transparency
        2. Data Format Transparency
        3. Getting to It
      3. State Design
        1. Starting Stateful
        2. Going Stateless
      4. What’s Next?
    10. 9. Messaging and Packaging
      1. Messaging on the Server
        1. Premise
        2. The EventManager Bean
        3. Business Logic and Messaging Logic
      2. Messaging on the Client
      3. Packaging
        1. Security Roles
        2. Method Permissions
        3. Container Transactions
      4. What’s Next?
    11. 10. Beyond Architecture
      1. Flexibility
        1. Data Modeling Versus Entity Modeling
        2. Single Point of Access
        3. Standardized Access APIs
      2. Decision Point
        1. Web Applications
        2. Web Services
      3. What’s Next?
    12. A. SQL Scripts
      1. The User Store
        1. Cloudscape
        2. InstantDB
        3. MySQL
        4. Oracle
        5. PostgreSQL
      2. The Accounts Store
        1. Cloudscape
        2. InstantDB
        3. MySQL
        4. Oracle
        5. PostgreSQL
      3. Events and Scheduling
        1. Cloudscape
        2. InstantDB
        3. MySQL
        4. Oracle
        5. PostgreSQL
      4. Starting Over
        1. Cloudscape
        2. InstantDB
        3. MySQL
        4. Oracle
        5. PostgreSQL
      5. Primary Keys
        1. Cloudscape
        2. InstantDB
        3. MySQL
        4. Oracle
        5. PostgreSQL
      6. Creating Types
        1. Cloudscape
        2. InstantDB
        3. MySQL
        4. Oracle
        5. PostgreSQL
    13. B. SQL Deployment
      1. Cloudscape
      2. InstantDB
      3. MySQL
      4. Oracle
      5. PostgreSQL
    14. C. Directory Server Setup
      1. iPlanet
        1. Installation
        2. Object Class Hierarchy
          1. The forethoughtPermission object class
          2. The groupOfForethoughtNames object class
        3. Directory Hierarchy
      2. OpenLDAP
        1. Installation
        2. Object Class Hierarchy
          1. The forethoughtPermission object class
          2. The groupOfForethoughtNames object class
        3. Directory Hierarchy
    15. D. Application Server Setup
      1. BEA Weblogic
        1. Configuration
        2. Deployment Descriptors
    16. E. Supplemental Code Listings
      1. Entity Beans
        1. The UserType Bean
        2. The User Bean
        3. The AccountType Bean
        4. The Fund Bean
        5. The Account Bean
        6. The Transaction Bean
        7. The Investment Bean
        8. The Event Bean
        9. Deployment Descriptors
      2. Application Exceptions
        1. Entity Exceptions
    17. Index
    18. Colophon