J2EE – Jitendra Zaa

Tutorial of Simple JSP Tiles application without Struts

Jitendra — Fri, 15 Apr 2011 09:43:15 +0000

There are very few resources available on internet which explains step by step integration of tiles in simple jsp page.
Apache Tilesâ„¢ is a templating framework built to simplify the development of web application user interfaces.

Tiles allows authors to define page fragments which can be assembled into a complete page at runtime. These fragments, or tiles, can be used as simple includes in order to reduce the duplication of common page elements or embedded within other tiles to develop a series of reusable templates. These templates streamline the development of a consistent look and feel across an entire application.

Ste p1 : Download the Tiles jar file from here.

Step 2 : Add following jar files in the lib folder of the web application.

commons-beanutils-1.8.0.jar
commons-digester-2.0.jar
jcl-over-slf4j-1.5.8.jar
log4j-over-slf4j-1.6.1.jar
servlet-api.jar
slf4j-api-1.5.8.jar
slf4j-jdk14-1.5.8.jar
tiles-api-2.2.2.jar
tiles-core-2.2.2.jar
tiles-jsp-2.2.2.jar
tiles-servlet-2.2.2.jar
tiles-servlet-wildcard-2.2.2.jar
tiles-template-2.2.2.jar

Step 3: Create following jsp pages:
banner.jsp, common_menu.jsp, credits.jsp, cssPath.jsp, home_body.jsp and SideBar.jsp.

Step 4: Create a master layout page.

<%@ taglib uri="http://tiles.apache.org/tags-tiles" prefix="tiles"%>


<tiles:getAsString name="title" />

As you can see, tiles:insertAttribute tag is used. It will work as placeholder and will be replaced by actual pages at run time as per definition in “tiles-defs.xml”

Below output shows the layout.

Simple JSP Tiles without Struts

Step 5: Now create a “tiles-defs.xml” in WEB-INF Folder, which have all the configuration.

The attribute “name” defined in tag “tiles:insertAttribute” comes from above configuration file and replaced by the pages specified.

Step 6 : Now create the jsp page which uses the Tiles template defined above.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>

<%@ taglib uri="http://tiles.apache.org/tags-tiles" prefix="tiles" %>



Insert title here

Template name “myapp.homepage” is looked up into file “tiles-defs.xml” and configuration is applied at runtime as per definition.

Download the war file from here, change extension from “zip” to “war”.

Java – J2EE Interview Questions – 1

Jitendra — Fri, 15 Apr 2011 05:58:18 +0000

1. What is Generic Servlet ?
Answer : Defines a generic, protocol-independent servlet. GenericServlet implements the Servlet and ServletConfig interfaces. GenericServlet makes writing servlets easier. It provides simple versions of the lifecycle methods init and destroy. To use Protocol specific servlet like http protocol, we can use HttpServlet. Difference in HttpServlet and GenericServlet is that, HttpServlet provides few more methods like doGet and doPost. Same operations can be done in service method of generic servlet. Read Servlet Life cycle

2. Can abstract class have Constructor ?
Answer : Yes. abstract class can have a constructor.

3. We cannot instantiate the abstract class, then what is the need of constructor and how it is called.
Answer : You may have not come across this situation. but answer i very easy. If want to initialize few parameters for all the subclasses then we can use the constructor of abstract class. Constructor calling mechanism is same as normal inheritance in java. Default constructor gets called automatically and to call other constructors we have to explicitly call it by using keyword “super”.

4. Does java have virtual function ?
Answer : As such there is no keyword “virtual” present in java. but except static, final and private method all the methods are virtual bu default. Refer this article to read more on it.

5. How you will create custom tag in JSP ?
Answer :

Create tld file in “WEB-INF/tlds” folder and configure required properties.
Create a class which implements interface Tag / BodyTag or extends class TagSupport / BodyTagSupport. In that class write getter and setter for defined property. Few methods required by interface are doStartTag(), doEndTag() and release(). Read how to create custom tag in detail.

6. What is Externalization ?
Answer : Externalization is the interface provided by the JAVA which extends interface Serializable. It provides two more methods as compared to Serializable interface –

void readExternal(ObjectInput in)
void writeExternal(ObjectOutput out)

The above two methods gives the flexibility and control over how the object is serialized and deserialized. for further read refer this article.

7. What is the use of serialVersionUID in JAVA ?
Answer : Whenever object is created, one unique ID is associated with object and its implementation may defer from compiler to compiler. Whenever any object is serialized and deserealized, this variable is used to determine whether the object is in same state or not ? assignment of default serialVersionUID is mostly depends upon the methods and fields present in class and if any field is added or removed from the class definition then its serialVersionUID also changes and if the value does not match then it results in “InvalidClassException”. Because of this reason it is recommended to have a default unique serialVersionUID with each serialized undergoing class. To read in detail with example, refer this article.

8. If i don’t want to serialize some fields in class, then how to achieve this ?
Answer : This question can also be asked as “What is the transient variable ?”. “transient variables and static variables” can be used to avoid the field being serialized in Java. (As static variable is class level variable, and it does not associated at object level – it is not serialized).

9. What will happen if one of the members in the class doesn’t implement Serializable interface?
Answer : If you try to serialize an object of a class which implements Serializable, but the object includes a reference to an non- Serializable class then a “˜NotSerializableException‘ will be thrown at runtime.

10. If a class is Serializable but its super class in not, what will be the state of the instance variables inherited from super class after deserialization?
Answer : Java serialization process only continues in object hierarchy till the class is Serializable and values of the instance variables inherited from super class will be initialized by calling constructor of Non-Serializable Super class during deserialization process .

11. What is the conceptual difference between interface and abstract class ? When to use interface and abstract class ?
Answer :

Abstract class and its usage :

A class which is partially implemented and have few abstract methods are know an “abstract class“. few developers think that why anybody should create a partial implementation ? The best example i have in my mind is “DataMapper Pattern”. For the CRUD operation – open connection and close connection and sequence of save method will be known to the programmer however which query will be executed to save or retrieve differs for different object. in that case createInsertSQL() method can be made abstract and internally save() will call openConnection() and closeConnection() which is implemented. below code snap explains the save() method.

abstract public String createInsertSQL();//abstract method

public void save() //method implemented
{
     try{
          openConnection();//method implemented
          String sql = createInsertSQL(); //abstract method
          executeStatement();//method implemented
      }
      catch(SQLException ex){

     }
     finally{
        closeconnection();//method implemented
     }
}

As you can see in above code snap, only unknown implementation is the SQL Query which is made abstract and others are implemented. and therefore underlying child class must implement the method createInsertSQL() and call save().

Interface and its usage :
interface are also known as “contract”. when we know the skeleton/ structure of the class but it complete implementation differs then we must use interface. in following scenario we must use interface :

Dependency injection
Runtime polymorphism

In design pattern programming to interface is preferable rather than programming to implementation (inheritance).

12. How to iterate over keys of HashMap in JDK 4 and 5?
Answer : This is the common question asked in interview.

In JAVA 5 : we can use advance for loop as shown in above code, use map.keySet(). This will return the Set (As Keys must be unique)

In JAVA 4 : use map.keySet() and get the Iterator object using map.iterate() . then using while loop , get the value for each key.

13. What is Exception chaining and how to achieve ?
Answer : When one exception causes another exception then the second exception must print the log of the first exception also.

We can use initcause() method of the “Throwable” class to retain the cause of exception.

J2EE – Servlet , JSP , JSF and JMS Version Table

Jitendra — Wed, 13 Apr 2011 10:24:00 +0000

Hi Friends,

Below table gives the information about the versions of J2EE (Java Table Version).

	J2EE 1.2	J2EE 1.3	J2EE 1.4	JEE 5	JEE 6 new
Servlet	2.2	2.3	2.4	2.5 new	3 new
JSP	1.1	1.2	2.0 new	2.1	2.2
JSTL	-	-	1.1	1.2	1.2
Tomcat	4.x	5.x	5.x	6.x	7.x
JMS	1.0.2	1.0.2	1.1	1.1	1.1
JSF	-	-	-	1.2	2.0 new
J2EE Release Date	Dec 12, 1999	Sep 24, 2001	Nov 11, 2003	May 11 , 2006	Dec 2009
EJB	1.1	2.0	2.1	3.0	3.0
Extra Info	-	-	-	-	JDK 5 and above required

Create Servlet using Annotation – Servlet 3.0

Jitendra — Wed, 13 Apr 2011 09:53:55 +0000

Before reading this article, i will suggest readers to go through the version table of J2EE.

One of the most appraised feature of Servlet 3.0 is the support of the annotations to create the Servlet. Before this the Deployment Descriptor (web.xml) was used to create the servlet mapping , defining init parameters etc. All the settings can be now achieved without any entry in web.xml.

Prerequisite:

JDK 5.0 and above.
Tomcat 7
Eclipse 3.6 – Helios (as of now, it only supports Tomcat 7)

We will start with creating the Servlet class :

package com.g2.servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(
		name="TestServlet",
		urlPatterns={"/test","/testServlet"},
		initParams={
				@WebInitParam(name="db",value="Oracle"),
				@WebInitParam(name="jdk",value="6"),
				@WebInitParam(name="tomcat",value="7")
				}
			)
public class ServletUsingAnnotation extends HttpServlet{

	@Override
	protected void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
		PrintWriter pw = res.getWriter();

		res.setContentType("text/html");
		pw.write("Running Servlet using Annotation..");
		pw.write("
");
		pw.write("-- Init parameters --");
		pw.write("
");
		pw.write("db : "+this.getInitParameter("db"));
		pw.write("
");
		pw.write("jdk : "+this.getInitParameter("jdk"));
		pw.write("
");
		pw.write("tomcat : "+this.getInitParameter("tomcat"));
	}
}

As you can see in above code, we have used annotation “@WebServlet” to declare this class as servlet. to pass the init parameter to servlet, we have used “@WebInitParam“. Before Servlet 2.5 we were not able to specify multiple url for the same servlet. As you can see in above code, we have given two URLs for the same servlet.

Create “index.jsp” page :

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>



Creating servlet using Annotation


Servlet using Annotation

After clicking on hyperlink on page “index.jsp” Servlet will open with following output.

Running Servlet using Annotation..
— Init parameters —
db : Oracle
jdk : 6
tomcat : 7

Cause and solution of “org.hibernate.LazyInitializationException: could not initialize proxy – no Session” error

Jitendra — Tue, 22 Feb 2011 17:42:12 +0000

In Hibernate, a common error faced by lots of developer is “org.hibernate.LazyInitializationException: could not initialize proxy – no Session“. In lots of forum the answer is no answer and most of forum have answer but there is no explanation for the beginners.

First, Lets reproduce this error in Hibernate.

Assume that Hibernate configuration (hibernate.cfg.xml) and mapping file is already written.

Consider below snap of code and assume that function is written in class “DBManager”.

 public List getMessages() {
            List MessageList = new ArrayList();
            Configuration cf = new Configuration().configure();
            SessionFactory factory = cf.buildSessionFactory();
            Session session = null;
            try {
                  session = factory.openSession();
                  String SQL_QUERY = "from ChatMessage c";
                  Query query = session.createQuery(SQL_QUERY);
                  Iterator it = query.iterate();
                  while (it.hasNext()) {
                        ChatMessage c = it.next();
                        MessageList.add(c);
                         //If below line is commented then code throws an error
                        //System.out.println("In Manager - Msg - "+c.getMessage());
                  }

            } catch (Exception e) {
                  e.printStackTrace();
            } finally {
                  session.close();
            }

            return MessageList;
      }

In above code, i am trying to fetch the collection of class “ChatMessage”. In while loop, simply i am adding the object in ArrayList and at the end i am returning the List. Check that i have commented the SOP statement at the end of while loop.

Lets consider that other class is invoking this code. Code snap of other class is:

List msgList = dbManager.getMessages();
                  System.out.println(" Size : "+msgList.size());
                  for(ChatMessage chatMsg : msgList)
                  {
                        out.println(olMsg+""+chatMsg.getUserName()+""+chatMsg.getMessage()+"

");
                  }

Whenever this code executes, it will throw an error inside for loop at “chatMsg.getUserName()” because the lazy loading is true by default and as error also describes this. The best solution is to make “lazyLoad=false” in configuration file. The code will then run perfect, but why this error did come?

This error means that you’re trying to access a lazily-loaded property or collection, but the hibernate session is closed or not available . Lazy loading in Hibernate means that the object will not be populated (via a database query) until the property/collection is accessed in code. Hibernate accomplishes this by creating a dynamic proxy object that will hit the database only when you first use the object. In order for this to work, your object must be attached to an open Hibernate session throughout it’s lifecycle.

When we uncomment the SOP statement, program runs successfully, because it hits the object and therefore it initializes itself through hibernate session.

Difference in SendRedirect() and RequestDispatcher() in Servlet

Jitendra — Sat, 12 Feb 2011 19:17:14 +0000

SendRedirect

This is the method of object HttpServlerResponse.
Request is redirected to client (Browser), and it will process the new URL.
End User can see on which page, url is redirected.
In Nutshell, Processing done at client side.

RequestDispatcher

This object can be accessed from HttpServletRequest.
Servlet will internally forward the request to another servlet or jsp page.
End user don’t know that which page is processed internally.
In Nutshell, Processing done at server side.

Life Cycle of Servlet

Jitendra — Sat, 12 Feb 2011 18:29:39 +0000

Servlet is used in J2EE to create the dynamic web pages under Java Environment. Like Applets, Servlet also have init() and destroy() methods. In this article i will explain the Life cycle of servlet.

Step 1 : After Compilation of the Servlet, the class file is loaded by the loader.

Step 2 : Then the Container instantiates the Servlet class by calling default Constructor. Read this article to know more that how container works for Servlet.

Servlet Life Cycle

Step 3: At Step 2, the Servlet object is just normal java object. It is the init() method which is just called after the instantiation of object and gives the Servletness to object. Like applets, this method is called only once in life cycle. It is recommended not to override the init() method but if you want to override then read this article.

Step 4 : Then Service() method is called and this is the place where servlet spends most of its life. Each request here comes as a separate thread. This method then internally calls the doGet() or doPost() method depending upon the type of request comes.

Step 5 : destroy() method is called just before destroying the Servlet. This method should be used if any clean code needs to be run before destroying the servlet.

How container handles the Servlet request

Jitendra — Sat, 12 Feb 2011 12:32:45 +0000

1. User clicks a link that has a URL of Servlet.

Client Browse Servlet URL

2. Container (Apache Tomcat is one of the example) sees that the request is for servlet , so create two objects :
HttpServletRequest
HttpServletResponse

HttpServletRequest and HttpServletResponse

3. Container finds correct servlet on the basis of URL passed with the help deployment descriptor (web.xml) file. Creates / Allocate thread for that request and pass request and response object to servle thread.

Create Thread for Servlet

4. Container calls the servlets service() method, on the type of request, service calls doGet() or doPost() methods.

Service method of servlet

5. Lets assume that service calls the doPost() method. doPost() method generates dynamic page and add the page in response object.

Servlet - doPost - response object

6. Thread completes, container converts the response object into HttpResponse object and destroys the response and request object.

destroy response and request object

Example to Override the init() method of the servlet

Jitendra — Thu, 10 Feb 2011 20:28:00 +0000

It is not recommended to override the init() method of the servlet.

Here is an example to override init() method of servlet:

    public class BookDBServlet ... {

        private BookstoreDB books;

        public void init(ServletConfig config) throws ServletException {

            // Store the ServletConfig object and log the initialization
            super.init(config);

            // Load the database to prepare for requests
            books = new BookstoreDB();
        }
        ...
    }

you must write super.init(config) code and after that program specific logic.

Why not to write constructor in Servlet

Jitendra — Thu, 10 Feb 2011 20:24:14 +0000

Technically you can define constructors in servlet. But, the declared constructor cannot access the ServletConfig object or throw a ServletException.

Then why is it not customary to declare a constructor in a servlet? Because the init() method is used to perform servlet initialization. In JDK 1.0 (servlet were written in this version), constructors for dynamically loaded Java classes such as servlets cannot accept arguments. Therefore init() was used to initialize by passing the implemented object of ServletConfig interface and other needed parameters.
Also, Java constructors cannot be declared in interfaces. So, javax.servlet.Servlet interface cannot have a constructor that accepts a ServletConfig parameter. To overcome this, init() method is used for initialization instead of declaring a constructor.