JBoss.org Community Documentation

Struts Tools Tutorial

Version: 1.0.0.GA

Copyright © 2007 Red Hat

1. Introduction
2. Getting Started Guide for Creating a Struts Application
2.1. Starting Up
2.2. Creating the Application Components
2.2.1. Creating JSP Page Placeholders
2.2.2. Creating an Action Mappings
2.2.3. Creating a Link
2.2.4. Creating a Forward
2.2.5. Creating a Global Forward
2.2.6. Creating a Form Bean
2.3. Generating Stub Coding
2.4. Coding the Various Files
2.4.1. Java Stub Classes
2.4.2. JSP Pages
2.5. Compiling the Classes
2.6. Running the Application
2.7. Other relevant resources on the topic
3. Getting Started Struts Validation Examples
3.1. Starting Point
3.2. Defining the Validation Rule
3.3. Client-Side Validation
3.4. Server Side Validation
3.5. Editing the JSP File
3.6. Editing the Action
3.7. Editing the Form Bean
3.8. Other Resources

Chapter 1. Introduction

The following chapters describe how to deal with classic/old style of Struts development. We recommend users to use JBoss Seam to simplify development, but until then you can read about classical Struts usage here.

Chapter 2. Getting Started Guide for Creating a Struts Application

2.1. Starting Up
2.2. Creating the Application Components
2.2.1. Creating JSP Page Placeholders
2.2.2. Creating an Action Mappings
2.2.3. Creating a Link
2.2.4. Creating a Forward
2.2.5. Creating a Global Forward
2.2.6. Creating a Form Bean
2.3. Generating Stub Coding
2.4. Coding the Various Files
2.4.1. Java Stub Classes
2.4.2. JSP Pages
2.5. Compiling the Classes
2.6. Running the Application
2.7. Other relevant resources on the topic

We are going to show you how to create a simple Struts application using the JBoss Developer Studio. The completed application will ask a user to enter a name and click a button. The resulting new page will display the familiar message, "Hello <name>!"

This document will show you how to create such an application from the beginning, along the way demonstrating some of the powerful features of JBoss Developer Studio. You will design the application, generate stub code for the application, fill in the stub coding, compile the application, and run the application all from inside JBoss Developer Studio.

We assume that you have already launched Eclipse with JBoss Developer Studio installed and also that the Web Development perspective is the current perspective. (If not, make it active by selecting Window > Open Perspective > Other > Web Development from the menu bar.)

We are first going to create a new project for the application.

A "StrutsHello" node should appear in the upper-left Package Explorer view.

At this point, its empty except for the background grid lines.

Now, we will design the application by creating the individual components as placeholders first. (We dont have to complete all of the details inside the components until afterwards.)

Next, let's create and place two JSP pages. We will not write any code for the files, but only create them as placeholders so that we can create links to them in the diagram. We will write the code a little bit later.

Just leave these files as is for now.

Lets now place the two pages just created on the diagram.

You should now have two JSP pages in the diagram.

Using a context menu on the diagram, we are next going to create an Action mapping.

Table 2.1. 

path/greeting
nameGetNameForm
scoperequest
typesample.GreetingAction
validate<leave blank>

("GetNameForm" is the name for a form bean that we will create later.)

  • Click Finish

The /greeting action should appear in four places, in the diagram, under the action-mappings node, under the struts-config.xml node in Tree view, in Web Projects view and in the Outline view. Also, note the asterisk to the right of the name, struts-config.xml, in the Outline view showing that the file has been changed, but not saved to disk.

Let's now create a link from the inputname.jsp page to the action.

Create New Connection Icon

Figure 2.1. Create New Connection Icon


  • In the connect-the-components mode you are in now, click on the /pages/inputname.jsp icon in the diagram and then click on the /greeting action

A link will be created from the page to the action.

Next, we are going to create a forward for the action.

Create New Connection Icon

Figure 2.2. Create New Connection Icon


  • Click on the /greeting action icon in the diagram and then click on the pages/greeting.jsp icon

  • That's it. A link will be drawn from the actions new greeting forward to the greeting.jsp JSP page. Note that the forwards name will be set based on the name of the target JSP file name. If you don't like it, you can easily change it

  • Select the Tree tab at the bottom of the editor window (between Diagram and Source)

  • Expand the struts-config.xml/action-mappings//greeting node and then select the greeting forward

  • In the Properties Editor to the right, change the text to "sayHello" in the Name field

  • Select the Diagram tab at the bottom of the editor window and see how the diagram is also updated to reflect the change

One last component that we need to create in the diagram is a global forward.

A forward object now appears on the diagram and also in the global-forwards folder in the Outline view.

Diagram View

Figure 2.3. Diagram View


One last thing that we need to do is to create a form bean.

Note the disappearance of the asterisk next to the name, struts-config.xml.

We are done with designing the application through the diagram. Now we need to write code for the action component. We also need to write an action class for the /greeting mapping along with a FormBean. To aid in the coding phase, JBoss Developer Studio can generate Java class stubs for all of the components shown in the diagram.

You should see a screen that says:

Generated classes: 2

Actions: 1

Form beans: 1

The Java files will be generated in a JavaSource > sample folder that you can see in the Package Explorer view under the "StrutsHello" node. One Action stub and one FormBean stub will have been generated.

We will now code both the Java stub classes just generated, the JSP files left in as placeholders from previous steps, and a new start JSP page we will have to create.

private String name = "";

     private String greetName = "";

this.name = "";

     this.greetName = "";

ActionErrors errors = new ActionErrors();

     return errors;

The final GetNameForm.java file should look like this:

package sample;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts.action.ActionErrors;

import org.apache.struts.action.ActionMapping;


public class GetNameForm extends org.apache.struts.action.ActionForm 

{

    

    private String name = "";

    private String greetName = "";

    

    public String getName() 

    {

        return name;

    }

    public void setName(String name) 

    {

        this.name = name;

    }

    

    public String getGreetName() 

    {

        return greetName;

    }

    

    public void setGreetName(String greetName) 

    {

        this.greetName = greetName;

    }

    

    public GetNameForm() 

    {

    }

    

    public void reset(ActionMapping actionMapping, HttpServletRequest request) 

    {

        this.name = "";

        this.greetName = "";

    }

    

    public ActionErrors validate(ActionMapping actionMapping, 

            HttpServletRequest request) 

    {

        ActionErrors errors = new ActionErrors();

        return errors;

    }

}

String name = ((GetNameForm)form).getName();

String greeting = "Hello, "+name+"!";

((GetNameForm)form).setName(greeting);

return mapping.findForward(FORWARD_sayHello);

The final version of GreetingAction.java should look like this:

package sample;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionForm;

import org.apache.struts.action.ActionForward;

import org.apache.struts.action.ActionMapping;


public class GreetingAction extends org.apache.struts.action.Action 

{

    

    // Global Forwards

    public static final String GLOBAL_FORWARD_getName = "getName";

    

    // Local Forwards

    public static final String FORWARD_sayHello = "sayHello";

    

    public GreetingAction() 

    {

    }

    public ActionForward execute(ActionMapping mapping, ActionForm form,

    HttpServletRequest request, HttpServletResponse response) throws Exception 

    {

        String name = ((GetNameForm)form).getName();

        String greeting = "Hello, "+name+"!";

        ((GetNameForm)form).setName(greeting);

        return mapping.findForward(FORWARD_sayHello);

    }

}

The last thing left to do is to code the JSP files whose editors should still be open from having been created as placeholders.

In this page, the user will enter any name and click the submit button. Then, the greeting action will be called through the form.


Input name:
JBoss Tools Palette

Figure 2.4. JBoss Tools Palette


  • In the Insert Tag dialog box, type in name for property and select Finish

  • In the StrutsForm library in the JBoss Tools Palette, select submit, and drag it to right after the text box in the Visual pane of the editor

  • Right-click the submit button and select <html:submit> Attributes from the context menu

  • In the Attributes dialog box, select the value field and type in "Say Hello!" for its value

After tidying the page source, the Editor window for the file should look something like this:

Editor Window

Figure 2.5. Editor Window


Next, we will fill in the result page.


<html>

<head>

    <title>Greeting</title>

</head>

    <body>

        <p>

        </p>

    </body>

</html>

To complete editing of this file, we will use macros from the JBoss Tools Palette. This palette is a view that should be available to the right of the editing area.

This will insert the following line at the top of the file:



<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>

The editor should now look like this:

Editor Window

Figure 2.6. Editor Window


Finally, we will need to create and edit an index.jsp page. This page will use a Struts forward to simply redirect us to the getName global forward.

The finished code for the page is shown below:

<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>

<logic:redirect forward="getName"/>

Because this is the Eclipse environment, no explicit compilation step is required. By default, Eclipse compiles as you go.

Everything is now ready for running our application without having to leave JBoss Developer Studio by using the JBoss Application Server engine that comes with the JBoss Developer Studio. For controlling JBoss AS within JBoss Developer Studio, there is JBoss Server view.

JBoss Server Panel

Figure 2.7. JBoss Server Panel


  • Start up JBoss AS by clicking on the icon in JBoss Server view. (If JBoss AS is already running, stop it by clicking on the red icon and then start it again. Remember, the Struts run-time requires restarting the servlet engine when any changes have been made.)

  • After the messages in the Console tabbed view stop scrolling, JBoss AS is available. At this point, right-click on the getName global forward in the struts-config.xml diagram view and select Run on Server.

The browser should appear with the application started.

Apache Struts: Struts Technology

Struts 2: Apache Struts 2

Get Started: Struts Getting Started

Struts on IBM: Struts - An open-source MVC implementation

FAQ: Struts FAQ

Download: Release of Apache Struts

Chapter 3. Getting Started Struts Validation Examples

3.1. Starting Point
3.2. Defining the Validation Rule
3.3. Client-Side Validation
3.4. Server Side Validation
3.5. Editing the JSP File
3.6. Editing the Action
3.7. Editing the Form Bean
3.8. Other Resources

Validation of input is an important part of any Web application. All Apache Jakarta frameworks, including Struts, can use a common Jakarta Validation Framework for streamlining this aspect of Web application development. The Validation Framework allows you to define validation rules and then apply these rules on the client-side or the server-side.

JBoss Developer Studio makes using the Validation Framework in Struts even easier with the help of a specialized editor for the XML files that controls validation in a project. In this document, we'll show you how this all works by creating some simple client-side validation and server-side validation examples.

The example assumes that you have already created our sample "StrutsHello" application from the Getting Started Guide for Creating a Struts Application. You should have the JBoss Developer Studio perspective open on this StrutsHello project.

In these steps you will set up the validation that can be used for either client-side or server side validation. You need to enable validation as a part of the project, define an error message, and tie it into an appropriate part of the application.

Create Formset

Figure 3.1. Create Formset


  • Expand the "form-beans" node under the StrutsHello > Configuration > default > struts-config.xml node. Then, drag the form bean "GetNameForm" and drop it onto a formset in the XML Editor

  • In the Validation Editor, expand the formset node, right-click GetNameForm, and select Create Field... from the context menu

  • Enter a name for Property in the dialog box. A new property will be created:

New Property Is Added

Figure 3.2. New Property Is Added


  • In the Properties view for the name field to the right of the "tree" for the validation.xml file, click on the Change...button next to the Depends entry field

  • In the displayed double list, select required from the left list and then click Add

  • Click Ok

  • Right-click name and select Add Arg... from the context menu

  • In the Add Arg dialog box, click on the Change...button next to the Key field

  • In the Key dialog box that appears now, click on the Add button

  • Enter "name.required" in the Name field, and enter a person's name in the Value field

  • Click Finish, then Ok, and then Ok again

  • Select File > Save All from the menu bar

Client-side validation uses a scripting language (like JavaScript) running in the client browser to actually do the validation. In a Struts application using the Validation Framework, however, you don't actually have to do any of the script coding. The Validation Framework handles this.

To see how this works in our application, you'll just need to make a couple of modifications to one of the JSP files.


onsubmit="return validateGetNameForm(this)"

The file should now look like this:




<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>

<html:html>

<head>

    <title>Input name</title>

    <html:javascript formName="GetNameForm"/>

</head>

<body>

    <html:form action="/greeting.do" onsubmit="return

        <para>validateGetNameForm(this)"></para>

        <table border="0" cellspacing="0" cellpadding="0">

            <tr>

                <td><b>Input name:</b></td>

            </tr>

            <tr>

                <td>

                    <html:text property="name" />

                    <html:submit value=" Say Hello! " />

                </td>

            </tr>

        </table>

    </html:form>

</body>

</html:html>
Run Icon

Figure 3.3. Run Icon


  • In the browser window, click on the "Say Hello!" button without having entered any name in the form

A JavaScript error message should be displayed in an alert box.

Server side validation does the validation inside the application on the server. In a Struts application using the Validation Framework, you still don't have to do any of the actual validation coding. The Validation Framework handles this. You will though have to make a few changes to the JSP file you modified for client-side validation along with a change to an action and a few changes to the form bean class.

The JSP file should now look like this:


<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>

<html:html>

<head>

    <title>Input name</title>

    <html:javascript formName="GetNameForm"/>

</head>

<body>

    <html:form action="/greeting.do">

        <table border="0" cellspacing="0" cellpadding="0">

            <tr>

                <td><b>Input name:</b></td>

            </tr>

            <tr>

                <td>

                    <html:text property="name" />

                    <html:submit value=" Say Hello! " />

                </td>

            </tr>

        </table>

    </html:form>

    <html:errors />

</body>

</html:html>

The file should now look like this:

package sample;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts.action.ActionErrors;

import org.apache.struts.action.ActionMapping;

public class GetNameForm extends


org.apache.struts.validator.ValidatorForm 

{


    private String name = "";

    

    /**

    * @return Returns the name.

    */

    public String getName() 

    {

        return name;

    }

    

    /**

    * @param name The name to set.

    */

    public void setName(String name) 

    {

        this.name = name;

    }

    

    public GetNameForm () 

    {

    }

    

    public void reset(ActionMapping actionMapping, 

        HttpServletRequest request) 

    {

        this.name = "";

    }

    

    // public ActionErrors validate(ActionMapping actionMapping,

        HttpServletRequest request) 

    {

        // ActionErrors errors = new ActionErrors();

        // return errors;

        // }

    }

The error message should appear in a refreshed version of the form.

You can also read Struts chapter in our "Visual Web Tools" guide for more information on this topic.