Spring DAO模块

Spring的DAO模块提供了对JDBC、Hibernate、Mybatis等DAO层支持，本节介绍DAO模块对JDBC的支持。DAO模块依赖ommons-dbcp.jar、commons-pool.jar。

一、JdbcDaoSupport的使用

传统的JDBC时需要创建连接、打开、执行sql、关闭连接这一系列的步骤，Spring框架对JDBC进行了封装，我们只需使用封装好的JdbcTemplate执行sql语句。既然是JdbcDaoSupport的使用，为什么是使用JdbcTemplate呢？因为JdbcDaoSupport提供了JdbcTemplate对象，通过JdbcTemplate对象进行数据库操作。可以转到定义，查看JdbcDaoSupport、JdbcTemplate两个类的具体实现。我们通过下面的例子来了解JdbcDaoSupport的使用，这里还是使用JDBC章节的数据库daodemodb和表t_user信息。

第一步，根据t_user表信息准备Model类User。定义了id、name、age、money属性，并声明了两个构造函数。

package com.demo.model;

public class User {

    @Override
    public String toString() {

        return "Id:"+this.getId()+" Name:"+this.getName()+" Age:"+this.getAge()+" Money:"+this.getMoney();
    }

    private int Id;
    private String Name;
    private int Age;
    private double Money;

    public User()
    {

    }

    public User(String name, int age, double money) {

        Name = name;
        Age = age;
        Money = money;
    }

    public int getId() {
        return Id;
    }

    public void setId(int id) {
        Id = id;
    }

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public int getAge() {
        return Age;
    }

    public void setAge(int age) {
        Age = age;
    }

    public double getMoney() {
        return Money;
    }

    public void setMoney(double money) {
        Money = money;
    }

}

第二步，定义接口类IUserDAO，在接口中声明了两个方法，QueryAllUser方法属于查询操作，查询所有User，AddUser属于更新操作，新增User。

package com.demo.model;

import java.util.*;

public interface IUserDAO {

    public List<User>QueryAllUser();

    public Boolean AddUser(User user);

    public Boolean transfer(int fromUserId, int toUserId, float transferMoney);

}

第三步，就是JdbcDaoSupport的使用了，在下面的SpringDAODemo类中首先继承了JdbcDaoSupport，同时实现了IUserDAO 接口中的方法。JdbcDaoSupport提供了JdbcTemplate对象，SpringDAODemo继承了JdbcDaoSupport,所以也就可以直接获取到JdbcTemplate对象，然后执行该对象的方法进行数据库操作。

package com.demo.model;

import java.util.*;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class SpringDAODemo extends JdbcDaoSupport implements IUserDAO {

    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext(new String[]{"ApplicationContext.xml"});
        BeanFactory factory=context;
        IUserDAO userDao=(IUserDAO)factory.getBean("userDao");
        User user=new User("JdbcDaoSupportTest",26,333.33);
        userDao.AddUser(user);
        List<User> list=userDao.QueryAllUser();
        for(User u:list)
        {
            System.out.println(u.toString());
        }
    }

    public List<User> QueryAllUser() {
        String sql="select id,name,age,money from t_user order by id desc";
        List<Map<String,Object>> list=getJdbcTemplate().queryForList(sql);
        List<User> userList=new ArrayList<User>();
        for(Map<String,Object> row:list)
        {
            User user=new User();
            user.setId((Integer)row.get("id"));
            user.setName((String)row.get("name"));
            user.setAge((Integer)row.get("age"));
            user.setMoney(Double.parseDouble(row.get("money").toString()));
            userList.add(user);
        }
        return userList;
    }

    public Boolean AddUser(User user) {
        String sql="insert into t_user (name,age,money) values (?,?,?)";
        int row=getJdbcTemplate().update(sql, new Object[]{user.getName(),user.getAge(),user.getMoney()});
        if(row>0)
        {
            System.out.println("数据新增成功!");
            return true;
        }
        return false;
    }

}

第四步，配置属性。在上面的main方法中先通过上下文获取到bean对象，然后执行新增操作和查询操作。但是上面的代码并未看到数据库信息，这里还需要在ApplicationContext.xml中配置数据库信息，并为JdbcDaoSupportDemo设置数据源。为什么会有dataSource属性呢，因为JdbcDaoSupport中包含这个属性。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
">
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
  <property name="driverClassName">
          <value>com.mysql.jdbc.Driver</value>
  </property>
  <property name="url">
          <value>jdbc:mysql://127.0.0.1:3306/daodemodb</value>
  </property>
  <property name="username">
          <value>root</value>
  </property>
  <property name="password">
      <value>123456</value>
  </property>
</bean>
<bean id="userDao" class="com.demo.model.SpringDAODemo" depends-on="dataSource">
    <property name="dataSource" ref="dataSource"></property>
</bean>
</beans>

第五步，pom.xml中配置的依赖信息。例子是Spring中DAO的实现，而且是对jdbc的封装，所以包含Spring相关依赖和jdbc的相关依赖。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.demo</groupId>
  <artifactId>SpringDAO</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <spring.version>5.0.0.RELEASE</spring.version>
  </properties>
  <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
            <version>1.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
       </dependencies>
</project>

运行SpringDAODemo，可以发现数据库和打印结果中增加了一条记录。

二.MappingSqlQuery的使用

在JdbcDaoSupport的使用小节获取所有User的方法QueryAllUser()中，使用getJdbcTemplate().queryForList()返回的是List<Map<String,Object>>类型，需要遍历转换成Java对象，那问题来了，查询的不止这一个方法，可能以后会有条件查询的方法，那每次都要把从数据库返回的List<Map<String,Object>>类型的List转一遍，当然也可以专门写一个转换的方法，这样每次传List<Map<String,Object>>类型的参数，然后返回List<User>类型的值。其实还有一种方式，就是使用MappingSqlQuery。MappingSqlQuery是一个抽象类，需要实现它的方法mapRow()。
第一步，实现MappingSqlQuery抽象类，这里在UserMappingSqlQuery类中实现了mapRow()方法。

package com.demo.model;

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

import org.springframework.jdbc.object.MappingSqlQuery;

public class UserMappingSqlQuery extends MappingSqlQuery<User>{

    @Override
    protected User mapRow(ResultSet rs, int rowNum) throws SQLException {
        User user=new User();
        user.setId((Integer)rs.getInt("id"));
        user.setName((String)rs.getString("name"));
        user.setAge((Integer)rs.getInt("age"));
        user.setMoney((Double)rs.getDouble("money"));
        return user;
    }

}

第二步，UserMappingSqlQuery类的使用。这里重写SpringDAODemo类中的QueryAllUser()方法。UserMappingSqlQuery需要传入DataSource和sql，并执行compile()编译。这里通过getDataSource()获取的是JdbcDaoSupport的DataSource属性。如果有参数，可以使用setParameters()设置参数，下面的代码为了演示设置参数，增加了where 1=1的查询条件。

    public List<User> QueryAllUser() {
        String sql="select id,name,age,money from t_user where ?";
        UserMappingSqlQuery userQuery=new UserMappingSqlQuery();
        userQuery.setDataSource(getDataSource());
        userQuery.setSql(sql);
        userQuery.setParameters(new SqlParameter(java.sql.Types.VARCHAR));
        userQuery.compile();
        return userQuery.execute(new Object[]{new String("1=1")});
    }
    

三.SqlUpdate的使用

SqlUpdate主要是用来更新，可以设置参数。SqlUpdate可以将某个功能模块化。通过下面的例子来了解下SqlUpdate的使用。

package com.demo.model;

import javax.sql.DataSource;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.SqlParameter;
import org.springframework.jdbc.object.SqlUpdate;

public class UserSqlUpdate extends SqlUpdate{

    public static void main(String[] args) {

        ApplicationContext context=new ClassPathXmlApplicationContext(new String[]{"ApplicationContext.xml"});
        BeanFactory factory=context;
        UserSqlUpdate userSqlUpdate=(UserSqlUpdate)factory.getBean("userSqlUpdate");
        userSqlUpdate.updateUserMoney("小李",666.66);
    }

    public UserSqlUpdate(DataSource ds) {
        setDataSource(ds);
        setSql("update t_user set money=? where name=?");
        declareParameter(new SqlParameter(java.sql.Types.DOUBLE) );
        declareParameter(new SqlParameter(java.sql.Types.VARCHAR) );
        compile();
    }

    public Boolean updateUserMoney(String name,double money)
    {
        int row= update(new Object[]{new Double(money),new String(name)});
        if(row>0)
        {
            System.out.println("数据新增成功!");
            return true;
        }
        return false;
    }

}

在ApplicationContext.xml中配置userSqlUpdate对应的bean节点。

<bean id="userSqlUpdate" class="com.demo.model.UserSqlUpdate">
  <constructor-arg ref="dataSource" index="0"></constructor-arg>
</bean>

在上面的UserSqlUpdate中继承了SqlUpdate，通过setDataSource、setSql分别设置SqlUpdate的数据源和要执行的sql。在main方法中将name为小李的money修改为666.66，执行main方法之后会打印出数据新增成功，数据库中小李的money改成了666.66。

四.SqlFunction的使用

SqlFunction返回单一行的查询结果，默认返回int，也可以重载返回其他类型。下面直接在main函数中使用。

package com.demo.model;

import org.apache.commons.dbcp.BasicDataSource;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.object.SqlFunction;

public class SqlFunctionDemo {

    public static void main(String[] args) {

        ApplicationContext context=new ClassPathXmlApplicationContext(new String[]{"ApplicationContext.xml"});
        BeanFactory factory=context;
        BasicDataSource dataSource=(BasicDataSource)factory.getBean("dataSource");
        SqlFunction sf=new SqlFunction(dataSource,"select count(1) from t_user;");
        sf.compile();
        int count=sf.run();
        System.out.println("User Count:"+count);
    }

}

五、事务管理

至于什么是事务在JDBC章节已经介绍，这里就不再说。JDBC中有事务管理，Spring使用DataSourceTransactionManager 作为JDBC的事务管理者，同时把被管理的对象使用 TransactionProxyFactoryBean配置。从名字也能猜出这里使用的设计模式是代理设计模式。这是一个事务代理Bean，能够使用IOC、AOP等注入事务管理代码。在JDBC中介绍事务时用的转账操作，这里为了更好理解，还是使用转账操作。
第一步，在IUserDAO接口中增加转账方法transfer。

public Boolean transfer(int fromUserId, int toUserId, float transferMoney);

第二步，在SpringDAODemo类中实现transfer。从fromUserId这个用户转账到toUserId这个用户，outInMoney方法就是执行sql更新数据库用户的money。这里如果人为制造一个异常，把int i=1/0;这行注释取消，就会在后面执行转账时自动回滚，转账不会成功。

    public Boolean transfer(int fromUserId, int toUserId, float transferMoney) {

        Boolean out= outInMoney(fromUserId,-transferMoney);
        int i=1/0; //事务回滚
        Boolean in=outInMoney(toUserId,transferMoney);

        return out∈
    }
    private Boolean outInMoney(int toUserId,float money)
    {
        String sql="update  t_user set money=money+? where id=? ";
        int row=getJdbcTemplate().update(sql, new Object[]{money,toUserId});
        if(row>0)
        {
            return true;
        }
        return false;
    }

第三步，配置事务，在ApplicationContext.xml中配置事务管理对象DataSourceTransactionManager，设置事务代理对象TransactionProxyFactoryBean。

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置业务层代理 -->
<bean id="userDaoProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <!-- 配置目标对象 -->
    <property name="target" ref="userDao"/>
    <!-- 注入事务管理器 -->
    <property name="transactionManager" ref="transactionManager"/>
    <!-- 注入事务的属性 -->
    <property name="transactionAttributes">
        <props>
            <prop key="transfer">PROPAGATION_REQUIRED</prop>
        </props>
    </property>
</bean>

第四步，执行转账操作，在main方法中执行transfer方法，为用户1、2进行转账，如果transfer方法中人为制造的异常注释的话是可以正常转账，取消注释则转账失败，打印事务回滚。

    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext(new String[]{"ApplicationContext.xml"});
        BeanFactory factory=context;
        IUserDAO userDao=(IUserDAO)factory.getBean("userDaoProxy");
        try
        {
          userDao.transfer(1, 2, 100);
        }
        catch(Exception e)
        {
            System.out.println("事务回滚");
        }
    }