Spring4.0 study notes (6)

Use of JdbcTemplate

Introduction

JdbcTemplate is the encapsulation of JDBC operations that comes with the Spring framework. The purpose is to provide a unified template method to make the operation of the database more convenient, friendly, and efficient. However, the function is still not powerful enough (for example, it does not support cascading properties), and it needs to be mixed with frameworks such as hibernate and mybaties in practical applications.

jar package that needs to be imported

c3p0-0.9.2.1.jar
commons-logging-1.1.1.jar
mchange-commons-java-0.2.3.4.jar
mysqljdbc.jar
spring-beans-4.0.2.RELEASE.jar
spring-context-4.0.2.RELEASE.jar
spring-core-4.0.2.RELEASE.jar
spring-expression-4.0.2.RELEASE.jar
spring-jdbc-4.0.2.RELEASE.jar
spring-tx-4.0.2.RELEASE.jar

source code

db.properties

jdbc.user=root
jdbc.password=1995
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql:///spring4

jdbc.initPoolSize=5
jdbc.maxPoolSize=10

<?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-4.0.xsd">

    <!-- 导入资源文件 -->
    <context:property-placeholder location="classpath:db.properties"/>

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

        <property name="initialPoolSize" value="${jdbc.initPoolSize}"></property>
        <property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>
    </bean>

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

    <!-- 
        配置 NamedParameterJdbcTemplate , 该对象可以使用具名参数, 其没有无参数的构造器, 
        所以必须为其构造器指定参数 
    -->
    <bean id="namedParameterJdbcTemplate"
        class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
        <constructor-arg ref="dataSource"></constructor-arg>
    </bean>
</beans>

public class Employee {

    private Integer id;
    private String lastName;
    private String email;
    private Department department;

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }

    public Department getDepartment() {
        return department;
    }
    public void setDepartment(Department department) {
        this.department = department;
    }
    @Override
    public String toString() {
        return "Employee [id=" + id + ", lastName=" + lastName + ", email=" + email + ", department=" + department
                + "]";
    }


}

class JDBCTest {

    private ApplicationContext ctx = null;
    private JdbcTemplate jdbcTemplate = null;
    private NamedParameterJdbcTemplate namedParam = null;

    {
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        jdbcTemplate = ctx.getBean(JdbcTemplate.class);
        namedParam = ctx.getBean(NamedParameterJdbcTemplate.class);
    }

    @Test
    public void testDataSource() throws SQLException {
        DataSource dataSource = (DataSource) ctx.getBean("dataSource");
        System.out.println(dataSource.getConnection());
    }

    /**
     * 执行 INSERT, UPDATE, DELETE
     */
    @Test
    public void testUpdate() {
        String sql = "UPDATE employees SET last_name = ? WHERE id = ?";
        jdbcTemplate.update(sql , "Angel2.0" , 1);
    }

    /**
     * 执行批量更新 : 批量的 INSERT, UPDATE, DELETE
     * 最后一个参数是 Object[] 的 List 类型 : 因为修改一条记录需要一个 Object 数组,
     * 那么多条就是多个 Object 数组
     */
    @Test
    public void testBatchUpdate() {
        String sql = "INSERT INTO employees(last_name, email, dept_id) VALUES(?,?,?)";

        List<Object[]> batchArgs = new ArrayList<>();

        batchArgs.add(new Object[] {"AA", "[email protected]", 1});
        batchArgs.add(new Object[] {"BB", "[email protected]", 2});
        batchArgs.add(new Object[] {"CC", "[email protected]", 3});
        batchArgs.add(new Object[] {"DD", "[email protected]", 3});
        batchArgs.add(new Object[] {"EE", "[email protected]", 2});

        jdbcTemplate.batchUpdate(sql, batchArgs);
    }

    /**
     * 从数据库中读取一条记录, 实际得到一个对应的一个对象
     * 注意不是调用 queryForObject(String sql, Class<Employee> requiredType, Object ... args)
     * 而是调用 queryForObject(String sql, RowMapper<Employee>rowMapper, Object ... args)
     * 1. 其中的 RowMapper 指定如何去映射结果集的行, 常用的实现类为 BeanPropertyRowMapper
     * 2. 使用 SQL 中的别名完成列名和属性名的映射 例如 last_name lastName
     * 3. 不支持级联属性 JdbcTemplate 到底是一个 JDBC 的小工具, 而不是 ORM 框架
     */
    @Test
    public void testQueryForObject() {
        String sql = "SELECT id, last_name lastName, email FROM employees WHERE ID = ?";
        RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<>(Employee.class);
        Employee employee = jdbcTemplate.queryForObject(sql, rowMapper, 1);

        System.out.println(employee);
    }

    /**
     * 查询实体类的集合
     * 注意调用的不是 queryForList 方法
     */
    @Test
    public void testQueryForList() {
        String sql = "SELECT id, last_name lastName, email FROM employees WHERE id = ?";
        RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<>(Employee.class);
        List<Employee> employees = jdbcTemplate.query(sql, rowMapper, 3);

        System.out.println(employees);
    }

    /**
     * queryForList 可以获取某一个单个属性列的集合
     */
    @Test
    public void testQueryForList2() {
        String sql = "SELECT last_name lastName FROM employees WHERE dept_id = ?";
        List<String> list = jdbcTemplate.queryForList(sql, String.class, 3);
        System.out.println(list);
    }

    /**
     * 查询单个列的值, 或做统计查询
     * 使用 queryForObject(String sql, Class<Long> requiredType)
     */
    @Test
    public void testQueryObject2() {
        String sql = "SELECT count(id) FROM employees";
        long count = jdbcTemplate.queryForObject(sql, Long.class);

        System.out.println(count);

        sql = "SELECT last_name FROM employees WHERE id = ?";
        String lastName = jdbcTemplate.queryForObject(sql, String.class,1);

        System.out.println(lastName);
    }

    /**
     * 可以为参数起名字
     * 1. 好处 : 若有多个参数, 则不用再去对应设置, 制定对应参数名, 便于维护
     * 2. 缺点 : 较为麻烦
     */
    @Test
    public void testNamedParamterJdbcTemplat() {
        String sql = 
            "INSERT INTO employees(last_name, email, dept_id)VALUES(:ln,:email,:di)";
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("ln", "FF");
        paramMap.put("email", "[email protected]");
        paramMap.put("di", 2);
        namedParam.update(sql, paramMap);
    }

    /**
     * 使用具名参数, 可以使用 update(String sql, SqlParameterSource paramSource)
     * 1. SQL 语句中的参数名和类的属性一致！
     * 2. 使用 SqlParameterSource 的 BeanPropertySqlParameterSource 作为实现类
     */
    @Test
    public void testNamedParamterJdbcTemplat2() {
        String sql = "INSERT INTO employees(last_name, email)"
                + "VALUES(:lastName, :email)";

        Employee employee = new Employee();
        employee.setLastName("XYZ");
        employee.setEmail("[email protected]");

        SqlParameterSource paramSource = new BeanPropertySqlParameterSource(employee);
        namedParam.update(sql, paramSource);
    }

}