ConnectionPerThreadDataSource.java

Violations

Source code

/*
 * hgcommons 9
 * Hammurapi Group Common Library
 * Copyright (C) 2003  Hammurapi Group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * URL: http://www.hammurapi.biz/hammurapi-biz/ef/xmenu/hammurapi-group/products/products/hgcommons/index.html
 * e-Mail: support@hammurapi.biz
*/

package biz.hammurapi.sql;

import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import javax.sql.DataSource;

import biz.hammurapi.config.Component;
import biz.hammurapi.config.ConfigurationException;

/**
 * Maintains one connection per thread. Connection is allocated on first
 * getConnection() call. Every next call increments use counter.
 * Connection closes when it is not used (counter==0) and  connectionCloseTimeout passed.
 *
 * @author Pavel Vlasov
 * @version $Revision: 1.7 $
 */
public class ConnectionPerThreadDataSource implements DataSource, Component {
	
	private String dbURL;
	private String user;
	private String password;
	
	private boolean inShutdown;
	private Collection connections=new ArrayList();
	
	private class MasterEntry {
		
		{
			synchronized (ConnectionPerThreadDataSource.this) {
				connections.add(this);
			}
		}
		
		Connection master;
		int counter;
		
		synchronized Connection getMaster() throws SQLException {
			if (master==null) {
				master=DriverManager.getConnection(dbURL, user, password);
				master.setAutoCommit(true);
				if (initConnectionTransaction!=null) {
					initConnectionTransaction.execute(new SQLProcessor(master, null));
				}
			}
			return master;
		}
		
		public void shutdown() {
			if (counter == 0) {
				if (master!=null) {
					try {
						master.close();
					} catch (SQLException e) {
						e.printStackTrace();
					}
				}
			}			
		}

		public void release() {
			counter--;
			if (inShutdown && counter ==0) {
				if (master!=null) {
					try {
						master.close();
					} catch (SQLException e) {
						e.printStackTrace();
					}
				}
			}			
		}

		public void use() {
			counter++;			
		}
		
		protected void finalize() throws Throwable {
			shutdown();
			super.finalize();
		}
	}
		
	private ThreadLocal connectionTL=new ThreadLocal() {
		protected Object initialValue() {
			return new MasterEntry();
		}
	};
	
	private Transaction initConnectionTransaction;
	private ClassLoader classLoader = getClass().getClassLoader();
	
	/**
	 * Constructor
	 * @param driverClass
	 * @param dbURL
	 * @param user
	 * @param password
	 * @throws ClassNotFoundException
	 */
	public ConnectionPerThreadDataSource(
			String driverClass, 
			String dbURL, 
			String user, 
			String password,
			Transaction initConnectionTransaction) throws ClassNotFoundException {
		//"org.hsqldb.jdbcDriver"

        Class.forName(driverClass);
		this.dbURL=dbURL;
		this.user=user;
		this.password=password;
		this.initConnectionTransaction=initConnectionTransaction;
	}
			
	/**
	 * Constructor
	 * @param driverClass
	 * @param dbURL
	 * @param user
	 * @param password
	 * @throws SQLException
	 * @throws ClassNotFoundException
	 * @throws IllegalAccessException
	 * @throws InstantiationException
	 */
	public ConnectionPerThreadDataSource(
			ClassLoader classLoader, 
			String driverClass, 
			String dbURL, 
			String user, 
			String password,
			Transaction initConnectionTransaction) throws SQLException, InstantiationException, IllegalAccessException, ClassNotFoundException {
		if (classLoader==null) {
			throw new NullPointerException("classLoader==null");
		}
		DriverManager.registerDriver((Driver) classLoader.loadClass(driverClass).newInstance());
		this.dbURL=dbURL;
		this.user=user;
		this.password=password;
		this.initConnectionTransaction=initConnectionTransaction;
		this.classLoader=classLoader;
	}
	
	private int loginTimeout;
	private PrintWriter logWriter;
	
	public int getLoginTimeout() {
		return loginTimeout;
	}
	
	public void setLoginTimeout(int seconds) {
		loginTimeout=seconds;	
	}
	
	public PrintWriter getLogWriter() throws SQLException {
		return logWriter;
	}
	
	public void setLogWriter(PrintWriter out) throws SQLException {
		logWriter=out;
	}
	
	public Connection getConnection() throws SQLException {
        return getConnection(user,password);        
	}
	
	public Connection getConnection(String user, final String password) throws SQLException {
		if (inShutdown) {
			throw new SQLException("Data source is shut down");
		}
		
		final MasterEntry me=(MasterEntry) connectionTL.get();
		final Connection master=me.getMaster();
		me.use();
		
		InvocationHandler handler=new InvocationHandler() {
			boolean closed = false;

			public Object invoke(Object proxy, Method method, Object[] arguments) throws Throwable {
				if (Connection.class.isAssignableFrom(method.getDeclaringClass())) {
					if ("close".equals(method.getName()) && method.getParameterTypes().length==0) {
						if (!closed) {
							closed=true;
							master.setAutoCommit(true);
							me.release();
						}
						return null;
					} else if (closed) {
						throw new SQLException("Connection is closed");
					} else {
						return method.invoke(master, arguments);
					}					
				} 
				
				return method.invoke(master, arguments);
			}
			
		};
		
		return (Connection) Proxy.newProxyInstance(classLoader, new Class[] {Connection.class}, handler);        
	}
	
	/**
	 * Closes all pooled (unused) connections and instructs connections being used
	 * to close immeidatly once they are released.
	 * @throws SQLException
	 */
	synchronized public void shutdown() {		
		inShutdown=true;
		Iterator it=connections.iterator();
		while (it.hasNext()) {
			((MasterEntry) it.next()).shutdown();
		}
	}
	
	protected void finalize() throws Throwable {
		shutdown();
		super.finalize();
	}
	
	/**
	 * @return connection initialization transaction
	 */
	public Transaction getInitConnectionTransaction() {
		return initConnectionTransaction;
	}

	public void setOwner(Object owner) {
		// Nothing		

	}

	public void start() throws ConfigurationException {
		// Nothing

		
	}

	public void stop() throws ConfigurationException {
		shutdown();		
	}
}