My SQL-day06--数据库连接池、Spring JDBC : JDBC Template

最新推荐文章于 2024-01-26 08:59:10 发布
最新推荐文章于 2024-01-26 08:59:10 发布
阅读量128 收藏
点赞数
分类专栏： My SQL 文章标签： 数据库 mysql java jdbc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xingxing_LM/article/details/112159693
版权

数据库连接池

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

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

3. 实现：
	1. 标准接口：DataSource   javax.sql包下的
		1. 方法：
			* 获取连接：getConnection()
			* 归还连接：Connection.close()。如果连接对象Connection是从连接池中获取的，
			  那么调用Connection.close()方法，则不会再关闭连接了。而是归还连接

	2. 一般我们不去实现它，有数据库厂商来实现
		1. C3P0：数据库连接池技术
		2. Druid：数据库连接池实现技术，由阿里巴巴提供的

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
    导入包：
    在这里插入图片描述在这里插入图片描述

在这里插入图片描述

配置文件：
在这里插入图片描述

com.mysql.jdbc.Driver jdbc:mysql://localhost:3306/db4 root 123456 
<!-- 连接池参数 -->
<!-- 初始化申请的连接数量 -->
<property name="initialPoolSize">5</property>
<!-- 最大的连接池对象 -->
<property name="maxPoolSize">10</property>
<!-- 超时时间 -->
<property name="checkoutTimeout">3000</property>
com.mysql.jdbc.Driver jdbc:mysql://localhost:3306/db4 root 123456 
<!-- 连接池参数 -->
<property name="initialPoolSize">5</property>
<property name="maxPoolSize">8</property>
<property name="checkoutTimeout">1000</property>

代码实现：

package datasource.c3p0;

import com.mchange.v2.c3p0.ComboPooledDataSource;

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

public class C3P0Demo1 {
    public static void main(String[] args) throws Exception {
        //0.导入jar包和配置文件

        //1.创建数据库连接池
        DataSource ds = new ComboPooledDataSource();//使用的默认的配置
        //DataSource ds = new ComboPooledDataSource("otherc3p0");//使用的命名的配置

        //2.获取连接
        Connection conn = ds.getConnection();

        //3.打印连接
        System.out.println(conn);

    }
}

druid：

步骤：
1. 导入jar包 druid-1.0.9.jar
2. 定义配置文件：
* 是properties形式的
* 可以叫任意名称，可以放在任意目录下
3. 加载配置文件。Properties
4. 获取数据库连接池对象：通过工厂来来获取 DruidDataSourceFactory
5. 获取连接：getConnection
导入包：
在这里插入图片描述
在这里插入图片描述
配置文件：
在这里插入图片描述
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db3
username=root
password=123456
#初始化连接数量
initialSize=5
#最大连接数量
maxActive=10
#最大等待时间
maxWait=3000

Druid演示

package datasource.druid;

import com.alibaba.druid.pool.DruidDataSource;
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 DruidDemo {
    public static void main(String[] args) throws Exception {


    //1.导入jar包
    //2.定义配置文件

    //3.加载配置文件
    Properties pro = new Properties();
        InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
        pro.load(is);

    //4.获取连接池对象
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);

    //5.获取连接
        Connection conn = ds.getConnection();
        System.out.println(conn);
    }
}

利用工具类来封装druid，在调用工具类操作数据库
druid工具类：

package datasource.util;

import com.alibaba.druid.pool.DruidDataSourceFactory;

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

/*
Druid连接池的工具类
 */
public class JDBCUtil {
    //1.定义成员变量 DataSource
    private static DataSource ds;

    static {
        try {
            //1.加载配置文件
            Properties pro = new Properties();
            InputStream rs = JDBCUtil.class.getClassLoader().getResourceAsStream("druid.properties");
            pro.load(rs);

            //2.获取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){
        if (stmt !=null){
            try {
                stmt.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

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



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

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

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

    }


    /**
     * 获取连接池的方法
     *
     */

    public static  DataSource getDataSource(){
        return ds;
    }
}

测试类：

package datasource.druid;

import datasource.util.JDBCUtil;

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

/**
 * 使用durid工具类
 */
public class JDBCUtilTest {
    public static void main(String[] args) {
        //给account 表添加一条记录
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            //1.获取连接
            conn = JDBCUtil.getConnection();

            //2.定义sql语句
            String sql = "insert into account values(null,?,?)";

            //3.获取pstmt对象
            pstmt = conn.prepareStatement(sql);
            //4.给sql赋值
            pstmt.setString(1,"zhao");
            pstmt.setDouble(2,5000);
            //5.执行语句
            int i = pstmt.executeUpdate();
            System.out.println(i);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            //释放资源
            JDBCUtil.close(pstmt,conn);
        }
    }
}

Spring JDBC : JDBC Template，在Druid的基础上实现

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

      1. 导入jar包（不要忘记驱动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的参数：RowMapper
            • 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
            • new BeanPropertyRowMapper<类型>(类型.class)
        • queryForObject：查询结果，将结果封装为对象
          • 一般用于聚合函数的查询

      4. 练习：

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

import java.util.Date;

/**
 * 封装Emp
 */
public class Emp {

    private Integer id;
    private String ename;
    private Integer job_id;
    private Integer mgr;
    private Date joindate;
    private Double salary;
    private Double bonus;
    private Integer dept_id;


    public Integer getId() {
        return id;
    }

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

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public Integer getJob_id() {
        return job_id;
    }

    public void setJob_id(Integer job_id) {
        this.job_id = job_id;
    }

    public Integer getMgr() {
        return mgr;
    }

    public void setMgr(Integer mgr) {
        this.mgr = mgr;
    }

    public Date getJoindate() {
        return joindate;
    }

    public void setJoindate(Date joindate) {
        this.joindate = joindate;
    }

    public Double getSalary() {
        return salary;
    }

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

    public Double getBonus() {
        return bonus;
    }

    public void setBonus(Double bonus) {
        this.bonus = bonus;
    }

    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 +
                ", ename='" + ename + '\'' +
                ", job_id=" + job_id +
                ", mgr=" + mgr +
                ", joindate=" + joindate +
                ", salary=" + salary +
                ", bonus=" + bonus +
                ", dept_id=" + dept_id +
                '}';
    }
}

练习测试类：

package jdbctemplate;

import datasource.util.JDBCUtil;
import domain.Emp;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

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

public class JdbcTemplateDemo2 {
    //Junit单元测试，可以让方法独立运行
    //1.获取JdbcTemplate对象,,,,,这里用到了JDBCUtil中获取datasource的方法
    private JdbcTemplate template = new JdbcTemplate(JDBCUtil.getDataSource());

    /**
     * 修改1号数据的salary的数据为10000
     */
    @Test
    public void test1(){

        //2.定义Sql语句
        String sql = "update emp set salary = ? where id = ?";
        //3.执行sql语句
        int i = template.update(sql,10000,1001);
        System.out.println(i);

    }
    //添加一条记录
    @Test
    public void test2(){
        String sql ="insert into emp(id,ename,dept_id) values(?,?,?)";
        int i = template.update(sql, 1015, "guojing", 10);
        System.out.println(i);
    }

    //删除刚才添加的记录
    @Test
    public void test3(){
        String sql = "delete from emp where id = ?";
        int i = template.update(sql, 1015);
        System.out.println(i);
    }

    /**
     * 4.查询id为1的记录，将其封装为Map集合
     * 查询的结果集长度只能是1
     */
    @Test
    public void test4(){
        String sql = "select * from emp where id = ?";
        Map<String, Object> map = template.queryForMap(sql, 1001);
        System.out.println(map);
        //{id=1001, ename=孙悟空, job_id=4, mgr=1004, joindate=2000-12-17, salary=10000.00, bonus=null, dept_id=20}
    }

    /**
     * 5.查询所有记录，将其封装为List
     * 他会将其封装为map集合，然后再装到list集合中去
     */
    @Test
    public void test5(){
        String sql = "select * from emp";
        List<Map<String, Object>> list = template.queryForList(sql);
        for (Map<String, Object> stringObjectMap : list) {
            System.out.println(stringObjectMap);
        }
    }

    /**
     * 6.查询所有记录，将其封装为Emp对象的集合,再封装为list返回list对象
     */
    @Test
    public void test6(){
        String sql = "select * from emp";
        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 ename = rs.getString("ename");
                int job_id = rs.getInt("job_id");
                int mgr = rs.getInt("mgr");
                Date joindate = rs.getDate("joindate");
                double salary = rs.getDouble("salary");
                double bonus = rs.getDouble("bonus");
                int dept_id = rs.getInt("dept_id");

                emp.setId(id);
                emp.setEname(ename);
                emp.setJob_id(job_id);
                emp.setMgr(mgr);
                emp.setJoindate(joindate);
                emp.setSalary(salary);
                emp.setBonus(bonus);
                emp.setDept_id(dept_id);


                return emp;
            }
        });
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }
	
	//6.2查询所有记录，将其封装为Emp对象的集合,再封装为list返回list对象
    //一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装

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


    /**
     * 7.查询总记录数
     */
    @Test
    public void tes7(){
        String sql = "select count(id) from emp";
        Long total = template.queryForObject(sql, Long.class);
        System.out.println(total);
    }
}
grilla1024
关注
专栏目录
修改了别人的代码、优化前与优化后的对比，唉，写个好代码真不容易啊
通用权限管理系统
01-04 1259
   最近紧急接手别人做了一半的项目，看了一些代码，惨不忍睹，也号称是上海的IT公司写的代码，还说自己是做了很多年的政府项目，自信得很，态度很高傲、目中无人，我是彻底服了，我已经很嚣张了，居然比我还嚣张很多很多，项目做得一塌糊涂，代码质量还这么差，当然也不是说我的代码写得有多好，只是想说，写代码需要认真再认真，需要仔细做好每件事、日积月累，才能有个良好的技术积累、项目积累，想赚钱也会容易很
JavaWeb-02（JDBC、数据库连接池、Spring JDBC）
weixin_46117619的博客
04-20 313
JavaWeb-02（JDBC） 1. JDBC 概念及快速入门2. DriverManager3. Connection4. Statement5. ResultSet6.JDBC工具类 1. JDBC 概念及快速入门 概念：Java DataBase Connectivity Java 数据库连接， Java语言操作数据库 * JDBC本质：其实是官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。 各个数据库厂商去实现这套接口，提供数据库驱动jar包。 我们可以
JDBC部分已经很难找到的jar包
03-23
mysql-connector 5.1.46 commons-dbcp2-2.5.0 commons-logging-1.2 commons-pool2-2.6.0 druid-1.1.9
太难了，我终于把JDBC的代码终于优化了！
qq_44715697的博客
09-23 255
开篇声明：需要jar包和配置文件的兄弟们可以去我的主页免费下载。 数据库连接池 1.概念 数据库连接池就是一个容器（集合），存放数据库连接的容器。 在之前我们学到的JDBC操作中，我们在进行操作之前都要向系统底层获取连接对象，在执行完操作之后就会对连接进行释放。这样的方法不仅会大大降低执行效率，而且会浪费很多的资源。为了应对这样的情况，就需要数据库连接池。 当系统初始化后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完成之后，会将连接对象归还给容器。 2..
太复杂了么，秒懂jdbc的用法
Jump2code的博客
06-05 430
jdbc大家都知道是用来链接数据库的，可以说用法也是固定的 String DBUser="";//数据库登陆用户名 String DBUser="root";//数据库登陆用户名 String DBPwd="root";//数据库登陆密码 String DBHost="127.0.0.1";//数据库主机IP地址 String DBName="myshool";//数据库名字 int
全面解析JDBC
胡杨的知识库
05-03 1033
全面解析JDBC  　　综述：Java数据库连接体系结构是用于Java应用程序连接数据库的标准方法。JDBC对Java程序员而言是API，对实现与数据库连接的服务提供商而言是接口模型。作为API，JDBC为程序开发提供标准的接口，并为数据库厂商及第三方中间件厂商实现与数据库的连接提供了标准方法。JDBC使用已有的SQL标准并支持与其它数据库连接标准，如ODBC之间的桥接。JDBC实现了所有这些面向
数据库连接池：C3P0、Druid、Spring JDBC ----JDBC Template
weixin_45291606的博客
05-02 109
数据库连接池 1. 概念：其实就是一个容器(集合)，存放数据库连接的容器。 当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。 2. 好处： 1. 节约资源。 2. 用户访问高效。 3. 实现： 1. 标准接口：DateSource javax.sql包下的 1. 方法： * 获取连接：g...
Java学习（数据库连接池(C3P0,Druid),Spring框架对JDBC的简单封装)
XXX_17的博客
03-01 280
2022/2/29 一、数据库连接池 1.概念：其实就是一个容器（集合），存放数据库连接的容器. 当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完后，会将连接对象归还给容器。 2.好处：节省资源，还可以使用户访问高效 3.实现： 1)标准接口：DataSource javax.sql包下的 1.1方法： ...
JDBC：Java数据库连接使用和简化
努力吃书的小白
04-05 369
学习了jdbc连接和连接池c3p0、druid两种实现后对其进行的整理笔记，除此之外还附加了JDBC Template和junit两个很好用的插件的好处和具体使用，跪求大佬们多多指点。
springboot集成sharding-jdbc mybatis-plus连接oracle实现单库按月份分表及注意事项
he3more的博客
11-01 1937
文章目录sharding-jdbc简介引入依赖前置准备sharding-jdbc配置分表验证整合mybatis-plus不支持的操作 sharding-jdbc简介 sharding-jdbc是一个轻量级Java框架，在Java的JDBC层提供的额外服务。 它使用客户端直连数据库，以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。 适用于任何基于Java的ORM框架，如：JPA, Hibernate, Mybatis, Spring JDBC T
【Spring】spring对jdbc的优化
Evan_QB的博客
10-26 565
使用步骤: 先引入jdbc相关jar包 然后在db.properties中配置连接数据库的信息 jdbc.user=root jdbc.password=root jdbc.driverClass=com.mysql.jdbc.Driver jdbc.jdbcUrl=jdbc:mysql:///day09 jdbc.initPoolSize=5 jdbc.maxPoolSize=10
刚刚完成的，关于JAVA中oracle数据库连接的（jdbc)，难度不高！！！
wumeilan的专栏
07-29 574
简单的数据库操作，包括数据库连接及数据的查询、插入、删除、修改！！！
学习JDBC，写代码的时候思路不清晰该怎么办？花花教你一个口诀解决。
最新发布
weixin_70317964的博客
01-26 217
2.类和对象不会写，那就是javase仍有欠缺，记得好好复习javase呦。1.如果实在数据库连接方面有困难，那就着重再次复习一遍jdbc链接。&&花花在这里祝每个看过帖子的小伙伴都能代码全通过，bug全绕道。基本上大体思路就是这样子啦，如果里边的代码不会写该怎么办？首先要确定你是那些代码不会写；1）创建项目（导入jar包）1.那笔先写思路步骤。
简单的jdbc
Milky1994的专栏
04-21 105
我一直以为自己在学校学得还挺好的，来苏州实训的时候才知道自己差多少，我根本一点都不懂Java。 钱就不说了，可是还要用4个月的时间来再学一遍，后悔这两个字以后就不想了，说多了都是眼泪。   就说一下jdbc吧，我反应好慢，老师讲过后我又问老师好几遍， package jdbc;   import java.sql.Connection; import java.sql.Driver...
JDBC从入门到放弃
猿生之路
08-07 226
一、前言 之前学过一点jdbc，但后来会了Mybatis，就放弃了JDBC的记忆，这两天将JDBC重新学习了一遍，现在记录一下学习的内容 二、什么是JDBC? JDBC的全称是Java DataBase Connection，也就是Java数据库连接，是应用于Java编程语言去连接数据库的一个技术。它为Java开发者使用数据库提供了统一的编程接口，是Java程序与数据...
JDBC初学笔记
weixin_43228670的博客
06-27 163
JDBC的主要过程是： 1.加载数据库驱动。 2.与数据库建立连接。 3.将sql语句通过Statement或preparedStatement发送给数据库程序并接收数据库程序的处理结果，将结果保存在ResultSet中（其中ResultSet是结果集）。 4.断开与数据库的连接并将在与数据库建立连接时申请的资源释放掉。 在将sql语句发送给数据库程序以及接收结果时需要注意的是，一个Stateme...
适合初学者学习的JDBC教程【深入浅出】
d5821476的博客
02-23 428
Java数据库连接，（Java Database Connectivity，简称JDBC）是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。JDBC也是Sun Microsystems的商标。我们通常说的JDBC是面向关系型数据库的。 数据库实现了数据的持久化，但我们最终要在程序里处理数据啊，这就要用到sun公司设定的一套数据库标准了，即JDBC。但它只是规范，不做具体实现。于是数据库厂商又根据JDBC标准，实现自家的驱动Driver。有了这套解..
Hikari连接池
drug1910951117的博客
08-17 279
Hikari连接池配置引用
JDBC基础知识
Stay hungry，stay foolish。
12-04 122
一、概念JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。二、和ODBC比较（ODBC基础知识）目前，Microsoft 的 ODBC API 可能是使用最广的、用于访问关系数据库的编程接口。它能在几乎所有平台上连接几乎所有的数据库。为什么 J...
JDBC-ODBC桥：Java跨数据库连接详解
数据源是一种管理数据库连接池的机制，允许程序在需要时高效地获取和释放连接，减少了频繁创建和销毁连接的开销。 JDBC连接数据库的过程通常包括以下几个步骤： 1. **注册和加载驱动器**：首先，需要注册数据库...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值