分类：
2007-10-26 00:14:18
Using Eclipse plug-ins to edit, compile, and debug your app
==================
Eclipse is a Java-based, extensible open source development platform. By itself, it is simply a framework and a set of services for building a development environment from plug-in components. Fortunately, Eclipse comes with a standard set of plug-ins, including the Java Development Tools (JDT).
While most users are quite happy to use Eclipse as a Java IDE, its ambitions do not stop there. Eclipse also includes the Plug-in Development Environment (PDE), which is mainly of interest to developers who want to extend Eclipse, since it allows them to build tools that integrate seamlessly with the Eclipse environment. Because everything in Eclipse is a plug-in, all tool developers have a level playing field for offering extensions to Eclipse and providing a consistent, unified integrated development environment for users.
This parity and consistency isn't limited to Java development tools. Although Eclipse is written in the Java language, its use isn't limited to the Java language. For example, plug-ins are available or planned that include support for programming languages like C/C++ and COBOL. The Eclipse framework can also be used as the basis for other types of applications unrelated to software development, such as content management systems.
The premiere example of an Eclipse-based application is the IBM® WebSphere® Studio Workbench, which forms the basis of IBM's family of Java development tools. WebSphere Studio Application Developer, for example, adds support for JSPs, servlets, EJBs, XML, Web services, and database access.
|
Open source software is software released with a license intended to ensure that certain rights are granted to users. The most obvious right, of course, is that the source code must be made available so users are free to modify and redistribute the software. This protection of users' rights is accomplished with a device called a copyleft: the software license claims copyright protection and prohibits distribution unless the user is granted these rights. The copyleft also requires that any re-distributed software be covered by the same license. Since this, in effect, stands the purpose of copyright on its head -- using the copyright to grant rights to the user, rather than reserve them for the developer of the software -- copyleft is often described as "all rights reversed."
Much of the fear, uncertainty, and doubt that has been spread about regarding open source software involves the so-called viral nature of some copyleft licenses -- the idea that if you use open source software as part of a program you develop, you will lose your intellectual property because the license will "infect" the proprietary parts you develop. In other words, the license may require that all software bundled with the open source software, including any newly developed software, must be released under the same license. While this may be true of the most well-known copyleft license, the GNU General Public License (under which Linux®, for example, is released), there are other licenses that provide a better balance between commercial and community concerns.
The Open Software Initiative is a nonprofit organization that explicitly defines what open source means and certifies licenses that meet its criteria. Eclipse is licensed under the OSI-approved Common Public License (CPL) V1.0, which "is intended to facilitate the commercial use of the Program ..." (for the complete text of the Common Public License V1.0, see Resources).
Developers who create plug-ins for Eclipse or who use Eclipse as the basis for a software development application are required to release any Eclipse code that they use or modify under the CPL, but are free to license their own additions in any way they like. Proprietary code bundled with software from Eclipse does not need to be licensed as open source, and the source code does not need to be made available.
Although most developers will not use Eclipse to develop plug-ins or to create new products based on Eclipse, the open source nature of Eclipse is important beyond the mere fact that it makes Eclipse available for free (and despite the fact that a commercial-friendly license means that plug-ins can cost money). Open source encourages innovation and provides incentives for developers, even commercial developers, to contribute code back to the common open source code base. There are a number of reasons for this, but perhaps the most essential is that the more developers contribute to the project, the more valuable the project becomes for everyone. As the project becomes more useful, more developers will use it and create a community around it, like those that have formed around Apache and Linux.
|
The Eclipse.org Consortium manages and directs Eclipse's ongoing development. Created by IBM after reportedly spending $40 million developing Eclipse and releasing it as an open source project, the Eclipse.org Consortium recruited a number of software tool vendors including Borland, Merant, Rational, RedHat, SuSE, TogetherSoft, and QNX. Other companies have since joined, including Hewlett-Packard, Fujitsu, and Sybase. These companies each appoint a representative to a Board of Stewards that determines the direction and scope of the Eclipse project.
At the highest level, the Project Management Committee (PMC) manages the Eclipse project. The project is divided into subprojects and each of these has a leader. Large subprojects are divided into components, and each of these also has a leader. At present, most of these managerial roles are filled by people from the IBM subsidiary that originally developed Eclipse, Object Technology International (OTI), but as an open source project, anyone is welcome to participate. Responsibility for any specific piece is earned by contributing to the project.
Now that we've looked at some of the theory, history, and politics behind Eclipse, let's take a look at the product itself.
|
The first time you open Eclipse, you see the welcome screen.
The Eclipse Workbench consists of several panels known as views, such as the Navigator view at the top left. A collection of panels is called a perspective. The default perspective is the Resource Perspective, which is a basic, generic set of views for managing projects and viewing and editing files in a project.
The Navigator view lets you create, select, and delete projects. The panel to the right of the Navigator is the editor area. Depending on the type of document selected in the Navigator, an appropriate editor window opens here. If Eclipse does not have an appropriate editor registered for a particular document type (for example, a .doc file on a Windows® system), Eclipse will try to open the document using an external editor.
The Outline view, below the Navigator, presents an outline of the document in the editor. The precise nature of this outline depends on the editor and the type of document; for a Java source file, the outline displays any declared classes, attributes, and methods.
The Tasks view gathers information about the project you are working on. This can be information generated by Eclipse, such as compilation errors, or it can be tasks that you add manually.
Most of the other features of the workbench, such as the menu or the toolbar, should be similar to those of familiar applications. One convenient feature is a toolbar of shortcuts to different perspectives that appears on the left side of the screen; these vary dynamically according to context and history. Eclipse also comes with a robust help system that includes user guides for the Eclipse workbench and the included plug-ins such as the Java Development Tools. It is worthwhile to browse through the help files at least once to see the range of available options and to better understand the flow of Eclipse.
To continue this short tour of Eclipse, we'll create a project in the Navigator. Right click in the Navigator view, and then select New > Project. When the New Project dialog box appears, select Java on the left. Standard Eclipse has only one type of Java project, named Java Project. If there were a plug-in installed to supply support for JSPs and servlets, we would see an additional option here for Web applications. For now, select Java Project, enter "Hello" when prompted for the project name, then click Finish.
Next, we'll take a look at the Java perspective. Depending on how you like to manage your screen, you can either change the perspective in the current window by selecting Window > Open Perspective > Java or you can open a new window by selecting Window > New Window and selecting the new perspective.
The Java perspective, as you might expect, has a set of views that are better suited for Java development. One of these includes, as the top left view, a hierarchy containing various Java packages, classes, JARs, and miscellaneous files. This view is the called the Package Explorer. Also notice that the main menu has expanded to include two new menu items: Source and Refactor.
To try out the Java development environment, we'll create and run a Hello World application. Using the Java perspective, right-click on the Hello project, and select New > Class, as shown in Figure 2. In the dialog box that appears, type "Hello" as the class name. Under "Which method stubs would you like to create?" check "public static void main(String[] args)," then Finish.
This will create a .java file with a Hello class and an empty main() method in the editor area as shown in Figure 3. Add the following code to the method (note that the declaration for i has been deliberately omitted):
You'll notice some of the Eclipse editor's features as you type, including syntax checking and code completion. In V2.1 (which I previewed by downloading build M2), when you type an open parenthesis or double quote, Eclipse will provide its partner automatically and place the cursor inside the pair.
In other cases, you can invoke code completion by using Ctrl+Space. Code completion provides a context-sensitive list of suggestions selectable by keyboard or mouse. The suggestions can be a list of methods specific to a particular object, or a code snippet to expand, based on various keywords like for or while.
Syntax checking depends on incremental compilation. As you save your code, it is compiled in the background and checked for syntax errors. By default, syntax errors are underlined in red, and a red dot with a white X appears in the left margin. Other errors are indicated with a light bulb in the editor's left margin; these are problems that the editor might be able to fix for you -- a feature called Quick Fix.
The code above has a light bulb next to the for statement because the declaration for i has been omitted. Double-clicking on the light bulb will bring up a list of suggested fixes. In this case, it will offer to create a class field i, a local variable i, or a method parameter i; clicking on each of these suggestions will display the code that would be generated. Figure 4 shows the list of suggestions and the code it suggests for a local variable.
Double-clicking on the suggestion inserts the code in the proper location in the code.
Once the code compiles without error, you can execute the program by selecting Run from the Eclipse menu. (Note that there is no separate compilation step because compilation takes place as you save the code. If your code has no syntax errors, it's ready to run.) A Launch Configurations dialog box appears, with appropriate defaults; click Run at the bottom right. A new tabbed panel appears in the lower panel (the Console), displaying the program's output as shown in Figure 5.
You can also run the program in the Java debugger. First, set a breakpoint in main() System.out.println() by double-clicking in the gray margin on the left side of the editor view, next to the call to System.out.println(). A blue dot will appear. From the Run menu, select Debug. As described above, a Launch Configurations dialog will appear. Select Run. The perspective will automatically change to the Debug perspective, with a number of interesting new views as shown in Figure 6.
First, notice the Debug view at the top left of the perspective. This view shows the call stack and has a toolbar in the title bar that allows you to control the execution of the program, including buttons to resume, suspend, or terminate the program, step into the next statement, step over the next statement or return from a method.
The panel at the top right contains a number of tabbed views, including Variables, Breakpoints, Expressions, and Display. I've clicked Variables so we can see the current value of i.
You can obtain more information about any of the views with the context-sensitive help: click on the title of the view and press F1.
|
In addition to plug-ins like the JDT for editing, compiling, and debugging applications, plug-ins are available that support the complete development process from modeling, build automation, unit testing, performance testing, version control, and configuration management.
Eclipse comes with a plug-in for working with CVS, the open source Concurrent Versions System for source control. The Team plug-in connects to a CVS server, allowing the members of a development team to work on a set of source code files without stepping on each other's changes. Source control from within Eclipse won't be explored here further because it requires setting up a CVS server, but the capability for supporting a development team, not just stand-alone development, is an important and integral feature of Eclipse.
Third-party plug-ins include:
Version control and configuration management
UML modeling
Graphics
Web development, HTML, XML
Application server integration
For a more complete list of available plug-ins, see Resources.
|
To view an example of a plug-in and see how it integrates with Eclipse, download the popular OMONDO EclipseUML (see Resources); you'll need to register, but the plug-in is free. This plug-in depends on Graphical Editor Framework (GEF), another plug-in for Eclipse. GEF is part of the Tools subproject. To download GEF, go to the Eclipse Web site (see Resources), select Downloads and click the link for the Tools PMC downloads page. Note you will need to download the GEF build recommended by OMONDO (GEF V2.0 for OMONDO V1.0.2).
Once downloaded, a plug-in is usually installed by unzipping the download file and copying its contents to the Eclipse plug-ins directory. In this case, GEF requires that it be unzipped into the Eclipse directory (it automatically goes into the plug-ins directory from there) while EclipseUML requires unzipping directly into the plug-ins subdirectory of the Eclipse directory. To be safe, you might want to unzip each into a temporary directory and copy the directories as appropriate from there. If Eclipse is running, you'll need to stop and restart it for the plug-ins to be recognized.
Once EclipseUML (and GEF) are installed, you can create a class diagram the same way you create a Java class file. In the Java perspective, right click on the Hello project in the Package Explorer and select New > Other from the pop-up menu. There will be a new option for UML in the left panel of the New dialog. The free version of EclipseUML only supports class diagrams, so the only option on the right is UML Class Diagram. Select UML Class Diagram, and type in a name for the class diagram, such as "Hello":
In the editor area, a graphical editor will appear with a blank canvas for a class diagram. There are two ways you can create a class diagram: by reverse-engineering existing code by dragging and dropping a Java file from the Package Explorer onto the class diagram or by using the drawing tools available in the toolbar above the blank diagram. To try out the first method, create a new class called Person (use File > New >Class ) and give it the two private attributes listed below.
/** Person.java
* @author david
*/
public class Person {
private String name;
private Address address;
/**
* Returns the address.
* @return Address
*/
public Address getAddress() {
return address;
}
/**
* Returns the name.
* @return String
*/
public String getName() {
return name;
}
/**
* Sets the address.
* @param address The address to set
*/
public void setAddress(Address address) {
this.address = address;
}
/**
* Sets the name.
* @param name The name to set
*/
public void setName(String name) {
this.name = name;
}
}
|
(I should confess that I only typed in the lines for the name and address attributes. The getter and setter methods were automatically generated through Eclipse by right-clicking on the source code and selecting Source > Generate Getter and Setter from the pop-up menu.)
Save and close Person.java Hello.ucd.
To create a Java class from the UML, click New class on the toolbar at the top of the class diagram window, third button from the left, and click on the class diagram. When the New class wizard opens, type in Address as the class name and click Finish.
You can add attributes to the class by right-clicking on the class name and selecting New > Attribute. In the New attribute dialog box, enter the attribute name, type, and visibility. Add methods by right-clicking on the class name and selecting New > Method.
As you change the diagram, the Source Editor window below the diagram will reflect the changes. Finally, you can diagram the relationship between the classes by clicking on the Association button (fifth from the left) and drawing a line from the Person class to the Address class. This will bring up another dialog box where the association properties can be entered (refer to the EclipseUML help for more information about the required information). The diagram should look something like Figure 9.
This UML plug-in demonstrates several characteristics that are typical of Eclipse plug-ins. First, it shows the tight integration between tools. It is never obvious that there are multiple components at work; the integration with the Eclipse Platform and the JDT are seamless. For example, when the Person class was created, it displayed syntax errors because one of its attributes, Address, was undefined. These went away once the Address class was created in the UML diagram.
Another characteristic is EclipseUML's ability to build on functionality offered by other plug-ins -- in this case, the GEF, which provides tools for developing visual editors.
Yet another characteristic involves the way the EclipseUML plug-in is distributed using several tiers of functionality. The basic plug-in, which supports class diagrams, is free, but more sophisticated versions are available for a fee.
|
The Eclipse Platform is a framework with a powerful set of services that support plug-ins, such as JDT and the Plug-in Development Environment. It consists of several major components: the Platform runtime, Workspace, Workbench, Team Support, and Help.
Platform
The Platform runtime is the kernel that discovers at startup what plug-ins are installed and creates a registry of information about them. To reduce start-up time and resource usage, it does not load any plug-in until it is actually needed. Except for the kernel, everything else is implemented as a plug-in.
Workspace
The Workspace is the plug-in responsible for managing the user's resources. This includes the projects the user creates, the files in those projects, and changes to files and other resources. The Workspace is also responsible for notifying other interested plug-ins about resource changes, such as files that are created, deleted, or changed.
Workbench
The Workbench provides Eclipse with a user interface (UI). It is built using the Standard Widget Toolkit (SWT) -- a nonstandard alternative to Java's Swing/AWT GUI API -- and a higher-level API, JFace, built on top of SWT that provides UI components.
The SWT has proven to be the most controversial part of Eclipse. SWT is more closely mapped to the native graphics capabilities of the underlying operating system than Swing or AWT, which not only makes SWT faster but also allows Java programs to have a look and feel more like native applications. The use of this new GUI API could limit the portability of the Eclipse workbench, but SWT ports for the most popular operating systems are already available.
The use of SWT by Eclipse affects only the portability of Eclipse itself -- not any Java applications built using Eclipse, unless they use SWT instead of Swing/AWT.
Team support
The team support component is responsible for providing support for version control and configuration management. It adds views as necessary to allow the user to interact with whatever version control system (if any) is being used. Most plug-ins do not need to interact with the team support component unless they provide version control services.
Help
The help component parallels the extensibility of the Eclipse Platform itself. In the same way that plug-ins add functionality to Eclipse, help provides an add-on navigation structure that allows tools to add documentation in the form of HTML files.
A critical mass is developing around Eclipse. Major software tool vendors are on board, and the number of open source Eclipse plug-in projects is growing every day.
A portable, extensible, open source framework isn't a new idea, but because of its mature, robust, and elegant design, Eclipse brings a whole new dynamic into play. IBM's release of $40 million worth of world-class software into the open source arena has shaken things up in a way that has not been seen in a long time.
