Borland® JBuilder™ Developer’s Guide

Table of contents

1. Copyright
2. About the Lead Authors
3. Acknowledgments
4. We Want to Hear from You!
5. Introduction
6. Starting Out—A First Look at JBuilder
   1. Viva Java
      1. From Oak to J2EE—A Brief History of Java
      2. Borland JBuilder, a First Look
      3. What Is Next?
      4. Summary
   2. Exploring JBuilder
      1. The JBuilder Integrated Development Environment
      2. The Main Menu
      3. The Toolbar
      4. In Practice
      5. Summary
   3. Employing the JBuilder Designers
      1. Screen Designer
      2. Writing Event Handlers
      3. Menu Designer
      4. In Practice
      5. Summary
7. JBuilder for Application Design, Modeling, and Testing
   1. Modeling
      1. A “Warp 6” Overview of UML
      2. JBuilder and UML
      3. Design Guidelines—Modeling
      4. In Practice
      5. Summary
   2. Unit Testing
      1. JBuilder Test Options
      2. JUnit Testing Framework
      3. JBuilder Test Runner, Test Cases, and Test Suites
      4. Comparison, JDBC, and JNDI Fixtures
      5. In Practice
      6. Summary
   3. Debugging
      1. Integrated Debugger
      2. Fundamental Debugging
      3. More Debugging Options
      4. In Practice
      5. Summary
   4. Refactoring
      1. What Is Refactoring?
      2. Move Refactor
      3. Rename Refactor
      4. Changing Parameters
      5. Extract Method
      6. Introduce Variable
      7. Optimize Imports
      8. Surround with Try/Catch
      9. In Practice
      10. Summary
   5. Documenting in JBuilder
      1. Adding Comments
      2. Javadoc Tags
      3. Javadoc Provides More than Documentation
      4. Documentation Doesn’t Match Code
      5. Automatic Javadoc Templates
      6. Using the JavaDoc Wizard
      7. Design Guidelines
      8. Summary
   6. Deployment
      1. Java Archive Files
      2. Manifest File
      3. Java Archive Tool
      4. JBuilder’s Archive Builder
      5. Design Guidelines
      6. In Practice
      7. Summary
8. JBuilder for Java Client Applications
   1. AWT
      1. AWT Basics
      2. Applications Versus Applets
      3. Working with AWT Containers
      4. Working with AWT Components
      5. In Practice
      6. Summary
   2. Swing
      1. Why Use Swing Instead of AWT?
      2. Design Guideline—Model View Controller Architecture
      3. Swing Component Hierarchy
      4. Working with Swing in JBuilder
      5. In Practice
      6. Summary
   3. Understanding Layout Managers
      1. Uncovering Layout Managers
      2. Layout Managers Available
      3. Using a Layout Manager
      4. Using the XYLayout Manager
      5. Using the BorderLayout Manager
      6. Using the FlowLayout Manager
      7. Using VerticalFlowLayout
      8. Using the BoxLayout2 Manager
      9. Using the GridLayout Manager
      10. Using the CardLayout Manager
      11. Using the OverlayLayout2 Manager
      12. Using the PaneLayout Manager
      13. Using the GridBagLayout Manager
      14. Creating a Custom Layout Manager
      15. Design Guidelines
      16. In Practice
      17. Summary
   4. Drawing with Java
      1. Java2D API Overview
      2. Rendering Effects
      3. In Practice
      4. Summary
   5. Files, Streams, and Serialization
      1. File Class
      2. Input and Output Streams
      3. Reader and Writer Classes
      4. StreamTokenizer Class
      5. Object Serialization
      6. In Practice
      7. Summary
   6. Database Connectivity
      1. Overview of Databases, SQL, JDBC, and DataExpress
      2. Using the JDBC API
      3. Using JBuilder’s DataExpress
      4. Using Data Modules
      5. In Practice
      6. Summary
9. JBuilder for Web-based Applications
   1. Servlets
      1. What Is a Web Application?
      2. What Are Servlets?
      3. Why Servlets?
      4. The Java Servlet API
      5. Debugging
      6. Deployment
      7. In Practice
      8. Summary
   2. Java Server Pages
      1. Where Do JSPs Fit into a Web Application?
      2. The JSP API
      3. Debugging
      4. Deployment
      5. In Practice
      6. Summary
   3. Tag Libraries
      1. What Is a Tag Library?
      2. Integrating a Tag Library into a Web Application
      3. Tag Library Descriptor (TLD) File
      4. The Custom Tag Library API
      5. Servlet and JSP Development Guidelines
      6. In Practice
      7. Summary
   4. InternetBeans Express
      1. InternetBeans Express in Detail
      2. Using InternetBeans with Servlets
      3. Using InternetBeans Express with JSPs
      4. Design Guidelines
      5. Summary
10. JBuilder for Enterprise Applications
    1. XML
       1. Structured Graphical Markup Language (SGML)
       2. HTML
       3. XML Overview
       4. Using JBuilder’s XML Tools
       5. Design Guidelines
       6. In Practice
       7. Summary
    2. An Architectural Overview of Enterprise JavaBeans
       1. Ancient History or Not So Ancient
       2. Client/Server Saves the Day
       3. Application Servers
       4. Enterprise JavaBeans and Component-based Middleware
       5. Enterprise JavaBeans Goals
       6. How EJB Systems Work
       7. The Enterprise JavaBeans Component
       8. The Enterprise JavaBeans Container
       9. Remote Interface
       10. The Home Interface
       11. Where Do I Get an EJB Object Class?
       12. Enterprise JavaBeans Types
       13. How Does It All Work?
       14. Summary
    3. Developing Session Beans
       1. Session Bean in Detail
       2. Writing a Client
       3. Writing a Session Bean
       4. Design Guidelines
       5. In Practice
       6. Summary
    4. Developing Entity Beans
       1. A Closer Look at Entity Beans
       2. Developing a CMP Bean
       3. Developing a BMP Bean
       4. Advanced Container-Managed Persistence
       5. Transactions
       6. Container Security
       7. Design Guidelines
       8. In Practice
       9. Summary
    5. Message-Driven Beans
       1. Point-to-Point Versus Publish/Subscribe
       2. Writing a Message-Driven Bean
       3. Testing the Message-Driven Bean
       4. Building a Message-Driven Bean with JBuilder
       5. Design Guidelines
       6. In Practice
       7. Summary
    6. CORBA
       1. CORBA Defined
       2. Interface Definition Language (IDL)
       3. Basics of CORBA
       4. Setting Up JBuilder and CORBA
       5. Building a CORBA Server
       6. Building a CORBA Client
       7. In Practice
       8. Summary
    7. Debugging Your Enterprise Application
       1. Remote Debugging Explained
       2. Setting Up the Debugging Environment
       3. Debugging a Remote Application
       4. Cross-Process Breakpoints
       5. Configuration Settings for Application Servers
       6. In Practice
       7. Summary
    8. Development and Deployment for WebLogic and WebSphere
       1. Using WebLogic with JBuilder
       2. Using IBM WebSphere with JBuilder
       3. Summary
    9. Web Services
       1. Simple Object Access Protocol (SOAP)
       2. WSDL Component of Web Services
       3. UDDI Component of Web Services
       4. JBuilder Web Services Toolkit
       5. In Practice
       6. Summary
    10. Using JBuilder with J2ME
        1. Introducing the Micro Edition
        2. JBuilder’s MobileSet Environment
        3. Design Guidelines
        4. In Practice
        5. Summary
    11. Team Development with JBuilder
        1. Why Is Team Development Important?
        2. Design Guideline: Team Structure and Responsibility
        3. Using JBuilder with Version Control Systems
        4. Summary
    12. Struts and JBuilder
        1. Struts Tag Libraries
        2. Building a Struts Application with JBuilder
        3. Design Guidelines
        4. In Practice
        5. Summary
11. Index