In this example we will see how we
can validate a login page using Struts Let's first create the login page. We use
Struts UI tags to create the login page. The <s:head /> tag should be
placed in the headsection of the HTML
page. The s:head tag automatically generates links to the css and javascript
libraries that are necessary to render the form elements.
The s:form tag contains all the form
elements. The action attribute contains the action name to wich the form should be submitted.
This action name should be same as the one specified in the XML declarative
architecture. In this example we use struts.xml file to do the configuration.
The textfield tag is used create a
text box. The label attribute of the textfield tag contains the name to be displayed on the
page and the name attribute contains the name of the property in the action class to be
mapped. The password tag is same as the textfield tag except that the input
value is masked. The submit tag is used to create a submit button, the value
"Login" represents
the label of the button.
Note that the code
is simple without any HTML tables, this is because Struts 2 will automatically
create the necessary tables for the page based on the theme selected. By
default the XHTML theme is selected.
<%@taglib
uri="/struts-tags" prefix="s" %>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Login Page</title>
<s:head />
</head>
<body>
<s:form action="Login">
<s:textfield name="userName" label="User Name" />
<s:password name="password" label="Password" />
<s:submit value="Login" />
</s:form>
</body>
</html>
When the user
clicks the Login button the request will be forwarded to the Login action.
We do the action
mapping using the struts.xml file. First we need to create a package for our
action.
<struts>
<package name="default" extends="struts-default">
<action name="Login" class="vaannila.Login">
<result name="input">/login.jsp</result>
<result name="success">/success.jsp</result>
</action>
</package>
</struts>
Here our "default" package
extends "struts-default" package. By
extending the "struts-default" package the
action will by default inherit the set of interceptors defined in the
defaultstack. The "struts-default" package is
defined in the struts-default.xml file.
All the common
tasks done by the Actions are seperated and placed in different interceptors.
You can define an interceptor stack for each action. Most commonly used
interceptors are grouped in defaultstack of the struts-default package. The
defaultstack will be sufficient in most cases. The inteceptors will be fired in
the order in which they are declared in the stack both before and after the
action is executed.
Here the "Login" action is
mapped to the "Login" class in the
"vaannila" package. The
results are defined using the "<result>" element. If any
validation errors occur the user will be forwarded to the login.jsp page. If
the login is successfull then the user will be forwarded to the success.jsp page.
The defaultstack
contains the following interceptors.
<interceptor-stack name="defaultStack">
<interceptor-ref name="exception"/>
<interceptor-ref name="alias"/>
<interceptor-ref name="servletConfig"/>
<interceptor-ref name="prepare"/>
<interceptor-ref name="i18n"/>
<interceptor-ref name="chain"/>
<interceptor-ref name="debugging"/>
<interceptor-ref name="profiling"/>
<interceptor-ref name="scopedModelDriven"/>
<interceptor-ref name="modelDriven"/>
<interceptor-ref name="fileUpload"/>
<interceptor-ref name="checkbox"/>
<interceptor-ref name="staticParams"/>
<interceptor-ref name="actionMappingParams"/>
<interceptor-ref name="params">
<param name="excludeParams">dojo\..*,^struts\..*</param>
</interceptor-ref>
<interceptor-ref name="conversionError"/>
<interceptor-ref name="validation">
<param name="excludeMethods">input,back,cancel,browse</param>
</interceptor-ref>
<interceptor-ref name="workflow">
<param name="excludeMethods">input,back,cancel,browse</param>
</interceptor-ref>
</interceptor-stack>
Our Login Action
class extends ActionSupport. It is good to extend ActionSupport class as it
provides default implementation for most common tasks.
public class Login extends ActionSupport {
private String
userName;
private String
password;
public Login() {
}
public String
execute() {
return SUCCESS;
}
public void validate() {
if (getUserName().length() == 0) {
addFieldError("userName", "User Name is required");
} else if (!getUserName().equals("Eswar")) {
addFieldError("userName", "Invalid User");
}
if (getPassword().length() == 0) {
addFieldError("password", getText("password.required"));
}
}
public String
getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String
getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
The ActionSupport class implements Action interface which exposes the execute() method.
The following
constants are declared in the Action interface which can be used as return
values in the execute() method.
public
static final String ERROR = "error"
public
static final String INPUT = "input"
public
static final String LOGIN = "login"
public
static final String NONE = "none"
public
static final String SUCCESS = "success"
ERROR is returned when the action execution
fails.
INPUT is returned when the action requires
more input from the user.
LOGIN is returned when the user is not
logged into the system.
NONE is returned when the action execution
is successfull and there are no views to display.
SUCCESS is returned when the action executed
successfully and the corresponding result is displayed to the user.
Now lets see the
roles played by the different interceptors.
The params interceptor helps in transfering the request data onto the action
object.
The workflow interceptor controls the flow of cotrol.
The workflow interceptor checks
whether the action implements the Validateable interface , if it does, the workflow interceptor will invoke the validate() method of the
Action class.
In the validate() method we validate
the user name and the password. If the validation fails an error is added using
the addFiledError() method.
The validate() method doesn't return
any errors, instead it stores all the errors with the help of theValidationAware interface.
Now the workflow
interceptor will check any validation errors has occured. If any error has
occured the workflow interceptor will stop the request processing and transfer
the control to the input page with the appropriate error messages.
On executing the
sample example the following page will be displayed to the user.
For each field the
error messages can be added using the addFieldError() method. The error
messages can either be added directly or it can be specified in a seperate
properties file.
The properties files should have the
same name as the Action class. In our case the properties file name is "Login.properties" and the
Action name is "Login.java".
The
Login.properties file contains the following entry.
password.required = Password is required.
The getText()
method provided by the TextProvider interface can be used to retrive the error
messages.
You can also do the
business validations in the validate() method.
If there are no
errors, then the execute() method will be invoked by the workflow interceptor.
No comments:
Post a Comment