Java,J2ee,Hybris E-commerce suit,Apache Ofbiz ,database, E-commerce domain Experts

HashMap working concept in Java | how hashMap internally working

How HashMap works in Java or sometime how get method work in HashMap is common interview questions now days. Almost everybody who worked in Java knows what hashMap is, where to use hashMap or difference between hashtable and HashMap then why this interview question becomes so special? Because of the breadth and depth this question offers. It has become very popular java interview question in almost any senior or mid-senior level java interviews.

Questions start with simple statement

"Have you used HashMap before" or "What is HashMap? Why do we use it “
Almost everybody answers this with yes and then interviewee keep talking about common facts about hashMap like hashMap accpt null while hashtable doesn't, HashMap is not synchronized, hashMap is fast and so on along with basics like its stores key and value pairs etc.
This shows that person has used hashMap and quite familiar with the functionality HashMap offers but interview takes a sharp turn from here and next set of follow up questions gets more detailed about fundamentals involved in hashmap. Interview here you and come back with questions like

"Do you Know how hashMap works in Java” or
"How does get () method of HashMap works in Java"
And then you get answers like I don't bother its standard Java API, you better look code on java; I can find it out in Google at any time etc.
But some interviewee definitely answer this and will say "HashMap works on principle of hashing, we have put () and get () method for storing and retrieving data from hashMap. When we pass an object to put () method to store it on hashMap, hashMap implementation calls
hashcode() method hashMap key object and by applying that hashcode on its own hashing funtion it identifies a bucket location for storing value object , important part here is HashMap stores both key+value in bucket which is essential to understand the retrieving logic. if people fails to recognize this and say it only stores Value in the bucket they will fail to explain the retrieving logic of any object stored in HashMap . This answer is very much acceptable and does make sense that interviewee has fair bit of knowledge how hashing works and how HashMap works in Java.
But this is just start of story and going forward when depth increases a little bit and when you put interviewee on scenarios every java developers faced day by day basis. So next question would be more likely about collision detection and collision resolution in Java HashMap e.g

"What will happen if two different objects have same hashcode?”
Now from here confusion starts some time interviewer will say that since Hashcode is equal objects are equal and HashMap will throw exception or not store it again etc. then you might want to remind them about equals and hashCode() contract that two unequal object in Java very much can have equal hashcode. Some will give up at this point and some will move ahead and say "Since hashcode () is same, bucket location would be same and collision occurs in hashMap, Since HashMap use a linked list to store in bucket, value object will be stored in next node of linked list." great this answer make sense to me though there could be some other collision resolution methods available this is simplest and HashMap does follow this.
But story does not end here and final questions interviewer ask like

"How will you retreive if two different objects have same hashcode?”

Hmmmmmmmmmmmmm
Interviewee will say we will call get() method and then HashMap uses keys hashcode to find out bucket location and retrieves object but then you need to remind him that there are two objects are stored in same bucket , so they will say about traversal in linked list until we find the value object , then you ask how do you identify value object because you don't value object to compare ,So until they know that HashMap stores both Key and Value in linked list node they won't be able to resolve this issue and will try and fail.

But those bunch of people who remember this key information will say that after finding bucket location , we will call keys.equals() method to identify correct node in linked list and return associated value object for that key in Java HashMap. Perfect this is the correct answer.

In many cases interviewee fails at this stage because they get confused between hashcode () and equals () and keys and values object in hashMap which is pretty obvious because they are dealing with the hashcode () in all previous questions and equals () come in picture only in case of retrieving value object from HashMap.
Some good developer point out here that using immutable, final object with proper equals () and hashcode () implementation would act as perfect Java HashMap keys and improve performance of Java hashMap by reducing collision. Immutability also allows caching there hashcode of different keys which makes overall retrieval process very fast and suggest that String and various wrapper classes e.g Integer provided by Java Collection API are very good HashMap keys.

Now if you clear all this java hashmap interview question you will be surprised by this very interesting question "What happens On HashMap in Java if the size of the Hashmap exceeds a given threshold defined by load factor ?". Until you know how hashmap works exactly you won't be able to answer this question.
if the size of the map exceeds a given threshold defined by load-factor e.g. if load factor is .75 it will act to re-size the map once it filled 75%. Java Hashmap does that by creating another new bucket array of size twice of previous size of hashmap, and then start putting every old element into that new bucket array and this process is called rehashing because it also applies hash function to find new bucket location.

If you manage to answer this question on hashmap in java you will be greeted by "do you see any problem with resizing of hashmap in Java" , you might not be able to pick the context and then he will try to give you hint about multiple thread accessing the java hashmap and potentially looking for race condition on HashMap in Java.

So the answer is Yes there is potential race condition exists while resizing hashmap in Java, if two thread at the same time found that now Java Hashmap needs resizing and they both try to resizing. on the process of resizing of hashmap in Java , the element in bucket which is stored in linked list get reversed in order during there migration to new bucket because java hashmap doesn't append the new element at tail instead it append new element at head to avoid tail traversing. if race condition happens then you will end up with an infinite loop. though this point you can potentially argue that what the hell makes you think to use HashMap in multi-threaded environment to interviewer :)

I like this question because of its depth and number of concept it touches indirectly, if you look at questions asked during interview this HashMap questions has verified

Concept of hashing

Collision resolution in HashMap

Use of equals () and hashCode () method and there importance?

Benefit of immutable object?

race condition on hashmap in Java

Resizing of Java HashMap

Just to summarize here are the answers which does makes sense for above questions

How HashMAp works in Java

HashMap works on principle of hashing, we have put () and get () method for storing and retrieving object form hashMap.When we pass an both key and value to put() method to store on HashMap, it uses key object hashcode() method to calculate hashcode and they by applying hashing on that hashcode it identifies bucket location for storing value object.
While retrieving it uses key object equals method to find out correct key value pair and return value object associated with that key. HashMap uses linked list in case of collision and object will be stored in next node of linked list.
Also hashMap stores both key+value tuple in every node of linked list.

What will happen if two different HashMap key objects have same hashcode?

They will be stored in same bucket but no next node of linked list. And keys equals () method will be used to identify correct key value pair in HashMap.

In terms of usage HashMap is very versatile and I have mostly used hashMap as cache in electronic trading application I have worked . Since finance domain used Java heavily and due to performance reason we need caching a lot HashMap comes as very handy there.

JDBC Database connection pool in Spring 2.5 Framework – Code setup in Spring for connection pooling

Setting up JDBC Database Connection Pool in Spring framework is easy for any Java application, just matter of changing few configuration in spring configuration file.If you are writing core java application and not running on any web or application server like Tomcat or Weblogic, Managing Database connection pool using Apache Commons DBCP and Commons Pool along-with Spring framework is nice choice but if you have luxury of having web server and managed J2EE Container, consider using Connection pool managed by J2EE server those are better option in terms of maintenance, flexibility and also help to prevent java.lang.OutofMemroyError:PermGen Space in tomcat by avoiding loading of JDBC driver in web-app class-loader, Also keeping JDBC connection pool information in Server makes it easy to change or include settings for JDBC over SSL. In this article we will see how to setup Database connection pool in spring framework using Apache commons DBCP and commons pool.jar

This article is in continuation of my tutorials on spring framework and database like LDAP Authentication in J2EE with Spring Security and manage session using Spring security If you haven’t read those article than you may find them useful.

Spring Example JDBC Database Connection Pool
Spring framework provides convenient JdbcTemplate class for performing all Database related operation. if you are not using Hibernate than using Spring's JdbcTemplate is good option. JdbcTemplate requires a DataSource which is javax.sql.DataSource implementation and you can get this directly using spring bean configuration or by using JNDI if you are using J2EE web server or application server for managing Connection Pool. See How to setup JDBC connection Pool in tomcat and Spring for JNDI based connection pooling for more details. In order to setup Data source you will require following configuration in your applicationContext.xml (spring configuration) file:

//Datasource connection settings in Spring

</bean>

//Dao class configuration in spring

</bean>

Below configuration of DBCP connection pool will create 20 database connection as initialSize is 20 and goes up to 30 Database connection if required as maxActive is 30. you can customize your database connection pool by using different properties provided by Apache DBCP library. Above example is creating connection pool with Oracle 11g database and we are using oracle.jdbc.driver.OracleDriver comes along with ojdbc6.jar or ojdbc6_g.jar , to learn more about how to connect Oracle database from Java program see the link.
Java Code for using Connection pool in Spring
Database connection pool Spring example codeBelow is complete code example of DAO class which uses Spring JdbcTemplate to execute SELECT query against database using database connection from Connection pool. If you are not initializing Database connection pool on start-up than it may take a while when you execute your first query because it needs to create certain number of SQL connection and then it execute query but once connection pool is created subsequent queries will execute faster.

//Code for DAO Class using Spring JdbcTemplate

package com.test

import javax.sql.DataSource;

import org.log4j.Logger;

import org.log4j.LoggerFactory;

import org.springframework.jdbc.core.JdbcTemplate;

/**

* Java Program example to use DBCP connection pool with Spring framework

* @author Javin Paul

public class EmployeeDAOImpl implements EmployeeDAO {

private Logger logger = LoggerFactory.getLogger(EmployeeDAOImpl.class);

private JdbcTemplate jdbcTemplate;

public void setDataSource(DataSource dataSource) {

this.jdbcTemplate = new JdbcTemplate(dataSource);

}

@Override

public boolean isEmployeeExists(String emp_id) {

try {

logger.debug("Checking Employee in EMP table using Spring Jdbc Template");

int number = this.jdbcTemplate.queryForInt("select count(*) from EMP where emp_id=?", emp_id);

if (number > 0) {

return true;

}

} catch (Exception exception) {

exception.printStackTrace();

}

return false;

}

Dependency:

1. you need to include oracle driver jar like ojdbc_6.jar in you classpath.

2. Apache DBCP and commons pool jar in application classpath.

That's all on how to configure JDBC Database connection pool in Spring framework.

Apply Auto Refresh funtionality in JSP | Implement Automatic refresh JSP page after a givem time

Hi Everyone in my project there was requirment of Automatic refresh of JSP page after a 5 Second
I have applied below logic in JSP Page

Code :

<% // Set refresh, autoload time as 5 seconds

response.setIntHeader("Refresh", 5);

// Get current time , for testing of current time display

Calendar calendar = new GregorianCalendar();

String am_pm; int hour = calendar.get(Calendar.HOUR); int minute = calendar.get(Calendar.MINUTE); int second = calendar.get(Calendar.SECOND); if(calendar.get(Calendar.AM_PM) == 0) am_pm = "AM"; else am_pm = "PM"; String CT = hour+":"+ minute +":"+ second +" "+ am_pm; out.println("Crrent Time: " + CT + "\n");

Difference between Application Server and Web Server

Application Server vs Web Server

1. Application Server supports distributed transaction and EJB. While Web Server only supports Servlets and JSP.

2. Application Server can contain web server in them. most of App server e.g. JBoss or WAS has Servlet and JSP container.

3. Though its not limited to Application Server but they used to provide services like Connection pooling, Transaction management, messaging, clustering, load balancing and persistence. Now Apache tomcat also provides connection pooling.

4. In terms of logical difference between web server and application server. web server is supposed to provide http protocol level service while application server provides support to web service and expose business level service e.g. EJB.

5. Application server are more heavy than web server in terms of resource utilization.

Use Concurrent HashMap instead of hashtable & synchronizedMap | JDK 1.5 new features Concurrent HashMap

Use Concurrent HashMap instead of hashtable & synchronizedMap

Some of the drawbacks of Synchronized collection such as HashTable , Collections.synchronizedMap are as follows .

Synchronized collection classes such as Hashtable and the synchronized wrapper classes created by the Collections.synchronizedMap are thread safe with poor concurrency, less performance and scalabilty .

1. Poor concurrency : When these collections are accessed by two or more threads, they achieve thread safety by making the collection's data private and synchronizing all public methods so that only one thread at a time can access the collection (hashtable / synchronizedMap ) data. This leads to poor concurrency. As Single lock is used for the whole collection , multiple threads struggle for the collection wide lock which reduces the performance

2. ConcurrentModificationException :

When one thread is traversing the hashtable / Collections.synchronizedMap through an Iterator , while another thread changes it by mutative operations (put, remove , etc) , iterator implemented in the java.util collections classes fails by throwing ConcurrentModificationException . The exception occurs when the hasNext() or next() method of Iterator class is called. The same error also occurs (See Code Part 1 : ) , when elements are added in hashtable or synchronizedMap , once the iterator is constructed. While iterating the collection (hashtable) through iterator , collection / table- wide locking is required , otherwise ConcurrentModificationException is occured .

3. Scalabilty Issues :

Scalabilty is the major issue when we use synchronized collections . When the workload of the application increases , increasing the resources like processor , memory should also increase the throughtput of the application. Unfortunately , it does not happen . A scalable program can handle a proportionally larger workload with more resources. As synchronized collections synchronize on a single common lock , it restricts access to a single thread at a time, other threads are restricted to access that collections , even if the resources are available to schedule those threads.

4. Some of the common sequences of operations , such as put-if-absent (to check if an element is in the collection before adding it) or iteration , require external synchronization (i.e. client side locking ) (See Code Part 3 ) to avoid data races .

Code Part 1 :

//Map hm=Collections.synchronizedMap(new HashMap());

Map hm=new Hashtable(new HashMap());

//ConcurrentHashMap hm=new ConcurrentHashMap();

hm.put(1, "Blue");

hm.put(2, "Green");

hm.put(3, "Yellow");

Iterator entries = hm.entrySet().iterator();

hm.put(4, "Red");

hm.put(5, "Orange");

while (entries.hasNext()) {

Map.Entry entry = (Map.Entry) entries.next();

Integer key = (Integer)entry.getKey();

String value = (String)entry.getValue();

System.out.println("Key = " + key + ", Value = " + value);}

To overcome the above issues with the synchronized collections , a new version of HashMap with concurrent access has been designed that is ConcurrentHashMap. This class is packaged with java.util.concurrent in JDK 1.5)

The main purpose to create ConcurrentHashMap is to provide

1. better concurrency

2 high scalability

3. thread safe

and it supports
1. full concurrency of retrievals. Allows all readers to read the table concurrently . No lock is used for retrival operations.

2. concurrency for writes . Allows a limited number of writers to update the table concurrently

3. full thread safe .

ConcurrentHashMap can be used where more read operation is required ( i.e. traversal is the dominant operation )

How a ConcurrentHashMap is implemented ? or How it works? or how concurrency is achieved?

          Volatile fields and lock striping plays major role for to achieve concurrency .
Lock striping :   Synchronizing every method on a single lock, restricts access to a single thread at a time.   Instead of using single lock , ConcurrentHashMap uses different locking mechanism called lock striping to access the shared collection concurrently which increases the scalabilty and performance .     Using different locks to allow different threads to operate on different portions of the same data structure called lock striping. Splitting the lock into more than one improves the scalability . For example two locks allow two threads to execute concurrently instead of one.

    Lock splitting can sometimes be extended to partition locking on a variablesized set of independent objects, in which case it is called lock striping.

              Now let see that how lock striping mechanism is applied to ConcurrentHashMap . The strategy is to subdivide the collection (hashtable) into independent subsets called segments each guarded by a lock sothat each subset (itself a hashtable)   can be accessed concurrently.    It uses an array of 16 locks each of which guards 1/16 of the hash buckets. N/16 locks are used for a hashtable having N hash buckets. Hash bucket N is guarded by lock N mod 16. 16 locks allow maximum of 16 threads to modify the hashtable at same time.   Mutative operations such as put() and remove() use locks where as read operation does not use locks .

Note : The number of locks can be increased

Volatile Fields :   Some of the volatile fileds declared in the ConcurrentHashMap are

transient volatile int count;

static final class HashEntry<K,V> {

final K key;

final int hash;

volatile V value;

volatile HashEntry<K,V> next;

HashEntry(K key, int hash, HashEntry<K,V> next, V value) {

.....

}

transient volatile HashEntry<K,V>[] table;

From the source of ConcurrentHashMap

As we know , volatile field ensures visibilty i.e. one thread reads the most up-to-date value written by another thread . For example count is the volatile field which is used to track the number of elements . When one thread adds an element to the table , the count is increased by one , Similarly when one thread removes an element from the table , the count is decreased by one . Now the other threads doing many read operations get the count variable's most recent updated value.

Similarly HashEntry<K,V>[] table , value , volatile HashEntry<K,V> next fileds are declared as volatile. This ensures that all the threads see the the most recent written value of those fields at all times.

When iterating the collection (hashtable) through iterator , it does not throw ConcurrentModificationException, but the elements added or removed after the iterator was constructed may or may not be reflected . No collection / table- wide locking is required while iterating the collection.
Issue: How to protect / lock the entire collection? . There is no support for locking the entire table in a way that prevents all access. Then One way is to acquire all of the locks recursively which is costlier than using a single lock .
ConcurrentHashMap provides three new update methods:
putIfAbsent(key, value) - check if the key is in the collection before adding the specified key and associate it with the given value
replace( key, value) - Replace the existing key with given key , only if the key is mapped to given value.
remove(key, value) - Remove the key only if the key is mapped to given value.

The following program using ConcurrentHashMap helps to keep the accessed files in a cache .
Code Part 2 :

import java.util.*;

import java.util.concurrent.ConcurrentHashMap;

import java.io.*;

public class CacheUsingMap2 {

ConcurrentHashMap cache;

public CacheUsingMap2() {

cache = new ConcurrentHashMap();

}

public String getFile2(String fname) {

cache.putIfAbsent(fname, readFile(fname));

return ((myFile)cache.get(fname)).getFileData();

}

public myFile readFile(String name)

{

File file = new File(name);

String fileData="";

try {

Scanner scan = new Scanner(file);

scan.useDelimiter("\\Z");

fileData = scan.next();

} catch (FileNotFoundException e){

System.out.println(e);

}

catch ( IOException e) {

System.out.println(e);

}

return (new myFile( fileData));

}

public static void main(String args[]) {

CacheUsingMap2 cache=new CacheUsingMap2();

String filePath="D:/Files/";

System.out.println( cache.getFile2(filePath+"k.txt"));

System.out.println( cache.getFile2(filePath+"k1.txt"));

System.out.println( cache.getFile2(filePath+"k.txt"));

System.out.println( cache.getFile2(filePath+"k1.txt"));

}

class myFile {

String fileData;

public myFile(String data)

{

fileData=data;

}

public String getFileData() {

return fileData;

}

Code Part 3 :

Sample code to createt cache using Hashtable (implements put-if-absent operation) which requires client side locking

....

Hashtable cache =new Hashtable();

....

public String getFile(String fname) {

// if (cache.get(fname)==null)

if (!cache.containsKey(fname))

{

synchronized(cache)

{

cache.put(fname, readFile(fname));

}

return ((myFile)cache.get(fname)).getFileData(); }

Write a SImple Java program to determine a integer whether it is prime

Below Simple program
Write a program that repeatedly prompts the user to enter a positive integer > 1. The program should then take this integer and determine whether it is prime. (A prime integer is evenly divisible only by itself and 1.) Then display whether the integer is prime or composite (not prime). If the user enters 0, then exit from the program. Hint: Use a for loop and the mod function

package com.prime;

import java.util.Scanner;

public class PrimeTest {
public static void main(String[] args)
{
    Scanner sc= new Scanner(System.in);
    boolean value=false;
//    while ()
    int number= 2;

    if(number==0)
    {
    System.exit(1);
    }
    //System.out.println("Please Enter Number");
    while (number >0)
    {
    System.out.println("enter a positive integer > 1 : ");
    number =     sc.nextInt();
    if(number==0)
    {
        System.exit(1);

    }
    value= TestPrimeNumber(number);
    if(value=true)
    {
        System.out.println("Prime Number");
    }
    else
    {
        System.out.println("Not Prime Number");
    }

    }
    }
private static boolean TestPrimeNumber(int n)
{
    //check if n is a multiple of 2
    if (n%2==0) return false;
    //if not, then just check the odds
    for(int i=3;i*i<=n;i+=2) {
        if(n%i==0)
            return false;
    }
    return true;

}
}

TLD or attribute directive in tag file, attribute value does not accept any expressions in JSP

When i run the following simple code in eclipse with   App. Server Information : Apache Tomcat/7.0.26 , Sevlet Version : 3.0 , JSP Version : 2.1 and Java Version : 1.6.0_20

<c:forEach var="i" begin="1" end="50" step="1" >
   <c:out value="${i}"/ >
   </c:forEach >

I got the error "According to TLD or attribute directive in tag file, attribute value does not accept any expressions" . If you get the same error , making the below changes in the JSP will save your day.

Replace the line       <%@ taglib uri='http://java.sun.com/jstl/core' prefix='c'% >   in the JSP with    either

       <%@ taglib uri='http://java.sun.com/jsp/jstl/core' prefix='c'% >              OR

         <%@ taglib uri='http://java.sun.com/jstl/core_rt' prefix='c'% >


Let us see how the problem is solved .

Tag library descriptor (TLD) files play major role because it maps the tag and the tag handler class . You need to just include taglib directive in the JSP with absolute URI mentioned in the tld file sothat the page can use

the tags defined in a tag library. TLD file has various attributes to be passed to the tag handler class. One of the attribute is value which accepts value or the expression to be evaluated depending upon the node

rtexprvalue (run time expression value)   value as given below   <rtexprvalue >true </rtexprvalue > . If it is true , it accepts , the expression , otherwise not. Now let us see the reason.

Suppose you are using jstl-1.2.jar and standard-1.1.2.jar , it has three .tld files for each library
For example , core library has three tld files (c-1_0.tld ,   c-1_0-rt.tld   , c.tld ) , format library has three tld files that are fmt-1_0.tld ,   fmt-1_0-rt.tld   , fmt.tld . Similary xml , sql

library have three tld files each , functions library has only one tld file. You can see the tld files in the META-INF folder when you extract the jar files.

Now let us take the core library tld files c-1_0.tld ,   c-1_0-rt.tld   , c.tld . Each tld files have some changes . I have noticed some of the changes . Please gothrough the tld files given below which are related to

our problem

According to the old c-1_0.tld , some of the specifications are as follows
1. attribute value does not accept any runtime expressions(rt)   , 2. it uses DTD to define the struture of XML document , 3 .it uses the encoding format "ISO-8859-1" , 4. URI to identify   the tag library

descriptor (TLD) file uniquely is   http://java.sun.com/jstl/core    , 5. JSTL version 1.0   , 6. required JSP version is 1.2

Part of the tld file is given below

   <?xml version="1.0" encoding="ISO-8859-1" ? >

<!DOCTYPE taglib   PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"   "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd" >

<taglib >

.........

.........

<jsp-version >1.2 </jsp-version >

   <short-name >c </short-name >

   <uri >http://java.sun.com/jstl/core </uri >

   <description >JSTL 1.0 core library </description >

    <attribute >

         <name >value </name >

         <required >false </required >

         <rtexprvalue >false </rtexprvalue >   // false - does not accept rt expression

     </attribute >

....................

According to the   c-1_0-rt.tld file ,
1. attribute value accepts runtime expressions(rt)   , 2. URI to identify   the tag library descriptor (TLD) file is   http://java.sun.com/jstl/core_rt   , 3. JSTL version 1.0   , 4. required JSP version is 1.2

Part of the tld file is given below

<?xml version="1.0" encoding="ISO-8859-1" ? >

<!DOCTYPE taglib   PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"   "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd" >

....

......

<jsp-version >1.2 </jsp-version >

   <short-name >c_rt </short-name >

   <uri >http://java.sun.com/jstl/core_rt </uri >

   <display-name >JSTL core RT </display-name >

   <description >JSTL 1.0 core library </description >

<attribute >

         <name >value </name >

         <required >false </required >

         <rtexprvalue >true </rtexprvalue >   // true - accepts rt expression

     </attribute >

......................

According to the latest   c.tld   file ,
1. attribute value accepts any runtime expressions(rt)   , 2. it uses XSD (XML Schema)   to define the struture of XML document , 3. it uses the encoding format "UTF-8" , 4. URI to identify   the

tag library descriptor (TLD) file   is   http://java.sun.com/jsp/jstl/core    , 5. data type is fixed for most of the variables which ensures the type safe , 5. JSTL version 1.1    , 6. required JSP version is 2.0

Part of the tld file is given below

<?xml version="1.0" encoding="UTF-8" ? >

<taglib xmlns="http://java.sun.com/xml/ns/javaee"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"     version="2.1" >

.....

.....

<description >JSTL 1.1 core library </description >

   <short-name >c </short-name >

   <uri >http://java.sun.com/jsp/jstl/core </uri >

.....

    <attribute >

         <description >

   Expression to be evaluated.

         </description >

         <name >value </name >

         <required >false </required >

         <rtexprvalue >true </rtexprvalue >

         <deferred-value >

      <type >java.lang.Object </type >

         </deferred-value >

     </attribute >

...............

Now you have to decide which URI you have to use with taglib directive .

Summary to remember

JSTL 1.0 is compatible with : Servlet 2.3 , JSP 1.2 , suitable URI is http://java.sun.com/jstl/core . To accept RT expression , use http://java.sun.com/jstl/core_rt
JSTL 1.1 is compatible with Servlet 2.4 , JSP 2.0 , suitable URI is http://java.sun.com/jsp/jstl/core . To work with old .tld file , use the URI   http://java.sun.com/jstl/core_rt
JSTL 1.2 is compatible with Servlet 2.5 onwards , JSP 2.1 , suitable URI is http://java.sun.com/jsp/jstl/core .Still you have chance to work with old .tld file using the URI    http://java.sun.com/jstl/core_rt