G-InfoArena will bring to you all IT related information...
from a common computer Information to a complex information all you will find it here.
G-InfoArena is setup mainly with the aim to help the people who are Novice to IT industry.
Every project that we do, there are always some common requirement, that project must need to implement. So one of the common requirement i want to discuss here is...
"duplicate form request submission"
In any project duplicate form request must be intercept and must be aborted, to avoid duplicate data or inconsistency.
In J2EE environment, we can achieve this functionality by using following resources-
Using Filter Class
Using Controller Class(Servlet)
Lets start creating.....
Presentation Tier Component (JSPs)
insertstudent.jsp
success.jsp
error.jsp
Controller Component (Filter)
DuplicateRequestInterceptor.class
StudentInsertServlet.class
Entries in Deployment Descriptor(web.xml)
web.xml
You have to include below code in all jsp page that are the part of your navigation, to stop duplicate form submission.
In java ,Class Loader is one who is responsible for loading the
corresponding class files. JVM itself not load the classes, rather
when ever it find a dependent class, it goes to classLoader as ask him
to load the corresponding class file.
Types of class Loader
In java Class Loader functionality differ for both core and J2E
There are 3 types of basic core Class Loaders-
Bootstrap ClassLoader
Extension ClassLoader
System ClassLoader
Bootstrap ClassLoader-
This is parent of all class loaders.
In java its also called as native class loader
Functions:-
Bootstrap ClassLoader load the classes that are present in
{$JAVA_HOME}/jre/lib/rt.jar , i.e it load the default
java classes (forex- java.lang.String etc.) , that are required during any
other java classes..
Bootstrap ClassLoader is specific for each platform.
It load platform dependent classes.
Extension ClassLoader-
This is parent of System ClassLoader and child of Bootstrap
ClassLoader .
Functions:-
Extension ClassLoader load the classes that are present in
{$JAVA_HOME}/jre/lib/ext folder Any class that is
found in ext folder is loaded by Extension loader.
System ClassLoader-
This is child of Extension ClassLoader and Bootstrap
ClassLoader .
Functions:-
System ClassLoader load the classes that are present in
Classpath and -cp and from classpath attribute present in manifest file.
Principle of Class Loading
In java class loading mechanism executed on the basis of 3 principle's mentioned below
By principle of Delegation
By principle of Visibility
By principle of Uniqueness
Principle of Delegation
In java when ever JVM want a class to load, it always ask System class loader
to find and load the class, but instead of looking for and loading the class,
system class loader first delegate it to its parent class loader, i.e extension class
loader. Similarly extension class loader delegate the request to its parent
i.e bootstrap loader. As bootstrap is the supreme parent it look for the
class in rt.jar and if not found throw an exception, then request comes to
extension class loader again, now it will check class in ext folder, and in
system property, if not found throw an exception, then request again comes to
system class loader, now it will check the class file in classpath and -cp. if
it finds the class it will load it else throws an exception.
Thus this complete cycle obey principle of Delegation.
Principle of Visibility
As all class loader are arranged in parent and child hierarchy,
no parent class loader can see the classes loaded by child class loader,
but vice versa is possible.
Principle of Uniqueness
It states that no two class loader can load same class.
Is principle of Uniqueness always follow??
Is really Principle of Uniqueness always follow, or there are
some ways we can violate it!!!!!!!!!!!!!!!!!!!!!!!!!.
Consider the below Scenario...
Class TestLoader
{
public static void main(String[] args) throws Exception
{
// we can create object by two ways-
Hello h=new Hello();
Hello h1=new TestLoader().getLoaderClass("Hello"); --line 4
}
// method
public Object getLoaderClass(String clsname) throws Exception
{
Object obj=Class.forName(clsname,true,this.getClass().getClassLoader());
return obj;
}
}
Suppose we have class name Hello.java, that is present in both
classpath and ext folder.
Now when main executed JVM find hello class, so he went to system class loader
and ask it to load Hello file.
System loader follow delegation principle and delegate the request,
this process goes upto to supreme parent.
As bootstrap loader will not found the classes, request again comes to
extension loader.
As class is present in ext folder, so its load the Hello class.
But again in (line number 4), we are again creating class object,
but this time we are explicitly telling to JVM to load my classes
through current class loader.
So this time the class is directly loaded by System Class Loader,
and so ,delegation principle is ignored, and now single class is loaded by
two class loader.
But behind the screen this is not happen and principle of
Uniqueness endured because of NameSpaces
Let see what is NameSpace and what is does??
Whenever a classLoader load a class, it will place that class in NameSpace
by prefixing that class with its name.(for ex- ExtensionClassLoader.Hello).
So even in above case Hello class is loaded by Extension as well
as System classLoader, they both will store as-
ExtensionClassLoader.Hello
SystemClassLoader.Hello
So both of them treated as a different class, and thus Principle of Uniqueness Obeyed.
Hierarchy of classLoaders
Phases of Class Loading
Apart from all the basic core class loader, also there are some other class loader present.
But point to remember here is functionality of Core class Loader is different from J2E class Loader.
In J2E there is dedicated class loader to load the classes. The implementation of these dedicated loader
depend upon the server vendor.
In a J2E environment we can create three types of appplication.ie...
jar(Collection of classes)
war (Collection of classes and web resource)
ear(war+jar)
jar
|-Classes
war
|-web resources
|-jar
ear
|-war
|-jar
So in J2E Environment we can say that their are basically 3 dedicated loader.
jar loader
war loader
ear loader
These loader are internally using each other. Lets take a Scenario..................
In an enterprise application their is --
'n' number of war and
'n' number of jar
Suppose we have 2 war and 1 jar in an enterprise application. So for that
their is 2 separate war class loader and 1 separate jar loader.
which implies that all war related class are loaded by separate war loader,
and all jar related classes are loaded by jar loader in this enterprise application.
Just Create two servlet in two different web application and use the
common singleton class in both servlet, and then print the hashcode for Singleton class,
u will find two different hashcode of a singleton class.
Some Facts related to class loading, and their impact
Let discuss Singleton class, and how class loading impact it..
What actually a Singleton class is?
Basic Definition (Applicable to core level):-
A class is called as Singleton only when,for that class their must be
only 1 object per JVM exist.
public class Singleton implements Cloneable {
private static Singleton instance;
private Singleton() {
// no-op
}
public static synchronized Singleton getInstance() {
if (instance == null) {
System.out.println("first time object creation");
instance = new Singleton();
}
return instance;
}
/*
* (non-Javadoc)
* @see java.lang.Object#clone()
*
* overriding clone() method and throwing CloneNotSupportedException
*/
public Object clone() throws CloneNotSupportedException
{
// return super.clone();
throw new CloneNotSupportedException("This class prohibited Cloning");
}
}
The above class will generate a single object per JVM at core level.
But if we use the same class at web application level i.e if we
use it for two separate web application , then you will find that
their will be more than 1 object for that class exist.
And the Reason behind that is the class loading mechanism of dedicated class loader in J2E.
So the more effective way to Define of Singleton Class is.............
A Singleton Class is a class that have 1 object per scope of
a dedicated class loader or application Level.
