Web Tech Java Servlet Update1

24/03/2009 @JECRC,JODHPUR 1

An Introduction to Java Web Technology(Java Servlet)

Presented At:JECRC, Faculty of

E&T,Jodhpur National

University,Jodhpur, RajasthanIndia -342001


HTTP

HTTP stands for HyperText Transport Protocol, and is the network protocol used over the web. It runs over TCP/IP.

HTTP uses a request/response model.Client sends an HTTP request, then the server gives back the HTTP response that the browser will display (depending on the content type of the answer).

If the response is an HTML file, then the HTML file is added to the HTTP response body.

An HTTP response includes : status code, the content-type (MIME type), and actual content of the response.

A MIME type tells the browser what kind of data the response is holding.

URL stands for Uniform Resource Locator: starts with a protocol, then a server name, optionally followed by a port number, then the path to the resource followed by the resource name. Parameters may appear at the end, separated from the rest by a ? .


HTTP METHODS

METHOD DESCRIPTION

HEAD Asks for the response identical to the one that would correspond to a GET request, but without the response body. This is useful for retrieving meta-information written in response headers, without having to transport the entire content.

GET means retrieve whatever data is identified by the URI

POST Submits data to be processed (e.g., from an HTML form) to the identified resource. The data is included in the body of the request.

DELETE Deletes the specified resource.

TRACE Echoes back the received request, so that a client can see what intermediate servers are adding or changing in the request.

OPTIONS Returns the HTTP methods that the server supports for specified URL. This can be used to check the functionality of a web server by requesting '*' instead of a specific resource.

CONNECT

Converts the request connection to a transparent TCP/IP tunnel, usually to facilitate SSL-encrypted communication (HTTPS) through an unencrypted HTTP proxy.[3]

PUT Uploads a representation of the specified resource.


HTTP METHODS

HTTP servers are required to implement at least the GET and HEAD methods [4] and, whenever possible, also the OPTIONS method Safe methodsSome methods (for example, HEAD, GET, OPTIONS and TRACE) are defined as safe, which means they are intended only for information retrieval and should not change the state of the server.Idempotent methodsSome http methods are defined to be idempotent, meaning that multiple identical requests should have the same effect as a single request. Methods PUT, DELETE, GET, HEAD, OPTIONS and TRACE, being prescribed as safe, should also be idempotent. HTTP is a stateless protocol.By contrast, the POST method is not necessarily idempotent, and therefore sending an identical POST request multiple times may further affect state or cause further side effects.(like updating inserting records in database multiple times).


DIFFERENCE BETWEEN GET AND POST

GET:GET parameters are passed on the URL line, after a ?. The URL size is

limited. The parameters appear in the browser URL field, hence showing any

password to the world... GET is supposed to be used to GET things (only retrieval, no modification

on the server). GET processing must be idempotent. A click on a hyperlink always sends a GET request. GET is the default method used by HTML forms. Use the method=”POST”

to change it. POST:POST has a body.In POST requests, the parameters are passed in the body of the request,

after the header. There is no size-limit. Parameters are not visible from the user.

POST is supposed to be used to send data to be processed. POST may not be idempotent and is the only one. IDEMPOTENT : Can do the same thing over and over again, with no

negative side effect.


WHAT IS WEB CONTAINER?

A Web application runs within a Web container of a Web server. The Web container provides the runtime environment through components that provide naming context and life cycle management. Some Web servers may also provide additional services such as security and concurrency control.

Web applications are composed of web components and other data such as HTML pages. Web components can be servlets, JSP pages created with the JavaServer Pages™ technology, web filters, and web event listeners. These components typically execute in a web server and may respond to HTTP requests from web clients. Servlets, JSP pages, and filters may be used to generate HTML pages that are an application’s user interface.


WHAT IS JAVA SERVLET?

Servlets are Java classes that process the request dynamically and generate response independent of the protocol. Servlets are defined in Java Servlet API specification. Latest Servlet API specification available is 2.5.

Servlets are server side Java programs which extends the functionality of web server. Servlet are protocol independent that means it can be used virtually with any protocol to process the request and generate the response. However in practice Servlets are used to process the HTTP requests and generate the HTML response.


STRUCTURE OF A WEB APPLICATION

Web Applications use a standard directory structure defined in the Servlet specification. When developing web applications on J2EE platform, you must follow this structure so that application can be deployed in any J2EE compliant web server.

A web application has the directory structure as shown in figure.

The root directory of the application is called the document root. Root directory is mapped to the context path.

Root directory contains a directory named WEB-INF. Anything under the root directory excepting the WEB-INF directory is publically available, and can be accessed by URL from browser.

WEB-INF directory is a private area of the web application, any files under WEB-INF directory cannot be accessed directly from browser by specifying the URL like http://somesite/WEB-INF/someresource.html. Web container will not serve the content of this directory. However the content of the WEB-INF directory is accessible by the classes within the application.


WEB-INF DIRECTORY

WEB-INF directory contains WEB-INF/web.xml deployment descriptor WEB-INF/classes directory WEB-INF/lib directoryCLASSES- directory is used to store compiled servlet and other classes of

the application.LIB - directory is used to store the jar files. If application has any bundled jar

files, or if application uses any third party libraries such as log4j which is packaged in jar file, than these jar files should be placed in lib directory.

All unpacked classes and resources in the /WEB-INF/classes directory, plus classes and resources in JAR files under the /WEB-INF/lib directory, are made visible to the containing web application.


SERVLET LIFE CYCLE

Servlets are managed components. They are managed by web container. Of the various responsibilities of web container, servlet life cycle management is the most important one.

A servlet is managed through a well defined life cycle that defines how it is loaded, instantiated ad initialized, handles requests from clients and how it is taken out of service.

The servlet life cycle methods are defined in the javax.servlet.Servlet interface of the Servlet API that all Servlets must implement directly or indirectly by extending GenericServlet or HttpServlet abstract classes. Most of the servlet you develop will implement it by extending HttpServlet class.

The servlet life cycle methods defined in Servlet interface are init(), service() and destroy().

The signature of this methods are shown below.

public void init(ServletConfig config) throws ServletException public void service(ServletRequest req, ServletResponse res) throws

ServletException, IOExceptionpublic void destroy()


SERVLET LIFE CYCLE


SERVLET LIFE CYCLE - STEPS

The servlet life cycle consists of four steps, instantiation, initialization, request handling and end of service.

Loading and instantiation

During this step, web container loads the servlet class and creates a new instance of the servlet. The container can create a servlet instance at container startup or it can delay it until the servlet is needed to service a request.

Initialization

During initialization stage of the Servlet life cycle, the web container initializes the servlet instance by calling the init() method. The container passes an object implementing the ServletConfig interface via the init() method. This configuration object allows the servlet to access name-value initialization parameters from the web application’s deployment descriptor (web.xml) file. The container guarantees that the init() method will be called before the service() method is called.

The init() method is typically used to perform servlet initialization, creating or loading objects that are used by the servlet in the handling of its requests.

The init() method is commonly used to perform one time activity. One of the most common use of init() method is to setup the database connection or connection pool.


SERVLET LIFE CYCLE - STEPS

Request handling

After a servlet is properly initialized, it is ready to handle the client requests. If the container has a request for the servlet, it calls the servlet instance’s service() method. The request and response information is wrapped in ServletRequest and ServletResponse objects respectively, which are then passed to the servlet's service() method. In the case of an HTTP request, the objects provided by the container are of types HttpServletRequest and HttpServletResponse.

Service() method is responsible for processing the incoming requests and generating the response.

End of serviceWhen the servlet container determines that a servlet should be removed from

service, it calls the destroy () method of the Servlet instance to allow the servlet to release any resources it is using. The servlet container can destroy a servlet because it wants to conserve some memory or server itself is shutting down.

Destroy() method is used to release any resources it is using. The most common use of destroy() method is to close the database connections.


SETTING UP SERVLET DEVELOPMENT ENVIRONMENT

List of required softwares: JAVA 1.5 or 1.6 Tomcat 5.5.16

First of all you need the Java software development kit 1.5 or 1.6 (JAVA SDK) installed.

Checking if JAVA is already installed in your system



Set up the JAVA_HOME environment variableOnce the JAVA SDK is installed follow this step to set the

JAVA_HOME environment variable. If JAVA_HOME variable is already set, you can skip this step.





In the variable name filed, enter JAVA_HOME. Specify the path to root directory of JAVA installation in variable value field and click OK button. Now JAVA_HOME will appear under user variables. Next you need to add bin directory under the root directory of JAVA installation in PATH environment variable.Select the PATH variable from System variables and click on Edit button. Add: ;%JAVA_HOME%\bin; at the end of variable value field and click OK button.


INSTALLING TOMCAT

Tomcat is an opensource web container. it is also web container reference implementation. Download the latest version of tomcat from this URL . Download the jakarta-tomcat-5.0.28.tar.gz and extract it to the directory of your choice. Note: This directory is referred as TOMCAT_HOME in other tutorials.

That’s all, tomcat is installed.

Starting and shutting down TomcatTo start the tomcat server, open the command prompt, change the directory to TOMCAT HOME/bin and run the startup.bat file. It will start the server. >startup To shut down the tomcat server, run the shutdown.bat file. It will stop the server. >shutdown Verifying Tomcat installationTo verify that tomcat is installed properly, start the server as explained above, open the web browser and access the following URL. http://localhost:8080/index.jsp It should show the tomcat welcome page, if tomcat is installed properly and server is running.


INSTALLING TOMCAT

Setting up the CLASSPATHNow you need to create a new environment variable CLASSPATH if it is not already set. We need to add the servlet-api.jar into the CLASSPATH to compile the Servlets. Follow the same steps as you did to create the JAVA_HOME variable. Create a new variable CLASSPATH under system variables. Add TOMCAT_HOME/lib/servlet-api.jar in variable value field. Note: here TOMCAT_HOME refers to the tomcat installation directory.


SERVLET API CLASSES AND INTERFACES

Servlet API is specified in two packages: javax.servlet and javax.servlet.http. The classes and interfaces in javax.servlet are protocol independent, while the classes and interface in javax.servlet.http deals with specialized HTTP Servlets.

Some of the classes and interfaces in the javax.servlet.http package extend those specified in javax.servlet package.

The javax.servlet packageThe javax.servlet package defines the contract between container and the servlet class.

It provides the flexibility to container vendor to implement the API the way they want so long as they follow the specification. To the developers, it provides the library to develop the servlet based applications.

the javax.servlet InterfacesThe javax.servlet package is composed of 14 interfaces.

Servlet interfaceThe Servlet Interface is the central abstraction of the Java Servlet API. It defines the

life cycle methods of a servlet. All the servlet implementations must implement it either directly or indirectly by extending a class which implements the Servlet interface. The two classes in the servlet API that implement the Servlet interface are GenericServlet and HttpServlet. For most purposes, developers will extend HttpServlet to implement their Servlets while implementing web applications employing the HTTP protocol.



ServletRequest interface ServletRequest interface provides an abstraction of client request. The object of ServletRequest is used to obtain the client request

information such as request parameters, content type and length, locale of the client, request protocol etc.

Developers don’t need to implement this interface. The web container provides the implementation this interface. The web container creates an instance of the implementation class and passes it as an argument when calling the service() method.

ServletResponse interface The ServletResponse interface assists a servlet in sending a response to

the client. Developers don’t need to implement this interface. Servlet container

creates the ServletResponse object and passes it as an argument to the servlet’s service() method.



ServletConfig interface The servlet container uses a ServletConfig object to pass initialization

information to the servlet. ServletConfig object is most commonly used to read the initialization

parameters. Servlet intialialization parameters are specified in deployment

descriptor (web.xml) file. Servlet container passes the ServletConfig object as an argument

when calling servlet’s init() method. ServletContext interface ServletContext object is used to communicate with the servlet container. There is only one ServletContext object per web application (per JVM). This is initialized when the web application is started and destroyed only when

the web application is being shutdown. ServletContext object is most commonly used to obtain the MIME type of a file,

dispatching a request, writing to server’s log file, share the data across application, obtain URL references to resources etc



SingleThreadModel Interface SingleThreadModel is a marker interface. It is used to ensure that servlet handle

only one request at a time. Servlets can implement SingleThreadModel interface to inform the container

that it should make sure that only one thread is executing the servlet’s service() method at any given moment.

RequestDispatcher Interface The RequestDispatcher interface is used to dispatch requests to other

resources such a servlet, HTML file or a JSP file.

Filter Interface Filter interface declares life cycle methods of a filter. The life cycle

methods include, init() doFilter() and destroy().

FilterChain Interface The FilterChain object provides the filter with a handle to invoke the

rest of the filter chain. Each filter gets access to a FilterChain object when its doFilter() method is invoked. Using this object, the filter can invoke the next filter in the chain.



FilterConfig interface The FilterConfig interface is similar to ServletConfig interface. It is used

to get the initialization parameters. ServletContextAttributeListner Implementation of this interface receives notification whenever an

attribute is added, removed or replaced in ServletContext. To receive the notifications, the implementation class must be configured in the deployment descriptor (web.xml file).

ServletContextListner Interface Implementation of this interface receives notification when the context is

created and destroyed. ServletRequestAttributeListner Interface Implementation of this interface receives notification whenever an

attribute is added, removed or replaced in ServletRequest. ServletRequestListner Interface Implementation of this interface receives notification whenever the

request is coming in and out of scope. A request is defined as coming into scope when it is about to enter the first servlet or filter in each web application, as going out of scope when it exits the last servlet or the first filter in the chain.



The javax.servlet ClassesThe javax.servlet package contains 9 classes.GenericServlet class The GenericServlet abstract class defines the generic protocol independent

servlet. It can be extended to develop our own protocol-based servlet. ServletContextEvent class This is the event class for notifications about changes to the servlet context

of a web application. ServletInputStream class Provides an input stream for reading binary data from a client request. ServletOutputStream class Provides an output stream for sending binary data to the client. javax.servlet Exception classesThe javax.servlet package defines 2 exception classes. ServletException class Defines a general exception a servlet can throw when it encounters

difficulty. UnavailableException class Defines an exception that a servlet or filter throws to indicate that it is

permanently or temporarily unavailable.


Understanding the GenericServlet class

GenericServlet class defines a generic protocol independent servlet. It is protocol independent in the sense it can be extended to provide implementation of any protocol like FTP, SMTP etc.

Servlet API comes with HttpServlet class which implements HTTP protocol. Generally when developing web application, you will never need to write a servlet

that extends GenericServlet. Most of the Servlets in your application will extend HttpServlet class to handle web requests.

GenericServlet class provides implementation of Servlet Interface. This is an abstract class, all the subclasses must implement service () method.

Public abstract class GenericServlet implements Servlet,ServletConfig,Serializable

In addition to those methods defined in Servlet Interface, GenericServlet defines following additional methods. Public void init()Public void log(String message)Public void log(String message, Throwable t)



Initializing the ServletPublic void init(ServletConfig config)Public void init()

Public void init(ServletConfig config) method is an implementation of init(ServletConfig config) method defined in Servlet interface, it stores the ServletConfig object in private transient instance variable.

getServletConfig() method can be used to get the reference of this object. If you override this method, you should include a class to super.init(config) method. Alternatively, you can override no-argument init() method.

Handling requestsPublic abstract void service (ServletRequest request, ServletResponse

response)This is an abstract method, and you must override this method in your subclass to

handle requests. All the code related to request processing and response generation goes here.

Destroying the ServletPublic void destroy() This method provides default implementation of destroy () method defined in the

Servlet interface. You can override this method in your subclasses to do some cleanup tasks when servlet is taken out of service.



Accessing the environmentGenericServlet class also implements ServletConfig interface so all the methods of

ServletConfig interface can be called directly without first obtaining reference to ServletConfig instance. Public String getInitParameter(String name) : used to obtaing value of servlet initialization parameter.

public String getInitParameterNames() : returns names of all initialization parameters.

Public ServletContext getServletContext() : returns reference to ServletContext object.

String getServletName() : used to obtain name of the servlet.

Writing to server log file Public void log(String message)Public void log(String message, Throwable t)

GenericServlet class provides two utility methods for writing to server log file. log(String message) method writes servlet name and message to web containers log file. the other method log(string message, Throwable t), writes servlet name, string message and the exception stack trace of the given Throwable exception to web containers log file.


GenericServlet Example

import java.io.IOException;import java.io.PrintWriter;import javax.servlet.GenericServlet;import javax.servlet.ServletException;import javax.servlet.ServletRequest;import javax.servlet.ServletResponse; public class GenericServletExample extends GenericServlet {

public void init() {log("inside init() method");

}public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {

log("Handling request");response.setContentType("text/html");PrintWriter out = response.getWriter();out.write("<html><head><title>GenericServle example</title></head>");out.write("<body><h1>GenericServlet: Hallo world

</h1></body></html>");out.close();

}


GenericServlet Example

public void destroy() {log("inside destroy() method");

}} --------------------------------------------------------------------------Web.xml deployment descriptor <?xml version="1.0" encoding="ISO-8859-1"?><web-app xmlns="http://java.sun.com/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"version="2.5">

<servlet><servlet-name>GenericServlet</servlet-name><servlet-class>com.jsptube.servlet.GenericServletExample</servlet-class>

</servlet><servlet-mapping>

<servlet-name>GenericServlet</servlet-name><url-pattern>/exampleservlet</url-pattern>

</servlet-mapping></web-app>


A VERY SIMPLE SERVLET EXAMPLE

What is covered in this Servlet example How to write the servlet class. How to compile the Servlet class. How to extract the HTML form parameters from HttpServletRequest. web.xml deployment descriptor file. How to create the war (web application archive) file. How to deploy and run the sample web application in tomcat web

container. This is a very simple web application containing a HTML file and a servlet.

The HTML document has a form which allows the user to enter the name, when the form is submitted application displays the welcome message to the user.



Create the HTML file.Copy the following code into form.html file and save it under servlet-

example/pages directory. <html>

<head><title>The servlet example </title>

</head><body><h1>A simple web application</h1><form method="POST" action="/WelcomeServlet">

<label for="name">Enter your name </label><input type="text" id="name" name="name"/><br><br><input type="submit" value="Submit Form"/><input type="reset" value="Reset Form"/>

</form></body>

</html>



The welcome Servlet classimport java.io.IOException;import java.io.PrintWriter;

import javax.servlet.ServletConfig;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;

public class WelcomeServlet extends HttpServlet {

@Overridepublic void init (ServletConfig config) throws ServletException {super.init(config);} protected void doPost (HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

/* Get the value of form parameter */String name = request.getParameter("name");String welcomeMessage = "Welcome "+name;/* Set the content type(MIME Type) of the response.*/response.setContentType("text/html");PrintWriter out = response.getWriter();



/** Write the HTML to the response*/out. println ("<html>");out. println ("<head>");out. println ("<title> A very simple servlet example</title>");out. println ("</head>");out. println ("<body>");out. println ("<h1>"+welcomeMessage+"</h1>");out. println ("<a href="/servletexample/pages/form.html">"+"Click here to go back to input page "+"</a>");out. println ("</body>");out. println ("</html>");out. close (); }public void destroy() { }

}Compile the WelcomeServlet.java using the following command.>javac WelcomeServlet.java It will create the file WelcomeServlet.class in the same directory. Copy the class

file to classes directory. All the Servlets and other classes used in a web application must be kept under WEB-INF/classes directory.

Note: to compile a servlet you need to have servlet-api.jar file in the class path.



The deployment descriptor (web.xml) file.Copy the following code into web.xml file and save it directly under servlet-

example/WEB-INF directory. <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>WelcomeServlet</servlet-name><servlet-

class>jsptube.tutorials.servletexample.WelcomeServlet</servlet-class></servlet><servlet-mapping>

<servlet-name>WelcomeServlet</servlet-name><url-pattern>/WelcomeServlet</url-pattern>

</servlet-mapping><welcome-file-list>

<welcome-file>/pages/form.html

</welcome-file></welcome-file-list>

</web-app>



Create the WAR (Web application archive) file.Web applications are packaged into a WAR (web application archive). There

are many different ways to create a WAR file. You can use jar command, ant or an IDE like Eclipse. This tutorial explains how to create the WAR file using jar tool.

Open the command prompt and change the directory to the servlet-example directory, and execute the following command.

>jar cvf servletexample.war * This command packs all the contents under servlet-example directory,

including subdirectories, into an archive file called servletexample.war.We used following command-line options: -c option to create new WAR file. -v option to generate verbose output. -f option to specify target WAR file name.

You can use following command to view the content of servletexample.war file. >Jar –tvf servletexample.war.

This command lists the content of the WAR file.



Deploying the application to tomcat web container.Deployment steps are different for different J2EE servers. This tutorial

explains how to deploy the sample web application to tomcat web container. If you are using any other J2EE server, consult the documentation of the server.

A web application can be deployed in tomcat server simply by copying the war file to <TOMCAT_HOME>/webapp directory.Copy servletexample.war to <TOMCAT_HOME>/webapp directory. That’s it! You have successfully deployed the application to tomcat web server. Once you start the server, tomcat will extract the war file into the directory with the same name as the war file.

To start the server, open the command prompt and change the directory to <TOMCAT_HOME/bin> directory and run the startup.bat file.

Our sample application can be accessed at http://localhost:8080/servletexample/. If tomcat server is running on port other than 8080 than you need to change the URL accordingly.

If the application has been deployed properly, you should see the screen similar to below when you open the application in browser.







How the application works.When you access the application by navigating to URL

http://localhost:8080/servletexample/ the web server serves the form.html file. “\pages\form.html” file is specified as welcome file in web.xml file so web

server serves this file by default. When you fill the form field and click on submit form button, browser sends

the HTTP POST request with name parameter. Based on the servlet mapping in web.xml, the web container delegates the

request to WelcomeServlet class. When the request is received by WelcomeServlet it performs following tasks. Extract the name parameter from HttpServletRequest object. Generate the welcome message. Generate the HTML document and write the response to

HttpServletResponse object. Browser receives the HTML document as response and displays in browser

window. The next step is to understand the code.


Handling Form Data using Java Servlet


ADVANTAGES OF JAVA SERVLET

Portability Powerful Efficiency Safety Integration Extensibilty Inexpensive


ADVANTAGES OF JAVA SERVLET OVER CGI

Platform IndependenceServlets are written entirely in java so these are platform independent. Servlets can run on any Servlet enabled web server. For example if you develop an web application in windows machine running Java web server, you can easily run the same on apache web server (if Apache Serve is installed) without modification or compilation of code. Platform independency of servlets provide a great advantages over alternatives of servlets.

PerformanceDue to interpreted nature of java, programs written in java are slow. But the java servlets runs very fast. These are due to the way servlets run on web server. For any program initialization takes significant amount of time. But in case of servlets initialization takes place first time it receives a request and remains in memory till times out or server shut downs. After servlet is loaded, to handle a new request it simply creates a new thread and runs service method of servlet. In comparison to traditional CGI scripts which creates a new process to serve the request.

ExtensibilityJava Servlets are developed in java which is robust, well-designed and object oriented language which can be extended or polymorphed into new objects. So the java servlets take all these advantages and can be extended from existing class to provide the ideal solutions.

SafetyJava provides very good safety features like memory management, exception handling etc. Servlets inherits all these features and emerged as a very powerful web server extension.

SecureServlets are server side components, so it inherits the security provided by the web server. Servlets are also benefited with Java Security Manager.


INTRO TO SERVER SIDE PROGRAMMING

Advantages of Server Side Programs

•All programs reside in one machine called the Server. Any number of remote machines (called clients) can access the server programs.

•New functionalities to existing programs can be added at the server side which the clients’ can advantage without having to change anything from their side.

•Migrating to newer versions, architectures, design patterns, adding patches, switching to new databases can be done at the server side without having to bother about clients’ hardware or software capabilities.

•Issues relating to enterprise applications like resource management, concurrency, session management, security and performance are managed by service side applications.

•They are portable and possess the capability to generate dynamic and user-based content (e.g. displaying transaction information of credit card or debit card depending on user’s choice).


INTRO TO SERVER SIDE PROGRAMMING

Types of Server Side Programs

Active Server Pages (ASP)

Java Servlets

Java Server Pages (JSPs)

Enterprise Java Beans (EJBs)

PHP

To summarize, the objective of server side programs is to centrally manage all programs relating to a particular application (e.g. Banking, Insurance, e-shopping, etc). Clients with bare minimum requirement (e.g. Pentium II, Windows XP Professional, MS Internet Explorer and an internet connection) can experience the power and performance of a Server (e.g. IBM Mainframe, Unix Server, etc) from a remote location without having to compromise on security or speed. More importantly, server programs are not only portable but also possess the capability to generate dynamic responses based on user’s request.


WRITING SIMPLE HELLOWORLD SERVLET

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

public class HelloWorld extends HttpServlet{ public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,IOException{ response.setContentType("text/html"); PrintWriter pw = response.getWriter(); pw.println("<html>"); pw.println("<head><title>Hello World</title></title>"); pw.println("<body>"); pw.println("<h1>Hello World</h1>"); pw.println("</body></html>"); }}



web.xml file for this program:<?xml version="1.0" encoding="ISO-8859-1"?>

<web-app> <servlet> <servlet-name>Hello</servlet-name>

<servlet-class>HelloWorld</servlet-class> </servlet> <servlet-mapping>

<servlet-name>Hello</servlet-name> <url-pattern>/HelloWorld</url-pattern>

</servlet-mapping></web-app>




WRITING SIMPLE DISPLAYINGDATE SERVLET

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

public class DisplayingDate extends HttpServlet{ public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{ PrintWriter pw = response.getWriter(); Date today = new Date(); pw.println("<html>"+"<body><h1>Today Date is</h1>"); pw.println("<b>"+ today+"</b></body>"+ "</html>"); }}



<?xml version="1.0" encoding="ISO-8859-1"?>

<web-app> <servlet> <servlet-name>Hello</servlet-name> <servlet-class>DateDisplay</servlet-class> </servlet> <servlet-mapping> <servlet-name>Hello</servlet-name> <url-pattern>/DateDisplay</url-pattern> </servlet-mapping></web-app>






SIMPLE COUNTING IN SERVLET


public class SimpleCounter extends HttpServlet{ int counter = 0; public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); PrintWriter pw = response.getWriter(); counter++; pw.println("At present the value of the counter is " + counter); }}


GETTING SERVER INFORMATION


public class SnoopingServerServlet extends HttpServlet{ protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { PrintWriter pw = response.getWriter(); pw.println("The server name is " + request.getServerName() + "<br>"); pw.println("The server port number is " + request.getServerPort()+ "<br>"); pw.println("The protocol is " + request.getProtocol()+ "<br>"); pw.println("The scheme used is " + request.getScheme()); }}


GETTING HEADER INFORMATION

import java.io.*;import java.util.*;import javax.servlet.*;import javax.servlet.http.*;public class HeaderServlet extends HttpServlet{ protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { PrintWriter pw = response.getWriter(); pw.println("Request Headers are"); Enumeration enumeration = request.getHeaderNames(); while(enumeration.hasMoreElements()){ String headerName = (String)enumeration.nextElement(); Enumeration headerValues = request.getHeaders(headerName); if (headerValues != null){ while (headerValues.hasMoreElements()){

String values = (String) headerValues.nextElement(); pw.println(headerName + ": " + values);

} } } }}


GETTING HEADER INFORMATION


READING INITIALIZATION PARAMETER

In this example we are going to retreive the init paramater values which we have given in the web.xml file. Whenever the container makes a servlet it always reads it deployment descriptor file i.e. web.xml. Container creates name/value pairs for the ServletConfig object. Once the parameters are in ServletConfig they will never be read again by the Container. The main job of the ServletConfig object is to give the init parameters.



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

public class InitServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { PrintWriter pw = response.getWriter(); pw.print("Init Parameters are : "); Enumeration enumeration = getServletConfig().getInitParameterNames(); while(enumeration.hasMoreElements()){ pw.print(enumeration.nextElement() + " "); } pw.println("\nThe email address is " + getServletConfig().getInitParameter("AdminEmail")); pw.println("The address is " + getServletConfig().getInitParameter("Address")); pw.println("The phone no is " + getServletConfig().getInitParameter("PhoneNo")); }}



<?xml version="1.0" encoding="ISO-8859-1"?><!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app><servlet> <init-param> <param-name>AdminEmail</param-name>

<param-value>[email protected]</param-value> </init-param> <init-param> <param-name>Address</param-name>

<param-value>Okhla</param-value> </init-param> <init-param> <param-name>PhoneNo</param-name>

<param-value>9911217074</param-value> </init-param> <servlet-name>Zulfiqar</servlet-name> <servlet-class>InitServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>Zulfiqar</servlet-name> <url-pattern>/InitServlet</url-pattern> </servlet-mapping></web-app>




PASSING PARAMETER USING HTML FORM

<html><head><title>New Page 1</title></head><body><h2>Login</h2><p>Please enter your username and password</p><form method="GET" action="/htmlform/LoginServlet"> <p> Username <input type="text" name="username" size="20"></p> <p> Password <input type="text" name="password" size="20"></p> <p><input type="submit" value="Submit" name="B1"></p></form><p> </p></body></html>




public class LoginServlet extends HttpServlet{ public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); PrintWriter out = response.getWriter(); String name = request.getParameter("username"); String pass = request.getParameter("password"); out.println("<html>"); out.println("<body>"); out.println("Thanks Mr." + " " + name + " " + "for visiting roseindia<br>" ); out.println("Now you can see your password : " + " " + pass + "<br>"); out.println("</body></html>"); }}



<?xml version="1.0" encoding="ISO-8859-1"?>

<web-app> <servlet> <servlet-name>Hello</servlet-name> <servlet-class>LoginServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>Hello</servlet-name> <url-pattern>/LoginServlet</url-pattern> </servlet-mapping></web-app>




MULTIPLE VALUES FOR A SINGLE PARAMETER

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html><head><title>Insert title here</title></head><body><form method = "post" action = "/GetParameterServlet/GetParameterValues"><p>Which of the whisky you like most</p><input type = "checkbox" name ="whisky" value = "RoyalChallenge">RoyalChallenge.<br><input type = "checkbox" name ="whisky" value = "RoyalStag">RoyalStag.<br><input type = "checkbox" name ="whisky" value = "Bagpiper">Bagpiper.<br><input type ="submit" name= "submit"></form></body></html>



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

public class GetParameterValues extends HttpServlet{ protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); PrintWriter pw = response.getWriter(); String[] whisky = request.getParameterValues("whisky"); for(int i=0; i<whisky.length; i++){ pw.println("<br>whisky : " + whisky[i]); } }}




Thank You!!Please don’t forget to write your

review comments on

http://slideshare.net/vikramsingh.v85