JDBC 鏈接池 & Template

時間  2020-08-06
標籤 jdbc 鏈接 template 欄目 Java 简体版
原文   原文鏈接

數據庫鏈接池

# 概念：其實就是一個容器（集合），存放數據庫鏈接的容器。
　　* 當系統初始化號之後，容器被建立，容器中會申請一些鏈接對象，當用戶來訪問數據庫時，從容其中獲取鏈接對象，用戶訪問完以後，會將鏈接對象歸還給容器。java

# 好處：
　　* 節約資源
　　* 用戶訪問高效mysql

# 實現：
　　* 標準接口：DataSource    javax.sql 包下的
　　　　* 方法：
　　　　　　* 獲取鏈接：getConnection()
　　　　　　* 歸還鏈接：Connection.close()
　　　　　　　　* 若是鏈接對象 Connection是從鏈接池中獲取的，那麼調用 Connection.close() 方法，則不會再關閉鏈接了，而是歸還鏈接。spring

　　* 通常咱們不去實現它，有數據庫廠商來實現
　　　　* C3P0：數據庫鏈接池技術
　　　　* Druid：數據庫鏈接池技術，由阿里巴巴提供sql

C3P0：數據庫鏈接池技術

　　* 步驟：
　　　　1）導入 jar 包（兩個）：c3p0-0.9.5.2.jar 和 mchange-commons-java-0.2.12.jar
　　　　　　* 不要忘記導入數據庫驅動 jar 包
　　　　2）定義配置文件
　　　　　　* 名稱：c3p0.properties 或者 c3p0-config.xml
　　　　　　* 路徑：直接將文件放在 src 目錄便可
　　　　3）建立核心對象  數據庫鏈接池對象：ComboPooledDataSource
　　　　4）獲取鏈接：getConnection數據庫

　　* 代碼實現app

//一、建立數據庫鏈接池對象
DataSource ds = new ComboPooledDataSource(); //二、獲取鏈接對象
Connection conn = ds.getConnection
<c3p0-config>
    <!-- 使用默認的配置讀取鏈接池對象 -->
    <default-config>
        <!--  鏈接參數 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/db4</property>
        <property name="user">root</property>
        <property name="password">123</property>

        <!-- 鏈接池參數 -->
        <!--  initialPoolSize初始化申請鏈接的數量  -->
        <property name="initialPoolSize">5</property>
        <!--  maxPoolSize最大的鏈接數量    -->
        <property name="maxPoolSize">10</property>
        <!--  checkoutTimeout超時時間    -->
        <property name="checkoutTimeout">3000</property>
    </default-config>

    <named-config name="otherc3p0">
        <!--  鏈接參數 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/day25</property>
        <property name="user">root</property>
        <property name="password">root</property>

        <!-- 鏈接池參數 -->
        <property name="initialPoolSize">5</property>
        <property name="maxPoolSize">8</property>
        <property name="checkoutTimeout">1000</property>
    </named-config>
</c3p0-config>
c3p0-config.xml 
package cn.itcast.datasource.c3p0;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * c3p0的演示
 */
public class C3P0Demo1 {
    public static void main(String[] args) throws SQLException {
        //一、建立數據庫鏈接池對象
        DataSource ds = new ComboPooledDataSource();
        //二、獲取鏈接對象
        Connection conn = ds.getConnection();
        //三、打印
        System.out.println(conn);
    }
}
View Code  

Druid：數據庫鏈接池技術，阿里巴巴提供

　　* 步驟：
　　　　1）導入 jar 包：druid-1.0.9.jar
　　　　2）定義配置文件
　　　　　　* 是 properties 形式的
　　　　　　* 能夠教任意名字，放在任意目錄下
　　　　3）加載配置文件 Properties
　　　　4）獲取數據庫鏈接池對象：經過工廠類來獲取 ：DruidDataSourceFactory
　　　　5）獲取鏈接：getConnection()框架

　　* 代碼實現ide

//三、加載配置文件
Properties pro = new Properties(); InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties"); pro.load(id); //四、獲取鏈接池對象
DataSource ds = DruidDataSourceFactory.createDataSource(pro); //五、獲取鏈接
Connection conn = ds.getConnection();
package cn.itcast.datasource.druid;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;

/**
 * Druid演示
 */
public class DruidDemo1 {
    public static void main(String[] args) throws Exception {
        //一、導入jar包
        //二、定義配置文件
        //三、加載配置文件
        Properties pro = new Properties();
        InputStream is = DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties");
        pro.load(is);
        //四、獲取鏈接池對象
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);
        //五、獲取鏈接
        Connection conn = ds.getConnection();
        System.out.println(conn);
    }
}
View Code

 

* 定義工具類
　　　　* 定義一個類 JDBCUtils
　　　　* 提供靜態代碼塊加載配置文件，初始化鏈接池對象
　　　　* 提供方法：
　　　　　　* 獲取鏈接方法：經過數據庫鏈接池獲取鏈接
　　　　　　* 釋放資源
　　　　　　* 獲取鏈接池的方法函數

package cn.itcast.datasource.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.naming.Context;
import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * Druid鏈接池的工具類
 */
public class JDBCUtils {

    // 一、定義成員變量 DataSource
    private static DataSource ds;

    static {
        try {
            Properties pro = new Properties();
            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 獲取鏈接的方法
     */
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    /**
     * 釋放資源的方法
     */
    public static void close(Statement stmt, Connection conn) {
        close(null, stmt, conn);
    }

    public static void close(ResultSet rs, Statement stmt, Connection conn) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 獲取鏈接池的方法
     */
    public static DataSource getDataSource() {
        return ds;
    }
}
JDBCutils 
package cn.itcast.datasource.druid;

import cn.itcast.datasource.utils.JDBCUtils;

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

/**
 * 使用新的工具類
 */
public class DruidDemo2 {
    public static void main(String[] args) {
        /**
         * 完成添加操做，給account表添加一條記錄
         */
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            //一、獲取鏈接
            conn = JDBCUtils.getConnection();
            //二、定義sql
            String sql = "insert into account values(null,?,?)";
            //三、獲取執行對象
            pstmt = conn.prepareStatement(sql);
            //四、給問號賦值
            pstmt.setString(1, "王五");
            pstmt.setDouble(2, 3000);
            //五、執行sql
            int count = pstmt.executeUpdate();
            System.out.println(count);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.close(pstmt, conn);
        }
    }
}
View Code

 

Spring JDBC

　　* Spring 框架對 JDBC 的簡單封裝，提供了一個 JDBCTemplate 對象簡化 JDBC 的開發工具

　　* 步驟：
　　　　1）導入 jar 包
　　　　2）建立 JdbcTemplate 對象，依賴於數據源 DataSource
　　　　　　* JdbcTemplate template = new JdbcTemplate(ds);
　　　　3）調用 JdbcTemplate 的方法來完成 CRUD 的操做
　　　　　　* update()：執行 DML 語句，實現 增、刪、改 操做
　　　　　　* queryForMap()：查詢結果將封裝爲 map 集合，將列名做爲 Key，將值做爲 value，將這條記錄封裝爲一個 map 集合
　　　　　　　　* 注意：這個方法查詢的結果集長度只能爲1
　　　　　　* queryForList()：查詢結果將封裝爲 list 集合
　　　　　　　　* 注意：將每一條記錄封裝爲一個 Map 集合，再將 Map 集合裝載到 List 集合中
　　　　　　* query()：查詢結果將封裝爲 JavaBean 對象
　　　　　　　　* query() 的參數：
　　　　　　　　　　* 通常咱們使用 BeanPropertyRowMapper 實現類，能夠完成數據到 JavaBean 的自動封裝
　　　　　　　　　　* new BeanPropertyRowMapper< 類型 >( 類型.class )
　　　　　　* queryForObject()：查詢結果將封裝爲對啊ing
　　　　　　　　* 通常用於聚合函數的查詢

package cn.itcast.jdbtemplate;

import cn.itcast.datasource.utils.JDBCUtils;
import org.springframework.jdbc.core.JdbcTemplate;


/**
 * JdbcTemplate入門
 */
public class JdbcTemplateDemo1 {
    public static void main(String[] args) {
        //一、導入jar包
        //二、建立J的BCTemplate對象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //三、調用方法
        String sql = "update account set balance = 5000 where id = ?";
        int count = template.update(sql, 4);
        System.out.println(count);

    }

}
View Code

 

　　* 練習：
　　　　* 需求：
　　　　　　1）修改 1 號數據的 salary 爲 10000
　　　　　　2）添加一條記錄
　　　　　　3）刪除剛纔添加的記錄
　　　　　　4）查詢 id 爲 1 的記錄，將其封裝爲 Map 集合
　　　　　　5）查詢全部記錄，將其封裝爲 List
　　　　　　6）查詢全部記錄，將其封裝爲 Emp 對象的List集合
　　　　　　7）查詢總記錄數

package cn.itcast.jdbtemplate;

import cn.itcast.bean.Emp;
import cn.itcast.datasource.utils.JDBCUtils;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import javax.sql.DataSource;
import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

public class JdbcTemplateDemo2 {
    //Junit單元測試，可讓方法獨立的執行,再也不依賴於主方法
    //一、獲取JDBCTemplate對象
    private DataSource dataSource = JDBCUtils.getDataSource();
    private JdbcTemplate template = new JdbcTemplate(dataSource);

    /**
     * 修改 1 號數據的 salary 爲 10000
     */
    @Test
    public void test1() {
        String sql = "update emp set salary = 1000 where id = 1001";
        int count = template.update(sql);
        System.out.println(count);
    }

    /**
     * 添加一條記錄
     */
    @Test
    public void test2() {
        String sql = "insert into emp(id,ename,dept_id) values(?,?,?)";
        int count = template.update(sql, 1015, "郭靖", 10);
        System.out.println(count);
    }

    /**
     * 刪除剛纔添加的記錄
     */
    @Test
    public void test3() {
        String sql = "delete from emp where id = ?";
        int count = template.update(sql, 1015);
        System.out.println(count);
    }

    /**
     * 查詢 id 爲 1 的記錄，將其封裝爲 Map 集合
     */
    @Test
    public void test4() {
        String sql = "select * from emp where id = ?";
        Map<String, Object> map = template.queryForMap(sql, 1001);
        System.out.println(map);
    }

    /**
     * 查詢全部記錄，將其封裝爲 List
     */
    @Test
    public void test5() {
        String sql = "select * from emp";
        List<Map<String, Object>> maps = template.queryForList(sql);
        for (Map<String, Object> map : maps) {
            System.out.println(map);
        }
    }

    /**
     * 查詢全部記錄，將其封裝爲 Emp 對象的List集合
     */
    @Test
    public void test6() {
        String sql = "select * from emp";
        List<Emp> list = template.query(sql, new RowMapper<Emp>() {
            @Override
            public Emp mapRow(ResultSet resultSet, int i) throws SQLException {
                Emp emp = new Emp();
                int id = resultSet.getInt("id");
                String ename = resultSet.getString("ename");
                int job_id = resultSet.getInt("job_id");
                int mgr = resultSet.getInt("mgr");
                Date joindate = resultSet.getDate("joindate");
                double salary = resultSet.getDouble("salary");
                int dept_id = resultSet.getInt("dept_id");
                double bonus = resultSet.getDouble("bonus");

                emp.setId(id);
                emp.setE_name(ename);
                emp.setBounds(bonus);
                emp.setJoin_date(joindate);
                emp.setMgr(mgr);
                emp.setDept_id(dept_id);
                emp.setJob_id(job_id);
                emp.setSalary(salary);

                return emp;
            }
        });

        for (Emp emp : list) {
            System.out.println(emp);
        }
    }

    /**
     * 查詢全部記錄，將其封裝爲 Emp 對象的List集合
     */
    @Test
    public void test6_2() {
        String sql = "select * from emp";
        List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }

    /**
     * 查詢總記錄數
     */
    @Test
    public void test7() {
        String sql = "select count(id) from emp";
        Long total = template.queryForObject(sql, Long.class);
        System.out.println(total);
    }
}
View Code
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程