Eclipse Kick Start

Introduction.

    Who Should Read This Book.

    How This Book Is Organized.

    Downloading and Installing Eclipse.

    Conventions Used in This Book.

    Source Code for This Book.

I. THE ECLIPSE JAVA DEVELOPMENT ENVIRONMENT.

1. Using the Eclipse Workbench.

    The Workbench.

    Perspectives, Editors, Views, and Natures.

      Perspectives.

      Editors.

      Views.

      Natures.

    The Java Development Tooling (JDT).

      Java Perspective.

      Java Browsing Perspective.

      Java Type Hierarchy Perspective.

      Debug Perspective.

    JDT Preferences.

   Customizing a Perspective.

    In Brief.

2. Writing and Running a Java Application.

    Implementing a Java Application.

      Creating a Project.

      Creating an Interface.

      Creating a Class.

      Creating a JUnit Test.

      Using the Java Editor.

      Customizing the Java Editor.

      Creating a Scrapbook Page.

    Searching for Files, Types, Fields, and Plug-Ins.

    Running a Java Application.

      The Launcher.

      Creating Custom Launchers.

      Launching an Applet.

    In Brief.

3. Debugging.

    Debugging in the Java Development Tooling Environment.

    The Debug Perspective.

    Debugging Standalone Java Code.

    Remote Debugging.

    In Brief.

4. Refactoring.

    Overview.

    Renaming Resources.

      Changing the Signature of an Existing Method.

    Extracting an Interface from a Class.

    Moving Methods to the Superclass.

    Extracting a Method from Existing Code.

    In Brief.

5. Writing GUIs in Eclipse.

    Installing the Visual Editor.

    The Visual Editor.

      Overview.

      Palettes.

    Using the Visual Editor.

    Building a Database Viewer.

    Visual Editor Preferences.

    In Brief.

6. High-Grade Testing Using JUnit.

    Overview.

    The JUnit Framework.

      TestCase.

      TestSuite.

      TestRunner: The JUnit GUI.

    Creating a Test Case.

      Create a Class.

      Create a Test Case.

    Running the Test.

    Creating and Running a Test Suite.

    Custom JUnit Launch Configurations.

    Extensions to JUnit.

      Using a Non-Plug-in-Based JUnit Extension.

    In Brief.

7. Painless Code Sharing Using Team Support.

    Eclipse Support for CVS.

      CVS Perspective.

      Creating a New Repository Entry.

      A Brief Tour of the Various Views.

    Accessing CVS.

      Checking In.

      Checking Out.

      Branching.

    Merging a Branch.

    In Brief.

II. DEVELOPING APPLICATIONS USING PLUG-INS.

8. Finding, Installing, and Using Plug-ins.

    The Eclipse Plug-In Site(s).

    Installing a Plug-In in Two (Maybe Three) Steps.

      Installing Your First Plug-In.

      Installing a Plug-In to an External Location.

      Installing a Plug-In Using the Eclipse Update Manager.

    Displaying and Configuring Plug-Ins.

    In Brief.

9. J2EE and the MyEclipse Plug-In.

    J2EE and Eclipse.

    Downloading and Installing MyEclipse.

    Using MyEclipse to Implement Web Applications.

      Creating Enterprise Application Projects.

      Creating Web Module Projects.

      Implementing and Deploying an EJB Using EJB Module Projects.

    Debugging Servlets, JSPs, and EJBs.

    Exporting the Finished Product.

    In Brief.

10. Developing Web Services Using the IBM Web Services Software Developer Toolkit.

    Web Services Software Development Kit.

    Reviewing Web Services.

    Installing the WSDK Plug-In.

    Creating a Simple Java Bean Web Service.

      Create a New Dynamic Web Project.

      Create a JavaBean Class.

      Create the Web Service.

    IBM-Provided WSDK Examples.

    In Brief.

11. Struts Development Using MyEclipse.

    J2EE, Struts, and Eclipse.

      Struts.

      Finding and Installing MyEclipse and Tomcat.

    Implementing a Web Application Using a Struts Module.

      Implementing CourseSearchAction.

      Adding Global Forwards.

       Replacing Java-Based Forms with DynaActionForm.

      Adding Global Exceptions.

      Configuring a Struts Datasource.

    In Brief.

12. UML Using Omondo.

    UML and Eclipse.

      Understanding the Types of UML Diagrams.

    The Omondo UML Plug-In.

     Using UML to Facilitate Your Design.

      Creating a Use Case Diagram.

      Using a Class Diagram.

      Using a Sequence Diagram.

    Reverse Engineering.

      Viewing Relationships.

    Configuring EclipseUML.

    In Brief.

III. EXTENDING ECLIPSE.

13. The Eclipse Plug-In Architecture.

    Everything Is a Plug-In.

      The Plug-In Architecture.

      The Plug-In Extension Points.

    The Plug-In Developer Environment.

      The Perspective and Its Views.

      Resource Management.

      Workbench UI.

      Debug Support.

      Help System.

    Running a Plug-In from Within Eclipse.

      The Runtime Workbench.

    In Brief.

14. Writing a Trivial (and Not So Trivial) Plug-In.

    The Hello World Console Plug-In.

      Creating a Plug-In Project.

       Running the Plug-In.

      Debugging the Plug-In.

    The Hello World View Plug-In.

      A Plug-In with a View.

      Deploying the Plug-In.

      The Hello World Project Wizard.

    The Hello World Project Type.

    The HelloWorld Wizard.

    The Hello World Preferences Panel.

      Adding to the Preference Dialog.

    In Brief.

15. Implementing a Help Plug-In.

    Extension Points of the Eclipse Help Plug-In.

    Five Ways to Implement a Help Plug-In.

      One Table of Contents File.

      Multiple Table of Contents File.

      Nested Documentation Structures.

      Context-Sensitive Help Using Infopops.

      Active Help.

    In Brief.

IV. APPENDICES.

Appendix A: Navigating Through Eclipse Help.

    Introduction to the Eclipse Help System.

    The Help Window.

      Bookshelf Contents.

      Search.

      Links.

      Bookmarks.

      Working Sets.

    Accessing the Eclipse Help Server Outside of Eclipse.

Appendix B: Setting Up and Running a Local CVS Server.

    Getting a CVS Server for Windows.

    Installing CVSNT.

      Gotchas.

    Configuring CVSNT.

    Registering a Repository.

Appendix C: Running Ant Tasks from Within Eclipse.

    Ant Editor.

    Runtime Ant.

    Ant Preferences.

    The Ant View.

Appendix D: Useful Editors.

    XML.

      Available XML Editors.

      XMLBuddy.

    JavaServer Pages.

      Available JavaServer Pages Editors.

      The MyEclipse JSP Editor.

    Properties Files.

      Available Properties Editors.

      Eclipse Property File GUI Editor.

    In Brief.

Appendix E: Recommended Resources.

    Eclipse Help Documentation.

    Projects and Tutorials.

    UML Tutorials.

    Online Articles.

    Books.

    Plug-Ins Used in This Book.

Index.