Struts Web Framework With Netbeans

• Overview of the Application
• Setting Up a Struts Application
• Creating JSP Pages
  • Creating a Login Page
  • Creating a Success Page
• Creating an ActionForm Bean
• Creating an Action Class
• Implementing Validation
  • Accessing Bean Data and Preparing a Forwarding Condition
  • Setting Up an Error Message
• Adding forward Entries to struts-config.xml
• Configuring and Running the Application
  • Setting the Welcome Page
  • Attaching a Stylesheet
  • Running the Application
• See Also

• The Java installation enables you to optionally install the GlassFish server and the Apache Tomcat servlet container. You must install one of these (or register a different server in the IDE) to work through this tutorial.
• If you need to compare your project with a working solution, you can download the sample application.

Overview of the Application

Setting Up a Struts Application

1. Choose File > New Project (Ctrl-Shift-N; ⌘-Shift-N on Mac) from the main menu. Under Categories, select Web. Under Projects, select Web Application and click Next.
2. In the Name and Location panel, enter MyStrutsApp for Project Name and click Next.
3. In the Server and Settings panel, select the server to which you want to deploy your application. Only servers that are registered with the IDE are listed. (To register a server, click Add next to the Server drop-down list.) Also, note that the Context Path to your deployed application becomes /MyStrutsApp. Click Next.
4. In the Frameworks panel, select Struts:
   
   For purposes of this tutorial, do not change any of the configuration values in the lower region of this panel. These are the following:
   • Action Servlet Name: The name of the Struts action servlet used in the application. The web.xml deployment descriptor contains an entry for the action servlet and specifies the appropriate Struts-specific parameters, such as the path to the servlet class within the Struts library and to the struts-config.xml configuration file within the application.
   • Action URL Pattern: Specifies the patterns of incoming requests which are mapped to the Struts action controller. This generates a mapping entry in the deployment descriptor. By default, only the *.do the pattern is mapped.
   • Application Resource: Lets you specify the resource bundle which will be used in the struts-config.xml file for localizing messages. By default, this is com.myapp.struts.ApplicationResource.
   • Add Struts TLDs: Lets you generate tag library descriptors for the Struts tag libraries. A tag library descriptor is an XML document that contains additional information about the entire tag library as well as each individual tag. In general, this is not necessary, because you can refer to on-line URIs rather than local TLD files.
5. Click Finish. The IDE creates the project folder in your file system. As with any web application in the IDE, the project folder contains all of your sources and the IDE's project metadata, such as the Ant build script. However, your web application in addition has all of the Struts libraries on its classpath. Not only are they on the application's classpath, but they are included in the project and will be packaged with it later when you build the project.

<servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
    <init-param>
        <param-name>config</param-name>
        <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>
    <init-param>
        <param-name>debug</param-name>
        <param-value>2</param-value>
    </init-param>
    <init-param>
       <param-name>detail</param-name>
       <param-value>2</param-value>
    </init-param>
    <load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>

Creating JSP Pages

• Creating a Login Page
• Creating a Success Page

<html:form action="/login">
    <table border="0">
        <tbody>
            <tr>
                <td>Enter your name:</td>
                <td><html:text property="name" /></td>
            </tr>
            <tr>
                <td>Enter your email:</td>
                <td><html:text property="email" /></td>
            </tr>
            <tr>
                <td></td>
                <td><html:submit value="Login" /></td>
            </tr>
        </tbody>
    </table>
</html:form>

Creating an ActionForm Bean

1. Right-click the MyStrutsApp project node and choose New > Other. Under Categories choose Struts, then under File Types choose Struts ActionForm Bean. Click Next.
2. Type in LoginForm for the Class Name. Then select com.myapp.struts in the Package drop-down list and click Finish. The IDE creates the ActionForm bean and opens it in the Source Editor. By default, the IDE provides it with a String called name and an int called number. Both fields have accessor methods defined for them. Also, the IDE adds a bean declaration to the struts-config.xml file. If you open the struts-config.xml file in the Source Editor, you can see the following declaration, which was added by the wizard:
   

   <form-beans>
       <form-bean name="LoginForm" type="com.myapp.struts.LoginForm" />
   </form-beans>

   The IDE provides navigation support in the struts-config.xml file. Hold down the Ctrl key and hover your mouse over the ActionForm bean's fully qualified class name. The name becomes a link, enabling you to navigate directly to the class in the Source Editor:
   
3. In the ActionForm bean in the Source Editor, create fields and accompanying accessor methods that correspond to the name and email text input fields that you created in login.jsp. Because name has already been created in the ActionForm skeleton, you only need to implement email. Add the following declaration beneath name (changes in bold):
   

   private String name;
   private String email;

   To create accessor methods, place your cursor on email and press Alt-Insert.
   Select Getter and Setter, then in the dialog that displays, select email : String , and click Generate. Accessor methods are generated for the email field.
   
   Note: You can delete the declaration and accessor methods for number, as it is not used in this tutorial.

Creating an Action Class

1. In the Projects window, right-click the MyStrutsApp project node and choose New > Other. From the Struts, category choose Struts Action and click Next.
2. In the Name and Location panel, change the name to LoginAction.
3. Select com.myapp.struts in the Package drop-down list.
4. Type /login in Action Path. This value must match the value you set for the action attribute of the <html:form> tags in login.jsp. Make sure settings appear as in the screenshot below, then click Next.
   
5. In the third step of the wizard, you are given the opportunity to associate the Action class with a form bean. Notice that the LoginForm bean you previously created is listed as an option for ActionForm Bean Name. Make the following adjustments to the panel:
   • Delete the forward slash for the Input Resource field
   • Set Scope to Request (Session is the default scope setting in Struts.)
   • Deselect the Validate ActionForm Bean option
   Click Finish. The LoginAction class is generated, and the file opens in the Source Editor. Also, note that the following action entry is added to the struts-config.xml file:

   <action-mappings>
       <action name="LoginForm" path="/login" scope="request" 

   type="com.myapp.struts.LoginAction" validate="false"/>
       <action path="/Welcome" forward="/welcomeStruts.jsp"/>
   </action-mappings>

   The name and scope attributes apply to the form bean that is associated with the action. Specifically, when an incoming request matches /login, the Struts framework automatically instantiates a LoginForm object and populates it with the form data sent in the request. The default value of validate is set to true. This tells the framework to call the validate method of the form bean. You deselected this option in the wizard however because you will hand-code simple validation in the next step, which does not require the validate method.

Implementing Validation

public ActionForward execute(ActionMapping mapping, ActionForm form,
    HttpServletRequest request, HttpServletResponse response)
    throws Exception {

    return mapping.findForward(SUCCESS);
}

private final static String SUCCESS = "success";

• Accessing Bean Data and Preparing a Forwarding Condition
• Setting Up an Error Message

public class LoginAction extends org.apache.struts.action.Action {

    private final static String SUCCESS = "success";
    private final static String FAILURE = "failure";

    public ActionForward execute(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response)
            throws Exception {

        // extract user data
        LoginForm formBean = (LoginForm)form;
        String name = formBean.getName();
        String email = formBean.getEmail();

        // perform validation
        if ((name == null) ||             // name parameter does not exist
            email == null  ||             // email parameter does not exist
            name.equals("") ||            // name parameter is empty
            email.indexOf("@") == -1) {   // email lacks '@'

            formBean.setError();
            return mapping.findForward(FAILURE);
        }

        return mapping.findForward(SUCCESS);

    }
}

Adding forward Entries to struts-config.xml

1. Open struts-config.xml in the Source Editor, right-click anywhere in the action entry for LoginForm, and choose Struts > Add Forward.
   
2. In the Add Forward dialog box, type success in forwarding Name. Enter the path to success.jsp in the Resource File field (i.e., /WEB-INF/success.jsp). The dialog box should now look as follows:
   
   Click Add. Note that the following forward entry was added to struts-config.xml (changes in bold):

   <action name="LoginForm" path="/login" scope="request" 

   type="com.myapp.struts.LoginAction" validate="false">
       <forward name="success.jsp" path="/WEB-INF/success.jsp"/>
   </action>

3. Perform the same action to add a forward entry for failure. Set the Resource File path to /login.jsp. The following forward entry is added to struts-config.xml (changes in bold):

   <forward name="success" path="/WEB-INF/success.jsp"/>
   <forward name="failure" path="/login.jsp"/>

Configuring and Running the Application

• Setting the Welcome Page
• Attaching a Stylesheet
• Running the Application

Setting the Welcome Page

1. In the Projects window, double-click the web.xml deployment descriptor. The tabs listed along the top of the Source Editor provide you with an interface to the web.xml file. Click on the Pages tab. In the Welcome Files field, enter login.jsp.
   
   Now click on the XML tab to view the file. Note that login.jsp is now listed in the welcome-file entry:

   <welcome-file>login.jsp</welcome-file>

Attaching a Stylesheet

1. Add a simple stylesheet to the project. One easy way to do this is by saving this sample stylesheet to your computer. Copy the file (Ctrl-C), then in the IDE, select the Web Pages node in the Projects window and press Ctrl-V). The file is added to your project.
2. Link the stylesheet to your JSP pages by adding a reference between the <head> tags of both login.jsp and success.jsp:

   <link rel="stylesheet" type="text/css" href="stylesheet.css">

Running the Application

1. In the Projects window, right-click the project node and choose Run. The IDE builds the web application and deploys it, using the server you specified when creating the project. The browser opens and displays the login.jsp page. Type in some data that should fail validation, i.e., either leave either field blank or enter an email address with a missing '@' sign:
   
   
   When you click Login, the login form page redisplays, containing an error message:
   
   
   Try entering data that should pass validation. Upon clicking Login, you are presented with the success page: