Spring学习笔记——JDBCTemplate

JDBCTemplate

JDBCTemplate是Spring框架中提供的一个对象，是对原始繁琐的JDBC API对象的简单封装

Spring框架提供了很多的操作模板类，如操作关系型数据库的JdbcTemplate，操作NoSQL数据库的RedisTemplate，操作消息队列的JmsTemplate等

JDBCTemplate基本步骤

导入spring-jdbc和spring-tx坐标

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>${spring.ver}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>${spring.ver}</version>
</dependency>

创建数据库表和实体

public class User {

    private String name;
    private String password;

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

创建JdbcTemplate对象，执行数据库操作

@Test // 测试JDBCTemplate基本步骤
public void Test1() throws PropertyVetoException {

    // 创建数据源对象 Druid
    DruidDataSource dataSourceDruid = new DruidDataSource();
    dataSourceDruid.setDriverClassName("com.mysql.cj.jdbc.Driver");
    dataSourceDruid.setUrl("jdbc:mysql://localhost:3306/demo?serverTimezone=GMT");
    dataSourceDruid.setUsername("root");
    dataSourceDruid.setPassword("root");

    // 创建数据源对象 c3p0
    ComboPooledDataSource dataSourceC3P0 = new ComboPooledDataSource();
    dataSourceC3P0.setDriverClass("com.mysql.cj.jdbc.Driver");
    dataSourceC3P0.setJdbcUrl("jdbc:mysql://localhost:3306/demo?serverTimezone=GMT");
    dataSourceC3P0.setUser("root");
    dataSourceC3P0.setPassword("root");

    JdbcTemplate jdbcTemplate = new JdbcTemplate();

    // 测试C3P0
    jdbcTemplate.setDataSource(dataSourceC3P0); // 设置数据源对象
    int c3p0 = jdbcTemplate.update("insert into user values (?,?);", "C3P0", "c3p0");
    System.out.println(c3p0);

    // 测试Druid
    jdbcTemplate.setDataSource(dataSourceDruid); // 设置数据源对象
    int druid = jdbcTemplate.update("insert into user  values (?,?);", "Druid", "druid");
    System.out.println(druid);
}
}

Spring创建JdbcTemplate对象

在Spring配置文件中配置数据源和JdbcTemplate对象

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 配置数据源对象 c3p0连接池 -->
    <bean id="c3p0" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/demo?serverTimezone=GMT"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>
	
    <!-- 配置数据源对象 druid连接池 -->
    <bean id="druid" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/demo?serverTimezone=GMT"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!-- 配置JdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- <property name="dataSource" ref="druid"/> -->
        <property name="dataSource" ref="c3p0"/>
    </bean>
</beans>

编写测试

@Test // 测试Spring创建JdbcTemplate
public void Test2(){
    ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
    JdbcTemplate jdbcTemplate = (JdbcTemplate) app.getBean("jdbcTemplate");
    int row = jdbcTemplate.update("insert into user  values (?,?);", "Spring", "spring");
    System.out.println(row);
}

抽取数据库相关配置

一般情况下，我们需要将Spring配置文件和数据库相关配置分来，以便后期维护，这时需要将Spring配置数据源时的部分内容抽取出来

创建properties文件

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/demo?serverTimezone=GMT
user=root
password=root

修改Spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">

    <!-- 加载外部配置 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 配置数据源对象 -->
    <bean id="c3p0" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${driver}"/>
        <property name="jdbcUrl" value="${url}"/>
        <property name="user" value="${user}"/>
        <property name="password" value="${password}"/>
    </bean>

    <bean id="druid" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${user}"/>
        <property name="password" value="${password}"/>
    </bean>

    <!-- 配置JdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- <property name="dataSource" ref="druid"/> -->
        <property name="dataSource" ref="c3p0"/>
    </bean>
</beans>

JDBCTemplate的常用操作

增加操作

jdbcTemplate.update("insert into user values (?,?);", "C3P0", "c3p0");

删除操作

jdbcTemplate.update("delete from user where name = ?","Spring");

修改操作

jdbcTemplate.update("update user set password = ? where name = ?","123","Spring");

查询操作

查询全部内容

public < T > java.util.List< T > query(String sql, org.springframework.jdbc.core.RowMapper< T > rowMapper)

其中RowMapper是一个接口，我们需要使用它的实现类BeanPropertyRowMapper来封装查询结果

在创建BeanPropertyRowMapper对象时，泛型需要的是结果需要封装为什么实体，后面的参数需要的是实体对象的字节码

@Test
public void testSelectAll(){
    List<User> Users = jdbcTemplate.query("select * from user", new BeanPropertyRowMapper<User>(User.class));
    System.out.println(Users);
}

查询单个内容

public < T > T queryForObject(String sql,org.springframework.jdbc.core.RowMapper< T > rowMapper,@Nullable Object… args)

@Test
public void testSelect(){
    User spring = jdbcTemplate.queryForObject("select * from user where name = ?", 
                                              new BeanPropertyRowMapper<User>(User.class), 
                                              "Spring");
    System.out.println(spring);
}

聚合查询

public T queryForObject(String sql,Class requiredType)

与查询单个内容不同，虽然都是queryForObject()方法，但是参数不同，由于聚合查询一般会返回基本数据类型，所以不需要使用RowMapper来封装，这里的第二参数是需要返回的类型的字节码

@Test
public void testSelectCount(){
    Integer sum = jdbcTemplate.queryForObject("select count(*) from user ", Integer.class);
    System.out.println(sum);
}

JDBCTemplate要点

步骤

1. 导入spring-jdbc和spring-tx坐标
2. 创建数据库表和实体类
3. 创建JdbcTemplate对象
4. 执行数据库操作

方法

更新操作：update(sql,params)

查询操作：query(sql,Mapper,params)

​ queryForObject(sql,Mapper,params)