Spring4 之 JdbcTemplate

蔚落 2022-06-05 01:51 209阅读 0赞

## **Spring4 之 JdbcTemplate** ##

为了使 JDBC 更加易于使用, Spring 在 JDBC API 上定义了一个抽象层, 以此建立一个 JDBC 存取框架。

作为 Spring JDBC 框架的核心, JDBC 模板的设计目的是为不同类型的 JDBC 操作提供模板方法. 每个模板方法都能控制整个过程, 并允许覆盖过程中的特定任务. 通过这种方式, 可以在尽可能保留灵活性的情况下, 将数据库存取的工作量降到最低。

--------------------

## **实例** ##

延用之前的项目框架

*  添加Spring JDBC 相关的 jar包
    
        
                
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-jdbc</artifactId>
                    <version>4.3.7.RELEASE</version>
                </dependency>
        
                
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>5.1.6</version>
                </dependency>
        
                
                <dependency>
                    <groupId>c3p0</groupId>
                    <artifactId>c3p0</artifactId>
                    <version>0.9.1.2</version>
                </dependency>
        
        
                
 *  java 部分代码
 *  Department.java
    
        package com.spring.example.jdbc;
        
        public class Department { 
        
            private Integer id;
            private String name;
        
            public Integer getId() {
                return id;
            }
        
            public void setId(Integer id) {
                this.id = id;
            }
        
            public String getName() {
                return name;
            }
        
            public void setName(String name) {
                this.name = name;
            }
        
            @Override
            public String toString() {
                return "Department [id=" + id + ", name=" + name + "]";
            }
        
        }
 *  DepartmentDao.java
    
        package com.spring.example.jdbc;
        
        import javax.sql.DataSource;
        
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.jdbc.core.BeanPropertyRowMapper;
        import org.springframework.jdbc.core.RowMapper;
        import org.springframework.jdbc.core.support.JdbcDaoSupport;
        import org.springframework.stereotype.Repository;
        
        
        @Repository("departmentDao")
        public class DepartmentDao extends JdbcDaoSupport{ 
        
            @Autowired
            public void setDataSource2(DataSource dataSource){
                setDataSource(dataSource);
            }
        
            public Department get(Integer id){
                String sql = "SELECT id, dept_name name FROM departments WHERE id = ?";
                RowMapper<Department> rowMapper = new BeanPropertyRowMapper<>(Department.class);
                return getJdbcTemplate().queryForObject(sql, rowMapper, id);
            }
        
        }
 *  Employee.java
    
        package com.spring.example.jdbc;
        
        public class Employee { 
        
            private Integer id;
            private String lastName;
            private String email;
        
            private Integer dpetId;
        
            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 Integer getDpetId() {
                return dpetId;
            }
        
            public void setDpetId(Integer dpetId) {
                this.dpetId = dpetId;
            }
        
            @Override
            public String toString() {
                return "Employee [id=" + id + ", lastName=" + lastName + ", email="
                        + email + ", dpetId=" + dpetId + "]";
            }
        
        
        }
 *  EmployeeDao.java
    
        package com.spring.example.jdbc;
        
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.jdbc.core.BeanPropertyRowMapper;
        import org.springframework.jdbc.core.JdbcTemplate;
        import org.springframework.jdbc.core.RowMapper;
        import org.springframework.stereotype.Repository;
        
        @Repository("employeeDao")
        public class EmployeeDao {
        
            @Autowired
            private JdbcTemplate jdbcTemplate;
        
            public Employee get(Integer id){
                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, id);
        
                return employee;
            }
        }
 *  JDBCTest.java
    
        package com.spring.example.jdbc;
        
        import java.sql.SQLException;
        import java.util.ArrayList;
        import java.util.HashMap;
        import java.util.List;
        import java.util.Map;
        
        import javax.sql.DataSource;
        
        import org.junit.Test;
        import org.springframework.context.ApplicationContext;
        import org.springframework.context.support.ClassPathXmlApplicationContext;
        import org.springframework.jdbc.core.BeanPropertyRowMapper;
        import org.springframework.jdbc.core.JdbcTemplate;
        import org.springframework.jdbc.core.RowMapper;
        import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
        import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
        import org.springframework.jdbc.core.namedparam.SqlParameterSource;
        
        public class JDBCTest { 
        
            private ApplicationContext ctx = null;
            private JdbcTemplate jdbcTemplate;
            private EmployeeDao employeeDao;
            private DepartmentDao departmentDao;
            private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
        
            {
                ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
                jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbcTemplate");
                employeeDao = ctx.getBean(EmployeeDao.class);
                departmentDao = ctx.getBean(DepartmentDao.class);
                namedParameterJdbcTemplate = ctx.getBean(NamedParameterJdbcTemplate.class);
            }
        
            /** * 使用具名参数时, 可以使用 update(String sql, SqlParameterSource paramSource) 方法进行更新操作 * 1. SQL 语句中的参数名和类的属性一致! * 2. 使用 SqlParameterSource 的 BeanPropertySqlParameterSource 实现类作为参数. */
            @Test
            public void testNamedParameterJdbcTemplate2(){
                String sql = "INSERT INTO employees(last_name, email, dept_id) "
                        + "VALUES(:lastName,:email,:dpetId)";
        
                Employee employee = new Employee();
                employee.setLastName("XYZ");
                employee.setEmail("xyz@sina.com");
                employee.setDpetId(3);
        
                SqlParameterSource paramSource = new BeanPropertySqlParameterSource(employee);
                namedParameterJdbcTemplate.update(sql, paramSource);
            }
        
            /** * 可以为参数起名字. * 1. 好处: 若有多个参数, 则不用再去对应位置, 直接对应参数名, 便于维护 * 2. 缺点: 较为麻烦. */
            @Test
            public void testNamedParameterJdbcTemplate(){
                String sql = "INSERT INTO employees(last_name, email, dept_id) VALUES(:ln,:email,:deptid)";
        
                Map<String, Object> paramMap = new HashMap<>();
                paramMap.put("ln", "FF");
                paramMap.put("email", "ff@163.com");
                paramMap.put("deptid", 2);
        
                namedParameterJdbcTemplate.update(sql, paramMap);
            }
        
            @Test
            public void testDepartmentDao(){
                System.out.println(departmentDao.get(1));
            }
        
            @Test
            public void testEmployeeDao(){
                System.out.println(employeeDao.get(1));
            }
        
            /** * 获取单个列的值, 或做统计查询 * 使用 queryForObject(String sql, Class<Long> requiredType) */
            @Test
            public void testQueryForObject2(){
                String sql = "SELECT count(id) FROM employees";
                long count = jdbcTemplate.queryForObject(sql, Long.class);
        
                System.out.println(count);
            }
        
            /** * 查到实体类的集合 * 注意调用的不是 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,5);
        
                System.out.println(employees);
            }
        
            /** * 从数据库中获取一条记录, 实际得到对应的一个对象 * 注意不是调用 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, dept_id as \"department.id\" FROM employees WHERE id = ?";
                RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<>(Employee.class);
                Employee employee = jdbcTemplate.queryForObject(sql, rowMapper, 1);
        
                System.out.println(employee);
            }
        
            /** * 执行批量更新: 批量的 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", "aa@163.com", 1});
                batchArgs.add(new Object[]{
             "BB", "bb@163.com", 2});
                batchArgs.add(new Object[]{
             "CC", "cc@163.com", 3});
                batchArgs.add(new Object[]{
             "DD", "dd@163.com", 3});
                batchArgs.add(new Object[]{
             "EE", "ee@163.com", 2});
        
                jdbcTemplate.batchUpdate(sql, batchArgs);
            }
        
            /** * 执行 INSERT, UPDATE, DELETE */
            @Test
            public void testUpdate(){
                String sql = "UPDATE employees SET last_name = ? WHERE id = ?";
                jdbcTemplate.update(sql, "Jack", 5);
            }
        
            @Test
            public void testDataSource() throws SQLException {
                DataSource dataSource = ctx.getBean(DataSource.class);
                System.out.println(dataSource.getConnection());
            }
        
        }
 *  数据库建表
    
        CREATE TABLE `employees` ( `id` int(8) NOT NULL AUTO_INCREMENT, `last_name` varchar(255) DEFAULT NULL, `email` varchar(255) DEFAULT NULL, `dept_id` int(8) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;
 *  db.properties
    
        jdbc.user=root
        jdbc.password=bai5331359
        jdbc.driverClass=com.mysql.jdbc.Driver
        jdbc.jdbcUrl=jdbc:mysql://localhost:3306/spring4?useUnicode=true&characterEncoding=utf8&characterSetResults=utf8&autoReconnect=true
        
        jdbc.initPoolSize=5
        jdbc.maxPoolSize=10
 *  Bean 配置
    
        
            <context:component-scan base-package="com.spring.example">
            
            </context:component-scan> 
        
            
            <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
                <property name="locations">
                    <list>
                        <value>classpath:db.properties</value>
                        
                    </list>
                </property>
            </bean>
        
            
            <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>
        
            
            <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
                <property name="dataSource" ref="dataSource"></property>
            </bean>
        
            <bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
                <constructor-arg ref="dataSource"></constructor-arg>    
            </bean>

--------------------

## **小结** ##

*  Spring 自生提供了 JDBC 的底层API，同时也支持其他 持久层的整合比如 Hibernate、Mybatis等。只不过不同的持久层使用了不同的 “JdbcTemplate”。实现高度热拔插式的封装，这是Spring 受欢迎的一大因素。
 *  由于Spring 自生提供的JDBC API 在实际的项目中很少用到在这里我们简单了解一下，后续将会详细介绍Spring 整个主流的 持久层框架比如 Mybatis 和 Hibernate等。