// (1)以异步线程的方式执行JdbcStudentService#addStudent()方法，以模拟多线程的环境
    public static void asynchrLogon(JdbcStudentService userService,
            Student student) {
        StudentServiceRunner runner = new StudentServiceRunner(userService,
                student);
        runner.start();
    }
    private static class StudentServiceRunner extends Thread {
        private JdbcStudentService studentService;
        private Student student;
        public StudentServiceRunner(JdbcStudentService studentService,
                Student student) {
            this.studentService = studentService;
            this.student = student;
        }
        public void run() {
            studentService.addStudent(student);
        }
    }
    // (2) 让主执行线程睡眠一段指定的时间
    public static void sleep(long time) {
        try {
            Thread.sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    /**
     * 
     * 
     * @Title: reportConn
     * 
     * @Description: (3)汇报数据源的连接占用情况
     * 
     * @param basicDataSource
     * 
     * @return: void
     */
    public static void reportConn(BasicDataSource basicDataSource) {
        System.out.println("连接数[active:idle]-["
                + basicDataSource.getNumActive() + ":"
                + basicDataSource.getNumIdle() + "]");
    }
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "com/xgj/dao/transaction/dbConnleak/conf_conn_leak.xml");
        JdbcStudentService jdbcStudentService = (JdbcStudentService) ctx
                .getBean("jdbcStudentService");
        BasicDataSource basicDataSource = (BasicDataSource) ctx
                .getBean("dataSource");
        // (4)汇报数据源初始连接占用情况
        JdbcStudentService.reportConn(basicDataSource);
        Student student = new Student();
        student.setAge(20);
        student.setName("LEAK");
        student.setSex("MALE");
        JdbcStudentService.asynchrLogon(jdbcStudentService, student);
        JdbcStudentService.sleep(500);
        // (5)此时线程A正在执行JdbcStudentService#addStudent()方法
        JdbcStudentService.reportConn(basicDataSource);
        JdbcStudentService.sleep(2000);
        // (6)此时线程A所执行的JdbcStudentService#addStudent()方法已经执行完毕
        JdbcStudentService.reportConn(basicDataSource);
        JdbcStudentService.asynchrLogon(jdbcStudentService, student);
        JdbcStudentService.sleep(500);
        // (7)此时线程B正在执行JdbcStudentService#addStudent()方法
        JdbcStudentService.reportConn(basicDataSource);
        JdbcStudentService.sleep(2000);
        // (8)此时线程A和B都已完成JdbcStudentService#addStudent()方法的执行
        JdbcStudentService.reportConn(basicDataSource);
    }

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 扫描类包，将标注Spring注解的类自动转化Bean，同时完成Bean的注入 -->
    <context:component-scan base-package="com.xgj.dao.transaction.dbConnleak" />
    <!-- 使用context命名空间，配置数据库的properties文件 -->
    <context:property-placeholder location="classpath:spring/jdbc.properties" />
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close" 
        p:driverClassName="${jdbc.driverClassName}"
        p:url="${jdbc.url}" 
        p:username="${jdbc.username}" 
        p:password="${jdbc.password}" />
    <!-- 配置Jdbc模板 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
        p:dataSource-ref="dataSource" />
    <!--事务管理器，通过属性引用数据源 -->
    <bean id="jdbcManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
        p:dataSource-ref="dataSource"/>
    <!-- 通过aop 配置事务增强 -->
    <aop:config  proxy-target-class="true">
        <!-- 切点 -->
        <aop:pointcut  id="serviceJdbcMethod" expression="within(com.xgj.dao.transaction.dbConnleak.JdbcStudentService)"/>
        <!-- 切面 -->
        <aop:advisor pointcut-ref="serviceJdbcMethod" advice-ref="txAdvice"/>
    </aop:config>
    <!-- 增强,供aop:advisor引用 -->
    <tx:advice id="txAdvice" transaction-manager="jdbcManager">
        <tx:attributes>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
</beans>

public abstract class DataSourceUtils {
    …
    public static Connection doGetConnection(DataSource dataSource) throws SQLException {
        Assert.notNull(dataSource, "No DataSource specified");
        //①首先尝试从事务同步管理器中获取数据连接
        ConnectionHolder conHolder = 
            (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
        if (conHolder != null && (conHolder.hasConnection() || 
            conHolder.isSynchronizedWithTransaction())) { 
            conHolder.requested();
            if (!conHolder.hasConnection()) {
                logger.debug(
                    "Fetching resumed JDBC Connection from DataSource");
                conHolder.setConnection(dataSource.getConnection());
            }
            return conHolder.getConnection();
        }
        //②如果获取不到，则直接从数据源中获取连接
        Connection con = dataSource.getConnection();
        //③如果拥有事务上下文，则将连接绑定到事务上下文中
        if (TransactionSynchronizationManager.isSynchronizationActive()) {
            ConnectionHolder holderToUse = conHolder;
            if (holderToUse == null) {
                holderToUse = new ConnectionHolder(con);
            }
            else {holderToUse.setConnection(con);}
            holderToUse.requested();
            TransactionSynchronizationManager.registerSynchronization(
                new ConnectionSynchronization(holderToUse, dataSource));
            holderToUse.setSynchronizedWithTransaction(true);
            if (holderToUse != conHolder) {
                TransactionSynchronizationManager.bindResource(
                dataSource, holderToUse);
            }
        }
        return con;
    }
    …
}

public void addStudent(Student student) {
        try {
            // (0)直接从数据源获取连接，后续程序没有显式释放该连接
            // Connection connection = jdbcTemplate.getDataSource()
            // .getConnection();
            // 在事务环境下，通过DataSourceUtils获取数据连接
            Connection coon = DataSourceUtils.getConnection(jdbcTemplate
                    .getDataSource());
            jdbcTemplate.update(addStudentSQL, student.getName(),
                    student.getAge(), student.getSex());
            Thread.sleep(1000);// (0-1)模拟程序代码的执行时间
            logger.info("addStudent successfully");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

public void addStudent(Student student) {
        Connection conn = null;
        try {
            // 在非事务环境下，通过DataSourceUtils获取数据连接
            conn = DataSourceUtils.getConnection(jdbcTemplate.getDataSource());
            jdbcTemplate.update(addStudentSQL, student.getName(),
                    student.getAge(), student.getSex());
            Thread.sleep(1000);// (0-1)模拟程序代码的执行时间
            logger.info("addStudent successfully");
            // (1)
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 必须显式使用DataSourceUtils释放连接，否则造成了解泄露
            DataSourceUtils.releaseConnection(conn,
                    jdbcTemplate.getDataSource());
        }
    }

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close" 
        p:driverClassName="${jdbc.driverClassName}"
        p:url="${jdbc.url}" 
        p:username="${jdbc.username}" 
        p:password="${jdbc.password}" />
<!-- ①对数据源进行代理-->
<bean id="dataSourceProxy"
    class="org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy"
    p:targetDataSource-ref="dataSource"/>
<!-- ②直接使用数据源的代理对象-->
<bean id="jdbcTemplate"
    class="org.springframework.jdbc.core.JdbcTemplate"
    p:dataSource-ref="dataSourceProxy"/>
<!-- ③直接使用数据源的代理对象-->
<bean id="jdbcManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
    p:dataSource-ref="dataSourceProxy"/>