Java Web Programming. Student Workbook

Transcription

1 Student Workbook

2 Java Web Programming Mike Naseef, Jamie Romero, and Rick Sussenbach Published by ITCourseware, LLC., 7245 South Havana Street, Suite 100, Centennial, CO Editors: Danielle Hopkins and Jan Waleri Editorial Assistant: Ginny Jaranowski Special thanks to: Many instructors whose ideas and careful review have contributed to the quality of this workbook and the many students who have offered comments, suggestions, criticisms, and insights. Copyright 2011 by ITCourseware, LLC. All rights reserved. No part of this book may be reproduced or utilized in any form or by any means, electronic or mechanical, including photo-copying, recording, or by an information storage retrieval system, without permission in writing from the publisher. Inquiries should be addressed to ITCourseware, LLC., 7245 South Havana Street, Suite 100, Centennial, Colorado, (303) All brand names, product names, trademarks, and registered trademarks are the property of their respective owners. Page ii Rev ITCourseware, LLC

3 Contents Chapter 1 - Course Introduction... 7 Course Objectives... 8 Course Overview Using the Workbook Suggested References Chapter 2 - Web Applications and MVC Web Applications JSPs and Servlets Model-View-Controller Model 2 Architecture The WAR File web.xml Building the WAR Deploying the WAR Labs Chapter 3 - JavaServer Pages Introduction to JSP JSP Syntax JSP Scripting Elements Request and Response Implicit Objects page Directive Error Handling The include directive include and forward Actions Labs Chapter 4 - Java Servlets HTTP Requests HttpServlet Servlet Lifecycle... Annotation ITCourseware, LLC Rev Page iii

4 RequestDispatcher HttpSession ServletContext Servlet Filters JSP vs. Servlet Labs Chapter 5 - JavaBeans What is a JavaBean? Rules Properties Using JavaBeans in JSPs Properties and Forms Data Access Objects Resource Reference Bean Scopes in Servlets Bean Scopes in JSPs Labs Chapter 6 - JSP Expression Language JSP Expression Language Literals Variables The. and [ ] Operators Other Operators Implicit Objects Labs Chapter 7 - Introduction to JSTL What is JSTL? Core Tags Conditionals Core Tags Iteration and Import Variables, Output, and Exceptions XML Manipulation Tags Internationalization Tags SQL Tags Labs Page iv Rev ITCourseware, LLC

5 Chapter 8 - Security Concepts Constraints Roles login-config BASIC Authentication FORM Authentication Login and Error Pages Labs Appendix A - Tag Libraries Custom Tags Using Custom Tags Defining Tags Tags with Attributes Fragments and Variables Packaging Tag Files Labs Appendix B - Ant What Is Ant? build.xml Tasks Properties and Property Files Managing Files and Directories Filesets Java Tasks Creating Java Archives Specifying Paths Miscellaneous Tasks Solutions Index ITCourseware, LLC Rev Page v

6 Page vi Rev ITCourseware, LLC

7 Chapter 1 Course Introduction Chapter 1 - Course Introduction 2011 ITCourseware, LLC Rev Page 7

8 Course Objectives Write web applications that combine Java Servlets, JavaServer Pages, and JavaBeans using the Model-View-Controller architecture. Use JavaBeans to encapsulate business and data access logic. Generate HTML or XML output with JavaServer Pages. Process HTTP requests with Java Servlets. Configure your web applications with the web.xml deployment descriptor. Create scriptless JSPs by using JSTL tags combined with JSP Expression Language for functionality, such as conditionals, iteration, internationalization, and XML processing. Page 8 Rev ITCourseware, LLC

9 Chapter 1 Course Introduction 2011 ITCourseware, LLC Rev Page 9

10 Course Overview Audience: Java programmers who need to develop web applications using JSPs and Servlets. Prerequisites: Java programming experience and basic HTML knowledge are required. Classroom Environment: A workstation per student. Page 10 Rev ITCourseware, LLC

11 Chapter 1 Course Introduction Using the Workbook This workbook design is based on a page-pair, consisting of a Topic page and a Support page. When you lay the workbook open flat, the Topic page is on the left and the Support page is on the right. The Topic page contains the points to be discussed in class. The Support page has code examples, diagrams, screen shots and additional information. Hands On sections provide opportunities for practical application of key concepts. Try It and Investigate sections help direct individual discovery. In addition, there is an index for quick look-up. Printed lab solutions are in the back of the book as well as on-line if you need a little help. The Topic page provides the main topics for classroom discussion. The Support page has additional information, examples and suggestions. Java Servlets Chapter 2 Servlet Basics The Servlet Life Cycle The servlet container controls the life cycle of the servlet. When the first request is received, the container loads the servlet class and calls the init() method. Topics are organized into first (), second ( ) and For every request, the container uses a separate thread to call the service() method. third ( ) level When points. the servlet is unloaded, the container calls the destroy() method. As with Java s finalize() method, don t count on this being called. Override one of the init() methods for one-time initializations, instead of using a constructor. The simplest form takes no parameters. Hands On: Add an init() method to your Today servlet that initializes a bornon date, then print the bornon date along with the current date: Today.java... public class Today extends GenericServlet { private Date bornon; public void service(servletrequest request, ServletResponse response) throws ServletException, IOException {... // Write the document out.println("this servlet was born on " + bornon.tostring()); out.println("it is now " + today.tostring()); } public void init() { bornon = new Date(); } The init() method is called when the servlet is } loaded into the container. Callout boxes point out important parts of the example code. Code examples are in a fixed font and shaded. The on-line file name is listed above the shaded area. public void init() {...} If you need to know container-specific configuration information, use the other version. public void init(servletconfig config) {... Whenever you use the ServletConfig approach, always call the superclass method, which performs additional initializations. super.init(config); Page 16 Rev ITCourseware, LLC Pages are numbered sequentially throughout the book, making lookup easy. Screen shots show examples of what you should see in class ITCourseware, LLC Rev Page ITCourseware, LLC Rev Page 11

12 Suggested References Basham, Bryan, Kathy Sierra, and Bert Bates Head First Servlets and JSP: Passing the Sun Certified Web Component Developer Exam (SCWCD). O'Reilly & Associates, Sebastopol, CA. ISBN Bergsten, Hans JavaServer Pages, 3rd Edition. O'Reilly & Associates, Sebastopol, CA. ISBN Hall, Marty and Larry Brown Core Servlets and JavaServer Pages, Vol. 1: Core Technologies, 2nd Edition. Prentice Hall, Englewood Cliffs, NJ. ISBN Hall, Marty, Larry Brown and Yaakov Chaikin Core Servlets and JavaServer Pages, Volume II (2nd Edition). Prentice Hall, Englewood Cliffs, NJ. ISBN Heffelfinger, David, Java EE 6 with GlassFish 3 Application Server. Packt Publishing, Birmingham, UK. ISBN Jendrock, Eric, et.al The Java EE 6 Tutorial: Basic Concepts (4th Edition). Prentice Hall, Upper Saddle River, NJ. ISBN Steelman, Andrea, Joel Murach. Bergsten, Hans Murach's Java Servlets and JSP, 2nd Edition. Mike Murach & Associates. ISBN Java Servlet Technology: JSP Technology: JSTL Technology: Java EE 6 Tutorial: Page 12 Rev ITCourseware, LLC

13 Chapter 1 Course Introduction 2011 ITCourseware, LLC Rev Page 13

14 Page 14 Rev ITCourseware, LLC

15 Chapter 2 Web Applications and MVC Chapter 2 - Web Applications and MVC Objectives Describe Java web technologies. Explain how the Model-View-Component architecture applies to a web application. Describe the structure of WAR files. Build and deploy a web application ITCourseware, LLC Rev Page 15

16 Web Applications Web applications are applications that the end user can access using a standard web browser. The Java Platform Enterprise Edition (Java EE) defines a web application as a collection of web components and supporting files. Web components include Java servlets and JSP files. Supporting files include static HTML documents, image files, and supporting classes. Your web application runs in the environment of a web container, which is managed by an application server. Web containers can contain several web applications. Your applications can work together or operate independently. Each web application is addressed with a context path. The context path is determined when the application is deployed. A web container can contain a "default" application, which has an empty context path. To access a component or file in the web application from a browser, you must include the context path in the request URL. Page 16 Rev ITCourseware, LLC

17 Chapter 2 Web Applications and MVC Browser HTTP Application Server Web Container Web Application Servlet JSP 2011 ITCourseware, LLC Rev Page 17

18 JSPs and Servlets The standard protocol for communication between browsers and servers is designed for static documents. Typically, a web server returns the contents of a static file in response to a browser request. Use servlets and JavaServer Pages (JSP) to handle requests from a browser dynamically. A servlet is a web component which receives an object encapsulating the browser request and constructs a response to the browser. The response typically contains an HTML document. JSP pages start as text documents containing HTML or XML with special tags for executing Java code. JSP pages are compiled into servlets automatically. HTML designers do not need to learn Java. Java developers do not need to learn HTML. You get some important benefits by using Java's web component architecture: Your application will be portable across web containers. You can get better performance and security from servlets than from standard CGI. You can make full use of the vast set of Java APIs. You can use facilities provided by the web container to maintain state. Page 18 Rev ITCourseware, LLC

19 Chapter 2 Web Applications and MVC 2011 ITCourseware, LLC Rev Page 19

20 Model-View-Controller The Model-View-Controller (MVC) architecture was originally described by Smalltalk for implementing GUI applications. The primary goal of MVC is to separate user interface code (the view) from domain code (the model). The controller is introduced as a separate body of code that manages the translation of events in the view to procedures in the model. The view only accesses the model to retrieve values for display. The model should not have any knowledge of the view or the controller. The benefits of MVC are similar to encapsulation. Changes in the model can be made without impacting the view. The view can be modified, or new views can be implemented without impacting the model. Developers can focus on their skills database programmers do not need to understand user interface issues. MVC adapts well to the needs of web applications. The view is further separated from the model both architecturally and physically. The controller typically takes a broader role, managing the view as well as the model. Page 20 Rev ITCourseware, LLC

21 Chapter 2 Web Applications and MVC View Controller Model 2011 ITCourseware, LLC Rev Page 21

22 Model 2 Architecture The typical adaptation of MVC to Java web applications is called the Model 2 Architecture. Use JavaBeans to define the model. The controller should encapsulate business object data in JavaBeans to make the data accessible to the JSP views. The controller can provide helper JavaBeans to convert data from the business object to formats appropriate to the view. For example, a JavaBean could convert a date to an appropriate string value. Use a servlet as the controller. It will extract data needed to handle the request from the browser. The servlet will also call methods on business objects to process the request. Finally, it will forward the request to the JSP page, including any beans needed to generate the view. The servlet might choose between JSP pages based on the results of the request. Use JSP pages to generate the view typically an HTML or XML document. The view will retrieve information to display from the beans included by the servlet. Page 22 Rev ITCourseware, LLC

23 Chapter 2 Web Applications and MVC In the early days of JSP, the popular architecture was what is now referred to as "Model 1." In this architecture, a browser request is handled directly by a JSP file, which, in turn, creates JavaBeans to access the business objects. In both Model 1 and Model 2 architectures, JavaBeans are the preferred mechanism for accessing business objects. The JSP specification has strong support for working with JavaBeans objects, which makes it easier to separate the display logic of the JSP file from the business logic of the application. ArticleNotFound.jsp ListArticles.jsp ShowArticle.jsp View Browser blognews.articleservlet JSP 1 Web Container 3 Controller Servlet 2 Model JavaBean blognews.article The filenames shown in the diagram refer to files in the BlogNews example application ITCourseware, LLC Rev Page 23

24 The WAR File You must organize your web application using a specific directory structure. The application root directory acts as the document root for your application. You put your JSP, HTML, and other supporting files here. You can use subdirectories to organize your application. Store your application files in a subdirectory named WEB-INF. Place the optional web.xml configuration file here. This subdirectory is not accessible via the web server. Put your servlet classes and supporting classes in the WEB-INF/classes directory. Put any JAR files specific to your application in the WEB-INF/lib directory. This is the preferred method for storing your JavaBeans. If a JAR file will be used by other applications, it may make more sense to put it in a system-wide or server-wide directory. You can package your application for distribution in a Web ARchive (WAR) file. A WAR file is a JAR file that contains all of the files in your application. Since WAR files must conform to the Java EE specifications, they are portable between different web containers. Page 24 Rev ITCourseware, LLC

25 Chapter 2 Web Applications and MVC Contents of BlogNews.war: ArticleNotFound.jsp BadPostArticle.jsp GenericErrorHandler.jsp index.html ListArticles.jsp NewArticle.html ShowArticle.jsp ViewArticle.html META-INF MANIFEST.MF META-INF and MANIFEST.MF are artifacts created by the jar utility. They have no effect on the war. WEB-INF web.xml classes Most container vendors also suggest a vendorspecific XML file in the WEB-INF directory. blognews Article.class ArticleFactory.class ArticleNotFoundException.class ArticleDateComparator.class ArticleServlet.class 2011 ITCourseware, LLC Rev Page 25

26 web.xml Provide an optional deployment descriptor to supply additional configuration information for your web application. Create it as WEB-INF/web.xml in your web application directory. List files the container should look for when the user request specifies a context with the <welcome-file-list> element. Use the <error-page> element to delegate error handling to your own servlets, JSP pages, or HTML files. This allows you to customize the appearance of your error pages dynamically. HTTP errors are mapped by the 3-digit status code. <error-page> <error-code>404</error-code> <location>/errors/pagenotfound.jsp</location> </error-page> Exceptions are mapped by the full class name of the exception handled. <error-page> <exception-type>java.io.ioexception</exception-type> <location>/errors/ioexception.jsp</location> </error-page> The web container looks for a page matching the class of the exception thrown or one of its superclasses. When the web container invokes your error handler, it provides request attributes with the error code or exception, and the original request URI. Use these attributes to customize your error response. Page 26 Rev ITCourseware, LLC

27 Chapter 2 Web Applications and MVC Examples/WebContent/WEB-INF/web.xml <?xml version="1.0" encoding="utf-8"?> <web-app xmlns:xsi=" xmlns=" xmlns:web=" java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemalocation=" java.sun.com/xml/ns/javaee id="webapp_id" version="3.0"> <description> This is the BlogNews application. Setup is straightforward. No changes should be necessary at deployment unless you wish to change the default error page or the welcome file. Articles will be stored in the WEB-INF/articles directory which is created automatically the first time the servlet is accessed. </description> <welcome-file-list> <welcome-file>index.html</welcome-file> <welcome-file>index.htm</welcome-file> <welcome-file>index.jsp</welcome-file> <welcome-file>default.html</welcome-file> <welcome-file>default.htm</welcome-file> <welcome-file>default.jsp</welcome-file> </welcome-file-list> <error-page> <error-code>404</error-code> <location>/genericerrorhandler.jsp</location> </error-page> </web-app> You can use a <description> element to provide documentation. The location is specified relative to the web application root. Note: Prior to the Servlet 3.0 specification, web.xml was required. Servlet 3.0 defined several annotations that you can add to your code to take the place of many, but not all, of the web.xml entries ITCourseware, LLC Rev Page 27

28 Building the WAR You build your application using these steps: 1. Create a directory in which to build your web application. mkdir webapp 2. Compile your classes putting the resulting class files in WEB-INF/classes. javac -d webapp/web-inf/classes *.java If you create any JAR files, put them in WEB-INF/lib. 3. Copy your JSP files, HTML files, and other supporting files into the application directory. 4. Optionally, create your deployment descriptor in WEB-INF/web.xml. To build the WAR file, use the jar command to archive the application directory. jar cf MyApplication.war webapp Page 28 Rev ITCourseware, LLC

29 Chapter 2 Web Applications and MVC To simplify the building and deployment process, we will use the Apache Software Foundation's Ant tool. To use Ant, you create an XML configuration file called build.xml and define targets that define the steps for building and deploying your application. The targets also set dependencies, so that you can compile, build, and deploy with a single command. For this class, we have provided build.xml files for you with targets for compiling the Java files, building the WAR file, and deploying the WAR file. To complete all of the steps on the preceding page, you simply need to run the ant command with the appropriate build target. Your instructor will give you the details of how to run Ant and which target to use ITCourseware, LLC Rev Page 29

30 Deploying the WAR You deploy a web application with these fundamental steps. 1. Pass the WAR file to your web container. You might simply copy the file to a specific location or use a tool to locate the file. 2. Specify the context path for the application. The context path often defaults to the name of the WAR file. 3. Configure any container-managed resources as specified in the deployment descriptor. These might include database connections, JNDI services, and security roles. The mechanisms for performing these is determined by your web container. Some container providers have GUI or web-based tools for deploying applications. You may need to create the appropriate configuration files manually and include them in your WAR file. Page 30 Rev ITCourseware, LLC

31 Chapter 2 Web Applications and MVC Try It: The BlogNews application is a simple example of a web application using the Model 2 architecture. The application allows you to create and display a list of articles. The servlet creates a new directory within the WEB-INF directory of the deployed application. The articles are stored in this new directory as serialized objects. The upside of this implementation is that you do not need to configure a storage directory or database. The downside is that this directory is usually destroyed when the application is redeployed. The classes in the blognews package represent the controller, the model, and the business logic. The Article class is our model JavaBean. The ArticleFactory and supporting class ArticleNotFoundException provide the business logic for working with articles. The ArticleServlet is the controller Start Tomcat, then build and deploy the application by running the ant command in the chapter's Examples directory. To view the application, navigate with your browser to ITCourseware, LLC Rev Page 31

32 Labs Modify the deployment descriptor so that the 405 error (generated when a user tries to use a GET when a POST is required) is handled by the GenericErrorHandler. You can generate this error by entering the URL for the View command manually in your browser's address bar ( (Solution: Solutions-Lab1/WebContent/WEB-INF/web.xml) Modify the servlet so that it throws a runtime exception (try dividing by zero or dereference a null pointer). Deploy the application and observe the error displayed. Now, modify the deployment descriptor so that GenericErrorHandler.jsp is displayed instead. (Solutions: Solutions-Lab2/src/blognews/ArticleServlet.java, Solutions-Lab2/WebContent/ WEB-INF/web.xml) (Optional) Create a new view which lists only the titles of the articles. Add an action to the servlet to display the view, and add a link to index.html in order to access this action. (Solutions: Solutions-Lab3/src/blognews/ArticleServlet.java, Solutions-Lab3/WebContent/ ListTitles.jsp, Solutions-Lab3/WebContent/index.html) (Optional) Create a new view that allows the user to edit the body of an article. You will need to create a form to enter the title of the article to edit and a new action in ArticleServlet to display the new view using the article entered in the form. The new view can use the existing Post action in the servlet to save the changes. Add a link to index.html to display the new form. (Solutions: Solutions-Lab4/WebContent/EditArticle.jsp, Solutions-Lab4/WebContent/ EditArticle.html, Solutions-Lab4/src/blognews/ArticleServlet.java, Solutions-Lab4/ WebContent/index.html) Page 32 Rev ITCourseware, LLC

33 Chapter 2 Web Applications and MVC 2011 ITCourseware, LLC Rev Page 33

34 Page 132 Rev ITCourseware, LLC

35 Chapter 8 Security Chapter 8 - Security Objectives Add authentication and authorization to a web application. Use HTTP Basic and Form-based login methods. Create security roles and constraints in web.xml ITCourseware, LLC Rev Page 133

36 Concepts Often, you want to restrict access to your web application to certain users. Authentication allows you to identify who is trying to run the application. At a bank, you will be asked to present a picture ID to prove your identity. Once you know who the user is, you need to authorize that user; that is, decide if they are allowed access. Even if you prove your identity, the bank will not let you access another person's account. Another person can tell the bank you should have access to their account. Web applications need to authenticate a user, and then determine if the user is authorized to perform a request. A user often provides a password to authenticate their identity. The web application can then check requested actions against those allowed for the user. Page 134 Rev ITCourseware, LLC

37 Chapter 8 Security Hands On: A news blog application is provided in the chapter directory. Currently, it has no security restrictions. We will add security features to this application throughout this chapter. Build and deploy the application using Ant. Navigate with your browser to SecureBlogNews to view the application. Browser Application Server HTTP Request 401 Authentication Required Access a Restricted URL Prompt for username and password Original HTTP Request + username and password Web Page Username/ password OK Note: All subsequent HTTP requests will include the username/password (if needed). They are cached for the given realm ITCourseware, LLC Rev Page 135

38 Constraints Add <security-constraint> entries to web.xml to restrict access to portions of a web application. Each security constraint entry describes what access is allowed on a set of resources. Security constraints must have a <web-resource-collection> sub-element, describing the set of resources covered by the security constraint. The collection must have a <web-resource-name> sub-element describing the collection. The collection can have any number of <url-pattern> sub-elements describing URLs to include in the collection. URL patterns can include wildcard characters. Security constraints should have an <auth-constraint> sub-element. Leaving out the <auth-constraint> results in access by everyone. An empty <auth-constraint> results in access by no one. Page 136 Rev ITCourseware, LLC

39 Chapter 8 Security Hands On: Add the following entry to the end of Examples/WebContent/WEB-INF/web.xml:... </error-page> <security-constraint> <web-resource-collection> <web-resource-name>the entire app</web-resource-name> <url-pattern>/*</url-pattern> </web-resource-collection> <auth-constraint/> </security-constraint> </web-app> Use Ant to redeploy the application and try it out. Note that all pages of the application are now restricted ITCourseware, LLC Rev Page 137

40 Roles Roles specify who is allowed access to secured resources. Roles provide finer granularity than "everyone" and "no one." The <security-role> element specifies which roles are available for use by the web application. The <role-name> sub-element defines a role. Use as many <security-role> elements as needed. The <auth-constraint> element specifies which roles are allowed access to the resource. No one has access if no roles are provided. Specify a role using the <role-name> sub-element. Provide as many <role-name> sub-elements as needed. The special role "*" matches all the roles defined by the <security-role> elements in web.xml for this application. Assignment of users to roles is application-server specific. Page 138 Rev ITCourseware, LLC

41 Chapter 8 Security Hands On: The application server contains a user entry with username student and password password, which is mapped to the blog-user role. Change <auth-constraint> in web.xml and add the <security-role> entry to the end of web.xml:... </error-page> <security-constraint> <web-resource-collection> <web-resource-name>the entire app</web-resource-name> <url-pattern>/*</url-pattern> </web-resource-collection> <auth-constraint> <role-name>blog-user</role-name> </auth-constraint> </security-constraint> <security-role> <role-name>blog-user</role-name> </security-role> </web-app> You have specified who can use the application, but do not yet have a way to determine the user's identity ITCourseware, LLC Rev Page 139

42 login-config Add a <login-config> element to tell the application what type of authentication to use. BASIC and FORM authentication use a username and password type of authentication. Other authentication methods exist, but require more setup and are lesscommonly used. The <login-config> element also provides any extra information needed by the authentication method. Once a user is authenticated, the container looks up which roles are associated with that user. Requests against secured resources result in the container asking for authentication. The container allows or denies the request based on whether the user has a role that can use the resource. Use the getremoteuser() method of the request inside a servlet to return the user's name. public void doget(httpservletrequest req, HttpServletResponse res){ String user=req.getremoteuser();... } Page 140 Rev ITCourseware, LLC

43 Chapter 8 Security Hands On: Add the following entry to the end of web.xml, but do not redeploy the application.... <security-role> <role-name>blog-user</role-name> </security-role> <login-config> </login-config> </web-app> 2011 ITCourseware, LLC Rev Page 141

44 BASIC Authentication The default form of authentication is BASIC. Explicitly set BASIC authentication by setting the <auth-method> subelement of <login-config> to BASIC. You can provide an optional realm name with the <realm-name> subelement. The realm is usually not important except as part of the client prompt. The application server tells the client which realm the resource is in, and asks the client to get the corresponding username and password. The client displays a dialog box presenting the request. The client encodes the username and password, passing them back to the application server. The client encodes the username and password using the Base-64 scheme. Base-64 is easy to decode, so treat it as if the username and password are sent as plain text. Use HTTPS instead of HTTP if this is an issue. Page 142 Rev ITCourseware, LLC

45 Chapter 8 Security Hands On: Change the login config in web.xml to the following and redeploy the application:... <security-role> <role-name>blog-user</role-name> </security-role> <login-config> <auth-method>basic</auth-method> <realm-name>news Blog</realm-name> </login-config> </web-app> Now a dialog box displays when you try to access the application. Submit the dialog using student and password to access the application ITCourseware, LLC Rev Page 143

46 FORM Authentication Customize the login form with FORM authentication. BASIC authentication presents a standard dialog box that cannot be customized. Set the <auth-method> sub-element of <login-config> to FORM to use FORM authentication. The <form-login-config> sub-element of <login-config> provides additional information. The <form-login-page> sub-element provides the URL of the custom login form. The <form-error-page> sub-element provides the URL of the custom login error page. The application server uses these pages instead of the standard authentication dialog box. FORM authentication does not use realms. Usernames and passwords are plain text fields of a form. Use HTTPS to keep these secret. Page 144 Rev ITCourseware, LLC

47 Chapter 8 Security Hands On: Replace the <login-config> entry in web.xml and redeploy the application:... <security-role> <role-name>blog-user</role-name> </security-role> <login-config> <auth-method>form</auth-method> <form-login-config> <form-login-page>/customlogin.html</form-login-page> <form-error-page>/customloginerror.html</form-error-page> </form-login-config> </login-config> </web-app> Access the application and note that the custom login screen is now used. Enter an invalid username and password to bring up the custom error page. Login with a valid username and password to access the application ITCourseware, LLC Rev Page 145

48 Login and Error Pages The custom login page must contain a form that follows some simple rules. The action for the form must be j_security_check. The form must contain a field named j_username. The form must also contain a field named j_password. The custom login page can contain anything else you want. The custom error page can be any page you want. HTML or JSP is fine. No special rules it is just like any other page. Possible additions to an error message are: A link to try again A link to a forgotten password or username A link to reset a forgotten password Page 146 Rev ITCourseware, LLC

49 Chapter 8 Security Examples/WebContent/CustomLogin.html <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" " <html>... <body> Please Login below: <p> <form method="post" action="j_security_check"> <table> <tr> <td>login:</td> <td><input type="text" name="j_username"></td> </tr> <tr> <td>password:</td> <td><input type="password" name="j_password"></td> </tr> <tr><td><input type="submit" value="submit"></td></tr> <tr><td></td></tr> </table> </form> </body> </html> Examples/WebContent/CustomLoginError.html <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" " <html>... <body> Bad username/password combination - is the Caps Lock on? </body> </html> 2011 ITCourseware, LLC Rev Page 147

50 Labs The StarterCode directory contains a candy store application. Use Ant to deploy the application. The main entry point to the application is An admin page is also available at localhost:8080/truffles/admin/setprice. Add BASIC authentication to the application such that any recognized user can run the application. (Solution: Solutions/WebContent/WEB-INF/web.xml) Change the BASIC authentication to FORM authentication. (Solution: Solutions/WebContent/WEB-INF/web.xml.2, Solutions/WebContent/ TruffleLogin.html, Solutions/WebContent/TruffleError.html) Change the authentication so that only the manager can set prices. (Solution: Solutions/WebContent/WEB-INF/web.xml.3) Page 148 Rev ITCourseware, LLC

51 Chapter 8 Security The application server contains the following accounts that you can use in the labs. username password role customer1 customer2 manager password password password cust cust mgr 2011 ITCourseware, LLC Rev Page 149