Java Servlet Life Cycle

A servlet is a Java programming language class that is used to extend the capabilities of servers that host applications accessed by means of a request-response programming model. Although servlets can respond to any type of request, they are commonly used to extend the applications hosted by web servers. For such applications, Java Servlet technology defines HTTP-specific servlet classes.

The javax.servlet and javax.servlet.http packages provide interfaces and classes for writing servlets. All servlets must implement the Servlet interface, which defines life-cycle methods. When implementing a generic service, you can use or extend the GenericServlet class provided with the Java Servlet API. The HttpServlet class provides methods, such as doGet and doPost, for handling HTTP-specific services.

Servlet Life Cycle

The life cycle of a servlet is controlled by the container in which the servlet has been deployed. When a request is mapped to a servlet, the container performs the following steps.

1.      If an instance of the servlet does not exist, the web container

a.      Loads the servlet class.

b.      Creates an instance of the servlet class.

c.       Initializes the servlet instance by calling the init method.

2.      Invokes the service method, passing request and response objects.

3.      If the container needs to remove the servlet, it finalizes the servlet by calling the servlet’s destroy method.

Lets try to understand the Servlet Life Cycle in details

1.      A web browser sends an HTTP request to a web server by any one of the following ways.

a.      A user clicks on a hyperlink displayed in an HTML page.

b.      A user fills out a form in an HTML page and submits it.

c.       A user enters a URL in the browser’s address field and presses Enter.

2.      The container "sees" that the request is for a servlet, so the web container creates two objects.

a.      HttpServletRequest

b.      HttpServletResponse

3.      The Web Container finds the correct servlet based on the URL in the request , the container then creates or allocate a thread for that request and calls the service() method of the servlet, passing the request and response objects as arguments.

4.      The service() method figures out which servlet method to call based on HTTP method sent by the client.If the client sent GET , then corresponding doGet() method is called.

5.      The servlet uses the response object to write the response to the client.

6.      The service() method completes, the threads dies or returns to  back to the pool.The request and response object are garbage collected.The client gets the response.

Servlet Life Cycle

Bean scopes

Bean scopes in Spring

When we create a bean definition, we are actually creating is actual instances of the class defined by that bean definition. You can control the various dependencies and configuration values along with the scope of the objects created from a particular bean definition. Beans can be defined to be deployed in one of a number of scopes: out of the box, the Spring Framework supports five scopes of which three are available only if you are using a web-aware ApplicationContext.

Scope	Description
singleton	A single bean definition to a single object instance per Spring IoC container.
prototype	A single bean definition to any number of object instances.
request	A single bean definition to the lifecycle of a single HTTP request; that is each and every HTTP request will have its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.
session	A single bean definition to the lifecycle of a HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.
global session	A single bean definition to the lifecycle of a global HTTP Session. Typically only valid when used in a portlet context. Only valid in the context of a web-aware Spring ApplicationContext.

The singleton scope

The singleton scope is the default scope in Spring. For a singleton bean, only one shared instance of the bean will be managed, and all requests for beans with an id or ids matching that bean definition will result in that one specific bean instance being returned by the Spring container.

When you define a bean definition and it is scoped as a singleton, then the Spring IoC container will create exactly one instance of the object defined by that bean definition. This single instance will be stored in a cache of such singleton beans, and all subsequent requests and references for that named bean will result in the cached object being returned.

The prototype scope

Prototype scope of bean will create a new bean instance every time a request for that specific bean is made. You should use the prototype scope for all beans that are stateful, while the singleton scope should be used for stateless beans.

When deploying a bean in the prototype scope, please take note that , Spring does not manage the complete lifecycle of a prototype bean: the container instantiates, configures, decorates and otherwise assembles a prototype object, hands it to the client and then has no further knowledge of that prototype instance. This means that while initialization lifecycle callback methods will be called on all objects regardless of scope, in the case of prototypes, any configured destruction lifecycle callbacks will not be called. It is the responsibility of the client code to clean up prototype scoped objects and release any expensive resources that the prototype bean(s) are holding onto.

The request scope

The Spring container will create a brand new instance of the bean definition for each and every HTTP request. You can change the internal state of the instance that is created as much as you want. When the request is finished processing, the bean that is scoped to the request will be discarded.

The session scope

The Spring container will create a brand new instance of the  bean using the bean definition for the lifetime  of a single HTTP Session. In other words, the bean will be effectively scoped at the HTTP Session level. Just like request-scoped beans, you can change the internal state of the instance that is created. When the HTTP Session is eventually discarded, the bean that is scoped to that particular HTTP Session will also be discarded.

The global session scope

The global session scope is similar to the HTTP Session scope, and makes sense in the context of portlet-based web applications. The portlet specification defines the notion of a global Session that is shared amongst all of the various portlets that make up a single portlet web application. Beans defined at the global session scope are scoped to the lifetime of the global portlet Session.

Bean scopes

Autowiring In Spring

It is possible to automatically let Spring framework resolve dependencies for the bean by inspecting contents of the BeanFactory. This is kown as Autowiring.  A BeanFactory is able to autowire relationships between collaborating beans.

The autowiring functionality has five modes. Autowiring is specified per bean and can thus be enabled for some beans, while other beans won't be autowired.

Using autowiring, it is possible to reduce or eliminate the need to specify properties or constructor arguments, saving a significant amount of typing. In an XmlBeanFactory, the autowire mode for a bean definition is specified by using the autowire attribute of the bean element.

Some advantages of autowiring:

• It can reduce the volume of configuration required.
• It can cause configuration to keep itself up to date as your objects evolve. For example, if you need to add an additional dependency to a class, that dependency can be satisfied automatically without the need to modify configuration.

Some disadvantages of autowiring:

• Wiring information may not be available to tools that may generate documentation from a Spring application context.
• Autowiring by type will only work when there is a single bean definition of the type specified by the setter method or constructor argument. You need to use explicit wiring if there is any potential ambiguity.

Autowiring In Spring

Default Methods in Java 8

Default Methods in Java 8

With the release of Java 8, it is now possible for an interface method to define a default implementation. This new capability is called the default method.

Default method enables us a means by which interfaces could be expanded without breaking pre-existing code.

In simple terms default methods enable us to add new functionalities to interfaces without breaking the classes that implements that interface.

When a non-abstract class implements an interface, it must implement all methods defined by that interface. If a new method is to an existing interface, then the addition of that method would break pre-existing code, because no implementation would be found for that new method in pre-existing classes. The default method solves this problem by supplying an implementation that will be used if no other implementation is explicitly provided. Thus, the addition of a default method will not cause pre-existing code to break. This enables interfaces to be gracefully evolved over time without negative consequences.

Example of Default Method

public interface Account { default void OpenAccount(){       System.out.println("This is the Account Interface . . . ."); } }

public class SavingAccount implements Account{ public void OpenSavingAccount(){       System.out.println("This is the Saving Account Class . . . ."); } }

public class Main { public static void main(String[] args) {       SavingAccount sa=new SavingAccount();       sa.OpenAccount(); // Default method of interface is called       sa.OpenSavingAccount(); } }

Upon executing the Main class, we get the following output.

This is the Account Interface . . . .

This is the Saving Account Class . . . .

Default Methods and Multiple Inheritance
In case of multiple Inheritance, where both the implemented interfaces contain default methods with same method signature, the implementing class should explicitly specify which default method is to be used or it should override the default method.

interface InterfaceOne {       // Default method       default void show()       {             System.out.println("Default InterfaceOne");       } }

interface InterfaceTwo {       // Default method       default void show()       {             System.out.println("Default InterfaceTwo");       } }

public class MainClass implements InterfaceOne, InterfaceTwo {       // Overriding default show method       public void show()       {             // use super keyword to call the show             // method of InterfaceOne interface             InterfaceOne.super.show();             // use super keyword to call the show             // method of InterfaceTwo interface             InterfaceTwo.super.show();       }       public static void main(String args[])       {             MainClass d = new MainClass();             d.show();       } }

Upon executing the MainClass, we get the following output.

Default InterfaceOne

Default InterfaceTwo

Important Points:

1.     Interfaces can have default methods with implementation from java 8 onwards.

2.     Interfaces can have static methods as well similar to static method of classes.

3.     Default methods were introduced to provide backward comparability for old interfaces so that they can have new methods without effecting existing code.

Lambda expressions in Java 8

Lambda expressions are a new and important feature included in Java SE 8. They provide a clear and concise way to represent one method interface using an expression. Lambda expressions also improve the Collection libraries making it easier to iterate through, filter, and extract data from a Collection.

A lambda expression can be understood as a concise representation of an anonymous function that can be passed around: it doesn’t have a name, but it has a list of parameters, a body, a return type, and also possibly a list of exceptions that can be thrown.

o    Anonymous— Anonymous because it doesn’t have an explicit name like a method would normally have: less to write and think about!

o    Function— Function because a lambda isn’t associated with a particular class like a method is. But like a method, a lambda has a list of parameters, a body, a return type, and a possible list of exceptions that can be thrown.

o    Passed around— A lambda expression can be passed as argument to a method or stored in a variable.

o    Concise— You don’t need to write a lot of boilerplate like you do for anonymous classes.

Lambdas technically let you do anything that you could do prior to Java 8. But you no longer have to write clumsy code using anonymous classes.

 The result is that your code will be clearer and more flexible. For example, using a lambda expression you can create a custom Comparator object in a more concise way.

Before:

Comparator<Apple> byWeight = new Comparator<Apple>() { public int compare(Apple a1, Apple a2){ return a1.getWeight().compareTo(a2.getWeight()); } };

After (with lambda expressions):

Comparator<Apple> byWeight = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());

Lambda Expression Syntax

Lambda expressions address the bulkiness of anonymous inner. A lambda expression is composed of three parts.

A lambda expression is composed of parameters, an arrow,

and a body.

Argument List	Arrow Token	Body
(int x, int y)	->	x + y

The body can be either a single expression or a statement block. In the expression form, the body is simply evaluated and returned. In the block form, the body is evaluated like a method body and a return statement returns control to the caller of the anonymous method. The break and continue keywords are illegal at the top level, but are permitted within loops. If the body produces a result, every control path must return something or throw an exception.

Take a look at these examples:

(int x, int y) -> x + y

() -> 42

(String s) -> { System.out.println(s); }

 

The first expression takes two integer arguments, named x and y, and uses the expression form to return x+y.

The second expression takes no arguments and uses the expression form to return an integer 42.

The third expression takes a string and uses the block form to print the string to the console, and returns nothing.

Lambda Examples

Runnable Lambda

public class RunnableTest {   public static void main(String[] args) {     System.out.println("=== RunnableTest ===");        // Anonymous Runnable     Runnable r1 = new Runnable(){          @Override       public void run(){         System.out.println("Hello world one!");       }     };         // Lambda Runnable     Runnable r2 = () -> System.out.println("Hello world two!");         // Run them     r1.run();     r2.run();       } }

Comparator Lambda

In Java, the Comparator class is used for sorting collections. In the following example, an ArrayList consisting of Person objects is sorted based on surName. The following are the fields included in the Person class.

public class Person { private String givenName; private String surName; private int age; private String eMail; private String phone; private String address; }

The following code applies a Comparator by using an anonymous inner class and a couple lambda expressions.

public class ComparatorTest {  public static void main(String[] args) {        // Create List of Person         List<Person> personList1 = null;           // Sort with Inner Class     Collections.sort(personList1, new Comparator<Person>(){       public int compare(Person p1, Person p2){         return p1.getSurName().compareTo(p2.getSurName());       }     });         System.out.println("=== Sorted Asc SurName ===");     for(Person p:personList1){       System.out.println(                   "Name: " + p.getGivenName() + " " + p.getSurName());     }         // Use Lambda instead         // Print Asc     System.out.println("=== Sorted Asc SurName ===");     Collections.sort(personList1, (Person p1, Person p2) -> p1.getSurName().compareTo(p2.getSurName()));     for(Person p:personList1){ System.out.println(                   "Name: " + p.getGivenName() + " " + p.getSurName());     }         // Print Desc     System.out.println("=== Sorted Desc SurName ===");     Collections.sort(personList1, (p1,  p2) -> p2.getSurName().compareTo(p1.getSurName()));     for(Person p:personList1){ System.out.println(                   "Name: " + p.getGivenName() + " " + p.getSurName());     }       } }