An attribute is used to communicate some value from one servlet to another. Depending upon the scope of the attribute we can access the attributes at parts of the application.An attribute can be set at either of the scopes as follows :

1.Application

2.Session

3.Request

Now in order to find out which attribute/s is/are thread safe,we can ponder upon with following discussion.

1.Application Attributes : An application attribute is a value set at application level. The code to set the attribute at application level is :

getServletContext().setAttribute(“name”,”value”);

As these attributes are accessible throughout the application,any servlet or any other web entity can update or get these attributes from various parts of the application. Since application attributes can be accessed or modified by any servlet in the web application,these are not thread safe.

2.Session Attributes : A session attribute is a value set at session scope. Session is used to retain user specific data. The code to set the attribute at application level is :

req.getSession().setAttribute(“name”,”value”);

When we talk about thread safety of session attributes,at one glimpse it deceives to appear as thread safe. In cases where we have the new tab feature in the modern browsers,the same session for the web application is opened in the new tab. In such case, if session attribute are updated from one tab will be reflected in the another tab with the same session. Thus we can say that session attributes are also not thread safe.

3.Request Attributes : A request attribute is a value set at request scope.he code to set the attribute at application scope is :

req.setAttribute(“name”,”value”);

As we know that each request is a unique object , whatever attribute we set at request scope cant be updated or get from another request. Thus request attributes are thread safe.

Conclusion : Thus request attributes are thread safe and application and session attributes are not.

Related posts:

1. Types Of Attributes In Servlet Servlet Scopes And Attributes Saving Data In A Servlet Attributes Interview Question
2. Life Cycle Of A Servlet Explained Handling Servlet Life-Cycle Events Servlet Life Cycle Servlet Interview Questions Java Servlet Programming
3. How Container Does The Cookie Work in J2EE Define Cookie Cookies Explained Session In Servlet What Is Cookie How Apache Tomcat Handles Cookies Cookies Explained How Cookies Work Cookie Guide

An attribute is an object used to pass some value from one servlet to another.An attribute in a servlet can be set at various scopes depending upon the visibility in the web application.As we know that there are three scopes at servlet level in the application.Theses scopes are :

1.Request

2.Session

3.Application

An attribute can be set on either of the scopes depending on the situation we want access the attribute value either at request,session or application level.

When we want the value of an attribute o be accessed at request level we use request attributes and likewise for session and application.

Types of attributes in servlet can be explained on the basis of scope it belongs to :

1.Request Attributes

2.Session attributes

3.Application Attributes

1.Request Attributes can be set or get as demonstrated below in the code :

req.setAttribute("name","value");
req.getAttribute("name");

2.Session Attributes  can be set or get as shown below :

req.getSession(false).setAttribute("name","value");
req.getSession(false).getAttribute("name");

3.Application Attributes can be set or get as below :

getServletContext().setAttribute("name","value");
getServletContext().getAttribute("name");

Now comes the question where to use what?

Request Attributes : If we want to retain or communicate  a value across servlets where request does not change,we use request attributes.This can be the situation where include or forward is happening between the servlets in a web application.In such cases where we want to communicate a value across servlets we can use request attributes which when set from one servlet can be get in other servlets.

Session Attributes : In cases where user specific data has to be retained or communicated, we use session attributes.We use session attributes when we do not want a user’s data to be interfered by other users.It should be noted that these attributes can be retrieved  even when redirect is happening provided the session is maintained .

Application Attributes : In cases where some value has to be set at application level and all the entities in the web application can read that value we use application attributes.

Related posts:

1. Difference Between Parameters And Attributes In Servlets/JSP Parameter vs. Attribute
2. Life Cycle Of A Servlet Explained Handling Servlet Life-Cycle Events Servlet Life Cycle Servlet Interview Questions Java Servlet Programming
3. Concept Of Session In J2EE Session Tracking In J2EE Session Management Seesion Concept Servlet Basics Servlet Guide Session Tracking

An abstract class in java is a class which has at least one abstract function.

An interface in java  is an entity and not a class which has all its methods as abstract.We cannot have even one implementation of function or method in an interface in java.

An abstract class with all its methods as abstract is close to being an interface.But the concept for usage of both is polls apart in context.

An abstract class looks like :

public abstract class AbstractClassExample1{
abstract void abstractMethod();
// concrete methods are still allowed in abstract classes
void nonAbstractMethod() {
System.out.println("This is a non abstract method.");
}

Here we can see that we can have both abstract and non abstract methods in abstract class.

An interface looks like :

interface InterfaceExample{

  public void method1();
  public void method2();
  }
}

Here in the interface all the methods or functions are abstract.

All the methods in interface need to be public .

Now comes the scenario ,when to use an abstract class and when to use an interface.

Scenarios where we want re usability of some of the methods or functions and some methods or functions are left  for the client to implement as per their requirement calls for the use of an abstract class.In such cases client knows that some of the default implementation is already there and some part is up to them how to implement in the form of methods or functions.In such cases it logical to extend the concrete class from an abstract class.

Now comes the scenario where two coders are working for an application or software in which one calls the function or method  in his module which is written by another coder.If in future the first coder who writes the method or function ,for some reason changes the function signature it will hamper the code of the coder who is calling the function.To avoid these type of issues we can use interfaces.If the person who writes the method implements it with interface and the function call is also done with the reference type interlace,then both he coders know the standard to be followed in order to write or call a method.Thus in order to follow some standard we use interfaces.

Related posts:

1. Life Cycle Of A Servlet Explained Handling Servlet Life-Cycle Events Servlet Life Cycle Servlet Interview Questions Java Servlet Programming
2. Quartz Open source Scheduler Basic Schedulers in Java Install Quartz for JAva
3. Difference Between Parameters And Attributes In Servlets/JSP Parameter vs. Attribute

Statements  in JDBC are carrier for sql queries in JDBC.  Statements in JDBC are obtained from connection objects.

Connection is the handle for the session between JDBC and Database server.Without connection object we cannot have a statement object and without statement object,sql queries cannot be run at the database server side from the JDBC code.

There are three types of statements in JDBC.These are as follows :

1.Statement

2.Prepared Statement

3.Callable Statement

1.Statement : These statements are used to execute queries like select statements at the server side. Every time a statement is run it is compiled at the server (database side),it is compiled at the server side and run.

The code looks like this :

Class.forName("driver class");
Connection conn = DriverManager.getConnection("connection string","username","password");
String sql = "select * from tablename";
Statement st  = conn.createStatement(sql);
st.executeQuery();

2.Prepared Statement : These statements are used where we have to execute same query multiple number of times with small changes like update value.In such cases we do not need to compile the query again and again at the server side but we need to compile he query once and keep executing again and again at the the server side.Thus,prepared statements help in this case as these are precompiled statements which can be executed ample times thus saving time.

The code looks like this :

Class.forName("driver class");
Connection conn = DriverManager.getConnection("connection string","username","password");
String sql = "insert into tablename values (?,?,?)";
PreparedStatement pst  = conn.prepareStatement(sql);
pst.setString(1,"java");
pst.setInt(2,3);
pst.setFloat(3,3.14);
pst.executeQuery();

The ‘?’ are placeholders to feed the value to the precompiled statements.setXXX methods are used to set the values to the placeholders depending upon the  data type at the server side.In the code pst.setString(1,”java”),1 denotes the first place holder.

3.Callable Statement : These statements are used to execute stored procedures and function at the database server side.

The code looks like this :

Class.forName("driver class");
Connection conn = DriverManager.getConnection("connection string","username","password");
String sql = "{? = execute procesdureorfunctionname(?,?)}";
CallableStatement cst  = conn.prepareCall(sql);
cst.registerOutParameter(1,java.sql.Types.String);
cst.setString(2,"java");
cst.setInt(3,3);

cst.execute();
String str = cst.getString(1);

Related posts:

1. Driver Registration In JDBC JDBC Connection Using the JDBC Driver Registering the JDBC driver Registering A JDBC driver JDBC Database Connections Basics Of JDBC How To Establish A JDBC Connection
2. Life Cycle Of A Servlet Explained Handling Servlet Life-Cycle Events Servlet Life Cycle Servlet Interview Questions Java Servlet Programming
3. Transaction Locking And Isolation In JDBC Transaction isolation levels Using Transactions JDBC Isolation Example JDBC Guide Basics Of JDBC

A servlet is a java code which runs at the server side to process request and return response to the client.

In other words, a servlet is an extension to the server which processes request and returns response as an HTML page to the client. Like applets we donot have main method in a servlet. As in case of applet,its life cycle is taken care by the browser itself,similarly in case of servlet its life cycle of a servlet is managed by the server/container.

Life Cycle Of A Servlet denotes the phases it goes through. These phases are symbolized by the life cycle methods in the servlet.As server manages the Life Cycle Of A Servlet, these life cycle methods are called by the server itself. Let us have a look at different Life Cycle methods Of A Servlet. These are as follows :

1. init
2. service
3. destroy

1. init : The init method is the first Life Cycle method Of A Servlet. It is this method which after being called by the server makes a servlet eligible for being called a servlet. After the servlet class constructor is called,the init method is called by the server. The method looks like :

public void init(ServletConfig sc) throws ServletException {
  // Initialization code...
}

Here we can see that the ServletConfig object is passed to the init method. This object is created by serverand passed to the init method. Having received the ServletConfig object ,a servlet is said to be a servlet.

2. service : This life cycle method is called every time a request is sent to the servlet .This means that the servlet’s init method has been called and servlet is ready to process requests.This method looks like :

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

3.destroy : This is the last phase in the Life Cycle Of A Servlet. Before the servlet object is garbage collected at the server side this method is called to relinquish the resources at the server side. This method looks like :

public void destroy() {
    // Finalization code...
  }

It can be noted that the init method is called only once in the Life Cycle Of A Servlet, service is called as many times as many the requests are fired and destroy is called only once in the Life Cycle Of A Servlet.

Related posts:

1. How Container Does The Cookie Work in J2EE Define Cookie Cookies Explained Session In Servlet What Is Cookie How Apache Tomcat Handles Cookies Cookies Explained How Cookies Work Cookie Guide
2. ETA – Estimated Turn Around Time Planning Software Life Cycle
3. A Hello,World Servlet Servlet Tutorial Servlet Examples Run servlet on tomcat

Delegating the request from one servlet to another or transfer of excution from one servlet to another is known as request dispatching in servlet.

In another ways we can define it as interservlet communication,which means one servlet calling another servlet.This concept can be used in cases where some piece of code is needed to be written in different servlets.Thus, in such cases we can write that code in a single servlet and keep on calling that code from different servlets.

There are three ways in which request delegation can be done. These ways are as follows :

1.Include

2.Forward

3.Redirect

1. Include : This method suggests that the response from the another servlet be included in the response of the first  servlet. This is equivalent to copy pasting the response of one servlet into another.In case of inclusion,the response which the client receives is the append of both including and the included servlets.However,for the client it appears that the including servlet only has responded.Following line of code is used to include a servlet response into another servlet :

RequestDispatcher rd = request.getRequestDispatcher("url-pattern of the servlet");
rd.include(request,response);

Here RequestDispatcher object is needed .We can see that request and response objects of the first servlet are passed to the servlet which we wish to include through include method so that request remains the same and the included servlet can write to the response of the including servlet and it appears that including servlet itself has processed the request.

2. Forward : It works same as  include except for the difference that the reponse from the first servlet is flushed out and the reponse from the second servlet only is visible.Example code is :

RequestDispatcher rd = request.getRequestDispatcher("url-pattern of the servlet");
rd.forward(request,response);

Here also it appears to the client that the first servlet only has processed the request.

3. Redirect : In the case of redirect the first servlet issues a new request to a another servlet to which redirection has happened.In this case client sees a new request in the browser url bar and can realize that the response comes from the second servlet.Example code is :

response.sendRedirect("url-pattern of the servlet");

Here we can see that response object is used.This done for the reason that the issuing of the new request at the client side,in the browser url bar has to be done by the first servlet.

Related posts:

1. How To Redirect From One Servlet To Another Servlet Basics Servlet Redirect
2. how to include one servlet into another Servlet Essentials Servlet Include
3. how to forward from one servlet to another Servlet Essentials Servlet Forward

An interface links two unrelated objects.A driver in JDBC context is an interface which links java code to database for communication.

Before ever the connection is established between the java programming end and the database end,the driver needs to be registered with the JVM by the means of DriverManager class.The DriverManager class has a vector of drivers registered to it.Once the entry has been made in the vector of the DriverManager class the driver is said to be registered.Each driver has the implementation and is capable of registering itself with the DriverManager class.This implementation is written in the static initialization block of the driver class.

We know that the static initialization block for a class is executed every time we load the class in the class loader. So, in order to run the static initialization block in the class loader we need to run the following line of code so that the driver registers itself with the DriverManager class :

Class.forName("DriverClass");

We can load or compile a class in class loader by calling the Class.forName(“class name”) method of the reflection concept in java.

Now let us have a look at how  the static initialization block in the driver class looks like :

class Driver{

 static{
    --------
    DriverManager.registerDriver(Driver Class);
    ----
    ----
    ----
    }
}

The function registerDriver() of the DriverManager class takes driver class as one of the parameters and looks for an entry ofr that driver in the vector it has. If an entry is found it means that the driver is already registered and the reference is returned from the vector.UIf entry is not available in the vector,the entry is made and reference is returned.This way we say that the driver is registered and connection can be made with the database as follows :

DriverManager.getConnection("Connection String","username","password");

Here connection String is depenedent on what database we are using.A typical example is :

jdbc:postgresql://host:port/database

Here ,username and password are username and password for the database.

Related posts:

1. Transaction Locking And Isolation In JDBC Transaction isolation levels Using Transactions JDBC Isolation Example JDBC Guide Basics Of JDBC
2. Concept Of Session In J2EE Session Tracking In J2EE Session Management Seesion Concept Servlet Basics Servlet Guide Session Tracking
3. Basics of tomcat Apache-Tomcat Tutorial Download and Run Tomcat

Transaction is a set of instructions which follow atomicity,consistency,Integrity and durability.

1. Atomicity : This states that either all actions should complete or none should occur.

2. Consistency : This imposes certain business rule.

3. Integrity : This states that the two actions shall not interfere with each other or access each others data.

4. Durability : This states that the changes occurred due to a certain action or transaction must be stored in a durable persistent storage.

When we talk about the Transaction Locking And Isolation In JDBC, following are the issues we need to address when to concurrent transactions are taking place :

1. Dirty read : This happens when uncommitted data is read.Typical example is :

a. Transaction 1 inserts a row into a table.

b.Transaction 2 reads the new row.

c.Transaction 1 rolls back.

2. Non-repeatable read : This happens when data reads from the same table for the same row are not same.Typical example is

a. Transaction 1 reads a row.

b. Transaction 2 updates the row.

c. Transaction 1 reads the same row a second time and gets a different  results.

3. Phantom Read : This occurs due to appearing of new records when same query is run at different times.Typical example is :

a. Transaction 1 reads all rows that satisfy a WHERE clause.

b. Transaction 2 inserts additional rows that satisfies the WHERE clause.

c. Transaction 1 executes  the WHERE condition and picks up the additional row.

There are different transaction isolation levels used from JDBC coding to address these issues.The function to set isolation level is :

con.setTranscationIsolationLevel(intvalue);

Different integer values can be provided as follows :

0 – JDBC_TRANSACTION_NONE
1 – JDBC_TRANSACTION_READ_UNCOMMITTED
2 – JDBC_TRANSACTION_READ_COMMITTED
4 – JDBC_TRANSACTION_REPEATABLE_READ
8 – JDBC_TRANSACTION_SERIALIZABLE

Once we set the isolation levels using the above function,we can address the issues of transaction level in JDBC connection.As the isolation     level increases it gets stricter and lower level problems are also addressed.If we have set the value to 8 ,the isolation level with value lesser than 8 ,ie. 0,1,2,4, are also taken  care of.

Related posts:

1. Concept Of Session In J2EE Session Tracking In J2EE Session Management Seesion Concept Servlet Basics Servlet Guide Session Tracking
2. How Container Does The Cookie Work in J2EE Define Cookie Cookies Explained Session In Servlet What Is Cookie How Apache Tomcat Handles Cookies Cookies Explained How Cookies Work Cookie Guide
3. Constructor And Destructor In C++ Basics Of OPPS Concepts Explained

A Cookie is a key value pair primarily used by the container to pass the session id in order to maintain session between client and server. There can be user defined cookies as well to use cookie as attributes to pass values from one part of the web application to another.

The user only requests for the session,creating a session object,attaching the session id with the session object and sending it to the client side or the browser with the response is done by the server at the back end. These things the code has nothing to bother about,the code asks for the session and these things happen automatically.

The code below shows how to get a session object in servlet :

HttpSession sess = request.getSession();

With the help of the above written code,the session can be retrieved from the server.Following are the steps covered by the server as soon as this line of code executes :

1. HttpSession object is created

2. Unique Session id is created

3. A new cookie object is created.

4. Session id is associated with cookie

5. Cookie is set Into the response to be sent to client side

These are the steps involved in sending the cookie with the response if session does not exist .

The same code when executed does the work of retrieving a session object from request if it exists.If session already exists,the server finds the session id from the request(since cookie will be sent to the server from client side as part of the url).The server finds out the unique session id from the cookie and retrieves the session object with the matching Session id.

Thus all the cookie work happens behind the scene.

To know whether the session already existed or was just created,we can ask the session object itself as :

sess.isNew();

If it returns true ,it means session is created otherwise it is a preexisting session.

Related posts:

1. Concept Of Session In J2EE Session Tracking In J2EE Session Management Seesion Concept Servlet Basics Servlet Guide Session Tracking
2. Basics of tomcat Apache-Tomcat Tutorial Download and Run Tomcat
3. A Hello,World Servlet Servlet Tutorial Servlet Examples Run servlet on tomcat

Session in J2EE application is the time of interaction between the client and the server.A session in used to retain the state of a client.As we know that http is connectionless protocol,after each request and response cycle between the client and the server,the connection is broken. It seems logical to break the connection as bandwidth is an expensive resource and needs to be relinquished so that the same can be used for another request.This is the reason http is the protocol used to access the web application in any web technology.

With the advantage of releasing the bandwidth comes the issue of maintaining the session in J2EE ,as after the request response cycle,the server does not remember the client.

So some extra work is needed in order to maintain the session.

The code to get a session object in servlet is as follows :

request.getSession(TRUE);

or

request.getSession(FALSE);

The difference between the two overloaded functions is that the function with ‘ TRUE’ as parameter returns a new session object even if a session does not  exist otherwise it will return the preexisting session object but in the later case the function will return the existing session object if it exists or if not existing a null  will be returned.

As we have got the session in a servlet now,it will be lost after a request response cycle.So,in order to maintain session we need to follow either of the approaches from:

1. Hidden parameters

2. Cookies

3. URL rewriting

1. Hidden parameter : In this case we pass the session id allotted by the server to the session object via parameters

2. Cookies : In this case the browser downloads the cookies at the client side,so that it can append the session id with each request.Creating a cookie ,attaching session id to it and sending it to the client side is all done implicitly by the server as soon as we execute the code

request.getSession(TRUE/FALSE);

3. URL rewriting is something to fall upon if the browser at the client side doe snot accept cookies.In such cases we encode the URL with an extra info called sessionid as the parameter.

The code for url rewriting is as follows :

response.encodeRedirectUrl("url-pattern");

Related posts:

1. How To Redirect From One Servlet To Another Servlet Basics Servlet Redirect
2. A Hello,World Servlet Servlet Tutorial Servlet Examples Run servlet on tomcat
3. how to forward from one servlet to another Servlet Essentials Servlet Forward