Servlet Technology Model

Agenda:

1. Servlet API and life cycle
   • javax.servlet Package :
     • Interfaces :(14)
     • Classes : (9)
     • Exceptions : (2)
   • javax.servlet.Servlet interface :
   • load-on-startup
   • Life Cycle of the Servlet that implements Servlet interface :
   • GenericServlet(AC):
   • javax.servlet.http package :
     • Interfaces :(8)
     • Classes :(7)
   • Structure of HttpRequest :
   • Structure of HttpResponse :
2. Http methods
   1. GET
   2. POST
   3. HEAD
   4. OPTIONS
   5. PUT
   6. DELETE
   7. TRACE
   • HttpServlet :
   • Life Cycle of HttpRequst :
3. HttpServletRequest
   1. To retrive request parameters
   2. To retrive request headers
   3. To retrive request cookies
   • Retrieving client & Server information from the request :
4. HttpServletResponse
   1. To set response headers
   2. To set ContentType of response
   3. To get Text Stream for response
   4. To get Binary stream for response
   5. To perform redirecting
   6. To add Cookies to the response
   • Differences between send-Redirection and forward mechanism :

Introduction :

2-tier:

Web resources :

1. static
2. Dynamic

WEB APPLICATION REQUIREMENTS :

1. Browser software.
2. Technology to develop client side.
3. Technology to develop server side.
4. User software.
5. DataBase software.

WEB Server Software :

Responsibilities of web server :

1. It collects all client http requests.
2. It passes to appropriate web resources of web application.
3. Web server proceed built middle ware software.
4. container built in controller software.
5. Gives resultant out put.

Responsibilities of Servlet Container :

1. To provide the environment to manage web resource of Web Application.
2. It Perform total life cycle operations.
3. In case of JSP to generate corresponding Generated Servlet.

Web Programming for Static information :

Web Programming for Dynamic information :

The following are various possible Helper Applications at Server side.

TYPES OF WEB CONTAINER:

1. Stand alone :
   Both web server and web container are available in a single integrated component , such type of web container are called Stand-alone web container.
   Ex : Tomcat
   This type of web containers are best-suitable for small scale applications and rarely used.
   
2. In-Process Web container :
   If the web container runs in same address space(same machine) of web server and it is available as plug-in such type of web containers are called In-Process web container.
   In this case both web server and web container need not be from the same vendor.
   
3. Out-Process Web container:
   Web server and web container both are running on different machines , Web container is attached to the web server externally.Such type of web containers are called Out-process web containers.
   we can configure front-end apache has to forward the request to the back-end weglogic server. These type of web containers are industry using.
   This type of web Containers are most commonly used web containers.
   
   

Differences between CGI and Servlets :

FAST CGI :

Servlet Technology Model :

1. servlet API and life cycle
2. Http methods
3. HttpServletRequest
4. HttpServletResponse

Servlet API :

1. javax.servlet: This package defines several classes and interfaces to develop servlets from scratch irrespective of any protocol.
2. javax.servlet.http : It is the sub package of javax.servlet and contains several convenient classes and interfaces to develop http based servlets.

javax.servlet Package :

Interfaces of javax.servlet Package :(14)

1. Servlet :
   Every servlet in java should implement servlet interface either directly or indirectly. ie, Servlet interface acts as a root interface for all java Servlets.
   This interface defines the most common methods (including life cycle methods) which are applicable for any servlet object.
   
2. ServletRequest :
   ServletRequest object can be used to hold client data.
   ServletRequest interface defines several methods to acts as end users provided data from the request object.
   Ex: getParameter()
   
3. ServletResponse :
   ServletResponse object can be used to prepare and send responds to the client.
   ServletResponse interface defines several methods which are required for preparation of response.
   Ex: getWriter(), setContentType()
4. ServletConfig :
   For every servlet , web container creates one ServletConfig object to hold its configuration information like logical name of the Servlet , instantiation parameters etc.
   ServletConfig interface defines several methods to access servlets configuration information.
   Ex: getServletName()
           getInitParameter()
   
5. ServletContext :
   For every web application, web container will create one ServletContext object to hold application level configuration information like name of the app'n and ServletContext parameter etc.
   Note : ServletConfig is per Servlet , where as ServletContext is per web application.
   
6. RequestDispatcher :
   By using RequestDispatcher object we can dispatch the request from one component to another component.
   This interface defines two methods.
   1. forward()
   2.include()
   
   
7. SingleThreadModel :

   Servlet technology is single instance multi threaded model. i.e, multi threads can operate simultaneously on the servlet object . Hence there may be a chance of data inconsistency problems.

   we can resolve these problems by using SingleThreadModel interface. If a servlet implements SingleThreadModel interface, then a single thread can access servlet object at a time i.e, Servlet can process only one request at a time. i.e, the main objective of SingleThreadModel interface is to provide thread-safety.

   But the problem with SingleThreadModel is Servlet can process only one request at a time which impacts performance of the system. Because of this problem SingleThreadModel interface is not recommended to use and it is deprecated in Servlet 1.3 version without introducing any replacement.

   we can provide thread-safety to the Servlet by using syncronized keyword.

   SingleThreadModel interface doesn't contain any methods . It is a marker interface.

   Note: In addition to above interfaces javax.servlet package defines the following interfaces also .
   
   
8. Filter
9. FilterConfig
10. FilterChain
                    ----- to implements Filter Concept.
    
11. ServletRequestListener
12. ServletRequestAttributeListener
13. ServletContextListener
14. ServletContextAttributeListener
                      ----- to implements Listener Concept.

Classes of javax.servlet package : (9)

1. GenericServlet :
   This class implement Servlet interface and provides dafault implementation for every method except service( ). Hence it is an abstract class.
   we can use this class as a base class to develope protocol independent servlets.
   
2. ServletOutputStream :
   we can use this class object to send binary data( pdf files , image files , video/audio files etc ) as response to the client.
   
   
3. ServletInputStream:
   we can use ServletInputStream objects to read binary data send by the client.
   Note:
   In addition to above classes javax.servlet package defines the following classes also
   
4. ServletRequestWrapper
   
5. ServletResponseWrapper
                    -----------to implement wrapper concept.
   
6. ServletRequestEvent
   
7. ServletRequestAttributeEvent
   
8. ServletContextEvent
   
9. ServletContextAttributeEvent
                    -----------to define Events for Listeners.
   

Exceptions of javax.servlet package :

1. ServletException.
   Servlet can throw this exception whenever it faces any difficulty while processing client request.
   
2. UnavailableException :
   It is the child class of ServletException and it is depricated .

javax.servlet.Servlet interface :

1. init():

2. service( ) :

3. destroy() :

4. getServletConfig :

5. getServletInfo ( ) :

package com.jobs4times;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class FirstServlet  implements Servlet {

	static {
		System.out.println("Servlet class loading");
	}
	public FirstServlet () {
	System.out.println("servlet instantiation");
	}
	
	ServletConfig config;
	public void init(ServletConfig  config ) throws ServletException {
		this.config=config;
		System.out.println(" we are in  init( ) method ");		
	}
	public void service(ServletRequest request, ServletResponse response)
	                               throws ServletException, IOException {      
		System.out.println("We are in service( ) method ");
		PrintWriter out=response.getWriter();
		out.println("welcome to SCWCD");
	}
	public void destroy() {
		System.out.println("We are in destroy() method ");		
	}
	public ServletConfig getServletConfig( ) {
		return null ;
	}
	public String getServletInfo() {
    	return "Written by Jobs4Times " ;
	}	
}

<web-app>
<servlet>
  <servlet-name>first</servlet-name>
  <servlet-class>com.jobs4times.FirstServlet</servlet-class>
  <load-on-startup>5</load-on-startup>
 </servlet>
 
 <servlet-mapping>
  <servlet-name>first</servlet-name>
  <url-pattern>/fs</url-pattern>
 </servlet-mapping>
</web-app>

1. When ever we are sending the request ,webserver checks whether this request is for static or dynamic information by using URL pattern.
2. If the request is for static information , Webserver searches for the required static file and provides required response.
3. If the request is for dynamic information , Webserver forwards that request to webcontainer .
   The webcontainer identifies the corresponding servlet class by using web.xml
4. Webcontainer loads that .class file , perform instantiation , and execute init( ) and service( ) methods and provide required response to the webserver
5. webserver inturn forwards that response to end-user.

WithOut <load-on-startup> :

1. loading .class file (/ servlet loading)
2. Instantiation
3. init( )
4. service( )

With <load-on-startup> :

1. loading .class file (/ servlet loading)
2. Instantiation
3. init( )

Note:

• Highest value to give the least priority
• Lowest value give high Priority
• Zero will give last priority
• -ve  value means ignore the <load-on-startup> concept.

What is the advantage of <load-on-startup> :

Note:

<servlet-mapping>
        <url-pattern>/test </url-pattern>
        <url-pattern>/test </url-pattern>
</servlet-mapping>

• In the case of Tomcat the order of evaluation of web.xml is Bottom to Top.
• In the case of Weblogic the order of evaluation of web.xml is Top to Bottom.

Life Cycle of the Servlet that implements Servlet interface :

1. Servlet class loading by class loader.(It is part of Jvm)
2. Servlet Instantiation by webcontainer , For this web container always calls public-no-argument constructor . Hence Every servlet should compulsary contain public-no-argument constructor.Otherwise we will get RuntimeException saying java.lang.Instantiation exception .
3. Execution of init(-) by webcontainer
   Note: The above 3 steps will be performed Generally at the time of first request.If<load-on-startup> is configured these will be executed at the time of either server startup or at the time of application deployment.
4. Execution of service( ) by web-container.
5. Execution of destroy( )

constructor Vs init( ) :

• In general , we can use constructor to perform initialization activities but in old versions of java, constructor cannot accept dynamically generated class name as argument.
• To perform initialization of servlet compulsary we should provide ServletConfig object as argument. whose class name is dynamically generated by web-container
• As constructor cannot accept these dynamically generated names, Sun people ignores constructor concept and introduced a specific method init( ) to perform initialization activities , which can take dynamically generated class names as the arguments.
• In the older versions , constructor cannot take any arguments but to perform initialization of a servlet compulsary we should provide ServletConfig as argument.
• Hence we can't use constructor to perform initialization activities , Sun people introduced a specific methods init( ) . for this , which can take ServletConfig as argument.

destroy( ) Vs finalise( ) :

• Before destroying any object Garbage collector always calls finalise( ) to perform cleanup activities. But we can't expect exact behaviour of Garbage collector. which is vendor dependent.
• Hence instead of depending on finalise( ) , Sun people introduced a specific method destroy( ) to perform cleanup activities , which should be executed always.

GenericServlet(AC):

• We can develope servlet by implementing Servlet interface directly. In this apprach compulsary we should provide implementing for all methods of servlet interface whether it is required or not . This approach increase length of the code and reduces readability. We can resolve this problem by using GenericServlet.
• GenericServlet implements Servlet interface and provide default implementation for every method except service( ). Hence it is an abstract class.
• We can develope servlets very easily by extending GenericServlet, instead of implementing Servlet interface directly. In this appraoch we have to provide implementation only for required methods instead of implementing all. It reduces length of the code and improves readability.
• GenericServlet is protocol independent servlet.
• GenericServlet implements ServletConfig and Serializable interfaces also.

public class FirstServlet extends GenericServlet {
 public void service(ServletRequest request,ServletResponse response)
                               throws ServletException, IOException {
 PrintWriter pw=response.getWriter();
 pw.println("Developing Servlet by GenericServlet");
 System.out.println("This is Service() in First Servlet ");
 }
 }

public abstract class GenericServlet implements 
                   Servlet , ServletConfig , Serializable {
 
 private transient ServletConfig config ; 
 
 public void init(ServletConfig config) throws ServletException { 
 this.config=config ;       //webcontainer purpose
 init( );
 }
 
 public void init( ) throws ServletException { //programmer purpose
 }
 
 public abstract service(ServletRequest request,ServletResponse response)
                               throws ServletException, IOException ;

 public void destroy() {
 }
 							   
 public ServletConfig getServletConfig( ) {
 return config; 
 }
 
 public String getServletInfo( ) {
 return "this is GenericServlet" ;
 } 
 
 
 ----- ------ ---- ------
 -------- ------ ------ 
}
 

public void init(ServletConfig config )  throws ServletException {
	 // my own initialization
 }

If we are calling getServletName() then we will get Runtime Exception saying java.lang.NullPointerExceprion

 public void init(ServletConfig config )  throws ServletException {
	 super.init(config);
	 ............................
}
 

 public void init( )  throws ServletException {
		 // my own initialization activities
 }
 

How many init( ) present in GenericServlet and explain the need of it ?

In how many ways we can override init( ) in our Servlet and which is the best way ?

In GenericServlet why config variable declared as transient ?

1. Every Servlet in java is Serializable. At the time of Serialization of servlet object the corresponding config object is serialized automatically . Because it is part of object-graph of Servlet object.
2. If we are serializing config object , from that config object hacker may get corresponding context object reference. Once hacker got context object he can able to perform any operation on our application , which is never be recommended security wise. Hence at the time of serialization of servlet object , we can't Serialize config object. Due to this reason config variable declared as transient.
   

2.javax.servlet.http package :

Interfaces of javax.servlet.http : (8)

1. HttpServletRequest :
   It is the child interface of ServletRequest .
   HttpServletRequest object can be used to hold client information.
2. HttpServletResponse :
   It is the child interface of ServletResponse.
   This object can be used to prepare and send response to the client.
3. HttpSession :
   We can use HttpSession object to remember the client information across multiple requests. i.e., we can use session object for session management purpose.
   
4. HttpSessionListener :
   To implement http based Listener
5. HttpSessionAttributeListener :
   To implement http based Listener
6. HttpSessionBindingListener :
   To implement http based Listener
7. HttpSessionActivationListener :
   To implement http based Listener
8. HttpSessionContext :
   deprecated and hence not recommended to use

Classes of javax.servlet.http package : (7)

1. HttpServlet :
   It is the child class of GenericServlet . It can be used for developing http based Servlets .
2. Cookie :
   We can use Cookie objects to implement Session management.
   
3. HttpSessionEvent :
   To define Events for http based Listeners.
4. HttpSessionBindingEvent :
   To define Events for http based Listeners.
5. HttpServletRequestWrapper :
   To define http based Wrappers.
6. HttpServletResponseWrapper :
   To define http based Wrappers.
7. HttpUtils :
   Deprecated , not recommended to use .

Structure of HttpRequest :

Request Line :

Request Headers :

1. media types accepted by browser , language accepted by browser , encoding types supported by browser etc.
2. Web server use this information to send custimized responses to the client .

Request Body :

1. It contains end-user provides information for the GET request it is optional where as for the POST request it is mandatory.
2. This is the structure of HttpRequest , If the browser sends request in this format , then only webserver understands the request . i.e, webserver understandable form.

Structure of HttpResponse :

Status Line :

Status Codes :

Response Headers :

Response Body :

Types of HttpRequest methods :

1. GET
2. POST
3. HEAD
4. OPTIONS
5. PUT
6. DELETE
7. TRACE
8. CONNECT
9. MOVE
10. LOCK
11. PROFIND

	  1 - 3  methods  introduced in http 1.0
	  4 - 11 methods introduced in http 1.1
	  1 - 7  are Big Http methods 	  
	 

GET :

1. We can use get request if we are expecting information from the server .
2. Usually for the get request read operation will be performed at server side . Hence status of application won't be changed in get request.
3. In GET request end-users provided information will be appended to the url as the part of Query string.
4. As the end-users information is visible in url. there may be a chance of security problems will raise. Hence sensitive data we can't send by using get request.
5. The length of the url is fixed . Hence we can send only limited amount of information by get request .
6. Only character data is allowed in url . Hence we can't send binary data by using get request.
7. As extra client provided information is available in the url , Bookmarking of url is possible .

Idempotent request :

Safe request :

1. Type url in the address bar and submit is always GET request.
2. Clicking hyperlink is always GET request.
3. Submitting the form , where method attribute specify with GET value is always GET request.
   

      
   <form action="/test"  method="GET">
     ----------- ---- 
   </form>
   

4. Submitting the form without method attribute is always GET request i.e., default method for form is GET.
   

   <form action="/test">
      ----------
      ---------
   </form>
   

POST :

1. If we want to post huge amount of information to the server then we should go for POST.
   Ex: uploading our resume in job portal.
2. Usually in post requests update operation will be performed. The state of operation will be changed.
3. In post request , client information will be encapsulated in the request body instead of appending to the url . Hence we can send sensitive data by using POST request.
4. There is no limit on size of request body . Hence we can send huge amount of information to the Server.
5. We can send binary data also in addition to text data.
6. Bookmarking of POST request is not possible.
7. POST requests are not Idempotent and not-safe to repeat.

Triggers to send POST request :

<form action="/test"  method="POST">
   ----------
   ---------
</form>

Differences between GET & POST :

HEAD :

• We can use this method to get only response header information like content type , content length , last modified date etc., but no response body i.e., head request retrives always respone header but not response body.
• For HEAD request , internally doGet( ) will be executed. HEAD request is part of GET request.
• HEAD requests are Idempotent & Safe.

HEAD request ----->  doHead { 
                        doGet { 
                            take only header part of GET response and 
                             provide that as response to  HEAD request. 
                         } 
                      }  

OPTIONS :

• This method is for getting supporting http methods to retrive a perticular resource from the Server side .
• OPTIONS method is Idempotent and Safe.
• Note: HEAD response is the part of GET response and OPTIONS is the part of HEAD response .

response from OPTIONS method request :

Host : www.jobs4times.com
Server : Apache
Date : Fri, o8 Nov
Allow : OPTIONS , HEAD , GET , POST
Content length : 0

PUT :

1. We can use PUT method for placing a resource at Server side where the location is specified by URL.
2. At the specified location , if already another resource present then the old resource is replaced with provided new resource .
3. By means of status code we can identify whether replacement is happend or not .
4. 200 means replacement happen , 201 means replacement not happen.
5. PUT method is Idempotent but not Safe .

DELETE :

• We can use this method for deleting a perticular resource from Server side. It is exactly counter part of PUT method.
• DELETE is Idempotent , but not-Safe.

TRACE :

HttpServlet :

Ex:

HttpServlet contains 2 service( ) methods.

1. public void service(ServletRequest request , ServletResponse response ) throws ServletException, IOException
2. protected void service(HttpServletRequest request , HttpServletResponse response ) throws ServletException, IOException

login.html

<html>
  <body><h1>This is HttpServlet Demo</h1>
    <form action="/scwcd1c/test"  method="post">
     Enter Name : <input type="text" name="uname" >
     <input type="submit">
    </form>
  </body>
</html>

FirstServlet.java

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;

public class FirstServlet  extends HttpServlet {	
public void doGet(HttpServletRequest request, HttpServletResponse response)
	                               throws ServletException, IOException {      
		PrintWriter out=response.getWriter();
		String name=req.getParameter("uname");
		out.println("Hello"+name+"Good Morning , This is doGet method");
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
	                               throws ServletException, IOException {      
		PrintWriter out=response.getWriter();
		String name=req.getParameter("uname");
		out.println("Hello"+name+"Good Morning , This is doPost method");
}	
}

web.xml

<web-app>
<servlet>
  <servlet-name>first</servlet-name>
  <servlet-class>FirstServlet</servlet-class>
</servlet>
 
 <servlet-mapping>
  <servlet-name>first</servlet-name>
  <url-pattern>/fs</url-pattern>
 </servlet-mapping>
</web-app>

Deployment Structure :

Life Cycle of HttpRequst :

1. When ever we are submitting the form , browser prepares HttpRequest and send to the Server.
2. Webserver checks whether the request is for static or for dynamic information, by using URL.
3. If the request is for static information , webserver provide required response.
4. If the request is for dynamic information , then webserver forwards that request to web-container.
5. Webcontainer identifies the corresponding matched servlet by using web.xml
6. Webcontainer checks whether the corresponding Servler object is already available or not . If it is not already available , then webcontainer loads the corresponding .class file and perform instantiation by executing public no argument constructor .
7. After instantiation , immediately webcontainer creates the ServletConfig object and invoke init( ) by passing that config object as argument.
8. Webcontainer creates ServletRequest and ServlerResponse object and by passing those as arguments , It will invoke public service( ).
9. With in that service( ) , request and response objects will be type casted into HttpServletRequest and HttpServletResponse and invoke protected service( ) by passing those as arguments.

   public  void service(ServletRequest  req , ServletResponse res ) 
                           throws  ServletException, IOException  {  
   HttpServletRequest req=(HttpServletRequest)req ; 
   HttpServletResponse res=(HttpServletResponse)res ;
   service(req1 , res1);  
   }
   

10. With in the protected service( ) we will identify HttpRequest method and corresponding doXxx( ) will be invoked. If it is not a valid Http method then it is method will return 501 status code response saying invalid Http method .

    protected void service(HttpServletRequest request,HttpServletResponse response)
                                             throws  ServletException, IOException{
     	String method=request.getMethod( ) ; 		
     	if(method.equals("GET")) { 
     		doGet(req , res) ;		
     	}		
     	else if(method.equals("POST")) {			
     		doPost(req , res) ;		
     	}		
     	else if(method.equals("HEAD")) {	
     		doHead(req , res) ;		
     	}		
     	..........................	
     	.........................	
     	else {		
     	 prepare response with 501 Status code saying Invalid Http Method.
     	}
      }
    

11. If our Servlet class contain required doXxx( ) , then it will be executed . Otherwise parent class doXxx( ) will be executed.

1. For every web application, web container creates one ServletContext object at the time of application deployment.
2. For every Servlet , web container creates one ServletConfig object just before calling init( ).
3. For every request web container creates one ServletRequest and one ServletResponse objects just before calling service( ) . Once service( ) completes both request and response objects will be eligible for Garbage Collector(GC).

• Case 1 : If we are writting public service( ) in our Servlet , then for any type of request [GET or POST] only service( ) will be executed.
• Case 2 : If our Servlet contains both public service( ) and protected service( ) , then for every request only public service( ) will be executed.
• Case 3 : If our Servlet contains both service( ) and doGet( ) , then for any request including GET , only service( ) will be executed. And there is no chance of executing doGet( ).
  Note: It is never recommended to place service( ) in our Servlet. i.e., defining service( ) in our Servlet is stupid kind of activity.
• Case 4 : If we are sending get request , but our Servlet doesn't contain doGet( ) , then HttpServlet doGet( ) will be executed which provides response with 405 status code saying Http method GET is not Supported by this url.
• Case 5 : If we are sending post request , but our servlet doesn't contain doPost( ) , then HttpServlet doPost( ) will be executed , which provide 405 status code saying Http method POST is not Supported by this url.
• Case 6 : HttpServlet class doesn't contain any abstract method , still it is declared as abstract class what is the reason ?
  For majority methods in HttpServlet , proper implementation is not available and these are just to send error information .
  Hence if we are creating HttpServlet object directly and calling these methods , we will get just error information , with that we can't do anything.
  To prevent instantiation of HttpServlet , Sun people declared HttpServlet class as abstract .
• Case 7 : To provide same response for both GET and POST request , we have to implement doGet( ) and doPost( ) as follows .
  
  Ex:

  public class FirstServlet extends HttpServlet {
  public void doGet(HttpServletRequest request,HttpServletResponse response)
                                      throws ServletException, IOException {
  		  // implemented required information  		  
  }  
  public void doPost(HttpServletRequest request,HttpServletResponse response)
                                       throws ServletException, IOException {
   			doGet( ) ;	  
  }  
  } 
  

• Case 8 : In our Servlet , It is not recommended to override the following methods . Because these methods are properly implemented inside HttpServlet.
  
  1. service(ServletRequest request, ServletResponse response)
  2. service(HttpServletRequest request, HttpServletResponse response)
  3. doHead( )
  4. doOptions( )
  5. doTrace( )
• Case 9 : In our Servlet , it is highly recommended to override the following methods , because these methods doesn't have proper implementation in HttpServlet.
  
  1. doGet( )
  2. doPost( )
  3. doPut( )
  4. doDelete( )
• Case 10 : To provide response to HEAD request , we have to override either doHead( ) or doGet( ) , otherwise we will get 405 status code saying Http method GET is not supported by this url.

HttpServletRequest :(I)

1. Retrieve Form parameters
   1. getParameter( )
   2. getParameterValues( )
   3. getParameterNames( )
   4. getParameterMap( )
2. Retrieve request Headers
   1. getHeader( )
   2. getHeaders( )
   3. getHeaderNames( )
   4. getIntHeader( )
   5. getDateHeader( )
3. Retrive Cookies
   1. getCookies( )

Retrieve Form parameters :

• Form parameters are key-value pairs , where both key and values are String objects only.
• A parameter can be associated with either a single value or with multiple values.
• ServletRequest interface defines the following methods to retrieve Form parameters at server side .
  
  1. getParameter( )
  2. getParameterValues( )
  3. getParameterNames( )
  4. getParameterMap( )

1. getParameter( ) :
   

   public String getParameter(String pname )

   • It returns the value associated with specified parameter.
   • If the parameter associated with multiple values then this method simply returns only first value.
   • If the specified parameter not available then we will get null argument is case-sensitive .

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

2. getParameterValues( )

   public String[ ] getParameterValues(String pname )

   • It returns all values associated with specified parameter.
   • If the parameters not available , we will get null .
   • Argument is Case-Sensitive.
   •  Ex:

      
         String[ ]  course=request.getParameterValues("course");
         for(String s:course)  {
         out.println(s);
         }

3. getParameterNames( )

   public Enumeration getParameterNames( )

   • Returns all Form parameters names.
   • If the request is not associated with any form parameters. Then we will get empty enumeration object but not null.
     
     Ex:

     Enumeration e= request.getParameterNames( ) ;
         	while(e.hasMoreElements( ) {
         	 String pname=(String)e.nextElement( ) ;
         	 String pvalue=request.getParameter(pname);
     		 out.println(pname+" "+pvalue);
     		 }
        

4. getParameterMap( )

   public Map getParameterMap( )

   • Returns the map object containing parameter names as keys and parameter values as map values.
   • Keys are strings and values are string[ ] .
   • If the request doesn't associated with any parameters , this method returns empty map object , but not null.
     
     

     key(String)	value(String[ ])
     subject	{SCJP , SCWCD }
     user	{ arun }
     ..........	...........
     ----------	---------

   
   Ex:

       
        Map  m = request.getParameterMap( ) ;
        for(Object  o : m)  {
        Map.Entry  m1=(Map.Entry) o;
        String pname=(String)m1.getKey( );
        String[ ]  pvalue=(String[])m1.getValue() ;
        out.print(pname+"......." );
        
        for( String s1 : pvalue ) {  
        out.println(s1 + "  , ");  
        } 
        out.println("   ");   
        }
   	 output :
   	 subject .....SCJP , SCWCD
   	 user.......arun
   	 

Map m=req.getParameterMap();
Set keySet=m.entrySet();
Iterator itr=keySet.iterator();
while(itr.hasNext()) {
Map.Entry  entry=(Map.Entry)itr.next();
String pname=(String)entry.getKey();
out.println(pname);
String[] pvalues=(String[])entry.getValue();
out.println(pvalues);

public void doPost(..).. {
response.setContentType();
PrintWriter pw=res.getWriter();
out.println("");
out.println("name :"+ request.getparameter("uname"));
............
............
}

Retrieving Request headers :

• For every request browser sends its configuration information in the form of request headers. These may include the media types accepted by browser , encoding types supported by browser the type of browser etc.
• Server uses these request headers to send customized responses to the client.

The following are some of the important request headers.

1. Accept :
   media types accepted by browser.[ like txt/html , pdf , ppt , jar ]
2. Accept-Encoding:
   Encoding types supported by browser.
3. User-agent:
   It represents the type of the browser.
4. Content-length:
   It represents the length of request body.
5. Cookie :
   Used to send cookies for Session managament.

Utilities of Request headers :

1. By using Accept-Encoding request header at Server side we can identity whether browser supports compression from or not.
2. If browser supports compressed form , we can send response in compressed form. So that we can save download time and bandwidth.
3. By using User-agent request header at server side we can identify the type of browser which sends the request. Based on that we can send browser compatable customized responses.
4. By using Cookie request header we can send Cookie to the server so that we can achieve session management.

HttpServletRequest defines the following methods to retrieving header information at server side

1. getHeader( )

   public String getHeader(String hname)

   • It returns the value associated with specified request header.
   • If the header associated with multiple values then this method returns only 1^st value .
   • If the specified request header is not available then we will get null.
   • Argument is not-case sensitive .
   • Ex:

     String  hvalue=request.getHeader("accept");
     
     output :
     accept -- text/html , application/xhtml+xml , application/xml ;
     

2. getHeaders( )
   

   public Enumeration getHeaders(String hname)

   • Returns all values associated with specified header .
   • If the specified header not available , then this method returns empty Enumeration object, but not null.
   • Argument is not-case sensitive .
3. getHeaderNames( )
   

   public Enumeration getHeaderNames( )

   Returns all request header names associated with that request object.
   
   HttpServletRequest defines the following more convinient methods to retrive int and date values(Headers) directly .
4. getIntHeader( )

   public int getIntHeader(String hname);

   Ex:

   String length=request.getIntHeader("content-length");
   int l=Integer.parseInt(length);
     (OR)
   int l=request.getIntHeader("content-length");
   

   If the specified request header is not associated with int value , then this method returns NumberFormatException.

   req.getIntHeader("user-agent");//RE:java.lang.NumberFormatException
   

   If the specified request header is not available in getIntHeader() , this method returns "-1" but not null.
5. getDateHeader( )

   public long getDateHeader(String hname);

   • Returns the date value associated with specified header as no. of milliseconds Since Jan 1^st 1970.
   • If we pass these milliseconds as arguments to Date constructor. We will get exact date
     Ex:

     long l=request.getDateHeader("date");
     Date  d=new Date(l);
     

   • If the specified header is not associated with the date , then we will get RuntimeException saying IllegalArgument Exception.
   • If the specified request header is not available in getDateHeader() , this method returns "-1" but not null.

Write a Servlet to print all request-headers associated with the request.

 
public class  ReqHeader   extends  HttpServlet { 
public  void doGet(HttpServletRequest request,HttpServletResponse response)
                                     throws ServletException, IOException {
PrintWriter out = response.getWriter( ) ; 
Enumeration e = request.getHeaderNames( ) ;
while(e.hasMoreElements( ) ) {
	String hname=(String)e.nextElement( ); 
	String hvalue=request.getHeader(hname); 
	out.println(hname+"------"+hvalue);
	 }
 } 
}

Retriving Cookies from the request :

• HttpServletRequest interface defines the following methods to retrive cookies from the request object .
  Cookie[] c = request.getCookiees( ) ;

Retrieving client & Server information from the request :

1. public String getRemoteHost( )

   Returns fully qualified name of the client which sends the request.

2. public String getRemoteAddr( )

   Returns IP-address of the client .

3. public String getRemotePort( )

   Returns the port no. on which the client is running .

4. public String getServerName( )

   Returns the name of the Server to which the request has been sent .

5. public String getServerPort( )

   Returns the port no. on which server is running .

HttpServletResponse :

1. To set Response Headers .
2. To set content type of Response .
3. To acquire text stream for response.
4. To acquire binary stream for response .
5. To redirect the request to another URL .
6. To add cookies to response.

Setting HttpResponse Headers :

• Http response header describes the configuration information of the server and information about the response like content-type , content-length , last modified data etc.,
• Browser using these response headers to display response body properly to the end user.

1. public void addHeader(String hname , String hvalue )

   • If the specified header name is already available , to the existing values , this new value will also be added.
   • Replacement will not Occur .

2. public void setHeader(String hname , String hvalue )

   • If the specified header is already available . Then the old value will be replaced with new value .
   
   Some times headers associated with int & date values .
3. public void addIntHeader(String hname , int hvalue )
4. public void setIntHeader(String hname , int value )
5. public void addDateHeader(String hname , long ms )
6. public void setDateHeader(String hname , long ms )

Set Content type of Response :

Common MIME Types :

1. text/html --------> Html text as response
2. text/xml --------> xml document as response
3. image/jpeg --------> JPEG as response
4. image/png --------> png as response
5. application/ms-excel --------> excel sheet as response
6. application/ms-word --------> word document as response
7. application/pdf --------> PDF file as response
8. application/jar --------> jar file as response

1. By ServletResponse interface :
   It contains the following method to set the response.

   public void setContentType(String mimeType)

   Ex:

   response.setContentType("application/PDF")

2. By HttpServletResponse interface :
   It contains setHeader( ) to set content type.

   public void setHeader(String hname , String hvalue)

   
   Ex:

   response.setHeader("content type" , "text/html");  

   Note: In general response.setContentType( ) is recommended to use.

To acquire text stream for the response :

1. We can send text data as the response by using PrintWriter object .
2. We can get PrintWriter object by using getWriter( ) of ServletResponse .

   public PrintWriter getWriter( ) throws IOException

   Ex:

    PrintWriter  out = response.getWriter( ) ;

To acquire Binary stream as response :

1. We can send Binary information(video , image files) by using ServletOutputStream object.
2. By using getOutputStream( ) of ServletResponse we can get this object .
   

   public ServletOutputStream getOutputStream( ) throws IOException

   Ex:

   ServletOutputStream  sos=response.getOutputStream ( ) ;

 Demo   program  to send image  file as  response  to the client
 
 import javax.servlet.*;
 import javax.servlet.http.*;
 
 public class BinaryStream extends HttpServlet  {
 	public void doGet(HttpServletRequest request,HttpServletResponse response)
	                                      throws ServletException,IOException{
 	response.getContentType("image/jpeg");
 	ServletOutputStream sos = response.getOutputStream( ) ;
	
	//File  f= new File("c:\\tomcat\sunset.jpeg");
	
 	String path=getServletContext( ).getRealPath("sunset.jpeg"); 	
 	File  f= new File(path);
 	FileInputStream fis=new  FileInputStream(f);
	
 	byte[]  b=new byte[(int)f.length()];  
	             //f.length()  returns long  so we have to convert into int.
			   //[] --> accepts int only
	
	
 	fis.read(b);        //reading the image & place into byte[]
 	sos.write(b);       //write byte[] to response
 	sos.flush( );
 	sos.close( );
 	}
 }
 

To send XML data as a response :

response.setHeader("content-Type","text/xml");
PrintWriter out=response.getWriter();
out.print("<?xml version=\"1.0\"?>");
out.print("<greeting language=\"en_US\">");
out.print("hello world");
out.print("</greeting>");

public void doGet( )  {
	PrintWriter out=response.getWriter( );
	ServletOutputStream sos =response.getOutputStream( ) ;
	-----------
	-----------
	}
	

1. PrintWriter()
2. ServletOutputStream ()
3. ServletInputStream ()
4. None of the above ()

Re-directing HttpRequest to another url :

Process of send Redirection :

1. Browser sends request to Servlet1
2. If servlet1 is not responsible to provide response , then it will update browser to contact servlet2. This can be informed by setting status code 302 & location header with servlet2.
3. Browser by seeing status code 302 creates a new request object & sends to Servlet2.
4. Servlet2 provides desired response to the browser & the browser inturn display that response to the end user .

Demo program for send Re-direct :

public class FirstServlet  extends   HttpServlet {
public void doGet(HttpServletRequest request,HttpServletResponse response)
                                     throws ServletException, IOException {
	response.sendRedirect("test2");
					(or)
	response.setStatus("302");
	response.setHeader("location" , "scwcd/test2");
}
}

public class SecondServlet  extends   HttpServlet {
	public void doGet(HttpServletRequest request,HttpServletResponse response)
                                        throws ServletException, IOException {
		PrintWriter out=response.getWriter( );
		out.println("2nd  Servlet ");
		}
 }

• When ever we are sending request to FirstServlet , SecondServlet will provide the response through re-direction
• After committing the response we are not allow to perform re-direction. Otherwise we will get RuntimeException saying IllegalStateException(Tomcat people doesn't provide support for this).

public void doGet(HttpServletRequest request,HttpServletResponse response)
                                     throws ServletException, IOException{
-----------------
---------------------
out.flush();	//committing the response
response.sendRedirect("/test2");	//RE:IllegalStateException
}

Differences between send-Redirection and forward mechanism :

send Re-direct	forward
This mechanism will work at client side. Hence client aware of which Servlet is providing the required response.	This mechanism will work at server side and it is not visible to the client. Hence client is not aware of which Servlet is providing the required response.
In this approach an extra trip is required to the client side . Hence network traffic increases & effects the performence of the system.	No extra trip is required to the client & hence there are no network traffic & performance problem.
This is only possible mechanism to communicate with resoueces which are present outside of web-container.	forward mechanism will work with in the web-container only and we can't use this mechanism to communicate with the resources present outside of container.
Seperate new request object will be created in send Redirection .	Same request object will be forwarded .
By using HttpServletResponse object . we can achieve send redirection. response.sendRedirect("/test2");	By using Request Dispatcher object we can achieve forward mechanism . rd.forward(req , res);
After commiting the Response we are not allow to perform send Redirection .Otherwise we will get RuntimeException saying IllegalStateException.	After Commiting Response , we can't perform forward otherwise IllegalStateException.

Adding Cookies to the response :

1. We can use redirection to communicate either with in the same server or outside the server. But recommended to use communicate outside.
2. forward mechanism is applicable to communicate only with in the same server . But outside of server we can't use.
3. To communicate with in the same server we can use either forward or send redirection but recommended to use forward.