4. • Once you’ve 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
5. • Struts is based on the MVC or Model-View-Controller design pattern. Struts: Introduction
6. • Under Struts the work of operating a web application is divided up: ActionServlet —this Struts component controls navigation. Action —this Struts component controls business logic. Struts: Introduction
7. • Here’s 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. Struts: Introduction
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 Struts: Introduction
9. We will explore these in depth, but here’s a thumbnail version of each: ActionForm —Collects form data from HTML page. ActionServlet —Controls everything. ActionMapping —Helps when deciding where to go. ActionForward —Where to send request Action —Called to do business logic. Struts: Introduction
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>
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 Servlet’s doPost() method: String userField = request.getParameter(" user "); Struts: ActionForm <HTML> <HEAD><TITLE>Simple JSP</TITLE></HEAD> <BODY> <FORM METHOD="POST" ACTION="/SomeServlet"> <BR>Username: <INPUT TYPE="text" NAME =" user " VALUE=""> <BR>Password: <INPUT TYPE="text" NAME =" pass " VALUE=""> </FORM> </BODY> </HTML>
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 it’s 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 you —saving you the trouble of loading it. Struts: ActionForm
14.
15.
16. • So, let’s recall our HTML/JSP file, and then see how we would create the correct ActionForm: Struts: ActionForm <HTML> <HEAD><TITLE>Simple JSP</TITLE></HEAD> <BODY> <FORM METHOD="POST" ACTION="/SomeServlet"> <BR>Username: <INPUT TYPE="text" NAME=" user " VALUE=""> <BR>Password: <INPUT TYPE="text" NAME=" pass " VALUE=""> </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.
17. • When compiled, this .class file should be placed here: webapps myapp WEB-INF classes Struts: ActionForm
18. Struts: ActionForm • Here’s 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.
20. • The ActionServlet behaves like an orchestra Conductor. It doesn’t 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
21. • The ActionServlet uses a special xml configuration file called: struts-config.xml . Struts: ActionServlet When the web container receives a request in the form of /register-complete/enter .do , then—because of the .do extension—it 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.
22. • So, let’s 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.) … Struts: ActionServlet
24. • The Struts Java class called ActionMapping is used inside of the Action class (not yet covered). • It has only one method we’re 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
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
27. import org.apache.struts.action.*; 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.
28. import org.apache.struts.action.*; import javax.servlet.http.*; public class MyAction extends Action { public ActionForward perform( ActionMapping mapping , ActionForm form , HttpServletRequest req, HttpServletResponse res ) { 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, it’s called SimpleForm . Recall, since SimpleForm is an ActionForm , we can perform this cast. import org.apache.struts.action.*; public class SimpleForm extends ActionForm {
29. import org.apache.struts.action.*; import javax.servlet.http.*; public class MyAction extends Action { public ActionForward perform( ActionMapping mapping , ActionForm form , HttpServletRequest req, HttpServletResponse res ) { 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 how—depending on the results of the logic performed in this Action class—we use the ActionMapping class to decide where to send the request from here.
30.
31. • And let’s 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 ”. Here’s where that is defined.
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, let’s see if we can understand the entire process. Struts: Review So Far
34. 1.) Point your browser to a web page. http://localhost:8080/ register-complete /enter.jsp Struts: Review So Far First, we see that we’re executing the JSP called enter.jsp that lives in a web application called register-complete .
35. 2.) This is the HTML within the page enter.jsp Struts: Review So Far <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.
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. Struts: Review So Far Since we are already inside the register-complete web application, you can omit that part of the name. So, we’re doing a post against /register-complete/enter.do . The ActionServlet knows to strip off the .do , so it’s looking for a path mapped to /enter . And, we see that does exist.
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.
38.
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. Struts: Review So Far This same line also informs the ActionServlet which ActionForm class it should use when it captures all the request parameter information.
40. 6.) Finally, depending on the outcome of the business logic in the RegisterAction class, one of the findForward() methods is executed. Struts: Review So Far
42. Struts: Understanding the Architecture • Let’s 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 .
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. Struts: Understanding the Architecture
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
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 directory—which 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.
48. • As you recall from the previous slide, these files are contained in the WEB-INF directory. Struts: Our First Example 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
49. • This slide explores the struts-config.xml file Struts: Our First Example 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.
50. • This is a look at the HTML behind our first JSP. Struts: Our First Example Welcome.jsp
