15.Spring之JdbcTemplate

[toc]

Spring之JdbcTemplate

1. 概述

1. 为了使JDBC更加易于使用，Spring在JDBC API上定义了一个抽象层，以此建立一个JDBC存取框架。
2. 作为Spring JDBC框架的核心，JDBC模板的设计目的是为不同类型的JDBC操作提供模板方法，通过这种方式，可以在尽可能保留灵活性的情况下，将数据库存取的工作量降到最低。
3. 可以将Spring的JdbcTemplate看作是一个小型的轻量级持久化层框架。

2. 环境准备

2.1 导入JAR包

// IOC容器所需要的JAR包

commons-logging-1.1.1.jar
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELEASE.jar
spring-core-4.0.0.RELEASE.jar
spring-expression-4.0.0.RELEASE.jar

// JdbcTemplate所需要的JAR包
spring-jdbc-4.0.0.RELEASE.jar
spring-orm-4.0.0.RELEASE.jar
spring-tx-4.0.0.RELEASE.jar

//数据库驱动和数据源
druid-1.1.9.jar
mysql-connector-java-5.1.7-bin.jar

2.2 新建测试数据表

CREATE TABLE `employee` (
  `emp_id` int(11) NOT NULL AUTO_INCREMENT,
  `emp_name` char(100) DEFAULT NULL,
  `salary` double DEFAULT NULL,
  PRIMARY KEY (`emp_id`)
) ENGINE=InnoDB AUTO_INCREMENT=14 DEFAULT CHARSET=gb2312;

2.3 db.properties

jdbc.user=root
jdbc.password=*******
jdbc.jdbcUrl=jdbc:mysql://cdb-o6r75r3g.bj.tencentcdb.com:10015/jdbctmp
jdbc.driverClass=com.mysql.jdbc.Driver

2.4 applicationContext.xml

1. 在Hibernate的HQL查询中我们体验过具名参数的使用，相对于基于位置的参数，具名参数具有更好的可维护性，在SQL语句中参数较多时可以考虑使用具名参数。
2. 在Spring中可以通过NamedParameterJdbcTemplate类的对象使用带有具名参数的SQL语句。

<?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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
">

    <context:component-scan base-package="cn.justweb"></context:component-scan>

    <context:property-placeholder location="classpath:db.properties"/>

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

    <bean id="template" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>


    <!-- 配置一个具有  具名参数  功能的JdbcTemplate；NamedParameterJdbcTemplate -->
    <bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
        <!-- 使用构造器方式注入一个数据源 -->
        <constructor-arg name="dataSource" ref="dataSource"></constructor-arg>
    </bean>
</beans>

2.5 实体类

/**
 * @Date 2020/5/26 20:45
 * @Version 10.21
 * @Author DuanChaojie
 */
@Data
public class Employee {
    private Integer EmpId;

    private String EmpName;

    private Double salary;

}

3. 测试JdbcTemplate

3.1 测试数据源

1. JdbcTemplate
2. NamedParameterJdbcTemplate

/**
 * @Date 2020/5/26 21:24
 * @Version 10.21
 * @Author DuanChaojie
 */
public class TestJdbcTemplate {

     ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
     JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
     NamedParameterJdbcTemplate namedJdbcTemplate = ioc.getBean(NamedParameterJdbcTemplate.class);
    
    @Test
    public void test1(){
        DataSource dataSource = ioc.getBean(DataSource.class);
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
            // connection = com.mysql.jdbc.JDBC4Connection@145eaa29
            System.out.println("connection = " + connection);
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void test2(){
        // jdbcTemplate = org.springframework.jdbc.core.JdbcTemplate@80169cf
        System.out.println("jdbcTemplate = " + jdbcTemplate);
    }
}

3.2 update

/**
  * 实验2：将emp_id=5的记录的salary字段更新为1300.00
  */
 @Test
 public void test22(){
     String sql = "UPDATE employee SET salary=? WHERE emp_id=?";
     int update = jdbcTemplate.update(sql, 1300.00,5);
     // 更新员工：1
     System.out.println("更新员工："+update);
 }

3.3 batchUpdate

/**
 * 实验3：批量插入；batchUpdate
 */
@Test
public void test03(){
    String  sql ="INSERT INTO employee(emp_name,salary) VALUES(?,?)";
    //List<Object[]>
    //List的长度就是sql语句要执行的次数
    //Object[]：每次执行要用的参数
    List<Object[]> batchArgs = new ArrayList<Object[]>();
    batchArgs.add(new Object[]{"张三",1998.98});
    batchArgs.add(new Object[]{"李四",2998.98});
    batchArgs.add(new Object[]{"王五",3998.98});
    batchArgs.add(new Object[]{"赵六",4998.98});

    int[] is = jdbcTemplate.batchUpdate(sql, batchArgs);
    for (int i : is) {
        // 1
        System.out.println(i);
    }
}

3.4 queryForObject

/**
 * 实验4：查询emp_id=5的数据库记录，封装为一个Java对象返回；
 * javaBean需要和数据库中字段名一致，否则无法完成封装；
 *
 * jdbcTemplate在方法级别进行了区分
 * 查询集合：jdbcTemplate.query()
 * 查询单个对象：jdbcTemplate.queryForObject()
 * 		如果查询没结果就报错；
 *
 */
@Test
public void test04(){
    String sql = "SELECT emp_id empId,emp_name empName,salary FROM employee WHERE emp_id=?";
    //RowMapper：每一行记录和javaBean的属性如何映射
    Employee employee = null;
    try {
        employee = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Employee.class), 5);
    } catch (DataAccessException e) {

    }
    // Employee(EmpId=5, EmpName=Kasier, salary=1300)
    System.out.println(employee);
}

3.5 query

/**
 * 实验5：查询salary>4000的数据库记录，封装为List集合返回
 */
@Test
public void test05(){
    String sql = "SELECT emp_id empId,emp_name empName,salary FROM employee WHERE salary>?";
    //封装List；集合里面元素的类型
    List<Employee> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Employee.class), 4000);

    for (Employee employee : list) {
        // √
        System.out.println(employee);
    }
}

3.6 queryForObject

/**
 * 实验6：查询最大salary
 */
@Test
public void test06(){
    String sql = "select max(salary) from employee";
    //无论是返回单个数据还是单个对象，都是调用queryForObject
    Double object = jdbcTemplate.queryForObject(sql, Double.class);
    // 9034.51
    System.out.println(object);
}

3.7 update

/**
 * 实验7：使用带有具名参数的SQL语句插入一条员工记录，并以Map形式传入参数值
 *
 * 具名参数：（具有名字的参数，参数不是占位符了，而是一个变量名）
 * 		语法格式：   :参数名
 * Spring有一个支持具名参数功能的JdbcTemplate
 *
 * 占位符参数：?的顺序千万不能乱。传参的时候一定注意；
 */
@Test
public void test07(){
    String sql = "INSERT INTO employee(emp_name,salary) VALUES(:empName,:salary)";

    //Map
    Map<String, Object> paramMap = new HashMap<>();
    //将所有具名参数的值都放在map中；
    paramMap.put("empName", "田七");
    paramMap.put("salary", 9887.98);
    int update = namedJdbcTemplate.update(sql, paramMap);
    // 1
    System.out.println(update);
}

3.8 update

/**
 * 实验8：重复实验7，以SqlParameterSource形式传入参数值
 */
@Test
public void test08(){
    String sql = "INSERT INTO employee(emp_name,salary) VALUES(:empName,:salary)";
    Employee employee = new Employee();
    employee.setEmpName("哈哈");
    employee.setSalary(998.98);

    int i = namedJdbcTemplate.update(sql, new BeanPropertySqlParameterSource(employee));
    // 1
    System.out.println(i);

}

3.9 update

EmployeeDao

/**
 * @Date 2020/5/26 21:56
 * @Version 10.21
 * @Author DuanChaojie
 */
@Repository
public class EmployeeDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void saveEmployee(Employee employee) {
        String sql = "INSERT INTO employee(emp_name,salary) VALUES(?,?)";
        jdbcTemplate.update(sql, employee.getEmpName(),employee.getSalary());
    }
}

测试

    /**
     * 实验9：创建BookDao，自动装配JdbcTemplate对象
     */
    @Test
    public void test09(){
        EmployeeDao bean = ioc.getBean(EmployeeDao.class);
        Employee employee = new Employee();
        employee.setEmpName("哈哈2");
        employee.setSalary(998.98);
        bean.saveEmployee(employee);
    }

}

☆