Spring Vs Struts

Differences between Struts and Springs

Springs:

·         Dependency Injection

·         Inversion of Control

·         Transaction Management

·         Aspect Oriented Programming

·         DB Connection Control

·         Model View Controller (this is small part that is somehow comparable with Struts)

·         Spring Web flow (define control flows).

·         Spring is made up of many components, main component being the core container (Beans, BeanFactory, Application Context, etc) that provide the Dependency injection via a lightweight container, and the rest of the components (e.g. AOP, Transaction Management, etc.) are built around it.

Apache Struts is an open-source web application framework for developing Java EE web applications. It uses and extends the Java Servlet API to encourage developers to adopt a model-view-controller (MVC) architecture.

Spring is much more than Struts. Web MVC is just a small subset of the capabilities that Spring provides.

Struts is one of the first web MVC frameworks based on servlets and JSPs

Spring is a Java EE application framework based on Inversion of Control (IoC) and aspect-oriented programming (AOP).

Spring has a web MVC module that's analogous to Struts.  Spring can also use Struts as its web MVC module.

Struts are basically a request based framework while spring is a component based framework. All the benefits of struts can be achieved through spring (Spring MVC). Spring has many modules which helps you develop enterprise application with different components like ORM, AOP, MVC, and Transaction management etc., With Spring 3.0 it has an inbuilt support for restful services too. Also spring portfolio has other project which seamlessly integrates with spring like spring security (Acegi security), osgi, spring web services and all. Over all spring offers more benefits than struts in developing a quality applications by enforcing good design and decoupled components

12 BENEFITS of Spring MVC over Struts

Spring is a powerful Java application framework, used in a wide range of Java applications. It provides enterprise services to Plain Old Java Objects (POJOs). Spring uses dependency injection to achieve simplification and increase testability.

1. Spring provides a very clean division between controllers, JavaBeans models, and views.

2. Spring’s MVC is very flexible. Unlike Struts, which forces your Action and Form objects into concrete inheritance (thus taking away your single shot at concrete inheritance in Java), Spring MVC is entirely based on interfaces. Furthermore, just about every part of the Spring MVC framework is configurable via plugging in your own interface. Of course we also provide convenience classes as an implementation option.

3. Spring, like WebWork, provides interceptors as well as controllers, making it easy to factor out behavior common to the handling of many requests.

4. Spring MVC is truly view-agnostic. You don’t get pushed to use JSP if you don’t want to; you can use Velocity, XLST or other view technologies. If you want to use a custom view mechanism 

– for example, your own templating language – you can easily implement the Spring View interface to integrate it.

5. Spring Controllers are configured via IoC like any other objects. This makes them easy to test, and beautifully integrated with other objects managed by Spring.

6. Spring MVC web tiers are typically easier to test than Struts web tiers, due to the avoidance of forced concrete inheritance and explicit dependence of controllers on the dispatcher servlet.

7. The web tier becomes a thin layer on top of a business object layer. This encourages good practice. Struts and other dedicated web frameworks leave you on your own in implementing your business objects; Spring provides an integrated framework for all tiers of your application.

8. No ActionForms. Bind directly to domain objects

9. More testable code (validation has no dependency on Servlet API)

10. Struts imposes dependencies on your Controllers (they must extend a Struts class), Spring doesn’t force you to do this although there are convenience Controller implementations that you can choose to extend.

11. Spring has a well defined interface to business layer

12. Spring offers better integration with view technologies other than JSP (Velocity / XSLT / Free Marker / XL etc.)

Collection FrameWork in Java

Concrete Collections
--------------------

Concrete Collection     Implements  description

HashSet       Set                     Hashtable
TreeSet        SortedSet           Balance binary Tree
ArrayList      List                    Re-sizable array
LinkedList    List                    LinkedList
Vector          List                    re-sizable array
HashMap     Map                   hashtable
TreeMap      SortedMap        balance binary tree
HashTable    Map                  hashtable



/**
 *
 */
package com.jit;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Vector;

/**
 * @author Vinay Guntaka
 * Factors of Collection Framework to be considered
 * API
 * Synchronization
 * Data growth
 * Usage patterns
 */
public class CollectionFrameWork {

    public static void main(String[] args) {
        getHashSet();
        getTreeSet();
        getArrayList();
        getLinkedList();
        getVectorList();
        getHashMap();
        getHashTable();
        getTreeMap();
       
    }
   
    /*
     * Unordered (A HashSet use the hash function to store the values)
     * No Duplicates
     * Allow Null
     */
   
    public static void getHashSet()
    {
        Set<String> hs = new HashSet<String>();
        hs.add("Vinay");
        hs.add("Vinay");
        hs.add("Kumar");
        hs.add("Guntaka");
        hs.add(null);
        System.out.println(hs);
    }
    /*  A TreeSet is more efficient in case of search element.
     *  null throws NullPointerException
     *  By Default Sorted
     *  No Duplicates
     */
    public static void getTreeSet()
    {
        Set<String> ts = new TreeSet<String>();
        ts.add("Vinay");
        ts.add("Vinay");
        ts.add("Kumar");
        ts.add("Guntaka");
        ts.add("");
        System.out.println(ts);
       
    }
   
    /**
     * If you need to support random access, without inserting or removing
     * elements from any place other than the end, then ArrayList offers the optimal collection.
       * If, however, you need to frequently add and remove elements from the middle of the list and
     * only access the list elements sequentially, then LinkedList offers the better implementation.
     *
     */
   
    /*
     * Ordered
     * Allows Null
     * Allows Duplicates
     * Iterating from To-And-Fro Directions
     * Not Synchronized
     */
   
    public static void getArrayList(){
        List<String> al= new ArrayList<String>();
        al.add("Vinay");
        al.add(null);
        al.add("Vinay");
        al.add("Guntaka");
        System.out.println(al);
        // Iterating from Back Side
        ListIterator<String> lsitr = al.listIterator(al.size());
        while(lsitr.hasPrevious()){
            System.out.println(lsitr.previous());
        }
        // Iterating from front Side
        while(lsitr.hasNext()){
            System.out.println(lsitr.next());
        }
        al.subList(0, 2).clear();
        System.out.println(al);
    }
    /**
     * In a LinkedList, each element is linked to its previous and next element making
     * it easier to delete or insert in the middle of the list
     */
   
    public static void getLinkedList(){
        List<String> ll= new LinkedList<String>();
        ll.add("Vinay");
        ll.add(null);
        ll.add("Vinay");
        ll.add("Guntaka");
        System.out.println(ll);
       
    }
   
    /*
     * Synchronized
     */
    public static void getVectorList(){
        Vector<String> v = new Vector<String>();
        v.add("Vinay");
        v.add("Kumar");
        v.add(null);
        v.add("Guntaka");
        v.add("Guntaka");
        System.out.println(v);
       
    }
    /*
     * Key Name should be Unique
     * Unidentified Order
     * UnSynchronized
     * The values can be null.
     */
   
    public static void getHashMap(){
        Map<String,String> hm = new HashMap<String, String>();
        hm.put("FName", "Vinay");
        hm.put("MName", "Kumar");
        hm.put("LName", "Guntaka");
        hm.put("MName", null);
        System.out.println(hm);
    }
    /*
     * Key Name should be Unique
     * Does not let you have null value for key.
     * Synchronized
     */
    public static void getHashTable(){
        Map<String,Integer> ht = new Hashtable<String, Integer>();
        ht.put("FName", 100);
        ht.put("MName", 99);
        ht.put("LName", 101);
        ht.put("Name", 152);
        System.out.println(ht);
    }
    /*
     * The values can be null. But the key should be unique
     * UnSynchronized
     */
    public static void getTreeMap(){
        Map<String,Integer> tm = new TreeMap<String, Integer>();
        tm.put("FName", 100);
        tm.put("MName", 99);
        tm.put("LName", 101);
        tm.put("Name", null);
        System.out.println(tm);
    }

}

Google Maps on Android Mobile / Simulator

Loading the Google Maps on Android Mobile / Simulator

Follow the following link to generate the map key

http://code.google.com/android/add-ons/google-apis/mapkey.html


Command to load the debug.keystore

C:\Java\jre\bin>keytool.exe -list -alias androiddebugkey -keystore "C:\Documents and Settings\jit\.android\debug.keystore" -storepass android -keypass android

on Enter you will get a privateKeyEntry with Certficate FingerPrint (MD5)


Once the MD5 finger print is generated

Registering the Certificate Fingerprint with the Google Maps Service
http://code.google.com/android/maps-api-signup.html

Note: Make sure the simluator is set to Google 2.X API


Program to Load Google MAP on Android


--------------------------------------
main.xml
--------------------------------------

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<com.google.android.maps.MapView
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/webview"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:clickable="true"
        android:enabled="true"
        android:apiKey="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
    />
</LinearLayout>

----------------------------------------
AndroidManifest.xml
----------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.jit"
      android:versionCode="1"
      android:versionName="1.0">


    <application android:icon="@drawable/icon" android:label="@string/app_name">
     <uses-library android:name="com.google.android.maps" />
        <activity android:name=".GMap"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
   
 <uses-permission android:name="android.permission.INTERNET"/>
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
 
<uses-permission android:name="android.permission.ACCESS_LOCATION_EXTRA_COMMANDS"></uses-permission>

</manifest>

------------------------------------------------
GMAP.Java
-------------------------------------------------

package com.jit;
/*
 * @author: Vinay Guntaka
 */
import android.os.Bundle;
import android.view.MotionEvent;
import android.widget.Toast;

import com.google.android.maps.GeoPoint;
import com.google.android.maps.MapController;
import com.google.android.maps.MapView;

public class GMap extends com.google.android.maps.MapActivity{
    MapController mMapController;
    MapView mMapView;
    GeoPoint p;
 
   
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        mMapView = (MapView) findViewById(R.id.webview);
        mMapView.setBuiltInZoomControls(true);
     
        mMapView.setSatellite(true);
     
        mMapController = mMapView.getController();
        mMapController.setZoom(15);
        //mMapView.setSatellite(true);
        mMapView.setStreetView(true);
        String coordinates[] = {"1.352566007", "103.78921587"};
        double lat = Double.parseDouble(coordinates[0]);
        double lng = Double.parseDouble(coordinates[1]);

        p = new GeoPoint(
            (int) (lat * 1E6),
            (int) (lng * 1E6));

        mMapController.animateTo(p);
        mMapController.setZoom(17);
        mMapView.invalidate();


       /* MyOverlays myOverlays = new MyOverlays(this.getResources().getDrawable(R.drawable.icon), this);
     
        OverlayItem tempOverlayItem = new OverlayItem(new GeoPoint(17000000,78000000), "NewActivity", "Welcome to New Activity");
        tempOverlayItem.setMarker(this.getResources().getDrawable(R.drawable.icon));
     
        myOverlays.addOverlay(tempOverlayItem);
     
        mMapView.getOverlays().add(myOverlays);*/
     
     

    }
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Toast.makeText(this, "Ooops! I am touched", Toast.LENGTH_LONG).show();
        return super.onTouchEvent(event);
    }

    @Override
    protected boolean isRouteDisplayed() {
        // TODO Auto-generated method stub
        return false;
    }
 
}

------------------------------------------

Ajax Programming setup instructions

Ajax Programming :

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
 <HEAD>
  <TITLE> New Document </TITLE>
  <META NAME="Generator" CONTENT="EditPlus">
  <META NAME="Author" CONTENT="">
  <META NAME="Keywords" CONTENT="">
  <META NAME="Description" CONTENT="">
 </HEAD>
<script type="text/javascript" language="javascript">
  // function to create an XMLHttpClient in a cross-browser manner
  function getAJAXRequest() {
      var xmlhttp=null;;  
      try {
          // Mozilla / Safari / IE7
          xmlhttp = new XMLHttpRequest();
      } catch (e) {
           // IE
           var XMLHTTP_IDS = new Array('MSXML2.XMLHTTP.5.0',
                                     'MSXML2.XMLHTTP.4.0',
                                     'MSXML2.XMLHTTP.3.0',
                                     'MSXML2.XMLHTTP',
                                     'Microsoft.XMLHTTP' );
          var success = false;
          for (var i=0;i < XMLHTTP_IDS.length && !success; i++) {
              try {
                   xmlhttp = new ActiveXObject(XMLHTTP_IDS[i]);
                   success = true;
                   break;
                } catch (e) {}
          }
          if (!success) {
              return null;
          }
     }
     return xmlhttp;
 }

 function loadAjaxCall(){
   
    var http_request=getAJAXRequest();
    //open(method,url,async)    
    //Specifies the type of request, the URL, and if the request should be handled asynchronously or not.
    //method: the type of request: GET or POST
    //url: the location of the file on the server
    //async: true (asynchronous) or false (synchronous)

    var parameters="one="+FristVal+"&sec="+SecVal;

    //Note: When you use async=false, do NOT write an onreadystatechange function - just put the code after the send() statement:
    //Note: When using async=true, specify a function to execute when the response is ready in the onreadystatechange event:

    http_request.open('POST', "/projectName/SomeAction.do", false);
    http_request.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
    http_request.setRequestHeader("Content-length", parameters.length);
    http_request.setRequestHeader("Connection", "close");
    http_request.send(parameters);
   
    // here the state is synch
    // getting the response as responseText or responseXML
    document.getElementById("myDiv").innerHTML=xmlhttp.responseText;

    /*
     * Suppose if Asynch we are have to set the readyState
        // here the response is in ready state
         xmlhttp.onreadystatechange=function()
             {
                 if (xmlhttp.readyState==4 && xmlhttp.status==200)
                    {
                         document.getElementById("myDiv").innerHTML=xmlhttp.responseText;
                     }
            }
     *
     */
// onreadystatechange     Stores a function (or the name of a function) to be called automatically each time the readyState property changes
//readyState :-
//Holds the status of the XMLHttpRequest. Changes from 0 to 4:

//0: request not initialized
//1: server connection established
//2: request received
//3: processing request
//4: request finished and response is ready

//status:-
//200: "OK"
//404: Page not found

 }

</script>

 <BODY>
   
 </BODY>
</HTML>

Captcha Programming

Captcha Programming in Java



package com.jit;

import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Iterator;

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author Vinay Guntaka
 * Servlet implementation class CaptchaServlet
 */
public class CaptchaServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
     
    /**
     * @see HttpServlet#HttpServlet()
     */
    public CaptchaServlet() {
        super();
    }

    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        createCatcha(request, response);
    }

    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        createCatcha(request, response);
    }
    @SuppressWarnings("unchecked")
    protected void createCatcha(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException {

        response.setContentType("image/jpg");

         try {
            Color textColor = Color.white;
            Font textFont = new Font("Georgia", Font.PLAIN, 18);
            int charsToPrint = 6;
            int width = 125;
            int height = 28;
            float horizMargin = 20.0f;
            float imageQuality = 0.95f; // max is 1.0 (this is for jpeg)
            double rotationRange = 0.7; // this is radians
            BufferedImage bufferedImage = new BufferedImage(width, height,BufferedImage.TYPE_INT_RGB);

            Graphics2D g = (Graphics2D) bufferedImage.getGraphics();

            // Draw an oval
            g.setColor(new Color(255, 153, 0));
            g.fillRect(0, 0, width, height);
            g.setColor(textColor);
            g.setFont(textFont);

            FontMetrics fontMetrics = g.getFontMetrics();
            int maxAdvance = fontMetrics.getMaxAdvance();
            int fontHeight = fontMetrics.getHeight();

            // i removed 1 and l and i because there are confusing to users...
            // Z, z, and N also get confusing when rotated
            // 0, O, and o are also confusing...
            // lowercase G looks a lot like a 9 so i killed it
            // this should ideally be done for every language...
            // i like controlling the characters though because it helps prevent
            // confusion
            String elegibleChars = "ABCDEFGHJKLMPQRSTUVWXYabcdefhjkmnpqrstuvwxy23456789";
            char[] chars = elegibleChars.toCharArray();

            float spaceForLetters = -horizMargin * 2 + width;
            float spacePerChar = spaceForLetters / (charsToPrint - 1.0f);
            StringBuffer finalString = new StringBuffer();

            for (int i = 0; i < charsToPrint; i++) {
                double randomValue = Math.random();
                int randomIndex = (int) Math.round(randomValue*(chars.length - 1));
                char characterToShow = chars[randomIndex];
                finalString.append(characterToShow);
                int charWidth = fontMetrics.charWidth(characterToShow);
                int charDim = Math.max(maxAdvance, fontHeight);
                int halfCharDim = (int) (charDim / 2);

                BufferedImage charImage = new BufferedImage(charDim, charDim,BufferedImage.TYPE_INT_ARGB);
                Graphics2D charGraphics = charImage.createGraphics();
                charGraphics.translate(halfCharDim, halfCharDim);
                double angle = (Math.random() - 0.5) * rotationRange;
                charGraphics.transform(AffineTransform.getRotateInstance(angle));
                charGraphics.translate(-halfCharDim, -halfCharDim);
                charGraphics.setColor(textColor);
                charGraphics.setFont(textFont);

                int charX = (int) (0.5 * charDim - 0.5 * charWidth);
                charGraphics.drawString("" + characterToShow,charX,
                                (int) ((charDim - fontMetrics.getAscent()) / 2 + fontMetrics
                                        .getAscent()));

                float x = horizMargin + spacePerChar * (i) - charDim / 2.0f;
                int y = (int) ((height - charDim) / 2);
                g.drawImage(charImage, (int) x, y, charDim, charDim,null, null);

                charGraphics.dispose();
            }

            // Write the image as a jpg
            Iterator iter = ImageIO.getImageWritersByFormatName("JPG");
            if (iter.hasNext()) {
                ImageWriter writer = (ImageWriter) iter.next();
                ImageWriteParam iwp = writer.getDefaultWriteParam();
                iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
                iwp.setCompressionQuality(imageQuality);
                writer.setOutput(ImageIO.createImageOutputStream(response.getOutputStream()));
                IIOImage imageIO = new IIOImage(bufferedImage, null, null);
                writer.write(null, imageIO, iwp);
            } else {
                throw new RuntimeException("no encoder found for jsp");
            }

            // let's stick the final string in the session
            request.getSession().setAttribute("captcha", finalString.toString());
            g.dispose();

        } catch (IOException ioe) {
            throw new RuntimeException("Unable to build image", ioe);
        }

    }

}

----------------------------------
Captcha.jsp

<%@page contentType="text/html" pageEncoding="UTF-8"%>


<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Captcha</title>
<link rel="stylesheet" href="style.css">
</head>
<body>
<center>
<form method="post">
<table cellspacing="15">
<tr>
<td>Are you human?</td>
<td><input type="text" name="code"></td>
</tr>

</table>

<br>
<img src="CaptchaServlet">

<br><br>
<input type="submit" value="submit">

</form>
<br><br>
<%
  String captcha = (String) session.getAttribute("captcha");
  String code = (String) request.getParameter("code");

  if (captcha != null && code != null) {

      System.out.println("Captcha Code:"+captcha);
      System.out.println("Code:"+code);

    if (captcha.equals(code)) {
      out.print("<p class='alert'>Correct</p>");
    } else {
          out.print("<p class='alert'>Incorrect</p>");
    }
  }
%>
</center>
</body>
</html>

--------------------------------
web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>Captcha</display-name>
  <welcome-file-list>
    <welcome-file>captcha.jsp</welcome-file>
  </welcome-file-list>
  <servlet>
    <description></description>
    <display-name>CaptchaServlet</display-name>
    <servlet-name>CaptchaServlet</servlet-name>
    <servlet-class>com.jit.CaptchaServlet</servlet-class>;
  </servlet>
  <servlet-mapping>
    <servlet-name>CaptchaServlet</servlet-name>
    <url-pattern>/CaptchaServlet</url-pattern>
  </servlet-mapping>
</web-app>

Configure JNDI Connection Pooling:

Configure JNDI Connection Pooling:

For establishing the connection pool i have created a dynamic web-project with SampleConn, with MySql Database and loggers. So, make sure we have the mysql.jar in tomcat working lib directory and log4j.jar in your project library.

Here i am listing out the steps to follow:

------------------------------------------------------------------------------------------
Step 1) Configure web.xml file

Here i am invoking a servlet on startup of server (GetConnPool)

---------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>SampleConn</display-name>
  <resource-ref>
    <description>DB Connection</description>
    <res-ref-name>jdbc/JIT</res-ref-name>
    <res-type>javax.sql.DataSource</res-type>
    <res-auth>Container</res-auth>
  </resource-ref>
  <servlet>
    <servlet-name>Connection</servlet-name>
    <servlet-class>com.jit.servlets.GetConnPool</servlet-class>;
    <load-on-startup>1</load-on-startup>
  </servlet>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>
----------------------------------------------------------------

Step 2) Create a context.xml in META-INF of your Project

-----------------------------------------------------------------

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

<Context privileged="true" antiResourceLocking="false"
    antiJARLocking="false" debug="1" reloadable="true" path="">
   
     <!-- maxActive: Maximum number of dB connections in pool. Make sure you
         configure your mysqld max_connections large enough to handle
         all of your db connections. Set to -1 for no limit.
         -->

    <!-- maxIdle: Maximum number of idle dB connections to retain in pool.
         Set to -1 for no limit.  See also the DBCP documentation on this
         and the minEvictableIdleTimeMillis configuration parameter.
         -->

    <!-- maxWait: Maximum time to wait for a dB connection to become available
         in ms, in this example 10 seconds. An Exception is thrown if
         this timeout is exceeded.  Set to -1 to wait indefinitely.
         -->

    <!-- username and password: MySQL dB username and password for dB connections  -->

    <!-- driverClassName: Class name for the old mm.mysql JDBC driver is
         org.gjt.mm.mysql.Driver - we recommend using Connector/J though.
         Class name for the official MySQL Connector/J driver is com.mysql.jdbc.Driver.
         -->
   
    <!-- url: The JDBC connection url for connecting to your MySQL dB.
         -->
   
   
    <Resource name="jdbc/JIT" auth="Container" type="javax.sql.DataSource"
         username="root"
         password="root" maxActive="-1" maxIdle="-1" maxWait="-1"
         driverClassName="com.mysql.jdbc.Driver"
         url="jdbc:mysql://localhost:3306/sample?autoReconnect=true"
         />
   
</Context>

--------------------------------------------------------------------

Step 3) Configure your log4j.properties file in your project source directory

--------------------------------------------------------------------

# Set root category priority to INFO and its only appender to CONSOLE.
log4j.rootCategory=DEBUG, CONSOLE
#log4j.rootCategory=INFO, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.Threshold=DEBUG
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=[%d{dd MMM yyyy HH:mm:ss}] %l - %m%n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.Threshold=DEBUG
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=[%d{dd MMM yyyy HH:mm:ss}] %l - %m%n

log4j.logger.org.apache.commons.digester.Digester=info


--------------------------------------------------------------------
Step 4)  GetConnPool.java
Here in the init() i am invoking & closing the connection

---------------------------------------------------------------------
package com.jit.servlets;
/**
 * @author Vinay Guntaka
 */
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.jit.connections.ConnectionUtil;

/**
 * Servlet implementation class GetConnPool
 */
public class GetConnPool extends HttpServlet {
    private static final long serialVersionUID = 1L;
      
    /**
     * @see HttpServlet#HttpServlet()
     */
    public GetConnPool() {
        super();
        // TODO Auto-generated constructor stub
    }
     @Override
    public void init() throws ServletException {
        // TODO Auto-generated method stub
        super.init();
       
        ConnectionUtil.closeConnection(ConnectionUtil.getConnection());
    }

    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
    }

    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
    }

}

------------------------------------------------
Step 5) ConnectionUtil.Java

This is the main program that we are fetching the JNDI Connection Pool Object
------------------------------------------------
package com.jit.connections;
/**
 * @author Vinay Guntaka
 */
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;

import org.apache.log4j.Logger;

public class ConnectionUtil
{
    //Initlizing the Logger
    private static final Logger logger = Logger.getLogger(ConnectionUtil.class);
   
    public static Connection getConnection() {
        Connection conn = null;
        try {
            Context initCtx = new InitialContext();
            Context envCtx = (Context) initCtx.lookup("java:comp/env");
            DataSource ds = (DataSource) envCtx.lookup("jdbc/JIT");
            conn = ds.getConnection();
            if (conn != null) {
                logger.info("Successfully Obtained Connection From ConnectionPool");
            }
            return conn;
        } catch (SQLException se) {
            logger.error(se.getMessage());
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
        return conn;
    }
    public static Connection closeConnection(Connection conn){
        try {
            if(conn != null){
                conn.close();
                conn = null;
                logger.info("Successfully Closed Connection From ConnectionPool");
               
            }
        } catch (SQLException se) {
            logger.error(se.getMessage());
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
        return conn;
    }

   
}
----------------------------------------------------------------------

Retrieving multiple result sets from a stored procedure in a JDBC application

Hello,

Retrieving multiple result sets and OUT Parameters by passing IN Parameter from a stored procedure in a JDBC application.

Connection File:

package com.jit;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
 * @author Vinay Guntaka
 * Retrieving multiple result sets from a stored procedure in a JDBC application
 * All Connections are Configured in this Class
 */
public class ConnectionUtil {
  

    public static Connection closeConnection(Connection conn){
        try {
            if(conn != null){
                conn.close();
                conn = null;
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return conn;
    }

    public static CallableStatement closeCallableStatement(CallableStatement clst){
        try{
            if(clst !=null){
                clst.close();
                clst = null;
            }
            }catch (SQLException e) {
                System.err.println(e.getMessage());
            }
            return clst;
        }
      
  

    public static ResultSet closeResultSet(ResultSet resultSet){
        try {
            if(resultSet != null){
                resultSet.close();
                resultSet = null;
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

        return resultSet;
    }

  

    public static Connection getLocalConnection() {
        Connection conn = null;
        try {
          
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            String url = "jdbc:mysql://localhost:3306/sample";
            conn = DriverManager.getConnection(url, "root", "root");

            if (conn != null) {
                System.out.println("Successfully Obtained Connection From ConnectionPool");
            }
            return conn;
        } catch (SQLException se) {
            System.out.println(se.getMessage());
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return conn;
    }
}


Main Program To Execute Procedure:

package com.jit;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Types;
/**
 * @author Vinay Guntaka
 * We are Fetching the Results from MySQL Procedure by passing
 * one IN Param and fetching One OUT Param with Multiple Result sets.
 */
public class CallProcedure {
    public static void main(String[] args) {
        Connection conn =null;
        CallableStatement callStmt = null;
        ResultSet rs =null;
      
        try {
            conn = ConnectionUtil.getLocalConnection();
            callStmt = conn.prepareCall("call proc_getData(?,?)");
            //Passing param to Execute First Query
            callStmt.setInt(1, 22);
            //Registering the Out Parameter
            callStmt.registerOutParameter(2,Types.VARCHAR);
            //Fetching the First RS of OUT Param
            callStmt.execute();
            String outParam = callStmt.getString(2);           ; // OUT parameter
            System.out.println("First Result Set Out Param:-"+outParam);
            //Fetching the Second Result Set from Procedure
            rs = callStmt.executeQuery();
            while(rs.next()){
                System.out.println("Second Query Result Set");
                System.out.println(rs.getString(1));
                System.out.println(rs.getString(2));
                System.out.println(rs.getString(3));
                System.out.println(rs.getString(4));
                System.out.println(rs.getString(5));
            }
            //Checking is there any more result sets
            if(callStmt.getMoreResults())
            {
                System.out.println("One More Result Set is there");
                //Fetching the Thrid Result Set from the Procedure
                rs = callStmt.executeQuery();
                while(rs.next()){
                    System.out.println("Thrid Query Result Set");
                    System.out.println(rs.getString(1));
                    System.out.println(rs.getString(2));
                    System.out.println(rs.getString(3));
                    System.out.println(rs.getString(4));
                    System.out.println(rs.getString(5));
                }
            }else
            {
                System.out.println("No More Results Sets");
            }
        } catch (Exception e) {
            System.err.println(e.getMessage());
        }finally
        {  
            //Closing all connections
            ConnectionUtil.closeConnection(conn);
            ConnectionUtil.closeCallableStatement(callStmt);
            ConnectionUtil.closeResultSet(rs);
        }
      
    }
}

Here is the procedure:

DELIMITER $$

DROP PROCEDURE IF EXISTS `sample`.`proc_getData`$$

CREATE DEFINER=`root`@`localhost` PROCEDURE `proc_getData`(in user_id int,out user_name varchar(64))
BEGIN
    select user_name from users where id=user_id into user_name ;
    select * from employee;
    select * from users;
   
    END$$

DELIMITER ;