数据库连接池，Spring JDBC

1.数据库连接池（数据源）

1.概念

其实就是一个容器（集合），存放数据库的容器。当系统初始化好后，容器被创建，容器中会申请一些数据库连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完后，会将连接对象归还给容器。
好处：节约资源，高效

2.实现

DataSource是一个获取数据库连接对象的工厂，一个接口。推荐通过DataSource对象的getConnection方法获取数据库连接对象。getConnection抽象方法一般我们不去实现它，由数据库厂商实现它。
方法：

1. 获取连接对象：getConnection
2. 归还连接对象：close,如果连接对象Connnection是从连接池中获取的，那么调用Connection.close方法不会关闭连接，而是归还连接。

数据库连接池技术有：C3P0,Druid等

2.C3P0的基本使用

1.使用步骤：

1. 导入两个jar包(c3p0-0.9.5.5.jar，mchange-commons-java-0.2.19.jar），如果是使用MySQL数据库，还要导入数据库驱动jar包mysql-connector-java-8.0.26.jar
2. 定义配置文件(.xml形式或者.properties形式)：名称：c3p0.properties或者c3p0-config.xml,路径：直接将文件放在src目录下即可
3. 创建数据库连接池对象ComboPooledDatabase
4. 获取连接：getConnection

// 示例
1. 在项目目录下新建一个目录,并将上述三个jar包放入其中，右击该目录名，将其添加为库
2. 在src目录下新建c3p0-config.xml配置文件，配置信息编辑好
3. 测试如下
//无参构造方法，使用默认配置；有参方法则使用带有名字的配置
ComboPooledDataSource cpds = new ComboPooledDataSource();
System.out.println(cpds);
// 获取数据库连接对象
Connection cnn = cpds.getConnection();
// 定义sql
String sql = "insert into noticeboard(number,time,content)values(?,?,?)";
// 获取执行sql的PreparedStatement对象
PreparedStatement ps = cnn.prepareStatement(sql);
// 给占位符？设置值
ps.setString(1, "6");
ps.setString(2, "2021/09/28");
ps.setString(3, "选课通知");
// 执行sql操作
int row = ps.executeUpdate();
System.out.println(row);    // 1，表示插入成功

// 释放资源
cnn.close();

3.Druid的基本使用

Druid是Java语言中最好的数据库连接池

1.使用步骤

导入jar包
定义配置文件

1. .properties形式的
2. 可以叫任意名称，可以放在任意目录下
3. 加载配置文件
4. 获取数据库连接池对象：通过工厂类来获取（DruidDataSourceFactory）
5. 获取连接：getConnection

// 示例：
 // 加载配置文件
Properties pro = new Properties();
InputStream is = HelloWorld.class.getClassLoader().getResourceAsStream("druid.properties");
pro.load(is);
// 获取数据库连接对象
DataSource druidDataSourceFactory = DruidDataSourceFactory.createDataSource(pro);
System.out.println(druidDataSourceFactory);
// 获取连接
Connection con = null;
try {
    con = druidDataSourceFactory.getConnection();
} catch (SQLException e) {
    e.printStackTrace();
}
System.out.println(con);
con.close();

4.spring配置数据源

可以将DataSource的创建权交由spring容器完成。

1.pom文件中导入坐标

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.25</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.10</version>
        </dependency>
    </dependencies>

2.jdbc.properties配置文件

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/secs
jdbc.username=root
jdbc.password=123456

3.在spring配置文件applicationContext.xml中抽取jdbc配置文件

spring的applicationContext.xml这个配置文件加载jdbc.properties配置文件获取连接信息

首先引入context命名空间

xmlns:context="http://www.springframework.org/schema/context"

在xsi:schemaLocation属性值后引入约束路径

http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

spring配置文件中加载外部的properties配置文件

<!--spring配置文件中加载外部的properties配置文件，其中jdbc.properties位于resources目录下 -->
<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
// 示例
<bean id="comboDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
</bean>

applicationContext.xml如下：

<?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:context="http://www.springframework.org/schema/context"
       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">
    <!--spring配置文件中加载外部的properties配置文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <bean id="comboDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!--
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/secs"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/secs"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
    -->
</beans>

4.测试

    @Test
    // spring容器产生ComboPooledDataSource数据源对象
    public void c3p0SpringConfigTest() throws SQLException {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        ComboPooledDataSource dataSource = (ComboPooledDataSource)app.getBean("comboDataSource");
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }
    @Test
    // spring容器产生ComboPooledDataSource数据源对象
    public void druidSpringConfigTest() throws SQLException {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        DruidDataSource dataSource = (DruidDataSource) app.getBean("druidDataSource");
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }
    @Test
    // 手动创建C3p0数据源测试(加载properties配置文件形式)
    public void c3p0ConfigTest() throws PropertyVetoException, SQLException {
        ResourceBundle rb = ResourceBundle.getBundle("jdbc");
        String driver = rb.getString("jdbc.driver");
        String url = rb.getString("jdbc.url");
        String username = rb.getString("jdbc.username");
        String password = rb.getString("jdbc.password");
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }
    @Test
    // 手动创建C3p0数据源测试
    public void c3p0Test() throws PropertyVetoException, SQLException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/secs");
        dataSource.setUser("root");
        dataSource.setPassword("123456");
        Connection connection = dataSource.getConnection();
        System.out.println(connection); //com.mchange.v2.c3p0.impl.NewProxyConnection@28eaa59a
        connection.close();
    }

    @Test
    // 手动创建Druid数据源测试(加载properties配置文件形式)
    public void driudConfigTest() throws SQLException {
        ResourceBundle rb = ResourceBundle.getBundle("jdbc");
        String driver = rb.getString("jdbc.driver");
        String url = rb.getString("jdbc.url");
        String username = rb.getString("jdbc.username");
        String password = rb.getString("jdbc.password");
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        DruidPooledConnection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }
    @Test
    // 手动创建Druid数据源测试
    public void druidTest() throws SQLException {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/secs");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        DruidPooledConnection connection = dataSource.getConnection();
        System.out.println(connection); // com.mysql.cj.jdbc.ConnectionImpl@4034c28c
        connection.close();
    }

5.Spring Jdbc

1.概述

Spring框架提供的对JDBC的简单封装,目的是使JDBC更加易于使用。它提供了一个JDBCTemplate对象简化JDBC的开发，并且JdbcTemplate处理了资源的建立和释放。

2.使用步骤（不使用maven）

准备DruidDataSource连接池
导入jar包（五个）
创建JdbcTemplate对象。依赖于数据源DataSourceJdbcTemplate template = new JdbcTemplate(DataSource类型的对象)
调用JdbcTemplate对象的方法来完成CURD的操作
最后不用手动完成释放资源的操作，其内部自动完成。

update:执行DML语句（增删改）
queryForMap:查询结果将结果集封装为Map集合。这个方法查询的结果集长度只能是1
queryList:查询结果将结果封装为List集合.将每一条记录封装成map,再将map集合装载到List集合中
query:查询结果将结果封装为javaBean对象。query方法的一个参数RowMapper一般使用系统实现好的接口实现类BeanPropertyRowMapper,可以完成数据到JavaBean的自动封装
queryForObject:查询结果将结果封装为对象，一般用于聚合函数的查询
queryForInt:执行查询语句返回一个整型值
execute：可以执行所有sql语句一般用于执行DDL语句

案例1.使用JdbcTemplate对象的update方法完成增删改：

1. 增
// 创建JdbcTemplate对象
JdbcTemplate template = new JdbcTemplate(DruidJdbcUtils.getDataSource());
// 定义sql
String sql = "insert into noticeboard values (?,?,?)";
// 执行sql
template.update(sql,"3","2021/09/31","选课3");
template.update(sql,"4","2021/09/32","选课4");
template.update(sql,"3","2021/09/33","选课5");

 2. 删
 // 创建JdbcTemplate对象
JdbcTemplate template = new JdbcTemplate(DruidJdbcUtils.getDataSource());
// 定义sql
String sql = "delete from noticeboard where number = ?";
// 执行sql
int update = template.update(sql, "1");
System.out.println(update); // 4，表示影响4行

3. 改
JdbcTemplate template = new JdbcTemplate(DruidJdbcUtils.getDataSource());
String sql = "update noticeboard set time = ?, content = ? where number = ?";
int update = template.update(sql, "2021/09/32", "学校倒闭了，不要选课", "3");
System.out.println(update); // 2

案例2：查询noticeboard表中number = 2的记录，使用queryForMap方法

JdbcTemplate jdbcTemplate = new JdbcTemplate(DruidJdbcUtils.getDataSource());
String sql = "select * from noticeboard where number = ?";
Map<String, Object> stringObjectMap = jdbcTemplate.queryForMap(sql, 2);
System.out.println(stringObjectMap);    //{number=2, time=2021/05/23 23:35:54, content=选课通知}

案例3：查询noticeboard表中的所有记录将其封装为list

JdbcTemplate jdbcTemplate = new JdbcTemplate(DruidJdbcUtils.getDataSource());
String sql = "select * from noticeboard";
List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
for (Map<String, Object>map : maps) {
    System.out.println(map);
}

案例4：查询表中所有的总记录数

String sql0 = "select count(number) from noticeboard";
Integer integer = template.queryForObject(sql0, Integer.class);
System.out.println(integer);

案例5：将noticeboard表中的记录数封装到NoticeBoard对象的list集合中.使用query方法，其中一个参数为BeanPropertyRowMapper,返回一个List集合，List中存放的是RowMapper指定类型的数据。

JdbcTemplate template = new JdbcTemplate(DruidJdbcUtils.getDataSource());
String sql = "select *  from noticeboard;";
List<NoticeBoard> list = template.query(sql, new BeanPropertyRowMapper<NoticeBoard>(NoticeBoard.class));
for (NoticeBoard nb : list) {
    System.out.println(nb);
}

3.使用步骤（使用maven）

导入spring-jdbc和spring-tx坐标

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.14</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.3.14</version>
</dependency>

创建数据库表和实体
创建JdbcTemplate对象
执行数据库操作

posted on 2022-08-25 19:37 scrutiny-span 阅读(218) 评论(0) 编辑收藏举报

刷新页面返回顶部

导航