Rational Application Developer 7.5 Programming Guide - WebSphere Portal v6.1

 

+

Search Tips   |   Advanced Search

 

 

Chapter 1. Introduction

  1. Concepts
  2. IBM Rational Software Delivery Platform
  3. Eclipse and IBM Rational Software Delivery Platform
  4. Eclipse Project
  5. Eclipse Software Developer Kit (SDK)
  6. Application development challenges
  7. Product packaging
  8. Rational Developer supported platforms and databases
  9. Rational Application Developer v7.5 eAssembly
  10. Product tools and features
  11. Tools
  12. Summary of new features in v7.5
  13. Specification versions
  14. Installation and licensing
  15. Installation
  16. Licensing
  17. Updates
  18. Uninstalling
  19. Migration and coexistence
  20. Migration
  21. Compatibility with previous versions
  22. Sample code
  23. Summary

 

Chapter 2. Programming technologies

  1. Desktop applications
  2. Simple desktop applications
  3. Database access
  4. Graphical user interfaces
  5. Extensible Markup Language (XML)
  6. Static Web sites
  7. Hypertext Transfer Protocol (HTTP)
  8. HyperText Markup Language (HTML)
  9. Dynamic Web applications
  10. Simple Web applications
  11. Struts
  12. JavaServer Faces (JSF) and persistence using SDO or JPA
  13. Web 2.0 Development
  14. Portal applications
  15. Enterprise JavaBeans and Java Persistence API (JPA)
  16. EJB 3.0 specification: What is new
  17. Different types of EJBs
  18. Java Persistence API (JPA)
  19. Other EJB and JPA features
  20. Java EE Application Clients
  21. Web services
  22. Interoperatility considerations
  23. Web services in Java EE 5
  24. Messaging systems
  25. Java Message Service (JMS)
  26. Message-driven EJBs (MDBs)
  27. Requirements for the development environment
  28. Summary

 

Chapter 3. Workbench setup and preferences

  1. Workbench basics
  2. Workspace basics
  3. Logging
  4. Preferences
  5. Automatic builds
  6. Manual builds
  7. Capabilities
  8. File associations
  9. Local history
  10. Perspectives preferences
  11. Web Browser preferences
  12. Internet preferences
  13. Java development preferences
  14. Java classpath variables
  15. Appearance of Java elements
  16. Code style and formatting
  17. Java editor settings
  18. Compiler options
  19. Installed JREs
  20. Summary

 

Chapter 4. Perspectives, views, and editors

  1. Integrated development environment (IDE)
  2. Perspectives
  3. Views
  4. Editors
  5. Perspective layout
  6. Switching perspectives
  7. Specifying the default perspective
  8. Organizing and customizing perspectives
  9. Help
  10. Available perspectives
  11. Crystal Reports perspective
  12. CVS Repository Exploring perspective
  13. Data perspective
  14. Database Debug perspective
  15. Database Development perspective
  16. Debug perspective
  17. Java perspective
  18. Java Browsing perspective
  19. Java EE perspective
  20. Java Type Hierarchy perspective
  21. JavaScript perspective
  22. Jazz Administration perspective
  23. JPA perspective
  24. Plug-in Development perspective
  25. Profiling and Logging perspective
  26. Report Design perspective
  27. Requirement perspective
  28. Resource perspective
  29. Team Synchronizing perspective
  30. Test perspective
  31. Web perspective
  32. Work items perspective
  33. Progress view
  34. Summary

 

Chapter 5. Projects

  1. Java Enterprise Edition 5
  2. Enterprise application modules
  3. Web modules
  4. EJB modules
  5. Application Client modules
  6. Resource adapter modules
  7. Java utility libraries
  8. Project basics
  9. Create a new project
  10. Project properties
  11. Deleting projects
  12. Project interchange files
  13. Closing projects
  14. Java EE 5 project types
  15. Enterprise application project
  16. Application client project
  17. Dynamic Web project
  18. EJB project
  19. Connector project
  20. Utility project
  21. Project wizards
  22. Sample projects
  23. Help system samples
  24. Example projects wizard
  25. Summary

 

Chapter 6. RUP, patterns, and SOA

  1. Rational Unified Process
  2. RUP installation in
  3. Process Browser
  4. Process Advisor
  5. Process Search
  6. Process preferences
  7. Patterns
  8. GoF patterns
  9. Architectural patterns
  10. Enterprise patterns
  11. SOA
  12. Services
  13. Web services interoperability
  14. Web Service Business Process Execution Language (WS-BPEL)
  15. Additional information

 

Chapter 7. Unified Modeling Language (UML)

  1. Overview
  2. Constructing and visualizing applications using UML
  3. UML visualization capabilities
  4. Unified Modeling Language
  5. Working with UML class diagrams
  6. Create class diagrams
  7. Create, editing, and viewing Java elements in UML class diagrams
  8. Create, editing, and viewing EJBs in UML class diagrams
  9. Create, editing, and viewing WSDL elements in UML class diagrams
  10. Class diagram preferences
  11. Exploring relationships in applications
  12. Browse diagrams
  13. Topic diagrams
  14. Describing interactions with UML sequence diagrams
  15. Create sequence diagrams
  16. Create lifelines
  17. Create messages
  18. Create combined fragments
  19. Create references to external diagrams
  20. Exploring Java methods by using static method sequence diagrams
  21. Sequence diagram preferences
  22. More information about UML

 

Chapter 8. Develop Java applications

  1. Java perspectives, views, and editor overview
  2. Java perspective
  3. Package Explorer view
  4. Hierarchy view
  5. Outline view
  6. Problems view
  7. Declaration view
  8. Console view
  9. Call Hierarchy view
  10. Java Browsing perspective
  11. Java Type Hierarchy perspective
  12. Develop the ITSO Bank application
  13. ITSO Bank application overview
  14. Packaging structure
  15. Interfaces and classes overview
  16. Interfaces and classes structure
  17. Interface and class fields and getter and setter methods
  18. Interface methods
  19. Class constructors and methods
  20. Class diagram
  21. ITSO Bank application step-by-step development guide
  22. Create a Java project
  23. Create a UML class diagram
  24. Create Java packages
  25. Create Java interfaces
  26. Create Java classes
  27. Create Java attributes (fields) and getter and setter methods
  28. Adding method declarations to an interface
  29. Adding constructors and Java methods to a class
  30. Create relationships between Java types
  31. Implementing the classes and methods
  32. Running the ITSO Bank application
  33. Create a run configuration
  34. Understanding the sample code
  35. Additional features used for Java applications
  36. Use scripting inside the JRE
  37. Analyzing source code
  38. Debugging a Java application
  39. Use the Java scrapbook
  40. Pluggable Java Runtime Environment (JRE)
  41. Exporting Java applications to a JAR file
  42. Running Java applications external to
  43. Import Java resources from a JAR file into a project
  44. Javadoc tooling
  45. Generating Javadoc
  46. Generating Javadoc from an existing project
  47. Generating Javadoc from an Ant script
  48. Generating Javadoc with diagrams from existing tags
  49. Generating Javadoc with diagrams automatically
  50. Java editor and rapid application development
  51. Navigating through the code
  52. Use the Outline view to navigate the code
  53. Use the Package Explorer to navigate the code
  54. Use bookmarks to navigate the code
  55. Source folding
  56. Type hierarchy
  57. Smart insert
  58. Marking occurrences
  59. Smart compilation
  60. Java and file search
  61. Working sets
  62. Quick fix
  63. Quick assist
  64. Content assist
  65. Import generation
  66. Adding constructors
  67. Use the delegate method generator
  68. Refactoring
  69. More information

 

Chapter 9. Accelerating development using patterns

  1. Introduction to pattern implementation
  2. Pattern specification and pattern implementation
  3. Pattern implementation and
  4. Prepare for the sample
  5. Create a pattern implementation
  6. Create a new JET Transform project
  7. Populating the transformation model
  8. Adding and deriving attributes
  9. Generating and editing templates
  10. Applying the pattern
  11. Facade pattern
  12. Import the facade example
  13. Facade transformation
  14. Running the transformation examples
  15. More information

 

Chapter 10. Develop XML applications

  1. XML overview and associated technologies
  2. XML processors
  3. DTDs and XML schemas
  4. XSL
  5. XML namespaces
  6. XPath
  7. XML tools
  8. Create an XML schema
  9. Generating HTML documentation from an XML schema file
  10. Generating an XML file from an XML schema
  11. Editing an XML file
  12. Working with XSL transformation files
  13. Transforming an XML file into an HTML file
  14. XML mapping
  15. Generating JavaBeans from an XML schema
  16. Service Data Objects and XML
  17. Loading an SDO data graph from XML
  18. Navigating the SDO data graph
  19. Updating the SDO data graph
  20. More information

 

Chapter 11. Develop database applications

  1. Introduction
  2. Connecting to the ITSOBANK database
  3. Connecting to databases
  4. Create a connection to the ITSOBANK database
  5. Browsing a database with the Data Source Explorer
  6. Create SQL statements
  7. Create a Data Development project
  8. Populating the transactions table
  9. Create a select statement
  10. Running the SQL query
  11. Develop Java stored procedures
  12. Create a Java stored procedure
  13. Deploying a Java stored procedure
  14. Running the stored procedure
  15. Develop SQLJ applications
  16. Create SQLJ files
  17. Examining the generated SQLJ file
  18. Testing the SQLJ program
  19. Data modeling
  20. Create a Data Design project
  21. Create a physical data model
  22. Modeling with diagrams
  23. Generating DDL from physical data model and deploy
  24. Analyzing the data model
  25. More information

 

Chapter 12. Persistence using the Java Persistence API (JPA)

  1. Introducing the Java Persistence API
  2. Entities
  3. Mapping the table and columns
  4. Relationships
  5. Entity inheritance
  6. Persistence units
  7. Object-relational mapping through orm.xml
  8. Persistence provider
  9. Entity manager
  10. JPA query language
  11. Develop JPA entities
  12. Set up the ITSOBANK database
  13. Create a JPA project
  14. Generating JPA entities from database tables
  15. Generated JPA entities
  16. Adding business logic
  17. Adding named queries
  18. Visualizing JPA entities
  19. Testing JPA entities
  20. Create the Java project for entity testing
  21. Create a Java class for entity testing
  22. Set up the build path for OpenJPA
  23. Set up the persistence.xml file
  24. Create the test
  25. Running the JPA entity test
  26. Displaying the SQL statements
  27. Adding inheritance
  28. Preparing the entities for deployment in the server
  29. Summary
  30. More information

 

Chapter 13. Develop Web applications using JSPs and servlets

  1. Introduction to Java EE Web applications
  2. Java EE applications
  3. Model-view-controller (MVC) pattern
  4. Web development tooling
  5. Web perspective and views
  6. Web Site Navigation Designer
  7. Web Diagram
  8. Page Designer
  9. Page templates
  10. CSS Designer
  11. Security Editor
  12. File creation wizards
  13. Summary of new features in v7.5
  14. RedBank application design
  15. Model
  16. View layer
  17. Controller layer
  18. Implementing the RedBank application
  19. Create the Web project
  20. Import the Java RedBank model
  21. Defining the Web site navigation and appearance
  22. Create frameset pages
  23. Customizing frameset Web page areas
  24. Customizing a style sheet
  25. Verify the site navigation and page templates
  26. Develop the static Web resources
  27. Develop the dynamic Web resources
  28. Working with JSPs
  29. Web application testing
  30. Prerequisites to run the sample Web application
  31. Running the sample Web application
  32. Verify the RedBank Web application
  33. RedBank Web application conclusion
  34. More information

 

Chapter 14. Develop EJB applications

  1. Introduction to Enterprise JavaBeans
  2. EJB 3.0 specification
  3. EJB 3.0 simplified model
  4. EJB types and their definition
  5. Best practices for developing session EJBs
  6. Message-driven EJBs
  7. Web services
  8. Life cycle events
  9. Interceptors
  10. Dependency injection
  11. Use deployment descriptors
  12. EJB 3.0 application packaging
  13. EJB features in v7.5
  14. Sample application overview
  15. Preparing for the sample
  16. Required software
  17. Enable the EJB development capability
  18. Create and configuring the EJB projects
  19. Create an EJB project
  20. Make the JPA entities available to the EJB project
  21. Set up the ITSOBANK database
  22. Configure the data source for the ITSOBANK
  23. Develop an EJB application
  24. Implementing the session facade
  25. Preparing an exception
  26. Create the EJBBank session bean
  27. Defining the business interface
  28. Completing the session bean
  29. Testing the session EJB and the entities
  30. Testing with the Universal Test Client
  31. Create a test Web application
  32. Visualizing the test application
  33. Writing an EJB 3.0 Web application
  34. Implementing the RAD75EJBWeb application
  35. Running the Web application
  36. Cleanup
  37. Adding a remote interface
  38. Complete EJB application interchange files
  39. More information

 

Chapter 15. Develop Web applications using Struts

  1. Introduction to Struts
  2. Model-view-controller (MVC) pattern with Struts
  3. Support for Struts
  4. Preparing for the sample application
  5. Set up the sample database
  6. Configure the data source in the WebSphere Server v7.0
  7. Activating Struts development capabilities
  8. ITSO Bank Struts Web application overview
  9. Create a Dynamic Web project with Struts support
  10. Develop a Web application using Struts
  11. Create the Struts components
  12. Realizing the Struts components
  13. Modifying application resources
  14. Use the Struts validation framework
  15. Page Designer and the Struts tag library
  16. Completing the logon action
  17. Use the Struts Configuration Editor
  18. Completing the application
  19. Completing the Web Diagram
  20. Completing the application resources
  21. Completing the form beans
  22. Completing the actions
  23. Completing the JSPs
  24. Completing the Web Diagram and Struts configuration file
  25. Studying the sample code
  26. Running the Struts Web application
  27. Develop a Struts Web application using Tiles
  28. Enable the Struts Tiles support
  29. Building the Tiles application extension
  30. Running the Tiles application
  31. Import the final sample application
  32. More information

 

Chapter 16. Develop Web applications using JSF

  1. Introduction to JSF
  2. JavaServer Faces (JSF) overview
  3. JSF features and benefits
  4. Preparing for the sample JSF application
  5. Set up the sample database
  6. Configure the data source
  7. Develop a Web application using JSF and JPA
  8. Project setup
  9. Structure of the JSF Web application
  10. Editing the Faces JSP pages
  11. Editing the login page
  12. Create a JPA manager bean
  13. Editing the customer details page
  14. Editing the account details page
  15. Adding navigation between the pages
  16. Implementing deposit and withdraw
  17. Running the JSF application
  18. Web Diagram
  19. Drop-down menu for customer login
  20. Adding a deluxe pager
  21. Use the data source in the server
  22. Cleanup
  23. Final code
  24. More information about JSF and AJAX

 

Chapter 17. Develop Java EE application clients

  1. Introduction to Java EE application clients
  2. Overview of the sample application
  3. Preparing for the sample application
  4. Import the base EJB enterprise application sample
  5. Set up the sample database
  6. Configure the data source
  7. Testing the imported code
  8. Develop the Java EE Application Client
  9. Create the Java EE application client projects
  10. Configure the Java EE application client projects
  11. Import the graphical user interface and control classes
  12. Create the BankDesktopController class
  13. Completing the BankDesktopController class
  14. Create an EJB reference and binding
  15. Registering the BankDesktopController class as the main class
  16. Testing the Java EE Application Client
  17. Packaging the Java EE Application Client
  18. Packaging the application
  19. Running the deployed application client

 

Chapter 18. Develop Web services applications

  1. Introduction to Web services
  2. Service-oriented architecture (SOA)
  3. Web services as an SOA implementation
  4. Related Web services standards
  5. JAX-WS programming model
  6. Better platform independence for Java applications
  7. Annotations
  8. Invoking Web services asynchronously
  9. Data binding with JAXB 2.0 and 2.1
  10. Dynamic and static clients
  11. MTOM support
  12. Multiple payload structures
  13. SOAP 1.2 support
  14. Web services development approaches
  15. Web services tools in
  16. Create a Web service from existing resources
  17. Create a skeleton Web service
  18. Client development
  19. Testing tools for Web services
  20. Preparing for the samples
  21. Import the sample
  22. Testing the application
  23. Create bottom-up Web services from a JavaBean
  24. Create a Web service using annotations
  25. Create Web services using the Web Service wizard
  26. Resources generated by the Web Service wizard
  27. Create a synchronous Web service JSP client
  28. Generating and testing the Web Service client
  29. Resources generated by the Web Service client wizard
  30. Create a Web service JavaServer Faces client
  31. Create a Web service thin client
  32. Create asynchronous Web service clients
  33. Polling client
  34. Callback client
  35. Asynchronous message exchange client
  36. Create Web services from an EJB
  37. Create a top-down Web service from a WSDL
  38. Designing the WSDL using the WSDL editor
  39. Generating the skeleton JavaBean Web service
  40. Testing the generated Web service
  41. Create Web services with Ant tasks
  42. Creation procedure
  43. Running the Web service Ant task
  44. Sending binary data using MTOM
  45. Create a Web service project and import the WSDL
  46. Generating the Web service and client
  47. Implementing the JavaBean skeleton
  48. Testing and monitoring the MTOM enabled Web service
  49. Enable MTOM on the client
  50. Web services security
  51. Authentication
  52. Message integrity
  53. Message confidentiality
  54. Policy set
  55. Applying WS-Security to a Web service and client
  56. WS-I Reliable Secure Profile
  57. WS-Policy
  58. Configure a service provider to share its policy configuration
  59. Configure the client.policy using a service provider policy
  60. WS-MetadataExchange (WS-MEX)
  61. More information

 

Chapter 19. Develop Web applications using Web 2.0

  1. Introduction to Web 2.0
  2. Web 2.0 definition
  3. Web 2.0 application architecture
  4. Supporting technologies
  5. Web 2.0 features in v7.5
  6. Preparing for the sample application
  7. Set up the sample database
  8. Create a database connection
  9. Configure the data source
  10. Develop in Web 2.0 using JSF, Ajax Proxy, and JPA
  11. Project setup
  12. Structure of the Web 2.0 sample application
  13. Adding type-ahead control to the login page
  14. Adding Ajax refresh submit behavior
  15. Cleanup
  16. Develop a Web 2.0 application using Dojo and RPC
  17. Project setup
  18. Architecture of the Web 2.0 application
  19. Exposing an RPC Adapter service
  20. RPC Adapter Configuration Editor
  21. Create an RPC Converter
  22. Create a service using a servlet
  23. Testing the services
  24. Create the Web page
  25. Examining the Dojo components
  26. Application flow
  27. Logging
  28. Running the application
  29. Cleanup
  30. Final code
  31. More information about Web 2.0 technologies

 

Chapter 20. Develop applications to connect to enterprise information systems

  1. Introduction to Java EE Connector Architecture
  2. System contracts
  3. Resource adapter
  4. Common Client Interface
  5. WebSphere Adapters
  6. Application development for EIS
  7. Importers
  8. J2C wizards
  9. What is new in v7.5
  10. Tooling for WebSphere Adapters
  11. Deployment of WebSphere Adapters to WebSphere Application Server
  12. J2C Java bean deployment: EJB 2.1 and 3.0 support
  13. J2C Java bean deployment: Web services support
  14. CICS container link support
  15. MFS support for IMS
  16. Sample application overview
  17. CICS outbound scenario
  18. Prerequisites
  19. Create the Java data binding class
  20. Create the J2C bean
  21. Deploying the J2C bean as an EJB 3.0 session bean
  22. Generating a JSF client
  23. Running the JSF client
  24. CICS channel outbound scenario
  25. Create the Java data binding for the channel and containers
  26. Create the J2C bean that accesses the channel
  27. Develop a Web service to invoke the COBOL program
  28. Testing the Web service with CICS access
  29. SAP outbound scenario
  30. Required software and configuration
  31. Create a Connector Project and J2C bean
  32. Generating the sample Web application
  33. Testing the Web application
  34. More information

 

Chapter 21. Develop portal applications - Concepts

  1. Introduction to portal technology
  2. Portal concepts and definitions
  3. Portal page
  4. Portlet
  5. Portlet application
  6. Portlet states
  7. Portlet modes
  8. Portlet events
  9. IBM WebSphere Portal
  10. Portal and portlet development features
  11. Portal test environments
  12. JSR 168 vs. JSR 286 vs. IBM

 

Chapter 21a. Develop portal applications

  1. Enable the portal development capability
  2. Set up the Portal test environment
  3. Portal samples and tutorials
  4. New Portal Project wizard
  5. Portal Import wizard
  6. Portal Designer
  7. Skin and Theme Editing
  8. Theme editing support
  9. Create portal pages using static page aggregation
  10. Create user friendly URLs
  11. Client side click-to-action support
  12. Person tagging support
  13. JSR 286 new PDD editor
  14. Public render parameters
  15. Ajax proxy support


Develop eventing portlets

  1. Overview
  2. Project setup

 

Chapter 22. Servers and server configuration

  1. Introduction to server configurations
  2. Application servers supported by Rational 7.5
  3. Local and remote test environments
  4. Understanding WebSphere Application Server v7.0 profiles
  5. Types of profiles
  6. Use the profiles
  7. WebSphere Application Server v7.0 installation
  8. Use WebSphere Application Server v7.0 profiles
  9. Create a new profile using the WebSphere Profile wizard
  10. Verify the new WebSphere profile
  11. Deleting a WebSphere profile
  12. Defining the new server in
  13. Customizing a server
  14. Sharing a WebSphere profile between developers
  15. Defining a server for each workspace
  16. Adding and removing applications to and from a server
  17. Adding an application to the server
  18. Removing an application from a server
  19. Configure application and server resources
  20. Create a data source in the enhanced EAR
  21. Set substitution variable
  22. Configure server resources
  23. Configure security
  24. Configure security in the server
  25. Configure security in the Workbench
  26. Develop automation scripts
  27. Create a Jython project
  28. Create Jython script files
  29. Editing Jython script files
  30. Running administrative script files on WebSphere Application Server
  31. Generating WebSphere admin commands for Jython scripts
  32. Debugging Jython scripts
  33. Jython script for application deployment
  34. More information

 

Chapter 23. Testing using JUnit

  1. Introduction to application testing
  2. Test concepts
  3. Test phases
  4. Test environments
  5. Calibration
  6. Test case execution and recording results
  7. Benefits of unit and component testing
  8. Benefits of testing frameworks
  9. Test & Performance Tools Platform (TPTP)
  10. JUnit testing without TPTP
  11. JUnit fundamentals
  12. What is new in JUnit 4.x
  13. Prepare the JUnit sample
  14. Create a JUnit test case
  15. Create a JUnit test suite
  16. Running the JUnit test case or JUnit test suite
  17. JUnit testing of JPA entities
  18. Preparing the JPA unit testing sample
  19. Set up the ITSOBANK database
  20. Configure the RAD75JUnit project
  21. Create a JUnit test case for a JPA entity
  22. Set up the persistence.xml file
  23. Running the JPA unit test
  24. JUnit testing using TPTP
  25. Create the TPTP JUnit sample
  26. Running the TPTP JUnit test
  27. Analyzing the test results
  28. Web application testing
  29. Preparing for the sample
  30. Recording a test
  31. Editing the test
  32. Generating an executable test
  33. Running the test
  34. Analyzing the test results
  35. Generating test reports
  36. Cleaning the workspace

 

Chapter 24. Debugging local and remote applications

  1. Summary of new features in v7.5
  2. Overview of debugging tools
  3. Supported languages and environments
  4. Basic Java debugging features
  5. XSLT debugging
  6. Remote debugging
  7. Stored procedure debugging for DB2 V9
  8. Collaborative debugging using Rational Team Concert Client
  9. Debugging a Web application on a local server
  10. Import the sample application
  11. Running the sample application in debug mode
  12. Set breakpoints in a Java class
  13. Debug perspective
  14. Watching variables
  15. Evaluating and watching expressions
  16. Use the Display view
  17. Working with breakpoints
  18. Set breakpoints in a JSP
  19. Debugging a JSP
  20. Debugging a Web application on a remote server
  21. Exporting the RedBank as an EAR file
  22. Deploying the RedBank application
  23. Configure debug on a remote WebSphere Application Server
  24. Attaching to the remote server in
  25. Debugging a remote application
  26. Uninstalling the remote application
  27. Jython debugger
  28. Considerations for the Jython debugger
  29. Debugging a sample Jython script
  30. Debug extension for Rational Team Concert Client (Team Debug)
  31. Introduction
  32. Supported environments
  33. Prerequisites
  34. Sharing a Java debug session by transferring it to another user
  35. Sharing a WebSphere Application Server debug session
  36. More information

 

Chapter 25. Building applications with Ant

  1. Introduction to Ant
  2. Ant build files
  3. Ant tasks
  4. Ant features in
  5. Preparing for the sample
  6. Create a build file
  7. Project definition
  8. Global properties
  9. Building targets
  10. Content assist
  11. Code snippets
  12. Formatting an Ant script
  13. Defining the format of an Ant script
  14. Problems view
  15. Building a simple Java application
  16. Running Ant
  17. Ant console
  18. Rerun Ant
  19. Forced build
  20. Classpath problem
  21. Running the sample application to verify the Ant build
  22. Building a Java EE application
  23. Java EE application deployment packaging
  24. Preparing for the sample
  25. Create the build script
  26. Running the Ant Java EE application build
  27. Running Ant outside of
  28. Preparing for the headless build
  29. Running the headless Ant build script
  30. Use the Rational Build Utility
  31. Overview of the build utility
  32. Example of using the build utility
  33. More information about Ant

 

Chapter 26. Deploying enterprise applications

  1. Introduction to application deployment
  2. Common deployment considerations
  3. Java EE application components and deployment modules
  4. Deployment descriptors
  5. WebSphere deployment architecture
  6. Java and WebSphere class loader
  7. Preparing for the deployment of the EJB application
  8. Reviewing the deployment scenarios
  9. Install the prerequisite software
  10. Import the sample application project interchange files
  11. Sample database
  12. Packaging the application for deployment
  13. Removing the enhanced EAR data source
  14. Generating the deploy code
  15. Exporting the EAR files
  16. Manual deployment of enterprise applications
  17. Configure the data source in the application server
  18. Install the enterprise applications
  19. Starting the enterprise applications
  20. Verify the application after manual installation
  21. Uninstalling the application
  22. Automated deployment using Jython based wsadmin scripting
  23. Overview of wsadmin
  24. Overview of Jython
  25. Develop a Jython script to deploy the ITSO Bank
  26. Executing the Jython script
  27. Verify the application after automatic installation
  28. Generation Jython source code for wsadmin commands
  29. More information

 

Chapter 27. Profiling applications

  1. Introduction to profiling
  2. Profiling features
  3. Profiling architecture
  4. Profiling and Logging perspective
  5. Preparing for the profiling sample
  6. Prerequisite software installation
  7. Enable the Profiling and Logging capability
  8. Profiling a Java application
  9. Import the sample project interchange file
  10. Create a profiling configuration
  11. Running the EntityTester application
  12. Analyzing profiling data
  13. Execution statistics
  14. Execution flow
  15. UML sequence diagrams
  16. Memory statistics
  17. Thread analysis
  18. Reports
  19. Clean up
  20. Profiling a Web application running on the server
  21. Import the sample project interchange file
  22. Publishing and running sample application
  23. Starting the server in profiling mode
  24. Profile on server: Execution Time Analysis
  25. Running the sample application to collect profiling data
  26. Statistic views
  27. Execution statistics
  28. Execution flow
  29. UML sequence diagrams
  30. Refreshing the views and resetting data
  31. Ending the profiling session
  32. Profile on server: Memory and thread analysis
  33. More information

 

Chapter 28. CVS integration

  1. Introduction to CVS
  2. CVS features
  3. CVS support within
  4. CVSNT Server installation and implementation
  5. Install the CVS server
  6. Configure the CVS server repository
  7. Create the Windows users and groups used by CVS
  8. Verify the CVSNT installation
  9. Create CVS users
  10. CVS client configuration for
  11. Configure the CVS team capability
  12. Accessing the CVS repository
  13. Configure CVS in
  14. Label decorations
  15. File content
  16. Ignored resources
  17. CVS-specific settings
  18. CVS keyword substitution
  19. Development scenario
  20. Create and sharing the project (step 1 - cvsuser1)
  21. Adding a shared project to the workspace (step 2a - cvsuser2)
  22. Modifying the servlet (step 2b - cvsuser1)
  23. Synchronizing with the repository (step 3a - cvsuser1)
  24. Synchronizing with the repository (step 3b - cvsuser2)
  25. Parallel development (step 4 - cvsuser1 and cvsuser2)
  26. Create a version (step 5 - cvsuser1)
  27. CVS resource history
  28. Comparisons in CVS
  29. Comparing a workspace file with the repository
  30. Comparing two revisions in the repository
  31. Annotations in CVS
  32. Branches in CVS
  33. Branching
  34. Merging
  35. Working with patches
  36. Disconnecting a project
  37. Team Synchronizing perspective
  38. Custom configuration of resource synchronization
  39. Schedule synchronization
  40. More information

 

Chapter 29. Rational Team Concert

  1. Introduction to IBM Rational Team Concert
  2. Editions
  3. Architecture
  4. Getting started: Set up a project area
  5. Create a repository connection and project area
  6. Predefined work items: Defining team members
  7. Predefined work items: Defining iterations and iteration plans
  8. Process configuration: Defining preconditions
  9. New work item: Create components
  10. Create a repository workspace
  11. Set up team areas
  12. Source control scenarios
  13. Sharing existing projects
  14. Connecting to the repository and loading projects
  15. Managing conflicts
  16. Building with Team Concert and the Build Utility
  17. Create a build user
  18. Create a repository workspace owned by the build user
  19. Starting the Jazz Build Engine
  20. Preparing the Ant build file
  21. Create a build engine and a build definition
  22. Requesting a build
  23. Running reports (Standard edition only)
  24. Collaborative debugging
  25. More information

  26. Appendix A. Product installation

  27. Appendix B. Additional material and sample code

  28. Abbreviations and acronyms
  29. Related publications
  30. IBM Redbooks publications
  31. Other publications
  32. Online resources
  33. How to get IBM Redbooks publications
  34. Help from IBM