What is Struts :

* Struts is open source Web Application Framework for developing Java EE web application Developed by Apache in
2000.
* Struts 1 Framework was implemented on MVC 2 architecture and Front Controller Design Pattern.
* Struts mainly deals with Presentation Layer and Controller Layer. Struts does not specify or force any rules related
to model layer.
We can use any thing in Model Layer as per our requirement.
* Struts can interact with standard data access technologies, like JDBC and EJB, as well as most any third-party
packages, like Hibernate, iBATIS, or Object Relational Bridge.
* Struts has 3 Components on Controller Layer ActionServlet, RequestProcessor, Actions.
* For the View, Struts works well with JSP, including JSTL and EL, Struts Tag Library, Message Bundles, Form
Beans as well as Velocity Templates, XSLT, and other presentation systems.
* Struts provide various Tag Libraries for different purpose.
* It was originally created by Craig McClanahan and donated to the Apache Foundation in May, 2000.

Advantage of Struts :
Thread Safe

Difference between Struts and JSF :

* Struts is a Framework but JSF is a Technology.
* JSF bean class is not extending any built-in class like Struts Action and Bean class methods are not taking any
Parameters like Struts execute() method.
* The faces-config.xml is much easier to use than is the struts-config.xml file. In general, JSF is simpler.
* An event and listener model that defines how to handle events generated by activating a component, such as what to
do when a user clicks a button. Struts is not.
* The Struts validation framework includes a larger set of standard validators, which automatically generate both
server-side and client-side validation code based on a set of rules in a configuration file. While JSF has limited built in
Validations.
* The Struts controller can do things like access control on each Action based on user roles. This functionality is not
provided by JSF.

* Only one instance is created for ActionServlet, RequestProcessor, Action.

* We can replace ActionServlet & RequestProcessor class with our own class.

* ActionForm class Object creation One per Session / Request when scope is Session / Request.

Struts Controller Layer:

Following are various components of Struts Controller Layer.

A) ActionServlet
B) RequestProcessor
C) Actions

ActionServlet:-

ActionSerlvet is the Controller Servlet which is responsible for the following.

1) Initializing Struts Configuration document

2) Receiving request and delegating to RequestProcessor

2)RequestProcessor :-

RequesrProcessor is responsible for receiving the request, processing the request completely and delivers the response
to client.

RequestProcessor will do the following tasks while processing the request.

1) request.getrequestURI()
2) ActionMapping processMapping(HttpServletRequest req,HttpServletResponse res,URI)
3) ActionForm processActionForm(HttpServletRequest req,HttpServletResponse res,ActionMapping)
4) void processPopulate(HttpServletRequest req,HttpServletResponse res,ActionForm,ActionMapping)
5) boolean processValidate(HttpServletRequest req,HttpServletResponse res,ActionForm,ActionMapping)
 6) Action processActionCreate(HttpServletRequest req,HttpServletResponse res,ActionMapping)
7) ActionForward processActionPerform(HttpServletRequest req,HttpServletResponse res,Action,ActionForm,
ActionMapping)
8) ActionForward processException(HttpServletRequest req,HttpServletResponse res,Exception,ActionForm,
ActionMapping)
Or
boolean processForward(HttpServletRequest req,HttpServletResponse res,ActionMapping)

3)Actions :-

Action is the last component in the controller layer from where business layer starts.
Action class you are writing may be subclass of one the following built-in Actions.

1. Action
2. Dispatch Action
3. Lookup Dispatch Action
4. Mapping Dispatch Action
5. IncludeAction
6. ForwardAction
7. switch Action
8. LocaleAction
9. DownloadAction

ActionServlet :
import org.apache.struts.action.ActionServlet;
public class ActionServlet extends HttpServlet{}
ActionServlet provides the "controller" in the MVC design pattern for web applications that is commonly
known as "Model 2".
ActionServlet is responsible for initializing Struts Configuration document (sturts-config.xml).
Receiving the request and delegating to RequestProcessor.

RequestProcessor :
import org.apache.struts.action.RequestProcessor;
public class RequestProcessor extends Object{}
* RequestProcessor contains the processing logic that the ActionServlet performs as it receives each servlet request
from the container.
* RequestProcessor is responsible for receiving the request, processing the request completely and delivers the
response to the client.
* We can customize the request processing behavior by subclassing this class and overriding the method(s) whose
behavior we are interested in changing.

protected ActionMapping processMapping(HttpServletRequest, HttpServletResponse, String)

Select the mapping used to process the selection path for this request.

protected ActionForm processMapping(HttpServletRequest, HttpServletResponse, String)

Select the mapping used to process the selection path for this request.

ActionMapping :
import org.apache.struts.action.ActionMapping;
public class ActionMapping extends ActionConfig{}
* An ActionMapping represents the information that the controller, RequestProcessor, knows about the mapping of a
particular request to an instance of a particular Action class.
* The ActionMapping instance used to select a particular Action is passed on to that Action, thereby providing access
to any custom configuration information included with the ActionMapping object.

ActionForward :
import org.apache.struts.action.ActionForward;
public class ActionForward extends ForwardConfig{}
* An ActionForward represents a destination to which the controller, RequestProcessor, might be directed to perform
a
RequestDispatcher.forward or HttpServletResponse.sendRedirect to, as a result of processing activities of an Action
class.
* Instances of this class may be created dynamically as necessary, or configured in association with an
ActionMapping instance for named
lookup of potentially multiple destinations for a particular mapping instance.

ActionErrors :
import org.apache.struts.action.ActionErrors;
public class ActionErrors extends ActionMessages implements Serializable {}
* A class that encapsulates the error messages being reported by the validate() method of an ActionForm. Validation
errors are either global to the entireActionForm bean they are associated with, or they are specific to a particular
bean property (and, therefore, a particular input field on the corresponding form).
* Each individual error is described by an ActionMessage object, which contains a message key (to be looked up in an
appropriate message resources database), and up to four placeholder arguments used for parametric substitution in
the resulting message.
IMPLEMENTATION NOTE - It is assumed that these objects are created and manipulated only within the context of a
single thread. Therefore, no synchronization is required for access to internal collections.

ActionMessage :
import org.apache.struts.action.ActionMessage;
public class ActionMessage extends Object implements Serializable {}
An encapsulation of an individual message returned by the validate method of an ActionForm, consisting of a
message key (to be used to look up message text in an appropriate message resources database) plus up to four
placeholder objects that can be used for parametric replacement in the message text.

ActionMessages :
import org.apache.struts.action.ActionMessages;
public class ActionMessages extends Object implements Serializable {}
A class that encapsulates messages. Messages can be either global or they are specific to a particular bean property.
Each individual message is described by an ActionMessage object, which contains a message key (to be looked up in
an appropriate message resources database), and up to four placeholder arguments used for parametric substitution
in the resulting message.

IMPLEMENTATION NOTE - It is assumed that these objects are created and manipulated only within the context of
a single thread. Therefore, no synchronization is required for access to internal collections.

import org.apache.struts.action.ActionForm;
class LoginForm extends ActionForm{

public void reset(ActionMapping, HttpServletRequest){}

public ActionErrors validate(ActionMapping, HttpServletRequest){

return errors; // errors is an object of ActionErrors class
}
}

import org.apache.struts.action.Action;
class LoginAction extends Action{
public ActionForward execute(ActionMapping, ActionForm, HttpServletRequest,
HttpServletResponse)throws Exception{
return ActionMapping.findForward(String);
}
}

Web.xml
<web-app>

<display-name>JLC_Lab1</display-name>

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

<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,/WEB-INF/jlcindia-config.xml</param-value>
</init-param>

<init-param>
<param-name>debug</param-name>
<param-value>3</param-value>
</init-param>

<init-param>
<param-name>detail</param-name>
<param-value>3</param-value>
</init-param>

<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>

</web-app>

struts-config.xml (place in /WEB-INF folder)

<struts-config>

<data-sources>
<data-source></data-source>
</data-sources>

<form-beans>
<form-bean name="loginForm" type="com.jlcindia.LoginForm"/>
</form-beans>

<global-exceptions>
<exception key="errors.bidsearch.bid.notfound"
path="/bidSearch.jps"
type="com.jlcindia.BatchIDNotFoundException"/>
</global-exceptions>

<global-forwards>
<forward name="success" path="/home.jsp"/>
</global-forwards>

<action-mappings>
<action path="/loginSubmit"
name="loginForm"
type="com.jlcindia.LoginAction"
scope="request"
validate="true"
input="/login.jsp">
<forward name= path=/>
<exception key= type= path=/>
</action>

</action-mappings>

<controller/>

<message-resources parameter="com.jlcindia.MyMessage"/>

<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
<set-property value="/WEB-INF/validator-rules.xml, /WEB-INF/myform-validations.xml" property="pathnames"/>

<plug-in className=org.apache.struts.tiles.Tilesplugin>
<set-property value=/WEB-INF/tiles.xml property=definitions-config/>
</plug-in>

</plug-in>

</struts-config>

Struts Request Processing Flow:-> (stuts flow)

When I start the Server after deploying struts based web application, then following tasks will happen at
container start up.

1) Container initializes the ActionServlet because of <load-on-startup>

A) Loads the ActionServlet class(org.apache.struts.action.ActionServlet)
B) Creates the ActionServlet class instance.
C) Creates the ServletConfig object and initializes the ServletConfig object with init parameters
(config,debug,detail)
D) Invokes the init() method by passing ServletConfig object as parameter.
2) Init() method is responsible for parsing the Data(reading the data) from Struts configuration document.
3) If any errors found while parsing xml then ActionServlet will not be initialized and not ready to serve the
requests.
4) If no errors found while parsing xml then ActionServlet will be initialized and ready to Serve the requests
with url-pattern *.do

When you request for resource (login.jsp) then following things will happen.

A) Container invokes the service() method of ActionServlet.

B) ActionServlet delegates the request to RequestProcessor.
C) RequestProcessor starts the processing of given request by doing the following tasks.

1) RequestProcessor checks whether the requested Resource is available or not.

2) If the requested Resource is not available then error message will be given with Http status code:404
3) If the requested Resource is available then Request processor checks whether that Resource ( JSP)
contains any <html:form > tag.
4) If the identified resource does not contain any <html:form> tag then error message will be given
(500:cannot find bean org.apache.struts.taglib.html.BEAN in any scope)
5) If the identified resource contains <html:form> tag then takes the RequestURI(action attribute value).
6) RequestProcessor checks whether any <action> tag is available in struts config.xml whose path attribute
value is same as action attribute value.
7) If No matching action is found then error message will be given.
(500: cannot retrieve mapping for action/LoginSubmit1)
8) If matching action is found then RequestProcessor takes form bean name.
9) RequestProcessor checks whether any <form-bean> tag is available in struts-config.xml whose name
attribute value is same as action name attribute value.
10) If No matching form bean is found then error message will be given.
(500: cannot retrieve definition for form bean loginForm)
 11) If matching form bean is found then RequestProcessor takes the Form bean type which is the Form bean
java class.
12) RequestProcessor starts the Form bean lifecycle.

A) Loads the Form bean java class

B) Creates the Form bean java class object by calling default constructor.
C) Stores the Form bean object in the given scope (default scope is session)
D) Calls the reset() method (it is used to set the default values).
E) Collects the data from Form bean object by calling getter methods and populates that data in jsp form
fields.
13) Identified resource will be rendered to client.

When you submit the Form(login.jsp) then following things will happen.

A. Container invokes the service() method of ActionServlet.

B. ActionServlet delegates the request to RequestProcessor.
C. RequestProcessor starts the processing of given request by doing the following tasks.

1. RequestProcessor takes the RequestURI(action attribute value)

2. RequestProcessor checks whether any <action> tag is available in sturts-config.xml whose path attribute
value is same as action attributes value
3. If No matching action is found then error message will be given.
(500:cannot retrieve mapping for action/LoginSubmit1).
4. If matching action is found then RequestProcessor takes form bean name.
5. RequestProcessor checks whether any <form-bean> tag is available in struts-config.xml whose name attribute
value is same as action name attribute value.
6. If No matching form bean is found then error message will be given.
a. (500: cannot retrieve definition for form bean loginForm)

7. If matching form bean is found then RequestProcessor takes the Form bean type which is the Form bean java
class.
8. RequestProcessor starts the Form bean lifecycle.
a. Creates or retrieves the Form bean object.
b. Calls the reset() method.
c. Collects the data from client submitted request and stores the Form bean object by calling setter
methods.
d. Invokes the validate() method.
e. If ActionErrors object contains any ActionError objects then takes the input jsp and forwards to
client with error messages.
f. If ActionErrors object does not contain any ActionError objects the RequestProcessor takes action
type.
9. Creates or retrieves the Action class object.
10. Invokes execute() method.
11. Execute() method may return ActionForward object on the successful completion or Exception.
12. RequestProcessor identifies the JSP related to ActionForward object returned or Exception thrown by
execute() method.
13. Identified JSP will be rendered to Client.

Handling Exception thrown by Action class:-

Steps:-
1) Write the Required User-defined Exception

Class BatchIDNotFoundException extends Exception{

2) throw that User-defined Exception in any Action class

throw new BatchIDNotFoundException();

 3) configure the following <exception> in struts-config.xml

<struts-config>
<form-beans>
<form-bean name="bidSearchForm" type="com.jlcindia.struts1.BidSearchForm" />
</form-beans>
<action-mappings>
<action path="/BidSubmit" name="bidSearchForm"
type="com.jlcindia.struts1.BidSearchAction" scope="session" validate="true"
input="/bidsearch.jsp">

<exception type="com.jlcindia.struts1.BatchIDNotFoundException"
path="/bidsearch.jsp"
key="errors.bidsearch.bid.notfound" />

<forward name="bidsearch" path="/bidsearch.jsp" />

</action>
</action-mappings>
<message-resources parameter="com.jlcindia.struts1.ApplicationResources" />
</struts-config>

4) add the key in property file

errors.bidsearch.bid.notfound=Student Not Found.

5) Display the Error message with <html:errors/>

Handling ActionErrors in Action class:-

Write the following in Action class:-

ActionErrors errors = new ActionErrors();

errors.add("sid", new ActionError("errors.sidsearch.sid.notfound"));
this.saveErrors(req, errors);

write in Form class as follows:-

public ActionErrors validate(ActionMapping am,HttpServletRequest req){

ActionErrors errors=new ActionErrors();
if(sid==null || sid.length()==0){
errors.add("sid",new ActionError("errors.sidsearch.sid.required"));
}else if(!sid.startsWith("JLC-")){
errors.add("sid",new ActionError("errors.sidsearch.sid.format1"));
}else{
String p2=sid.substring(4);
if(p2.length()==0 || p2.length()>4){
errors.add("sid",new ActionError("errors.sidsearch.sid.format2"));
}else{
try {
int x=Integer.parseInt(p2);
} catch (Exception e) {
errors.add("sid",new ActionError("errors.sidsearch.sid.format2"));
}}}
return errors;
}

Struts Layers:-
Struts mainly deals with presentation layer and Controller layer.
Struts does not specify or force any rules related to model layer.
You can use any thing in model layer as per your requirement.

Struts Presentation Layer:-

You can implement the following components in the presentation layer of sturts application.
1) JSP element
2) EL (expression language)
3) JSTL
4) Struts Tag Library
5) Message Bundles
6) Form Beans

Struts Tag Library :-

Threre are six tag libraries provided.

1) HTML Tag Library

2) Bean Tag Library
3) Logic Tag Library
4) Tiles Tag Library
5) Nested Tag Library
6) Template Tag Library

Message Bundles:-

Message Bundle is nothing but a property file where you can define key-value pairs.
Message Bundle can used to centralize two types of Message.
1) Labels
2) Error Messages by validation

A) Labels :-

a) Define the Label in Message Bundle

label.sidSearch.sid=Enter Student Id
b) Accessing in JSP

<bean:message key= label.sidSearch.sid/>

B) Error Messages by validation

a) Define the errors in Message Bundle

errors.sidsearch.sid= Student Id is Required

b) Use the key to create the ActionError Object when you are adding ActionError Object to ActionErrors
Object.

errors.add(sid, new ActionError(errors.sidsearch.sid);

c) Accessing in JSO
<html:errors property=sid/> ->it shows errors realeted to sid

<html:errors/> -> it shows all errors

 Form Beans :

Threre are six form beans

1) ActionForm
2) DynaActionForm
3) ValidatorForm
4) DynaValidatorForm
5) ValidatorActionForm
6) .DynaValidatorActionForm

Struts Form Bean Class :

----------------------------
import org.apache.struts.action.ActionForm;
public abstract class ActionForm extends Object implements Serializable {}
An ActionForm is a JavaBean optionally associated with one or more ActionMappings. Such a bean will have had its
properties initialized from the corresponding request parameters before the corresponding Action.execute method is called.

import org.apache.struts.action.DynaActionForm;
public class DynaActionForm extends ActionForm implements DynaBean{}
Specialized subclass of ActionForm that allows the creation of form beans with dynamic sets of properties, without requiring
the developer to create a Java class for each type of form bean.

import org.apache.struts.validator.ValidatorForm;
public class ValidatorForm extends ActionForm implements Serializable{}
This class extends ActionForm and provides basic field validation based on an XML file. The key passed into the validator is
the action element's 'name' attribute from the struts-config.xml which should match the form element's name attribute in the
validation.xml.

import org.apache.struts.validator.DynaValidatorForm;
public class DynaValidatorForm extends DynaActionForm implements DynaBean, Serializable{}
This class extends DynaActionForm and provides basic field validation based on an XML file. The key passed into the
validator is the action element's 'name' attribute from the struts-config.xml which should match the form element's name
attribute in the validation.xml.

import org.apache.struts.validator.ValidatorActionForm;
public class ValidatorActionForm extends ValidatorForm implements Serializable{}
This class extends ValidatorForm and provides basic field validation based on an XML file. The key passed into the validator
is the action element's 'path' attribute from the struts-config.xml which should match the form element's name attribute in the
validation.xml.

import org.apache.struts.validator.DynaValidatorActionForm;
public class DynaValidatorActionForm extends DynaValidatorForm implements DynaBean, Serializable{}
This class extends DynaValidatorForm and provides basic field validation based on an XML file. The key passed into the
validator is the action element's 'path' attribute from the struts-config.xml which should match the form element's name
attribute in the validation.xml.

Struts Validation :
Struts Framework provides the functionality to validate the form data. It can be use to validate the data on the users
browser as well as on the server side. Struts provides two ways to perform Validations on input data :
1. Basic Validation (through validate() method)
2. Validation Framework Validations.

Basic Validations :-

when you write the validation logic inside the validate() method of form bean java class
then those are called as Basic validations.
 validate() method signature must be as follows.
public ActionErrors validate(ActionMapping, HttpServletRequest)

validate() method invocation will be depending on validate attribute of <action> tag.

Possible values of validate attribute are true or false.

If true then validate() method will be called
If false the validate() will be not called.

Validation Framework Validations:-

Validation Framework Validations is a separate Framework. it is not a part of Struts Framework.

If you want to use validation Framework Validations in struts , you must explicitly integrate validation
Framework with struts by writing the following <plug-in> in struts-configuration document.
For using this we have to integrate like-

<plug-in className=org.apache.struts.validator.ValidatorPlugIn>
<set-property property=pathnames value=/WEB-INF/validator-rules.xml,/WEB-INF/myform-
validator.xml>
</plug-in>

validator-rules.xml (3rd Party Rules defined/Registered here)

* it should be placed in /WEB-INF folder

* Apache has implemented some commonly required validations called

required, minlength, maxlength, email, data, byte, short, integer,

long, float double etc.

All these built-in validators are registered in validator-rules.xml.

* We can implement our own validation (Custom Validation) and you can register custome validations in validator-
rules.xml.

myform-validation.xml (use validator-rules.xml here)

It should be placed in /WEB-INF folder

You hava to specify the validations required for various fileds of your form.

Steps:-

1) Identify the Form and corresponding field validations.

Form name:LoginForm
Username: required,minlength,maxlength
Password:required, minlength,maxlength

2) Specify the validations required for various fields of login form in myform-validations.xml
<form name=loginForm>
<field property=username depends=required>
<arg0 key=login.un resource=true/>
</field>
<field property=password depends=required>
<arg0 key=Password resource=false/>
</field>

2) Add the required properties in message bundle

errors.required=<font color=red size=5> {0} is required</font>
login.un=Username
3) Use the correct form bean type
Public class LoginForm extends ValidatorForm{

}
Note:
We can use there validation Framework with
1. ValidatorForm,
2. DynaValidatorForm,
3. ValidatorActionForm,
4. DynaValidatorActionForm

4) To display errors in jsp, use<html:errors/>

Developing Custom Validation

1) Write the java class with the name JLCFieldChecks

2) Write one or more methods required depending on number of custom validations required.
3) Implements the required validation logic inside those methods.
public class JLCFieldChecks{
public boolean validateSID(Object, ValidatorAction, Field, ActionErrors, HttpServletRequest){
// write validation logic.
}
}
4)Register the Custom Validation in validator-rules.xml
---------------------------------------------------------------
<form-validation>
<global>
<validator name=sidformat
classname=com.jlcindia.struts. JLCFieldChecks
method= validateSID
methodParams=java.lang.Object,
org.apache.commons.validator.ValidatorAction
org.apache.commons.validator.Field,
org.apache.struts.action.ActionErrors,
javax.servlet.http.HttpServletRequest
msg=errors.sidformat>
</validator>
<validator>
// same for another method
</validator>
</global>
</form-validation>

4) Identify the form and corresponding field validations.

Form name: BidSearchForm

Bid:required,bidformat

Form name:sidSearchForm
Sid:required,sidformat
5) Specify the validation required for various fields in myform-validations.xml

<form name=bidSearchForm>
<field Proeprty=bid depends=required,bidformate>
<arg0 key=BatchId resource=false/>
</field>
</form>

<form name=sidSearchForm>
<field Proeprty=sid depends=required,sidformate>
<arg0 key=StudentId resource=false/>
</field>
</form>

6) Add the required properties in message bundle.

 7) Use the correct form bean type.
Public class LoginForm extends ValidatorForm{

}
8) To display errors in jsp, use <html:errors/>

Form Bean:
Form bean is Container of Data
Form bean can be in three scopes.
1) Request
2) Session
3) Application

Default scope of a form bean is session.

Form bean object can be initialized in two ways.
1) With the client submitted data( RequestProcessor will do automatically)
2) With the data Collected from DB ( you have to do explicitly).

Form Bean LifeCyle:

1) Loads the Form Bean class (one Time)

2) Created or Retrives the Form Bean Object.
3) If static form is used then calls the reset() method.
If dynamic form is used then all the fields will be reset to defaults automatically or fields will be initialized
with data specified for initial attribute of <form-property> tag
4) Collects the clients submitted data and populates into Form bean object
5) If(validate==true){
If(BasicValidation){
Invokes the validate() method overridden by you
}else{
Invokes various validatexx() method as per myformvalidations.xml
}
If any errors found
Request will be forwarded to input jsp
}else{
Go to step 6
}
}else{
Go to step6

6) execute() method will be called.

There are six types of Form beans.

1) ActionForm
2) DynaActionForm
3) ValidatorForm
4) DynaValidatorForm
5) ValidatorActionForm
6) DynaValidatorActionForm

These six types can be divided into 2 categories.

1) Static forms
2) Dynamic forms

NA-Not Applicable, VF Validations- Validation framework validations

SN Form Bean class ActionF DynaActi ValidatorFor DynaValidatorF ValidatorActi DynaValidator
orm onForm m orm onForm ActionForm

1
Static/Dynamic Static Dynamic Static Dynamic Static Dynamic
2
Fields declaration in YES NO YES NO YES NO
class
3
Fields declaration in NO YES NO YES NO YES
XML
4
reset() method YES NO(initial YES NO(initial YES NO(initial
attribute) attribute) attribute)
5
Validate() method YES NO YES NO YES NO
6
Validations Basic NA Basic and VF VF Validations Basic and VF VF Validations
Validati Validations Validations
ons
7
Validation Binding NA NA Form bean Form bean Action path Action path
name name value value

Tiles Framework :

Tiles framework is a seprate Framework and is not a part of sturts framework.

You have to explicitly integrate Tiles Framework with sturts1.x ,struts2.x.JSF1.x,JSF2.x,SpringMVC
You integrate Tile Framework with sturts, you have to add the following <plug-in> in struts-config.

<plug-in className="org.apache.struts.tiles.TilesPlugin">
<set-property value="WEB-INF/tiles.xml" property="definitions-config"/>
</plug-in>
tiles.xml should be in WIB-INF folder and will contain various Tiles Definitions.
<tiles-definitions>
<definition name= >
</tiles-definitions>

Tiles Framework is mainly a Layout design framework which allows you to centerlize the web page
Layouts,text formats,styles required etc

Struts integration with Spring Framework:

--------------------------------------------------
* No Changing in web.xml only ActionServlet will be configured.

* in struts-config.xml
<action path=/sidSubmit
name=sidForm
type=org.springframework.web.struts.DelegatingActionProxy
input=/sidSearch.jsp/>

<plug-in className=org.springframework.web.struts.ContextLoaderPlugIn>
<set-property property=contextConfigLocation
value=/WEB-INF/studentContext.xml/>
</plug-in>

* in studentContex.xml (Spring Configuration)

<beans>
<bean name=/sidSubmit class=com.jlcindia.struts.SidSearchAction>
<property name=>
<ref bean=/>
</property>
</bean>
</beans>

Note : DelegatingActionProxy is class extends from Action class.

In this above example - type=org.springframework.web.struts.DelegatingActionProxy
Because of this configuration, RP invokes always execute() method of DelegatingActionProxy class for any incoming
request URI. DelegatingActionProxy is responsible for looking up the spring container to find Action class instance
whose name is same as incoming request URI.

* In a Struts application Model Class interacts with database.

* Bean:message is to display message from .propertiesfile. Bean:write this tag is used to output bean property value from
bean property.

How RequestProcessor decides that validation is success or fail?

Based on ActionErrors instance returned by Formbean java class validate().

* Request processor`s processActionForm() instantiates Frombean java class.

What scope is applied to Frombean?

Request or session, depending upon what you selected while creating Formbean. Default Frombean scope is session.

What is the difference between ActionForm and DynaActionForm?

To get the data from user entered text fields we use Form bean concept in Struts. While using form bean, you need to create a
java class with few setters and getter and that class need to be extended from ActionForm. While using DynaActionForm
you no need to write a java class directly you can get the user details without including setter and getter methods.

Can you explain the directory structure for a struts folder in brief ?
Answers : Below are the folders from point of view of root folder.
3 META-INF: - This directory has the Meta information.
WEB-INF/classes: - This location has the actual JAVA classes.
WEB-INF/classes/ApplicationResources.properties:- Contains text which application can
use. For instance error messages.
WEB-INF/lib/struts.jar:- Contains the Struts servlet, helper classes, taglib code etc.
WEB-INF/*.tld:- The Struts tag libraries.
WEB-INF/struts-config.xml:- A Struts configuration file.
WEB-INF/web.xml:- Configuration file for the servlet container
Index.jsp:- All JSP files come in the root directory as this one Index.jsp.

ActionServlet?
ActionServlet is a simple servlet which is the backbone of all Struts applications. It is the main Controller component that
handles client requests and determines which Action will process each received request. It serves as an Action factory
creating specific Action classes based on users request.

7.What is role of ActionServlet?

ActionServlet performs the role of Controller:
Process user requests
Determine what the user is trying to achieve according to the request
Pull data from the model (if necessary) to be given to the appropriate view,
Select the proper view to respond to the user
Delegates most of this grunt work to Action classes
Is responsible for initialization and clean-up of resources

What design patterns are used in Struts?

Struts is based on model 2 MVC (Model-View-Controller) architecture. Struts controller uses the command design
pattern and the action classes use theadapter design pattern. The process() method of the RequestProcessor uses
the template method design pattern. Struts also implement the following J2EE design patterns.
Service to Worker
Dispatcher View
Composite View (Struts Tiles)
Front Controller
View Helper
Synchronizer Token

38.What is difference between ActionForm and DynaActionForm?

An ActionForm represents an HTML form that the user interacts with over one or more pages. You will provide
poerties to hold the state of the form with getters and setters to access them. Whereas, using DynaActionFormthere
is no need of providing properties to hold the state. Instead these properties and their type are declared in thestruts-
config.xml
The DynaActionForm bloats up the Struts config file with the xml based definition. This gets annoying as the Struts
Config file grow larger.
The DynaActionForm is not strongly typed as the ActionForm. This means there is no compile time checking for the
form fields. Detecting them at runtime is painful and makes you go through redeployment.
ActionForm can be cleanly organized in packages as against the flat organization in the Struts Config file.
ActionForm were designed to act as a Firewall between HTTP and the Action classes, i.e. isolate and encapsulate the
HTTP request parameters from direct use in Actions. With DynaActionForm, the property access is no different than
using request.getParameter( .. ).
DynaActionForm

Question: What are difference between ActionErrors and ActionMessage?

Answer: ActionMessage: A class that encapsulates messages. Messages can be either global or they are specific to a
particular bean property.
Each individual message is described by an ActionMessage object, which contains a message key (to be looked up in an
appropriate message resources database), and up to four placeholder arguments used for parametric substitution in the
resulting message.

ActionErrors: A class that encapsulates the error messages being reported by the validate() method of an ActionForm.
Validation errors are either global to the entire ActionForm bean they are associated with, or they are specific to a particular
bean property (and, therefore, a particular input field on the corresponding form).

Question: How you will handle exceptions in Struts?

Answer: In Struts you can handle the exceptions in two ways:
a) Declarative Exception Handling: You can either define global exception handling tags in your struts-config.xml or
define the exception handling tags within <action>..</action> tag.
Example:
<exception

key="database.error.duplicate"

path="/UserExists.jsp"

type="mybank.account.DuplicateUserException"/>

b) Programmatic Exception Handling: Here you can use try{}catch{} block to handle the exception.
Question: What is the difference between perform() and execute() methods?
Answer: Perform method is the method which was deprecated in the Struts Version 1.1. In Struts 1.x, Action.perform() is
the method called by the ActionServlet. This is typically where your business logic resides, or at least the flow control to
your JavaBeans and EJBs that handle your business logic. As we already mentioned, to support declarative exception
handling, the method signature changed in perform. Now execute just throws Exception. Action.perform() is now
deprecated; however, the Struts v1.1 ActionServlet is smart enough to know whether or not it should call perform or execute
in the Action, depending on which one is available.

Question: What is Struts actions and action mappings?

Answer: A Struts action is an instance of a subclass of an Action class, which implements a portion of a Web application and
whose perform or execute method returns a forward.

An action can perform tasks such as validating a user name and password.

An action mapping is a configuration file entry that, in general, associates an action name with an action. An action mapping
can contain a reference to a form bean that the action can use, and can additionally define a list of local forwards that is
visible only to this action.

An action servlet is a servlet that is started by the servlet container of a Web server to process a request that invokes an
action. The servlet receives a forward from the action and asks the servlet container to pass the request to the forward's URL.
An action servlet must be an instance of an org.apache.struts.action.ActionServlet class or of a subclass of that class. An
action servlet is the primary component of the controller.

Dispatch Action LookupDispatchAction

Its a parent class of LookupDispatchAction Subclass of Dispatch Action

DispatchAction provides a mechanism for An abstract Action that dispatches to the subclass
grouping a set of related functions into a single mapped executes method. This is useful in cases
action, thus eliminating the need to create where an HTML form has multiple submit buttons
separate actions for each function. with the same name. The button name is specified
by the parameterproperty of the corresponding
ActionMapping.
If not using Internalization functionality then Lookup Dispatch Action is useful when we are
dispatch action is more useful. using Internalization functionality

DispatchAction selects the method to execute LookupDispatchAction looks into the resource
depending on the request parameter value bundle file and find out the corresponding key
which is configured in the xml file. name. We can map this key name to a method
name by overriding the getKeyMethodMap()
method.
DispatchAction is not useful for I18N LookupDispatchAction is used for I18N

reset(): reset() method is called by Struts Framework with each request that uses the defined ActionForm. The purpose of
this method is to reset all of the ActionForm's data members prior to the new request values being set.

Example :
public void reset(ActionMapping mapping, HttpServletRequest request) {
this.password = null;
this.username = null;
}

Question 8: How you will make available any Message Resources Definitions file to the Struts Framework
Environment?

Ans: Message Resources Definitions file are simple .properties files and these files contains the messages that can be used in
the struts project. Message Resources Definitions files can be added to the struts-config.xml file through < message-
resources / > tag. Example: < message-resources parameter= MessageResources / >

Message resource definition files can available to the struts environment in two ways
1. using web.xml as
<servlet>
<servlet-name>action<servlet-name>
servlet-class>org.apache.struts.action.ActionServlet<servlet-class>
<init-param>
<param-name>application<param-name>
<param-value>resource.Application<param-value>
</servlet>

2.
<message-resource key="myResorce" parameter="resource.Application" null="false">

Q: What is Action Class?

A: The Action Class is part of the Model and is a wrapper around the business logic. The purpose of Action Class is to
translate the HttpServletRequest to the business logic. To use the Action, we need to Subclass and overwrite the execute()
method. In the Action Class all the database/business processing are done. It is advisable to perform all the database related
stuffs in the Action Class. The ActionServlet (commad) passes the parameterized class to Action Form using the execute()
method. The return type of the execute method is ActionForward which is used by the Struts Framework to forward the
request to the file as per the value of the returned ActionForward object.

1.What is MVC?
Model-View-Controller (MVC) is a design pattern put together to help control change. MVC decouples interface
from business logic and data.
Model : The model contains the core of the application's functionality. The model encapsulates the state of
the application. Sometimes the only functionality it contains is state. It knows nothing about the view or
controller.

View: The view provides the presentation of the model. It is the look of the application. The view can
access the model getters, but it has no knowledge of the setters. In addition, it knows nothing about the
controller. The view should be notified when changes to the model occur.

Controller:The controller reacts to the user input. It creates and sets the model.

More about Model-View-Controller Architecture >>

2.What is a framework?
A framework is made up of the set of classes which allow us to use a library in a best possible way for a specific
requirement.
3.What is Struts framework?
Struts framework is an open-source framework for developing the web applications in Java EE, based on MVC-2
architecture. It uses and extends the Java Servlet API. Struts is robust architecture and can be used for the
development of application of any size. Struts framework makes it much easier to design scalable, reliable Web
applications with Java.
4.What are the components of Struts?
Struts components can be categorize into Model, View and Controller:
Model: Components like business logic /business processes and data are the part of model.
View: HTML, JSP are the view components.
Controller: Action Servlet of Struts is part of Controller components which works as front controller to
handle all the requests.

5.What are the core classes of the Struts Framework?

Struts is a set of cooperating classes, servlets, and JSP tags that make up a reusable MVC 2 design.
 JavaBeans components for managing application state and behavior.
Event-driven development (via listeners as in traditional GUI development).
Pages that represent MVC-style views; pages reference view roots via the JSF component tree.

6.What is ActionServlet?
ActionServlet is a simple servlet which is the backbone of all Struts applications. It is the main Controller
component that handles client requests and determines which Action will process each received request. It serves
as an Action factory creating specific Action classes based on users request.

7.What is role of ActionServlet?

ActionServlet performs the role of Controller:
Process user requests
Determine what the user is trying to achieve according to the request
Pull data from the model (if necessary) to be given to the appropriate view,
Select the proper view to respond to the user
Delegates most of this grunt work to Action classes
Is responsible for initialization and clean-up of resources

8.What is the ActionForm?

ActionForm is javabean which represents the form inputs containing the request parameters from the View
referencing the Action bean.

9.What are the important methods of ActionForm?

The important methods of ActionForm are : validate() & reset().

10.Describe validate() and reset() methods ?

validate() : Used to validate properties after they have been populated; Called before FormBean is handed to
Action. Returns a collection of ActionError as ActionErrors. Following is the method signature for
thevalidate() method.

public ActionErrors validate(ActionMapping mapping,HttpServletRequest request)

reset(): reset() method is called by Struts Framework with each request that uses the defined ActionForm. The
purpose of this method is to reset all of the ActionForm's data members prior to the new request values being set.

public void reset() {}

11.What is ActionMapping?
Action mapping contains all the deployment information for a particular Action bean. This class is to determine
where the results of the Action will be sent once its processing is complete.

12.How is the Action Mapping specified ?

We can specify the action mapping in the configuration file called struts-config.xml. Struts framework
creates ActionMapping object from <ActionMapping> configuration element of struts-config.xml file

<action-mappings>
<action path="/submit"
type="submit.SubmitAction"
name="submitForm"
input="/submit.jsp"
scope="request"
validate="true">
 <forward name="success" path="/success.jsp"/>
<forward name="failure" path="/error.jsp"/>
</action>
</action-mappings>

13.What is role of Action Class?

An Action Class performs a role of an adapter between the contents of an incoming HTTP request and the
corresponding business logic that should be executed to process this request.

14.In which method of Action class the business logic is executed ?

In the execute() method of Action class the business logic is executed.

public ActionForward execute(

ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws Exception ;

execute() method of Action class:

Perform the processing required to deal with this request
Update the server-side objects (Scope variables) that will be used to create the next page of the user
interface
Return an appropriate ActionForward object

15.What design patterns are used in Struts?

Struts is based on model 2 MVC (Model-View-Controller) architecture. Struts controller uses the command design
pattern and the action classes use the adapter design pattern. The process()method of the RequestProcessor uses
the template method design pattern. Struts also implement the following J2EE design patterns.
Service to Worker
Dispatcher View
Composite View (Struts Tiles)
Front Controller
View Helper
Synchronizer Token

16.Can we have more than one struts-config.xml file for a single Struts application?
Yes, we can have more than one struts-config.xml for a single Struts application. They can be configured as
follows:

<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,
/WEB-INF/struts-admin.xml,
/WEB-INF/struts-config-forms.xml
</param-value>
</init-param>
.....
<servlet>

17.What is the directory structure of Struts application?

The directory structure of Struts application :

18.What is the difference between session scope and request scope when saving formbean ?
when the scope is request,the values of formbean would be available for the current request.
when the scope is session,the values of formbean would be available throughout the session.
19.What are the important tags of struts-config.xml ?
The five important sections are:
20.What are the different kinds of actions in Struts?
The different kinds of actions in Struts are:
ForwardAction
IncludeAction
DispatchAction
LookupDispatchAction
SwitchAction

21.What is DispatchAction?
The DispatchAction class is used to group related actions into one class. Using this class, you can have a method
for each logical action compared than a single execute method. The DispatchAction dispatches to one of the
logical actions represented by the methods. It picks a method to invoke based on an incoming request parameter.
The value of the incoming parameter is the name of the method that the DispatchAction will invoke.

22.How to use DispatchAction?

To use the DispatchAction, follow these steps :
Create a class that extends DispatchAction (instead of Action)
In a new class, add a method for every function you need to perform on the service The method has the
same signature as the execute() method of an Action class.
Do not override execute() method Because DispatchAction class itself provides execute() method.
Add an entry to struts-config.xml
DispatchAction Example

23.What is the use of ForwardAction?

The ForwardAction class is useful when youre trying to integrate Struts into an existing application that uses
Servlets to perform business logic functions. You can use this class to take advantage of the Struts controller and
its functionality, without having to rewrite the existing Servlets. Use ForwardAction to forward a request to
another resource in your application, such as a Servlet that already does business logic processing or even another
JSP page. By using this predefined action, you dont have to write your own Action class. You just have to set up
thestruts-config file properly to use ForwardAction.

24.What is IncludeAction?
The IncludeAction class is useful when you want to integrate Struts into an application that uses Servlets. Use the
IncludeAction class to include another resource in the response to the request being processed.

25.What is the difference between ForwardAction and IncludeAction?

The difference is that you need to use the IncludeAction only if the action is going to be included by another
action or jsp. Use ForwardAction to forward a request to another resource in your application, such as a Servlet
that already does business logic processing or even another JSP page.

26.What is LookupDispatchAction?
The LookupDispatchAction is a subclass of DispatchAction. It does a reverse lookup on the resource bundle to get
the key and then gets the method whose name is associated with the key into the Resource Bundle.

27.What is the use of LookupDispatchAction?

LookupDispatchAction is useful if the method name in the Action is not driven by its name in the front end, but by
the Locale independent key into the resource bundle. Since the key is always the same, the LookupDispatchAction
shields your application from the side effects of I18N.

28.What is difference between LookupDispatchAction and DispatchAction?

The difference between LookupDispatchAction and DispatchAction is that the actual method that gets called in
LookupDispatchAction is based on a lookup of a key value instead of specifying the method name directly.

29.What is SwitchAction?
The SwitchAction class provides a means to switch from a resource in one module to another resource in a
different module. SwitchAction is useful only if you have multiple modules in your Struts application. The
SwitchAction class can be used as is, without extending.

30.What if <action> element has <forward> declaration with same name as global forward?
In this case the global forward is not used. Instead the <action> elements<forward> takes precendence.

31.What is DynaActionForm?
A specialized subclass of ActionForm that allows the creation of form beans with dynamic sets of properties
(configured in configuration file), without requiring the developer to create a Java class for each type of form
bean.

32.What are the steps need to use DynaActionForm?

Using a DynaActionForm instead of a custom subclass of ActionForm is relatively straightforward. You need to
make changes in two places:
In struts-config.xml: change your <form-bean> to be anorg.apache.struts.action.DynaActionForm instead
of some subclass of ActionForm

<form-bean name="loginForm"type="org.apache.struts.action.DynaActionForm" >

<form-property name="userName" type="java.lang.String"/>
 <form-property name="password" type="java.lang.String" />
</form-bean>

In your Action subclass that uses your form bean:

o import org.apache.struts.action.DynaActionForm
o downcast the ActionForm parameter in execute() to a DynaActionForm
o access the form fields with get(field) rather than getField()

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionMessage;
import org.apache.struts.action.ActionMessages;

import org.apache.struts.action.DynaActionForm;

public class DynaActionFormExample extends Action {

public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws Exception {
DynaActionForm loginForm = (DynaActionForm) form;
ActionMessages errors = new ActionMessages();
if (((String) loginForm.get("userName")).equals("")) {
errors.add("userName", new ActionMessage(
"error.userName.required"));
}
if (((String) loginForm.get("password")).equals("")) {
errors.add("password", new ActionMessage(
"error.password.required"));
}
...........

33.How to display validation errors on jsp page?

<html:errors/> tag displays all the errors. <html:errors/> iterates over ActionErrors request attribute.

34.What are the various Struts tag libraries?

The various Struts tag libraries are:
HTML Tags
Bean Tags
Logic Tags
Template Tags
Nested Tags
Tiles Tags

35.What is the use of <logic:iterate>?

<logic:iterate> repeats the nested body content of this tag over a specified collection.
<table border=1>
<logic:iterate id="customer" name="customers">
<tr>
<td><bean:write name="customer" property="firstName"/></td>
<td><bean:write name="customer" property="lastName"/></td>
<td><bean:write name="customer" property="address"/></td>
</tr>
</logic:iterate>
</table>

36.What are differences between <bean:message> and <bean:write>

<bean:message>: is used to retrive keyed values from resource bundle. It also supports the ability to include
parameters that can be substituted for defined placeholders in the retrieved string.
<bean:message key="prompt.customer.firstname"/>
<bean:write>: is used to retrieve and print the value of the bean property. <bean:write> has no body.
<bean:write name="customer" property="firstName"/>

37.How the exceptions are handled in struts?

Exceptions in Struts are handled in two ways:
Programmatic exception handling :

Explicit try/catch blocks in any code that can throw exception. It works well when custom value (i.e., of
variable) needed when error occurs.

Declarative exception handling :You can either define <global-exceptions> handling tags in yourstruts-
config.xml or define the exception handling tags within <action></action> tag. It works well when custom
page needed when error occurs. This approach applies only to exceptions thrown by Actions.

<global-exceptions>
<exception key="some.key"
type="java.lang.NullPointerException"
path="/WEB-INF/errors/null.jsp"/>
</global-exceptions>
or
<exception key="some.key"
type="package.SomeException"
path="/WEB-INF/somepage.jsp"/>
38.What is difference between ActionForm and DynaActionForm?
An ActionForm represents an HTML form that the user interacts with over one or more pages. You will
provide properties to hold the state of the form with getters and setters to access them. Whereas,
usingDynaActionForm there is no need of providing properties to hold the state. Instead these properties
and their type are declared in the struts-config.xml
The DynaActionForm bloats up the Struts config file with the xml based definition. This gets annoying as
the Struts Config file grow larger.
The DynaActionForm is not strongly typed as the ActionForm. This means there is no compile time
checking for the form fields. Detecting them at runtime is painful and makes you go through redeployment.
ActionForm can be cleanly organized in packages as against the flat organization in the Struts Config file.
ActionForm were designed to act as a Firewall between HTTP and the Action classes, i.e. isolate and
encapsulate the HTTP request parameters from direct use in Actions. With DynaActionForm, the property
access is no different than using request.getParameter( .. ).
DynaActionForm construction at runtime requires a lot of Java Reflection (Introspection) machinery that
can be avoided.
39.How can we make message resources definitions file available to the Struts framework environment?
We can make message resources definitions file (properties file) available to Struts framework environment by
adding this file tostruts-config.xml.
<message-resources parameter="com.login.struts.ApplicationResources"/>

40.What is the life cycle of ActionForm?

The lifecycle of ActionForm invoked by the RequestProcessor is as follows:
Retrieve or Create Form Bean associated with Action
"Store" FormBean in appropriate scope (request or session)
Reset the properties of the FormBean
Populate the properties of the FormBean
Validate the properties of the FormBean
Pass FormBean to Action

Struts

Q 1. What is MVC?

Model-View-Controller (MVC) is a design pattern put together to help control change. MVC decouples interface from
business logic and data.
Model: The model contains the core of the application's functionality. The model enca psulates the state of the application.
Sometimes the only functionality it contains is state. It knows nothing about the view or controller.
View: The view provides the presentation of the model. It is the look of the application. The view can access the model
getters, but it has no knowledge of the setters. In addition, it knows nothing about the controller. The view should be notified
when changes to the model occur.
Controller: The controller reacts to the user input. It creates and sets the model.

Q 2. What is a framework?

Framework is made up of the set of classes which allow us to use a library y in a best possible way for a specific
requirement.

Q 3. What is Struts framework?

Struts framework is an open-source framework for developing the web applications in Java EE, based on MVC-2
architecture. It uses and extends the Java Servlet API. Struts is robust architecture and can be used for the development of
application
of any size. Struts framework makes it much easier to design scalable, reliable Web applications with Java. Struts provides
its own Controller component and integrates with other technologies to provide the Model and the View. For the Model,
Struts can interact with standard data access technologies, like JDBC and EJB, as well as most any third-party packages, like
Hibernate, iBATIS, or Object Relational Bridge. For the View, Struts works well with JavaServer Pages, including JSTL and
JSF, as well as Velocity Templates, XSLT, and other presentation systems.

Q 4. What is Jakarta Struts Framework?

Jakarta Struts is open source implementation of MVC (Model-View-Controller) pattern for the development of web based
applications. Jakarta Struts is robust architecture and can be used for the development of application of any size. Struts
framework makes it much easier to design scalable, reliable Web applications with Java.

Q 5. What is ActionServlet?
The class org.apache.struts.action.ActionServlet is the called the ActionServlet. In the the Jakarta Struts Framework this
class plays the role of controller. All the requests to the server
goes through the controller. Controller is responsible for handling all the requests.

Q 6. What is role of ActionServlet?

ActionServlet performs the role of Controller:

Process user requests

Determine what the user is trying to achieve according to the request
Pull data from the model (if necessary) to be given to the appropriate view,
Select the proper view to respond to the user
Delegates most of this grunt work to Action classes
Is responsible for initialization and clean-up of resources

Q 7. What is Action Class?

Any java class which extends from org.apache.struts.action.Action is called Action class. The Action is part of the controller.
The purpose of Action Class is to translate the HttpServletRequest to the business logic. To use the Action, we need to
Subclass and overwrite the execute() method. The ActionServlet (commad) passes the parameterized class to Action Form
using the execute() method. There should be no database interactions in the action. The action should receive the request, call
business objects (which then handle database, or interface with J2EE, etc) and then determine where to go next. Even better,
the business objects could be handed to the action at runtime (IoC style) thus removing any dependencies on the model. The
return type of the execute method is ActionForward which is used by the Struts Framework to forward the request to the file
as per the value of the returned ActionForward object..

Q 8. Write code of any Action Class?

package com.durgasoft;
import javax.servlet.http.*;
import org.apache.struts.action.*;
public class TestAction extends Action
{
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request,HttpServletResponse response) throws Exception
{
return mapping.findForward("success");
}
}

Q 9. What is ActionForm?

Any java class which extends from org.apache.struts.action.ActionForm is called ActionForm. An ActionForm is also
called JavaBean. ActionForm maintains the session state for web application and the ActionForm object is automatically
populated on the server side with data entered from a form on the client side.

Q10. What is Struts Validator Framework?

Struts Framework provides the functionality to validate the form data. It can be use to validate the data on the users browser
as well as on the server side. Struts Framework emits the java scripts and it can be used validate the form data on the client
browser. Server side validation of form can be accomplished by sub classing your From Bean
with DynaValidatorForm class.
The Validator framework was developed by David Winterfeldt as third-party add-on to Struts. Now the Validator framework
is a part of Jakarta Commons project and it can be used with or without Struts. The Validator framework comes integrated
with the Struts Framework and can be used without doing any extra settings.

Q11. How you will display validation fail errors on jsp page?

Following tag displays all the errors:

<html:errors/>
Q12. What is RequestProcessor?

The controller is responsible for intercepting and translating user input into actions to be performed by the model. The
controller is responsible for selecting the next view based on user input and the outcome of model operations. The Controller
receives the request from the browser, invoke a business operation and coordinating the view to return to the client.The
controller is implemented by a java servlet, this servlet is centralized point of control for the web application. In struts
framework the controller responsibilities are implemented by several different components like
The ActionServlet Class
The RequestProcessor Class
The Action Class
The ActionServlet extends the javax.servlet.http.httpServlet class. The ActionServlet class is not abstract and therefore can
be used as a concrete controller by your application.
The controller is implemented by the ActionServlet class. All incoming requests are mapped to the central controller in the
deployment descriptor as follows.
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
</servlet>
All request URIs with the pattern *.do are mapped to this servlet in the deployment descriptor as follows.
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
<servlet-mapping>
A request URI that matches this pattern will have the following form.
http://localhost:8080/mycontext/actionName.do
The preceding mapping is called extension mapping, however, you can also specify path mapping where a pattern ends
with /* as shown below.
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>/do/*</url-pattern>
<url-pattern>*.do</url-pattern>
A request URI that matches this pattern will have the following form.
http://localhost:8080/mycontext/do/action_Name The class
org.apache.struts.action.requestProcessor process the request from the controller. You can sublass the RequestProcessor with
your own version and modify how the request is processed.
Once the controller receives a client request, it delegates the handling of the request to a helper class. This helper knows how
to execute the business operation associated with the requested action. In the Struts framework this helper class is descended
of org.apache.struts.action.Action class. It acts as a bridge between a client-side user action and business operation. The
Action class decouples the client request from the business model. This decoupling allows for more than one-to-one mapping
between the user request and an action. The Action class also can perform other functions such as authorization, logging
before invoking business operation. the Struts Action class contains several methods, but most important method is the
execute() method.
public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
HttpServletResponse response) throws Exception
The execute() method is called by the controller when a request is received from a client. The controller creates an
instance of the Action class if one doesn?t already exist. The strut framework will create only a single instance of each
Action class in your application.
Action are mapped in the struts configuration file and this configuration is loaded into memory at startup and made
available to the framework at runtime. Each Action element is represented in memory by an instance of the
org.apache.struts.action. ActionMapping class. The ActionMapping object contains a path attribute that is matched against a
portion of the URI of the incoming request.
<action>
path= "/somerequest"
type="com.somepackage.someAction"
scope="request"
name="someForm"
validate="true"
input="somejsp.jsp"
<forward name="Success" path="/action/xys" redirect="true"/>
<forward name="Failure" path="/somejsp.jsp" redirect="true"/>
</action>
Once this is done the controller should determine which view to return to the client. The execute method signature in
Action class has a return type org.apache. struts.action.ActionForward class. The ActionForward class represents a
destination to which the controller may send control once an action has completed. Instead of specifying an actual JSP page
in the code, you can declaratively associate as action forward through out the application. The action forward are specified in
the configuration file.
<action>
path= "/somerequest"
type="com.somepackage.someAction"
scope="request"
name="someForm"
validate="true"
input="somejsp.jsp"
<forward name="Success" path="/action/xys" redirect="true"/>
<forward name="Failure" path="/somejsp.jsp" redirect="true"/>
</action>
The action forward mappings also can be specified in a global section, independent of any specific action mapping.
<global-forwards>
<forward name="Success" path="/action/somejsp.jsp" />
<forward name="Failure" path="/someotherjsp.jsp" />
</global-forwards>

Q13. How you will handle exceptions in Struts?

In Struts you can handle the exceptions in two ways:

a) Declarative Exception Handling: You can either define global exception handling tags in your struts-config.xml or
define the exception handling tags within
<action>..</action> tag.

Example:
<exception
key="database.error.duplicate"
path="/UserExists.jsp"
type="mybank.account.DuplicateUserException"/>
b) Programmatic Exception Handling: Here you can use try{}catch{} block to handle the exception.

Q14. What are the different kinds of actions in Struts?

The different kinds of actions in Struts are:

ForwardAction, IncludeAction, DispatchAction, LookupDispatchAction, SwitchAction

Q15. What is DispatchAction?

The DispatchAction class is used to group related actions into one class. Using this class, you can have a method for
each logical action compared than a single execute method. The DispatchAction dispatches to one of the logical actions
represented by the methods. It picks a method to invoke based on an incoming request parameter. The value of the incoming
parameter is the name of the method that the DispatchAction will invoke.

Q16. How to use DispatchAction?

To use the DispatchAction, follow these steps :

1. Create a class that extends DispatchAction (instead of Action)

2. In a new class, add a method for every function you need to perform on the service The method has the same
signature as the execute() method of an Action class.
3. Do not override execute() method Because DispatchAction class itself provides execute() method.
4. Add an entry to struts-config.xml

Q17. What is LookupDispatchAction?

The LookupDispatchAction is a subclass of DispatchAction. It does a reverse lookup on the resource bundle to get the key
and then gets the method whose name is associated with the key into the Resource Bundle.

Q18. What is the use of LookupDispatchAction?

LookupDispatchAction is useful if the method name in the Action is not driven by its name in the front end, but by the
Locale independent key into the resource bundle. Since the key is always the same, the LookupDispatchAction shields your
application from the side effects of I18N.

Q19. What is difference between LookupDispatchAction and DispatchAction?

The difference between LookupDispatchAction and DispatchAction is that the actual method that gets called in
LookupDispatchAction is based on a lookup of a key value instead of specifying the method name directly.

Q20. What is SwitchAction?

The SwitchAction class provides a means to switch from a resource in one module to another resource in a different module.
SwitchAction is useful only if you have multiple modules in your Struts application. The SwitchAction class can be used as
is, without extending.

Q21. What if <action> element has <forward> declaration with same name as global forward?

In this case the global forward is not used. Instead the <action> elements <forward> takes precendence.

Q22. What is difference between ActionForm and DynaActionForm?

An ActionForm represents an HTML form that the user interacts with over one or more pages. You will provide properties to
hold the state of the form with getters and setters to access them. Whereas, using DynaActionForm there is no need of
providing properties to hold the state. Instead these properties and their type are declared in the struts-config.xml.
The DynaActionForm bloats up the Struts config file with the xml based definition. This gets annoying as the Struts Config
file grow larger.
The DynaActionForm is not strongly typed as the ActionForm. This means there is no compile time checking for the form
fields. Detecting them at runtime is painful and makes you go through redeployment.
ActionForm can be cleanly organized in packages as against the flat organization in the Struts Config file.
ActionForm were designed to act as a Firewall between HTTP and the Action classes, i.e. isolate and encapsulate the HTTP
request parameters from direct use in Actions. With DynaActionForm, the property access is no different than using
request.get Parameter( .. ).

DynaActionForm construction at runtime requires a lot of Java Reflection (Introspection) machinery that can be
avoided.

Q23. What is the life cycle of ActionForm?

The lifecycle of ActionForm invoked by the RequestProcessor is as follows:

Retrieve or Create Form Bean associated with Action

"Store" FormBean in appropriate scope (request or session)
Reset the properties of the FormBean
Populate the properties of the FormBean
Validate the properties of the FormBean
Pass FormBean to Action

Q24.What are the important tags of struts-config.xml ?

<struts-config>
<!-- ========== Form Bean Definitions ============ -->
<form-beans>
<form-bean name="login" type=" LoginForm" />
</form-beans>
<!-- ========== Global Forward Definitions ========= -->
<global-forwards>
 </global-forwards>
<!-- ========== Action Mapping Definitions ======== -->
<action-mappings>
<action
path="/login"
type="LoginAction" >
</action>
</action-mappings>
<!-- ========== Properties Definitions ============ -->
<message-resources parameter="MessageResources" />
<!-- ========== Validator framework Definitions ============ -->
<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
<set-property
property="pathnames"
value="/org/apache/struts/validator/validator-rules.xml,
/WEB-INF/validation.xml"/>
</plug-in>
</struts-config>

Q25. What are the core classes of the Struts Framework?

A: Core classes of Struts Framework are ActionForm, Action, ActionMapping, Action Forward, ActionServlet etc.

Q26. What is action mappings?

An action mapping is a configuration file entry that, in general, associates an action name with an action. An action
mapping can contain a reference to a form bean that the action can use, and can additionally define a list of local forwards
that is visible only to this action.

Q27. Describe validate() and reset() methods ?

validate () and reset() methods defined inActionForm class.

validate() : Used to validate properties after they have been populated; Called before FormBean is handed to Action. Returns
a collection of ActionMessage as ActionErrors. Following is the method signature for the validate() method.
public ActionErrors validate(ActionMapping mapping, HttpServletRequest request)
reset(): reset() method is called by Struts Framework with each request that uses the defined ActionForm. The purpose of
this method is to reset all of the ActionForm's data members prior to the new request values being set.
public void reset() {}

Q28. Give the Details of XML files used in Validator Framework?

The Validator Framework uses two XML configuration files validator-rules.xml and validation.xml. The validator-
rules.xmldefines the standard validation routines, these are reusable and used in validation.xml. to define the form specific
validations. The validation.xml defines the validations applied to a form bean.

Q29. How you will enable front-end validation based on the xml in validation.xml?
The <html:javascript> tag to allow front-end validation based on the xml in validation.xml. For example the code:
<html:javascript formName="logonForm" dynamicJavascript="true" staticJavascript="true" /> generates the client side java
script for the form "logonForm" as defined in the validation.xml file. The <html:javascript> when added in the jsp file
generates the client site validation script.

Q30. What is the difference between perform() and execute() methods?

perform() method defined in Struts 1.0. but it is was deprecated in the Struts Version 1.1. In Struts 1.x, Action.perform() is
the method called by the ActionServlet. This is typically where your business logic resides, or at least the flow control to
your JavaBeans and EJBs that handle your business logic. As we already mentioned, to support declarative exception
handling, the method signature changed in perform. Now execute just throws Exception. Action.perform() is now
deprecated; however, the Struts v1.1 ActionServlet is smart enough to know whether or not it should call perform or execute
in the Action, depending on which one is available.

Q31. What are the various Struts tag libraries?

Struts is very rich framework and it provides very good and user friendly way to develop web application forms. Struts
provide many tag libraries to ease the development of web applications. These tag libraries are:
* Bean tag library - Tags for accessing JavaBeans and their properties.
* HTML tag library - Tags to output standard HTML, including forms, text boxes, checkboxes, radio buttons etc..
* Logic tag library - Tags for generating conditional output, iteration capabilities and flow management
* Tiles or Template tag library - For the application using tiles
* Nested tag library - For using the nested beans in the application

Q32. What are the difference between <bean:message> and <bean:write>?

<bean:message>: This tag is used to output locale-specific text (from the properties files) from a MessageResources bundle.
<bean:write>: This tag is used to output property values from a bean. <bean:write> is a commonly used tag which enables
the programmers to easily present the data.

Q33. What are difference between ActionErrors and ActionMessage?

ActionMessage: A class that encapsulates messages. Messages can be either global or they are specific to a particular
bean property.
Each individual message is described by an ActionMessage object, which contains a message key (to be looked up in an
appropriate message resources database), and up to four placeholder arguments used for parametric substitution in the
resulting message.
ActionErrors: A class that encapsulates the error messages being reported by the validate() method of an ActionForm.
Validation errors are either global to the entire ActionForm bean they are associated with, or they are specific to a particular
bean property (and, therefore, a particular input field on the corresponding form).

Q34. What is the use of ForwardAction?

The ForwardAction class is useful when youre trying to integrate Struts into an existing application that uses Servlets to
perform business logic functions. You can use this class to take advantage of the Struts controller and its functionality,
without having to rewrite the existing Servlets. Use ForwardAction to forward a request to another resource in your
application, such as a Servlet that already does business logic processing or even another JSP page. By using this predefined
action, you dont have to write your own Action class. You just have to set up the struts-config file properly to use
ForwardAction.

Q35. What is IncludeAction?

The IncludeAction class is useful when you want to integrate Struts into an application that uses Servlets. Use the
IncludeAction class to include another resource in the response to the request being processed.

Q36. What are the steps need to use DynaActionForm?

Using a DynaActionForm instead of a custom subclass of ActionForm is relatively straightforward. You need to make
changes in two places:
In struts-config.xml: change your <form-bean> to be an org.apache.struts.action.Dyna ActionForm instead of some subclass
of ActionForm

<form-bean name="loginForm"
type="org.apache.struts.action.DynaActionForm" >
<form-property name="userName" type="java.lang.String"/>
<form-property name="password" type="java.lang.String" />
</form-bean>
In your Action subclass that uses your form bean:
o import org.apache.struts.action.DynaActionForm
o downcast the ActionForm parameter in execute() to a DynaActionForm
o access the form fields with get(field) rather than getField()

Q.37 In struts what happens if made any changes in actionservlet?

The ActionServlet plays the role of controller wich is responsible for handling the request and selecting the correct
Application Module and storing ApplicationConfig and MessageResource bundle in the request object.
If we modify the ActionServlet the Controller may or may not work what happens that depends on your modification, You
have not specify whether you want to create your own custom ActionServlet by extending ActionServlet and overriding the
methods in it or what exactly you want to modify.