Spring4笔记8--Spring与JDBC模板（IoC应用的例子）

Spring 与 JDBC模板：

　　为了避免直接使用 JDBC 而带来的复杂且冗长的代码，Spring 提供了一个强有力的模板类---JdbcTemplate 来简化 JDBC 操作。并且，数据源 DataSource 对象与模板 JdbcTemplate 对象均可通过 Bean 的形式定义在配置文件中，充分发挥了依赖注入的威力。

　　因此，对于 JDBC 模板的使用，是 IoC 的应用，是将数据源 DataSource 对象和 JDBC 模板对象注入给了 Dao 层的实现类。

　　代码详解：

　　　　（1）定义实体类 User

package com.tongji.beans;

public class Student {
    private Integer id;
    private String name;
    private int age;
    
    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;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
    
}

　　　　

　　　　（2）定义数据库及表

　　　　

　　　　（3）定义IStudentDao接口：

package com.tongji.dao;

import java.util.List;

import com.tongji.beans.Student;

public interface IStudentDao {
    void insertStudent(Student student);
    void deleteStudent(int id);
    void updateStudent(Student student);
    
    String selectStudentNameById(int id);
    List<String> selectStudentNames();
    
    Student selectStudentById(int id);
    List<Student> selectStudents();
}

　　　　

　　　　（4）定义IStudentDaoImpl实现类：

package com.tongji.dao;

import java.util.List;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

import com.tongji.beans.Student;

public class StudentDaoImpl extends JdbcDaoSupport implements IStudentDao {

    //JDBC模板对增删改的实现都是通过update方法
    @Override
    public void insertStudent(Student student) {
        String sql = "insert into student(name,age) value(?,?)";
        this.getJdbcTemplate().update(sql, student.getName(), student.getAge());
    }

    @Override
    public void deleteStudent(int id) {
        String sql = "delete from student where id = ?";
        this.getJdbcTemplate().update(sql, id);
    }

    @Override
    public void updateStudent(Student student) {
        String sql = "update student set name = ?, age = ? where id = ?";
        this.getJdbcTemplate().update(sql, student.getName(), student.getAge(), student.getId());
    }

    @Override
    public String selectStudentNameById(int id) {
        String sql = "select name from student where id = ?";
        return this.getJdbcTemplate().queryForObject(sql, String.class, id);
    }

    @Override
    public List<String> selectStudentNames() {
        String sql = "select name from student";
        return this.getJdbcTemplate().queryForList(sql, String.class);
    }

    @Override
    public Student selectStudentById(int id) {
        String sql = "select * from student where id = ?";
        return (Student) this.getJdbcTemplate().queryForObject(sql, new StudentRowMapper(), id);
    }

    @Override
    public List<Student> selectStudents() {
        String sql = "select * from student";
        return this.getJdbcTemplate().query(sql, new StudentRowMapper());
    }

}

　　对Dao实现类的解释：

　　（1） 继承JdbcDaoSupport 类的作用：

　　　　Dao 实现类继承 JdbcDaoSupport 类，JdbcDaoSupport 类中有一个属性 JdbcTemplate，用于接收 JDBC 模板。所以 Dao 实现类继承了 JdbcDaoSupport 类后，也就具有了 JDBC 模板属性。在配置文件中，只要将模板对象注入即可。　　 
　　　　再仔细查看 JdbcDaoSupport 类，发现其有一个 dataSource 属性，查看 setDataSource()方法体可知，若 JDBC 模板为 null，则会自动创建一个模板对象。

　　　　所以，在 Spring 配置文件中，对于 JDBC 模板对象的配置完全可以省去，而是在 Dao 实现类中直接注入数据源对象。这样会让系统自动创建 JDBC 模板对象。

　　　　

　　　　

　　（2） JdbcTemplate 类对数据库的操作方法：

　　　　JdbcTemplate 类中提供了对 DB 进行修改、查询的方法。Dao 实现类使用继承自JdbcDaoSupport 的 getTemplate()方法，可以获取到 JDBC 模板对象。

　　　　（1）对 DB 的增、删、改都是通过 update()方法实现的。该方法常用的重载方法有两个：

　　　　　　public int update ( String sql)
　　　　　　public int update ( String sql, Object… args)  
　　　　第 1 个参数为要执行的 sql 语句，第 2 个参数为要执行的 sql 语句中所包含的动态参数。其返回值为所影响记录的条数。一般不用。

　　　　（2）JDBC 模板的查询结果均是以对象的形式返回。根据返回对象类型的不同，可以将查询分为两类：简单对象查询，与自定义对象查询。  
　　　　　　简单对象查询：查询结果为 String、Integer 等简单对象类型，或该类型做为元素的集合类型，如 List<String>等。  
　　　　　　自定义对象查询：查询结果为自定义类型，如 User 等，或该类型做为元素的集合类型，如 List<User>等。
　　　   　　（1）简单对象查询
　　　　　　　　常用的简单对象查询方法有：查询结果为单个对象的 queryForObject()与查询结果为 List的 queryForList()。  
　　　　　　　　　　pubic T queryForObject (String sql, Class<T> type, Object... args)
　　　　　　　　　　pubic List<T> queryForList (String sql, Class<T> type, Object... args) 

　　　　　　（2）自定义对象查询
　　　　　　　　常用的自定义对象查询方法有：查询结果为单个对象的 queryForObject()与查询结果为List 的 query()。  
　　　　　　　　　　pubic T queryForObject (String sql, RowMapper<T> m , Object... args)
　　　　　　　　　　pubic List<T> query (String sql, RowMapper<T > m, Object... args)  
　　　　　　　　注意，RowMapper 为记录映射接口，用于将查询结果集中每一条记录包装为指定对象。该接口中有一个方法需要实现：
　　　　　　　　　　public Object mapRow(ResultSet rs, int rowNum)  
　　　　　　　　参数 rowNum 表示总的结果集中当前行的行号，但参数 rs 并不表示总的结果集，而是表示 rowNum 所代表的当前行的记录所定义的结果集，仅仅是当前行的结果。  
　　　　　　　　一般，该方法体中就是实现将查询结果中当前行的数据包装为一个指定对象。

　　　　　　　　自定义的RowMapper实现类：

package com.tongji.dao;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;

import com.tongji.beans.Student;

//将数据库中的一行记录包装为一个对象
public class StudentRowMapper implements RowMapper<Student> {

    //rs:查询总结果集中，当前遍历的这一行
    //rowNum:当前遍历的行号
    @Override
    public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
        Student student = new Student();
        //从rs中读取数据，并将其包装为student对象
        student.setId(rs.getInt("id"));
        student.setName(rs.getString("name"));
        student.setAge(rs.getInt("age"));
        return student;
    }

}

 

　　　　（5）定义IStudentService接口：

package com.tongji.service;

import java.util.List;

import com.tongji.beans.Student;

public interface IStudentService {
    void addStudent(Student student);
    void removeStudent(int id);
    void modifyStudent(Student student);
    
    String findStudentNameById(int id);
    List<String> findStudentNames();
    
    Student findStudentById(int id);
    List<Student> findStudents();
}

 

　　　　（6）定义IStudentServiceImpl实现类：

package com.tongji.service;

import java.util.List;

import com.tongji.beans.Student;
import com.tongji.dao.IStudentDao;

public class StudentServiceImpl implements IStudentService {
    private IStudentDao dao;
    
    public void setDao(IStudentDao dao) {
        this.dao = dao;
    }

    @Override
    public void addStudent(Student student) {
        dao.insertStudent(student);
    }

    @Override
    public void removeStudent(int id) {
        dao.deleteStudent(id);
    }

    @Override
    public void modifyStudent(Student student) {
        dao.updateStudent(student);
    }

    @Override
    public String findStudentNameById(int id) {
        return dao.selectStudentNameById(id);
    }

    @Override
    public List<String> findStudentNames() {
        return dao.selectStudentNames();
    }

    @Override
    public Student findStudentById(int id) {
        return dao.selectStudentById(id);
    }

    @Override
    public List<Student> findStudents() {
        return dao.selectStudents();
    }

}

 

　　　　（7）配置Spring配置文件：

<?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.xsd">
    
    <!-- 注册数据源：Spring默认的数据源 -->
    <!-- <bean id="myDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql:///mytest" />
        <property name="username" value="root" />
        <property name="password" value="248xiaohai" />
    </bean> -->
    
    <!-- 注册数据源：DBCP数据源 -->
    <!--<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql:///mytest" />
        <property name="username" value="root" />
        <property name="password" value="248xiaohai" />
    </bean> -->
    
    <!-- 注册数据源：C3P0数据源 -->
    <!-- <bean id="myDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql:///mytest" />
        <property name="user" value="root" />
        <property name="password" value="248xiaohai" />
    </bean> -->
    
    <bean id="myDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClass}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.user}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
    <!-- 注册JDBC属性文件 -->
    <!-- <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:jdbc.properties"/>
     </bean> -->
    
    <!-- 注册JDBC属性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    
    <!-- 注册JDBC模板对象,不用注册-->
    <!-- <bean id="myJdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <bean id="studentDao" class="com.tongji.dao.StudentDaoImpl">
        <property name="jdbcTemplate" ref="myJdbcTemplate"/>
    </bean> -->
    
    <!-- 注册Dao -->
    <bean id="studentDao" class="com.tongji.dao.StudentDaoImpl">
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <!-- 注册Service -->
    <bean id="studentService" class="com.tongji.service.StudentServiceImpl">
        <property name="dao" ref="studentDao"></property>
    </bean>    
</beans>

　　　　Spring配置文件的解释：

　　　　（1）数据源的配置
　　　　　　使用 JDBC 模板，首先需要配置好数据源，数据源直接以 Bean 的形式配置在 Spring 配置文件中。根据数据源的不同，其配置方式不同。下面主要讲解三种常用数据源的配置方式：  
　　　　　　　　（1）Spring 默认的数据源  
　　　　　　　　（2）DBCP 数据源  
　　　　　　　　（3）C3P0 数据源
　　　　（2）从属性文件读取数据库连接信息
　　　　　　为了便于维护，可以将数据库连接信息写入到属性文件中，使 Spring 配置文件从中读取数据。属性文件名称随意，但一般都是放在 src 下。

　　　　　　Spring 配置文件从属性文件中读取数据时，需要在<property/>的 value 属性中使用${ }，将在属性文件中定义的 key 括起来，以引用指定属性的值。

　　　　　　该属性文件若要被 Spring 配置文件读取，其必须在配置文件中进行注册。注册方式有两种：  
　　　　　　　　（1）<bean/>方式  
　　　　　　　　（2）<context>方式  （见代码）
　　　　（3）Dao和Service的配置：

　　　　　　注意：Dao只要手动注入数据源对象。

 

　　　　（8） 测试类：

package com.tongji.test;

import java.util.List;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.tongji.beans.Student;
import com.tongji.service.IStudentService;

public class MyTest {
    
    private IStudentService service;

    @Before
    public void before() {
        //创建容器
        @SuppressWarnings("resource")
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        service = (IStudentService) ac.getBean("studentService");
    }
    
    @Test
    public void testAdd() {
        service.addStudent(new Student("张三", 23));
    }
    
    @Test
    public void testRemove() {
        service.removeStudent(1);
    }
    
    @Test
    public void testModify() {
        Student student = new Student("李四", 24);
        student.setId(2);
        service.modifyStudent(student);
    }
    
    @Test
    public void testFindNameById() {
        String name = service.findStudentNameById(2);
        System.out.println(name);
    }
    
    @Test
    public void testFindStudentNames() {
        List<String> name = service.findStudentNames();
        System.out.println(name);
    }
    
    @Test
    public void testFindStudentById() {
        Student student = service.findStudentById(2);
        System.out.println(student);
    }
    
    @Test
    public void testFindStudents() {
        List<Student> students = service.findStudents();
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

 

　　补充：JDBC 模板对象是多例的
　　　　JdbcTemplate 对象是多例的，即系统会为每一个使用模板对象的线程（方法）创建一个JdbcTemplate 实例，并且在该线程（方法）结束时，自动释放 JdbcTemplate 实例。所以在每次使用 JdbcTemplate 对象时，都需要通过 getJdbcTemplate()方法获取。