Servlet 2.4 Specification Notes

Note while reading servlet 2.4 specification.

SRV.1.1 What is a Servlet?
A servlet is a JavaTM technology-based Web component, managed by a container,
that generates dynamic content. Like other Java technology-based components,
servlets are platform-independent Java classes that are compiled to platform-neutral
byte code that can be loaded dynamically into and run by a Java technology-enabled
Web server. Containers, sometimes called servlet engines, are Web server extensions
that provide servlet functionality. Servlets interact with Web clients via a
request/response paradigm implemented by the servlet container.

SRV.1.2 What is a Servlet Container?
The servlet container is a part of aWeb server or application server that provides the
network services over which requests and responses are sent, decodes MIME-based
requests, and formats MIME-based responses. A servlet container also contains and
manages servlets through their lifecycle.

All servlet containers must support HTTP as a protocol for requests and
responses, but additional request/response-based protocols such as HTTPS
(HTTP over SSL) may be supported.

Sequence of Servlet Request & Response
The following is a typical sequence of events:
1. A client (e.g., a Web browser) accesses a Web server and makes an HTTP request.
2. The request is received by the Web server and handed off to the servlet container.
The servlet container can be running in the same process as the host
Web server, in a different process on the same host, or on a different host from
the Web server for which it processes requests.
3. The servlet container determines which servlet to invoke based on the configuration
of its servlets, and calls it with objects representing the request and response.
4. The servlet uses the request object to find out who the remote user is, what
HTTP POST parameters may have been sent as part of this request, and other
relevant data. The servlet performs whatever logic it was programmed with,
and generates data to send back to the client. It sends this data back to the client
via the response object.
5. Once the servlet has finished processing the request, the servlet container ensures
that the response is properly flushed, and returns control back to the host
Web server.

Comparing Servlets with Other Technologies
In functionality, servlets lie somewhere between Common Gateway Interface (CGI)
programs and proprietary server extensions such as the Netscape Server API
(NSAPI) or Apache Modules.
Servlets have the following advantages over other server extension mechanisms:
• They are generally much faster than CGI scripts because a different process
model is used.
• They use a standard API that is supported by many Web servers.
• They have all the advantages of the Java programming language, including
ease of development and platform independence.
• They can access the large set of APIs available for the Java platform.

Servlet Interface

The Servlet interface is the central abstraction of the Java Servlet API. All servlets
implement this interface either directly, or more commonly, by extending a class
that implements the interface. The two classes in the Java Servlet API that implement
the Servlet interface are GenericServlet and HttpServlet. For most purposes,
Developers will extend HttpServlet to implement their servlets.

SRV.2.1 Request Handling Methods
The basic Servlet interface defines a service method for handling client requests.
This method is called for each request that the servlet container routes to an instance
of a servlet.
The handling of concurrent requests to a Web application generally requires
that the Web Developer design servlets that can deal with multiple threads executing
within the service method at a particular time.
Generally the Web container handles concurrent requests to the same servlet
by concurrent execution of the service method on different threads.

SRV.2.1.1 HTTP Specific Request Handling Methods
The HttpServlet abstract subclass adds additional methods beyond the basic
Servlet interface that are automatically called by the service method in the
HttpServlet class to aid in processing HTTP-based requests. These methods are:
• doGet for handling HTTP GET requests
• doPost for handling HTTP POST requests
• doPut for handling HTTP PUT requests
• doDelete for handling HTTP DELETE requests
• doHead for handling HTTP HEAD requests
• doOptions for handling HTTP OPTIONS requests
• doTrace for handling HTTP TRACE requests
Typically when developing HTTP-based servlets, a Servlet Developer will
only concern himself with the doGet and doPost methods. The other methods are
considered to be methods for use by programmers very familiar with HTTP programming.

SRV.2.1.2 Additional Methods
The doPut and doDelete methods allow Servlet Developers to support HTTP/1.1
clients that employ these features. The doHead method in HttpServlet is a specialized
form of the doGet method that returns only the headers produced by the doGet
method. The doOptions method responds with which HTTP methods are supported
by the servlet. The doTrace method generates a response containing all instances of
the headers sent in the TRACE request.

SRV.2.1.3 Conditional GET Support
The HttpServlet interface defines the getLastModified method to support conditional
GET operations. A conditional GET operation requests a resource be sent only if
it has been modified since a specified time. In appropriate situations, implementation
of this method may aid efficient utilization of network resources.

Format My Source Code for Blogging

One of the post very useful for all blogger and developer
Format My Source Code for Blogging

this Keyword In Java

All java developer aware role of 'this'. 'this' is a reference to the current object in constructor and instance methods.

In java we use 'this' in different place are:

1. Using 'this field' inside constructor/non-static method.

2. Using 'this field' inside static method.

3. Using this() method inside constructor

4. Using this() method inside static/non-static methods.

5. Recursive constructor invocation using this().

S.No.	Place of 'this'	Description	When executes	Where Not Include	Sample Code
1	Using 'this field' inside constructor/non-static method	'this' act as the reference to the current object, So using 'this' we can access the class instance variable and methods(static/no-static). Most of the case we use in POJO class setter & getter method.	We can use to refer the current object instance variable inside the constructor/non-static methods.	Its should be used anywhere in inside constructor/non-static method.	package thispck; public class SampleThis { int intvalue; public SampleThis(int intvalue) { this.intvalue=intvalue; } public static void main(String arg[]) { SampleThis sampleThis=new SampleThis(10); System.out.println("Int Value::"+sampleThis.intvalue); } } Output: Int Value::10
2	Using 'this field' inside static method.	Not possible to use this.	-	Compile time error. Error: cannot use this in a static context.	-
3	Using 'this() method' inside constructor	This() method used for calling the default constructor and parameter constructor in a class.	While object creation using new keyword.	'this()' declaration should be first statement in constructor. Otherwise compile time Error: Constructor call must be first statement in constructor	package thispck; public class SampleThis { int intvalue; public SampleThis(int intvalue) { this.intvalue=intvalue; } public SampleThis() { this(0); } public static void main(String arg[]) { SampleThis sampleThis=new SampleThis(10); System.out.println("Int Value::"+sampleThis.intvalue); } } output: Int Value::10
4	Using this() method inside static/non-static methods.	Compile time error	-	Error: Constructor call must be the first statement in a constructor	-
5	Recursive constructor invocation using this()	Compile time error	-	Compile time error. public SampleThis(int intvalue) { this(); this.intvalue=intvalue; } public SampleThis() { this(0); }	package thispck; public class SampleThis { int intvalue; public SampleThis(int intvalue) { this(); this.intvalue=intvalue; } public SampleThis() { this(0); } public static void main(String arg[]) { SampleThis sampleThis=new SampleThis(10); System.out.println("Int Value::"+sampleThis.intvalue); } }

Role of Super Keyword in Java

In this article trying to explain the use of 'Super' keyword in Child class.

1. super() method @ Child class constructor
   

2. Super() with parameter method @ Child class constructor
   

3. Super()default/parameter method@ child class member method
   

4. Super keyword @child class Constructor
   

5. Super keyword @ child class member method

   Basically super keyword always refer the parent class object reference. We all know the parent of all java class is java.lang.Object. So when ever we create a java file(class) with out extending any class \,java compiler will do three basic operation.
   

1. Extend parent class java.lang.Object
   

2. if no constructor(default/Parameter) for the child class its include
   the default constructor.
   

3. If no super() method in constructor its include the super() in the
   first line of the constructor.

   Fact:
   

when ever we create the object for any User define class we always able to
access the methods from the Object class.Its does means always
create two object in Heap memory one is user define class and another
one is Object class.

S.No	Place of Super	Description	When executes	Where Not Include	Sample Code
1	Super() default method @ Child class Constructer	Super() its used for calling parent class constructer from child class constructer.In this case two object will be created . First Parent object will be created and than child object will be created.	While creating object reference for the child class.	It should be Present in first line of the child class constructer. Should not be two super() method statement in same constructer.	package superpck.blog; class Parent{ public Parent() { System.out.println("Creating Parent Object"); } } class Child extends Parent { public Child() { System.out.println("Creating Child Object"); } } public class SampleSuper { public static void main(String arg[]) { Child child=new Child(); } } output: Creating Parent Object Creating Child Object
2	Super() with parameter method @ child class.	Super() with Parameter it used for calling parent class constructer with parameter from child class constructer.In this case two object will be created . First Parent object will be created and than child object will be created. But we can initialize parent class instance variable from this.	while creating object for the child class	Same as S.No:1(Super() default method @ Child class Constructer)	package superpck.blog; class Parent{ Integer Parentage; public Parent() { System.out.println("Creating Parent Object"); } public Parent(int age){Parentage=age;} } class Child extends Parent { public Child() { System.out.println("Creating Child Object"); } public Child(int Parentage) { super(Parentage); } } public class SampleSuper { public static void main(String arg[]) { Child child=new Child(30); System.out.println("Parent age::"+child.Parentage); } } output: Parent age::30
3	Super() default/parameter method @ child class member method.	Error as : Constructor call must be the first statement in a constructor	-	Compile time error	-
4	Super keyword @ Child class constrcter	Its act as a parent class object reference from child class.Using super keyword we can call the parenet class member methods and instance variables only not constrcter.	Its depends upon the Instruction flow.	It can present any where and many time in both child class constrcter/ member methods.	package superpck.blog; class Parent{ Integer Parentage; public Parent() { System.out.println("Creating Parent Object"); } public Parent(int age){Parentage=age;} public void memberMethod() {System.out.println("Inside member method of Parent"); } } class Child extends Parent { public Child() { System.out.println("Creating Child Object"); } public Child(int Parentage) { super(Parentage); super.memberMethod(); super.memberMethod(); } } public class SampleSuper { public static void main(String arg[]) { Child child=new Child(30); System.out.println("Parent age::"+child.Parentage); } } Output: Inside member method of Parent Inside member method of Parent Parent age::30
5	Super keword @ child class member method.	Its act as a parent class object reference from child class.Using super keyword we can call the parenet class member methods and instance variables only not constrcter.	Its depends upon the Instruction flow.	It can present any where and many time in both child class constrcter/ member methods.	Refer s.No 4 sample.

Static Keyword In Java

In this article i have explained the use of 'Static' keyword in different place of java.

like
1.Instance variable
2.In methods
3.In Class
4.In Inner Class -Create Object and call inner static and Non-Static methods.
5.Purpose of Static method and Static Class,static instance variable.
With Sample Program.

S.No	Place of static	Description	When executes	Where Not Include	Sample Code
1	Static block	Nothing but the block of code will be written inside of the static keyword in class .	Called only first time of object creation. First priority will always go to static block even normal block of code present	Inside Methods we can't declare a static block.	Package staticpck.block; public class StaticBlock { { System.out.println("Inside empty block"); } static {System.out.println("Inside static Block");} } package staticpck.block; public class StaticBlockMain { public static void main(String arg[]) {StaticBlock staticBlock=new StaticBlock(); StaticBlock staticBlock1=new StaticBlock(); } } Output: Inside static Block Inside empty block Inside empty block
2	Static Instance Variable	Only one copy for the entire class.(each object reference have only one copy). Even you can access static variable with out creating reference for Object	Only one copy for entire class (Only class name is enough to refer instance variable)	NA(Inside Method local static variable are not possible)	package staticpck.Instvar; public class InstanceVar { static int Instance=1; } package staticpck.Instvar; public class InstanceVarMain { public static void main(String arg[]) { InstanceVar instanceVar=new InstanceVar(); instanceVar.Instance=2; InstanceVar instanceVar2=new InstanceVar(); instanceVar2.Instance=3; System.out.println("instanceVar.Instance="+instanceVar.Instance); }} Output: instanceVar.Instance=3
3	Static @ method	Only one copy for the entire class.(each object reference have only one copy). Even you can access static variable with out creating reference for Object	When a method function is independent of its reference variable in that case we can use Static method.		package staticpck.method; public class Method { public static String getClassDesc() { return "This Class Refers Static Method";} } package staticpck.method; public class MethodImp { public static void main(String[] args) { System.out.println("With Out Obj Ref Call::"+Method.getClassDesc()); System.out.println("With Obj Ref Call::"+new Method().getClassDesc()); }} OutPut: With Out Obj Ref Call::This Class Refers Static Method With Obj Ref Call::This Class Refers Static Method
4	Static @ class	We can't use static for class.	-	Compile time error	-
5	Static in inside method	We can't use static inside method. No use to keep its in Stack memory	-	Compile time error	-
6	Inner class : static @ instance variable	Error msg: The field “sample” cannot be declared static; static fields can only be declared in static or top level types	-	Compile time error	To eliminate error declare inner class as static
7	Inner class : static @ method	Error msg: The method “innermethod” cannot be declared static; static methods can only be declared in a static or top level type	-	Compile time error	To eliminate error declare inner class as static
8	Static @Inner class	If u want to declare static instance/static methods inside the Inner class than Inner class must be declared as Static	All execution are same for outer class		package staticpck.inner; public class InnerSample { static class InnerStatic{ static{ System.out.println("hi i am from inner static block"); } { System.out.println("Hi i am from Inner class block"); } static int instance; static String InnerMethod() { return "I am from Static InnerMethod"; } } class Inner{ //static int instance; String InnerMethod() { return "I am not able to use static due to My hirearchy"; } } } package staticpck.inner; public class InnerSampleImp { public static void main(String arg[]) { System.out.println(InnerSample.InnerStatic.InnerMethod()); InnerSample innerSample=new InnerSample(); InnerSample.Inner inner=innerSample.new Inner(); System.out.println(); } } Output: hi i am from inner static block Innser Static class:I am from Static InnerMethod