MELJUN CORTES Jedi course notes web programming-lesson2-basic servlets

1,423 views
1,346 views

Published on

MELJUN CORTES Jedi course notes web programming-lesson2-basic servlets

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
1,423
On SlideShare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
14
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

MELJUN CORTES Jedi course notes web programming-lesson2-basic servlets

  1. 1. ServletsIntroductionDefinitionA servlet is a Java programming language class used to extend the capabilities of serversthat host applications accessed via a request-response programming model as adaptedfrom j2EE Tutorial. It is a Java class that implements the Servlet interface and acceptsrequests that can come from Java classes, Web clients, or other Servlets and generatesresponses."Servlets" are also called "HTTP Servlet". This is because servlets are commonly usedwith HTTP, but are actually not tied to a specific client-server protocol.To start making servlets, youll need to have knowledge about Java programming, client-server concepts, basic HTML and HTTP (HyperText Transfer Protocol). To create aServlet, youll need to import in your java program the standard extension classes in thepackages javax.servlet and javax.servlet.http.javax.servlet contains the basic servlet framework, while javax.servlet.http is usedas an extension of the Servlet framework for Servlets that answer HTTP requests.Servlet Architecture OverviewPrior to Servlets, one of the most common ways of adding functionality for a web serverwas through the use of Common Gateway Interface (CGI). CGI provides a server aninterface to an external program, allowing it to be called by the server to handle clientrequests. However, CGI was designed in such a way that each call for a CGI resourcecreates a new process on the server; information meant for the program is passed tothis process using standard input and environment variables. Once the request isaccomplished, the process is shut down, returning resources to the system. The problemincurred by this approach was that it imposed a heavy requirement on system resources,limiting the number of users that the application can handle at the same time.Servlets were designed to be able to bypass this problem inherent in CGI and to providedevelopers a robust Java solution to creating applications for the Web. Instead ofcreating a heavy-weight process on the server each time a request from a client comesin, with servlets, there is only one process that handles ALL requests: the processrequired by the servlet container to run. When a new request comes in, the containercreates only a lightweight thread to execute the servlet.Servlets are also loaded into memory only once: either the container loads them intomemory on server startup, or the first time the servlet is required to service a client,unlike CGI where each client request loads and unloads the program data into and frommemory. Once the servlet is loaded into memory, it stays loaded in memory, ready tohandle further client requests.
  2. 2. Servlet First LookThe sample code that follows shows the structure of a basic servlet that handles GETrequests, as well as displays the traditional Hello World. import java.io.*; import javax.servlet.*; import javax.servlet.http.*; public class HelloServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //"request" is used for reading incoming HTTP headers // HTML form data (e.g. data the user entered and submitted) // and other data that can be inferred from the client request. // "response" is for specifying the HTTP response line and // headers(e.g. specifying the content type, setting cookies). // It also contains methods that allow the servlet to generate // responses for the client. PrintWriter out = response.getWriter(); out.println("<HTML> <TITLE>Hello Page</TITLE><BODY><br>"); out.println("<h1>Hello World!</h1>"); out.println("</BODY></HTML>"); //"out" for sending content to browser } } Figure 1: Basic Servlet that Displays Hello WorldThe first part of the code in Figure 2.1 is importing classes in java.io (for PrintWriter,etc.), javax.servlet and javax.servlet.http. The javax.servlet and javax.servlet.http arepackages that provide interfaces and classes for wrtiting servlets (for HttpServlet,HttpServletRequest and HttpServletResponse).By extending HttpServlet, this class inherits methods that are automatically called by theserver depending on certain conditions which will be expound more later. By overridingthese methods, we can make our servlet perform the functionality we want it to do.In this case, the method inherited from HttpServlet that we overrode is the doGetmethod. To put it simply, it is the method invoked by the servlet container whenever aGET request is issued to a particular servlet. Remember from the previous module thatsite navigation, document retrieval, page viewing are examples of GET requests. So,whenever a user wants to view the output of our servlet, it is a GET request that isissued.
  3. 3. If we look at the code listing, we will see that the doGet method takes in twoparameters: an HttpServletRequest object and an HttpServletResponse object. Wherethese objects came from are no longer the concern of the developer. They are createdand maintained by the servlet container and are simply passed to us the moment thecontainer calls the doGet method. In respect to this, the doGet method and othermethods to be discussed later, are similar in a way to the public static voidmain(String[] args) method we use in a command-line based Java program. We do notcreate the String array passed into the method; it is simply provided for us by theruntime environment.HttpServletRequest and HttpServletResponse objects provide developers with well-needed functionality: • The HttpServletRequest object provides access to all information regarding the clients request, including whatever form parameter values they may have put in, HTTP request headers, the HTTP request method that they used, etc. • The HttpServletResponse object contains all the necessary methods needed by developers to produce a response that will be sent back to the client. This includes methods to set the HTTP response headers to declare the MIME type of the response, as well as methods to retrieve instances of Java I/O classes that we can use directly to produce output.Going back to the code, we see that, aside from the comments, there are only severallines that we use to perform the functionality of displaying "Hello World!" to the user.One is PrintWriter out = response.getWriter(), and the other, multiple calls toout.println(). For now, think of the PrintWriter simply as an object that will let us outputtext to the client browser. With that in mind, it is easy to see how multiple calls toout.println() is able to produce the following content: Figure 2: Output of HelloServletTesting the Sample ServletAt this point, we need to be able to display the output of the sample servlet. To initiallyabstract the details of servlet deployment and configuration, we will be making use ofthe automated tools provided by IDEs. The IDE that we will be making use of in our
  4. 4. example is Sun Studio Enterprise 8, which is available for free for members of the SunDeveloper Network. It has complete support for the servlet and JSP specifications, aswell as a host of additional features.From here on, we will assume that Enterprise 8 has already been successfully installed inyour system. For help in installation, refer to the Appendix section of this courseware.First off, for our servlet example here, we need to create a new web application project.To do this, in the menubar, select New->Project. In the screen that appears next, selectthe Web category. In the right, choose New Web Application.The next screen will prompt you for details about the project. For our first test servlet,lets make use of "FirstServletProject" as our project name, and make use of defaultvalues for the other fields. Figure 3: Creating a New Web Application Project
  5. 5. After creating a new web project, the screen should look something like what isillustrated below: Figure 4: New Web Application ProjectTo add our servlet to the application, right click on Source Packages, select New->Servlet. If Servlet does not appear in the New context menu, select New->File/Folderinstead. In the next screen, select the Web category, then Servlet.
  6. 6. Figure 5: Adding Servlet to the ApplicationThe IDE will then launch a series of screens which will ask for details about the servlet tobe created. In the first screen, name the servlet FirstServlet. Under package name, usejedi.servlet.
  7. 7. Figure 6: Changing the Class Name and Package NameIn the screen that follows, leave the default values untouched. Click the Finish button.
  8. 8. This will result in something like the screen below being generated. Figure 7: The processRequest MethodFrom this we can see that the IDE has created and partially implemented for us amethod named processRequest . If we were to click on the box with a plus sign on thelower left, we would see that processRequest is simply a method that will be called byboth doGet and doPost. This means that the contents of processRequest method formthe basis of the functionality of our servlet.First, remove all contents of the processRequest method. Then, copy/paste the contentsof the doGet method from the code listing for the test servlet into it.
  9. 9. Figure 8: New processRequest MethodTo run, press Shift + F6. The IDE will then package, deploy, and invoke the servletautomatically for the production of output.Servlet LifecycleA servlet is managed through a well-defined lifecycle described in the servletspecification. The servlet lifecycle describes how a servlet is loaded, instantiated,initialized, services requests, destroyed and finally garbage collected. The lifecycle of aservlet is controlled by the container in which the servlet has been deployed.The servlet life cycle allows servlet engines to address both the performance andresource problems of CGI and the security concerns of low-level server APIprogramming. A servlet engine may execute all its servlets in a single Java virtualmachine (JVM). Because they are in the same JVM, servlets can efficiently share datawith each other, but they are prevented by the Java language from accessing oneanothers private data. Servlets may also be allowed to persist between requests asobject instances, taking up far less memory than full-fledged processes.The image above shows the major events in a servlets life. It is important to note thatfor each of these events there is a method in the servlet that will be invoked by thecontainer. Lets go through them one by one.
  10. 10. InstantiationIn this stage, the servlet class is loaded into memory, and an instance of it created bythe servlet container.By default, a servlet container practices what is called lazy loading. Using this method,a servlet class is loaded into memory, instantiated, and initialized only after a requesthas been made for it. This makes a faster startup time for the application, but this alsomeans that there is a little bit of overhead associated to the first call of each servlet. Ifthis behavior were undesirable, each servlet can be configured to be loaded at server orapplication startup. More on this later in our discussion of the applications deploymentdescriptor.As we can see in the diagram, a servlet goes through the instantiation phase only onceper lifetime. This means that the overhead associated with loading the servlets classdefinition into memory happens only once. This shows the servlets advantage over othercompeting technologies.The relevant method that the container will call at this stage will be the servlets no-argument constructor. It is not really recommended that any code be placed in theconstructor though. Most functionality that developers want to add to constructorsinvolves the set-up of the object, or the initialization of its values. Servlets have aseparate phase for this kind of activity.InitializationIn this phase, the servlet is primed for use in the application. Like the instantiationphase, a servlet goes through this stage only once. It is only after this phase that ourobject instance can start to be called a servlet.The method that is called by the container at this point is the init() method. Itscomplete method signature is presented below. public void init(ServletConfig config)As we can see, this method takes in one parameter: an instance of a ServletConfigobject. This object contains the servlets configuration information, as well as providing away for the servlet to access application-wide information and facilities.As mentioned before, any configuration or initialization code should not be placed in theservlets constructor but should instead be placed here in the init method. If a developeris to implement this method though, it is important that he remember to make a call tosuper.init(config). This makes sure that a servlets default initialization action is notleft out and its configuration info is properly set.After initialization, the servlet is able to handle client requests.This method can only be called again when the server reloads the servlet . The servercannot reload a servlet until after the server has destroyed the servlet by calling thedestroy method.
  11. 11. ServiceThis is the phase when a servlet is in for the bulk of its lifetime. In this phase, the servletcan be repeatedly called by the container to provide its functionality.The following is the signature of the method invoked by the servlet container during thisphase: public void service(ServletRequest req, ServletResponse res)The ServletRequest and ServletResponse objects passed on to this method providemethods to extract information from the users request and methods to generate theresponse.One important thing to note is that the servlet container makes these repeated calls tothe service method using separate threads. Mostly, there is only one active servletinstance taking up space in memory, handling multiple requests. That is one advantagea Java servlet has. That is also one of the reasons why a servlet (and its service method)should always be designed to be thread-safe.For HTTP-specific servlets (servlets extending HttpServlet), developers should notoverride the service method directly. Instead, developers should override any of thefollowing methods: public void doGet(HttpServletRequest req, HttpServletResponse res) public void doPost(HttpServletRequest req, HttpServletResponse res) public void doPut(HttpServletRequest req, HttpServletResponse res) public void doTrace(HttpServletRequest req, HttpServletResponse res)Each of these methods correspond to a specific HTTP method (GET, POST, ...). Theappropriate method is then called when the servlet receives a HTTP request.Since most HTTP calls that developers concern themselves with are either GET or POSTmethod calls, servlets can implement only doGet, doPost, or both.DestructionThere are times when a servlet container will run out of memory, or detect that theamount of free memory it has is within a certain threshold. When this happens, thecontainer will attempt to free up memory by destroying one or more servlet instances.Which servlet to be removed is determined by the servlet container and is not somethinga developer has direct control over.A container will also free up a servlet instance as part of its shutdown process.When a servlet is to be removed from a containers management, it is said to be in itsdestruction phase. The method called by the container before this is accomplished is thedestroy() method. Here, our servlet should be coded to explicitly free up resources thatit has a handle to (e.g. Database connections).
  12. 12. Garbage CollectionThis phase in the servlet lifecycle is equivalent to that in any other Java object. As arecap, this phase occurs just before an object instance is removed from memory (a.k.a.garbage collected). Developers have no direct control as to when this will occur.The object method called in this phase is the finalize() method.Section QuizAnswer the following questions about a servlets phases:1. What are the 5 phases of a servlets lifecycle?2. What are the servlet methods associated with each phase of the lifecycle?3. Why does code placed in a servlets service method need to be thread-safe?4. When is a servlet destroyed?5. How many times can the code placed in the servlets init() method be called? In the service() method?6. If our servlet extends HttpServlet, what additional methods can we override to produce the needed functionality?Handling Requests and ResponsesThe main purpose of a servlet is to provide dynamic content to the user. By definition,dynamic content changes in response to various conditions. Examples of which are theparticulars of a user request, time of day, etc.To give the servlet access to the particulars of a users request, it is provided an instanceof a ServletRequest object that encapsulates those details. HTTP-based servlets aregiven a subclass, HTTPServletRequest, that provides additional methods in retrievingHTTP-specific information, such as cookie information, header details, etc.Form Data and Parametersrequest.getParameterOne of the most often encountered scenarios requiring dynamic content is when we wantour application to respond to the user data as presented in a form.Take the following example:
  13. 13. Figure 9: Input User NameGiven the form above which takes in the users name, we want to be able to produce aresponse customized to that users name.For this and other similar scenarios, Java provides the getParameter method in theHttpServletRequest object. The following is its method signature: public String getParameter(String parameterName)Basically, this method takes in the name of the parameter we wish to retrieve andreturns the String value of that parameter.Below is a sample code that takes in the users name and outputs a simple greeting,followed by the HTML used to display the form.public class GetParameterServlet extends HttpServlet {public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // retrieve the value supplied by the user String userName = request.getParameter("userName"); // retrieve the PrintWriter object and use it to output the greeting PrintWriter out = response.getWriter(); out.println("<HTML><BODY><H1>"); out.println("HELLO AND WELCOME, " + userName + "!"); out.println("</H1></BODY></HTML>"); out.close(); }} Figure 10: Sample servlet that takes int the uses name and outputs a simple greeting
  14. 14. <HTML> <TITLE>Halloa!</TITLE> <BODY> <form action="GetParameterServlet" method="post"> Enter user name: <input type="text" name="userName"/> </br> <input type="submit" value="Greet me!"/> </form> </BODY></HTML> Figure 11: Sample HTML that displays the formIf we were to supply "JEDI" as the value for the form we created earlier, the followingresult would be generated: Figure 12: Output of GetParameterServletrequest.getParameterValuesThere are times when we need to retrieve data from a form with multiple elements ofthe same name. In this case, simply using the getParameter method previouslydescribed will return only the value of the first element with the given name. To retrieveall of the values, we use the getParameterValues method: public String[] getParameterValues(String parameterName)This method is similar to the one we just discussed. It also takes in the name of theparameter whose values we wish to retrieve. This time though, instead of a singleString, it returns a String array.Below is a sample, along with its output:
  15. 15. public class GetParameterValuesServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletExceptionm IOException{ String paramValues[] = request.getParameterValues("sports"); StringBuffer myResponse = new StringBuffer(); PrintWriter out = response.getWriter(); out.println("<HTML><TITLE>Your choices</TITLE>"); out.println("<BODY><H1>Your choices were : </H1>"); for (int i = 0; i < paramValues.length; i++) { out.println("<br/><li>"); out.println(paramValues[i]); } }}<html> <title>Choice selection</title><body> <H1>What sports activities do you perform?</h1> <form action="GetParameterValuesServlet" method="post"><input type="checkbox" name="sports" value="Biking"> Biking <br/><input type="checkbox" name="sports" value="Table Tennis"> Table Tennis <br/><input type="checkbox" name="sports" value="Swimming"> Swimming <br/> <input type="checkbox" name="sports" value="Basketball"> Basketball <br/> <input type="checkbox" name="sports" value="Others"> Others <br/> <input type="submit"> </form></body></html> Figure 13: Retreiving Data from a Form with Multiple ElementsIf the entries "Biking", "Table Tennis", and "Swimming" were to be chosen, the outputwould be:
  16. 16. Figure 14: Output of GetParameterValuesServletrequest.getParameterNamesThere are times when we want our servlet to be aware of the name(s) of one or more ofthe parameters within the form without having to hardcode them into the servlet. In thiscase, we can use the getParameterNames method. public Enumeration getParameterNames()The Enumeration object that this method returns contains all of the names of theparameters embedded in the users request.Retrieving Info from the Request URLRemember, from our HTTP, a request URL is composed of the following parts: http://[host]:[port]/[requestPath]?[queryString]We can retrieve the curent values for each of these parts from the users request bycalling on methods in the HttpServletRequest object. • Host – request.getServerName() • Port – request.getServerPort() • Request Path – in Java, the request path is divided into 2 logical components : • Context – the context of the web application. Can be retrieved by invoking request.getContextPath() • Path info – the rest of the request after the context name. Can be retrieved by invoking request.getPathInfo() • Query String – request.getQueryString()So, for example, with a request URL of: http://www.myjedi.net:8080/HelloApp/greetUser?name=JediAnd if we call pm the aforementioned methods, these results are yielded:
  17. 17. request.getServerName() www.myjedi.net request.getServerPort() 8080 request.getContextPath() HelloApp request.getPathInfo() greetUser request.getQueryString() name=JediHeader InformationHeader information can be retrieved from within the servlet by calling on the followingmethods in HttpServletRequest: • getHeader(String name) – returns the value of the specified header as a String. If the specified header does not exist, this method returns null. • getHeaders(String name) – similar to getHeader(). However, it retrieves all values for the specified header as an Enumeration object. • getHeaderNames() - this method returns the names of all headers included in the HTTP request as an Enumeration object. • getIntHeader(String name) - returns the value of the specified header as an int. If the specified header does not exist in the request, this method returns -1. • getDateHeader(String name) – returns the value of the specified header as a long value that represents a Date object. If the specified header does not exist, this method returns -1. If the header cannot be converted to a Date, this method throws an IllegalArgumentException.Output GenerationIn all the previous examples, weve been able to generate dynamic output for the user.Weve done this by using methods exposed in the HttpServletResponse object.So far, we have been making use mostly of the getWriter method. This method returns aPrintWriter object associated with our response to the user. To help put things in properperspective, we should remember that the System.out object that we regularly use tooutput content to the console is also an instance of a PrintWriter object. That is, theybehave mostly the same way: if you have an instance of a PrintWriter object, simply callits provided print or println methods to provide output.The code for our first servlet is replicated here for recall, with the output code in boldfont.
  18. 18. import java.io.*;import javax.servlet.*;import javax.servlet.http.*;public class HelloServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //"request" is used for reading incoming HTTP headers // HTML form data (e.g. data the user entered and submitted) // and other data that can be inferred from the client request. // "response" is for specifying the HTTP response line and // headers(e.g. specifying the content type, setting cookies). // It also contains methods that allow the servlet to generate // responses for the client. PrintWriter out = response.getWriter(); out.println("<HTML> <TITLE>Hello Page</TITLE><BODY><br>"); out.println("<h1>Hello World!</h1>"); out.println("</BODY></HTML>"); //"out" for sending content to browser }} Figure 15: Recalling HelloServletOther notable methods in the HttpServletResponse object are: • setContentType – this informs the clients browser of the MIME type of the output it is about to receive. All of the content weve generated so far have been HTML. We could easily send other types of content such as JPEG, PDF, DOC, XLS, etc. For non-text output though, the print methods in the PrintWriter object weve been using so far are insufficient. To generate non-text output, we make use of another method. • getOutputStream – this retrieves an instance of the OutputStream object associated with our response to the user. With this OutputStream, we can then use standard Java I/O objects and methods to produce all kinds of output.Below is a sample code that will output a JPG file contained in the web application to theuser.
  19. 19. public JPEGOutputServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) { // define a byte array to hold data byte bufferArray[] = new byte[1024]; // retrieve the ServletContext which we will use to retrieve the resource ServletContext ctxt = getServletContext(); // inform the browser that the resource we are sending is a GIF file response.setContentType("image/gif"); // retrieve the output stream we will use to produce response ServletOutputStream os = response.getOutputStream(); // retrieve the resource as an input stream InputStream is = ctxt.getResource("/WEB-INF/images/logo.gif").openStream(); // read the contents of the resource and write it afterwards into the outputstream int read = is.read(bufferArray); while (read != -1) { os.write(bufferArray); read = is.read(bufferArray); } // close the streams used is.close(); os.close(); }} Figure 16: Sample Code to Output a JPG FileRequest Handling/Response Generation Exercises1. Given the following form: <HTML> <BODY> <form action="AddServlet" method="post"> Enter number 1 : <input type="text" name="operand1"/> </br> Enter number 2 : <input type="text" name="operand2"/> </br> <input type="submit" value="Perform addition"/> </form> </BODY> </HTML> Create a servlet named AddServlet that will retrieve the 2 numbers given by the user, add them, and then output the result.2. Given the following form: <html> <title>Menu</title><body>
  20. 20. <H1>Which food items do you want to order?</h1> <form action="MenuSelectionServlet" method="post"> <table> <tr> <td><input type="checkbox" name="order" value="20"> Sundae </td> <td> P 20 </td> </tr> <tr> <td><input type="checkbox" name="order" value="25"> Reg. Burger </td> <td> P 25 </td> </tr> <tr> <td><input type="checkbox" name="order" value="15"> Dessert Pie </td> <td> P 15 </td> </tr> <tr> <td><input type="checkbox" name="order" value="70"> Rice Meal </td> <td> P 70 </td> </tr> <tr> <td><input type="submit"></td> </tr> </form></body> </html> Create a servlet named MenuSelectionServlet that will retrieve the selections made by the user, add their values, and return the computed result to the user.Configuration, Packaging, and DeploymentIn all the examples we have done so far, we have used the tools inherent in theEnterprise IDE to abstract the details of web application configuration, packaging, anddeployment. We will take a closer look at those details now.Web Application ConfigurationThe servlet specification defines an XML file named web.xml that acts as a configurationfile for our web applications. This file is also called the deployment descriptor.
  21. 21. <web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://java.sun.com/xml/ns/j2eehttp://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> <servlet> <servlet-name>FirstServlet</servlet-name> <servlet-class>jedi.servlet.FirstServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>FirstServlet</servlet-name> <url-pattern>/FirstServlet</url-pattern> </servlet-mapping> <session-config> <session-timeout> 30 </session-timeout> </session-config> <welcome-file-list> <welcome-file> index.jsp </welcome-file> </welcome-file-list></web-app> Figure 17: web.xml for FirstServletListed above is the web.xml we used for our FirstServlet example. We will use this as ourstarting point in the exploration of web.xml.NOTE : The web.xml for Enterprise web application projects can be found by expandingthe Configuration Files tab in the project view.<web-app>This line serves as both the root element of the configuration file and a declaration of tgenecessary information (through its attributes) for the servlet container to recognize thefile as a valid deployment descriptor file.<servlet>Each instance of this element defines a servlet to be used by the application. It has thefollowing child nodes: • <servlet-name> - A logical name supplied by the developer which will be used for all future references to this servlet. • <servlet-class> - The fully qualified class name of the servlet. • <load-on-startup> (Optional) – Having an entry and value for this element tells the container that the servlet should be instantiated and initialized on container/application startup, bypassing the normal lazy loading rule. The value for this element is a number which dictates the order of its loading compared to other <load-on-startup> servlets.<servlet-mapping>Each instance of this element defines a mapping to a servlet. It has the following child
  22. 22. nodes: • <servlet-name> - The logical name of the servlet to be mapped. Must be defined previously in the descriptor file. • <url-pattern> - The URL pattern to which this servlet will be mapped. Having a value of /* will make all requests to your application redirected to your servlet.In the given example, the url pattern of FirstServlet is /FirstServlet. This means that allURL requests to http://[host]:[port]/FirstServletProject/FirstServlet will be handled byFirstServlet.Take note that all servlet definitions must first be supplied before adding any servletmappings.<session-config>This element defines configuration details for session management. It will be discussedin the next chapter.<welcome-file-list>This element defines a web component that will be automatically loaded if the userenters a request for the application without specifying a particular resource. Forexample, a request to http://[host]:[port]/FirstServletProject will cause the file definedhere to be loaded.More than one file can be specified in this list. Only the first one visible to the webcontainer will be loaded.Packaging the Web ApplicationLet us take a look again at the structure of a web application as mandated by the servletspecification: Contains HTML, images, other static content, plus JSPs Contains meta-information about your application (optional) All contents of this folder cannot be seen from the web browser Contains class files of Java classes created for this application (optional) Contains JAR files of any third-party libraries used by your app (optional) XML file storing the configuration entries for your application Figure 18: Directory Structure of Java Web ApplicationOur application can be deployed to a server by making use of what is called a WAR file.WAR files are the same as JARs; they contain Java application code compressed usingthe ZIP format. Informally, WAR stands for Web Archive.Generating WAR files from existing Enterprise projectsIt is very simple to produce the WAR file containing our web application from an existing
  23. 23. project in Sun Studio Enterprise 8. It is as simple as right clicking on the project name inthe Project view, and selecting Build Project. The IDE will then proceed to packageyour application. Figure 19: Build ProjectThe IDE will inform you if the build operation is successful and inform you of the locationof the created WAR file.
  24. 24. Figure 20: Build SuccessfulUsing an Ant build file to package the applicationAside from using an IDE to package the web application, we can also make use of a buildtool that can automate the compilation and packaging process for us.A build tool that has wide industry acceptance is Ant. It is an open-source project of theApache Software Foundation, and can be downloaded from http://ant.apache.org.Basically, Ant reads in a build file (traditionally named build.xml). This build file is madeup of targets, which essentially define logical activities that can be carried out by thebuild file. These targets are, in turn, composed of one or more tasks that define thedetails of how the targets perform their activities.A build file that can perform compilation and packaging tasks is included in thecourseware and can be found in the samples/blankWebApp directory.Requirements of the build file: • It must be located in the project root of the directory structure recommended by the Apache Software Foundation for web application development. • Additionally, there must also exist a lib directory in the project root that will contain all JAR dependencies of the application.
  25. 25. • There must exist a file named build.properties in the same directory as the build script and must contain values for the following properties: • app.name – the name of the application / project • appserver.home – the installation directory of a Sun Application Server 8.1 instanceThe following is the directory structure recommended for web application development: After build script has executed, will contain the application in a directory structure recognized by servlet containers. After build script has executed, will contain the WAR file. Used to contain whatever documentation is used by the dev team. Directory under which all Java source files must be placed. Directory containing all static content of the app (HTML, JSP), will be the basis of the document root of your project. Directory containing configuration files such as the deployment descriptor (web.xml), tag library descriptors, etc. Figure 21: Directory Structure Recommended for Web Application DevelopmentThis directory structure was designed to be separated from the directory structurerequired by the servlet specification. Apache lists the following advantages for havingsuch a separate directory structure: • Contents of source directory are more easily administered, moved, or backed up if the deployment version is not intermixed. • Source code control is easier to manage on directories that contain only source files (no compiled classes, etc.). • The files that make up an installable distribution of the application is easier to select when the deployment hierarchy is separate.Things may be a bit hard to understand at first glance. To help in understanding, all ofthe requirements to compile and package our FirstServlet example is provided in thesamples/FirstServlet directory.To perform the packaging of an applicatio using this structure, run the following on thecommand-line (in the same directory containing the build file). ant distThis will call the dist target in the build file which will generate the WAR file and place itinto the dist directory. This WAR file can then be loaded into the target servlet containerusing the admin tools provided by the container.Deployment into ServerServlet containers generally contain administrative tools that can be used to deploy webapplications. Here we will cover the steps required to deploy the generated WAR file intoSun Application Server 8.1.
  26. 26. • First step, log-in into the administrative console. This can be accessed by entering the following URL in your browser http://localhost:[ADMIN_PORT] where ADMIN_PORT is the port configured during installation to handle administrative requests. Figure 22: Deploying the WAR File • Second, left click on the Web Applications tab on the panel to the left, then click on the Deploy button found in the panel to the right. • In the screen that next appears, click on the Browse button to select the WAR file to upload. Click on the Next button found in the upper right. • Click on the Finish button in the next screen. • Congratulations, your application is now deployed.Servlet and Application Parameters1. Identify the web.xml element described by each of the following: a) Contains the logical name used to refer to a servlet. b) The root element of the configuration file. c) Defines a mapping between a servlet and a user request.2. Rearrange the following in order of their required appearance within the XML file: session-config servlet servlet-mapping
  27. 27. welcome-file-list3. Suppose that we have a servlet whose name is TrialServlet, create a servlet-mapping entry such that TrialServlet will be called for each request to: http://[host]/[context]/myExerciseServlet.4. What are WAR files?5. Given an existing web project in our IDE, how can a WAR file be generated?Servlet and Application ParametersServletConfig and Servlet Initialization ParametersThe ServletConfig object is the object passed to a specific servlet during its initializationphase. Using this, a servlet can retrieve information specific to itself (e.g. initializationparameters). The servlet can also gain access to an instance of the ServletContext objectusing the ServletConfig object.Initialization parameters are of great use, especially when dealing with information thatmay vary with each deployment of the application. Also, supplying some data to theservlet as parameters, as opposed to hard-coding them directly into the servlet, allowsdeployers the ability to change servlet behaviour without having to recompile the code.We can add initialization parameters to the servlet by specifying them in the servletsdefinition in the deployment descriptor. Below is a sample:...<servlet> <servlet-name>FirstServlet</servlet-name> <servlet-class>jedi.servlet.FirstServlet</servlet-class> <init-param> <param-name>debugEnabled</param-name> <param-value>true</param-value> </init-param></servlet>... Figure 23: Adding Initialization Parameters to the ServletThe <init-param> and </init-param> tags tell the container that we are starting andending parameter definition respectively. <param-name> defines the name of theparameter, and <param-value> defines its value.To gain access to the servlet parameters, a servlet must first get a handle on itsServletConfig object, which can be done by calling on the getServletConfig() method.Afterwards, the parameter value can be retrieved as a String by calling thegetInitParameter method and supplying the value of <param-name> as the parameter.
  28. 28. public void doGet(HttpServletRequest request, HttpServletResponse response) throwsServletException, IOException { ServletConfig config = getServletConfig(); String isDebugEnabled = config.getInitParameter("debugEnabled"); if (isDebugEnabled.equals("true") { ...} Figure 24: Accessing Servlet ParametersAbove is a sample piece of code that illustrates the procedure.ServletContext and Application ParametersThe ServletContext object is an object that gives the servlet access to the applicationcontext.Think of the application context as the area which an application moves in. This area isprovided by the container for each web application. With each applications context beingseparated from each other, an application may not access the context of anotherapplication.Having access to this context is important because with this, the servlet can retrieveapplication-wide parameters and data. It can also store data that can be retrieved byany components in the application.In much the same way that initialization parameters can be supplied for individualservlets, they can also be supplied for use by the entire application.<context-param> <param-name>databaseURL</param-name> <param-value>jdbc:postgresql://localhost:5432/jedidb</param-value></context-param> Figure 25: Adding Application-wide ParametersThe above code shows an example of how to add application-wide parameters. The xmlelement used here is <context-param>. Each instance of such an element defines aparameter for use by the whole application. <param-name> and <param-value> workthe same way as their <init-param> counterparts.NOTE : Again, be reminded that the specification is strict about the ordering of elementsinside the deployment descriptor. To keep your web.xml valid, all <context-param>entries must be located BEFORE any <servlet> entries.The procedure to retrieve the parameter values is very similar to that used for retrievingservlet-specific parameters. This time though, it is an instance of ServletContext that theservlet must have a handle to. This can be retrieved by calling the getServletContext()method from an instance of the servlets ServletConfig object.
  29. 29. public void doGet(HttpServletRequest request, HttpServletResponse response) throwsServletException, IOException { ServletContext ctxt = getServletConfig().getServletContext(); String jdbcURL = ctxt.getInitParameter("databaseURL"); // custom code setURL(jdbcURL);....} Figure 26: Retrieving Parameter ValuesSummary– Servlets are Javas solution to producing dynamic content for the web and its counterpart to CGI.– Servlets come with a number of advantages over CGI, including a reduced memory footprint and less overhead with each client request.– A servlet is entirely managed by its container. The only code necessary for developers is the one implementing functionality.– To create servlets, developers will create subclasses of HttpServlet and place their functional implementations in either the doGet or doPost methods.– Request details can be retrieved from HttpServletRequest, and response-generating methods can be accessed from HttpServletResponse. Both are passed as parameters to doGet and doPost.– To deploy servlets into the web container, they should first be loaded as pre- packaged WAR files. This packaging process can be automated for us by either an IDE or through the use of a build tool.– Deployment descriptors are essential parts of the application. They must be located in the applications WEB-INF directory and must follow certain rules.– Parameters can be supplied to the application using the deployment descriptor and can be retrieved by using methods in ServletConfig or ServletContext instances.

×