JDBC连接池&JDBCTemplate（五）

最新推荐文章于 2024-07-04 18:22:35 发布
最新推荐文章于 2024-07-04 18:22:35 发布
阅读量349 收藏 1
点赞数
分类专栏： MySQL与JDBC 文章标签： 数据库 java mysql spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45585288/article/details/107921668
版权

数据库连接池

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

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

3.弊端
  第一次创建的时候会略微多消耗一点时间，第二次开始就会快很多。

4. 实现：
  在Java中怎么表示数据库连接池？
    接口：DataSource 链接池又叫数据(Data)源(Source)
      1. 标准接口：DataSource java.sql包下的
        1. 方法：
          * 获取连接：getConnection()
          * 归还连接：Connection.close()。 如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则 理解为：不是关闭连接。而是归还连接。

      2. 一般我们不去实现它，有数据库厂商来实现。有两种数据库连接池（C3P0、Druid）
        1. C3P0： 数据库连接池技术 //了解
          以前框架：ssh（spring、structs2、hibernate）

后来框架：ssm（spring、springMVC、mybatis）

        2. Druid：数据库连接池实现技术，由阿里巴巴（Made in China）提供的 （重点掌握）

  面试题：普通的连接（Connection对象）的close方法和数据库连接池中的连接（Connection对象）的close方法有什么区别？
    1.普通的连接：释放、销毁
    2.数据库连接池的连接：将连接归还到数据库连接池中 （动态代理）

5. C3P0：数据库连接池技术
 * 步骤：
   1. 导入jar包 (两个) c3p0-0.9.5.5.jar mchange-commons-java-0.2.19.jar ，
    外加配置文件（一个）：c3p0-config.xml
     * 不要忘记导入数据库驱动jar包
   2. 定义配置文件：
     * 名称： c3p0.properties 或者 c3p0-config.xml （其他名字不行）
     * 路径： 直接将文件放在src目录下即可。 （其他目录也不行）
      如果使用C3P0连接池一定要注意放在src下，名字也是固定的 c3p0.properties 或者 c3p0-config.xml

   3. 创建核心对象 数据库连接池对象 ComboPooledDataSource
   4. 获取连接： getConnection

代码：

     //1.创建数据库连接池对象
       DataSource ds  = new ComboPooledDataSource();
    //2. 获取连接对象
       Connection conn = ds.getConnection();

    (1)为什么要导入jar包？
      因为JDK自带的jar包中没有吗，而我现在又要使用，这个时候就必须要导入jar包名

6.Druid：数据库连接池实现技术，由阿里巴巴提供的 //掌握
 1. 步骤：
   1. 导入jar包 druid-1.0.9.jar
   2. 定义配置文件：
     * 是properties形式的
     * 可以叫任意名称，可以放在任意目录下 //注意和C3p0对比
   3. 加载配置文件 使用方式: Properties
   4. 获取数据库连接池对象： 通过工厂类来获取 DruidDataSourceFactory
   5. 获取连接：getConnection

配置文件：
   代码：

# druid.properties文件的配置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db1
username=root
password=123456
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大超时时间
maxWait=3000

加载配置文件
   代码：

    Properties pro = new Properties();
	InputStream is = DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties");
	pro.load(is);
	//4.获取连接池对象
	DataSource ds = DruidDataSourceFactory.createDataSource(pro);
	//5.获取连接
	Connection conn = ds.getConnection();

 2. 定义工具类：
   1.定义一个类 JDBCutils
   2.提供静态代码块加载配置文件，初始化连接池对象
   3.提供方法
     1.获取连接方法：通过数据库连接池获取连接
     2.释放资源
     3.获取连接池的方法

代码实现：

 private  static DataSource ds;

    static {
        try {
            //1、创建Properties对象
            Properties pro = new Properties();
            //2、连接配置文件
            InputStream in = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
            pro.load(in);

            //3、获取DataSource对象
            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 throwables) {
                    throwables.printStackTrace();
                }
            }

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

            if (conn != null) {
                try {
                    conn.close();     //归还连接
                } catch (SQLException throwables) {
                    throwables.printStackTrace();

            }
        }
    }

    /**
     * 获取连接池的方法
     */
    public static DataSource getDataSource(){
        return ds;
    }

}

工具类的测试：向account添加一条记录
代码实现：

/*
    使用新的工具类
 */
public class DruidDemo2 {
    public static void main(String[] args) throws Exception {
          /**
           * 完成添加朝操作,给account添加一条记录
           */

          Connection conn = null;
        PreparedStatement pstmt =null;
        try {
              //1、获取连接
              conn = JDBCUtils.getConnection();
              //2、定义sql
              String sql ="insert into account values (null ,?,?)";
              //3、获取sql对象
              pstmt = conn.prepareStatement(sql);
              //4、给 ？ 赋值
              pstmt.setString(1,"王五");
              pstmt.setInt(2,3000);
              //5、执行sql
              int i = pstmt.executeUpdate();
              System.out.println(i);

          } catch (SQLException throwables) {
              throwables.printStackTrace();
          }finally {
                 //释放资源
                JDBCUtils.close(pstmt,conn);
          }
    }
}


Spring JDBCTemplate

三层结构：控制层（Controller层）、业务层（service层）、持久层（dao层）

JDBCTemplate是我们spring框架的一个组成部分，是持久层的一个实现方式

  1. Spring框架对JDBC的简单封装。 提供了一个JDBCTemplate对象简化JDBC的开发（就是对JDBC的一个封装）
    *步骤：

    1. 导入jar包

    2. 创建JdbcTemplate对象。依赖于数据源DataSource

       JdbcTemplate template = new JdbcTemplate(ds);
 参数：ds是数据库连接池对象（druid连接池）

  2. 调用JdbcTemplate的方法来完成CRUD的操作
    * update():执行DML语句。增、删、改语句
    注意：使用前需要导入jar包 方法名不要写成excuteUpdate

    * queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合//了解
	  * 注意：这个方法查询的结果集长度只能是1  (说白了就是一次性只能查询一条记录)
* queryForList():查询结果将结果集封装为list集合  //了解
	  * 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
* query():查询结果，将结果封装为JavaBean对象   //最重要
	   前提：必须先有一个"标准的"JavaBean对象
		因为我们传入的字节码文件对象，底层使用反射的方式创建对象，使用反射的调用set方法进行赋值
	* query的参数：RowMapper
		* 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
		* new BeanPropertyRowMapper<类型>(类型.class)
* queryForObject：查询结果，将结果封装为对象  //熟悉
		特点:查询的结果需要是单行单列的
	* 一般用于聚合函数的查询（比如：查询总数）

    4.JDBCTemplate快速入门

代码实现：

public class Template01 {
    public static void main(String[] args) {
        //1、导入jar包
        //2、创建JDBCTemplate对象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //3、调用方法
        String sql = "update account set balance = 5000 where id = ?";
        int update = template.update(sql,3);
        System.out.println(update);

       /**
		 *	短短几行足以。       
         *     JDBCTemplate: 
         *          不需要再申请连接了
         *          不需要再释放资源了
         *          JdbcTemplate自己内部解决了
         *
         *          只关心：如何定义sql语句、执行、处理
         */

    }
}

1、练习
需求：

  1. 修改1号数据的 salary 为 1000
  2. 添加一条记录
  3. 删除刚才添加的记录
  4. 查询 id 为1的记录，将其封装为Map集合
  5. 查询所有记录，将其封装为List
  6. 查询所有记录，将其封装为Emp对象的List集合
  7. 查询总的记录数

Emp代码的实现：

	public class Emp {
    private  Integer     id ;
    private  String  name;
    private  String  gender;
    private  Double  salary;
    private  Date join_date;
    private  Integer     dept_id;


    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    public Date getJoin_date() {
        return join_date;
    }

    public void setJoin_date(Date join_date) {
        this.join_date = join_date;
    }

    public Integer getDept_id() {
        return dept_id;
    }

    public void setDept_id(Integer dept_id) {
        this.dept_id = dept_id;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", salary=" + salary +
                ", join_date=" + join_date +
                ", dept_id=" + dept_id +
                '}';
    }
}

练习代码：

public class Template02 {

    //每一个@Test都要写一次如下代码，所以直接提升作用域,使其template的作用域为成员变量
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());

    /**
     * 1、修改1号数据的 salary 为 1000
     */
    @Test
    public void test1() {
        String sql1 = "update emp00 set salary = ? where id = ?";
        int i = template.update(sql1,1000,1);
        System.out.println(i);
    }

    /**
     * 2、添加一条记录
     */
    @Test
    public void tset02() {
        String sql = "insert into emp00(id,name,gender) values (?,?,?)";
        int i = template.update(sql,6,"沙悟净","男");
        System.out.println(i);
    }

    /**
     * 3、删除刚才添加的记录
     */
    @Test
    public void test03() {
        String sql = "delete from emp00 where id in (?,?)";
        int update = template.update(sql, 6, 7);
        System.out.println(update);
    }

    /**
     * 4、查询 id 为1的记录，将其封装为Map集合
     * queryForMap方法的代码实现
     *  注意：这个方法查询的结果集长度只能是 :1  (说白了就是一次性只能查询一条记录)
     */
    @Test
    public void test04() {
        String sql = "select * from emp00 where id =?";
        Map<String, Object> map = template.queryForMap(sql, 1);

        System.out.println(map);
        //{id=1, name=孙悟空, gender=男, salary=1000.0, join_date=2013-02-24, dept_id=1}
    }

    /**
     * 5、查询所有记录，将其封装为List
     * queryForList方法的代码实现
     * 将每一条记录封装为一个Map集合，再将Map集合装载到List集合中  (说白了就是重复多次test04)
     */
    @Test
    public void test05() {
        String sql = "select * from emp00";
        List<Map<String, Object>> list = template.queryForList(sql);

        //遍历 使得输出结果换行。
        for (Map<String, Object> map : list) {
            System.out.println(list);
        }


    }

   /**
    *  6、查询所有记录，将其封装为Emp对象(JavaBean对象)的List集合
    *  和package domain下的Emp 组队
    */
    @Test
    public void test06() {
        String sql = "select * from emp00 ";
        List<Emp> list = template.query(sql, new RowMapper<Emp>() {

            @Override
            public Emp mapRow(ResultSet rs, int i) throws SQLException {
                Emp emp = new Emp();

                int id = rs.getInt("id");
                String name = rs.getString("name");
                String gender = rs.getString("gender");
                double salary = rs.getDouble("salary");
                Date join_date = rs.getDate("join_date");
                int dept_id = rs.getInt("dept_id");

                emp.setId(id);
                emp.setName(name);
                emp.setGender(gender);
                emp.setSalary(salary);
                emp.setJoin_date(join_date);
                emp.setDept_id(dept_id);


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

    /**
     *  6、查询所有记录，将其封装为Emp对象(JavaBean对象)的List集合
     *  简化上述代码
     */
    @Test
    public void test07() {
        String sql = "select * from emp00 ";
        List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));

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

    }

    /**
     * 7、查询总的记录数
     */
    @Test
    public void test08() {
        String sql = "select count(*) from emp00 ";
        Long total = template.queryForObject(sql, Long.class);

        System.out.println(total);
    }
}
弑神灬索隆。
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring JdbcTemplate释放连接
sgq0085的专栏
07-22 1万+
前言 Spring JdbcTemplate在通过DataSourceUtils管理Connection，DataSourceUtils通过ConnectionHolder管理Connection。并且将ConnectionHolder保存在ThreadLocal，所以是线程安全的。 详见org.springframework.jdbc.datasource.DataSourceUtils...
JDBC连接池&JDBCTemplate
二月
01-28 196
2020.9.9 文章目录数据库连接池C3P0：数据库连接池技术Druid：数据库连接池实现技术，由阿里巴巴提供的Spring JDBC 数据库连接池 概念：其实就是一个容器(集合)，存放数据库连接的容器。 当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。 好处： 节约资源 用户访问高效 实现： 标准接口：DataSource接口 位于javax.sql包下的 方法： 获取连接：getConn
JdbcTemplate基本使用
01-27
DBC已经能够满足大部分用户最基本的需求，但是在使用JDBC时，必须自己来管理数据库资源如：获取PreparedStatement，设置SQL语句参数，关闭连接等步骤。 JdbcTemplate是Spring对JDBC的封装，目的是使JDBC更加易于使用。JdbcTemplate是Spring的一部分。JdbcTemplate处理了资源的建立和释放。他帮助我们避免一些常见的错误，比如忘了总要关闭连接。他运行核心的JDBC工作流，如Statement的建立和执行，而我们只需要提供SQL语句和提取结果。 在JdbcTemplate中执行SQL语句的方法大致分为3类： execute：可以执行所有S
JdbcTemplate 使用总结
weixin_44491927的博客
11-22 714
JdbcTemliate 执行增删改查操作
JdbcTemplate数据库连接耗尽问题排查
SherJamYu的博客
09-28 4463
JdbcTemplate 数据库连接耗尽
JDBC-数据库连接池-SpringJDBCTemplate
Able033的博客
04-06 143
数据库连接池 概念：存放数据库连接的容器。当系统初始化好后容器被创建，容器申请一些对象，当用户访问数据库时从容器中获取连接对象，用户访问完之后会将连接对象归还给容器。 实现： 1.标准接口：DataSource javax.sql包下的 （1）获取连接：getConnection() （2）归还连接：如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法不会关闭连接。而是归还连接。 2.数据库厂商实现： ...
JDBC数据库连接池 + JdbcTemplate
qq_36450449的博客
08-27 1279
本篇博客的主要内容有两个：1.JDBC 数据库连接池 2.JdbcTemplate； 1.JDBC 数据库连接池 1.相关概念及其他 2.C3P0数据库连接池 3.Druid数据库连接池 4.JDBCUtils 5.整体使用 2.JdbcTemplate 1.相关概念及其他 2.JdbcTemplate使用步骤 3.template的一些方法 4.练习 ...
day06_JDBC连接池&JDBCTemplate2
08-08
JDBC（Java Database Connectivity）是...JDBC连接池和JDBCTemplate是其在实际开发中的两个重要补充，它们提高了性能和代码质量，简化了数据库操作的复杂度。了解并熟练掌握这些知识，对于Java开发人员来说至关重要。
day06_JDBC连接池&JDBCTemplate_docx1
08-04
【JDBC连接池&JDBCTemplate】是Java开发中处理数据库交互的重要技术。JDBC是Java Database Connectivity的缩写，它提供了一组接口和类，使得Java程序能够与各种类型的数据库进行通信。JDBC不仅是Java操作数据库的...
JDBC连接池&JDBCTemplate课堂笔记.md
05-05
JDBC连接池&JDBCTemplate课堂笔记.md
Spring 数据库连接池（JDBC）详解
08-30
Spring 数据库连接池（JDBC）详解 本篇文章主要介绍了基于 Spring 的 JDBC 基本框架搭建、基于 Spring 的 JDBC增删改查、读取配置文件中的数据等，具有很好的参考价值。下面我们来详细讲解。 一、数据库连接池的...
Spring源码深度解析：十三、JdbcTemplate 的源码分析
代码的知行者
12-12 916
考虑到存在事务的情况，如果当前线程存在事务，那么说明在当前线程中存在共用数据库连接（存在事务则说明不止一个sql 语句被执行，则会共用同一个数据库连接, 所以如果当前Sql执行完毕，不能立即关闭数据库连接，而是将引用次数减一），这种情况下直接使用。对于警告的处理方式并不是直接抛出异常，出现警告很可能会出现数据错误，但是并不一定会影响程序执行，所以这里用户可以自己设置处理警告的方式，如果默认是忽略警告，当出现警告时仅打印警告日志，不抛出异常。如有侵扰，联系删除。除此之外，还有另一种形式的更新，其思路都相同。
Druid,JDBCTemplate连接池详解
大美妞的博客
03-26 4495
Druid 为什么使用连接池呢？什么时连接池？ 概念：就是一个容器（集合），存放数据库的连接的容器 当系统初始化化好了以后，容器就会被创建，容器中会被申请一些连接对象，当用户用来访问数据库后，会将连接对象归还给池子。 好处： 1，节约资源 2，用户访问高效。不用来回的申请资源，释放资源浪费时间。 Druid是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是目前国产的连接池中...
jdbc&数据库连接池&jdbcTemplate教程
...
07-31 2977
​ Java DataBase Connectivity，也就是Java 数据库连接，Java语言操作数据库​ 其实是官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包，我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。​ 步骤：​ 1.导入驱动jar包​ 2.注册驱动​ 3.获取数据库的连接对象 Connection​ 4.定义sql语句​ 5.获取执行sql语句的对象 S...
jdbctemplate连接释放_设计模式及其在Spring中的应用——模板模式 在JdbcTemplate中...
weixin_39720181的博客
01-29 917
模板模式在JdbcTemplate模板模式模板模式UML图在模板模式中：父类定义了骨架（调用哪些方法及顺序），某些特定方法由子类实现。最大的好处：代码复用，减少重复代码。除了子类要实现的特定方法，其他方法及方法调用顺序都在父类中预先写好了。所以父类模板方法中有两类方法：共同的方法： 所有子类都会用到的代码不同的方法： 子类要覆盖的方法，分为两种：抽象方法：父类中的是抽象方法，子类必须覆盖钩子方法：...
jdbc获取connection的五种方法
m0_59084856的博客
08-04 298
获取数据库连接5种方式获取数据库连接5种方式方式1（不推荐）方式2（不推荐）方式3（不推荐）方式4（推荐）
流式数据库 RisingWave「Demo」：直播指标实时分析
最新发布
https://risingwave.com/
07-04 801
直播是目前最为流行的娱乐形式之一，本教程将分享如何使用开源流式数据库 RisingWave 监控直播指标。我们为本教程设置了一个演示集群，以便大家可以轻松尝试。
简述手写连接池的实现过程及自定义JDBCTemplate的实现过程。
04-20
好的，我可以回答关于手写连接池和自定义JDBCTemplate的问题。手写连接池的实现过程包括以下步骤：首先，创建一个连接池对象，设置连接池大小和初始化连接数；接着，创建一个连接对象，并将其加入到连接池中；当有数据查询请求时，从连接池中获取一个连接对象，并执行查询操作；查询结束后，将连接对象放回连接池中。至于自定义JDBCTemplate的实现过程，它是Spring框架中的一个重要组件，主要作用是简化数据访问层的操作。首先，创建一个JDBC模板类，并定义连接池对象和数据源；接着，定义CRUD的方法，包括增删改查；在方法中，通过连接池对象获取连接对象，使用Connection类实现增删改查等操作。这是简单的答案，但如果需要更详细的解答，我可以提供进一步的信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值