2. 程式人生 > >Spring JDBC-資料連線洩露解讀

Spring JDBC-資料連線洩露解讀

阿新 • • 發佈：2019-01-28

概述

資料連線洩漏無疑是一個可怕的夢魘。如果存在資料連線洩漏問題，應用程式將因資料連線資源的耗盡而崩潰，甚至還可能引起資料庫的崩潰。

Spring DAO 對所有支援的資料訪問技術框架都使用模板化技術進行了薄層的封裝。只要我們的應用程式都使用 Spring DAO 模板（如 JdbcTemplate、HibernateTemplate 等）進行資料訪問，一定不會存在資料連線洩漏的問題 。
因此，我們無需關注資料連線（Connection）及其衍生品（Hibernate 的 Session 等）的獲取和釋放的操作，模板類已經通過其內部流程替我們完成了，且對開發者是透明的。

但是由於整合第三方產品，整合遺產程式碼等原因，可能需要直接訪問資料來源或直接獲取資料連線及其衍生品。這時，如果使用不當，就可能在無意中創造出一個魔鬼般的連線洩漏問題。

眾所周知，當 Spring 事務方法執行時，就產生一個事務上下文，該上下文在本事務執行執行緒中針對同一個資料來源綁定了一個唯一的資料連線（或其衍生品），所有被該事務上下文傳播的方法都共享這個資料連線。這個資料連線從資料來源獲取及返回給資料來源都在 Spring 掌控之中，不會發生問題。如果在需要資料連線時，能夠獲取這個被 Spring 管控的資料連線，則我們可以放心使用，無需關注連線釋放的問題。

那如何獲取這些被 Spring 管控的資料連線呢？ Spring 提供了兩種方法：

  • 其一是使用資料資源獲取工具類

  • 其二是對資料來源（或其衍生品如 Hibernate SessionFactory）進行代理。

示例：資料連線洩露演示

在具體介紹這些方法之前，讓我們先來看一下各種引發資料連線洩漏的場景。

package com.xgj.dao.transaction.dbConnleak;

import java.sql.Connection;
import java.sql.SQLException;

import org.apache.commons.dbcp.BasicDataSource;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired
 
;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;

@Service
public class JdbcStudentService {
    private Logger logger = Logger.getLogger(JdbcStudentService.class);

    private static final String addStudentSQL = "insert into student(id,name,age,sex) values(student_id_seq.nextval,?,?,?)";

    private JdbcTemplate jdbcTemplate;

    @Autowired
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void addStudent(Student student) {
        try {
            // (0)直接從資料來源獲取連線，後續程式沒有顯式釋放該連線
            Connection connection = jdbcTemplate.getDataSource()
                    .getConnection();
            jdbcTemplate.update(addStudentSQL, student.getName(),
                    student.getAge(), student.getSex());
            Thread.sleep(1000);// (0-1)模擬程式程式碼的執行時間
            logger.info("addStudent successfully");
        } catch (SQLException | InterruptedException e) {
            e.printStackTrace();
        }

    }


}

JdbcStudentService通過 Spring AOP 事務增強的配置，讓所有 public 方法都工作在事務環境中。即讓addStudent()方法擁有事務功能。在 addStudent() 方法內部，我們在(0)處通過呼叫 jdbcTemplate.getDataSource().getConnection()顯式獲取一個連線，這個連線不是 addStudent() 方法事務上下文執行緒繫結的連線，所以如果我們如果沒有手工釋放這連線（顯式呼叫 Connection#close() 方法），則這個連線將永久被佔用（處於 active 狀態），造成連線洩漏！

下面，我們編寫模擬執行的程式碼，檢視方法執行對資料連線的實際佔用情況

// (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);
    }

在 JdbcStudentService中新增一個可非同步執行 addStudent() 方法的 asynchrLogon() 方法，我們通過非同步執行 addStudent() 以及讓主執行緒睡眠的方式模擬多執行緒環境下的執行場景。在不同的執行點，通過 reportConn() 方法彙報資料來源連線的佔用情況。

配置檔案

<?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>

保證 BasicDataSource 資料來源的配置預設連線為 0，執行程式

2017-09-26 22:38:26,862  INFO [main] (AbstractApplicationContext.java:583) - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@4680937b: startup date [Tue Sep 26 22:38:26 BOT 2017]; root of context hierarchy
2017-09-26 22:38:26,951  INFO [main] (XmlBeanDefinitionReader.java:317) - Loading XML bean definitions from class path resource [com/xgj/dao/transaction/dbConnleak/conf_conn_leak.xml]
連線數[active:idle]-[0:0]
連線數[active:idle]-[1:0]
2017-09-26 22:38:29,975  INFO [Thread-1] (JdbcStudentService.java:35) - addStudent successfully
連線數[active:idle]-[1:1]
連線數[active:idle]-[3:0]
2017-09-26 22:38:31,872  INFO [Thread-2] (JdbcStudentService.java:35) - addStudent successfully
連線數[active:idle]-[2:1]

我們通過下表對資料來源連線的佔用和洩漏情況進行描述

這裡寫圖片描述

可見在執行執行緒 1 執行完畢後，只釋放了一個數據連線，還有一個數據連處於 active 狀態，說明洩漏了一個連線。相似的，執行執行緒 2 執行完畢後，也洩漏了一個連線：原因是直接通過資料來源獲取連線（jdbcTemplate.getDataSource().getConnection()）而沒有顯式釋放造成的。

事務環境下通過DataSourceUtils獲取資料連線

Spring 提供了一個能從當前事務上下文中獲取繫結的資料連線的工具類- DataSourceUtils。

Spring 強調必須使用 DataSourceUtils 工具類獲取資料連線，Spring 的 JdbcTemplate 內部也是通過 DataSourceUtils 來獲取連線的。

DataSourceUtils 提供了若干獲取和釋放資料連線的靜態方法

  • static Connection doGetConnection(DataSource
    dataSource)    ：首先嚐試從事務上下文中獲取連線，失敗後再從資料來源獲取連線；

  • static Connection getConnection(DataSource dataSource)：和doGetConnection 方法的功能一樣，實際上，它內部就是呼叫 doGetConnection 方法獲取連線的；

  • static void doReleaseConnection(Connection con, DataSourcedataSource)：釋放連線，放回到連線池中；

  • static void releaseConnection(Connection con, DataSource
    dataSource)    ：和 doReleaseConnection 方法的功能一樣，實際上，它內部就是呼叫 doReleaseConnection 方法獲取連線的；

來看一下 DataSourceUtils 從資料來源獲取連線的關鍵程式碼：

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;
    }
    …
}

它首先檢視當前是否存在事務管理上下文，並嘗試從事務管理上下文獲取連線，如果獲取失敗，直接從資料來源中獲取連線。在獲取連線後，如果當前擁有事務上下文，則將連線繫結到事務上下文中。

我們對上面那個有連線洩露的方法進行改造，使用 DataSourceUtils.getConnection() 替換直接從資料來源中獲取連線的程式碼：

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();
        }

    }

重新執行日誌如下：

2017-09-26 23:19:32,588  INFO [main] (AbstractApplicationContext.java:583) - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@2c686c5e: startup date [Tue Sep 26 23:19:32 BOT 2017]; root of context hierarchy
2017-09-26 23:19:32,719  INFO [main] (XmlBeanDefinitionReader.java:317) - Loading XML bean definitions from class path resource [com/xgj/dao/transaction/dbConnleak/conf_conn_leak.xml]
連線數[active:idle]-[0:0]
連線數[active:idle]-[0:0]
2017-09-26 23:19:36,716  INFO [Thread-1] (JdbcStudentService.java:40) - addStudent successfully
連線數[active:idle]-[0:1]
連線數[active:idle]-[1:0]
2017-09-26 23:19:38,273  INFO [Thread-2] (JdbcStudentService.java:40) - addStudent successfully
連線數[active:idle]-[0:1]

我們可以看到已經沒有連線洩漏的現象了。一個執行執行緒在執行 JdbcStudentService#addStudent() 方法時，只佔用一個連線，而且方法執行完畢後，該連線馬上釋放。這說明通過 DataSourceUtils.getConnection() 方法確實獲取了方法所在事務上下文繫結的那個連線，而不是像原來那樣從資料來源中獲取一個新的連線。

非事務環境下通過DataSourceUtils獲取資料連線也可能造成洩漏

如果 DataSourceUtils 在沒有事務上下文的方法中使用 getConnection() 獲取連線，依然會造成資料連線洩漏！

我們保持使用DataSourceUtils獲取資料來源的程式碼不變，修改下配置檔案中的AOP增強，去掉事務增強（如下部分）

<!-- 通過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>

再此執行

2017-09-26 23:23:04,538  INFO [main] (AbstractApplicationContext.java:583) - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@7ba2a618: startup date [Tue Sep 26 23:23:04 BOT 2017]; root of context hierarchy
2017-09-26 23:23:04,655  INFO [main] (XmlBeanDefinitionReader.java:317) - Loading XML bean definitions from class path resource [com/xgj/dao/transaction/dbConnleak/conf_conn_leak.xml]
連線數[active:idle]-[0:0]
連線數[active:idle]-[0:0]
2017-09-26 23:23:07,759  INFO [Thread-1] (JdbcStudentService.java:40) - addStudent successfully
連線數[active:idle]-[1:1]
連線數[active:idle]-[2:1]
2017-09-26 23:23:09,504  INFO [Thread-2] (JdbcStudentService.java:40) - addStudent successfully
連線數[active:idle]-[2:1]

有事務上下文時，需要等到整個事務方法（即 addStudent()）返回後，事務上下文繫結的連線才釋放。但在沒有事務上下文時，addStudent() 呼叫 JdbcTemplate 執行完資料操作後，馬上就釋放連線。

為了避免這種情況，需要進行如下改造

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());
        }

    }

顯式呼叫 DataSourceUtils.releaseConnection() 方法釋放獲取的連線。特別需要指出的是：一定不能在 (1)處釋放連線！因為如果 addStudent() 在獲取連線後，(1)處程式碼前這段程式碼執行時發生異常，則(1)處釋放連線的動作將得不到執行。這將是一個非常具有隱蔽性的連線洩漏的隱患點。

JdbcTemplate 如何做到對連線洩漏的免疫

分析 JdbcTemplate 的程式碼，我們可以清楚地看到它開放的每個資料操作方法，首先都使用 DataSourceUtils 獲取連線，在方法返回之前使用 DataSourceUtils 釋放連線。

來看一下 JdbcTemplate 最核心的一個數據操作方法 execute()：

public <T> T execute(StatementCallback<T> action) throws DataAccessException {
    //① 首先根據DataSourceUtils獲取資料連線
    Connection con = DataSourceUtils.getConnection(getDataSource());
    Statement stmt = null;
    try {
        Connection conToUse = con;
        …
        handleWarnings(stmt);
        return result;
    }
    catch (SQLException ex) {
        JdbcUtils.closeStatement(stmt);
        stmt = null;
        DataSourceUtils.releaseConnection(con, getDataSource());
        con = null;
        throw getExceptionTranslator().translate(
            "StatementCallback", getSql(action), ex);
    }
    finally {
        JdbcUtils.closeStatement(stmt);
        //② 最後根據DataSourceUtils釋放資料連線
        DataSourceUtils.releaseConnection(con, getDataSource());
    }
}

在 ① 處通過 DataSourceUtils.getConnection() 獲取連線，在 ② 處通過 DataSourceUtils.releaseConnection() 釋放連線。

所有 JdbcTemplate 開放的資料訪問方法最終都是通過 execute(StatementCallback<T> action)執行資料訪問操作的，因此這個方法代表了 JdbcTemplate 資料操作的最終實現方式。

正是因為 JdbcTemplate 嚴謹的獲取連線，釋放連線的模式化流程保證了 JdbcTemplate 對資料連線洩漏問題的免疫性。所以，如有可能儘量使用 JdbcTemplate，HibernateTemplate 等這些模板進行資料訪問操作，避免直接獲取資料連線的操作。

使用 TransactionAwareDataSourceProxy

如果不得已要顯式獲取資料連線，除了使用 DataSourceUtils 獲取事務上下文繫結的連線外，還可以通過 TransactionAwareDataSourceProxy 對資料來源進行代理。資料來源物件被代理後就具有了事務上下文感知的能力，通過代理資料來源的 getConnection() 方法獲取的連線和使用 DataSourceUtils.getConnection() 獲取連線的效果是一樣的。

下面是使用 TransactionAwareDataSourceProxy 對資料來源進行代理的配置：

<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"/>

對資料來源進行代理後，我們就可以通過資料來源代理物件的 getConnection() 獲取事務上下文中繫結的資料連線了。

因此，如果資料來源已經進行了 TransactionAwareDataSourceProxy 的代理，而且方法存在事務上下文，那麼最開始的程式碼也不會生產連線洩漏的問題。

其它資料訪問技術的等價類

Spring 為每個資料訪問技術框架都提供了一個獲取事務上下文繫結的資料連線（或其衍生品）的工具類和資料來源（或其衍生品）的代理類。

DataSourceUtils 的等價類

資料訪問框架 連接獲取工具類
SpringJDBC/ MyBatis org.springframework.jdbc.datasource.DataSourceUtils
Hibernate org.springframework.orm.hibernateX.SessionFactoryUtils
JPA org.springframework.orm.jpa.EntityManagerFactoryUtils
JDO org.springframework.orm.jdo.PersistenceManagerFactoryUtils

TransactionAwareDataSourceProxy 的等價類

資料訪問框架 連接獲取工具類
SpringJDBC/MyBatis org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy
Hibernate org.springframework.orm.hibernateX.LocalSessionFactoryBean
JPA org.springframework.orm.jpa.EntityManagerFactoryUtils
JDO 無

總結

使用 Spring JDBC 時如果直接獲取 Connection，可能會造成連線洩漏。為降低連線洩漏的可能，儘量使用 DataSourceUtils 獲取資料連線。也可以對資料來源進行代理，以便將其擁有事務上下文的感知能力；

可以將 Spring JDBC 防止連線洩漏的解決方案平滑應用到其它的資料訪問技術框架中

示例原始碼

相關推薦

Spring JDBC-資料連線洩露解讀

概述 資料連線洩漏無疑是一個可怕的夢魘。如果存在資料連線洩漏問題，應用程式將因資料連線資源的耗盡而崩潰，甚至還可能引起資料庫的崩潰。 Spring DAO 對所有支援的資料訪問技術框架都使用模板化技術進行了薄層的封裝。只要我們的應用程式都使用 Sp

Spring-JDBC 資料訪問

新增.jar包 <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc --> <dependency> <groupId>org

Java框架-Spring的jdbc、連線池及事務管理

1. Spring的AOP程式設計 1.1 純xml程式設計 <!--通知配置型別--> <aop:config> <!--設定切面--> <aop:aspect ref="logger"> <!-

Spring Boot使用JDBC方式連線MySQL

首先去spring官網下載一個名為test的Spring Boot專案模板：https://start.spring.io/ 然後在mysql中的testdb資料庫中新建一張名為test_user的表： drop table if exists `test_user`; create table `tes

spring jdbc --注：c3p0資料庫連線池或druid連線池使用配置整理

是Maven配置檔案：pom.xml的程式碼內容： <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:sch

Spring系列學習之Spring Data JDBC資料訪問拓展

英文原文：https://spring.io/projects/spring-data-jdbc-ext 目錄 概述 特性 Core Oracle 快速開始 學習 文件 示例 注意：該專案不再積極開發，將於今年晚些時候束之高閣。 概述 Spring

Spring系列學習之Spring Data JDBC資料訪問

英文原文：https://spring.io/projects/spring-data-jdbc 目錄 概述 Aggregate Root聚合根 特性 快速開始 學習 文件 概述 Spring Data JDBC是更大的Spring Data系列的一部分，可以

Spring JDBC刪除資料

以下示例將展示如何使用Spring jdbc執行刪除資料庫表中的記錄，這裡演示如何刪除指定student表中的記錄。語法：String deleteQuery = "delete from Student where id = ?"; jdbcTemplateObject.u

Spring JDBC學習筆記（3）：使用JdbcTemplate來獲取資料庫表和列的元資料

本篇文章才是我寫這一個系列文章的目的，原來我一般都是使用jdbc獲取資料庫的元資料，但是有點讓我很不爽，每次查資料表和列的時候都要自己寫“TABLE_NAME”和“COLUMN_HOME”等名稱，所以乾脆轉到JdbcTemplate實現上。通過JdbcTemplate獲取資

與spring整合的幾種資料連線池

資料來源概述 資料庫連線是一種關鍵的有限的昂貴的資源，這一點在多使用者的網頁應用程式中體現得尤為突出。對資料庫連線的管理能顯著影響到整個 應用程式的伸縮性和健壯性，影響到程式的效能指標。資料庫連線池正是針對這個問題提出來的。 　　資料庫連線池負責分配、管理

spring jdbc連線池的配置

ORACLE <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"><property name="driverClassN

Spring jdbc批量儲存資料

在很多時候同步資料的時候需要使用jdbc實現批量儲存，當然在分散式和主從資料庫就不用考慮這種方式了，我用這種方式只是為了有限數量的資料批量插入。 資料list：list.add(bcHistory); 批量插入： 1 2 3 4 5 6 7 8 9 10 11 12 13

Spring JDBC更新資料

以下示例將展示如何使用Spring jdbc執行更新資料庫表的記錄，這裡演示如何更新student表中指定條件的記錄。語法：String updateQuery = "update Student set age = ? where id = ?"; jdbcTemplate

spring資料連線洩漏

 對於應用開發者來說，資料連線洩漏無疑是一個可怕的夢魘。只要你開發的應用存在資料連線洩漏的問題，應用程式最終都將因資料連線資源的耗盡而崩潰，甚至還可能引起資料庫的崩潰。資料連線洩漏像一個黑洞那樣讓開發者避之唯恐不及。     Spring DAO對所有支援的資料訪問

spring配置hibernate 資料來源(資料連線池)

現在常用的開源資料連線池主要有c3p0、dbcp和proxool三種，其中：  hibernate開發組推薦使用c3p0;  spring開發組推薦使用dbcp(dbcp連線池有weblogic連線池同樣的問題，就是強行關閉連線或資料庫重啟後，無法reconnect，

Spring Boot採用JDBC方式連線資料庫

先前我安裝好了STS外掛，也實現了第一個spring boot應用，那如果想要連線資料庫該怎麼做呢？ 可以選擇JDBC方式，以及Hibernate方式。 JDBCTemplate是Spring對jdbc的封裝，但sql還是得自己寫，一旦要寫sql，則會增加靈

帆軟報表FineReport中資料連線的JDBC連線池屬性問題

連線池原理 在帆軟報表FineReport中，連線池主要由三部分組成：連線池的建立、連線池中連線使用的治理、連線池的關閉。下面就著重討論這三部分及連線池的配置問題。 1. 連線池原理 連線池技術的核心思想，是連線複用，通過建立一個數據庫連線池以及一套連線使用、分配、治理策略

spring學習筆記(17)資料庫配置[1]spring資料連線池詳解

資料連線池 在spring中，常使用資料庫連線池來完成對資料庫的連線配置，類似於執行緒池的定義，資料庫連線池就是維護有一定數量資料庫連線的一個緩衝池，一方面，能夠即取即用，免去初始化的時間，另一方面，用完的資料連線會歸還到連線池中，這樣就免去了不必要的連線建立

hive的訪問：通過JDBC遠端連線hive資料倉庫

hive的訪問：終端訪問  遠端訪問 終端訪問：安裝hive，利用shell指令碼訪問 不可併發訪問 遠端訪問：通過JDBC連線資料倉庫 支援併發訪問 啟動hiveserver2服務：檢視該命令可知hiveserver2,等價於hive --service hive

再淡spring jdbc 連線池斷開重連設定

先看一段錯誤日誌： ### Error querying database. Cause: com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: No operations allow