This section provides information on JSF and Struts tooling in JBoss Developer Studio which allows you to develop JSF and Struts applications much faster and with far fewer errors so sparing your time.
JBoss Developer Studio is especially designed for supporting JSF and JSF-related technologies. JBDS provides extensible and exemplary tools for building JSF-based applications as well as adding JSF capabilities to existing web projects, importing JSF projects (created outside JBDS) and choosing any JSF implementation while developing JSF application.
With Developer Studio, we don't lock you into any one JavaServer Faces implementation. Select the one you want to use for your project.
When you:
Create a new JSF project
Add JSF capability to any existing Eclipse project
Add JSF capability to any existing project (created outside JBDS)
You can always select which JSF implementation to use.
You can also create your own custom JSF environments.
JBoss Developer Studio will add all the required libraries for the selected version to your project.
This section will perform you all concepts that JBDS involves to use the Facelets.
The Facelets extends JavaServer Faces by providing a lightweight framework that radically simplifies the design of presentation pages for JSF. JBoss Developer Studio provides support for Facelets in a variety of ways:
The New JSF Project wizard contains templates for creating Facelets projects based on version 1.2 of the JSF Reference Implementation. Select the JSF 1.2 with Facelets in JSF Environment section.
Once you select the environment, you can specify the one of three available templates:
The fallowing table lists possible Facelets templates for any JSF project and gives a proper description for each one.
Table 2.1. Facelets Templates
Template |
Description |
---|---|
FaceletsBlankWithoutLibs |
Some servers already provide jsf libs and you take risk of getting conflicting libraries while deploying your project. To avoid such conflicts, use a template without libs if you have a server with its own jsf libraries |
FaceletsKickStartWithRILibs |
a sample application with Facelets that is ready to run |
FaceletsKickStartWithoutLibs |
a sample application without libraries |
The JBoss Tools Palette comes with the Facelets components ready to use. A useful tip appears when you hover the mouse cursor over the tag, the tip includes a detailed description of the tag component, the syntax and available attributes.
Code assist (Ctrl + Space) for Facelets tags is available when editing .xhtml files.
What's more, code assist is also available for "jsfc" attribute in any HTML tag.
After selecting "jsfc" you get the code assist for JSF components available on a page.
When a component is chosen you will see all available attributes for it.
JBDS provides Eclipse's OpenOn feature for editing Facelets files. Using this feature, you can easily navigate between the Facelets templates and other parts of your projects. Just by holding down the Control key while hovering the mouse cursor over a reference to a template, the reference becomes a hyperlink to open that template.
Necessary information and support for Facelets find out here.
To take an advantage of JSF support in JBoss Developer Studio firstly you should perform one of the next steps:
Create new JSF projects
Import (open) existing JSF projects
Add JSF capability to any existing Eclipse project
Import and add JSF capability to any existing project created outside Eclipse.
In this section we're going to stop on each of them in detail.
If you want your project has already contained all JSF libraries, tag libraries and JSF configuration file, just organize a new brand JSF project. JBoss Developer Studio allows to do this easily with the help of the special wizard. To get it, select File > New > Project > JBoos Tools Web > JSF > JSF Project and click Next.
On the next form you'll be prompted to enter Project Name and select a location for the project or just leave a default path.
Here, JSF Version also allows you to select which JSF implementation to use.
JBoss Developer Studio comes with a number of predefined project templates that are flexible and easily customizable. Thus you can pick a different template on which the project should be based to. Almost all templates come in two variations: with jsf libraries and without ones.
The table below provides description for each possible JSF template.
Table 2.2. JSF Project Templates
Template |
Description |
---|---|
JSFBlankWithLibs |
This template will create a standard Web project structure with all JSF capabilities |
JSFKickStartWithLibs |
This template will create a standard Web project structure but will also include a sample application that is ready to run |
JSFKickStartWithoutLibs |
Some servers already provide jsf libs and you take risk of getting conflicting libraries while deploying your project. To avoid such conflicts, use a template without libs if you have a server with its own jsf libraries |
On the next screen select what Servlet version to use and whether to register this application with JBoss AS (or other server) for running and testing of your application.
The Context Path is the name under which the application will be deployed.
The Runtime value tells Eclipse where to find Web libraries in order to build (compile) the project. It is not possible to finish project creation without selecting Runtime. If you don't have any values, select New... to add new Runtime.
The Target Server allows you specifying whether to deploy the application. The Target Server corresponds to the Runtime value selected above. If you don't want to deploy the application, uncheck this value.
When you are all done, you should have the project that has been appeared in the Package Explorer view:
At this point you can open faces-config.xml and start working on your application. JBDS provides a lot of features to develop JSF applications. We will describe the features further.
For detailed information on migration projects to JBoss Developer Studio see Migration Guide.
With JBoss Developer Studio it's also possible to add JSF capability (JSF libraries, tag libraries) to any existing Eclipse project in your workspace. After that you'll be able to make use of such JBoss Developer Studio editors as JSF configuration editor, JBoss Tools JSP editor and any others.
Right click the project and select JBoss Tools > Add JSF Capabilities. This will start the process of adding all necessary libraries, files to make this a Web JSF project.
The wizard will first ask you to show the web.xml file location and the project name.
On the last form you can set the different folders for your project as well as register this application with a servlet container.
Make sure to select Add Libraries for JBoss Developer Studio to add all required JSF related libraries to this project.
The Context Path is the name under which the application will be deployed.
The Runtime value tells Eclipse where to find Web libraries in order to build (compile) the project. It is not possible to finish project import without selecting Runtime. If you don't have any values, select New... to add new Runtime.
The Target Server allows you to specify whether to deploy the application. The Target Server corresponds to the Runtime value selected above. If you don't want to deploy the application, uncheck this value.
Once your project is imported you can see that JSF related libraries have been added to your project: jsf-api.jar and jsf-impl.jar .
Some application servers provide their own jsf implementation libraries. So, to avoid conflicts you should not add jsf libraries while adding jsf capabilities.
You are now ready to work with JSF by creating a new JSF configuration file:
Template is a set of files that serve as a basis to facilitate the creation of a new project. Project templates provide content and structure for a project.
JBoss Developer Studio has a powerful templating capability for creating new and importing existing Struts and JSF projects. This templating facility has a variety of aspects to consider. But, let's start with the most straightforward case and consider the process of creating a template from your existing JSF project.
Let's say you have a project that you want to use as the basis for a new template. Follow these steps to make a template out of it:
In the Web Projects view, right-click the project and select JBoss Tools JSF > Save As Template as template
In the first dialog box, you can choose a name for the template (defaults to the project name) and confirm what run-time implementation of the project's technology will be used
Select Next and you will be sent to a dialog box with your project structure displayed with check boxes. Here you can check only those parts and files in your project directory that should be part of the template
At this point, unless you want to designate some extra files as having Velocity template coding inside them, you should click Finish .
That's it. Now, you can use this template with any new or imported project that uses the same run-time implementation as the project you turned into a template.
JBDS provides a graphical editor for working with JSF configuration file ( faces-config.xml ). The editor has three main viewers (modes):
Diagram
Tree
Source
The modes can be selected via the tabs at the bottom of the editor.
The JSF configuration editor also comes with a very useful OpenOn selection feature. Now let's dwell on each mode and all specific functionality which they provide for work with JSF configuration file.
The Diagram view displays the navigation rules in the JSF configuration file:
To create a new page (view), you can click the page icon on this toolbar and then click anywhere on the diagram. A New Page Wizard will appear.
To create a transition (rule) connecting pages:
Select the transition icon from the toolbar (2nd from the bottom).
Click the source page.
Click the target page.
A transition will appear between the two pages:
It is also possible to create a new page with context menu by right-clicking anywhere on the diagram and selecting New View.
To edit an existing transition, first select the transition line. Then, place the mouse cursor over the last black dot (on the target page). The mouse cursor will change to a big +. At this point, drag the line to a new target page:
The Tree mode for the editor displays all JSF application artifacts referenced in the configuration file in a tree format. By selecting any node you can see and edit its properties which will appear in the right-hand area. For example, a Managed Bean:
To edit some artifact, right-click any node and select one of the available actions in the context menu. You can also edit in the properties window to the right:
The same way you can create a new artifact:
The Source mode for the editor displays a text view of the JSF configuration file. All three viewers are always synchronized, so any changes made in one of the viewers will immediately appear in the others:
Code Assist provides pop-up tip to help you complete your code statements. It allows you to write your code faster and with more accuracy.
Code assist is always available in the Source mode:
When you are developing your project, JBoss Developer Studio constantly provides error checking. This greatly reduces your development time as it allows you to catch many of the errors during development.
Errors will be reported by JBoss Developer Studio's verification facility:
Other errors are also reported.
You can also work in the Source editor with the help of the Outline view. The Outline views show a tree structure of the JSF configuration file. Simply select any element in the Outline view, and it will jump to the same place in the Source editor, so you can navigate through the source code with Outline view.
If your diagram is large, within Outline view you can switch to a Diagram Navigator mode by selecting the middle icon at the top of the view window. It allows you to easily move around the diagram. Just move the blue area in any direction, and the diagram on the left will also move:
You can also edit the properties of the selected element in the Tree mode with the help of the Properties view as shown below:
JBoss Developer Studio gives you lots of power to work with managed beans.
Add and generate code for new managed beans
Generate code for attributes and getter/setter methods
Add existing managed beans to JSF configuration file
To start, create a new managed bean in JSF configuration file editor, in the Tree view.
When you define a new managed bean, make sure that Generate Source Code is checked as shown in the figure below.
After the "Java" class has been generated you can open it for additional editing. There are two ways to open the "Java" class:
click on Managed-Bean-Class link in the editor
or
right click the managed bean and select Open Source
The generated Java source:
You can also generate source code for properties, also includes "getter" and "setter" methods. Right click on the bean and select New > Property . You will see Add Property dialog.
When the form is open make sure that all the check boxes are selected:
Once the generation is complete, you can open the file and see the added property with "getter" and "setter" methods:
Thus, we've discussed everything which comes to creating a new Managed Bean. Further we will show you how to add an existing Bean into a JSF configuration file.
If you already have a Java bean you can easily add it to a JSF configuration file.
You should start the same way you create a new managed bean. Use the Browse... button to add your existing Java class.
Once the class is set, it's Name will be set as well. But you can easily substitute it for the other one. Notice that Generate Source Code option is not available as the "Java" class already exists.
After adding your class Next button will be activated. Pressing it you'll get Managed Properties dialog where all corresponding properties are displayed. Check the necessary ones to add them into your JSF Configuration File.
If you don't want to add any, just click Finish.
Above-listed steps have demonstrated specifying an existing Bean in the JSF configuration file, i.e. faces-config.xml. In the next section you'll know how to organize and register a custom Converter to specify your own converting rules.
To create and register a custom converter it's necessary to go through the following steps:
In the Project Explorer view open faces-config.xml and select Tree tab.
Select Converters and click on Add button.
On the form type the name of your converter in the Converter-id field and name of the class for converters. After clicking Finish button your custom converter is registered under the entered name.
Now you can create "converter" class. In the Converter section you should see your Converter-id and Converter-class. Click on Converter-class to generate the source code.
A usual wizard for creating a Java class will appear. All needed fields here will be adjusted automatically. Just leave everything without changes and click Finish.
To open a converter class click again on Converter-class link in the Converter section. Now you are able to add a business logic of converter in the Java editor.
With the help of JBDS it's also quite easy to develop your own custom Validators. You should perform the actions similar to previous. Go through the following steps:
In the Project Explorer view open faces-config.xml and select Tree tab.
Select Validators and click on Add button.
Type the name of your validator in the Validator-id field and name of the class for validators. After clicking Finish button your custom validator is registered under the entered name.
Now you can create the "validator" class.
In the Validator section you can see your Validator-id and Validator-class . To generate the source code click on Validator-class.
Java class will be created automatically. Leave everything without changes and click Finish.
To open validator class click again on Validator-Class link in the Validator section. Now you are able to write a business logic of validator in the Java editor.
Creation of Referenced Beans is similar to creation of Custom Validator.
In the Project Explorer view open faces-config.xml and select Tree tab.
Select Referenced Beans and click on Add button.
Type in the name of your Referenced Bean and type in or select Referenced-Bean-Class by using Browse button.
In the Referenced Bean section you should see your Referenced-Bean-Name and Referenced-Bean-Class. Click on the link to open the Java creation wizard.
Java class will be created automatically. Leave everything without changes and click Finish.
To open Referenced Bean class click again on Referenced-Bean-Class in the Referenced Bean section. Now you are able to write business logic of Referenced Bean in the Java editor.
If you don't familiar with JSF technology, we suggest that you walk through the information on the topic.
If you prefer develop web applications using Struts technology JBoss Developer Studio also meets your needs.
JBDS supports the Struts 1.1, 1.2.x versions.
JBoss Developer Studio provides the following functionality when working with Struts:
Create new Struts projects
Import (open) existing Struts projects. You can import any project structure
Add Struts capabilities to any existing Eclipse project
Import and add Struts capabilities to any existing project created outside Eclipse.
JBoss Developer Studio includes a New Struts Project Wizard that radically simplifies the process for getting started with a new Struts project. You just need to follow these steps:
Select File > New > Project... from the menu bar. Then, select JBoss Tools Web > Struts > Struts Project in this dialog box. Click Next:
On this form, provide the Project Name. You can also select where to create the project or use the default path.
Next to Struts Environment set which Struts version to use.
Don't put spaces in project names since some OS could experience problems with their processing and searching these files.
You can select the KickStart template, then the project created will include a simple Hello World type application that is ready to run.
Next, you register this application with the current servlet container defined for your workspace (JBoss AS, by default) in order to allow you to test your application more easily while still developing it. A new entry will be added in the servlet container configuration file to enable running the application in-place (called null deployment or link deployment). Uncheck the "Target Server" check box if for some reason you don't want to register your application at this point.
On the next form, you can select the TLD files to include in this project:
After the project is created, you should have the following project structure (if you used the KickStart template):
If you want to hide the jar files from Web App Libraries in view, select the down-pointing arrow in the upper right corner, select Filters..., check the box next to Name filter patterns (matching names will be hidden), and type *.jar into the field. Then, click OK.
For detailed information on migration projects to JBoss Developer Studio see Migration Guide.
With JBoss Developer Studio you can add Struts capabilities (including Struts libraries, tag libraries and a Struts configuration file) to any existing Web application project in your Eclipse workspace. By adding a Struts Nature to your project, you can now edit files using JBoss Developer Studio editors, such as the Struts configuration editor and the JBoss Tools JSP editor.
To add Struts Nature to your existing Project right-click the project and select JBoss Tools > Add Struts Capabilities from the context menu. This will start the process of adding all necessary libraries and files to make this a Web Struts project.
In the wizard you should point to location of your deployment descriptor file web.xml and name of the project.
After hitting Next, you will see the following screen. This screen simply means that you need to add at least one Struts module to your project to make this project a Struts project. Adding a Struts module means that a new struts-config.xml will be added to your project and registered in the web.xml file. In addition, all required Struts libraries will be added. To add a Struts module, select the Add Struts Support button.
Here you can select what Struts Version, Servlet Class, URL Pattern and TLDs to add to this project.
When done, you will see the default Struts module configuration information. See how to Edit Struts modules.
On the last screen you can set the different folders for your project as well as register this application with a servlet container. If you want the libraries (.jar files) will be automatically added to your project, click on the checkbox Add Libraries.
When done, you can open end edit the struts-config.xml file using usefull Struts configuration file editor provided by JBDS. (The Struts configuration is shown below in the Tree viewer).
The Struts configuration file editor has three modes with different representation of struts-config.xml: Diagram, Tree and Source. The modes can be selected via the tabs at the bottom of the editor. Any changes made in one mode are immediately visible when you switch to any other mode.
When working in Source view, you always have all the following features available:
Content Assist
Open On Selection
File Folding
The Diagram mode graphically displays the Web flow of the application defined in the Struts configuration file.
The Diagram mode allows to edit navigation in your Struts application. Just by right-clicking anywhere on the diagram, you can use a context menu to create the building blocks of a Struts application:
Actions
Global forwards
Global exceptions
JSP Pages
Along the upper-left side of the editor is a stack of seven icons for changing the behavior of the cursor in the diagram.
The first icon switches to the default regular selection cursor, the second to the marquee selection cursor and the third to the new connection cursor. The last four icons switch the cursor to an insert cursor for each type of Struts build block listed above (and in the order listed).
For instance, clicking on the first of these four icons (the one with the gears) will switch the cursor to insert actions. Clicking anywhere in the diagram with this cursor has the same effect as right-click and selecting Add > Action... from the context menu with the regular cursor active. It's just more efficient to use this cursor if you're adding more than one action at once.
The Tree mode represents the different elements of the Struts application that are organized into functional categories on the left-hand side and a form for editing the properties of currently selected items on the right-hand side.
You can also right-click on any node in the category tree and perform appropriate operations through a context menu. For instance, by right-clicking on the action-mappings category node, you can add new actions to the application.
In the Source mode, you have complete editing control of the underlying XML coding.
You can take advantage of code assist.
The editor will also immediately flag any errors.
Finally, you can use the Outline view with the editor to easily navigate through the file.
Find more information about editor features here.
The Tiles configuration file editor has three main modes: Tree, Diagram and Source. The modes can be selected via the tabs at the bottom of the editor. Any changes made in one mode are immediately visible when you switch to any other mode.
When working in Source view, you always have all following features available:
Content Assist
Open On Selection
To create new Tiles files, right click any folder and select New > Tiles File.
The Tree mode represents the different elements of the Tiles file that are organized into functional categories on the left-hand side and a form for editing the properties of currently selected items on the right-hand side.
To edit the file, simply right click any node and select among the available actions.
The Diagram mode allows you to create complex Tiles files in the form of a diagram.
To create new definitions, simply right click anywhere in the diagram.
You can also use the Diagram toolbar to make editing easier.
It contains four icons for changing the cursor state. The first one is the default cursor state for selecting existing nodes. The second icon is marquee selector. The third is used for creating new connections and the last one is for adding definition template to the content.
The other mode of the Tiles editor is the Source mode that gives you full control over the source. Any changes here will immediately appear in other modes when you switch to them.
Code assist is available in the Source mode.
Any errors are immediately reported as shown below:
You can also use the Outline view together with the editor's Source mode. It provides an easier navigation through the file.
Providing full support for development Struts applications JBoss Developer Studio comes with a visual validation editor. To create a new validation file, right click any folder in Project Explorer and select File > New > Other... from the context menu and then JBoss Tools Web > Struts > Validation File.
The validation editor works with five modes: Formsets, Validators, Constants and standard Tree and Source that you can easily switch over using tabs at the bottom of the editor.
The Formsets mode shows forms and their elements on the left side and the dialogue for defining their validation rules on the right side.
The Constants mode let you set constant values for your validation rules.
The validation file can also be viewed in a Tree mode.
At any point you have full control over the source by switching to the Source mode. Any editing in this mode will immediately be available in other modes of the editor.
You can also open your own custom or Struts-standard validation-rules.xml file.
The Validators mode shows the validation rules for a selected validator. You can of course add your own rules.
Here are the validation rules shown in the Source mode.
JBoss Developer Studio supports working with Struts projects that have multiple modules. You can easily do the following:
Add new modules
Edit modules for an existing project or during Struts project import
During Struts project import, if the project has multiple modules, you will see a screen with all existing modules. You can select each module and edit its details.
To edit modules in an existing project, right click the project and select JBoss Tools > Modules Configuration.
You will see the same screen as above where you will be able to select a module and edit its details.
Adding a new module is very simple. First switch to Web Project view. Expand your project to the Configuration folder. Under that folder you should see the current modules. Right click on Configuration and select New > Struts Config.
You will see the screen below. You can specify a new module name and also add the new Struts configuration file to web.xml file.
JBoss Developer Studio comes with a code generation feature. You can generate stub code for Struts Actions, FormBeans, Forwards and Exceptions.
The code generation in JBoss Developer Studio is based on Velocity templates which can be modified for your use. The templates are located at {RedHatDeveloperStudioHome} > templates > codegeneration.
There are a number of ways to invoke code generation. One is simply right-clicking the Struts diagram and selecting Generate Java Code....
On this screen you can select for which elements to generate code. If you select Next you will be able to specify more options for each of the categories you selected.
please be careful not to override your existing files.
When generation is complete, a result window will appear letting you know how many classes were generated:
You don't always have to generate code for all elements at once. You can invoke generation for just an individual Struts artifact as well. Right-click an element on the diagram of the Struts configuration file and select Generate Java Code... from the context menu.
The same can be done from within the Tree viewer for the editor of the Struts configuration file.
JBoss Developer Studio comes with Struts configuration file debugger. It allows you to set break points on Struts diagram and then simply launch the server in debug mode.
Simply right click an Action or a page and select Add Breakpoint.
Custom page links allow you to define custom Struts page links that will be recognizable in the Struts application diagram. You can define these links by selecting Window > Preferences from the menu bar and then selecting JBoss Tools > Web > Struts > Customization from the Preferences dialog box.
Find out necessary information on Struts technology if you don't know enough.
As you are developing your project, JBoss Developer Studio Verification constantly provides dynamic validation, consistency checking and error checking. This greatly reduces your development time as it allows you to catch many of the errors during development. JBoss Developer Studio provides dynamic verification for both JSF and Struts projects.
JBoss Developer Studio checks for many different rules for a JSF project that can be configured by selecting Window > Preferences from the menu bar, selecting JBoss Tools > Web > Verification from the Preferences dialog box and then expanding the JSF Rules node.
Suppose you are working in the Source viewer for a JSF configuration file as shown below:
While typing a class name, you might make a minor typo (like "jsfHello.PersonBean9" instead of "jsfHello.PersonBean" ). After saving the file, verification checks to make sure everything is correct and finds the error below:
Notice that the Package Explorer View shows a marked folder and a marked file where the error is.
You can place the cursor over the line with an error message and get a detailed error message:
Verification also checks navigation rules:
If you provide a page name that does not exist, verification will let you know about that:
You can always call up verification explicitly by right-clicking any element in the tree and selecting Verify from the context menu. This works from both the Tree and Diagram viewers for the JSF configuration file editor. You can also invoke verification from the Web Projects view. Below we are checking all of the elements in the configuration file.
JBoss Developer Studio provides the same functionality for Struts projects. To configure Struts project verification select Window > Preferences from the menu bar, select JBoss Tools > Web > Verification from the Preferences dialog box and then expand the Struts Rules node.
Suppose you are working in the Source viewer for a Struts configuration file as shown below:
While typing a class name or entering it from the graphical editor, you might make a minor typo (like "sample.GreetingAction1" instead of "sample.GreetingAction" ). After saving the file, verification checks to make sure everything is correct and finds the error below:
Notice that the Package Explorer View shows a marked folder and a marked file where the error is.
You can place the cursor over the line with the error to view a detailed error message:
The verification also checks to make sure you have specified the correct JSP page for the forward:
Once you place the cursor over the line, you can see the error message:
You can always invoke the verification by switching to the Diagram viewer, right-clicking and selecting Verify from the context menu: