Java Programming Forum - Learn Java Programming - Blogs - Eclipse

Working with SVN in Eclipse

Eclipse — Wed, 29 Feb 2012 10:26:49 GMT

In a team work environment, using a version control system has been becoming standard approach to foster collaboration among team members, increase productivity, centralize resources management, reduce risks and development time�Subversion (SVN) is a version control system which is very popular and widely used in software development, and Subclipse is an Eclipse plug-in that supports Subversion within the Eclipses IDE. Subclipse has been widely used to develop Java projects in Eclipse IDE for team-oriented working environments.

This article will walk you from installing to using Subclipse for the most common tasks in terms of team collaboration. The version of Eclipse IDE targeted in this article is 3.7 � Indigo for Java EE developers.

A brief overview about Subclipse

Subclipse is an open-source Eclipse plug-in that supports working with Subversion servers within Eclipse IDE. It allows many developers working together on a project at the same time and synchronizing their work through a set of perspectives, views and functionalities. The project is managed by CollabNet, Inc � the firm started to develop Subversion as a replacement for CVS. Its home page can be touch at: http://subclipse.tigris.org/. The latest version is 1.8.5 and it is working with Eclipse versions from 3.2 or higher. Subclipse can be installed from its update site via Eclipse�s Install New Software feature, or can be downloaded separately from its website to be installed locally.

Install Subclipse in Eclipse

The easiest way is to install Subclipse from its update site. Select Help -> Install New Software� from Eclipse�s main menu. In the Install dialog, type the following URL into the text field Work with:

http://subclipse.tigris.org/update_1.8.x

Hit Enter, Eclipse will load features available for the plug-in in the drop-down list, the Subclipse and SVNKit, as shown in the following screenshot:

Figure: Select features of Subclipse to be installed

Click Select All, and click Next. It may take a while for Eclipse to calculate requirements and dependencies before displaying the Install Details dialog:

Figure: Review the items to be installed

Click Next, in the Review Licenses screen, select I accept the terms of the license agreements:

Figure: Accept the terms of the license agreements

Click Finish, Eclipse is installing the software:

Figure: Installation is in progress

During the installation, a security warning pops up:

Figure: Accept a security warning

Click OK. After installation completed, Eclipse asks to restart the IDE or apply changes immediately:

Figure: Restart the IDE after installation completed

It is advisable to click Restart Now.

Perspectives and Views for SVN

Once installed, Subclipse provides two perspectives, one for SVN and one for team collaboration:

SVN Repositories Exploring
Team Synchronizing

You can switch to the perspective by select Window -> Open Perspective� -> Other, and select one from the Open Perspective dialog:

Figure: Open perspectives provivded by Subclipse

The views provided by Subclipse can be found by selecting Window -> Show View -> Other� Expand the SVN branch:

Figure: Views provided by Subclipse

Check in a project to a SVN server

Check in is the process of putting a project from a local computer to a SVN server. The project will be shared to other developers so that they can work on the project at the same time.

Right click on to the project in Project Explorer view, and select Team -> Share Project� from the context menu:

Figure: Check in a project

The Share Project dialog appears, select SVN, click Next:

Figure: Select SVN as repository type

In the next screen, Share Project with SVN Repository, select Create a new repository location, click Next:

Figure: Create a new repository location

Type URL of the SVN repository into the Url field:

Figure: Type URL of the repository

Click Next, in the next screen, you can specify the name of the folder in the SVN repository:

Figure: Enter folder name

Click Finish. Note that you may have to enter user name and password to access the SVN repository, depending on the server�s settings.

Check out a project from a SVN server

Check out is the process of getting a project from a SVN server�s repository to local disk. There are two ways to check out a project in Eclipse:

Check out from menu File.
Check out from SVN Repositories view.

Check out from menu File

Select File -> New -> Project� In the New Project dialog, expand SVN node and select Check out projects from SVN:

Figure: Create a new project from SVN

Click Next, in the next screen, select Create a new repository location:

Figure: Create a new repository location

Click Next, enter URL of the SVN repository into the Url field, and click Next:

Figure: Specify URL of the repository

Eclipse will load content of the repository on the SVN server and ask you to select a project folder:

Figure: Select folder to be checked out

Click Next, in the Check Out As screen, you can specify how to check out the project as a new project using the New Project Wizard or as a project in the current workspace. You can also select to check out a specific revision. Click Finish when done:

Figure: Check out options

The check out is in progress:

Figure: Eclipse is downloading project from SVN

Note that you may be asked for providing user name and password to access the SVN repository.

Check out from SVN Repositories view

Switch to SVN Repository Exploring perspective, in the view SVN Repositories, click on the Add Repository icon:

Figure: Add SVN repository

In the dialog Add SVN Repository, type URL of the SVN repository into Url field, and click Finish:

Figure: Specify URL of the repository

You may have to provide user name and password to access the SVN repository. Eclipse will load content of the repository in a hierarchical tree. Expand the repository node, and right click on the folder name which you want to check out:

Figure: Check out from context menu

And follow the steps same as described above, for the Check Out As screen.

Team collaboration tasks

Subclipse provides a comprehensive context menu for team collaboration, it is the Team menu which can be found in the context menu:

Figure: Team context menu

Synchronize with Repository

This task allows reviewing your changes with other team members in order to synchronize them. Select Team -> Synchronize with Repository from context menu, Eclipse will switch you to Team Synchronizing perspective:

Figure: The Synchronize view

In the Synchronize view you can take a look at:

Outgoing changes: changes made by you and ready to be committed. They are denoted by an outgoing arrow in gray.
Incoming changes: changes made by other team members and ready to be updated. They are denoted by an incoming arrow in blue.
Conflicts: are the resources that have been changed by someone while you are still working on them. Conflicts are denoted by a two-way arrow in red.

From the changes in the Synchronize view, you can decide to do by some quick commands in the context menu:

Figure: Quick commands in context menu

Commit

Push your changes to SVN repository. The dialog Commit appears, you can review what changes to commit and provide a comment, then click OK.

Update

Update the resource with a latest revision from the repository. A conflict will be notified if any.

Override and Update

Always replace the content of the resource with a latest revision from the repository. If there is any conflict, you�re the local version is overridden by the revision from the repository.

Mark as Merged

This command should be called to indicate that the current resource is merged with incoming changes from the repository. This is usually used after resolving conflicts.

Revert changes

Undo the changes made to the resource since the last update.

Show History

Review revision history of a resource. Details will be shown up in the History view, and you can switch back to a specific revision via context menu.

Above are the most frequently used tasks. There are many other tasks which are waiting for you to explore.

The Synchronize view comes with a handy toolbar that helps switching to incoming mode, outgoing mode, conflicts mode, update all incoming/outgoing changes�:

Figure: Quick toolbar in Synchronize view

The Team Synchronization perspective also provides a very useful compare editor which lets you to compare the local changes and remote changes visually:

Figure: Code compare editor

The compare editor is automatically loaded when double clicking on a resource, it is very helpful for resolving conflicts and merging changes.

Conclusion

Subclipse is a great plug-in for working with SVN and fostering team collaboration, so it should be one of must-have tools for any Java developers.

Create new Form in Eclipse

Eclipse — Sat, 11 Feb 2012 13:59:29 GMT

Click the JFormDesigner button in toolbar of Eclipse. Also it can be initiated using following short keys.
� For Windows (Ctrl+Shift+V)
� For Mac (Shift+Command+V)

To create a new form using Eclipse�s Package Explorer, select destination folder and right click. It will open following dialog box.

Create new Form in Eclipse

Benefits of using Eclipse Plug-ins

Eclipse — Sat, 11 Feb 2012 13:56:22 GMT

Eclipse Plug-ins provides following benefits as compared to other development environments.

� Integrated editor to create and design in Eclipse.
� It uses current project�s source folders and classpath.
� When you make changes in design, it changes in code accordingly.
� In Java editor, you can fold generated Java code.
� In Java editor, you can navigate to event handlers.
� Strings in designer and properties file have two way synchronization.
� Copy and paste libraries to include in classpath.
� Integrated with version control system.

Conditional breakpoints in Eclipse

Eclipse — Sat, 11 Feb 2012 13:55:06 GMT

To debug a Java Program in Eclipse, it allow to setup �conditional break points�. Conditional break points are based on conditions. Your debugging thread will stop when the specified condition is matched at the break point line.

To setup a new conditional break point follow these steps.

� Double click on the required line in your code on which you are interested to setup break point.
� Right click -> Properties -> Insert condition.

The program will stop on this line when the entered condition matched and program is running in debug mode.

Conditional breakpoints in Eclipse

Increasing Eclipse Memory�s setting for Android Project

Eclipse — Sat, 11 Feb 2012 13:49:49 GMT

The Android project has a large size and it causes memory issues while compiling this project. To avoid such memory issues, increase memory size. To increase the memory size, edit �eclipse.ini� file. This file is located at following location:
Java Code:
/Applications/eclipse/Eclipse.app/Contents/MacOS/eclipse.ini
Default memory parameters are as shown below.
Java Code:
-Xms40m 
-Xmx256m 
-XX:MaxPermSize=256m
Following settings are recommended for Android development.
Java Code:
-Xms128m 
-Xmx512m 
-XX:MaxPermSize=256m
The above settings set minimum memory size to 128 MB. The maximum size set in the above code is 512 MB.

After setting these memory parameters, restart Eclipse.

Eclipse Remote Debugging

Eclipse — Sat, 11 Feb 2012 13:46:21 GMT

Follow these steps to set up remote debugging in Eclipse.

� Open your java project.
� Select project.
� Click Run -> Debug Configurations as shown below.

Debug Configurations

� A new dialog box will open with different configuration options. Select �Remote Java Application as shown below.

Debug Configurations Option with Remote Java Application

� Click �New�, it will create new configurations for your project. Setup host and port for your debugging.

New Debug Configurations

Eclipse Memory Analyzer (MAT)

Eclipse — Sat, 11 Feb 2012 13:41:26 GMT

Eclipse Memory analyzer (MAT) is used to analyze memory leaks in your application. If an object has no reference, it is released by Java Garbage Collector. In a situation you get OutOfMemoryError, you can instruct Java Virtual Machine to create heap dump. The Eclipse Memory Analyzer provides a visual image of Java heap dump and helps to identify memory leaks. Use the following command to guide JVM to create a heapdump.

XX:+HeapDumpOnOutOfMemoryError

Eclipse Memory Analyzer (MAT)

To install Eclipse Memory Analyzer using Eclipse Update Manager, open General Purpose Tools and then install Memory Analyzer.

Installing Eclipse Plug-ins

Eclipse — Sat, 11 Feb 2012 13:38:16 GMT

Eclipse is an extendible integrated development environment, which is open source platform and supports integration of new plug-ins. Eclipse supports building of new tools that can be integrated with it. Other than core runtime environment, everything in Eclipse is a plug-in. All the plug-ins are developed and integrated in almost same way.

In this section, we will discuss on installing an Eclipse plug-in. below image shows the Eclipse SDK folder.

Eclipse SDK folder

The folder hierarchy looks like following when you extract the Webtools package.

Webtools package

Copy the contents of the folders as shown below.

Installing Eclipse Plug-ins

Eclipse Plug-in Deployment

Eclipse — Sat, 11 Feb 2012 13:33:49 GMT

To deploy an Eclipse plug-in, deploy following into Eclipse intallation�s plug-in folder.

� Manifest File
� Jar Files
� Any other resources

Now Eclipse can activate this plug-in when it is required to perform some functionality. To activate a plug-in:

� Load runtime class
� Instantiate it
� Initialize it

Plug-in class is responsible for doing special tasks like allocation and reallocation of resources. For some simple plug-ins this activation and deactivation is not required and also plug-in class is not required in such cases. Eclipse runtime provides a default class in such cases.

Activation and deactivation methods are overridden by the org.eclipse.core.runtime.Plugin subclasses in order to perform some specific tasks at time of activation and deactivation.

Eclipse deployment consists of a management kernel called Eclipse platform and a certain core plug-ins. These are hard-coded plug-ins in the Eclipse environment and platform activates these plug-ins.

Remaining plug-ins which are not core are activated when they are required.

A plug-in may have one of the following relations with other plug-in in the Eclipse model.

� Dependency: Main roles are

o Dependent plug-in
o Prerequisite plug-in
� Extension: Main roles are

o Host plug-in
o Extender plug-in

Plug-in manifest file contains the declaration of these relationships.

The Eclipse Plug-in Model

Eclipse — Sat, 11 Feb 2012 13:31:54 GMT

Plug-in is a component that supports a particular service or functionality in the Eclipse workbench. This component can be integrated into system at deployment time. Eclipse supports a wide variety of these plug-ins that can work together to support an environment for development. A plug-in in Eclipse is embodied in plug-in runtime class instance. This class provides some configuration functionality for the plug-in instance. A plug-in class must extend org.eclipse.core.runtime.Plugin which is an abstact class and it supports functions for managing plug-ins.

Each Eclipse installation contains a folder, where these plug-ins are deployed. Each plug-in is installed in its own separate folder. An XML manifest file is used to describe plug-in. This file is called �calledplugin.xml� and it resides in the plug-in folder. This file contains useful information for Eclipse to activate this plug-in.

Develop a Java EE Application in Eclipse

Eclipse — Sat, 11 Feb 2012 13:30:41 GMT

1. Setup Eclipse for Web Development

� Install Eclipse for Java EE
� Install a web server like tomcat of glassfish
� Configure web server in your Eclipse

o Launch Eclipse->Window->Preference->Server Node->Runtime Environment->Add->Expand Apache and add tomcat

2. Hello Word JSP

� Create a new Web Application

o File->New->Dynamic Web Project
o Enter �HelloJSP� as project name and enter finish
� Create new JSP page

o Right click on your project
o New->Jsp File and enter �Hello� in file name

3. Create a Servlet

� Create a new Web Application:

o File -> New -> Dynamic Web Project
o Write HelloServlet in project name
� Create a new Servlet:

o Right click on the project
o New -> Servlet -> In "Java Package", enter "hello"
o In "Class Name", enter "HelloServlet"
o In "URL Mappings", select "\HelloServlet",

Eclipse Architecture

Eclipse — Sat, 11 Feb 2012 13:24:02 GMT

Eclipse is based on plug-ins and uses them to provide core functionality as compared to different other application where hard coded functionality is normally used. Eclipse is based on a runtime system called Equinox that is an implementation of OSGi core framework specification.
This plug-ins is software components that allow Eclipse to extend using other languages like Python or C. Also this plug-ins provides support to work with network applications. Using this plug-ins, you can write extension to Eclipse environment. For example CVS and Java is supported in Eclipse with many other third party plug-ins based version control systems.

At the core of Eclipse is a small run-time kernel. Everything other than this kernel is a plug-in. This plug-ins is integrated with Eclipse in same way like other plug-ins is integrated. This makes all new features are created equal. Eclipse has a support for large variety of plug-ins, for example UML plug-in for UML diagrams and DB Explorer etc.

� The Eclpse SDK includes following:
� Eclipse Java Development Tools
� Java compiler
� Full model of the Java source file.

It supports code analysis and advanced level refactoring of code. Eclipse also supports use of workspace where a set of metadata allows external file modifications.

For Java, widget toolkit is implemented by Eclipse that is called SWT. Many other Java applications uses AWT or swing but Eclipse uses a GUI layer called JFace which support building of applications based on SWT.

What is Eclipse?

Eclipse — Sat, 11 Feb 2012 13:22:39 GMT

Eclipse is an integrated development environment (IDE) that provides a software development environment and supports plug-ins. Eclipse is developed mostly in Java and it is used to develop Java applications with the help of plug-ins. Eclipse is also know as Eclipse ADT(Ada Development Toolkit) for Ada, for C/C++ it is called CDT, for Java it is called JDT and for PHP it is called PDT.

It is released under Eclipse Public License; it is open source and free software. Below figure shows a snapshot of Eclipse.

Eclipse IDE

Start writing a plug-in for Eclipse

Eclipse — Mon, 06 Feb 2012 04:13:12 GMT

The Eclipse IDE has an open architecture which allows third party developers to extend or add new functionalities to the Eclipse�s core platform. This architecture follows the OSGi framework which is a specification for application and component life cycle management.

This article will guide you to develop a sample plug-in from creating fundamental blocks to testing and installing as a feature to the IDE. The version of Eclipse targeted by this article is the 3.7 (Indigo).

Before getting started, let�s get familiar with some fundamental concepts regarding the plug-in development in Eclipse.

Fundamental Concepts about plug-ins for Eclipse

PDE: stands for Plug-in Development Environment, PDE provides necessary tools to help developers creating, developing, debugging, testing and deploying components for Eclipse IDE such as plug-ins, features, update sites� The PDE provided by Eclipse is very powerful, flexible and easy to use.
Plug-in: A plug-in is a smallest unit that represents a group of code which is modular, extendable and shareable. Plug-ins are the basic parts that make up of an Eclipse based program or product. Think a plug-in as a modular part of a program.
Extensions and Extension points: An extension is a way for a plug-in to extend a functionality of another plug-in through its extension point. An extension point is declared by a plug-in to allow another plug-in extends its functionality. Think extensions as interfaces that allow plug-ins to work together.
Feature: A feature is used to group some plug-ins together into a single unit which is installable and updatable. A product or program can contain several features.
Update Site: An update site is used to organize features so that they can be installed into Eclipse IDE. Update sites can be on a local computer on a remote server and it is the widely used way to deliver Eclipse based products.

There are other terms such as fragment, product, and target platform but for the purpose of this article, the terms described above is enough for you to start. For other terms, refer to Eclipse�s documentation.

Activate the PDE

The PDE is provided as a perspective in the IDE. Select Window -> Open Perspective -> Other� from Eclipse�s main menu, and choose Plug-in Development from the Open Perspective dialog:

Figure: Open the Plug-in Development perspective

The Plug-in Development perspective has the following views:

Figure: The views of Plug-in Development perspective

The New menu is also customized for creating plug-in related items:

Figure: New menu is customized for PDE

The following screenshot illustrates the Plug-in Development perspective for a plug-in project:

Figure: The Plug-in Development perspective

Creating a Eclipse plug-in project

We are going to develop a plug-in project that adds a custom menu to the main menu.

Select File -> New -> Plug-in Project from the main menu. In the Plug-in Project screen, type MyPlugin as the Project name. In the Target Platform section, select Eclipse version and select 3.6 from the dropdown list. The plug-in we are going to create will be run on Eclipse 3.6 or later:

Figure: Create a new Plug-in project

Click Next. In the Content screen:

Keep 1.0.0 as Version (delete the word qualifier).
Type My Company as Provider.
In the dropdown list Execution Environment, select the JavaSE version available on your computer.

Figure: Specify content for new plug-in project

Leave others as default, and click Next. In the Templates screen, uncheck the option Create a plug-in using one of the templates, as we will add an extension later.

Click Finish, Eclipse creates some skeleton stuff for the project, note the Activator.java class is created under src -> myplugin directory. This class is to control the plug-in life cycle:

Figure: The generated Activator class

Eclipse created the necessary skeleton code, and normally we don�t need to modify this class.
And note the new editor page:

Figure: The plug-in editor

This editor allows developers to control everything about a plug-in which is separated into individual pages such as Overview, Dependencies, Runtime, Extensions�This makes configuring and managing the plug-in easily.

Creating an extension for custom menu

Now let�s add something interesting to the plug-in. Select page Extensions in the MyPlugin tab, and click on the Add button:

Figure: Add an extension

In the New Extension dialog, select the tab Extension Wizards, and choose the �Hello, World� action set on the right:

Figure: Select an extension wizard

Click Next, in the next screen, type the following information:

MyAction for Action Class Name.
Greetings, thank you for using my plugin for Message Box Text.

Figure: Specify information for the action

Click Finish. Eclipse has created two things:

The plugin.xml file: holds configuration for the plug-in.
The MyAction.java class: implements the behavior when the menu is clicked. This class implements the IWorkbenchWindowActionDelegate interface and overrides some methods. The code to display the message is in the run() method.

Select the Sample Menu (menu) under the Sample Action Set (actionSet) in the All Extensions section.

In the section Extension Element Details, type myMenu for id, and My Menu for label, like the following screenshot:

Figure: Configure menu

Select the Sample Action (action), type myAction for id and My Action for label. Press Ctrl + S to save the changes to the project.

Testing the plug-in in Eclipse

The PDE allows developers to test their plug-in project with a single mouse click. Select page Overview, click Launch Eclipse application under the Testing section:

Figure: Click Launch an Eclipse application

Eclipse will launch a separate instance for testing. You will see a custom menu My Menu is added to the main menu, with a menu item My Action:

Figure: Test the action of the plug-in

Select My Menu -> My Action, a message box appears:

Figure: The message dialog

It is great, right? So far you don�t have to write any code at all. Eclipse automatically generates almost the code for you. Have a look at the plugin.xml file to see how Eclipse generates the XML declaration for the plug-in:

Figure: Content of the plugin.xml

And if you want to modify some code, look at the generated classes MyAction.java and Activator.java.

Creating a feature project

Till now we have a plug-in project that works. Next, we need to create a feature project that covers the plug-in and turns it into an installable unit.
Select File -> New -> Feature Project from the main menu. In the New Feature dialog:

Type MyFeature as Project name.
Keep 1.0.0 as Feature Version (delete the word qualifier).
Type My Company as Feature Provider.

Figure: Create a Feature project

Click Next. In the next screen, select option Initialize from the plug-ins list, then select the item MyPlugin:

Figure: Add a plug-in to the feature

Click Finish, Eclipse creates the MyFeature project:

Figure: Feature editor

There are only two files created for this project: build.properties and feature.xml. The feature.xml file contains various definitions for the feature such as the plug-in it wraps, copyright and license information.

Select the feature.xml page, type some information for the description, copyright and license, as in the screenshot below:

Figure: Content of feature.xml

Press Ctrl + S to save the project.

The Plug-ins page allows managing which plug-ins are included in the feature:

Figure: Plug-ins added to the feature

Here we see the MyPlugin is included because we selected it previously in the New Feature wizards.

Creating an update site project

This is the last step to create a deployable and installable unit. In the editor for MyFeature, select Overview page, then click Create an Update Site Project, in the Publishing section:

Figure: Click Create an Update Site Project

The New Update Site dialog appears, type MyUpdateSite as Project name, then click Finish:

Figure: Create an Update Site project

The project MyUpdateSite is created with a site.xml file and an editor Update Site Map:

Figure: Update Site Map editor

Click Add Feature, the Feature Selection dialog appears, select MyFeature in the drop-down list, and click OK:

Figure: Add a feature to the site

The feature MyFeature is added under the section Managing the Site. Click Build All button to build the projects MyFeature and MyPlugin. Some artifacts are created under MyUpdateSite project, as shown in the following screenshot:

Figure: Artifacts created after build

The JAR files created, along with the site.xml file, are ready for installing.

Install the feature to Eclipse

Now close all the projects, exit the IDE and re-launch Eclipse. We are going to install the plug-in created as a feature.

Select Help -> Install New Software from the main menu. In the Install dialog, click Add button. In the Add Repository dialog, type My Company into the Name field and click Local button. Select the directory of the MyUpdateSite project, and click OK:

Figure: Install feature from local site

Click OK in the Add Repository dialog. Click Select All in the Install dialog to choose the feature to be installed, and click Next.

In the next screen, Install Details, click Next. In the Review Licenses screen, select I accept the terms of the license agreement, and click Finish. Eclipse is now installing the software:

Figure: The feature is being installed

Eclipse may display a security warning dialog, click OK. Finally Eclipse asks to restart or apply change, click Apply Changes Now.

Immediately a new menu is added to the Eclipse�s main menu, My Menu. Select My Menu -> My Action, a message dialog appears:

Figure: Running the installed feature

So that our plug-in is installed and working properly!

We installed the plug-in from a local site. You can also copy the artifacts to a remote server and install it via an Update Site URL.

Uninstall the feature from Eclipse

To uninstall the plug-in, select Help -> About Eclipse. In the About Eclipse dialog, click Installation Details. In the Eclipse Installation Details dialog, select MyFeature from the list and click Uninstall:

Figure: Uninstall the feature

In the Uninstall Details dialog, click Finish. Eclipse is now uninstalling the software:

Figure: The feature is being uninstalled

Click Apply Changes Now when Eclipse asks, you will see the My Menu is immediately removed from the main menu. Check the Installation Details to see the MyFeature is no longer there. The plug-in is completely uninstalled.

Using WindowBuilder to design GUI in Eclipse

Eclipse — Mon, 06 Feb 2012 02:57:00 GMT

WindowBuilder is a great Eclipse plug-in that allows developers to visually design graphical user interface (GUI) for Java applications. It supports developing both Swing and SWT applications. In addition, it also supports Google Web Toolkit (GWT) and XML Windowing Toolkit (XWT). This article introduces this plug-in to Java developers about installation and working within Eclipse IDE environment.

Install WindowBuilder plug-in

WindowBuilder is already integrated into Eclipse Indigo version (Eclipse IDE for Java Developers). If you are using older versions (Helios, Galileo, Ganymede, �) you need to install the plug-in through the Eclipse�s Install New Software feature.

Select Help -> Install New Software� from Eclipse�s main menu. In the Install dialog, click Add button on the right of the dropdown list Work with. In the dialog Add Repository, you need to type the update URL of WindowBuilder into Location field. To know which update URL is for your current Eclipse version, go to http://www.eclipse.org/windowbuilder/download.php. You will see the links for different versions of Eclipse:

Figure: Update links page for WindowBuilder

Copy the link corresponding to your Eclipse version, and paste it into the Location field. Type a meaningful name for the Name field, such as WindowBuilder, and click OK:

Figure: Install WindowBuilder via update URL

Eclipse will load some information about the plug-in:

Figure: Select features of WindowBuilder to install

Click Select All to install all features of WindowBuilder, and click Next.

In the screen Install Details, click Next.

In the Review Licenses screen, select I accept the terms of the license agreements. Click Finish, Eclipse will download and install the plug-in:

Figure: Installation of WindowBuilder is in progress

You may have to restart the IDE after the installation completed:

Figure: A restart is recommended after installation

Click Restart Now to restart the IDE.

The WindowBuilder�s views

There is no separate perspective for WindowBuilder. Instead, Eclipse has three new views that support designing GUI:

Design view: the visual editor for designing windows, frames, dialogs, panels.
Palette view: provides UI widgets, components and layouts available for designing.
Structure view: displays the logical structure of the component being designed. This contains two panes:

Components pane: displays the hierarchical structure of the component being designed.
Properties pane: displays the properties of the current selected object.

The following screen shot illustrates the three views that come with WindowBuilder:

Figure: Views specific to WindowBuilder

To show a view, select Window -> Show View -> Other�There is a new branch in the Show View dialog � WindowBuilder:

Figure: Select a view of WindowBuilder

The Design view is not shown here because it is available only when viewing the source code of a container by switching to design mode, as depicted in the following screenshot:

Figure: The Design mode

To create a GUI container, select File -> New. In the New dialog, expand the branch WindowBuilder, you will see about a dozen of containers and components that can be created and managed by WindowBuilder:

Figure: WindowBuilder can work with various types of components

All Swing�s widgets are available to create. For other toolkits like GWT, SWT and XWT you need to do additional installation. If you want to develop a SWT application, select SWT User Interface from the above dialog, and click Next. You will be asked to install the SWT Toolkit:

Figure: Install SWT Toolkit

Click Finish to install SWT Toolkit. You have to restart the IDE after installation completed. SWT widgets are available to create in the New dialog:

Figure: The SWT Toolkit supports various components

Follow the same steps to install GWT Toolkit and XWT Toolkit.

The Palette View

The Palette provides quick access to common widgets such as labels, buttons, text fields�This view is shown automatically when switching to design mode or manually by selecting Window -> Show View from the main menu.

You can drag and drop widgets from the Palette into the Design view. The widgets in the Palette are specific to the current toolkit. For example, the Swing�s widgets are different with the SWT�s ones.

The following screenshot show different palette for Swing and SWT:

Figure: The difference between Swing palette and SWT palette

The widgets are grouped by categories for easy access, such as Layouts, Controls, Menu� You can do various customizations via the context menu:

Figure: The context menu of Palette view

The Design View

The Design view is the visual editor that allows to arrange, edit, move, re-size� widgets placed onto a container. The behavior of drag and drop widgets is different depending on the layout manager being used by the container.

The following screenshot illustrates the behavior when drop a widget onto a container using GridBagLayout:

Figure: The behavior of a container using GridBagLayout

And for a container that uses BorderLayout:

Figure: The behavior of a container using BorderLayout

The visual editor comes with a handy toolbar that provides quick access for common operations such as preview the window, refresh the source code and the design page, undo/redo, change the look and feel�

Figure: The toolbar of Design page

One great feature of WindowBuilder is, the design view and the source code are synchronized immediately when you make changes to either side. You can freely change the source code and the design page updates the changes immediately.

When selecting a widget or component in the design view, the Components pane and Properties pane display the corresponding information.

The Structure View

The Structure view is activated when switching to design mode or selecting Window -> Show View from the main menu. It is divided into two panes:

The Components pane: this represents the structure and relationship among components within a container in a hierarchical tree which allows quickly visualizing the structure and navigating among the components easily. In addition, you can perform various operations via the context menu:

Figure: The Components pane

When selecting an object in the design view, the components tree is also updated for the selected current selected component. You also can drag and drop widgets from the Palette view into the components tree.
The Properties pane: it is activated and refreshed each time a component is selected either in the design view or in the components tree. You can view and edit properties of the selected component via this pane, the changes are updated in the design view and components tree immediately.

Figure: The Properties pane

Configure WindowBuilder settings

You can configure various settings for WindowBuilder by choosing Window -> Preferences from the main menu, and select the branch WindowBuilder:

Figure: Configure WindowBuilder settings

References

WindowBuilder is a powerful GUI design tool which comes as a plug-in for Eclipse IDE. Here are some great resources about the plug-in:

WindowBuilder�s home page: http://www.eclipse.org/windowbuilder/.
This is the place to download separate installation or get update links.
WindowBuilder�s documentation: http://help.eclipse.org/indigo/index...l%2Findex.html
This is the original and great resource to learn using WindowBuilder.

Working with databases in Eclipse using QuantumDB

Eclipse — Sun, 05 Feb 2012 11:32:50 GMT

Database is an important part of a software program. There are a number of tools/editors for popular RMDBS such as MySQL Query Browser, SQL Server Management Studio, TOAD� for database administrators and/or developers. For those who are working with Java and database using Eclipse IDE, a plug-in for database integrated in an IDE would be a necessary tool, and QuantumDB is such a plug-in. It is easy to setup and helps developers working with the most popular database systems smoothly.

In summary, QuantumDB can work with various database systems: DB2, HSQLDB, MySQL, Oracle, Microsoft SQL Server � using standard JDBC drivers. It allows developer to review database structures like schemas, tables, views, sequences, constraints�; execute SQL statements against the database like inserts, updates, deletes�

Install QuantumDB for Eclipse

QuantumDB can be downloaded separately or installed as an Eclipse�s plug-in. The home page is http://quantum.sourceforge.net/
Select Help -> Install New Software from Eclipse�s main menu. In the Install dialog, click Add button on the right of the drop-down list Work with, in the dialog Add Repository, type the following information:

QuantumDB for Name field.
http://quantum.sourceforge.net/update-site for Location field.

As in the following screen:

Figure: Install QuantumDB via Eclipse's Software Update feature

Click OK, Eclipse takes a while to load some information about the plug-in and display it in the list:

Figure: Select features to be installed

Here we see three items, click Select All to install all features of the plug-in. Then click Next. It may take a while for Eclipse to calculate the required disk space to install the plug-in. The following screen will be displayed afterward:

Figure: Review all items before installing

Click Next. On the Review Licenses screen, select I accept the terms of the license agreements:

Figure: Accept the terms and license agreement

Then click Finish. The download and installation may take a few minutes to complete, depending on your network speed:

Figure: Installation progress

During the installation, Eclipse will pop up a warning:

Figure: Security warning

Click OK to continue. After the installation completed, Eclipse will ask to restart the IDE:

Figure: A restart required after installation

Click Restart Now to restart the IDE.

Working in QuantumDB Perspective

The plug-in provides a perspective � the Quantum DB perspective which can be opened by selecting Window -> Open Perspective -> Other� Select Quantum DB from the Open Perspective dialog:

Figure: A new perspective available for QuantumDB in Eclipse

The Quantum DB perspective displays the following views by default:

Database Bookmarks: manages database connections as bookmarks.
Quantum SQL Queries View: edit and execute SQL queries.
Quantum Table View: displays result sets made by the queries.
Quantum SQL Log: shows SQL queries history and other logging information.

The following screenshot shows the Quantum DB perspective in Eclipse:

Figure: The QuantumDB perspective in Eclipse IDE

Connect to a database

Making connection to a database is the first and important task. Quantum DB makes this easy by the Database Bookmarks view, as you can define the connections once and re-use them later, just like bookmarks. Another important thing is, QuantumDB uses standard JDBC drivers to work with database, so you must have JAR files for those drivers ready on your computer, such as mysql-connector-java.jar for MySQL, or ojdbc.jar for Oracle. In this article we will make connection to a MySQL database.

In the Database Bookmarks view, click on New Bookmark icon:

Figure: Add new database bookmark

In the New Bookmark dialog, click Add Driver� The New JDBC Driver dialog appears, do the followings:

Click Add External Jar� to select the JDBC driver�s JAR file, such as mysql-connector-java-5.1.7-bin.jar for MySQL database.
Select MySQL in the dropdown Type.
Click Browse to select driver�s class name, com.mysql.jdbc.Driver, for MySQL.

Figure: Select a driver class name

The New JDBC Driver dialog should look like the following screenshot:

Figure: Setup a JDBC driver

Click Finish. The driver name com.mysql.jdbc.Driver is added to the New Bookmark dialog:

Figure: A new driver is added

Select the com.mysql.jdbc.Driver name, click Next. In the next screen, you need to provide detail information to connect to the database, such as userid, password, host name, port, and database name:

Figure: Specify database connection details

After typing the required information, click Next. In the next screen, you will provide a name for the bookmark:

Figure: Name for the database bookmark

Click Next. In the last screen, you are asked to select which schemas should be displayed, select Show all schemas:

Figure: Select which schema should be displayed

Click Finish. The new bookmark, MySQL, is added to the Database Bookmarks view. Right click (or double left click) on the bookmark to connect to the database:

Figure: Connect to the database

The plug-in connects to the database and displays the structures in tree format, like the following screenshot:

Figure: The database tree structure

From this well-organized tree, you can perform various operations against database objects such as tables, views, procedures� by the context menu displayed when clicking on the object name. The output will be displayed as a tab in the Quantum Table View, and the logging information will be displayed in the Quantum SQL Log view.

Working with database tables

Most of the time you will be working with database tables, so the following list describes the most common and useful operations against tables:

Query all data of a table: Right click on the table name, select View Table (or left double click on the table name), the result set is displayed in the Quantum Table View:

Figure: Query all table data
View detailed structure of a table: Right click on the table name, select View Table Details. The structure is displayed like this:

Figure: View table structure in details
Quick delete all rows in a table: select SQL Statements -> Delete All Rows from the table�s context menu.
Quick drop a table: select SQL Statements -> Drop Table/View/Sequence� from the table�s context menu.
Export table structure: select Copy from the context menu, the XML structure data will be copied into clipboard. This feature is useful if you are working with DbUnit testing framework.
Export table data to XML catalog: Select Export from the context menu, in the Export dialog, select XML -> XML Catalog. This feature is useful if you are working with DbUnit testing framework.

Working with Quantum SQL Queries View

This view allows developers to type in queries in SQL language and execute them against the database. There are two main ways to execute queries:

Execute all statements in the editor: Do not select any statement, click on the Execute button
Execute a specific statement: Select the entire statement, then click Execute button.

You can also execute the statements from the context menu displayed when right clicking either on the selected statement or in the editor.

Figure: The SQL Queries view

Working with Quantum Table View

This view is not only to display data. It also allows developers to do some common tasks for a result set: Insert, Update, Delete, Export� All these commands can be found from the context menu:

Figure: Context commands for a result set

However, the plug-in does not allow you to alter table structure, just view.

Other views

The plug-in comes with some other views, to see the complete list, select Window -> Show View -> Other� and expand the QuantumDB branch:

Figure: All views of QuantumDB perspective

Disconnect from database

After finish working with the database, right click on the database bookmark name, select Disconnect.

Using custom Ant build script for Eclipse projects

Eclipse — Sun, 05 Feb 2012 04:25:13 GMT

Ant is XML-based script for building Java applications. Ant is popularly used in Java development because of its powerful and flexibility. It makes developer�s life easier by automatically processing repetitive tasks that happen before, during and after building of Java applications. Eclipse is a great IDE which supports Ant by integrating Ant�s libraries as its plug-in.

Generally, you may not deal with any Ant script during development of a Java project in Eclipse. However if your project has a quite complex process that involves in building or testing of a application and the Eclipse IDE itself cannot help, it�s time to consider to use custom Ant build script for the project. For example, suppose you have to package your application as a JAR file, include some documents and put all together in a zip file, then finally upload the zip archive to a FTP server. This process has to be made after every build of the application. It would be boring and time-consuming if you do all this repetitive tasks again and over again, thus using a custom Ant script to automate the tasks in this scenario will make things much easier.

In this article you will learn how to configure a custom Ant build script in Eclipse to automate the repetitive tasks of the above scenario.
The Eclipse IDE has built-in support for Ant so that you don�t have to download Ant distribution to run Ant script.

Project�s scenario

Suppose you already have written a Java project in Eclipse. After the project is built (by Eclipse�s auto-build feature), you want to do the following tasks:

Package the compiled classes as a JAR file.
Create a distribution directory.
Copy two support documents to the distribution directory.
Compress the distribution directory into a single zip archive.
Upload the Zip archive to a FTP server.

Creating Ant build file

Right click on the project name in the Project Explorer view, select New -> File. In the New dialog, type antbuild.xml as File name:

Figure: Create new Ant build file

Click Finish, and then add some code for the antbuild.xml file as following:
XML Code: Content of the antbuild.xml file
   
    
        
    

    
        
    
   
    
        
       

    
        
    

    
        
    
   
    
   
In our custom build, we created 6 targets. The first 5 targets are equivalent to the 5 tasks in the project�s scenario. The last target will be the main one that calls the others in the order as specified by the depends attribute of the target default. Each target simply prints out a message corresponding to its purpose, by using the tag. We don�t write real Ant tasks for the targets because this article�s purpose is to demonstrate how a custom build can be used with Eclipse, and the implementation of details is up to you. Ant provides various tasks that help you to complete the described scenario, here are some suggestions:

Task jar: creates a JAR file
Task mkdir: creates a directory
Task copyfile: copies files.
Task zip: creates a zip file.
Task FTP: performs various operations with a FTP server.

Adding custom Ant build to the project

Select Project -> Properties from the main menu. In the project properties dialog, select Builders:

Figure: Configure Builders for the project

You can see the Java Builder in the list on the right, this is the default build which Eclipse uses to build the project. We cannot modify this default build. To add our custom build script, click New. In the dialog Choose configuration type, select Ant Builder, click OK:

Figure: Create Ant Builder type

The dialog Properties for New_Builder appears to let us configure our custom build.

Type Ant_Builder into the Name field.

On the Main tab:

Click Browse Workspace� under Buildfile section to select the Ant build script.
Under the Base Directory section, click Browse Workspace to select the directory in which our Ant script will consider as its home directory.

Figure: Configure Ant builder

Select Targets tab. This tab allows us to specify when and what will be executed. There are four point of time (event) that we can select to run our custom build script:

After a �Clean�: run the script after a clean project action is performed.
Manual Build: run the script before or after a manual build action is performed. We can specify before or after later.
Auto Build: run the script before or after an auto build action is performed.
During a �Clean�: run the script during a clean action is performed.

On the right of each event, there is a button Set Targets. This button allows us to specify the target in our Ant script will be executed. We select the event Manual Build, click Set Targets button, the target default is automatically selected:

Figure: Select target to run

Click OK to close the Set Targets dialog and return to the Properties for New_Builder dialog:

Figure: Configure targets for build event

Click OK to close this dialog and return to the Project properties dialog:

Figure: New Ant builder is added

Our custom build, Ant_Builder is added to the Builders list, after the built-in Java Builder. The order of builders does matter here: Eclipse will process the builders in that order. The Ant_Builder is after Java Builder, so Eclipse will execute Java Builder first, then to Ant_Builder. If you want to change the order, select the builder name, click Up or Down button. You can add as many custom builders as you want, and make sure everything are in order.

Testing the custom build in Eclipse

Now, let�s test how the custom build gets running. Click OK to close the project properties dialog. Because we have set to run our custom build for the event Manual Build, we can test by manually build the project by selecting Project -> Build All from the main menu:

Figure: Manually build all

After the project is built, our custom ant build is executed and we will see some outputs in the Console view, like the following screen:

Figure: Console output for build

That�s what we�d expect! We have successfully configured a custom build for the project.

Writing build script with Ant Editor

In order to write Ant script efficiently, the XML file should be opened by Ant editor which is not opened by default for XML file. In the Project Explorer view, right click on the Ant build file, select Open With -> Ant Editor:

Figure: Open the XML with Ant Editor

Eclipse will provide code completion for writing Ant script:

Figure: The Ant script editor

Configure Ant settings

You can configure various Ant�s runtime and editor settings via the Preferences dialog by selecting Window -> Preferences from the main menu. Then select Ant branch:

Figure: Configure Ant settings

Working with Java Servlets in Eclipse

Eclipse — Sat, 04 Feb 2012 16:56:11 GMT

Servlet is a Java program that runs on a web server to handle requests and returns response to clients. It is widely used for Java enterprise development, and Eclipse is one of the best IDE for Java development. So this article will walk you through a Java project using Eclipse IDE to create a web application that plays around with a Java servlet.

Set up Eclipse development environment
The following software programs are required to be installed on your computer:

Java JDK 7.0: This is the latest Java version at the time of writing this article. Download the JDK at: http://www.oracle.com/technetwork/ja...ads/index.html
Eclipse IDE for Java EE Developers (Eclipse Indigo, version 3.7). Download the latest version of Eclipse at:

http://www.eclipse.org/downloads/

If you have Eclipse for Java Developers already installed, you have to install Web Tools Platform (WTP) in order to work with Java EE project. To install the WTP plug-in, select Help -> Install New Software� from Eclipse�s main menu. In the Install dialog, select �Indigo - http://download.eclipse.org/releases/indigo� from the drop down Work with, and check �Web, XML, Java EE and OSGi Enterprise Development� from the list, then click Next. And you have to restart Eclipse after the installation completed.
Tomcat server: we will work with the latest version of Tomcat, 7.0. Download Tomcat 7.0 distribution at: http://tomcat.apache.org/download-70.cgi

The project

We are going to build a simple but interesting web application. There is a web page that allows user to type a text and hit Submit button, the server will return an image with the text embedded at the center.

A quick introduction to Servlet

Here are some briefs about Java servlet you need to know:

A servlet is a Java program that runs on web server supports Java EE, such as Tomcat.
A servlet is just a Java class that extends the GenericServlet class or the HttpServlet class.
To handle client�s requests, the servlet class should override one of the following methods: doGet(), doPost(), doPut(), service()�However the doGet() and doPost() are the two methods which are commonly used.
The HttpServletRequest interface defines actions to work with client�s request.
To read data sent from the client (such as value of parameters or form fields), invoke method getParameter(String paramName) from an instance of the HttpServletRequest interface.
The HttpServletResponse interface defines actions to work with response to client.
To send output to the client, invoke methods on the ServletOutputStream object which is returned from HttpServletResponse.getOutputStream() method.
A servlet must be registered in the web deployment descriptor file (web.xml) in order to serve client�s requests.
A servlet can handle particular URL patterns through mapping in the web.xml file.
A serlvet has the following life cycle methods: init(), service() and destroy().
There is only one instance of a servlet created per web application.
Each client�s request is served by a separate thread.

Creating the project in Eclipse

Select File -> New -> New Project� from Eclipse�s main menu. In the New Project dialog, select Dynamic Web Project from the Web node:

Figure: New project in Eclipse

Click Next, in the New Dynamic Web Project screen, type ImageServlet as Project name, leave others as default:

Figure: Create new Dynamic Web project

Click Finish, the project is created with the following structure:

Figure: The project structure

Configure server runtime

Next, we need to add Tomcat 7.0 as the targeted runtime for our web application. The server runtime includes libraries and configuration that let us work with Java servlets. Select Project -> Properties from the main menu. In the dialog Project properties for ImageServlet, select the node Targeted Runtimes:

Figure: Project Properties

Click New, the New Server Runtime Environment dialog appears. If Tomcat 7.0 is installed on your computer successfully, you will see it under the Apache node:

Figure: Select Server Runtime

Select Apache Tomcat v7.0 from the list, and click Next. On the next screen, you need to specify the directory of your Tomcat�s installation:

Figure: Configure Tomcat server

Click Browse to select the directory of Tomcat�s installation which is usually under: C:\Program Files\Apache Software Foundation\Tomcat 7.0 if you are using Windows.

Click Finish to close the New Server Runtime Environment dialog. You will see Apache Tomcat v7.0 is added to the screen Properties for ImageServlet:

Figure: Tomcat is configured as a Target runtime

Check the Apache Tomcat v7.0, and click OK. The server runtime is now configured.

From the main menu, select Window -> Show View -> Servers to open the Servers view that allows us to work with the server and deploy the web application. Right click in the Servers view�s area, select New -> Server:

Figure: Create a new server

The New Server dialog appears, select Tomcat v7.0 Server under Apache node, then click Finish:

Figure: Define a new server

The server is now added to the Servers view:

Figure: The Servers view

To test the server, right click on its name in the Servers view, select Start. You should see some logging information in the Console view indicates that the server is up and running.

Creating the Servlet

First, create a new package under which we will put our servlet class. In the Project Explorer view, right click on the src directory, select New -> Package. In the New Java Package dialog, type com.servlet.tutorial into the Name field, and click Finish.

Now, expand the node Deployment Descriptor:�, right click on the Servlets, select New -> Servlet:

Figure: Create a new servlet

In the Create Servlet dialog, type com.servlet.tutorial into the field Java package, and type ImageServlet into the field Class name:

Figure: Configure servlet information

Click Next. In the next screen, we can type description for the servlet in the Description field. The Initialization parameters section allows us to define init parameters for the servlet, however we don�t need this; the section URL mappings show all URL patterns that are mapped to the servlet. Eclipse automatically created the default one: /ImageServlet

Figure: URL mapping for servlet

Click Next. In the next screen we can specify which methods from the HttpServlet class to be overridden. We implement only the doPost() method, so check the Inherited abstract methods and doPost:

Figure: Select stub methods to implement

Click Finish. Eclipse creates the servlet class looks like the following:

Figure: The generated Servlet code

As you can notice, the annotation @WebServlet("/ImageServlet") is added to the class ImageServlet:

@WebServlet is the annotation name.
/ImageServlet is the URL pattern which is mapped to this servlet.

Creating the JSP page

In order to call the servlet, we write a simple JSP page that contains only one text field and a button. Right click on the WebContent node, select New -> JSP File.

Figure: Create a new JSP file

In the New JSP File dialog, type index.jsp as the File name, click Finish. Add the following code to the index.jsp page:
Java Code:
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
   pageEncoding="ISO-8859-1"%>




Add Text to Image


    
        
            Text  

            
 
        
    
There is one thing should be noticed here: We specify ImageServlet as the form�s action. This name should map with the servlet mapping specified by the annotation @WebServlet("/ImageServlet"). Doing so our servlet will be invoked after the form is submitted.

Coding the Servlet

The servlet reads a text send from the user (via the form in the index.jsp page), embed the text into a specified image then return the image back to the user. The code is implemented in the doPost() method as follow:
Java Code:
    protected void doPost(HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException {
       
        // get the text from user
        String text = request.getParameter("imageText");
       
        // place is image under WebContent
        String imageName = "MyCar.jpg";
       
        // get absolute path of the image
        String imagePath = getServletContext().getRealPath(imageName);
       
        // load the image

       BufferedImage image = ImageIO.read(new File(imagePath));

       

       // specify the position to place the text

       int x = image.getWidth() / 3;

       int y = image.getHeight() / 3;

       

       // draw the text on the image

       Graphics graphic = image.getGraphics();

       graphic.setColor(Color.RED);

       graphic.setFont(new Font("Arial", Font.BOLD, 40));

       graphic.drawString(text, x, y);

       

       // return the image to client

       ImageIO.write(image, "jpg", response.getOutputStream());

    }
Make sure you put the image file MyCar.jpg under the WebContent directory. The servlet will load the image from this location.

Run the project

We have done the coding part. Now let�s see how the application works by running it on Tomcat server. In the Servers view, right click on the server name, select Start. Open a browser window, then type the following URL into the address bar:
http://localhost:8080/ImageServlet/

The port number may be different because it depends on your Tomcat�s configuration. You should see the following screen:

Figure: Access the application home page

The page is displayed with a text field and a Submit button. Type some text, such as Lamborghini 2012, and hit Enter. You should see the following screen:

Figure: Result after submitting form to the servlet

And voila! The image is added with the text we have typed. That indicates the servlet is running properly, as expected!

Packaging the application

A Java web application is commonly packaged as a web archive (WAR) file. A WAR file can be deployed on all web servers that support Java. Right click on the project name in the Project Explorer view, select Export -> WAR File� In the Export dialog, specify the path of the WAR file in the field Destination, then click Finish:

Figure: Generate a WAR file

So far you have been seeing some concepts about Java servlet and use Eclipse IDE to write an interesting web application that works with a servlet. You also understand how a servlet works throughout the example and how Eclipse IDE can be used to develop a Java web application.