Dealing with a request

sample servlet that have written using netbeans.i have use only the doPost method.normally in netbeans they forward the request to the processRequest() method in the servlet.so these things can be done in that method olso.no difference.

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


public class NewServlet extends HttpServlet {

protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//to get a parameter
String s= request.getParameter("what ever parameter sent from the previouse page");
//to get multiple parameters
String []s1= request.getParameterValues("para name");
//geting a header
String header= request.getHeader("name");
//get cookie info
Cookie []c= request.getCookies();
//to get session information
HttpSession session= request.getSession();
//to get clients port
getRemotePort();


}

//have to implement a method to get clients port
private void getRemotePort() {
throw new UnsupportedOperationException("Not yet implemented");
}

}

Request & Response

now we have come to know what are requests and responses.these derive from two interfaces
the request comes from

• ServletRequest
• HttpServletRequest

the HttpServlet interface implements the ServletRequest interface.all of the clients requests are implemented by these two interfaces.some of the useful methods definitions declared are

• ServletRequest

1. getAttribute(String)
2. getLocalPort()
3. getParameter()
4. getParameterNames()

• HttpServletRequest

1. getCookies()
2. getHeader(String)
3. getSession()
4. getMethod()

now lets consider about the response.there are two interfaces which will be generating the response to the client

• ServletResponse
• HttpServletResponse

some of the useful methods defined are
ServletResponse

1. getWriter()
2. setContentType()

HttpServletResponse

1. addHeader()
2. addCookie()
3. sendError()

we will discuss the usage of some of this methods using requests and responses in the next lesson.

Servlet basics

when we consider about the basics of a servlet we have to find the origin of it.
the Servlet interface comes here.which is javax.servlet.Servelt.we have some usefull method definitions there.some of them are

• service(ServletRequest, ServletResponse)
• init(ServletConfig)
• destroy()
  

after that we meet the abstract class GenericServlet (javax.servlet.GenericServlet) which implements the servlet interface.so this class consists of its own methods + the methods come from the servlet interface.some usefull methods are

• getInitParameter()
• getInitParameterNames()

then we meet the abstract class HttpServlet (javax.servlet.http.HttpServlet) which extends the GenericServlet class.so this class consist of all the methods form the Servlet interface + Generic servlet class + its own methods.some of the usefull methods are

• service(HttpServletRequest,HttpServletResponse)
• doGet(HttpServletRequest,HttpServletResponse)
• doPost(HttpServletRequest,HttpServletResponse

so when we write a servlet class we extend the HttpServlet class.(most often).we most often override the doGet() and doPost() methods.we define the business logic what ever we want inside them.

servlet config and servlet context

the ServletConfig object contain the deploy time information of a servlet and the ServletContext will be accessed through this object.and per servlet there will be only one ServletConfig object.the servletContext is used to access web application parameters.and per web application there will be one ServletContext.

the doGet() and the doPost()

post is more secured and it has a body where the get does not have.we can use a limited number of parameters with the get.post cannot be bookmarked and is used to send data to process.get is used to get some resourse.

The servlet life cycle

before learning about servlets lets discuss about the life cycle of the servlet.
when a client request something the request is directed to the container.the container makes two objects,which are

• request object
  
• response object

and it binds these objects to a thread.
the thread comes in to action in one of the two ways mentioned below.

• a thread pool provides one of the threads it have
• a new thread is created(new Thread();)
  

then this thread handles everything after this.it makes a servlet object and using that object calls the init() method of the servlet.this is done only once. after initiating the servlet the container calls the service() method of the servlet using our thread created.
then the service() method redirect the request to a relevant method which may be doGet() or doPost() according to the request. we will learn about these methods in future.
after executing one of these methods the generated response is directed to the browser by the container.and the threads work is also over.

so the thread goes to dead state if it is a newly created one and it will go back to pool if it was taken form the thread pool.
now there is no need of the request and response objects.so they are eligible for the garbage collector to be collected.

and when the servlet is no longer needed the destroy() method of the servlet is called and the servlet moves to the dead state.this is also called only once.

**for every request we make a new thread comes to the action.**

The difference between a web container and a web server

web container is also called as the application server. as you know tomcat is a popular web container.is there a difference between a web server and a web container?
actually yes.
a web server usually serves html pages and images.they are static things unless they contain java script in them.
but when using jsp's and servlets we must use an application server to support them.because it is a software that supports multiple operations in a dynamic environment.
when we request something through our browser(eg:button click) it comes to the web server abd the server redirect that request to the container.
the container manages the whole other things.such as threading,security,communication and life cycle management and so on.
when the request is completed the container forwards the generated response to the web server.then the server displays through the browser.we will learn more in the Servlet life cycle.