WebSphere Application Server - Express: A Development Example for New Developers

WebSphere Application Server - Express: A Development Example for New Developers

by Moore William, Mark Buensalido, Gwendolyn Gaumond, Bo Gong, Ilaria Gorla, Doug Grove, Stelios Psarras, Pasi Valjus, Ryan Karchner
Released November 2003
Publisher(s): IBM Redbooks
ISBN: None

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to live online training experiences, plus books, videos, and digital content from O’Reilly and nearly 200 trusted publishing partners.

Start your free trial

Book description

This IBM Redbooks publication is a practical guide to developing Web applications using WebSphere Studio. WebSphere Studio is used to develop a sample Web application targeted to the WebSphere Application Server - Express runtime platform. It implements a sample scenario based on realistic requirements for small and medium customers, and provides an end-to-end guide for the development of this scenario.

The book focuses on describing a simple process that allows non technical readers to understand and participate in the development of Web applications using WebSphere Studio .

Part 1 of the book is an overview of the Web application development process and the tools available within WebSphere Studio.

Part 2 describes the requirements and design of a sample application and details the process, architecture, and tools used to develop that sample. It is a detailed explanation of the steps needed to build the sample application. This illustrates how to achieve areas of functionality commonly found in dynamic Web applications, and provides worked examples that new developers can use in their own applications.

Please note that the additional material referenced in the text is not available from IBM.

Table of contents

  1. Notices
    1. Trademarks
  2. Preface
    1. The team that wrote this redbook
    2. Become a published author
    3. Comments welcome
  3. Part 1: The development process
    1. Chapter 1: Introduction
      1. Our objectives
        1. WebSphere Application Server - Express defined
      2. The focus of this redbook
        1. WebSphere Application Server - Express users
        2. Application stages
      3. How to use this redbook
    2. Chapter 2: Getting started
      1. The WebSphere platform (1/2)
      2. The WebSphere platform (2/2)
        1. Application servers
        2. Development environment
        3. Which studio do I use for which server?
        4. What if I have an iSeries?
      3. What is WebSphere Application Server - Express
        1. Simple to install and administer
        2. Simplifies enterprise-class tools and technologies
        3. Easy migration path to other servers in the family
        4. Summary of features
        5. What can I do with WebSphere Application Server - Express?
      4. Architecture and components
        1. Web container
      5. Key technologies
        1. Java 2 Platform, Enterprise Edition
        2. Java Database Connectivity
        3. XML
        4. Jakarta
    3. Chapter 3: Development tools
      1. WebSphere Application Server - Express, V5.0
        1. WebSphere Application Server - Express components
        2. Deploying WebSphere Application Server - Express
        3. Eclipse technology
        4. WebSphere Application Server - Express tooling
        5. WebSphere Studio
        6. Express Application Server: Overview
      2. Information road map
        1. Installation
        2. Migration
        3. Application development
      3. Using WebSphere Studio (1/3)
      4. Using WebSphere Studio (2/3)
      5. Using WebSphere Studio (3/3)
        1. Perspectives
        2. Editors
        3. Customizing perspectives
        4. Using fast views
        5. Setting perspective preferences
        6. The workspace
        7. Recovering files from their local history
        8. Finding help
      6. Struts (1/5)
      7. Struts (2/5)
      8. Struts (3/5)
      9. Struts (4/5)
      10. Struts (5/5)
        1. Struts overview
        2. Model-View-Controller architecture
        3. WebSphere Studio and Struts
        4. Web applications
        5. Struts details
        6. Why we use Struts
        7. Components of a Struts-based application
        8. Configuration of a Struts-based application
      11. Developing in a team environment (1/3)
      12. Developing in a team environment (2/3)
      13. Developing in a team environment (3/3)
        1. Team environment using WebSphere Studio
        2. What is Concurrent Versions System
        3. Using Concurrent Versions System with WebSphere Studio
        4. Working in a team using CVS
      14. Common development tasks (1/7)
      15. Common development tasks (2/7)
      16. Common development tasks (3/7)
      17. Common development tasks (4/7)
      18. Common development tasks (5/7)
      19. Common development tasks (6/7)
      20. Common development tasks (7/7)
        1. Creating projects in Studio
        2. Create a Java package
        3. Create a folder for Web content
        4. Create a Java class
        5. Required common code
        6. Create a Struts Web diagram
        7. Create an SQL statement
        8. Generate a JavaBean from an SQL statement
    4. Chapter 4: The development process
      1. Development process basics
        1. Definition of a development process
        2. Importance of a development process
        3. Realization of a development process
        4. Development process principles
      2. Starting a project
        1. Understanding your business today
        2. Where do you want to go
        3. An initial roadmap of how to get there
      3. Understanding and planning a project
      4. Building a solution
      5. Project hand-over
      6. RealEstate application architecture
        1. Component-based architecture
        2. Layered design
        3. Package structure
        4. Naming conventions
  4. Part 2: The sample solution
    1. Chapter 5: Requirements
      1. The business problem
        1. Business background
        2. Business problems
      2. Business objectives of the solution
        1. Put company information online
        2. Make all property information available in one place
        3. Communicate with customers online
        4. Benefit internal management
      3. Functional requirements
        1. Who are the application users?
        2. What can each group of users do?
        3. Customer registration
        4. Agents account maintenance
        5. Property search
        6. Customer interest list
        7. Business reports
        8. E-mail communication
        9. Error handling
      4. Summary
    2. Chapter 6: Building a prototype
      1. Introduction to prototypes
        1. Benefits of building a prototype
        2. Before you start building
      2. Tools to use when building a prototype
      3. Creating a prototype to our sample application (1/6)
      4. Creating a prototype to our sample application (2/6)
      5. Creating a prototype to our sample application (3/6)
      6. Creating a prototype to our sample application (4/6)
      7. Creating a prototype to our sample application (5/6)
      8. Creating a prototype to our sample application (6/6)
        1. Create the Web project
        2. Create the menus
        3. Update and use of the CSS file
        4. Create the logo
        5. Search properties
    3. Chapter 7: Application architecture
      1. Overview of the architecture
        1. Component-based development
        2. Layered application design
        3. Usage of design patterns
      2. Component architecture
        1. PropertyCatalog component
        2. News component
        3. E-mail component
        4. InterestList component
        5. Reporting component
        6. User component
        7. Dependencies between the components
      3. Layered architecture
        1. Presentation layer
        2. Controller layer
        3. Business facade layer
        4. Domain layer
        5. Data access layer
    4. Chapter 8: Design and specification
      1. High level design
        1. Screen flows
        2. User management and security
        3. Database operations
        4. User input validation
        5. E-mail
        6. Infrastructure
        7. Design of the managers
      2. Detailed design (1/4)
      3. Detailed design (2/4)
      4. Detailed design (3/4)
      5. Detailed design (4/4)
        1. Core functionality
        2. Presentation
        3. Requests and responses
        4. Database accessors
        5. 8.2.5
        6. Logging
    5. Chapter 9: User registration and security
      1. User management basics
        1. Underlying implementation
      2. User management component specification (1/2)
      3. User management component specification (2/2)
        1. User management component: the actors
        2. What the users can do: The use cases
        3. View user details: UC.ViewUserDetails
        4. Request password: UC.RequestPassword
        5. Register customer: UC.RegisterCustomer
        6. Modify customer details: UC.ModifyCustomerDetails
        7. Log out: UC.Logout
        8. Log in: UC.login
        9. List users: UC.ListUsers
        10. Delete customer details: UC.DeleteCustomerDetails
        11. Dependencies
        12. Interfaces for other components
      4. Building the user management component
        1. Preparing the workspace
        2. Creating the Java packages
        3. Creating the Web section
      5. Strategy
      6. The business layer (manager)
        1. LDAP Implementation
      7. The model layer (DAO)
      8. The domain layer (DTO)
      9. The presentation layer (Struts)
        1. Log in/out
        2. Registration
        3. User details management
        4. Administrative view/modify/delete user details
        5. Password e-mail request
        6. Security and guarding pages
      10. Testing the component
      11. Room for improvement
      12. Summary
    6. Chapter 10: Property catalog
      1. Property catalog component specification
        1. Use cases
        2. Dependencies
        3. Interface
      2. Building the property catalog component (1/12)
      3. Building the property catalog component (2/12)
      4. Building the property catalog component (3/12)
      5. Building the property catalog component (4/12)
      6. Building the property catalog component (5/12)
      7. Building the property catalog component (6/12)
      8. Building the property catalog component (7/12)
      9. Building the property catalog component (8/12)
      10. Building the property catalog component (9/12)
      11. Building the property catalog component (10/12)
      12. Building the property catalog component (11/12)
      13. Building the property catalog component (12/12)
        1. Preparing the workspace
        2. Presentation layer
        3. Controller layer
        4. Business facade layer
        5. Domain layer
        6. Data access layer
        7. Putting everything together
        8. Testing the component
    7. Chapter 11: Interest lists
      1. Interest list basics
        1. What is implemented?
      2. Interest list component specification
        1. Users of the interest list: the actors
        2. What the users can do: the use cases
        3. Show interest list: ILC.ShowInterestList
        4. Add property to interest list: ILC.AddProperty
        5. Update interest list: ILC.UpdateInterestList
        6. Clear interest list: ILC.ClearInterestList
        7. Return to property catalog: ILC.ReturnToPropertyCatalog
        8. Checkout interest list: ILC.CheckoutInterestList
        9. Dependencies
        10. Interfaces for other components
      3. How to work faster and write stable code
        1. Use a component-based development process
        2. Use a layered application framework
      4. Building the interest list component
        1. Preparing the workspace
        2. Creating the Java packages
        3. Creating the Web section
      5. A quick word about the database
      6. Strategy
      7. The business layer (manager)
      8. The model layer (DAO) (1/5)
      9. The model layer (DAO) (2/5)
      10. The model layer (DAO) (3/5)
      11. The model layer (DAO) (4/5)
      12. The model layer (DAO) (5/5)
        1. What needs to be implemented?
        2. Building the DAO revealed
      13. The domain layer (DTO)
      14. The presentation layer (Struts) (1/5)
      15. The presentation layer (Struts) (2/5)
      16. The presentation layer (Struts) (3/5)
      17. The presentation layer (Struts) (4/5)
      18. The presentation layer (Struts) (5/5)
        1. What we need to end up with
        2. Start with our adapter
        3. Create the Struts Web diagram
        4. Create the form bean
        5. Create the action
        6. Create the JSP or Web page node
      19. Testing the component
        1. Add property
        2. Update property
        3. Remove property
        4. Clear list
        5. Checkout list
      20. Room for improvement
      21. Summary
    8. Chapter 12: E-mail
      1. JavaMail API
        1. Protocols
        2. Core classes
        3. Example: Sending an e-mail
      2. Build sample e-mail application (1/2)
      3. Build sample e-mail application (2/2)
        1. Use cases
        2. Business facade layer
        3. Domain layer
      4. Configuring JavaMail resources
      5. Utility tag library mailer
    9. Chapter 13: Administering the catalog
      1. Component specification
        1. Use cases
        2. Dependencies
        3. Interface
      2. Building property catalog administration (1/17)
      3. Building property catalog administration (2/17)
      4. Building property catalog administration (3/17)
      5. Building property catalog administration (4/17)
      6. Building property catalog administration (5/17)
      7. Building property catalog administration (6/17)
      8. Building property catalog administration (7/17)
      9. Building property catalog administration (8/17)
      10. Building property catalog administration (9/17)
      11. Building property catalog administration (10/17)
      12. Building property catalog administration (11/17)
      13. Building property catalog administration (12/17)
      14. Building property catalog administration (13/17)
      15. Building property catalog administration (14/17)
      16. Building property catalog administration (15/17)
      17. Building property catalog administration (16/17)
      18. Building property catalog administration (17/17)
        1. Preparing the workspace
        2. Presentation layer
        3. Controller layer
        4. Business facade layer
        5. Domain layer
        6. Data access layer
        7. Integrate the code
    10. Chapter 14: Building a news component
      1. News component specification
        1. Use cases
        2. Dependencies
        3. Interface
      2. Building the news component (1/8)
      3. Building the news component (2/8)
      4. Building the news component (3/8)
      5. Building the news component (4/8)
      6. Building the news component (5/8)
      7. Building the news component (6/8)
      8. Building the news component (7/8)
      9. Building the news component (8/8)
        1. Preparing the workspace
        2. Presentation layer
        3. Controller layer
        4. Business facade layer
        5. Domain layer
        6. Data access layer
        7. Putting everything together
        8. Testing the news component
    11. Chapter 15: Reporting component
      1. Reporting component specification
        1. Use cases
        2. Dependencies
        3. Interface
      2. Building the reporting component (1/17)
      3. Building the reporting component (2/17)
      4. Building the reporting component (3/17)
      5. Building the reporting component (4/17)
      6. Building the reporting component (5/17)
      7. Building the reporting component (6/17)
      8. Building the reporting component (7/17)
      9. Building the reporting component (8/17)
      10. Building the reporting component (9/17)
      11. Building the reporting component (10/17)
      12. Building the reporting component (11/17)
      13. Building the reporting component (12/17)
      14. Building the reporting component (13/17)
      15. Building the reporting component (14/17)
      16. Building the reporting component (15/17)
      17. Building the reporting component (16/17)
      18. Building the reporting component (17/17)
        1. Preparing the workspace
        2. Presentation layer
        3. Controller layer
        4. Business facade layer
        5. Domain layer
        6. Data access layer
        7. Putting everything together
        8. Testing the reporting component
    12. Appendix A: Deploying the redbook sample code
      1. .Running the database creation script
        1. Verifying the database creation
      2. Setting up the WebSphere Studio workspace (1/2)
      3. Setting up the WebSphere Studio workspace (2/2)
        1. Creating a test server
        2. Configure application properties
        3. LOG4J properties
        4. Testing the sample application
      4. Install on WebSphere Application Server (1/3)
      5. Install on WebSphere Application Server (2/3)
      6. Install on WebSphere Application Server (3/3)
        1. Testing the sample on WebSphere Application Server
    13. Appendix B: Additional material
      1. Locating the Web material
      2. Using the Web material
        1. System requirements for downloading the Web material
        2. How to use the Web material
    14. Abbreviations and acronyms
    15. Related publications
      1. IBM Redbooks
      2. Other publications
      3. Online resources
      4. How to get IBM Redbooks
    16. Index (1/3)
    17. Index (2/3)
    18. Index (3/3)
    19. Back cover

Product information

  • Title: WebSphere Application Server - Express: A Development Example for New Developers
  • Author(s): Moore William, Mark Buensalido, Gwendolyn Gaumond, Bo Gong, Ilaria Gorla, Doug Grove, Stelios Psarras, Pasi Valjus, Ryan Karchner
  • Release date: November 2003
  • Publisher(s): IBM Redbooks
  • ISBN: None