Answer / rajkumar

ActionServlet acts as a back bone to all the Struts
applications.
Flow:

-->First the request is handled by the either doGet()/doPost
() method of the Action Servlet and it calls the process()
mthod of its own.This method gets the Current Request
Processor associated with the request.

-->Then this request preocessor calls its preocess() method.
(Note:RequestProcessor also one type of Servlet).
This is the actaul place where the request is handled.

-->This method reads the struts-config.xml file and find
outs the Action class by seeing the request url path.
for ex:
incoming request trl path is:/login

struts-config.xml:

<action path="/login" type="Test.LoginClass">
<forward name="Succes" path="/Welcome.jsp"/>
<forward name="failure" path="/Login.jsp"/>
</action>

-->After identifying the Actio class it checks the whether
the request is associtaed with any form bean.This can be
checked by usin the name attribute of athe action element
from the struts-config.xml.

Ex:<form-beans>
<form name="loginForm" type="Test.LoginForm"/>
</form-beans>
<action-mappings>
<action path="/login"type="Test.LoginClass"
name="loginForm">
....
....
</action-mappings>

-->Then it creates the instance of ActionForm and calls the
corresponding getter and setter methods for the incoming
request parameters.Optionally we can validate the request
parameter by calling the validate()method in ActionForm.For
this we need to specify validate="true" and
input="/Login.jsp" in struts-config.xml file.

-->Now the actual request is handled by the Action class by
calling the execute() method.Output of this method
indicates the response of the request.The return type of
this request is ActionMappings ....

Answer / pradeep c

the flow execution of struts.

The browser makes a request to the Struts application that
is processed by ActionServlet (Controller).

ActionServlet (Controller) populates the ActionForm (View)
object with HTML form data and invokes its validate( )
method.

ActionServlet (Controller) executes the Action object
(Controller).

Action (Controller) interfaces with model components and
prepares data for view.

Action (Controller) forwards control to the JSP (View).

JSP (View) uses model data to generate a response to the
browser.

Answer / sandeep garg

ActionServlet acts as a back bone to all the Struts
applications.
Flow:

-->First the request is handled by the either doGet()/doPost
() method of the Action Servlet and it calls the process()
mthod of its own.This method gets the Current Request
Processor associated with the request.

-->Then this request preocessor calls its preocess() method.
(Note:RequestProcessor also one type of Servlet).
This is the actaul place where the request is handled.

-->This method reads the struts-config.xml file and find
outs the Action class by seeing the request url path.
for ex:
incoming request trl path is:/login

struts-config.xml:

<action path="/login" type="Test.LoginClass">
<forward name="Succes" path="/Welcome.jsp"/>
<forward name="failure" path="/Login.jsp"/>
</action>

-->After identifying the Actio class it checks the whether
the request is associtaed with any form bean.This can be
checked by usin the name attribute of athe action element
from the struts-config.xml.

Ex:<form-beans>
<form name="loginForm" type="Test.LoginForm"/>
</form-beans>
<action-mappings>
<action path="/login"type="Test.LoginClass"
name="loginForm">
....
....
</action-mappings>

-->Then it creates the instance of ActionForm and calls the
corresponding getter and setter methods for the incoming
request parameters.Optionally we can validate the request
parameter by calling the validate()method in ActionForm.For
this we need to specify validate="true" and
input="/Login.jsp" in struts-config.xml file.

-->Now the actual request is handled by the Action class by
calling the execute() method.Output of this method
indicates the response of the request.The return type of
this request is ActionMappings ....

Answer / archana dandwate

Actually struts use MVC(model VIew Controller)
Archietecture.

In struts we have to define following things:
1. index.jsp(it takes input from user suppose username)
2.ActionServlet class
3.Action class
4.displayname.jsp(it display username)
---------------------
we need to change 2 file
5.struts-config.xml
6.web.xml
---------------
Lets Start with step one. we will create the view file
named index.jsp


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

<html>
<head>
<title>Sample Struts Application</title>
</head>
<body>
<html:form action="Name" name="nameForm"
type="example.NameForm">
<table width="80%" border="0">
<tr>
<td>Name:</td>
<td><html:text property="name" /></td>
</tr>
<tr>
<td><html:submit /></td>
</tr>
</table>
</html:form>
</body>
</html>
-----------------------------------------

Note:
here we write tag like <html:form> because its struts
specific form tag.
In the Form tags the attributes you can find some
attributes defined in we will go through it.

action : Represents the URL to which this form will be
submitted. This attribute is also used to find the
appropriate ActionMapping in the Struts configuration file,
which we will describe later in this section. The value
used in our example is Name, which will map to an
ActionMapping with a path attribute equal to Name.

name :Identifies the key that the ActionForm will be
referenced by. We use the value NameForm. An ActionForm is
an object that is used by Struts to represent the form data
as a JavaBean. It main purpose is to pass form data between
View and Controller components. We will discuss NameForm
later in this section.
type :Names the fully qualified class name of the form bean
to use in this request. For this example, we use thevalue
example.NameForm, which is an ActionForm object containing
data members matching the inputs of this form.

To use the HTML tags, you must first add a taglib entry in
the application’s web.xml file that references the URI /WEB-
INF/struts-html.tld. This TLD describes all of the tags in
the HTML tag library. The following snippet shows the
<taglib> element that must be added to the web.xml file:

<taglib>
<taglib-uri>/WEB-INF/struts-html.tld</taglib-uri>
<taglib-location>/WEB-INF/struts-html.tld</taglib-location>
</taglib>
--------------------------------------------

The struts-html.tld is placed in the /WEB_INF directory.

Next Step is to create the action form

The ActionForm used in this example contains a single data
member that maps directly to the name input parameter of
the form defined in the index.jsp View. When an
<html:form/> is submitted, the Struts framework populates
the matching data members of the ActionForm with the values
entered into the <html:input/> tags. The Struts framework
does this by using JavaBean reflection. The accessors of
the ActionForm must follow the JavaBean standard naming
convention for example

The NameForm.java file is shown below
NameForm.java

package example;
//import statements
import javax.servlet.http.HttpServletRequest;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;

public class NameForm extends ActionForm {
private String name = null;
public String getName() {
return (name);
}
public void setName(String name) {
this.name = name;
}
public void reset(ActionMapping mapping,
HttpServletRequest request) {
this.name = null;
}
}
To deploy the NameForm to our Struts application, you need
to compile this class, move it to the /WEB-
INF/classes/example directory, and add the following line
to the <form-beans> section of the /WEB-INF/struts-
config.xml file:

<form-bean name="nameForm" type="example.NameForm"/>

This makes the Struts application aware of the NameForm and
how it should be referenced.

Now we create the out page for the sample application.
Lets name it diplayname.jsp
displayname.jsp

<html>
<head>
<title>Sample Struts Display Name</title>
</head>
<body>
<table width="80%" border="0">
<tr>
<td>Hello <%= request.getAttribute("NAME") %> !!
</td>
</tr>
</table>
</body>
</html>

Now we move to the step two of creating the application's
controller

In a Struts application, two components make up the
Controller. These two components are the
org.apache.struts.action.ActionServlet and the org.apache.
struts.action.Action classes. In most Struts applications,
there is one org. apache.struts.action.ActionServlet
implementation and can have many org.apache.
struts.action.Action implementations.

The org.apache.struts.action.ActionServlet is the
Controller component that handles client requests and
determines which org.apache.struts.action.Action will
process the received request. When assembling simple
applications, such as the one we are building, the default
ActionServlet will satisfy your application needs, and
therefore, you do not need to create a specialized
org.apache.struts.action.ActionServlet implementation.

The second component of a Struts Controller is the
org.apache.struts. action.Action class. As opposed to the
ActionServlet, the Action class must be extended for each
specialized function in your application. This class is
where your application’s specific logic begins.
NameAction.java

package example;

import java.io.IOException;
import javax.servlet.ServletException;
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;

public class NameAction extends Action {
public ActionForward execute(ActionMapping mapping,
ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
String target = new String("success");
if ( form != null ) {
// Use the NameForm to get the request parameters
NameForm nameForm = (NameForm)form;
String name = nameForm.getName();
}
// if no mane supplied Set the target to failure
if ( name == null ) {
target = new String("failure");
}
else {
request.setAttribute("NAME", name);
}
return (mapping.findForward(target));
}
}

Moving to step three, to deploy the NameAction to our
Struts application, we need to compile the NameAction class
and move the class file to /WEB-INF/classes/example
directory, and add the following entry to the <action-
mappings> section of the /WEB-INF/struts-config.xml file:

<action path="/Name" type="example.NameAction"
name="nameForm" input="/index.jsp">
<forward name="success" path="/displayname.jsp"/>
<forward name="failure" path="/index.jsp"/>
</action>


For step four we modify the web.xml file. We have to to
tell the Web application about our ActionServlet. This is
accomplished by adding the following servlet definition to
the /WEB-INF/web.xml file:

<servlet>
<servlet-name>action</servlet-name>
<servlet-class> org.apache.struts.action.ActionServlet
</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

Once we have told the container about the ActionServlet, we
need to tell it when the action should be executed. To do
this, we have to add a <servlet-mapping> element to
the /WEB-INF/ web.xml file:

<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
----------------------------------------
important note:
You will notice in the previously listed index.jsp that our
action does not include a .do at the end of the URL. We do
not have to append the .do because it is automatically
appended if we use the <html:form /> tag. If you do not use
the <html:form /> tag, then you will need to append .do to
the action's URL. This mapping tells the Web application
that whenever a request is received with .do appended to
the URL, the servlet named action should service the
request.

Eg:
<html:form action="Name.do" name="nameForm"
type="example.NameForm">

-------------------------------------------------

Answer / rajashree

The Apache Struts development team has announced the
creation of a new sub-project: Struts Flow. "Struts Flow
originated at the struts.sf.net project and has been
formally adopted now as a Struts subproject. Struts Flow is
a port of Apache Cocoon's Control Flow to Struts to allow
complex workflow, like multi-form wizards, to be easily
implemented using continuations-capable Javascript and
eventually Java."

Answer / suresh

Struts is based on MVC architecuture.

1. request comes.

2. corrosponding action class will be searched in the struts.xml

3. mapped form-bean will be populated with data.

4. execute method of mapped action servlet will be executed
and result will be mapped in struts.xml with <forward> tag.

5. mapped jsp/html page with forward will be displayed.

Answer / prabhakar

Struts Flow
===========


1) When application server gets started,container loads the
web.xml

2) When first the request is made from a JSP/HTML/XSLT to
the server with a particular URI(/something.do) the control
first reaches Web.xml file.

3) It checks the mapping for /something.do in web.xml and
finds the ActionServlet and loads ActionServlet.
......
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
.....

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

4) As part of loading ActionServlet calls the init() as
every other servlet does.
(Note: ActionServlet extends HttpServlet only)
......................
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
........................

5) In init() it takes the init-parameters as
struts-config.xml and loads the xml file.

6) Then the ActionServlet calls the process() method of
RequestProcessor class.

7) process() method checks for the appropriate action in the
action mapping for current request and maps the URI to the
action in the struts-config.xml.

8) Then it creates an object to ActionForm associated to
that action.

9) It then calls the setters and reset() methods in the form
bean(Which extends ActionForm) corresponds to the mapped action.

10) If the action tag in struts-config.xml contains validate
"true" then the validate method is called.

11) if any validation errors it return to view component
(any jsp XSLT) which is specified as an attribute of input
"/error.jsp"

12) if there are no validation errors ,it then search for
execute method in the action class and executes it.

13) execute method performs the bussinesslogic which you
provide and returns with an ActionForward key.

14) Now the returned key is searched in the mapped action
which is specified as forward tag.

15) It looks for the appropriate view component and performs
the getters on that action form corresponding to this view
component and loads the view page in the browser.


- Prabhakar

Answer / ranjeet srivastav

Struts is an open-source framework for building Web
applications based on the MVC pattern. Struts encourages
application architectures based on the MVC pattern and
provides services common to most Web applications.

In a Struts application, you can architect the Model layer
so that the business and data retrieval logic are easy to
reuse. This layer is responsible for running the
application's business logic and getting the relevant data
(for example, running an SQL command or reading a flat
file).

Struts encourages application architectures based on the
Model-View-Controller design paradigm. Struts provides its
own Controller component (the ActionController classes) and
integrates with other technologies to provide the Model and
the View. For the Model (Model classes), Struts can
interact with any standard data access technology,
including Enterprise Java Beans technology, JDBC, and the
Object-Relational Bridge. For the View (ActionForm
classes), Struts works well with the JavaServer Pages (JSP)
environment and other presentation systems. Figure 2
illustrates the logical flow of a Struts-based application.

Answer / sri

The browser makes a request to the Struts application that
is processed by ActionServlet (Controller).

ActionServlet (Controller) populates the ActionForm (View)
object with HTML form data and invokes its validate( )
method.

ActionServlet (Controller) executes the Action object
(Controller).

Action (Controller) interfaces with model components and
prepares data for view.

Action (Controller) forwards control to the JSP (View).

JSP (View) uses model data to generate a response to the
browser.

Answer / gopal g

struts is MVC(Model,View,Controller)Archietecture based
F/W software.

Resourcers OF a Struts Application In 1.0 of Struts :
---------------------------------------------------
we use following resources:

1.jsp(View)
2.Web.xml
3.struts-config.xml
4.FormBean.java (Form Bean)
5.FormAction.java(Action class)
----------------------------------
----------------------------------


Flow OF Struts Application In 1.0 of Struts :
-------------------------------------------

1).End User gives Request to Struts Application,
By Clicking on a button,in JSP(View)of our struts
Application.
2).Then,Request comes to first Web.xml
3).Now from web.xml req goes to Action servlet(Controller
Of Struts Application)
4)Then controller/Front Controller/Req Processer/Dispather
Servlet forwarads req
to Struts configaration file.
5).from there req goes to Action class via Controller
('Model' of Struts App) & it'll execute B.logic there.do so
perations with DB -->return to controller
6).And from Struts configaration file it will goes FormBean
class
via Controller.(In 1.0 of Struts)
7).From FormBean to Response goes to JSP(VIEW).

How does one create an action in struts 2?

0 Answers  

Name some useful annotations introduced in Struts2?

0 Answers  

What is used to display the intermediate result in an interceptor?

0 Answers  

How you will enable front-end validation based on the xml in validation.xml?

0 Answers  

1.Which of the following can be performed using interceptors by the developer? 1. Provide pre-processing logic before invoking the action 2. Interact with the action and set the request parameter on the action 3. Provide post-processing logic after invoking the action 4. Modify the result 1, 2, 3 2, 3, 4 1, 2, 4 1, 2, 3, 4 2.Interceptors can be used for which of the following tasks? 1. Checking security and bottleneck 2. Tracing the log 3. Validating user input 4. Uploading file 1, 2, 3 2, 3, 4 1, 2, 4 1, 2, 3, 4 3.The ValueStack is made up of which of the following objects? 1. Temporary Objects 2. Model Object 3. Action Object 4. Permanent Object 1, 2, 3 2, 3, 4 1, 2, 4 1, 2, 3, 4 4.Which of the following statements are correct? Apache Struts is a Java based framework that separates the application logic from the presentation layer. Action is based on pull-MVC framework which means that the data to be displayed is pulled from the action class which is a POJO class acting as a model in the Web application. OGNL is a powerful expression language that allows you to refer and manipulate the data present on the ValueStack. Declarative architecture enables you to integrate the different components present in the Web application either using XML files or Annotations. 5.Which of the following are the examples of helpers? 1. Action Interface 2. ActionSupport Class 3. ActionImplement Interface 1, 2 2, 3 1, 3 1, 2, 3 6.The Struts 2 filter performs which of the following tasks? 1. Installation of the Action class 2. Execution of the method specified in the configuration file 3. Reading of the control string 1, 2 2, 3 1, 3 1, 2, 3 7.Which of the following value for the debug parameter displays an OGNL console to test OGNL expressions against the value stack? xml console command All of the above. 8.Which of the following are correct statements? The execute () method of the action class defines business logic implementations. ActionSupport class adds useful utilities to the class that extends it. Set of Interceptors are grouped into a stack known as Interceptor Stack. All of the above. 9.Which of the following annotation helps to set the path of the action URL? It is placed before the action class and it applies to all actions defined in the class, even if the fully qualified URLs are not supplied. @Namespace @Result @Results @ParentPackage 10.Which of the following statements are correct related to OGNL and Annotations? OGNL is an expression and binding language that is used for getting and setting the properties of the Java objects. Annotations acts as an alternative to HTML and Java properties configuration file. Action Annotations are available when the framework scans the classpath for action classes. Lifecycle callback annotations are invoked at any time during the processing of an action. 11.Which of the following are the features of the new unified Expression Language? Deferred evaluation of expression Support expressions that can set values and invoke methods Provides a pluggable API for resolving expressions All of the above. 12.By introducing the new feature by JSF, improvements have been made in which of the following areas? Set of standard converter messages Addition of requiredMessage, converterMessage, and validatorMessage attribute for input components. Displaying the error message using the input component name with the help of label attribute added to the input components All of the above. 13.Which of the following statements are correct about the 'label' attribute? In JSF 2.1, the label attribute have been introduced with the input components. The label attribute can accept literal or value expressions. The Literal or value expressions accepted by label attribute is prefixed before the components error message. All of the above. 14.Which of the following statements are correct? EL allows developers to use simple expressions to dynamically access data from JavaBeans components. EL supports only deferred evaluation. A value expression can either yield a value or set a value and can be used for both read and write. In immediate evaluation, the expression is evaluated immediately. 15.Which of the following statements are correct? Method expression invokes as arbitrary private method of an arbitrary object by passing a specified set of parameters and returning results from the calling method. JSTL is a part of Java EE 5 platform. JSF 1.2 includes a set of messages for standard converters. The requiredMessage, converterMessage, or the validatorMessage attribute of the input components are used to provide custom error messages.

2 Answers   Wipro,

Why was reload removed from struts (since 1.1)?

0 Answers  

What is the difference between validation.xml and validator-rules.xml files in struts validation framework?

0 Answers  

Which class of struts is responsible to converts data types from string and vice versa?

0 Answers  

What is the use of jsonvalidation in struts?

0 Answers  

What is the purpose of '@keyproperty'?

0 Answers  

How exceptions are handled in struts application?

0 Answers  

can we change the order of parameters in execute()?

4 Answers   Polaris, Serco,