跳至主要內容

JDBCTemplate

LiAngJava2023年11月15日SpringJava大约 10 分钟约 1905 字

需求

如果程序员就希望使用 spring 框架来做项目，spring 框架如何处理对数据库的操作呢？

​ 方案 1：使用前面做项目开发的 JdbcUtils 类 。

​ 方案 2：其实 spring 提供了一个操作数据库(表)功能强大的类 JdbcTemplate 。我们可以同 ioc 容器来配置一个 jdbcTemplate 对象，使用它来完成对数据库表的各种操作。

官方文档

JdbcTemplate APIs : /spring-framework-5.3.8/docs/javadoc-api/index.html

JdbcTemplate-介绍

  1. 通过 Spring 可以配置数据源，从而完成对数据表的操作 。
  2. JdbcTemplate 是 Spring 提供的访问数据库的技术。可以将 JDBC 的常用操作封装为模板方法。
image-20220611172851866
image-20220611172851866

使用案例

正确得到数据源

先引入JdbcTemplate需要的jar包。

image-20220611173023389
image-20220611173023389

创建数据库spring和表monster

-- 创建数据库 
CREATE DATABASE spring
-- 创建表 monster 
CREATE TABLE monster(
    id INT PRIMARY KEY, 
    `name` VARCHAR(64) NOT NULL DEFAULT '',
	skill VARCHAR(64) NOT NULL DEFAULT ''
)CHARSET=utf8 

INSERT INTO monster VALUES(100, '青牛怪', '吐火'); 
INSERT INTO monster VALUES(200, '黄袍怪', '吐烟'); 
INSERT INTO monster VALUES(300, '蜘蛛怪', '吐丝');

创建配置文件 src/jdbc.properties

jdbc.userName=root
jdbc.password=123456
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring

创建配置文件 src/JdbcTemplate_ioc.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 https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 引入外部属性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!-- 配置数据源 -->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
        <property name="user" value="${jdbc.userName}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
    </bean>
</beans>

测试是否可以正确得到数据源

package com.lzw.spring.test;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

/**
 * @author LiAng
 */
public class JdbcTemplateTest {

    @Test
    public void testDatasourceByJdbcTemplate() throws SQLException {
        //获取容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");

        DataSource dataSource = ioc.getBean(DataSource.class);
        Connection connection = dataSource.getConnection();
        System.out.println("获取到connection = " + connection);
        connection.close();
        System.out.println("ok");
    }
}
image-20220611175217274
image-20220611175217274

添加数据

配置 JdbcTemplate_ioc.xml

将数据源分配给 JdbcTemplate bean。

	<!--配置JdbcTemplate对象-->
    <bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
        <!--给JdbcTemplate对象配置dataSource-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

修改 JdbcTemplateTest.java

	//测试通过JdbcTemplate对象完成添加数据	
	@Test
    public void addDataByJdbcTemplate() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        //获取JdbcTemplate对象
        JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
        //1. 添加方式1
        //String sql = "Insert into monster Value(400, '红孩儿', '枪法')";
        //jdbcTemplate.execute(sql);
        //2. 添加方式2
        String sql = "INSERT INTO monster VALUES(?, ?, ?)";
        //affected表示 执行后表受影响的记录数
        int affected = jdbcTemplate.update(sql, 500, "红孩儿2", "枪法2");
        System.out.println("添加成功 affected = " + affected);
    }

修改数据

修改 JdbcTemplateTest.java

	//测试通过JdbcTemplate对象完成修改数据
    @Test
    public void updateDataByJdbcTemplate() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        //获取JdbcTemplate对象
        JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
        //组织SQL
        String sql = "UPDATE monster SET skill=? WHERE id=?";
        int affected = jdbcTemplate.update(sql, "美人计", 300);
        System.out.println("update ok affected= " + affected);
    }

批量添加数据

修改 JdbcTemplateTest.java

	//批量添加两个monster
    //这里有一个使用API的技巧
    /**
     * 1. 对于某个类， 有很多API, 使用的步骤
     * 2. 使用技巧（1） 先确定API名字 (2) 根据API提供相应的参数 [组织参数]
     *    (3) 把自己的调用思路清晰 (4) 根据API, 可以推测类似的用法和功能
     */

    /**
     * batch add data
     * 批量添加二个monster 白蛇精和青蛇精-update(sql,List<Object[]>)
     */
    @Test
    public void addBatchDataByJdbcTemplate() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        //得到JdbcTemplate bean
        JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);//添加..

        //1. 先确定,猜测API名称 batchUpdate[如果出现问题，才重新玩]
        //public int[] batchUpdate(String sql, List<Object[]> batchArgs){}
        //2. 准备参数
        String sql = "INSERT INTO monster VALUES(?, ?, ?)";
        List<Object[]> batchArgs = new ArrayList<>();
        batchArgs.add(new Object[]{600, "老鼠精", "偷吃粮食"});
        batchArgs.add(new Object[]{700, "老猫精", "抓老鼠"});
        //3. 调用
        //说明：返回结果是一个数组，每个元素对应上面的sql语句对表的影响记录数
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        //输出
        for (int anInt : ints) {
            System.out.println("anInt=" + anInt);
        }
        System.out.println("batch add ok..");

    }

查询单条数据并封装成对象

这里的Monster还是使用的第一章中的Monster类。

修改 JdbcTemplateTest.java

    //查询id=100的monster并封装到Monster实体对象[在实际开发中，非常有用]
    @Test
    public void selectDataByJdbcTemplate() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        //得到JdbcTemplate bean
        JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
        //组织SQL
        //通过BeanPropertyRowMapper获取rowmapper 是一个接口，可以将查询的结果，封装到你指定的Monster对象中.

        //1. 确定API ： queryForObject()
        //public <T> T queryForObject(String sql, RowMapper<T> rowMapper, @Nullable Object... args)
        //2.准备参数
        String sql = "SELECT id AS monsterID, NAME, skill FROM monster WHERE id = 100";
        //使用RowMapper 接口对返回的数据，进行一个封装->底层使用的反射->setter
        //这里有一个细节: 你查询的记录的表的字段需要和 Monster的对象字段名保持一致
        RowMapper<Monster> rowMapper = new BeanPropertyRowMapper<>(Monster.class);
        //jdbcTemplate
        Monster monster = jdbcTemplate.queryForObject(sql, rowMapper);
        System.out.println("monster= " + monster);
        System.out.println("查询ok");
    }

查询多条数据并封装成对象集合

修改 JdbcTemplateTest.java

	/**
     * 查询多条记录
     * 查询id>=100的monster并封装到Monster实体对象
     */
    @Test
    public void selectMulDataByJdbcTemplate() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        //得到JdbcTemplate bean
        JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
        //组织SQL
        //通过BeanPropertyRowMapper获取rowmapper 是一个接口，可以将查询的结果，封装到你指定的Monster对象中.

        //1.    确定API
        //public <T> T query(String sql, RowMapper<T> rowMapper, Object... args){}
        //2. 组织参数
        String sql = "SELECT id AS monsterId, NAME, skill FROM monster WHERE id >= ?";
        RowMapper<Monster> rowMapper = new BeanPropertyRowMapper<>(Monster.class);
        //3.调用
        List<Monster> monsterList = jdbcTemplate.query(sql, rowMapper, 100);
        for (Monster monster : monsterList) {
            System.out.println("monster= " + monster);
        }
    }

查询返回结果只有一行一列的数据

修改 JdbcTemplateTest.java

 	/**
     * 查询返回结果只有一行一列的值，比如查询id=100的怪物名
     */
    @Test
    public void selectScalarByJdbcTemplate() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        //得到JdbcTemplate bean
        JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);

        //1. 确定API
        //public <T> T queryForObject(String sql, Class<T> requiredType)
        //2. 提供参数
        String sql = "SELECT NAME FROM monster WHERE id = 100";
        String name = jdbcTemplate.queryForObject(sql, String.class);
        System.out.println("返回name= " + name);
    }

使用 Map 传入具名参数完成添加操作

修改 JdbcTemplate_ioc.xml

	<!--配置NamedParameterJdbcTemplate对象-->
    <bean class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate" id="namedParameterJdbcTemplate">
        <!--通过构造器，设置数据源-->
        <constructor-arg name="dataSource" ref="dataSource"/>
    </bean>

修改 JdbcTemplateTest.java

	/**
     * 使用Map传入具名参数完成操作，比如添加 螃蟹精.:name 就是具名参数形式需要使用NamedParameterJdbcTemplate 类,
     * 语句形式: String sql = "INSERT INTO monster VALUES(:my_id, :name, :skill)";
     */
    @Test
    public void testDataByNamedParameterJdbcTemplate() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        //得到NamedParameterJdbcTemplate bean
        NamedParameterJdbcTemplate namedParameterJdbcTemplate = ioc.getBean(NamedParameterJdbcTemplate.class);

        //1. 确定使用API
        //public int update(String sql, Map<String, ?> paramMap)
        //2. 准备参数 [:my_id, :name, :skill] 要求按照规定的名字来设置参数
        String sql = "insert into monster values(:id, :name, :skill)";
        Map<String, Object> paramMap = new HashMap<>();
        //给paramMap填写数据
        paramMap.put("id", 800);
        paramMap.put("name", "蚂蚁精");
        paramMap.put("skill", "喜欢打洞");
        //3. 调用
        int affected = namedParameterJdbcTemplate.update(sql, paramMap);
        System.out.println("add ok affected=" + affected);
    }
image-20220611192753526
image-20220611192753526

使用 sqlparametersoruce 来传入具名参数完成添加操作

修改 JdbcTemplateTest.java

	//使用sqlparametersoruce 来传入具名参数,还是添加一个Monster 狐狸精
    @Test
    public void operDataBySqlparametersoruce() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        //得到NamedParameterJdbcTemplate bean
        NamedParameterJdbcTemplate namedParameterJdbcTemplate = ioc.getBean(NamedParameterJdbcTemplate.class);
        //确定API
        //public int update(String sql, SqlParameterSource paramSource)
        //public BeanPropertySqlParameterSource(Object object)
        //准备参数
        String sql = "INSERT INTO monster VALUES(:monsterID, :name, :skill)";
        Monster monster = new Monster(900, "大象精", "搬运木头");
        SqlParameterSource sqlParameterSource = new BeanPropertySqlParameterSource(monster);
        //3. 调用
        int affected = namedParameterJdbcTemplate.update(sql, sqlParameterSource);
        System.out.println("add ok affected=" + affected);
    }
image-20220611192837530
image-20220611192837530

Dao 对象使用 JdbcTemplate 完成对数据的操作

创建 MonsterDao.java

package com.lzw.spring.jdbctemplate.dao;

import com.lzw.spring.bean.Monster;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;

/**
 * @author LiAng
 */
@Repository //将MonsterDao注入到Spring容器
public class MonsterDao {

    //注入一个属性
    @Resource
    private JdbcTemplate jdbcTemplate;

    //完成保存任务
    public void save(Monster monster){
        //组织sql
        String sql = "insert into monster values(?,?,?)";
        int affected = jdbcTemplate.update(sql, monster.getMonsterID(), monster.getName(), monster.getSkill());
        System.out.println("affected = " + affected);
    }
}

修改 JdbcTemplate_ioc.xml

	<!--配置要扫描的包-->
    <context:component-scan base-package="com.lzw.spring.jdbctemplate.dao"/>

修改 JdbcTemplateTest.java

	//测试MonsterDAO
    @Test
    public void monsterDaoSave() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        MonsterDao monsterDao = ioc.getBean(MonsterDao.class);
        Monster monster = new Monster(1000, "小鸭精", "吃鱼");
        monsterDao.save(monster);
        System.out.println("MonsterDAO保存 ok ..");
    }
上次编辑于: 2023/11/15 21:46:52
贡献者: LiAng