java常用的数据库连接池C3P0、Druid以及Spring JDBC总结
java    

java常用的数据库连接池C3P0、Druid以及Spring JDBC总结

124 次访问
三国小梦
Scroll Down

数据库连接池简介

概念

数据库连接池就是一个容器(集合)，存放数据库连接的容器。当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。

好处

  1. 节约资源
  2. 用户访问高效

实现

  1. 标准接口：javax.sql.DataSource

    1. 方法：

      • 获取连接：getConnection()
      • 归还连接：Connection.close()如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接了。而是归还连接

    2. 一般我们不去实现它，有数据库厂商来实现

      1. C3P0：数据库连接池技术
      2. Druid：数据库连接池实现技术，由阿里巴巴提供的

C3P0

可以在这里下载 这里 最新版jar包

步骤

  1. 导入jar包（不要忘记导入数据库驱动jar包）

    • c3p0-0.9.5.2.jar
    • mchange-commons-java-0.2.12.jar(c3p0的依赖jar包)

  2. 定义配置文件：

    • 名称： c3p0.properties 或者 c3p0-config.xml
    • 路径：直接将文件放在src目录下即可。

  3. 创建核心对象 数据库连接池对象 ComboPooledDataSource

  4. 获取连接： getConnection

代码

  1. 定义配置文件c3p0-config.xml
<c3p0-config>
  <!-- 使用默认的配置读取连接池对象 -->
  <default-config>
  	<!--  连接参数 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/db</property>
    <property name="user">root</property>
    <property name="password">123456</property>
    
    <!-- 连接池参数 -->
    <!--初始化申请的连接数量-->
    <property name="initialPoolSize">5</property>
    <!--最大的连接数量-->
    <property name="maxPoolSize">10</property>
    <!--超时时间-->
    <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/db</property>
    <property name="user">root</property>
    <property name="password">123456</property>
    
    <!-- 连接池参数 -->
    <property name="initialPoolSize">5</property>
    <property name="maxPoolSize">8</property>
    <property name="checkoutTimeout">1000</property>
  </named-config>
</c3p0-config>
  1. 编写测试类
public class C3P0Demo1 {
    public static void main(String[] args) throws SQLException {
        // 创建数据库连接池对象，不传参数使用默认配置
        DataSource ds = new ComboPooledDataSource();
	// 传参时，只用指定的配置
	// DataSource ds = new ComboPooledDataSource("otherc3p0");
        // 获取连接对象
        Connection connection = ds.getConnection();
        PreparedStatement ps = connection.prepareStatement("select * from student");
        ResultSet resultSet = ps.executeQuery();
        ArrayList<Student> students = new ArrayList<>();
        while (resultSet.next()) {
            Student stu = new Student(
                    resultSet.getInt("id"),
                    resultSet.getString("name"),
                    resultSet.getInt("age"),
                    resultSet.getString("sex"),
                    resultSet.getString("address"),
                    resultSet.getInt("math"),
                    resultSet.getInt("english")
            );
            students.add(stu);
        }
        // 把连接对象归还数据库连接池
        connection.close();
        students.forEach(System.out::println);
    }
}

Druid

可以在这里下载 这里 最新版jar包 ，推荐使用这里，由阿里巴巴提供国产的

步骤

  1. 导入jar包 druid-1.0.9.jar(不要忘记导入数据库驱动jar包)
  2. 定义配置文件：
    • 是xxx.properties形式的
    • 可以叫任意名称，可以放在任意目录下
  3. 加载配置文件。
  4. 获取数据库连接池对象：通过工厂来来获取DruidDataSourceFactory
  5. 获取连接：getConnection

代码

  1. 定义配置文件
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db
username=root
password=123456
initialSize=5
maxActive=10
maxWait=3000
  1. 编写测试类
public class DruidDemo1 {
    public static void main(String[] args) throws Exception {
        //1.加载配置文件
        Properties pro = new Properties();
        InputStream is = DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties");
        pro.load(is);
        //2.获取连接池对象
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);
        //3.获取连接
        Connection connection = ds.getConnection();
        
        PreparedStatement ps = connection.prepareStatement("select * from student");
        ResultSet resultSet = ps.executeQuery();
        ArrayList<Student> students = new ArrayList<>();
        while (resultSet.next()) {
            Student stu = new Student(
                    resultSet.getInt("id"),
                    resultSet.getString("name"),
                    resultSet.getInt("age"),
                    resultSet.getString("sex"),
                    resultSet.getString("address"),
                    resultSet.getInt("math"),
                    resultSet.getInt("english")
            );
            students.add(stu);
        }
        // 把连接对象归还数据库连接池
        connection.close();
        students.forEach(System.out::println);
    }
}

定义工具类

  1. 定义一个类 JDBCUtils
  2. 提供静态代码块加载配置文件，初始化连接池对象
  3. 提供方法
    1. 获取连接方法：通过数据库连接池获取连接
    2. 释放资源
    3. 获取连接池的方法(使用Spring JDBC时需要)
public class JDBCUtils {

    //1.定义成员变量 DataSource
    private static DataSource ds ;

    static{
        try {
            //1.加载配置文件
            Properties pro = new Properties();
            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            //2.获取DataSource
            ds = DruidDataSourceFactory.createDataSource(pro);
        } 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;
    }
}

Spring JDBC

点击这里，下载最新版jar包

Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
步骤

  1. 导入jar包

    • spring-jdbc-5.0.0.RELEASE-sources.jar
    • spring-beans-5.0.0.RELEASE-sources.jar(依赖包)
    • spring-core-5.0.0.RELEASE-sources.jar(依赖包)
    • spring-tx-5.0.0.RELEASE-sources.jar(依赖包)

  2. 创建JdbcTemplate对象。依赖于数据源（数据库连接池）DataSource

    • JdbcTemplate template = new JdbcTemplate(ds)

  3. 调用JdbcTemplate的方法来完成CRUD的操作（常用）

    • update(String sql,Object... args):执行DML语句。增、删、改语句
    • queryForMap(String sql,Object... args):查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
      • 注意：这个方法查询的结果集长度只能是1
    • queryForList(String sql,Object... args):查询结果将结果集封装为list集合
      • 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
    • query(String sql,RowMapper<T> rowMapper,Object... args):查询结果，将结果封装为JavaBean对象
      • query的参数：RowMapper
        • 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
        • new BeanPropertyRowMapper<类型>(类型.class)
    • queryForObject(String sql,Class<T> requiredType,Object... args)：查询结果，将结果封装为对象
      • 一般用于聚合函数的查询

注意：写sql语句时用？作为占位符，在调用方法时，传入sql语句，占位符要赋的值即可
例如：template.queryForList("select * from student where id=?",1),参数不限，有多个参数时，占位符赋值方法参数列表最后

案例

Student.java

public class Student {
    private int id;
    private String name;
    private int age;
    private String sex;
    private String address;
    private int math;
    private int english;

    // 当有其他构造方法时，必须又个空参的构造方法，否则spring jdbc会报错，或者都不写也可以
    public Student() {
    }

    public Student(int id, String name, int age, String sex, String address, int math, int english) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.address = address;
        this.math = math;
        this.english = english;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getEnglish() {
        return english;
    }

    public void setEnglish(int english) {
        this.english = english;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                ", math=" + math +
                ", english=" + english +
                '}';
    }
}

测试类

public class SpringJDBCDemo{


    public static void main(String[] args) {
        JdbcTemplate template = new JdbcTemplate(JDBCUtils2.getDataSource());
        List<Map<String, Object>> maps = template.queryForList("select * from student where id=?",1);
        for (Map<String, Object> map : maps) {
            System.out.println(map);
        }
        System.out.println("----------------------------");
        // Student 需要一个空参构造方法
        List<Student> query = template.query("select * from student where id=? or id=?", new BeanPropertyRowMapper<Student>(Student.class),1,3);
        query.forEach(System.out::println);

        System.out.println("----------------------------");
        Integer integer = template.queryForObject("select count(id) from student where sex=?", Integer.class,"男");
        System.out.println(integer);

        System.out.println("----------------------------");

    }
}
运行结果：
五月 19, 2020 6:37:52 下午 com.alibaba.druid.pool.DruidDataSource info
信息: {dataSource-1} inited
{id=1, name=马云, age=55, sex=男, address=杭州, math=66, english=78}
----------------------------
Student{id=1, name='马云', age=55, sex='男', address='杭州', math=66, english=78}
Student{id=3, name='马景涛', age=55, sex='男', address='香港', math=56, english=77}
----------------------------
5
----------------------------

Process finished with exit code 0

本文由 三国小梦 创作，如果您觉得本文不错，请随意赞赏
采用 知识共享署名4.0 国际许可协议进行许可
本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名
原文链接：https://lxy.zone/archives/java常用的数据库连接池c3p0druid以及springjdbc总结
最后更新于：2020-05-19 21:37:12

最新文章
Servlet+spring 纯java配置(无xml)

pom.xml<!--spring--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><v
spring+springmvc+mybatis-plus纯java环境搭建

修改pom.xml<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope&
spring boot+thymeleaf整合shiro并实现记住密码

至于在springboot中使用shiro,配置起来就简单多了，具体如下创建一个spirngboot项目，导入依赖在创建时除了勾选web依赖、mybatis依赖、lombok依赖外，还要手动添加以下依赖<!--springboot中使用jsp模板--><dependency>
spring mvc整合shiro

shiro整合springmvc,配置比较麻烦，先搭建springmvc环境，然后再整合，本文主要是介绍shiro至于使用mybatis访问数据库，请参考之前文章创建maven项目并修改pom.xml文件导入jar包<!--servlet--><dependency><
shiro快速入门

ApacheShiro从一开始就设计为支持任何应用程序-从最小的命令行应用程序到最大的群集Web应用程序。本案例从java程序开始简易版（读取配置文件的用户名密码）需求在控制台输入用户名和密码实现简单登录创建maven项目并导入依赖<!--shiro核心jar包--><depend
分类
标签
mybatis-plus mybatis-plus
spring boot springboot
shiro shiro
spring mvc springmvc
spring spring
mybatis mybatis
redis redis
json json
filter filter
jsp jsp
servlet servlet
tomcat tomcat
xml xml
生活 生活
halo halo
mysql mysql
java java
linux linux
python python
算法笔记 算法笔记
html html
docker docker