src/jdbc/JdbcSqlPooledConnection.java

   1 package csql.jdbc;
   2
   3 import java.util.*;
   4 import java.sql.*;
   5 import javax.sql.*;
   6 import javax.naming.*;
   7 import java.io.*;
   8 import java.lang.*;
   9 import java.lang.Class;
  10
  11 public class JdbcSqlPooledConnection implements javax.sql.PooledConnection
  12 {
  13
  14    //To store the connection Event Listions Hash manner for faster access
  15     private Map connectionEventListeners;
  16
  17
  18    // logical connection for connenction pool
  19     private Connection logicalConn;
  20
  21
  22    // Actual or physical connection
  23     private JdbcSqlConnection physicalConn;
  24
  25
  26   //says logical connection open or close
  27    boolean isclose = true;
  28
  29    //Constructor
  30     public JdbcSqlPooledConnection(Connection connection) {
  31                 logicalConn = null;
  32                 physicalConn =(JdbcSqlConnection) connection;
  33                 connectionEventListeners = new HashMap();
  34         }
  35
  36
  37
  38
  39    //Pooled connection methods. Here connection event listener is insert into hashed map.
  40     public synchronized void addConnectionEventListener(ConnectionEventListener conEventListener)
  41     {
  42         if(connectionEventListeners != null)
  43             connectionEventListeners.put(conEventListener,conEventListener);
  44     }
  45
  46
  47
  48    //Pooled connection method. Here the connection event listioner is removed from hash map
  49    public synchronized void removeConnectionEventListener(ConnectionEventListener conEventListener)
  50    {
  51        if(connectionEventListeners != null)
  52             connectionEventListeners.remove(conEventListener);
  53    }
  54
  55
  56
  57
  58    //Pooled connection method.
  59    public synchronized Connection getConnection() throws SQLException
  60    {
  61        try{
  62            if (physicalConn == null) {
  63                System.out.println("Connection not Exit");
  64                isclose = true;
  65            }
  66
  67            if(isclose != true ||  logicalConn != null){
  68                isclose  = true;
  69                logicalConn.rollback();
  70                eventListentionMethod(true,null);
  71            }
  72            logicalConn = (Connection)physicalConn;
  73            isclose = false;
  74        } catch (SQLException exception){
  75             eventListentionMethod(false,exception);
  76             throw exception;
  77        }
  78
  79        return logicalConn;
  80    }
  81
  82   //Pooled connection method.
  83    public synchronized void close() throws SQLException {
  84                 if (physicalConn != null) {
  85                         physicalConn.close();
  86                         physicalConn = null;
  87                 }
  88                 if (connectionEventListeners != null) {
  89                         connectionEventListeners.clear();
  90                         connectionEventListeners = null;
  91                 }
  92    }
  93
  94
  95    synchronized void eventListentionMethod(boolean isclose,SQLException sqlException) {
  96        if(connectionEventListeners == null){ return; }
  97        Iterator iterater = connectionEventListeners.entrySet().iterator();
  98
  99        ConnectionEvent conEvent = new ConnectionEvent(this,sqlException);
 100        while (iterater.hasNext()) {
 101            ConnectionEventListener conEventListener = (ConnectionEventListener) ((Map.Entry)iterater.next()).getValue();
 102            if (isclose) {
 103                conEventListener.connectionClosed(conEvent);
 104            } else {
 105                conEventListener.connectionErrorOccurred(conEvent);
 106            }
 107        }
 108
 109    }
 110
 111    public void addStatementEventListener(StatementEventListener listener) {
 112    //part of JDBC4
 113    }
 114
 115
 116    public void removeStatementEventListener(StatementEventListener listener) {
 117    //part of JDBC4
 118    }
 119
 120
 121 }