http://www.mycompany.com/myapplication/do/logon
where
/myapplication is the context path under which your application
is deployed.
Extension mapping, on the other hand, matches
request URIs to the action servlet based on the fact that the URI ends with a
period followed by a defined set of characters. For example, the JSP processing
servlet is mapped to the
*.jsp
pattern so that it is called to process every JSP page that is requested. To
use the *.do
extension (which implies "do something"), the mapping entry would
look like this:<servlet-mapping><servlet-name>action</servlet-name><url-pattern>*.do</url-pattern></servlet-mapping>
and a
request URI to match the
/logon
path described earlier might look like this:http://www.mycompany.com/myapplication/logon.do
WARNING - Struts will
not operate correctly if you define more than one
<servlet-mapping> element for the controller servlet.
WARNING - If you are
using the new module support in Struts 1.1, you should be aware that only extension
mapping is supported.
Configure the
Struts Tag Libraries
Next, you must add an entry defining the Struts tag
library.
The struts-bean taglib contains tags useful in
accessing beans and their properties, as well as defining new beans (based on
these accesses) that are accessible to the remainder of the page via scripting
variables and page scope attributes. Convenient mechanisms to create new beans based
on the value of request cookies, headers, and parameters are also provided.
The struts-html taglib contains tags used to create
struts input forms, as well as other tags generally useful in the creation of
HTML-based user interfaces.
The struts-logic taglib contains tags that are
useful in managing conditional generation of output text, looping over object
collections for repetitive generation of output text, and application flow
management.
The struts-tiles taglib contains tags used for
combining various view components, called "tiles", into a final
composite view.
The struts-nested taglib is an extension of other
struts taglibs that allows the use of nested beans.
Below is how you would define all taglibs for use
within your application. In practice, you would only specify the taglibs that
your application uses:
<taglib><taglib-uri>/tags/struts-bean</taglib-uri><taglib-location>/WEB-INF/struts-bean.tld</taglib-location></taglib><taglib><taglib-uri>/tags/struts-html</taglib-uri><taglib-location>/WEB-INF/struts-html.tld</taglib-location></taglib><taglib><taglib-uri>/tags/struts-logic</taglib-uri><taglib-location>/WEB-INF/struts-logic.tld</taglib-location></taglib><taglib><taglib-uri>/tags/struts-tiles</taglib-uri><taglib-location>/WEB-INF/struts-tiles.tld</taglib-location></taglib>
This tells
the JSP system where to find the tag library descriptor for this library (in
your application's WEB-INF directory, instead of out on the Internet
somewhere).
Configure the
Struts Tag Libraries (Servlet 2.3)
Servlet 2.3 Users only:
The Servlet 2.3 specification simplifies the deployment and configuration of
tag libraries. The instructions above will work on older containers as well as
2.3 containers (Struts only requires a servlet 2.2 container); however, if
you're using a 2.3 container such as Tomcat 4.x, you can take advantage of a
simplified deployment.
All that's required to install the struts tag
libraries is to copy struts.jar into your /WEB-INF/lib directory and reference
the tags in your code like this:
<%@ taglib uri=http://struts.apache.org/tags-htmlprefix="html" %>
Note that
you must use the full uri defined in the various struts tlds so that the
container knows where to find the tag's class files. You don't have to alter
your web.xml file or copy tlds into any application directories.
Add Struts
Components To Your Application
To use
Struts, you must copy the .tld files that you require into your
WEB-INF directory, and copy struts.jar (and all of the commons-*.jar files) into your WEB-INF/lib directory.
Struts Bean
Tags
This tag
library contains tags useful in accessing beans and their properties, as well
as defining new beans (based on these accesses) that are accessible to the
remainder of the page via scripting variables and page scope attributes.
Convenient mechanisms to create new beans based on the value of request
cookies, headers, and parameters are also provided.
Many of
the tags in this tag library will throw a
JspException
at runtime when they are utilized incorrectly (such as when you specify an
invalid combination of tag attributes). JSP allows you to declare an
"error page" in the <%@ page %> directive. If you wish to process the actual
exception that caused the problem, it is passed to the error page as a request
attribute under key org.apache.struts.action.EXCEPTION.
If you are viewing this page from within the Struts
Documentation Application (or online at http://struts.apache.org/), you can learn more about using these tags in the
Bean Tags Developer's Guide.
Tag Name Description
header Load the
response from a dynamic application request and make it available as a bean
include Render an internationalized message
string to the response.
message Expose a specified item from the page
context as a bean.
page Define a scripting variable based on the
value(s) of the specified request parameter.
parameter Load a web application resource and make it
available as a bean.
resource Define a bean containing the number of
elements in a Collection or Map.
size Expose a named Struts internal
configuration object as a bean.
Struts
The
core of the Struts framework is a flexible control layer based on standard
technologies like Java Servlets, JavaBeans, ResourceBundles, and XML, as well
as various Jakarta Commons packages. Struts encourages application
architectures based on the Model 2 approach, a variation of the classic
Model-View-Controller (MVC) design paradigm.
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.
The
Struts framework provides the invisible underpinnings every professional web
application needs to survive. Struts helps you create an extensible development
environment for your application, based on published standards and proven
design patterns.
What is the difference between Struts 1.0 and
Struts 1.1
The
new features added to Struts 1.1 are 1. RequestProcessor class 2. Method perform() replaced by execute() in Struts base Action Class
3. Changes to web.xml and struts-config.xml 4.Declarative exception handling
5.Dynamic ActionForms 6.Plug-ins 7.Multiple Application Modules 8.Nested Tags
9.The Struts Validator 10.Change to the ORO package 11.Change to Commons
logging 12.Removal of Admin actions 13. Deprecation of the GenericDataSource
Explain Struts navigation flow
A client requests a path that matches the
Action URI pattern. The container passes the request to the ActionServlet. If
this is a modular application, the ActionServlet selects the appropriate
module. The ActionServlet looks up the mapping for the path. If the mapping
specifies a form bean, the ActionServlet sees if there is one already or
creates one. If a form bean is in play, the ActionServlet resets and populates
it from the HTTP request. If the mapping has the validate property set to true,
it calls validate on the form bean. If it fails, the servlet forwards to the
path specified by the input property and this control flow ends. If the mapping
specifies an Action type, it is reused if it already exists or instantiated.
The
Action’s perform or execute method is called and passed the instantiated form
bean (or null). The Action may populate the form bean, call business objects,
and do whatever else is needed. The Action returns an ActionForward to the
ActionServlet. If the ActionForward is to another Action URI, we begin again;
otherwise, it’s off to a display page or some other resource. Most often, it is
a JSP, in which case Jasper, or the equivalent (not Struts), renders the page.
What is the difference between ActionForm and
DynaActionForm
In
struts 1.0, action form is used to populate the html tags in jsp using struts
custom tag.when the java code changes, the change in action class is needed. To
avoid the chages in struts 1.1 dyna action form is introduced.This can be used
to develop using xml.The dyna action form bloats up with the struts-config.xml
based definetion.
What is DispatchAction
The
DispatchAction class is used to group related actions into one class.
DispatchAction is an abstract class, so
you must override it to use it. It extends the Action class.
It should be noted that you dont have to use the
DispatchAction to group multiple actions into one Action class.
You could just use a hidden field that you inspect
to delegate to member() methods inside of your action.
How to call ejb from Struts
use the
Service Locator patter to look up the ejbs
Or You can use InitialContext and get the home
interface.
What are the various Struts tag libraries
struts-html tag library - used for creating dynamic HTML user interfaces
and forms. struts-bean tag library
- provides substantial enhancements to the basic capability provided by .
struts-logic tag library - can manage conditional generation of output
text, looping over object collections for repetitive generation of output text,
and application flow management.
struts-template tag library - contains tags that are useful in creating
dynamic JSP templates for pages which share a common format.
What is the difference between ActionErrors and
ActionMessages
The
difference between the classes is zero -- all behavior in ActionErrors was
pushed up into ActionMessages and all behavior in ActionError was pushed up
into ActionMessage. This was done in the attempt to clearly signal that these
classes can be used to pass any kind of messages from the controller to the
view -- errors being only one kind of message
How you will handle errors and exceptions using
Struts
There are various ways to handle exception:
1) To handle errors server side validation can be
used using ActionErrors classes can be used.
2) The exceptions can be wrapped across different
layers to show a user showable exception.
3)using validators
How you will save the data across different pages
for a particular client request using Struts
Several
ways. The similar to the ways session tracking is enabled. Using cookies,
URL-rewriting, SSLSession, and possibilty threw in the database.
What we will define in Struts-config.xml file. And
explain their purpose
The main
control file in the Struts framework is the struts-config.xml XML file, where
action mappings are specified. This file's structure is described by the
struts-config DTD file, which is defined at http://jakarta.apache.org/struts/.
A copy of the DTD can be found on the /docs/dtds subdirectory of the
framework's installation root directory. The top-level element is
struts-config. Basically, it consists of the following elements:
data-sources—A set of data-source elements,
describing parameters needed to instantiate JDBC 2.0 Standard Extension
DataSource objects
form-beans—A set of form-bean elements that
describe the form beans that this application uses
global-forwards—A set of forward elements
describing general available forward URIs
action-mappings—A set of action elements describing
a request-to-action mapping
What is the purpose of tiles-def.xml file,
resourcebundle.properties file, validation.xml file
The Tiles
Framework is an advanced version of that comes bundled with the Struts Webapp
framework. Its purpose is reduce the duplication between jsp pages as well as
make layouts flexible and easy to maintain. It integrates with Struts using the
concept of named views or definitions.
What is Action Class. What are the methods in
Action class
Action
class is request handler in Struts. we will extend the Action class and over
ride the execute() method in which we will specify the business logic to be
performed.
Explain about token feature in Struts
Tokens are used to check for invalid path for by
the uer:
1) if the user presses back button and submits the
same page
2)or if the user refreshes the page which will
result to the resubmit of the previous action and might lead to unstabality..
to solve the
abv probs we use tokens
1) in previous action type saveTokens(HttpServletreuest)
2) in current action check for duplication bu
if(!isValidToken())
What part of MVC does Struts represent
Bad question. Struts is a framework which supports
the MVC pattern.
What are the core classes of struts?
The core
classes of struts are ActionForm, Action, ActionMapping, ActionForward etc.
What are the
Important Components of Struts?
1. Action Servlet
2. Action Classes
3. Action Form
4. Validator Framework
5. Message Resources
6. Struts Configuration XML Files
7. View components like JSP
What is Struts?
Struts
is a web page development framework and an open source software that helps
developers build web applications quickly and easily. Struts combines Java
Servlets, Java Server Pages, custom tags, and message resources into a unified
framework. It is a cooperative, synergistic platform, suitable for development
teams, independent developers, and everyone between.
How is the MVC design pattern used in Struts
framework?
In
the MVC design pattern, application flow is mediated by a central Controller.
The Controller delegates requests to an appropriate handler. The handlers are
tied to a Model, and each handler acts as an adapter between the request and
the Model. The Model represents, or encapsulates, an application's business
logic or state. Control is usually then forwarded back through the Controller
to the appropriate View. The forwarding can be determined by consulting a set
of mappings, usually loaded from a database or configuration file. This
provides a loose coupling between the View and Model, which can make an
application significantly easier to create and maintain.
Controller--Servlet controller which supplied by
Struts itself; View --- what you can see on the screen, a JSP page and
presentation components; Model --- System state and a business logic JavaBeans.
Who makes the Struts?
Struts is
hosted by the Apache Software Foundation(ASF) as part of its Jakarta project,
like Tomcat, Ant and Velocity.
Why it called Struts?
Because the
designers want to remind us of the invisible underpinnings that hold up our
houses, buildings, bridges, and ourselves when we are on stilts. This excellent
description of Struts reflect the role the Struts plays in developing web
applications.
Do we need to pay the Struts if being used in
commercial purpose?
No.
Struts is available for commercial use at no charge under the Apache Software
License. You can also integrate the Struts components into your own framework
just as if they were writtern in house without any red tape, fees, or other
hassles
What are the core classes of Struts?
Action,
ActionForm, ActionServlet, ActionMapping, ActionForward are basic classes of
Structs.
What is the design role played by Struts?
The
role played by Structs is controller in Model/View/Controller(MVC) style. The
View is played by JSP and Model is played by JDBC or generic data source
classes. The Struts controller is a set of programmable components that allow
developers to define exactly how the application interacts with the user.
How Struts control data flow?
Struts implements the MVC/Layers pattern through
the use of ActionForwards and ActionMappings to keep control-flow decisions out
of presentation layer.
What configuration files are used in Struts?
--ApplicationResourcesl.properties
--struts-config.xml
These two
files are used to bridge the gap between the Controller and the Model.
What helpers in
the form of JSP pages are provided in Struts framework?
--struts-html.tld
--struts-bean.tld
--struts-logic.tld
Is Struts
efficient?
--The Struts is not only thread-safe but
thread-dependent(instantiates each Action once and allows other requests to be
threaded through the original object.
--ActionForm beans minimize subclass code and
shorten subclass hierarchies
--The Struts tag libraries provide general-purpose
functionality
--The Struts components are reusable by the
application
--The Struts localization strategies reduce the
need for redundant JSPs
--The Struts is designed with an open
architecture--subclass available
--The Struts is lightweight (5 core packages, 5 tag
libraries)
--The Struts is open source and well documented
(code to be examined easily)
--The Struts is model neutral
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.
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.
How you
will make available any Message Resources Definitions file to the Struts
Framework Environment?
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” />
What is Action Class?
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.
Write code of any Action Class?
Here is the code
of Action Class that returns the ActionForward object.
1. import javax.servlet.http.HttpServletRequest;
2. import javax.servlet.http.HttpServletResponse;
3. import org.apache.struts.action.Action;
4. import org.apache.struts.action.ActionForm;
5. import org.apache.struts.action.ActionForward;
6. import org.apache.struts.action.ActionMapping;
7.
8. public class TestAction extends Action
9. {
10. public ActionForward execute(
11. ActionMapping mapping,
12. ActionForm form,
13. HttpServletRequest request,
14. HttpServletResponse response) throws Exception
15. {
16. return mapping.findForward(\"testAction\");
17. }
18. }
What is ActionForm?
An ActionForm is a JavaBean that extends org.apache.struts.action.ActionForm.
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.
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.
Give the Details of XML files used in Validator Framework?
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.xml defines 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.
How you will display validation fail errors on jsp
page? The following tag displays all the errors:
<html:errors/>
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.
No comments:
Post a Comment