Why do I think of Eclipse and what is different from Borland JBuilder Foundation?
Level: primary
David Gallardo (David@gallardo.org) Software Consultant September 2004
Many programmers are stepping to Eclipse This increasingly popular open source development environment. This article is written for programmers who are familiar with JBuilder and being considering migrating to Eclipse. This article first compares the Eclipse 3.0 and the free JBuilder X Foundation version and then demonstrates how to implement basic features in Eclipse.
For NetBeans and Intellij IDEA programmers If you are considering moving to Eclipse, please read the David Gallardo on David Gallardo on David Gallardo:
Migrate from NetBeans to Eclipse to migrate from Intellij IDEA to Eclipse, please visit the developerWorks migration topic to get other migration paths based on open standard development.
Eclipse - Open source selection Eclipse is an open source, scalable integrated development environment, has recently attracted many attention of the industry. Eclipse's supporter source continues, and these supporters will be frustrated when there is no other characteristics in other IDEs (such as JBuilder), and these supporters will be frustrated and they want to develop these features. Most of the development software (but not all) work is written code. Regardless of whether an IDE provides much feature, if it only provides basic features, it will not give the programmer too much help. That's why many programmers have long since selecting a simple text editor, but not willing to use IDE.
Interestingly, many earlier users who use Eclipse are migrated from the text editor, not from other IDEs. Of course, this explains why they don't mind the lack of functionality. For many people, this is the first IDE they use, which does not simplify their development tasks. IBM affiliated OTI is a very excellent object-oriented technology company, has spent $ 40 million to develop Eclipse, and then donate it to open source communities.
More interesting questions is whether Eclipse is as good as other than other IDEs. The answer is very determined. First, this depends on what you want to do with it. If you only need basic development, it is not necessary to continue. For coding, debugging, reconstruction, unit testing, etc., Eclipse can match any of the IDE, even better than they. Similar to the free JBuilder X Foundation version, Eclipse also has code complement, code template features, and support for reconstruction, Ant, CVS, and JUnit. In fact, you may find that Eclipse supports many features better than JBuilder. For example, Eclipse has more reconstruction capabilities to better support the merging of local code to CVS servers.
In addition to these basic functions, depending on what characteristics you need, this story is more complicated. One of the advantages of Eclipse is that its source code is open, scalable is very good, can expand many plugins, open source plugins, and business plugins can be used to expand Eclipse. If you need the basic Eclipse IDE, you can usually find the plugin you need. In most cases, you can find a free plugin, at least you can fully implement the features you want - for example, for the development of Web and J2EE, you can usually find this plugin. (See Resources About access, installing and using a plug-in in Structs and web applications.) In addition to the free plugin, you can find a lot of commercial plugins for Eclipse prices. If you only need some of the advanced features, but you can't find a satisfactory free plugin, you can buy these plugins from a third-party vendor without having to buy a complete corporate IDE package, which will be more economical. Due to the popularity and open source characteristics of Eclipse, it has become a sharp knife in the IDE field - hundreds of plugins, both free, and commercial. Accessing the Eclipse plugin home page can find most Eclipse plugins.
Now we must specifically introduce Eclipse 3.0 lack of characteristics when developing, and JBuilder has this feature earlier: Building a visualization tool for user interface. This feature is now being actively developed. Eclipse Visual Editor (VE) Release 0.5 can support AWT / SWING, now available for Eclipse 2.1.x versions, and soon can be used for Eclipse 3.0, Release 1.0, but you may not be available when you read this article. VE 1.0 will provide downloads on the Eclipse website as a stand-alone software, which can also support AWT / SWING, but also support SWT. To learn more about VE, you want to experience VE, please refer to the article in the reference information "Building Guis with the Eclipse Visual Editor."
Starting Experience EclipseECLIPSE is slightly different from other IDE because it introduces a new level of an abstraction of the user interface: perspection (PERSPECTIVE). Eventually you will find that this concept will run through various rich features of Eclipse: it deletes options that have nothing to do with hand tasks, allowing you to focus on what you want to do.
For convenience, we also need to introduce some Eclipse terms. The Eclipse development environment (that is, all content in the Eclipse main window) is called Workbench. In this main window, there are a variety of panels, called views (View), and the view can be displayed in the view, the project's profile information, and the like. Multiple views often stack into a notepad form, and can be selected by tab. In addition to the view, there is also a special panel in the workbench, called editor, which can edit a variety of different types of documents, such as source code.
So far, we have a different description of the Eclipse Workbench and JBuilder is not different. When you perform different tasks (such as coding, debugging, or incorporating the code to the Central Code Base), you can use a special window for this task. These types of tasks are called perspectives. It is very similar to the tab function below the editor in JBuilder, but in Eclipse, the entire workbench can be changed, including the main toolbar and menu. The most basic viewing angle is that the Eclipse is turned off after the initial Welcome screen, which is called a resource perspective, as shown in Figure 1.
Figure 1. Perspective of Eclipse Resource
Similar to JBuilder, the resource perspective in Eclipse also has a tree-oriented view, called a navigator, is located in the upper left corner of the workbench (obviously there is nothing, because we have not created anything), The navigation and association of resources can be achieved. Initially, there are two other views-navigation views below the navigation view, and there is an Outline view under the main editor area.
Eclipse is extremely important for views and editors. One perspective can have multiple views, but only one editor can be, this editor is the focus of the workbench. In general, if you open a file in your editor, then other views reflect information different from this file. If you open a Java file, it is now the Java perspective, then one of the views, that is, Package Explorer will show you the physical location and package hierarchical relationship of the file, and another large-scale view will show the method and properties of the class. . If you have multiple Java files, these views have changed as you switch different files in your editor.
Even if we can easily open a new perspective and switch between these perspectives, it is not necessary to do so, because during your work, the angle will automatically change. (Of course, Eclipse will first trust your consent.) When we create a Java project and debug a Java program, you can see this. Once you are familiar with the use of perspectives, you will find this way of work is so smooth and natural, which can eliminate all UI components that do not adapt to the current task, including toolbar buttons, menus, views, and more. This way, we can find related tools more easily.
Creating a new project in Eclipse To start using Eclipse, you must first create a project. When you use Eclipse for the first time, you will ask you to confirm the location of the Workspace directory (assuming that you are not specified by the command line parameter), if the directory does not exist, Eclipse will create one for you. By default, all your information (including specific information, Java source files, images, etc. required for Eclipse), are saved in subdirectory or folders in this Workspace directory. Each folder in this directory corresponds to a project, which typically contains a separate application, a web application, or other type of component.
Although we recommend you to use this work space in the project, it can organize projects, but Eclipse 3.0 is also introduced to create or specify an existing directory as the project folder outside of the workspace. If you are moving from another IDE, the original IDE may not have a strict restriction of the structure of the directory, and this feature will be extremely useful. If you haven't used Eclipse before, I want to keep up with the trend, I will start using it right away (if you haven't installed Eclipse, please refer to the "Getting Started With the Eclipse Platform" in the reference.) When you run Eclipse, You can see the Welcome screen. This screen boots you open the tutorial and some other interesting information, you can turn this screen reproduce, or you can turn it off by clicking "X" in the top tag; you can also re-adjust from the main menu. This screen.
As shown in Figure 1 above, now you are in the resource perspective. In Eclipse, the method of completing a thing will never use, you can use shortcuts, toolbars, or you can choose through the menu, but in this article, we use the menu. Here, we will create a project with the context menu, as shown below:
In the resource perspective, click Right-click on the Navigator View and select New> Project. Select Java Project in the New Project Wizard. Enter a name for the project, such as "Hello", please note that in the Location section, you can accept the default setting "Create Project in Workspace." Next, in Project Layout. Part, accept the default selection "Use Project Folder As Root for Sources and Class Files". In general, it is best to use a separate directory (usually SRC and BIN), but now in order to simplify the problem, we simply accept the default value. At this time, if you click Next, you will join the class library and other items dependent on this project to ClassPath, but we don't need this, so click Finish. Later, Eclipse will ask, "This Kind of Project Is Associated with the java personpective. Do you want to switch to this personpect"? ", Select the" Remember My Decision "check box, then click Yes.
Now, we have created a project and can create classes. We will create a variant of a standard "Hello, World" program.
Use the right click to click the Hello project and select New> Class. This will open the New Class Wizard. Enter Com.example.Hello as the name of the package. Enter HelloBject as the name of the class. Keep Java.lang.object as the parent class. Confirm that the option is selected to create a settlement of the stub for the main () method. Click Finish. See Figure 2.
Although we recommend using workspace, you can work better, but Eclipse 3.0 is also introduced to create or specify an existing directory as the project folder outside the workspace. This feature is especially useful if you are from not strictly requiring IDE migration of the directory structure.
Figure 2. HelloObject class
After creating this class, you will find some different things. First, some to do items have appeared in the document, which is because we need to customize the templates that generate annotations. These comments are the same as other annotations (such as bookmarks, breakpoints, syntax errors, etc.), pointed out by one symbol on the left box of the editor. Later, you should modify the code template according to the system's instructions, but it is so good now. You should also notice that there is a small box in the right column corresponding to each symbol on the left column. The left box identifies what is visible in the current editor, and the right box shows the contents of the file. If your file is very long, there is an error at the end of the last end, then no matter which part of the file is displayed, the right box will display a small red box at the bottom; click this small box to reach the error. The place.
In addition to the check mark symbol on the leftmost box, there are some small triangles in the right of these tags, like this and JBuilder, which can control the folding of the code.
Figure 3. Code folding and TO-DO item
When you use the codes in Eclipse, you will also notice that there is another column between the annotations and code folding controls on the left box. This column contains some colored horizontal strips that compare the current code with the previous version. This feature is called QuickDiff. You can study yourself later.
Syntax checks and code makeups, we need to add some code so that you can actually be drifted. You will see that Eclipse provides the same features as JBuilder's codeInsight, ClassInsight, and other features to help you write source code.
Add a line of code in the main () method to create a vector named names. Because you have not imported the VECTOR class, at this time, a red box that is like a symbol that has been met, a fork "X" will appear, and a yellow bulb is added. If you are slightly strabism, it may even be mistaken this is the exclamation mark of the golden key used by jbuilder. See Figure 4. )
Figure 4. Question & Quickfix
"X" Of course, there is a problem, but the bulb indicates that Eclipse can provide QuickFix: one or more suggestions to solve this problem. You can click on this bulb or click on the Vector, then press CTRL-1 (Quickfix shortcut). A pop-up menu appears, which lists possible modifications, including: "Import Vector", "Rename In File", "Create Class Vector." You can double-click on the first suggestion to add Eclipse to you. A IMPORT statement.
When confirming that the Vector has been imported, you can enter Names in the next row. At this point you can use the code completion function to increase the appropriate method for Vector Names.
The code function in Eclipse is very similar to JBuilder, but the default state is slow. When you enter the Names, you must wait a few seconds to have a list of method names. (This is because if you are entered soon, Eclipse will try to wait until you are entered. You can change the number of milliseconds that automatically activate the delay by selecting Windows> Preferences> Java> Editor from the main menu.) If you need the system's suggestion And don't want to wait, you can press Ctrl-Space so you can see the list of options immediately. If you have forgotten what the need is the name, then the code is very useful, you don't want to think that PUT () is still add ()?
Of course, what you need is add (), when you select a single parameter version from the list, you will notice that Eclipse has not only completed the name of the method, but also adds two brackets to the beginning and ends, and specifically Draw a green line behind the brackets (similar to the cursor). This green line will often be seen when you enter the code in Eclipse. Although you can ignore it, it seems to have no obvious role, but it is still worth a few minutes to explain. If you write your own code to make a full template (this is very easy in Eclipse), you may use this feature.
Add hard-encoded string "MOE" in the Names Vector. When you enter the first quotation number, Eclipse immediately provides a latter quotation number and blocks the cursor between two quotes and provides an insertion point after the second quotation marks. After the MoE is input, press the Tab key to cross the second quotation mark. The first insertion point after the second parentheses is now reappeared. Press the Tab button again to move to the end of the statement, enter a semicolon.
Similar to this, you can add two names, curly, and larry for the Names Vector. The code at this time is as follows:
Public static void main (String [] args) {
Vector Names = new vector ();
Names.Add ("MoE");
Names.Add ("curly");
Names.Add ("larry");
}
}
One of the best features in the Eclipse code completion mechanism is that it can sense the context in which code is located. Look here, if you enter for, press Ctrl-Space, you can see several options, one of which is iterated on a set of data. Select this option, the iterative code of the Names vector is inserted, as shown in Figure 5.
Figure 5: For cycle iteration on a set of data
Note that the first instance of each identifier joined by Eclipse is surrounded by a frame. If you change one, Eclipse will change every appearance of this identifier. If you change it to i, another instance will also change. The only thing you need to modify here is to enter String, but you can change Element to Name. Pressing Tab and Shift-Tab to switch between each instance. The code after the modification is as follows, which also calls a method for how does not appear.
Iterator i = names.Item (); I.hasnext ();) {
String name = (string) i.next ();
Greet (Name);
}
Next, use Eclipse's Quickfix to generate a method stub, then add code to the stub. The method is to click on GREET and press CTRL-1 as shown below:
Private static void greet (String name) {
System.out.println ("Hello," Name;
}
At this time, there should be no errors in the code. Use the right click to click the editor and select Save from the pop-up menu.
The operation and debugging of the program mentioned before, Eclipse uses the incremental compiler, so it is not necessary to explicitly compile your Java file. When you save a Java file, you will save the compiled class file at the same time. To perform a program, select the Java file from the editor or in Package Explorer, then select Run> Run as> Java Application from the Eclipse main menu. (Note that it is different from the menu options of Run> Run ... The following options will be seen below.) This should generate the following output information in the console view under the editor: Hello, Moe
Hello, Curly
Hello, Larry
The method of running a simple program in the debugger is similar. First, double-click (not click on the JBuilder) to set the breakpoint where the main () method calls GREET (). If you want to set the condition breakpoint (ie, when I == 2 is true for this type of condition, or if the breakpoint stopped after running a specific number of times), you can use the right click to click the breakpoint, then select the BreakPoint property from the context menu. .
To start debug, select Run> Debug As> Java Application from the main menu. Since Eclipse has a debug view, it is more suitable than the Java perspective, so the system will ask if you need to switch to this perspective. Select the "Remember My Decision" option and click Yes. As shown in Figure 6.
Figure 6. DEBUG perspective
You will see that the view in the debug angle is similar to JBuilder, but due to this perspective, the entire Eclipse workbench is specially commissioned, so you don't need to view the variable, call the stack and output terminals and other information. Switch between different tabs.
Also note that the calling stack is displayed in a view called debug (not confusing with the debug view of this view), with the tool button (such as step over, step inTo, etc.) , Can control the process of execution. The reason for these controls and call stacks here is that if you debug more than one program (or multiple instances of a plurality of instances), or this program consists of multiple threads, then you can pass through the calling stack Select different programs or threads to implement control. If you like, you can also start the example programs again without terminating the first instance.
Sometimes you don't want (or can't) simply run the program with methods selected from the Run> Run AS> Java Application menu. If you need to pass the parameters to the program, or choose the virtual machine it run, you should use the Run> Run ... menu item. This will open a dialog for you to set up the running option, as shown in Figure 7.
Figure 7. Java startup configuration
One of the benefits of the perspective of resource perspectives lies that it can make your screen do not fall into confusion. You may have noticed that the class file is not included in the Package Explorer of the Java perspective. Suppose Eclipse can compile your Java file (if you can't tell you), you don't need to do anything, you can complete the build, run, and debugging. But once the above work ends, you have to copy the class file into another directory, or compress, send it to others via email.
One implementation method is performed outside the Eclipse because you know where the Workspace directory is, this directory, and the Hello subdirectory in your project files do not have any specials. But you can also implement the internal Eclipse, and the method is from the main menu to select File> Export. But first, you need to return to the resource perspective, so you can see all files. The simplest switching method is to click the resource perspective button in the upper right corner of the workstore (see Figure 8). Figure 8. Switch back resource perspective
Here you will see some files hidden in the Java perspective, including: class file helloObject.obj and two Eclipse for saving the metadata file of the project information. Project and .classfile. The method of compressed class files is:
Click and select on HelloObject.class. Select File> Export from the main menu. Select ZIP files as export destination and click Next. The next screen should have been compressed; browse or enter the path in the field entitled "To Zip File:", and the name of the compressed file to create, then click Finish.
Refactoring Eclipse is similar to JBuilder, one of the most powerful features is the reconstruction capability of the code. Although Eclipse's reconstruction is more than JBuilder, JBuilder also has one or two Eclipse that does not have characteristics, but both have the most important reconstruction characteristics. For more information on eclipse (and general sense) reconstruction, see "Refactoring for Everyone" listed in the reference.
If you are familiar with the reconstruction in JBuilder, you will find that the reconstruction in Eclipse is also the same, just Eclipse uses a wizard to guide you to complete the reconstruction process. With this wizard, you have the opportunity to use the most powerful comparison dialog in Eclipse to see which changes to Eclipse will make or veto them for each change.
We will quickly introduce a relatively simple reconstruction function: change the signature of the method (Change Method Signature). We will use this feature to change the type of String parameter in the GREET () method of the example program, turn it into Object, and add a parameter for a String type for GREET printing. The implementation method is as follows:
First click on the method name in the editor or outline view, select the GREET () method. Select Refactor> Change Method Signature from the context menu. (See Figure 9) In the table titled Parameters, click the String type and change it to Object. Change the name of the parameter to Object. Click on the right ADD button; this will add a new item in existing parameters. Change its type to String, name Greeting, the default value is "Welcome". We hope that the new Greeting parameter is the first parameter; confirm that it is still the selected parameter, then click the UP button. (You can also select the original parameters, then click the Down button.)
Figure 9. Signature of change method
Like all reconstruction in Eclipse, you will face two options. The first one you can be called "Just Do IT". Usually the reconstruction of Eclipse is correct, only a few cases are wrong, then you can always cancel the reconstruction operation via the Refactor> Undo menu. (This feature is only valid for a period of time after reconstruction. If you change any file, you can't cancel it again.) If you think this is good, you can click OK. Usually this is the easiest way, but it is not. The second choice can be called "I want to micromanage", let's take a look at this interesting option. By clicking Preview, Eclipse will show you a dialog box, you can select a specific change in all affected files at the top of the dialog, then side, and then compare the selected files. (Of course there is only one file in this example.) At this point, you can change the reconstruction of the test will be made one by one, and ratify or reject each change separately. See Figure 10. Select all changes, then click OK.
Figure 10. Source Code Comparison Dialog: Refactance Before and after
The following is the case of the code after reconstruction:
Public static void main (String [] args) {
INT x = 100;
Vector Names = new vector ();
Names.Add ("MoE");
Names.Add ("curly");
Names.Add ("larry");
Iterator i = names.Item (); I.hasnext ();) {
String name = (string) i.next ();
Greet ("Welcome,", NAME;
}
}
/ **
* @Param Greeting Todo
* @Param Object
* /
Private static void greet (String Greeting, Object Object) {
System.out.println ("Hello," Object);
}
It is noted that the reconstruction process is in addition to the change method itself, and the GREET () call in the main () method is also updated, and the first parameter uses the default value "Welcome," ". If there are other files in the project, Greet (), Then change in the same way.
If you are now running this program, the results you get are exactly the same as before, all of which correctly refactors should be done. What we get is printing information, as well as the ability to use different greetings when calling a Greet () method, but the latter requires our own function code, change system.out.println () to the following:
System.out.println (Greeting Object);
We may still want to change the way to print objects later, to print according to the object type. This is easy for a string, but if it is other type, the object first should be converted into a string with the TOSTRING () method of the object. Sometimes the result of doing this is not what we expect.
CVS Although JBuilder and Eclipse support CVS and other version control systems, Eclipse provides a more detailed interface with two independent perspectives. The first is the CVS library browsing perspective, which can choose which CVS library and module, and browse the files included. The second is a group synchronization perspective and can be merged into the library. Although this makes CVS initially difficult to use, this method encourages people to establish an orderly structured workflow.
Another difference is that Eclipse is very strict on the supported CVS library type. First, it does not support local libraries; that is, it cannot directly access the CVS library on the disk, but must be accessed through the client server (especially using the PServer or SSH protocol). Of course, SSH is a recommended protocol because it is more secure than PServer, and the latter is transferred with a clear text. By the way, Eclipse provides a built-in client for these two protocols. At the beginning, you need to access the CVS library and get the information you need to connect to this library. Select Window> Open Perspective> Other from the Eclipse main menu, open the CVS library browse perspective. There are some interesting views in this perspective, but the most important one is above the left, namely the CVS library view. In this right click, select New> Repository Location, then enter the information necessary to connect the CVS server (see Figure 11). You can see that if you use SSH, you need to select the EXTSSH connection type of Eclipse.
Figure 11: Connecting CVS library
You can create a new CVS module from the Eclipse project, as shown below:
Switch to Java or resource perspective. Right click on the project name, select Team> Share Project from the context menu. A dialog will appear in which a dialog box contains options that use the library location. Bel this option, you hare over your previous entered library. Click Next. In the next dialog box, accept the item name as the module name, click Next. In the next dialog, you will preview the content of check-in; if there is no problem, you can click Finish. The last dialog will remind you that you have not submitted change and ask you if you are submitted. Click Yes.
Now, you will be told that six resources are not within the version control. You can answer Yes as needed, but if you want to know what these resources are, you can choose Details first. You will see two Eclipse metadata files: .project, and .classpath, java source file, HelloBject.java, and nested folders that save Java source files (corresponding to their packages): / Hello / COM, / / Hello / Com / Example, and Hello / COM / EXAMPLE / HELLO.
If not, you can choose Yes. Let you enter a comment; enter "Initial Version".
You use these files to or detect CVS and have been in-depth operations, you need to make sure that the changes you do with do not conflict with others, then you can check in; in fact, if there is a conflict, CVS will You are not allowed to check.
There are two ways to resolve conflicts and consolidate the code to the library. The easiest way is to update local files in the CVS library, and the method is to click on your project and then select Team> Update from the context menu. If there is any change, it will be used in the differential format (ie, a large number of increases or deleted tags that are not in the line in the library, and vice versa) automatically merged to the local file. It is very boring that these documents are very boring and it is easy to cause errors.
A better way is to use the group synchronous perspective of Eclipse, which can be displayed in parallel to the changed file, you can preview the changes and accept or reject changes in each file. The implementation method is:
Right click on the project name and select Team> Synchronize with repository from the context menu. The system will notify you that this task is related to the group synchronization perspective and ask if you need to switch to this perspective. Select "Remember My Decision" and click Yes. Like most other perspectives, the first view you want to view is also on the upper left corner of the workbench, here is a synchronization view. The above is a plurality of tool buttons, including incoming mode, outgoing mode, incoming / outgoing mode, and conflicts mode. The selected mode is dependent on the library, and there is a change in the local code, or both. It sounds confusing, but in fact you don't need to care about the details; it is important that it can filter out unnecessary information. You will only see files that need preview, then update source code according to these information libraries.
Suppose you add some code to HelloBject (in order to handle String with other objects), while others detect code, and other modifications (such as modifying the main () method). You may not have to know this, but before checking in your file, you should use the right click to click this file and select Team> Synchronize with repository .... This will open the library synchronous perspective (of course below your license) and compare the files in the local file and the library, as shown in Figure 12.
Figure 12: Merge of the local changes to the code in the library
At this point you can preview each change in each file, you can copy the change to the local file through the Copy Right To Left tool button in the Java source comparison view, or manually edit the local file. When you are satisfied with the mergement results, use the right click on the file name in the synchronization view to select the file from the context menu, and mark the file as a merger.
Once you have solved all conflicts and merge all files in the synchronization view, you should return to the Java view, verify that the item can be built and run, and then check into the code. The method of checking in the code is as follows:
Right click on the project name (if you submit a single file, click the File Name), then select Team> Commit from the Project menu. When the system requires confirmation, enter a comment. (Note that if you check in the entire project, there are multiple files to change, then the comment will apply to all files. If you want to enter a comment separately, you need to check each file separately. )
Conclusion Eclipse 3.0 and Borland's JBuilder X Foundation version have very rich features, both of which provide grammatical check, code prompt, and functionality for encoding automatic generation code, and the two tools also provide Reconstruction, ANT, unit testing, and CVS support. Soon, using AWT / SWING or SWT to build the GUI's Eclipse Visual Editor 1.0 will be released. But there are also important differences between these two tools.
A little important difference is that the Eclipse user interface is designed in the design of the perspective, and performs a specific task to use a set of views, editors, and other UI elements. This simplifies the implementation of the task because the hand is available at any time (and can only use these applicable tools).
Another important difference is that Eclipse is an open source project. This open source feature has attracted many developer communities to develop some plugins for Eclipse, which have both free plugins, and commercial plugins. If you need a certain feature-face-oriented development support, or embedded MP3 player - all can find a free plugin, extending Eclipse to support this feature. Reference
You can see this article in our website on our world. Get a detailed list of Eclipse plugins. The "Eclipse platform entry" written by David Gallardo introduces the history and overview of the Eclipse platform, including how to install Eclipse and its plug-ins. Detailed steps (DeveloperWorks, Sep 2002). About Visual Editor and its technical insider, and Visual Editor 0.5 demonstrations in building AWT / SWING applications, as well as previews for SWT support in Visual Editor 1.0, see "Building a GUI with Eclipse Visual Editor projects" DeveloperWorks, May 2004). Article "Anyone can reconstruct" (September 2003) describes how to use Eclipse automatic reconstruction characteristics and why, also give all reconstructed features in Eclipse 2.1.x and in Eclipse Examples of most reconstructed properties in 3.0 are used. GEOFFREY R. Duck written "Using Eclipse as a development environment of Jakarta Tomcat" (developerWorks, May 2004), introduces how to develop Tomcat applications with Eclipse and Sysdeo Tomcat plugins. These include the steps to install Tomcat and their plugins. Paul Leszek writes "Using the Eclipse platform" (DeveloperWorks, May 2003), the summary describes how to debug programs in Eclipse. "Developing Struts for Eclipse Developing Struts" in Nancy Chen Junhua, "DeveloperWorks, April 2004) describes how to develop Struts programs in ESY Struts plug-in in Eclipse. These include the steps to install Struts and their plugins.
About the author David Gallardo is the author of Studio B, but also an independent software consultant and writer, his expertise is software internationalization, Java web application, and database development. He has been more than 15 years of professional software engineers, and has rich experience in a variety of operating systems, programming languages, and network protocols. Recently, he led database and international development in TradeAccess, Inc. in a B2B e-commerce company. Prior to this, he was a senior engineer of the Lotus Development Corporation China Development Team, dedicated to the development of cross-platform libraries, which provides Unicode and international language support for Lotus products (including Domino). David or Eclipse In Action: A Guide for Java Developers (Manning, 2003) You can contact him through David@gallardo.org.
