Struts Demo

1 1
J2EE
Struts
1 2
Struts:
Introduction
1 3
Once youve coded a lot of JSP applications, you find
yourself doing a lot of repetitive things.
Also, if you have a hard-coded link scattered around a lot
of JSPs, the first time you need to change that link you
discover a special kind of agony.
Struts was designed to solve that problem and a few
others.
Struts is about moving code to xml property files.
Struts: Introduction
*
* This lecture was based on Struts in Action by Ted Husted ISBN 1-930110-50-2
1 4
Struts is based on the MVC or Model-View-Controller
design pattern.
1 5
1 6
Under Struts the work of operating a web application is
divided up:
ActionServletthis Struts component controls
navigation.
Actionthis Struts component controls business logic.

1 7
Heres the process:
1.) An ActionServlet receives a request from the
container.
2.) The ActionServlet collects the information in the
request.
3.) Using the request URI, the ActionServlet tries to
match the URI with a so-called Action class.
4.) Whichever Action class is passed the request will take
the correct course of action.
1 8
The preceding is just a general idea of how it works.
Struts uses the following Java classes to work its magic:

ActionForm
ActionServlet
ActionMapping
ActionForward
Action

In addition to these, Struts places a lot of information in
xml configuration files:
strut-config.xml

1 9
We will explore these in depth, but heres a thumbnail
version of each:

ActionFormCollects form data from HTML page.
ActionServletControls everything.
ActionMappingHelps when deciding where to go.
ActionForwardWhere to send request
ActionCalled to do business logic.
1 10
Struts:
ActionForm
1 11
A Web Application is driven by HTML pages.

A typical WebApp contains text fields in a FORM.

To extract information from this page, we use the NAME.
Struts: ActionForm
<HTML>
<HEAD><TITLE>Simple JSP</TITLE></HEAD>
<BODY>
<FORM METHOD="POST" ACTION="/TestServlet">
<BR>Username:
<INPUT TYPE="text" NAME="user" VALUE="">
<BR>Password:
<INPUT TYPE="text" NAME="pass" VALUE="">
</FORM>
</BODY>
</HTML>
1 12
Given the HTML page we see below, we could pull out
the value of the tag with the NAME of user by using the
following code in a Servlets doPost() method:

String userField = request.getParameter("user");

Struts: ActionForm
<HTML>
<BODY>
<FORM METHOD="POST" ACTION="/SomeServlet">
<BR>Username:
<BR>Password:
</FORM>
</BODY>
</HTML>
1 13
However, with any fairly large page, this becomes tedious.

A better way is to use a JavaBean.

Using a JavaBean, we place all the data in the bean on the
JSP side and then its convenient for us to unpack it on the
servlet side.

Struts has taken this one step further.

If you follow the rules, Struts will automatically populate a
JavaBean for yousaving you the trouble of loading it.
Struts: ActionForm
1 14
Okay, what are these rules were suppose to follow?

Instead of making up your own JavaBean, you need to
extend a special Struts JavaBean called the ActionForm

extends org.apache.struts.action.ActionForm
Struts: ActionForm
1 15
A Struts action form:
is a JavaBean that extends ActionForm.

It captures the input fields sent through the request.

You must create a JavaBean (that extends ActionForm)
that has an instance variable (with the correctly named getters
and setters) for each input field in the JSP page.
Struts: ActionForm
1 16
So, lets recall our HTML/JSP file, and then see how we
would create the correct ActionForm:
Struts: ActionForm
<HTML>
<BODY>
<FORM METHOD="POST" ACTION="/SomeServlet">
<BR>Username:
<BR>Password:
</FORM>
</BODY>
</HTML>
import org.apache.struts.action.*;

public class SimpleForm extends ActionForm
{
private String user = ;
private String pass = ;

public SimpleForm(){}

public void setUser( String u ) { user = u; }
public void setPass( String p ) { pass = p; }
public String getUser() { return user; }
public String getPass() { return pass; }
}
As we see, our
SimpleForm
extends
ActionForm
It has getters and
setters named so they
will be automatically
found.
1 17
When compiled, this .class file should be placed here:

webapps
myapp
WEB-INF
classes

Struts: ActionForm
1 18
Struts: ActionForm
Heres what will happen. The ActionServlet will
receive a POST, thereby executing its doPost()
method.

The ActionServlet will try to match the
parameters in the request with the properties in the
ActionForm.

For a parameter wxyz, the JavaBean (ActionForm)
must have a corresponding setWxyz() and
getWxyz() method.
1 19
Struts:
ActionServlet
1 20
The ActionServlet behaves like an orchestra
Conductor. It doesnt do a lot of the work, but it
manages the other components.

The ActionServlet receives a request from the
container and it routes the request to the correct place.

99% of the time, you will never need to change the
existing ActionServlet
Struts: ActionServlet
1 21
The ActionServlet uses a special xml configuration file
called: struts-config.xml.
When the web container receives a request in the form of
/register-complete/enter.do, thenbecause of the
.do extensionit knows to pass the request off to the
ActionServlet. In turn, the ActionServlet looks in its
struts-config.xml file to see where to send the request.
Using this mapping, the
ActionServlet knows to send the
request to the JSP located at this path.
Thus, we have decoupled the location
of the actual JSP from its location as
implied by URL.
1 22
So, lets review the sequence so far:

1.) Web container gets a request with a .do extension.
2.) Web container passes the request to the
ActionServlet
3.) ActionServlet grabs all the request parameters and
tries to insert them in an ActionForm.
4.) ActionServlet strips the .do extension.
5.) ActionServlet looks in the struts-config.xml
file for a matching URI pattern.
6.)

1 23
Struts:
ActionMapping
1 24
The Struts Java class called ActionMapping is used inside
of the Action class (not yet covered).
It has only one method were interested in:

ActionMapping mapping = new ActionMapping();

mapping.findForward( somesymbolicname );

This means: When you reach this statement, you should
forward the request to the JSP page represented by this
symbolic name somesymbolicname.
Struts: ActionMapping
1 25
Struts:
Action
1 26
Recall that the business logic of a Struts application is all
done in the Action class.

You will often need to create your own subclass of this
Action class.

Your Action class must follow a very specific design
pattern:
Struts: Action
1 27
import javax.servlet.http.*;

public class MyAction extends Action
{
public ActionForward perform( ActionMapping mapping,
ActionForm form,
HttpServletRequest req,
HttpServletResponse res )
{

}
}
After you have extended the Action class,
you will need to override the inherited
method called perform().
In order for your override to work, it must
match the signature of the superclass, and
thus it must take the form we see here.
1 28

{
ActionForm form,
{
SimpleForm sf = (SimpleForm) form;
String username = sf.getUser();
String password = sf.getPass();

}
}
Now, the first step is to cast the
received ActionForm reference
into your subclass of
ActionForm. In this case, its
called SimpleForm. Recall, since
SimpleForm is an
ActionForm, we can perform
this cast.

public class SimpleForm extends ActionForm
{

1 29

{
ActionForm form,
{
SimpleForm sf = (SimpleForm) form;
String username = sf.getUser();
String password = sf.getPass();

if( username == null || password == null )
{
return mapping.findForward( failure );
}
else
{
return mapping.findForward( success );
}
}
}
Finally, we see howdepending
on the results of the logic
performed in this Action
classwe use the
ActionMapping class to
decide where to send the request
from here.
1 30
Remember, your Action class must do these three things:

Cast the incoming ActionForm class into your subclass.
Apply business logic.
Return the correct ActionForward.
Struts: Action
1 31
And lets review how the struts-config.xml would
be modified to use our action class:
Struts: Action
Here we see a new attribute was added to the action.
Within the Action class (our MyAction) we saw the
findForward() method referred to the symbolic
name success. Heres where that is defined.
1 32
Struts:
Review So Far
1 33
As you no doubt see, this can be confusing.

The names chosen for the components are not that meaningful and the
process is non-intuitive.

Still, lets see if we can understand the entire process.
Struts: Review So Far
1 34
1.) Point your browser to a web page.

http://localhost:8080/register-complete/enter.jsp
First, we see that were
executing the JSP called
enter.jsp that lives in a
web application called
register-complete.
1 35
2.) This is the HTML within the page enter.jsp
<form name="registerForm"
method="POST" action="/register-complete/enter.do">

UserName:
<input type="text" name="username" value=""><br>
enter password:
<input type="password" name="password1" value=""><br>
re-enter password:
<input type="password" name="password2" value=""><br>
<input type="submit" name="submit" value="Register">
</form>
When we click the Submit button, we trigger a POST against
the page /register-complete/enter.do.
The web container sees that we have asked it to render a page
that ends in .do.
The web container knows that all page requests that end in
.do should be sent to the ActionServlet, which will be
allowed to decide what to do.
1 36
3.) The ActionServlet receives the page request. It
looks up the URI mapping pattern in its struts-
config.xml file.
The ActionServlet also stores the request
parameters in the ActionForm bean.
Since we are already inside the
register-complete web
application, you can omit that part
of the name. So, were doing a post
against /register-
complete/enter.do.
The ActionServlet knows
to strip off the .do, so its looking
for a path mapped to /enter.
And, we see that does exist.
1 37
This is the RegisterAction.java class. Relying on
the struts-config.xml file to identify this class, the
ActionServlet will execute the perform() method.
1 38
4.) Next, the ActionServlet looks to see if a name
property is associated with the mapping.
In this case, it does find a name property, called
registerForm.
As we see, the name registerForm appears in the
line above. It represents an ActionForm bean called
RegisterForm.
The name property
tells it which
ActionForm class to
use.
1 39
5.) Since the ActionServlet has discovered an
ActionForm is associated, it instantiates the bean and tries
to call its getters and setters for each of the parameters in
the request.
This same line also informs the
ActionServlet which
ActionForm class it should
use when it captures all the
request parameter information.
1 40
6.) Finally, depending on the outcome of the business logic
in the RegisterAction class, one of the
findForward() methods is executed.
1 41
Struts:
Understanding the
Architecture
1 42
Struts: Understanding the Architecture
Lets first review the sequence of actions:
1.) A client requests a web page that matches the Action URI pattern.
2.) Seeing the .do extension, the web container passes the request to
the ActionServlet.
3.) The ActionServlet looks in its struts-config.xml for
the mapping for that particular path.
4.) If that mapping specifies an ActionForm [JavaBean], the
ActionServlet either uses an existing instance of that
ActionForm or it instantiates a new one. The ActionServlet
populates the ActionForm.
5.) The ActionServlet sees which Action class is mapped to
that path and executes the perform() method of that Action
class.
6.) The Action class does what it needs for business logic.
7.) The Action returns an ActionForward to the
ActionServlet.
1 43
1, 2.) A client requests a web page that matches the Action
URI pattern. Seeing the .do extension, the web container
passes the request to the ActionServlet.

How does this happen?

Recall that the web container [the server] has its web.xml configuration
file. Within that config file, there is an element called

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

that allows you to specify that all pages with this pattern should go to the servlet
action.
1 44
3-7.) The ActionServlet looks in its
struts-config.xml for the mapping for that
particular path.

When the ActionServlet receives a request, it has
several things to accomplish:
i.) process the locale
ii.) process the mappingto see which Action to send the request to
and whether a bean is needed.
iii.) if a bean is needed, either find one in scope or create a new one, then
process the ActionForm beantake the request parameters and
put them into the bean using its setters.
iv.) if the ActionMapping specifies the forward attribute, control is
either transferred to another resource or to an Action object.
v.) process the Action (if appropriate) by calling the perform()
method.
vi.) the Action returns an ActionForward
1 45
Struts:
Our First Example
1 46
Once again, we will take the organic approach and see what
happens in a linear fashion.
Before then, I would like to explore the set up of the web
app using Struts in the directory.
Struts: Our First Example
1 47
This logon is the root of the web app. Every path will be considered relative to this directory.
In this example, the pages directory will hold the JSP files. You have some
flexibility in where you place your JSPs, but wherever they go, you must make
sure your paths reflect that location.
This WEB-INF directory is
very important. In it we will
find the files at right.
We will explore these files more
on the next slide.
Our Action classes must go in this directory. In this
case, we see an app directorywhich tells us that our
Action class specified that it was in a package called
app.
The resources directory will hold .properties files,
such as Messages.properties or any other
resource we might need.
Finally, the lib directory holds JAR files such as the
struts.jar file.
1 48
As you recall from the previous slide, these files are
contained in the WEB-INF directory.
The web.xml file is the same one that
must be present in all web applications. In
our case, aside from listing the
ActionServlet as being present, this
web.xml has a line that informs it to
send all pages with a .do extension to the
ActionServlet for processing.
web.xml
1 49
This slide explores the struts-config.xml file
First, we create a key
logonForm that gives the
name of our ActionForm
struts-config.xml
These <action-mappings> tell the
ActionServlet which Action class
to execute when it encounters a particular
URI pattern.
In this example, you see that a forward has been
declared. This must work in concert with the business
logic in the Action class.
1 50
This is a look at the HTML behind our first JSP.
Welcome.jsp

Struts Demo

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Struts Demo

Hochgeladen von

Copyright:

Verfügbare Formate

1 1

Das könnte Ihnen auch gefallen