Here, the WelcomeAction Java class executes whenever someone asks for the Welcome action. As it completes, the Action class can select which page is displayed. Two pages the class can select here are error.jsp and welcome.jsp. But the Action class doesn’t need to know the path to the pages. The class can select them just using the names success or failure.

Why would the WelcomeAction want to only choose between success and failure?

Typically an application uses a database. If it can’t connect to the database, it can’t do its job. So before displaying the welcome page, the class runs some environment checks to see if the database is indeed available. The app is also internationalised, so adds some more checks to see if the message resources are available too. If both resources are available, the class forwards to the success path. Otherwise, it forwards to the failure path so that the appropriate error messages can be displayed.

{% highlight java %} public final class WelcomeAction extends Action {

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

ArrayList messages = new ArrayList();
MessageResources resources = getResources(request);
if (resources==null) {
  messages.add("ERROR:  Message resources not loaded");
}

UserDatabase userDatabase = getUserDatabase(request);
if (userDatabase==null) {
  messages.add("ERROR:  User database not loaded");
}

if (messages.size()>0) {
  request.setAttribute("ERROR", messages);
  return findFailure(mapping);
}

return (mapping.findForward("success"));

} } {% endhighlight %}

Plugins⌗

When a Struts application loads, it also loads whatever PlugIns are specified in its configuration. The PlugIn interface is quite simple, and you can them to do anything that might need to be done when your application loads. The PlugIn is also notified when the application shuts down, so you can release any allocated resources.

{% highlight xml %} {% endhighlight %}

Message Resources⌗

Another section of the Struts configuration loads the message resources for the application. If you change a message in the resource, and then reload the application, the change will appear throughout the application. If you provide message resources for additional locales, you can internationalize your application.

{% highlight xml %} {% endhighlight %}

You might not want to use the default resource bundle if you have several of them, and can use the key element to distinguish between them:

{% highlight xml %} {% endhighlight %}

The V in MVC (JSP)⌗

After confirming that the necessary resources exist, the WelcomeAction forwards to the welcome.jsp page. Struts provides many convenience JSP tag libraries. Here bean:message, html:link, and html:img are show cased:

{% highlight jsp %} <%@ page contentType=“text/html;charset=UTF-8” language=“java” %> <%@ taglib uri="/tags/struts-bean" prefix=“bean” %> <%@ taglib uri="/tags/struts-html" prefix=“html” %>

Change Language

• English
• Japanese
• Russian

• The bean:message tag inserts a message from the MessageResources file. If the Struts locale setting is changed for a user, the bean:message tag will render messages from that locale’s property bundle instead.
• The html:link tag does double duty. First, you can refer to an action or forward stored in the Struts configuration, and the tag will insert the corresponding path when the page is rendered. This makes it easy to rewire an application without touching all the pages. Second, the link tag will URL encode the hyperlink to maintain the client session. Your application can maintain client state without requiring cookies.
• The html:img tag renders an img tag. When necessary, the src URI is encoded as it is with the link tag. In this case, the tag inserts the src path from the “alternate” MessageResource bundle, along with the text for the alt element.
• When rendered, the welcome page lists two menu options: one to register with the application and one to login in (if you have already registered).

Let’s pick apart this part:

<html:link action="/Logon">
  <bean:message key="index.logon"/>
</html:link>

This should render an anchor <a href="" /> element, linking to the Login action. struts-config.xml shows us that the Login action is just a pass through forward action:

<action path="/Logon" forward="/logon.jsp"/>

logon.jsp:

{% highlight jsp %} <%@ page contentType=“text/html;charset=UTF-8” language=“java” %> <%@ taglib uri="/tags/struts-bean" prefix=“bean” %> <%@ taglib uri="/tags/struts-html" prefix=“html” %>

html:xhtml/

<html:errors />

<html:form action="/SubmitLogon" focus=“username” onsubmit=“return validateLogonForm(this);">

</html:form>

<html:javascript formName=“LogonForm” dynamicJavascript=“true” staticJavascript=“false” />

<jsp:include page=“footer.jsp” />

• html:errors, the credentials entered processed by the LogonAction class. If the credentials are incorrect, the LogonAction posts an appropriate error message and forwards back to the input page. If the html:errors tag sees that one or more messages were posted, the tag ouputs the messages to the page. The text of the messages can be specified in the MessageResource bundle, making them easy to internationalise.
• html:form renders an html form tag. The action element tells the tag to use SubmitLogon.do for the form’s action. The focus attribute tells the tag to generate a little Javascript after the form that sets its focus to the username field. The onsubmit attribute tells the form to run a Javascript when the form is submitted.
• Finally we see an html:javascript tag, which works together with the Struts Validator component to generate a JavaScript that can validate input before it is submitted to the LogonAction.

LogonAction.java:

{% highlight java %} public final class LogonAction extends Action { static String USERNAME = “username”; static String PASSWORD = “password”;

User getUser(UserDatabase database, String username, String password, ActionMessages errors) throws ExpiredPasswordException {

User user = null;
if (database == null){
  errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage("error.database.missing"));
}
else {
  user = database.findUser(username);
  if ((user != null) && !user.getPassword().equals(password)) {
    user = null;
  }
  if (user == null) {
    errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage("error.password.mismatch"));
  }
}

return user;

}

void SaveUser(HttpServletRequest request, User user) { HttpSession session = request.getSession(); session.setAttribute(Constants.USER_KEY, user); }

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

UserDatabase database = getUserDatabase(request);
String username = (String) PropertyUtils.getSimpleProperty(form, USERNAME);
String password = (String) PropertyUtils.getSimpleProperty(form, PASSWORD);
ActionMessages errors = new ActionMessages();

User user = getUser(database,username,password,errors);

if (!errors.isEmpty()) {
  this.saveErrors(request, errors);
  return (mapping.getInputForward());
}

SaveUser(request,user);

return (findSuccess(mapping));

}

} {% endhighlight %}

Validation⌗

The above logon.jsp featured some nifty Javascript validation, which was somehow magically generated by the Struts framework:

<html:javascript formName="LogonForm" dynamicJavascript="true" staticJavascript="false" />
<script language="Javascript1.1" src="staticJavascript.jsp"></script>

How does the Javascript tag know what scripts to write? How do the text and password tags know what values to redisplay? For answers, we need to turn to the Struts configuration files, struts-config.xml and validation.xml.

struts-config.xml:

{% highlight xml %}

…

…

Action attributes and child elements:

• path: the request pattern of the action.
• type: the action JavaBean.
• name: specifies something Struts calls an ActionForm. The ActionForm buffers input from a form and delivers it to an Action class as an object. The ActionForm can also validate the input. If validation fails, the tags can rewrite the input values from the ActionForm. The ActionForms are defined in the formbeans section of the struts configuration file. ActionForms can be conventional or dynamic. Here, we are using a dynamic ActionForm (DynaValidatorForm). Rather than cobble up an actual JavaBean class, we specify the properties the ActionForm can accept in the configuration file. If the property is not specified here, it is not captured, validated, or passed up to the Action class. In this mode, Struts creates the ActionForms automatically.
• scope: tells the controller whether to store the ActionForm in the request or session.
• input: Struts can also validate the ActionForm automatically. If validation fails, Struts looks for the forward (defined by the action itself or in global-forwards) specified by the input attribute. In this case, the logon forward sends control back to Logon.do, which in turn fires the LogonAction.
• Within the logon action element a new child element, exception, makes an appearance. <exception key="expired.password" type="net.bencode.web.ExpiredPasswordException" path="/ExpiredPassword.do" />. When a user logs on, it’s possible that an ExpiredPasswordException will be thrown by the data access layer. Should this happen, Struts will capture the exception and send control to the ExpiredPassword action.

The Struts best practice is to use request scope for single-page forms that contain all the properties needed by the Action. There is usually no need to maintain form data across requests.

validation.xml:

In the logon.jsp, we mentioned that the html:javascript tag confers with the Struts Validator components. The Validator is configured through another XML document, the validation.xml. Here’s the element for the LogonForm:

{% highlight xml %}

  <field property="password" depends="required, minlength,maxlength">
    <arg key="prompt.password"/>
    <arg key="${var:minlength}" name="minlength" resource="false"/>
    <arg key="${var:maxlength}" name="maxlength" resource="false"/>
    <var>
      <var-name>maxlength</var-name>
      <var-value>16</var-value>
    </var>
    <var>
      <var-name>minlength</var-name>
      <var-value>3</var-value>
    </var>
  </field>
</form>

public ActionForward execute(...) throws Exception {
  ...
  return (mapping.findForward("success"));
}

<action path="/MainMenu" forward="/mainMenu.jsp" />

if (valid) {
  return (EVAL_PAGE);
} else {
  ModuleConfig config =
    (ModuleConfig) pageContext.getServletContext().getAttribute(
      org.apache.struts.Globals.MODULE_KEY);
  
    try {
      pageContext.forward(config.getPrefix() + page);
    } catch (ServletException e) {
      throw new JspException(e.toString());
    } catch (IOException e) {
      throw new JspException(e.toString());
    }
   
  return (SKIP_PAGE);
}

String action = request.getParameter("action");
if (action == null) {
  action = "Create";
}

HttpSession session = request.getSession();

User user = null;
if (!"Create".equals(action)) {
  user = (User) session.getAttribute(Constants.USER_KEY);
  if (user == null) {
    return (mapping.findForward("logon"));
  }
}

...

return (mapping.findForward("success"));

<ul>
  <logic:iterate name="user" property="subscriptions" id="subscription">
    <li>
      <bean:write name="subscription" property="host" filter="true" />
    </li>
  </logic:iterate>
</ul>

<html:select property="type">
  <html:options
    collection="serverTypes"
    property="value"
    labelProperty="label"
  />
</html:select>

<select name="type">
  <option value="imap" selected>IMAP Protocol</option>
  <option value="pop3">POP3 Protocol</option>
</select>

if ((host == null) || (host.length() < 1))
  errors.add("host", new ActionMessage("error.host.required"));
if ((username == null) || (username.length() < 1))
  errors.add("username", new ActionMessage("error.username.required"));
if ((password == null) || (password.length() < 1))
  errors.add("password", new ActionMessage("error.password.required"));
if ((type == null) || (type.length() < 1))
  errors.add("type", new ActionMessage("error.type.required"));
else if (!"imap".equals(type) && !"pop3".equals(type))
  errors.add("type", new ActionMessage("error.type.invalid", type));

return (errors);