ConnectionPerThreadDataSourceFilter.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.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.Savepoint;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import javax.sql.DataSource;

/**
 * Wraps another datasource for re-using already allocated thread connections.
 * Maintains one connection per thread/user name/pwd. Connection is allocated on first
 * getConnection() call. Every next call increments use counter.
 * Connection closes when it is not used (counter==0).
 *
 * @author Pavel Vlasov
 */
public class ConnectionPerThreadDataSourceFilter implements DataSource {
	
	// Key for connection without user name and password.

	private Object key = new Object();
	
	private ThreadLocal connectionTL=new ThreadLocal() {
		protected Object initialValue() {
			return new HashMap();
		}
	};
	
	private DataSource master;
	
	/**
	 * Constructor
	 * @param master Master data source
	 * @param initConnectionTransaction optional transaction to initialize connection
	 * e.g. set database schema.
	 */
	public ConnectionPerThreadDataSourceFilter(DataSource master) {
		this.master = master;
	}
				
	public int getLoginTimeout() throws SQLException {
		return master.getLoginTimeout();
	}
	
	public void setLoginTimeout(int seconds) throws SQLException {
		master.setLoginTimeout(seconds);	
	}
	
	public PrintWriter getLogWriter() throws SQLException {
		return master.getLogWriter();
	}
	
	public void setLogWriter(PrintWriter out) throws SQLException {
		master.setLogWriter(out);
	}
	
	public Connection getConnection() throws SQLException {
		Map threadMap = (Map) connectionTL.get();
		Connection ret = (Connection) threadMap.get(key);
		if (ret==null) {
			ret = new ConnectionWrapper(master.getConnection(), key, threadMap);
		}
		return ret;
	}
	
	public Connection getConnection(String user, final String password) throws SQLException {
		Collection key = new ArrayList();
		key.add(user);
		key.add(password);
		Map threadMap = (Map) connectionTL.get();
		Connection ret = (Connection) threadMap.get(key);
		if (ret==null) {
			ret = new ConnectionWrapper(master.getConnection(), key, threadMap);
		}
		return ret;
	}
	
	private class ConnectionWrapper implements Connection {
		Connection master;
		
		private ConnectionWrapper(Connection master, Object key, Map threadMap) {
			super();
			this.master = master;
			this.key = key;
			this.threadMap = threadMap;
		}
		
		public void clearWarnings() throws SQLException {
			master.clearWarnings();
		}
		public void close() throws SQLException {
			counter--;
			if (counter==0) {
				master.close();
				master = null;
				threadMap.remove(key);
			}
		}
		public void commit() throws SQLException {
			master.commit();
		}
		public Statement createStatement() throws SQLException {
			return master.createStatement();
		}
		public Statement createStatement(int resultSetType,
				int resultSetConcurrency, int resultSetHoldability)
				throws SQLException {
			return master.createStatement(resultSetType, resultSetConcurrency,
					resultSetHoldability);
		}
		public Statement createStatement(int resultSetType,
				int resultSetConcurrency) throws SQLException {
			return master.createStatement(resultSetType, resultSetConcurrency);
		}
		public boolean getAutoCommit() throws SQLException {
			return master.getAutoCommit();
		}
		public String getCatalog() throws SQLException {
			return master.getCatalog();
		}
		public int getHoldability() throws SQLException {
			return master.getHoldability();
		}
		public DatabaseMetaData getMetaData() throws SQLException {
			return master.getMetaData();
		}
		public int getTransactionIsolation() throws SQLException {
			return master.getTransactionIsolation();
		}
		public Map getTypeMap() throws SQLException {
			return master.getTypeMap();
		}
		public SQLWarning getWarnings() throws SQLException {
			return master.getWarnings();
		}
		public boolean isClosed() throws SQLException {
			return counter==0 || (master!=null && master.isClosed());
		}
		public boolean isReadOnly() throws SQLException {
			return master.isReadOnly();
		}
		public String nativeSQL(String sql) throws SQLException {
			return master.nativeSQL(sql);
		}
		public CallableStatement prepareCall(String sql, int resultSetType,
				int resultSetConcurrency, int resultSetHoldability)
				throws SQLException {
			return master.prepareCall(sql, resultSetType, resultSetConcurrency,
					resultSetHoldability);
		}
		public CallableStatement prepareCall(String sql, int resultSetType,
				int resultSetConcurrency) throws SQLException {
			return master.prepareCall(sql, resultSetType, resultSetConcurrency);
		}
		public CallableStatement prepareCall(String sql) throws SQLException {
			return master.prepareCall(sql);
		}
		public PreparedStatement prepareStatement(String sql,
				int resultSetType, int resultSetConcurrency,
				int resultSetHoldability) throws SQLException {
			return master.prepareStatement(sql, resultSetType,
					resultSetConcurrency, resultSetHoldability);
		}
		public PreparedStatement prepareStatement(String sql,
				int resultSetType, int resultSetConcurrency)
				throws SQLException {
			return master.prepareStatement(sql, resultSetType,
					resultSetConcurrency);
		}
		public PreparedStatement prepareStatement(String sql,
				int autoGeneratedKeys) throws SQLException {
			return master.prepareStatement(sql, autoGeneratedKeys);
		}
		public PreparedStatement prepareStatement(String sql,
				int[] columnIndexes) throws SQLException {
			return master.prepareStatement(sql, columnIndexes);
		}
		public PreparedStatement prepareStatement(String sql,
				String[] columnNames) throws SQLException {
			return master.prepareStatement(sql, columnNames);
		}
		public PreparedStatement prepareStatement(String sql)
				throws SQLException {
			return master.prepareStatement(sql);
		}
		public void releaseSavepoint(Savepoint savepoint) throws SQLException {
			master.releaseSavepoint(savepoint);
		}
		public void rollback() throws SQLException {
			master.rollback();
		}
		public void rollback(Savepoint savepoint) throws SQLException {
			master.rollback(savepoint);
		}
		public void setAutoCommit(boolean autoCommit) throws SQLException {
			master.setAutoCommit(autoCommit);
		}
		public void setCatalog(String catalog) throws SQLException {
			master.setCatalog(catalog);
		}
		public void setHoldability(int holdability) throws SQLException {
			master.setHoldability(holdability);
		}
		public void setReadOnly(boolean readOnly) throws SQLException {
			master.setReadOnly(readOnly);
		}
		public Savepoint setSavepoint() throws SQLException {
			return master.setSavepoint();
		}
		public Savepoint setSavepoint(String name) throws SQLException {
			return master.setSavepoint(name);
		}
		public void setTransactionIsolation(int level) throws SQLException {
			master.setTransactionIsolation(level);
		}
		public void setTypeMap(Map arg0) throws SQLException {
			master.setTypeMap(arg0);
		}
		
		int counter=1;
		Object key;
		Map threadMap;
	}
	
}