• Home
• com.gitee.l0km
• sql2java-manager
• 5.3.3
• source code
• Manager.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

gu.sql2java.manager.Manager Maven / Gradle / Ivy

package gu.sql2java.manager;

import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DatabaseMetaData;

import static com.google.common.base.MoreObjects.firstNonNull;
import static com.google.common.base.Preconditions.*;
import static gu.sql2java.SimpleLog.*;
import static gu.sql2java.utils.JDBCUtility.getJavaClass;

import java.math.BigDecimal;
import java.net.URL;
import java.nio.ByteBuffer;
import java.sql.PreparedStatement;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicLong;

import javax.sql.DataSource;

import com.google.common.base.Strings;
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.vividsolutions.jts.geom.Geometry;
import com.vividsolutions.jts.io.ParseException;

import gu.sql2java.BaseBean;
import gu.sql2java.BaseRow;
import gu.sql2java.Constant;
import gu.sql2java.ListenerContainer;
import gu.sql2java.RowMetaData;
import gu.sql2java.SqlRunner;
import gu.sql2java.TableManager;
import gu.sql2java.UnnameRow;
import gu.sql2java.UnnameRowMetaData;
import gu.sql2java.ListenerContainer.FireType;
import gu.sql2java.TableManager.Action;
import gu.sql2java.exception.DaoException;
import gu.sql2java.exception.DataAccessException;
import gu.sql2java.exception.RuntimeDaoException;
import gu.sql2java.geometry.GeometryDataCodec;
import gu.sql2java.geometry.GeometryDataCodecs;
import gu.sql2java.manager.c3p0.C3p0DataSourceFactory;
import gu.sql2java.manager.druid.DruidDataSourceFactory;
import gu.sql2java.manager.parser.ParserSupport;
import gu.sql2java.manager.parser.SqlSyntaxNormalizer;
import gu.sql2java.manager.parser.SqlSyntaxNormalizers;
import gu.sql2java.manager.parser.StatementCache;
import gu.sql2java.manager.sqlite.SqliteDataSourceFactory;
import gu.sql2java.pagehelper.Page;
import gu.sql2java.pagehelper.PageHelper;

import static gu.sql2java.utils.ColumnTransformer.COLUMN_TRANSFORMER;

/**
 * The Manager provides connections and manages transactions transparently.
 * 

 * It is a singleton, you get its instance with the getInstance() method.
 * All of the XxxxManager classes use the Manager to get database connections.
 * Before doing any operation, you must pass either a
 * datasource or a jdbc driver/url/username/password.
 * @author guyadong
 */
final class Manager implements Constant,SqlRunner
{
	static final Map managers = new Hashtable<>();
	static final Map aliasManagers = new Hashtable<>();

    private static class Singleton{
        private static final Manager INSTANCE = new Manager();
    }
    private final ThreadLocal transactionConnection = new ThreadLocal();
    private final ThreadLocal localConnection = new ThreadLocal();
    private final ThreadLocal nestedCount = new ThreadLocal();

    private volatile DataSource dataSource = null;
    private volatile AutoKeyRetrieveType  retrieveType;
    private volatile ResultSetTypeCast extensiveResultSetTypeCast;
    private volatile DataSourceFactory dataSourceFactory;
    private volatile String productName;
    private volatile DatabaseMetaData databaseMetaData;
    private volatile StatementCache statementCache;
    private volatile GeometryDataCodec geometryDataCodec;
    final DataSourceConfig config;
    /**
     * Returns the manager singleton instance.
     */
    private Manager()
    {
        this(new DataSourceConfig());
    }

   Manager(Properties databaseProperties)
    {
	   this(DataSourceConfig.createConfig(databaseProperties));
    }
   Manager(DataSourceConfig config)
   {
	   this.config = config;
	   managers.put(checkNotNull(config.jdbcUrl,"jdbcUrl is null"), this);
	   aliasManagers.put(this.config.alias, this);
   }

    /**
     * Returns the manager singleton instance.
     */
    static Manager getInstance()
    {
        return Singleton.INSTANCE;
    }
    
    /** dispose pool */
    void disposePool(){
    	if(null != dataSourceFactory){
    		dataSourceFactory.destroy(dataSource);
    		dataSourceFactory = null;
    		dataSource = null;
    	}
    }
    private DataSourceFactory getDataSourceFactory(){
    	if(null == dataSourceFactory){
    		synchronized (this) {
    			if(null == dataSourceFactory){
    				switch (config.dataSource) {
					case DataSourceConfig.DT_SQLITE:
						dataSourceFactory = new SqliteDataSourceFactory();
						break;
					case DataSourceConfig.DT_C3P0:
						dataSourceFactory = new C3p0DataSourceFactory();
						break;
					case DataSourceConfig.DT_DRUID:
						dataSourceFactory = new DruidDataSourceFactory();
						break;
					default:
						throw new RuntimeException("UNSUPPORT DATA SOURCE TYPE:" + config.dataSource);
					}
    			}
			}
    	}
    	return dataSourceFactory;
    }
    private DatabaseMetaData getDatabaseMetaData(Connection c) throws SQLException{
        if(null == databaseMetaData){
            synchronized (this) {
                if(null == databaseMetaData){
                    this.databaseMetaData = c.getMetaData();
                    this.productName = this.databaseMetaData.getDatabaseProductName();
                }
            }
        }
        return this.databaseMetaData;
    }
    DatabaseMetaData getDatabaseMetaData() throws RuntimeDaoException{
        if(null == databaseMetaData){
            synchronized (this) {
                if(null == databaseMetaData){
                    try {
                        initDataSourceLazy();
                    } catch (SQLException e) {
                        throw new RuntimeDaoException(e);
                    }
                }
            }
        }
        return databaseMetaData;
    }

    String getProductName() throws RuntimeDaoException{
    	if(null == productName){
    		synchronized (this) {
    			if(null == productName){
    			    getDatabaseMetaData();
    			}
    		}
    	}
    	return productName;
    }
    StatementCache getStatementCache() {
        // double check
        if(null == statementCache){
            synchronized (this) {
                if(null == statementCache){
                    SqlFormatter sqlFormatter = SqlFormatters.formatterOf(getProductName());
                    SqlSyntaxNormalizer normalizer = SqlSyntaxNormalizers.normalizerOf(getProductName());
                    statementCache = new StatementCache(sqlFormatter, normalizer);
                }
            }
        }
        return statementCache;
    }

    GeometryDataCodec getGeometryDataCodec() {
        // double check
        if(null == geometryDataCodec) {
            synchronized (this) {
                if(null == geometryDataCodec) {
                    geometryDataCodec = GeometryDataCodecs.getGeometryDataCodec(getProductName());
                }
            }
        }
        return geometryDataCodec;
    }
    private void initDataSourceLazy() throws SQLException,RuntimeDaoException{
    	// double check
    	if (dataSource == null){
    		synchronized (this) {
    			if (dataSource == null){
    				try {
    					dataSource = getDataSourceFactory().createDataSource(config); 
    					/* initialize {@link #extensiveResultSetTypeCast} for extensive type cast of database engine,such SQLite */
    					{
    						try (Connection c = getConnection0()){
    							if("SQLite".equals(getDatabaseMetaData(c).getDatabaseProductName())){
    								extensiveResultSetTypeCast = ResultSetTypeCastSqliteImpl.SQLITE_CAST;
    							}
    						}
    					}
					} catch (RuntimeException e) {
						Throwables.throwIfInstanceOf(e, RuntimeDaoException.class);
			        	throw new RuntimeDaoException(e);
					}
    			}
    		}
    	}
    }
    void setDataSource(DataSource dataSource){
    	this.dataSource = dataSource;
    }
    void setDataSourceFactory(DataSourceFactory dataSourceFactory){
    	this.dataSourceFactory = dataSourceFactory;
    	setDataSource(null);
    }
    private Connection getConnection0() throws SQLException{
    	return dataSource.getConnection();
    }
    /**
     * Gets an auto commit connection.
     * 

     * Normally you do not need this method that much ;-)
     *
     * @return an auto commit connection
     */
    Connection getConnection() throws SQLException
    {
        Connection tc = transactionConnection.get();
        if (tc != null) {
            return tc;
        }
        Connection c = localConnection.get();
        if(null != c) {
            nestedCount.set(nestedCount.get() + 1);
            return c;
        }
    	initDataSourceLazy();
    	c = getConnection0();
    	localConnection.set(c);
    	nestedCount.set(0);
    	return c;
    }

    /**
     * Releases the database connection.
     * 

     * Normally you should not need this method ;-)
     */
    void releaseConnection(Connection c)
    {
        Connection tc = transactionConnection.get();
        if (tc != null){
            return;
        }
        if(c == localConnection.get()) {
            if(null != nestedCount.get() && nestedCount.get() > 0) {
                nestedCount.set(nestedCount.get() - 1);
                return ;
            }else {
                nestedCount.remove();
                localConnection.remove();
            }
        }
        try{
            if (c != null){
                c.close();
            }
        }catch (SQLException e){
            throw new RuntimeDaoException(e);
        }
    }

    /**
     * Initiates a database transaction.
     * 

     * When working within a transaction, you should invoke this method first.
     * The connection is returned just in case you need to set the isolation level.
     *
     * @return a non-auto commit connection with the default transaction isolation level
     */
    private Connection beginTransaction() throws SQLException
    {
        Connection c = this.getConnection();
        c.setAutoCommit(false);
        transactionConnection.set(c);
        return c;
    }

    /**
     * Releases connection used for the transaction and performs a commit or rollback.
     *
     * @param commit tells whether this connection should be committed
     *        true for commit(), false for rollback()
     */
    private void endTransaction(boolean commit) throws SQLException
    {
        Connection c = transactionConnection.get();
        if (c == null)
        {
            return;
        }

        try
        {
            if (commit)
            {
                c.commit();
            }
            else
            {
                c.rollback();
            }
        }
        finally
        {
            c.setAutoCommit(true);
            transactionConnection.remove();
            releaseConnection(c);
        }
    }
    /**
     * Run {@code Callable} as a transaction.

     * all exceptions but {@code SQLException} threw by {@code Callable} is wrapped into {@code RuntimeException}

     * throw {@code NullPointerException} if {@code fun} be {@code null}

     * @param   type of return result
     * @param fun
     * @param transactionListener listener for transaction status
     * @return
     * @throws RuntimeDaoException
     */
    T runAsTransaction(Callable fun,TransactionListener transactionListener) throws RuntimeDaoException{
    	checkArgument(fun != null, "fun is null");
    	checkArgument(null != transactionListener,"transactionListener is null");
        try {
            beginTransaction();
            transactionListener.onBegin();
            boolean commit = false;
            try {
                T result = fun.call();
                commit = true;
                transactionListener.onCommit();
                return result;
            } catch (SQLException e) {
                throw e;
            } catch (RuntimeException e) {
                throw e;
            }catch (Exception e) {
                throw new RuntimeException(e);
            }finally {
                endTransaction(commit);
                transactionListener.onEnd();
            }
        } catch (SQLException e) {
            throw new RuntimeDaoException(e);
        }
    }
    
    /**
	 * Run {@code Runnable} as a transaction.no return
	 * @param fun
	 * @param transactionListener listener for transaction status
	 * @throws RuntimeDaoException
	 * @see #runAsTransaction(Callable,TableListener.TransactionListener)
	 */
	void runAsTransaction(final Runnable fun,TransactionListener transactionListener) throws RuntimeDaoException{
		checkArgument(fun != null, "fun is null");
	    runAsTransaction(new Callable