<dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- c3p0 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.3</version>
        </dependency>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.15</version>
        </dependency>
        <!-- log -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>

# c3p0只是会将该驱动实例注册到DriverManager，不能保证最终用的是该实例，除非设置了forceUseNamedDriverClass
c3p0.driverClass=com.mysql.cj.jdbc.Driver
c3p0.forceUseNamedDriverClass=true
c3p0.jdbcUrl=jdbc:mysql://localhost:3306/github_demo?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=true
# 获取连接时使用的默认用户名
c3p0.user=root
# 获取连接时使用的默认用户密码
c3p0.password=root


####### Basic Pool Configuration ########
# 当没有空闲连接可用时，批量创建连接的个数
# 默认3
c3p0.acquireIncrement=3
# 初始化连接个数
# 默认3
c3p0.initialPoolSize=3
# 最大连接个数
# 默认15
c3p0.maxPoolSize=15
# 最小连接个数
# 默认3
c3p0.minPoolSize=3

         配置文件名为c3p0.properties，会自动加载。
        DataSource dataSource = new ComboPooledDataSource();
         获取连接
        Connection conn = dataSource.getConnection();

         获取未池化数据源对象
        DataSource ds_unpooled = DataSources.unpooledDataSource();
         将未池化数据源对象进行池化
        DataSource ds_pooled = DataSources.pooledDataSource(ds_unpooled);
         获取连接
        Connection connection = ds_pooled.getConnection();

    @Test
    public void save() throws SQLException {
         创建sql
        String sql = "insert into demo_user values(null,?,?,?,?,?)";
        Connection connection = null;
        PreparedStatement statement = null;
        try {
             获得连接
            connection = JDBCUtil.getConnection();
             开启事务设置非自动提交
            connection.setAutoCommit(false);
             获得Statement对象
            statement = connection.prepareStatement(sql);
             设置参数
            statement.setString(1, "zzf003");
            statement.setInt(2, 18);
            statement.setDate(3, new Date(System.currentTimeMillis()));
            statement.setDate(4, new Date(System.currentTimeMillis()));
            statement.setBoolean(5, false);
             执行
            statement.executeUpdate();
             提交事务
            connection.commit();
        } finally {
             释放资源
            JDBCUtil.release(connection, statement, null);
        }
    }

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.2.1</version>
            <scope>provided</scope>
        </dependency>

<?xml version="1.0" encoding="UTF-8"?>
<Context>
    <Resource auth="Container"
              description="DB Connection"
              driverClass="com.mysql.cj.jdbc.Driver"
              maxPoolSize="4"
              minPoolSize="2"
              acquireIncrement="1"
              name="jdbc/pooledDS"
              user="root"
              password="root"
              factory="org.apache.naming.factory.BeanFactory"
              type="com.mchange.v2.c3p0.ComboPooledDataSource"
              jdbcUrl="jdbc:mysql://localhost:3306/github_demo?useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=GMT%2B8&amp;useSSL=true" >
</Context>

    <resource-ref>
        <res-ref-name>jdbc/pooledDS</res-ref-name>
        <res-type>javax.sql.DataSource</res-type>
        <res-auth>Container</res-auth>
    </resource-ref>

<body>
    <%
    String jndiName = "java:comp/env/jdbc/pooledDS";
     方式一
    JndiRefConnectionPoolDataSource jndiDs = new JndiRefConnectionPoolDataSource();
    jndiDs.setJndiName(jndiName);
    System.err.println("方式一获得的数据源identityToken：" + jndiDs.getIdentityToken());
    Connection con2 = jndiDs.getPooledConnection().getConnection();
     do something
    System.err.println("方式一获得的连接：" + con2);


     方式二
    InitialContext ic = new InitialContext();
     获取JNDI上的ComboPooledDataSource
    DataSource ds = (DataSource) ic.lookup(jndiName);
    System.err.println("方式二获得的数据源identityToken：" + ((ComboPooledDataSource)ds).getIdentityToken());
    Connection con = ds.getConnection();
     do something
    System.err.println("方式二获得的连接：" + con);


     释放资源
    if (ds instanceof PooledDataSource){
      PooledDataSource pds = (PooledDataSource) ds;
       先看看当前连接池的状态
      System.err.println("num_connections: "      + pds.getNumConnectionsDefaultUser());
      System.err.println("num_busy_connections: " + pds.getNumBusyConnectionsDefaultUser());
      System.err.println("num_idle_connections: " + pds.getNumIdleConnectionsDefaultUser());
      pds.close();
    }else{
      System.err.println("Not a c3p0 PooledDataSource!");
    }
    %>
</body>

方式一获得的数据源identityToken：1hge1hra7cdbnef1fooh9k|3c1e541
方式一获得的连接：com.mchange.v2.c3p0.impl.NewProxyConnection@2baa7911
方式二获得的数据源identityToken：1hge1hra7cdbnef1fooh9k|9c60446
方式二获得的连接：com.mchange.v2.c3p0.impl.NewProxyConnection@e712a7c
num_connections: 3
num_busy_connections: 2
num_idle_connections: 1

# c3p0只是会将该驱动实例注册到DriverManager，不能保证最终用的是该实例，除非设置了forceUseNamedDriverClass
c3p0.driverClass=com.mysql.cj.jdbc.Driver
c3p0.forceUseNamedDriverClass=true


c3p0.jdbcUrl=jdbc:mysql://localhost:3306/github_demo?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=true


# 获取连接时使用的默认用户名
c3p0.user=root
# 获取连接时使用的默认用户密码
c3p0.password=root

####### Basic Pool Configuration ########
# 当没有空闲连接可用时，批量创建连接的个数
# 默认3
c3p0.acquireIncrement=3


# 初始化连接个数
# 默认3
c3p0.initialPoolSize=3


# 最大连接个数
# 默认15
c3p0.maxPoolSize=15


# 最小连接个数
# 默认3
c3p0.minPoolSize=3

# 最大空闲时间。超过将被释放
# 默认0，即不限制。单位秒
c3p0.maxIdleTime=0


# 最大存活时间。超过将被释放
# 默认0，即不限制。单位秒
c3p0.maxConnectionAge=1800


# 过量连接最大空闲时间。
# 默认0，即不限制。单位秒
c3p0.maxIdleTimeExcessConnections=0


# 检出连接未归还的最大时间。
# 默认0。即不限制。单位秒
c3p0.unreturnedConnectionTimeout=0

# c3p0创建的用于测试连接的空表的表名。如果设置了，preferredTestQuery将失效。
# 默认null
#c3p0.automaticTestTable=test_table


# 自定义测试连接的sql。如果没有设置，c3p0会去调用isValid方法进行校验（c3p0版本0.9.5及以上）
# null
c3p0.preferredTestQuery=select 1 from dual


# ConnectionTester实现类，用于定义如何测试连接
# com.mchange.v2.c3p0.impl.DefaultConnectionTester
c3p0.connectionTesterClassName=com.mchange.v2.c3p0.impl.DefaultConnectionTester


# 空闲连接测试周期
# 默认0，即不检验。单位秒
c3p0.idleConnectionTestPeriod=300


# 连接检入时测试（异步）。
# 默认false
c3p0.testConnectionOnCheckin=false


# 连接检出时测试。
# 默认false。建议不要设置为true。
c3p0.testConnectionOnCheckout=false

# 所有连接PreparedStatement的最大总数量。是JDBC定义的标准参数，c3p0建议使用自带的maxStatementsPerConnection
# 默认0。即不限制
c3p0.maxStatements=0


# 单个连接PreparedStatement的最大数量。
# 默认0。即不限制
c3p0.maxStatementsPerConnection=0


# 延后清理PreparedStatement的线程数。可设置为1。
# 默认0。即不限制
c3p0.statementCacheNumDeferredCloseThreads=0

# 失败重试时间。
# 默认30。如果非正数，则将一直阻塞地去获取连接。单位毫秒。
c3p0.acquireRetryAttempts=30


# 失败重试周期。
# 默认1000。单位毫秒
c3p0.acquireRetryDelay=1000


# 当获取连接失败，是否标志数据源已损坏，不再重试。
# 默认false。
c3p0.breakAfterAcquireFailure=false

# 连接检入时是否自动提交事务。
# 默认false。但c3p0会自动回滚
c3p0.autoCommitOnClose=false


# 连接检入时是否强制c3p0不去提交或回滚事务，以及修改autoCommit
# 默认false。强烈建议不要设置为true。
c3p0.forceIgnoreUnresolvedTransactions=false

# 连接检出时是否记录堆栈信息。用于在unreturnedConnectionTimeout超时时打印。
# 默认false。
c3p0.debugUnreturnedConnectionStackTraces=false


# 在获取、检出、检入和销毁时，对连接对象进行操作的类。
# 默认null。通过继承com.mchange.v2.c3p0.AbstractConnectionCustomizer来定义。
#c3p0.connectionCustomizerClassName


# 池耗尽时，获取连接最大等待时间。
# 默认0。即无限阻塞。单位毫秒
c3p0.checkoutTimeout=0


# JNDI数据源的加载URL
# 默认null
#c3p0.factoryClassLocation


# 是否同步方式检入连接
# 默认false
c3p0.forceSynchronousCheckins=false


# c3p0的helper线程最大任务时间
# 默认0。即不限制。单位秒
c3p0.maxAdministrativeTaskTime=0


# c3p0的helper线程数量
# 默认3
c3p0.numHelperThreads=3


# 类加载器来源
# 默认caller
#c3p0.contextClassLoaderSource


# 是否使用c3p0的AccessControlContext
c3p0.privilegeSpawnedThreads=false

    public static String allocateIdentityToken(Object o) {
        if(o == null)
            return null;
        else {
            // 获取对象的identityHashCode，并转为16进制
            String shortIdToken = Integer.toString(System.identityHashCode(o), 16);
            String out;
            long count;
            StringBuffer sb = new StringBuffer(128);
            sb.append(VMID_PFX);
            // 判断是否拼接当前对象被查看过的次数
            if(ID_TOKEN_COUNTER != null && ((count = ID_TOKEN_COUNTER.encounter(shortIdToken)) > 0)) {
                sb.append(shortIdToken);
                sb.append('#');
                sb.append(count);
            } else
                sb.append(shortIdToken);
            out = sb.toString().intern();
            return out;
        }
    }

    // 存放identityToken=PooledDataSource的键值对
    private static Map tokensToTokenized = new DoubleWeakHashMap();
    // 存放未关闭的PooledDataSource
    private static HashSet unclosedPooledDataSources = new HashSet();
    private static void incorporate(IdentityTokenized idt) {
        tokensToTokenized.put(idt.getIdentityToken(), idt);
        if(idt instanceof PooledDataSource) {
            unclosedPooledDataSources.add(idt);
            mc.attemptManagePooledDataSource((PooledDataSource)idt);
        }
    }

    public synchronized static PooledDataSource pooledDataSourceByName(String dataSourceName) {
        for(Iterator ii = unclosedPooledDataSources.iterator(); ii.hasNext();) {
            PooledDataSource pds = (PooledDataSource)ii.next();
            if(pds.getDataSourceName().equals(dataSourceName))
                return pds;
        }
        return null;
    }

public class PoolBackedDataSourceBase extends IdentityTokenResolvable implements Referenceable, Serializable{
    protected PropertyChangeSupport pcs = new PropertyChangeSupport( this );
    protected VetoableChangeSupport vcs = new VetoableChangeSupport( this );
}

    public AbstractComboPooledDataSource(boolean autoregister) {
        super(autoregister);
        // 创建DriverManagerDataSource和WrapperConnectionPoolDataSource对象
        dmds = new DriverManagerDataSource();
        wcpds = new WrapperConnectionPoolDataSource();
        // 将DriverManagerDataSource设置给WrapperConnectionPoolDataSource
        wcpds.setNestedDataSource(dmds);
        
        // 初始化属性connectionPoolDataSource
        this.setConnectionPoolDataSource(wcpds);
        // 注册监听器
        setUpPropertyEvents();
    }

    public DriverManagerDataSource(boolean autoregister) {
        // 1. 获得this的identityToken，并注册到C3P0Registry
        super(autoregister);
        // 2. 添加监听配置参数改变的Listenner(当driverClass属性更改时触发事件)
        setUpPropertyListeners();
        // 3. 读取配置文件，初始化默认的user和password
        String user = C3P0Config.initializeStringPropertyVar("user", null);
        String password = C3P0Config.initializeStringPropertyVar("password", null);
        if(user != null)
            this.setUser(user);
        if(password != null)
            this.setPassword(password);
    }

    public WrapperConnectionPoolDataSource(boolean autoregister) {
        // 1. 获得this的identityToken，并注册到C3P0Registry
        super(autoregister);
        // 2. 添加监听配置参数改变的Listenner(当connectionTesterClassName属性更改时实例化ConnectionTester，当userOverridesAsString更改时重新解析字符串)
        setUpPropertyListeners();
        // 3. 解析userOverridesAsString
        this.userOverrides = C3P0ImplUtils.parseUserOverridesAsString(this.getUserOverridesAsString());
    }

    public Connection getConnection() throws SQLException{
        PooledConnection pc = getPoolManager().getPool().checkoutPooledConnection();
        return pc.getConnection();
    }

    public BasicResourcePool(Manager mgr, int start, int min, int max, int inc, int num_acq_attempts, int acq_attempt_delay, long check_idle_resources_delay, long max_resource_age, long max_idle_time, long excess_max_idle_time, long destroy_unreturned_resc_time, long expiration_enforcement_delay, boolean break_on_acquisition_failure, boolean debug_store_checkout_exceptions, boolean force_synchronous_checkins, AsynchronousRunner taskRunner, RunnableQueue asyncEventQueue,
            Timer cullAndIdleRefurbishTimer, BasicResourcePoolFactory factory) throws ResourcePoolException {
        // ·······
        this.taskRunner = taskRunner;
        this.asyncEventQueue = asyncEventQueue;
        this.cullAndIdleRefurbishTimer = cullAndIdleRefurbishTimer;
        this.factory = factory;
        // 开启监听器支持
        if (asyncEventQueue != null)
            this.rpes = new ResourcePoolEventSupport(this);
        else
            this.rpes = null;
        // 确保初始连接数量，这里会去调用recheckResizePool()方法，后面还会讲到的
        ensureStartResources();
        // 如果设置maxIdleTime、maxConnectionAge、maxIdleTimeExcessConnections和unreturnedConnectionTimeout，会开启定时任务检查连接是否过期
        if(mustEnforceExpiration()) {
            this.cullTask = new CullTask();
            cullAndIdleRefurbishTimer.schedule(cullTask, minExpirationTime(), this.expiration_enforcement_delay);
        }
        // 如果设置idleConnectionTestPeriod，会开启定时任务检查空闲连接有效性
        if(check_idle_resources_delay > 0) {
            this.idleRefurbishTask = new CheckIdleResourcesTask();
            cullAndIdleRefurbishTimer.schedule(idleRefurbishTask, check_idle_resources_delay, check_idle_resources_delay);
        }
        // ·······
    }

    // 返回的是NewProxyConnection对象
    public Connection getConnection() throws SQLException{
        PooledConnection pc = getPoolManager().getPool().checkoutPooledConnection();
        return pc.getConnection();
    }
    // 返回的是NewPooledConnection对象
    public PooledConnection checkoutPooledConnection() throws SQLException {
        // 从连接池检出连接对象
        PooledConnection pc = (PooledConnection)this.checkoutAndMarkConnectionInUse();
        // 添加监听器，当连接close时会触发checkin事件
        pc.addConnectionEventListener(cl);
        return pc;
    }

    private Object checkoutAndMarkConnectionInUse() throws TimeoutException, CannotAcquireResourceException, ResourcePoolException, InterruptedException {
        Object out = null;
        boolean success = false;
        // 注意，这里会自旋直到成功获得连接对象，除非抛出超时等异常
        while(!success) {
            try {
                // 从BasicResourcePool中检出连接对象
                out = rp.checkoutResource(checkoutTimeout);
                if(out instanceof AbstractC3P0PooledConnection) {
                    // 检查该连接下的Statement是不是已经清除完，如果没有，还得重新获取连接
                    AbstractC3P0PooledConnection acpc = (AbstractC3P0PooledConnection)out;
                    Connection physicalConnection = acpc.getPhysicalConnection();
                    success = tryMarkPhysicalConnectionInUse(physicalConnection);
                } else
                    success = true; // we don't pool statements from non-c3p0 PooledConnections
            } finally {
                try {
                    // 如果检出了连接对象，但出现异常或者连接下的Statement还没清除完，那么就需要重新检入连接
                    if(!success && out != null)
                        rp.checkinResource(out);
                } catch(Exception e) {
                    logger.log(MLevel.WARNING, "Failed to check in a Connection that was unusable due to pending Statement closes.", e);
                }
            }
        }
        return out;
    }

    public Object checkoutResource(long timeout) throws TimeoutException, ResourcePoolException, InterruptedException {
        try {
            Object resc = prelimCheckoutResource(timeout);


            // 如果设置了testConnectionOnCheckout，会进行连接检出测试，会去调用PooledConnectionResourcePoolManager的refurbishResourceOnCheckout方法
            boolean refurb = attemptRefurbishResourceOnCheckout(resc);


            synchronized(this) {
                // 连接测试不通过
                if(!refurb) {
                    // 清除该连接对象
                    removeResource(resc);
                    // 确保连接池最小容量，会去调用recheckResizePool()方法，后面还会讲到的
                    ensureMinResources();
                    resc = null;
                } else {
                    // 在asyncEventQueue队列中加入当前连接检出时向ResourcePoolEventSupport报告的事件
                    asyncFireResourceCheckedOut(resc, managed.size(), unused.size(), excluded.size());
                    PunchCard card = (PunchCard)managed.get(resc);
                    // 该连接对象被删除了？？
                    if(card == null) // the resource has been removed!
                    {
                        if(Debug.DEBUG && logger.isLoggable(MLevel.FINER))
                            logger.finer("Resource " + resc + " was removed from the pool while it was being checked out " + " or refurbished for checkout. Will try to find a replacement resource.");
                        resc = null;
                    } else {
                        card.checkout_time = System.currentTimeMillis();
                    }
                }
            }
            // 如果检出失败，还会继续检出，除非抛出超时等异常
            if(resc == null)
                return checkoutResource(timeout);
            else
                return resc;
        } catch(StackOverflowError e) {
            throw new NoGoodResourcesException("After checking so many resources we blew the stack, no resources tested acceptable for checkout. " + "See logger com.mchange.v2.resourcepool.BasicResourcePool output at FINER/DEBUG for information on individual failures.", e);
        }
    }

    private synchronized Object prelimCheckoutResource(long timeout) throws TimeoutException, ResourcePoolException, InterruptedException {
        try {
            // 检验当前连接池是否已经关闭或失效
            ensureNotBroken();
            
            int available = unused.size();
            // 如果当前没有空闲连接
            if(available == 0) {
                int msz = managed.size();
                // 如果当前连接数量小于maxPoolSize，则可以创建新连接
                if(msz < max) {
                    // 计算想要的目标连接数=池中总连接数+等待获取连接的客户端数量+当前客户端
                    int desired_target = msz + acquireWaiters.size() + 1;


                    if(logger.isLoggable(MLevel.FINER))
                        logger.log(MLevel.FINER, "acquire test -- pool size: " + msz + "; target_pool_size: " + target_pool_size + "; desired target? " + desired_target);
                    // 如果想要的目标连接数不小于原目标连接数，才会去尝试创建新连接
                    if(desired_target >= target_pool_size) {
                        // inc是我们一开始设置的acquireIncrement
                        desired_target = Math.max(desired_target, target_pool_size + inc);
                        // 确保我们的目标数量不大于maxPoolSize，不小于minPoolSize
                        target_pool_size = Math.max(Math.min(max, desired_target), min);
                        // 这里就会去调整池中的连接数量
                        _recheckResizePool();
                    }
                } else {
                    if(logger.isLoggable(MLevel.FINER))
                        logger.log(MLevel.FINER, "acquire test -- pool is already maxed out. [managed: " + msz + "; max: " + max + "]");
                }
                // 等待可用连接，如果设置checkoutTimeout可能会抛出超时异常
                awaitAvailable(timeout); // throws timeout exception
            }
            // 从空闲连接中获取
            Object resc = unused.get(0);


            // 如果获取到的连接正在被空闲资源检测线程使用
            if(idleCheckResources.contains(resc)) {
                if(Debug.DEBUG && logger.isLoggable(MLevel.FINER))
                    logger.log(MLevel.FINER, "Resource we want to check out is in idleCheck! (waiting until idle-check completes.) [" + this + "]");


                // 需要再次等待后重新获取连接对象
                Thread t = Thread.currentThread();
                try {
                    otherWaiters.add(t);
                    this.wait(timeout);
                    ensureNotBroken();
                } finally {
                    otherWaiters.remove(t);
                }
                return prelimCheckoutResource(timeout);
            // 如果当前连接过期，需要从池中删除，并尝试重新获取连接
            } else if(shouldExpire(resc)) {
                if(Debug.DEBUG && logger.isLoggable(MLevel.FINER))
                    logger.log(MLevel.FINER, "Resource we want to check out has expired already. Trying again.");


                removeResource(resc);
                ensureMinResources();
                return prelimCheckoutResource(timeout);
            // 将连接对象从空闲队列中移出
            } else {
                unused.remove(0);
                return resc;
            }
        } catch(ResourceClosedException e) // one of our async threads died
            // ·······
        }
    }

    private void _recheckResizePool() {
        assert Thread.holdsLock(this);
        
        if(!broken) {
            int msz = managed.size();


            int shrink_count;
            int expand_count;
            // 从池中清除指定数量的连接
            if((shrink_count = msz - pending_removes - target_pool_size) > 0)
                shrinkPool(shrink_count);
            // 从池中增加指定数量的连接
            else if((expand_count = target_pool_size - (msz + pending_acquires)) > 0)
                expandPool(expand_count);
        }
    }

    private void expandPool(int count) {
        assert Thread.holdsLock(this);


        // 这里是采用异步方式获取连接对象的，具体有两个不同人物类型，我暂时不知道区别
        if(USE_SCATTERED_ACQUIRE_TASK) {
            for(int i = 0; i < count; ++i)
                taskRunner.postRunnable(new ScatteredAcquireTask());
        } else {
            for(int i = 0; i < count; ++i)
                taskRunner.postRunnable(new AcquireTask());
        }
    }

    public Object acquireResource() throws Exception {
        PooledConnection out;
        // 一般我们不回去设置connectionCustomizerClassName，所以直接看connectionCustomizer为空的情况
        if(connectionCustomizer == null) {
            // 会去调用WrapperConnectionPoolDataSource的getPooledConnection方法
            out = (auth.equals(C3P0ImplUtils.NULL_AUTH) ? cpds.getPooledConnection() : cpds.getPooledConnection(auth.getUser(), auth.getPassword()));
        } else {
            // ·····
        }
        
        // 如果开启了缓存语句
        if(scache != null) {
            if(c3p0PooledConnections)
                ((AbstractC3P0PooledConnection)out).initStatementCache(scache);
            else {
                logger.warning("StatementPooling not " + "implemented for external (non-c3p0) " + "ConnectionPoolDataSources.");
            }
        }
        // ······
        return out;
    }

    protected PooledConnection getPooledConnection(String user, String password, ConnectionCustomizer cc, String pdsIdt) throws SQLException {
        // 这里获得的就是我们前面提到的DriverManagerDataSource
        DataSource nds = getNestedDataSource();
        Connection conn = null;
        // 使用DriverManagerDataSource获得原生的Connection
        conn = nds.getConnection(user, password);
        // 一般我们不会去设置usesTraditionalReflectiveProxies，所以只看false的情况
        if(this.isUsesTraditionalReflectiveProxies(user)) {
            return new C3P0PooledConnection(conn,
                    connectionTester,
                    this.isAutoCommitOnClose(user),
                    this.isForceIgnoreUnresolvedTransactions(user),
                    cc,
                    pdsIdt);
        } else {
            // NewPooledConnection就是原生连接的一个包装类而已，没什么特别的
            return new NewPooledConnection(conn,
                    connectionTester,
                    this.isAutoCommitOnClose(user),
                    this.isForceIgnoreUnresolvedTransactions(user),
                    this.getPreferredTestQuery(user),
                    cc,
                    pdsIdt);
        }
    }

热门推荐：

这款Java版的CMS内容管理系统，拿来即用，非常方便（附项目地址）
你，终于知道道歉了。。。
这是我见过Java版的最好的OA系统，拿来即用，非常方便（附项目地址）

简历&面试题&视频资料获取 

扫描下方二维码，回复关键字【 java 】