Learn Java

What's New in JAVA 8

2014-04-10T06:04:00.000-07:00

Finally Java 8 released under oracle leadership with many features and enhancements. Though some of the popular JSR's like JSR 294 (Jigsaw) are deferred again to next release, Java 8 still be the largest ever upgrade to java after it was introduced in 1996. Lets see one of those improvements.

Performance improvement of java.util.HashMap under high hash-collision conditions :

Just to give a little background :

HashMap is used to store key-value pairs in no.of buckets technically 'Entry' objects .

Entry is an inner class of HashMap. Please click here to see the source code in java 7.

Each bucket has a unique number called hash code. When you try to put a key-value pair into the map, the hashmap will look at the hash code of the key, and store the pair in the bucket of which the identifier is the hash code of the key. Let's say if hash code of two keys are same then hash-collision occurs.

Till now (prior to Java 8), hash collision is addressed by creating a linked list data structure. Here is how...

Lets see the source code of 'createEntry' method which gets called internally when you try to 'put' values into HashMap.

In Java 7:

     void createEntry(int hash, K key, V value, int bucketIndex) {
         Entry<K,V> e = table[bucketIndex];
         table[bucketIndex] = new Entry<>(hash, key, value, e);
         size++;
     }

An index will be calculated based on hash-code of key as I said earlier and It will be passed to the above method. Don't confuse with the table field which is nothing but an array of Entry objects. After finding the index, it first check the table array to find whether that position already contains an Entry object and pass the same to create new Entry object, it could be null or existing object.

Here is the Entry inner class:

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        int hash;

        Entry(int h, K k, V v, Entry<K,V> n) {
             value = v;
             next = n;
             key = k;
             hash = h;
         }
        .
        .
        .
        .
        .
    }

If it finds an Entry object in the specified index, it will move the existing entry object to next and create a new entry object with new key and value. So when ever there is hash collision, new one will be placed in the first node and the rest will be moved to next node. Like this a linked list starts growing when ever there is a hash-collision on each bucket.This is the story till Java 7.

Problem with this approach:

More the linked list size grow in a single bucket, more compares (equals) will happen while getting one of the value in the linked list. In a worst case scenario,it will be O(n). Perfect way to solve this issue is with a good hash function.

But Java 8 gets us some kind of performance improvement even if you have a bad hash function. Here is how?

Many new fields got introduced in Java 8 HashMap, TREEIFY_THRESHOLD is one of those which needs to pay attention. in Java 8, When a 'put' method is called on a HashMap, it internally calls a method called 'putVal'. It normally works the same way that the previous version of Hashmap worked like creating a linked list when a hash collision occurs.

It checks for the node count on a particular bucket on which it is trying to insert, if the node count is > TREEIFY_THRESHOLD (default is 8), new method got added 'treeifyBin' which transform all the nodes into TreeNodes, each structured similarly to those in java.util.TreeMap. It recreates that single bucket (not whole hashmap) by using the TreeNodes. 'TreeNode' is an another static inner class like 'Entry' but works like a balanced tree (red–black tree). This gives a guaranteed searching in O(log n) time.

Java 8 Source - treeifyBin () :

    final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }

Java 8 Source - TreeNode :

    static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent; // red-black tree links
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;
        TreeNode(int hash, K key, V val, Node<K,V> next) {
            super(hash, key, val, next);
        }

        final TreeNode<K,V> root() {
            for (TreeNode<K,V> r = this, p;;) {
                if ((p = r.parent) == null)
                    return r;
                r = p;
            }
        }


Now we know that the bin/bucket transforms into a balanced tree after it reaches a threshold (TREEIFY_THRESHOLD). What happens if you delete some entries from the same bucket and now the node count is less than TREEIFY_THRESHOLD value. Will it still maintain the same balanced tree? Yes, until it reaches one more threshold called 'UNTREEIFY_THRESHOLD' (default 6). If the the node count reaches UNTREEIFY_THRESHOLD value, There is one more method called 'untreeify()' which gets the same old functionality of using linked list.

While investigating all these, I found one difference between Java 7 and Java 8 implementations of HashMap (There may be many which didn't recognize). Till Java 7, When there is a hash collision, new values will be added to beginning of the list by moving the rest to next. In Java 8, new values will be added always to end of linked list as it needs to count the no.of nodes every time to treeifyBin().

Singleton Design Pattern

2014-01-16T03:36:00.000-08:00

We need to create a class which can have only one instance at any time.

Solution 1:

      public class MySingleton {  
           private static MySingleton singleton= new MySingleton();  
           private MySingleton(){ System.out.println( "Object Created" ); }  
           public static MySingleton getMySingleton(){  
                return singleton;  
           }  
      }

Let's create the object when we need it, not at the time of loading the class.

Solution 2(with Lazy loading):

      public class MySingleton {             // Line : 1  
           private static MySingleton singleton=null;          // Line : 2  
           private MySingleton(){ System.out.println( "Object Created" ); } // Line : 3  
           public static MySingleton getMySingleton(){          // Line : 4  
                if(singleton == null)                              // Line : 5  
                {  
                     singleton = new MySingleton();               // Line : 6  
                }  
                return singleton;                                   // Line : 7  
           }  
      }

When multiple threads reach "Line : 5" at the same time, multiple objects can be created.

Solution 3: Using synchronized method

      public class MySingleton {  
           private static MySingleton singleton=null;  
           private MySingleton(){ System.out.println( "Object Created" ); }  
           public static synchronized MySingleton getMySingleton(){  
                if(singleton == null)  
                {  
                     singleton = new MySingleton();  
                }  
                return singleton;  
           }  
      }

Even to check the 'not null' condition, all threads need to wait, to acquire lock on that class. As the method is synchronized, we are paying the cost of synchronization for every thread invocation of the method, even though it is only required on the first thread invocation.
synchronize only the instance creation not the whole method.

Solution 4: Using synchronized block

      public class MySingleton {                                                       // Line : 1  
           private static MySingleton singleton=null;                              // Line : 2  
           private MySingleton(){ System.out.println( "Object Created" ); }     // Line : 3  
           public static MySingleton getMySingleton(){                              // Line : 4  
                if(singleton == null)                                                  // Line : 5  
                {  
                     synchronized (MySingleton.class) {                              // Line : 6  
                          singleton = new MySingleton();                              // Line : 7  
                     }  
                }  
                return singleton;                                                       // Line : 8  
           }  
      }

There is a problem in the above solution. Let's say there are two threads A and B. Thread A and thread B executes "Line: 5" at the same time. As the singleton object is yet to be instantiated, both satisfies the null check and enters into "Line: 6". As we are using synchronized block here, only one thread i.e. first thread (say Thread A) gets the lock on class and creates the singleton object, Thread B wait outside at "Line:6" until Thread A releases the lock. Once it releases the lock, Thread B also gets the lock and creates one more object. It can be resolved by checking null one more time inside the synchronized block.

Solution 5: Using Double-checked locking

 public class MySingleton {  
           private static MySingleton singleton=null;  
           private MySingleton(){ System.out.println( "Object Created" ); }  
           public static MySingleton getMySingleton(){  
                if(singleton == null)  
                {  
                     synchronized (MySingleton.class) {  
                          if(singleton == null)  
                          {  
                               singleton = new MySingleton();  
                          }  
                     }  
                }  
                return singleton;  
           }  
      }

It looks like, it is a perfect solution. No,it is not.

Note : Our Java compiler is free to reorder the instructions.

Let's say there are two threads A and B.Imagine that thread A is inside the synchronized block, executing the statement singleton = new MySingleton(); while thread B is just entering getMySingleton(). Consider the effect on memory of this initialization. Memory for the new MySingleton object will be allocated; the constructor for MySingleton will be called, initializing the member fields of the new object; and the field singleton of MySingleton will be assigned a reference to the newly created object.

However, since thread B is not executing inside a synchronized block, it may see these memory operations in a different order than the one thread A executes. It could be the case that B sees these events in the following order (and the compiler is also free to reorder the instructions like this): allocate memory, assign reference to singleton, call constructor. Suppose thread B comes along after the memory has been allocated and the singleton field is set, but before the constructor is called. It sees that singleton is not null, skips the synchronized block, and returns a reference to a partially constructed singleton! Needless to say, the result is neither expected nor desired.

Reference:: From JavaWorld

Solution 6: Using Volatile

volatile ensures that the system will not allow a write of a volatile to be reordered with respect to any previous read or write, and a read of a volatile cannot be reordered with respect to any following read or write

 public class MySingleton {  
           private static volatile MySingleton singleton=null;  
           private MySingleton(){ System.out.println( "Object Created" ); }  
           public static MySingleton getMySingleton(){  
                if(singleton == null)  
                {  
                     synchronized (MySingleton.class) {  
                          if(singleton == null)  
                          {  
                               singleton = new MySingleton();  
                          }  
                     }  
                }  
                return singleton;  
           }  
      }

Usually you sould not implement eaither Serializable or Cloneable while wrinting a singleton class.
Even if your singleton class implments Cloneable, here is how you can still make sure that there will be only one object for your single tom class.
Just override the clone method to throw an exception like below.

Solution 7: can't be cloned.

      public class MySingleton implements Cloneable {  
           private static volatile MySingleton singleton=null;  
           private MySingleton(){ System.out.println( "Object Created" ); }  
           public static MySingleton getMySingleton(){  
                if(singleton == null)  
                {  
                     synchronized (MySingleton.class) {  
                          if(singleton == null)  
                          {  
                               singleton = new MySingleton();  
                          }  
                     }  
                }  
                return singleton;  
           }  
           @Override  
        protected Object clone() throws CloneNotSupportedException {  
          throw new CloneNotSupportedException("Cloning of this class is not allowed");   
        }  
      }

Sometimes in distributed systems, we need to implement Serializable interface in Singleton class so that we can store it’s state in file system and retrieve it at later point of time. Here is a small singleton class that implements Serializable interface also.

To make a singleton class serializable, it is not sufficient merely to add implements Serializable to its declaration. To maintain the singleton guarantee, you have to declare all instance fields transient and provide a readResolve method. Otherwise, each time a serialized instance is deserialized, a new instance will be created
readResolve works only when all fields are transient.

Solution 8: using readResolve().

 import java.io.ObjectStreamException;  
      import java.io.Serializable;  
      public class MySingleton implements Cloneable,Serializable {  
           private static volatile MySingleton singleton=null;  
           private MySingleton(){ System.out.println( "Object Created" ); }  
           public static MySingleton getMySingleton(){  
                if(singleton == null)  
                {  
                     synchronized (MySingleton.class) {  
                          if(singleton == null)  
                          {  
                               singleton = new MySingleton();  
                          }  
                     }  
                }  
                return singleton;  
           }  
           @Override  
        protected Object clone() throws CloneNotSupportedException {  
          throw new CloneNotSupportedException("Cloning of this class is not allowed");   
        }  
           protected Object readResolve() throws ObjectStreamException {  
             return singleton;  
           }  
      }

After all here is the new simple singleton which can handle lazy inititialization, serialization and they are thread safe. Newly introduced in JAVA 1.5.

Solution 9: using ENUM.

public class MySingleton { private static enum SingletonEnum { INSTANCE; private static final MySingleton singleton = new MySingleton(); public MySingleton getSingleton() { return singleton; } } private MySingleton(){ System.out.println( "Object Created" ); } public static MySingleton getMySingleton(){ return SingletonEnum.INSTANCE.getSingleton(); } }

Building memory efficient JAVA applications

2012-02-02T07:49:00.000-08:00

http://domino.research.ibm.com/comm/research_people.nsf/pages/sevitsky.pubs.html/$FILE/oopsla08%20memory-efficient%20java%20slides.pdf

REST IN PEACE - JAVA 6

2012-02-01T10:27:00.001-08:00

According to Oracle, Java SE 6 will no longer be publicly available after this July.

Making your PC ready to develop android apps

2012-01-14T07:16:00.000-08:00

Learning Android is one of my resolution of this year, don't know how far I going to make it...

let's start with the first step of making your PC ready with all the bunch of installations.

1) install JDK 1.6 -- download jdk 1.6

2) install Eclipse indigo 3.7.1 -- download Eclipse

3) In Eclipse go to Help --> Install new software --> Add

Enter the below details

Name : ADT (you can give what ever)

Location : https://dl-ssl.google.com/android/eclipse/

Click OK and Finish.

4) Restart Eclipse when it asked. While starting eclipse, it will prompt you to download the android SDK or you can give the location if you already have in your mechine.

Now your system is ready to develop android apps.....

Importing a Oracle Dataset with impdp

2011-12-21T22:51:00.000-08:00

1)Login to Oracle with admin user(ex: system).

2)Execute the below script.

create directory expdp_dir as '<directory where the dataset resides>';

3)exit the Oracle and run the below command.

impdp DIRECTORY=expdp_dir DUMPFILE=<dump file name> FULL=y LOGFILE=impfull.log

Note: If you have multiple dump files to import, you can use comma(,) separated file names in DUMPFILE argument.

Which one is Better Vector or SynchronizedList

2010-01-29T01:56:00.001-08:00

Vector and SynchronizedList are synchronized.

In case of vector the synchronization is at method level,

Example:

public synchronized E get(int index) {
return (E)elementData[index];
}

And in case of SynchronizedList, the statements within the methods are synchronized on the list object.

SynchronizedList is static inner class inside collections class which implements list interface and necessary methods using synchronized blocks like below.

Link to Source code

Example :

public E get(int index) {
synchronized(colobj) {return list.get(index);}
}
where colobj is the collection object.

When you do Collections.synchronizedList(new ArrayList()); you end up creating 2 instances of List. Whereas, in case of Vector, you are creating only one instance.

Choosing right collection

2010-01-29T01:44:00.001-08:00

The performance of code can be affected significantly by choosing the right collection implementation. Regarding the correct and efficient use of the Java Collection classes, a significant performance setback comes from the low utilization of implementation classes other than ArrayList and HashMap. These two implementations are used for almost everything, although different implementations would be more appropriate in some situations.

The following rules should be applied to select the appropriate collection class:

· Use ArrayList to collect data in order of occurrence (append operation only). Adding or removing elements at the bottom of the list is very fast on ArrayLists and LinkedList, but the LinkedList puts a high load on the garbage collector. This is the most common use case for lists.

· Use LinkedList to maintain lists whenever elements have to be inserted or removed at positions other than the the bottom of the list. Inserting or removing elements is very slow for ArrayLists because at average half of the elements in the list have to be shifted.

· Use LinkedList to maintain lists that contain only very few elements and have a lot of instances (for example, 5000 lists with 3 elements each). An ArrayList wastes space for unused slots, a LinkedList needs more bytes per element.

· Never use LinkedList for index-based access. Use only the implementations of List that also implement the (tag-)interface RandomAccess.

· Use Set types like HashSet and TreeSet to maintain lists that contain no duplicates (for example, observers). Searching is very quick for sets: O(log n) instead of O(n). The Set implementation LinkedHashSet combines the preservation of the insertion order of the List type with the quick lookup of the HashSet type.

The values in the table below show the memory requirements of ArrayList and LinkedList during an append-only operation. The LinkedList is faster in filling the list but takes much more time to clean up afterwards. This is due to the complex memory-structure of a linked list (many objects, many references) and therefore a lot of work for the garbage collector.

So the real behavior depends largely on the load that is put on the system. When the CPU load is not high and garbage collections are not frequent, the garbage collection overhead of the LinkedList is no problem.

When garbage collection takes place as the CPU is busy the time, the garbage collector needs to work off the memory structure (GC Full Cycle Time in the table) will be added completely to the execution time of the application, because the program execution is interrupted until the memory is acquired by the garbage collector.

Appending 10.000.000 elements to a list.

List Class	Memory	Garbage	Execution Time^[1]	GC Time²	GC Full Cycle Time³
ArrayList	45MB	89MB	620 ms	< 1ms	140 ms
LinkedList	234MB	0MB	460 ms	230 ms	1.550 ms

^[1] no garbage collections in the background

² time required to collect the objects in the list after the reference to the list has been cleared

³ time the garbage collector took to traverse the heap for releasable objects (without finding any)

Regards,

Vamsi.

Internals of JSF

2009-11-27T23:50:00.000-08:00

Once jsf project set up properly i.e entries in the web.xml,jsf related jars in lib folder of your web app(setting up jsf project) we have to create a faces-config.xml to make our set up into a full fledged jsf application.

Creating Faces-config.xml ::

In the name itself telling us that it contains all the configurations needed for all jsf pages.In fact we don't need to create the file with the same name.We can create it with any name and we have to mention same as a context parameter in the WEB.xml (setting up jsf project).Now its the time to jump into the detailed view.

Fallowing are the two main components that we use frequently.

1)Managed Beans

It represents a Java bean that will be instantiated dynamically at the run time by JSF container.We can achive inversion of control in JSF.

Ex:

Class User{

private String name;

private String Address;

//setters and getters for both properties

}

Declaration in faces-config.xml

<managed-bean>

       <managed-bean-name>Userbean</managed-bean-name>

       <managed-bean-class>User</managed-bean-class>

       <managed-bean-scope>request</managed-bean-scope>

</managed-bean>

Now I can use the bean named "Userbean" in my JSF application at any time. This is done by using JSF's Expression Language. For example to bind a JSF user interface component (UI Component) to one of the properties of my Userbean, I use the expression #{Userbean.name} as a value argument to a JSF UI Component. Here is an example of binding the firstName property of the bean to a JSF inputText (UIInput) UI Component.

The scope specifies the lifetime that bean.

 <h:inputText value="#{Userbean.name}"/>

So now upon any form submissions the value entered into the input text field will be applied to the property of my Java Bean.

2)Navigation rule

It is a place where all the navigation's in the jsf application to be declared like to what jsp has to be rendered for a specified output.

Ex:

<navigation-rule>

     <from-view-id>/pages/login.jsp</from-view-id>

     <navigation-case>

       <from-outcome>success</from-outcome>

       <to-view-id>/pages/gretting.jsp</to-view-id>

     </navigation-case>

     <navigation-case>

       <from-outcome>failure</from-outcome>

       <to-view-id>/pages/login.jsp</to-view-id>

     </navigation-case>

   </navigation-rule>

In the above rule login.jsp is a jsp page which can contain a button

or command link or any thing whose action parameter is bind with a method.

 <h:commandButton action="#{Userbean.validateUser}"  value="login" />

If we click on the above button in the jsp page then it will search for the

validateUser() method in the UserBean i.e User class and execute that method.

If the returned value is "success" then greeting.jsp is displayed.If it is "failure"

then the same page gets displayed.Of course the same page gets rendered if the returned

value of the method doesn't match with any form-outcome.

SETTING UP JSF

2009-11-21T04:10:00.000-08:00

If you have knowledge on java web applications it is very easy to set up Java server faces application.If you have normal web application follow the below steps to convert it into a jsf app.

An entry in the web application's web.xml to process all the requests by JSF controller servlet called Faces Servlet and a certain URL pattern is specified.

<servlet>
        <servlet-name>Faces Servlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup> 1 </load-on-startup>
    </servlet>

    
    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>*.faces</url-pattern>
    </servlet-mapping>

2 . A JSF configuration file faces-config.xml, which allows for configuration of all elements of JSF application.It is usually located in the web application's WEB-INF/directory.We need to keep an entry int the web.xml.We will discuss the contents later.

    <context-param>
        <param-name>javax.faces.CONFIG_FILES</param-name>
        <param-value>/WEB-INF/faces-config.xml</param-value>
    </context-param>

3 . Keep the below jar files in WEB-INF/lib.

Actual JSF libraries : jsf-api.jar and jsf-impl.jar.

Additional dependencies : commons-beanutils.jar,commons-collections.jar,commons-digester.jar and commons-logging.jar

JSTL jar files : jstl.jar and standard.jar.

With above steps our web application is properly configured for JSF.

Next step is to develop a view using JSF.

Create a page HelloJSF.jsp in the web application.
Add the below lines in the jsp page to make it JSF compliance.These are core and html tag libraries from sun's reference implementation.

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>

3. In the body of the JSP,you must add a tag.This is the base UI component .All the jsf tags must be inside this view tag.

Following are the sample files of web.xml and a jsp page ::

Web.xml

<?xml version="1.0"?>
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>

    <context-param>
        <param-name>javax.faces.CONFIG_FILES</param-name>
        <param-value>/WEB-INF/faces-config.xml</param-value>
    </context-param>

    
    <servlet>
        <servlet-name>Faces Servlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup> 1 </load-on-startup>
    </servlet>

    
    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>*.faces</url-pattern>
    </servlet-mapping>
</web-app>

JSP Page

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<html >
    <head>
        <title>My First JSF Application</title>

    </head>
    <body>
                  <f:view>
                       <h:outputText value="This is MY JSF.."/>
   </f:view>

    </body>
</html>

Once the JSP is created then we need to deploy that application in server and enter the below URL in the browser.

http://localhost:8080//HelloJSF.faces

Note :: We need to give the name as HelloJSF.faces eventhogh its exentsion is JSP to wake up the FacesServlet.The servlet container uses the servlet mapping rule to activate the JSF servlet, which strips off the faces suffix and loads the HelloJSF.jsp page.

This is all about a sample JSF application .we will discuss in depth in the later posts.

Why & What JSF?

2009-11-21T02:59:00.000-08:00

There are two technologies popular for developing web applications.They are ASP.net and J2EE.The major advantage of ASP over java is Rapid development style.Of course JAVA has its own advantages like scalability,portability,open source,platform independent etc.Despite of all these advantages java is falling behind because of is Hard-Core coding style.

With the introduction of JSF, java brings up Rapid user interface development.We can develop web applications in JSF as fast as ASP can do.

Why JSF

MVC for web applications
Clean separation of roles like (page authors, application developers,component writers,application architects,tool vendors)
Easy to use
Extendable Component and Rendering architecture
Support for client device independence
Standard From SUN
Huge vendor and industry support
JSP and Servlet
– No built-in UI component model
Struts (I am not saying you should not use Struts)
– No built-in UI component model
– No built-in event model for UI components
– No built-in state management for UI components
– No built-in support of multiple renderers
– Not a standard (despite its popularity)
Struts and JSF can be used together

What JSF

It is a server side user interface component framework for Java technology-based web applications.

If you know about swings then we can call JSF as Swing for server side applications.

It is a component oriented and event driven framework for web applications. JSF eases the development of GUI for web applications. JSF allows the programmers to work with extensible user interfaces like buttons, text boxes, check boxes etc... Programmer writes the code for particular event such as button clicked. This makes programming much easier and now the there is no need to write request and response processing logic.

ORIGIN OF JSF

2009-11-21T01:57:00.000-08:00

Before jsf was introduced there were many frameworks which gained popularity (Spring,Struts etc).All of them offered many benefits explicitly by following MVC2 approach.Despite of those benefits they lacked something i.e a robust user-interface-oriented framework.We need better way to handle the view tier.

To address this need,several leading software vendors including SUN,IBM,Oracle and BEA met through the Java Community Process in may 2001 and given detailed specification for building J2EE thin client web applications whose primary goal is to provide a simple way to build user interfaces for java web applications.This result in Java Specification Request JSR #127.Here are the design goals of JSF taken from the java community process.

Create a standard GUI component framework which can be leveraged by development tools to make it easier for tool users to both create high quality GUIs and manage the GUI's connections to application behavior.
Define a set of simple lightweight Java base classes for GUI components, component state, and input events. These classes will address GUI lifecycle issues, notably managing a component's persistent state for the lifetime of its page.
Provide a set of common GUI components, including the standard HTML form input elements. These components will be derived from the simple set of base classes (outlined in #1) that can be used to define new components.
Provide a JavaBeans model for dispatching events from client-side GUI controls to server-side application behavior.
Define APIs for input validation, including support for client-side validation.
Specify a model for internationalization and localization of the GUI.
Automatic generation of appropriate output for the target client, taking into account all available client configuration data, such as browser version, etc.
Automatic Generation of output containing required hooks for supporting accessibility, as defined by WAI.