Spring(四)

2020-06-14

1. Spring中的JdbcTemplate

1.1 JdbcTemplate概述

它是spring框架中提供的一个对象，是对原始Jdbc API对象的简单封装。spring框架为我们提供了很多的操作模板类，入下图所示：

我们今天的主角在spring-jdbc-4.24.RELEASE.jar中，我们在导包的时候，除了要导入这个jar包外，还需要导入一个spring-tx-4.2.4.RELEASE.jar（它是和事务相关的）。

1.2 JdbcTemplate对象的创建

我们可以参考它的源码，来一探究竟：

public JdbcTemplate() {
}

public JdbcTemplate(DataSource dataSource) {
    setDataSource(dataSource);
    afterPropertiesSet();
}

public JdbcTemplate(DataSource dataSource, boolean lazyInit) {
    setDataSource(dataSource);
    setLazyInit(lazyInit);
    afterPropertiesSet();
}

除了默认构造函数之外，都需要提供一个数据源。既然有set方法，依据我们之前学过的依赖注入，我们可不可以在配置文件中配置呢？

答案是肯定的。

1.3 Spring中配置数据源

1.3.1 环境搭建

1.3.2 编写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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd">
	
</beans>

1.3.3 配置数据源

我们之前已经接触过了两个数据源，一个是C3P0，一个是DBCP。要想使用这两数据源都需要导入对应的jar包。

1.3.3.1 配置C3P0数据源

导包:

在Spring的配置文件中配置：

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring"></property>
    <property name="user" value="root"></property>
    <property name="password" value="root"></property>
</bean>

1.3.3.2 配置DBCP数据源

导包:

在Spring的配置文件中配置：

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/spring"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
</bean>

1.3.3.3 配置spring内置数据源

spring框架也提供了一个内置数据源，我们也可以使用spring的内置数据源，它就在spring-jdbc-4.2.4.REEASE.jar包中：

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/spring"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
</bean>

1.3.4 将数据库连接的信息配置到属性文件中:

定义属性文件

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring
jdbc.username=root
jdbc.password=root

引入外部的属性文件

一种方式:
<!-- 引入外部属性文件： -->
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location" value="classpath:jdbc.properties"/>
</bean>

二种方式:
<context:property-placeholder location="classpath:jdbc.properties"/>

1.4 JdbcTemplate的增删改查操作

1.4.1 前期准备

创建数据库：
create database spring;
use spring;

创建表：
create table account(
    id int primary key auto_increment,
    name varchar(40),
    money float
)character set utf8 collate utf8_general_ci;

1.4.2 在spring配置文件中配置JdbcTemplate

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 配置一个数据库的操作模板：JdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <!-- 配置数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
</beans>

1.4.3 最基本使用

public class JdbcTemplateDemo2 {
    public static void main(String[] args) {
        
        //1.获取Spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取bean对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
        //3.执行操作
        jt.execute("insert into account(name,money)values('eee',500)");
    }
}

1.4.4 保存操作

public class JdbcTemplateDemo3 {
    public static void main(String[] args) {
        
        //1.获取Spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取bean对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
        //3.执行操作
        //保存
        jt.update("insert into account(name,money)values(?,?)","fff",5000);
    }
}

1.4.5 更新操作

public class JdbcTemplateDemo3 {
    public static void main(String[] args) {
    
        //1.获取Spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取bean对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
        //3.执行操作
        //修改
        jt.update("update account set money = money-? where id = ?",300,6);
    }
}

1.4.6 删除操作

public class JdbcTemplateDemo3 {
    public static void main(String[] args) {
    
        //1.获取Spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取bean对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
        //3.执行操作
        //删除
        jt.update("delete from account where id = ?",6);
    }
}

1.4.7 查询所有操作

public class JdbcTemplateDemo3 {
    public static void main(String[] args) {
    
        //1.获取Spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取bean对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
        //3.执行操作
        //查询所有
        List<Account> accounts = jt.query("select * from account where money > ? ",new AccountRowMapper(), 500);
        for(Account o : accounts){
            System.out.println(o);
        }
    }
}

public class AccountRowMapper implements RowMapper<Account>{
    @Override
    public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
        Account account = new Account();
        account.setId(rs.getInt("id"));
        account.setName(rs.getString("name"));
        account.setMoney(rs.getFloat("money"));
        return account;
    }
}

public class JdbcTemplateDemo3 {

    public static void main(String[] args){
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.跟id获取bean对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
        //3.执行操作
        //查询所有
        List<Account> accounts = jt.query("select * from account where money > ?",new BeanPropertyRowMapper<Account>(Account.class),1000);
        for(Account account : accounts){
            System.out.println(account);
        }
    }
}

1.4.8 查询一个操作

//使用RowMapper的方式：常用的方式
public class JdbcTemplateDemo3 {
    public static void main(String[] args) {
    
        //1.获取Spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取bean对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
        //3.执行操作
        //查询一个
        List<Account> as = jt.query("select * from account where id = ? ", new AccountRowMapper(), 55);
        System.out.println(as.isEmpty()?"没有结果":as.get(0));
    }
}

//使用ResultSetExtractor的方式:不常用的方式
public class JdbcTemplateDemo3 {
    public static void main(String[] args) {
    
        //1.获取Spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取bean对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
        //3.执行操作
        //查询一个
        Account account = jt.query("select * from account where id = ?",new AccountResultSetExtractor(),3);
        System.out.println(account);
    }
}

1.4.9 查询返回一行一列操作

public class JdbcTemplateDemo3 {
    public static void main(String[] args) {
    
        //1.获取Spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取bean对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
        //3.执行操作
        //查询返回一行一列：使用聚合函数，在不使用group by字句时，都是返回一行一列。最长用的就是分页中获取总记录条数
        //queryForObject是spring 3.x之后的新方法，在spring2.x的时候，它的方法是多个：queryForInt  queryForLong queryForShort
        Integer total = jt.queryForObject("select count(*) from account where money > ? ",Integer.class,500);
        System.out.println(total);
    }
}

1.5 在dao中使用JdbcTemplate

1.5.1 准备实体类

/**
 * 账户的实体
 */
public class Account implements Serializable {

    private Integer id;
    private String name;
    private Float money;
    ...
}

1.5.2 第一种方式：在dao中定义JdbcTemplate

/**
 * 账户的持久层实现类
 * 此版本的dao，需要给dao注入JdbcTemplate
 */
public class AccountDaoImpl implements IAccountDao {

    private JdbcTemplate jdbcTemplate;
    
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    
    @Override
    public Account findAccountById(Integer id) {
        List<Account> list =  jdbcTemplate.query("select * from account where id = ? ",new AccountRowMapper(),id);
        return list.isEmpty()?null:list.get(0);
    }
    
    @Override
    public Account findAccountByName(String name) {
        List<Account> list =  jdbcTemplate.query("select * from account where name = ? ",new AccountRowMapper(),name);
        if(list.isEmpty()){
            return null;
        }
        if(list.size()>1){
            throw new RuntimeException("结果集不唯一，不是只有一个账户对象");
        }
        return list.get(0);
    }
    
    @Override
    public void updateAccount(Account account) {
        jdbcTemplate.update("update account set money = ? where id = ? ",account.getMoney(),account.getId());
    }

}

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd">
	
    <!-- 配置一个dao -->
    <bean id="accountDao" class="com.wgy.dao.impl.AccountDaoImpl">
        <!-- 注入jdbcTemplate -->
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
    
    <!-- 配置一个数据库的操作模板：JdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <!-- 配置数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
</beans>

1.5.3 第二种方式：让dao继承JdbcDaoSupport

JdbcDaoSupport是spring框架为我们提供的一个类，该类中定义了一个JdbcTemplate对象，我们可以直接获取使用，但是要想创建该对象，需要为其提供一个数据源：具体源码如下：

public abstract class JdbcDaoSupport extends DaoSupport {
    //定义对象
    private JdbcTemplate jdbcTemplate; 
    //set方法注入数据源，判断是否注入了，注入了就创建JdbcTemplate
    public final void setDataSource(DataSource dataSource) {
        if (this.jdbcTemplate == null || dataSource != this.jdbcTemplate.getDataSource()) {				//如果提供了数据源就创建JdbcTemplate
            this.jdbcTemplate = createJdbcTemplate(dataSource);
            initTemplateConfig();
        }
    }
    //使用数据源创建JdcbTemplate
    protected JdbcTemplate createJdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
    
    //当然，我们也可以通过注入JdbcTemplate对象
    public final void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
        initTemplateConfig();
    }
    //使用getJdbcTmeplate方法获取操作模板对象
    public final JdbcTemplate getJdbcTemplate() {
      return this.jdbcTemplate;
    }
}

/**
 * 账户的持久层实现类
 * 此版本dao，只需要给它的父类注入一个数据源
 */
public class AccountDaoImpl2 extends JdbcDaoSupport implements IAccountDao {

    @Override
    public Account findAccountById(Integer id) {
        //getJdbcTemplate()方法是从父类上继承下来的。
        List<Account> list = getJdbcTemplate().query("select * from account where id = ? ",new AccountRowMapper(),id);
        return list.isEmpty()?null:list.get(0);
    }
    
    @Override
    public Account findAccountByName(String name) {
        //getJdbcTemplate()方法是从父类上继承下来的。
        List<Account> list =  getJdbcTemplate().query("select * from account where name = ? ",new AccountRowMapper(),name);
        if(list.isEmpty()){
            return null;
        }
        if(list.size()>1){
            throw new RuntimeException("结果集不唯一，不是只有一个账户对象");
        }
        return list.get(0);
    }
    
    @Override
    public void updateAccount(Account account) {
        //getJdbcTemplate()方法是从父类上继承下来的。
        getJdbcTemplate().update("update account set money = ? where id = ? ",account.getMoney(),account.getId());
    }
}

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd">
	
    <!-- 配置dao2 -->
    <bean id="accountDao2" class="com.wgy.dao.impl.AccountDaoImpl2">
        <!-- 注入dataSource -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
</beans>

1.5.4 两种方式有什么区别呢？

第一种在Dao类中定义JdbcTemplate的方式，适用于所有配置方式（xml和注解都可以）。
第二种让Dao继承JdbcDaoSupport的方式，只能用于基于XML的方式，注解用不了。

2. Spring中的事务控制

2.1 Spring中事务控制的API介绍

2.1.1 `PlatformTransactionManager`

此接口是spring的事务管理器，它里面提供了我们常用的操作事务的方法，如下图：

我们在开发中都是使用它的实现类，如下图：

1
2
3

真正管理事务的对象
    org.springframework.jdbc.datasource.DataSourceTransactionManager	使用Spring JDBC或iBatis 进行持久化数据时使用
    org.springframework.orm.hibernate3.HibernateTransactionManager		使用Hibernate版本进行持久化数据时使用

2.1.2 `TransactionDefinition`

它是事务的定义信息对象，里面有如下方法：

2.1.2.1 事务的隔离级别

2.1.2.2 事务的传播行为

REQUIRED:如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）
SUPPORTS:支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）
MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常
REQUERS_NEW:新建事务，如果当前在事务中，把当前事务挂起。
NOT_SUPPORTED:以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
NEVER:以非事务方式运行，如果当前存在事务，抛出异常
NESTED:如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行REQUIRED类似的操作。

2.1.2.3 超时时间

默认值是-1，没有超时限制。如果有，以秒为单位进行设置。

2.1.2.4 是否是只读事务

建议查询时设置为只读

2.1.3 `TransactionStatus`

此接口提供的是事务具体的运行状态，方法介绍如下图：

2.2 基于XML的声明式事务控制（配置方式）

2.2.1 环境搭建

2.2.1.1 拷贝必要的jar

2.2.1.2 创建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:aop="http://www.springframework.org/schema/aop"
        xmlns:tx="http://www.springframework.org/schema/tx"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans 
                            http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/tx 
                            http://www.springframework.org/schema/tx/spring-tx.xsd
                            http://www.springframework.org/schema/aop 
                            http://www.springframework.org/schema/aop/spring-aop.xsd">	
</beans>

2.2.1.3 准备实体类

/**
 * 账户的实体
 */
public class Account implements Serializable {

    private Integer id;
    private String name;
    private Float money;
    ...
}

2.2.1.4 编写业务层接口和实现类

/**
 * 账户的业务层接口
 */
public interface IAccountService {
	
    /**
     * 根据id查询账户信息
     * @param id
     * @return
     */
    Account findAccountById(Integer id);//查
    
    /**
     * 转账
     * @param sourceName	转出账户名称
     * @param targeName		转入账户名称
     * @param money			转账金额
     */
    void transfer(String sourceName,String targeName,Float money);//增删改
}

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {
	
    private IAccountDao accountDao;
    
    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }
    
    @Override
    public Account findAccountById(Integer id) {
        return accountDao.findAccountById(id);
    }
    
    @Override
    public void transfer(String sourceName, String targeName, Float money) {
        //1.根据名称查询两个账户
        Account source = accountDao.findAccountByName(sourceName);
        Account target = accountDao.findAccountByName(targeName);
        //2.修改两个账户的金额
        source.setMoney(source.getMoney()-money);//转出账户减钱
        target.setMoney(target.getMoney()+money);//转入账户加钱
        //3.更新两个账户
        accountDao.updateAccount(source);
        int i=1/0;
        accountDao.updateAccount(target);
    }
}

2.2.1.5 编写Dao接口和实现类

/**
 * 账户的持久层接口
 */
public interface IAccountDao {
	
    /**
     * 根据id查询账户信息
     * @param id
     * @return
     */
    Account findAccountById(Integer id);
    
    /**
     * 根据名称查询账户信息
     * @return
     */
    Account findAccountByName(String name);
    
    /**
     * 更新账户信息
     * @param account
     */
    void updateAccount(Account account);
}

/**
 * 账户的持久层实现类
 * 此版本dao，只需要给它的父类注入一个数据源
 */
public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {

    @Override
    public Account findAccountById(Integer id) {
        List<Account> list = getJdbcTemplate().query("select * from account where id = ? ",new AccountRowMapper(),id);
        return list.isEmpty()?null:list.get(0);
    }
    
    @Override
    public Account findAccountByName(String name) {
        List<Account> list =  getJdbcTemplate().query("select * from account where name = ? ",new AccountRowMapper(),name);
        if(list.isEmpty()){
            return null;
        }
        if(list.size()>1){
            throw new RuntimeException("结果集不唯一，不是只有一个账户对象");
        }
        return list.get(0);
    }
    
    @Override
    public void updateAccount(Account account) {
        getJdbcTemplate().update("update account set money = ? where id = ? ",account.getMoney(),account.getId());
    }
}

/**
 * 账户的封装类RowMapper的实现类
 */
public class AccountRowMapper implements RowMapper<Account>{

    @Override
    public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
        Account account = new Account();
        account.setId(rs.getInt("id"));
        account.setName(rs.getString("name"));
        account.setMoney(rs.getFloat("money"));
        return account;
    }
}

2.2.1.6 在配置文件中配置业务层和持久层

<!-- 配置service -->
<bean id="accountService" class="com.wgy.service.impl.AccountServiceImpl">
    <property name="accountDao" ref="accountDao"></property>
</bean>
	
<!-- 配置dao -->
<bean id="accountDao" class="com.wgy.dao.impl.AccountDaoImpl">
    <!-- 注入dataSource -->
    <property name="dataSource" ref="dataSource"></property>
</bean>
	
<!-- 配置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/spring"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
</bean>

2.2.2 配置步骤

2.2.2.1 配置事务管理器

<!-- 配置一个事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!-- 注入DataSource -->
    <property name="dataSource" ref="dataSource"></property>
</bean>

2.2.2.2 配置事务的通知引用事务管理器

1
2
3

<!-- 事务的配置 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
</tx:advice>

2.2.2.3 配置事务的属性

<!--在tx:advice标签内部 配置事务的属性 -->
<tx:attributes>
    <!-- 指定方法名称：是业务核心方法 
        read-only：是否是只读事务。默认false，不只读。
        isolation：指定事务的隔离级别。默认值是使用数据库的默认隔离级别。 
        propagation：指定事务的传播行为。
        timeout：指定超时时间。默认值为：-1。永不超时。
        rollback-for：用于指定一个异常，当执行产生该异常时，事务回滚。产生其他异常，事务不回滚。没有默认值，任何异常都回滚。
        no-rollback-for：用于指定一个异常，当产生该异常时，事务不回滚，产生其他异常时，事务回滚。没有默认值，任何异常都回滚。
    -->
    <tx:method name="*" read-only="false" propagation="REQUIRED"/>
    <tx:method name="find*" read-only="true" propagation="SUPPORTS"/>
</tx:attributes>

2.2.2.4 配置AOP-切入点表达式

<!-- 配置aop -->
<aop:config>
    <!-- 配置切入点表达式 -->
    <aop:pointcut expression="execution(* com.wgy.service.impl.*.*(..))" id="pt1"/>
</aop:config>

2.2.2.5 配置切入点表达式和事务通知的对应关系

1 2	<!-- 在aop:config标签内部：建立事务的通知和切入点表达式的关系 --> <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"/>

2.2.2.6 完整配置

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

    <!-- 配置service -->
    <bean id="accountService" class="com.wgy.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!-- 配置dao -->
    <bean id="accountDao" class="com.wgy.dao.impl.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置SPRING内置数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

    <!-- spring基于XML的声明式事务控制 -->
    <!-- 第一步：配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入数据源 -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 第二步：配置事务的通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!-- 第四步：配置事务的属性
            isolation：配置事务的隔离级别。默认值：DEFAULT，使用数据库的默认隔离级别。mysql是REPEATABLE_READ
            propagation：配置事务的传播行为。默认值是：REQUIRED。 一般的选择。（增删改方法）。当是查询方法时，选择SUPPORTS
            timeout：指定事务的超时时间。默认值是：-1，永不超时。当指定其他值时，以秒为单位
            read-only：配置是否只读事务。默认值是：false，读写型事务。   当指定为true时，表示只读，只能用于查询方法。
            rollback-for：用于指定一个异常，当执行产生该异常时，事务回滚。产生其他异常时，事务不回滚。没有默认值，任何异常都回滚。
            no-rollback-for：用于指定一个异常，当执行产生该异常时，事务不回滚。产生其他异常时，事务回滚。没有默认值，任何异常都回滚。
        -->
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED" read-only="false"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>

    <!-- 第三步：配置aop
        要配的是：切入点表达式
                通知和切入点表达式的关联
    -->
    <aop:config>
        <!-- 配置切入点表达式 -->
        <aop:pointcut expression="execution(* com.wgy.service.impl.*.*(..))" id="pt1"/>
        <!-- 配置事务通知和切入点表达式的关联 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"/>
    </aop:config>
</beans>

2.3 基于XML和注解组合使用的整合方式

2.3.1 环境搭建

2.3.1.1 拷贝必备的jar

2.3.1.2 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:aop="http://www.springframework.org/schema/aop"
                xmlns:tx="http://www.springframework.org/schema/tx"
                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/tx 
                                    http://www.springframework.org/schema/tx/spring-tx.xsd
                                    http://www.springframework.org/schema/aop 
                                    http://www.springframework.org/schema/aop/spring-aop.xsd
                                    http://www.springframework.org/schema/context
                                    http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 配置spring要扫描的包 -->
    <context:component-scan base-package="com.wgy"></context:component-scan>
</beans>

2.3.1.3 准备实体类

/**
 * 账户的实体
 */
public class Account implements Serializable {

    private Integer id;
    private String name;
    private Float money;
    ...
}

2.3.1.4 业务层实现类使用注解让spring管理

/**
 * 账户的业务层实现类
 */
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private IAccountDao accountDao;
    
    @Override
    public Account findAccountById(Integer id) {
        return accountDao.findAccountById(id);
    }
    
    @Override
    public void transfer(String sourceName, String targeName, Float money) {
        //1.根据名称查询两个账户
        Account source = accountDao.findAccountByName(sourceName);
        Account target = accountDao.findAccountByName(targeName);
        //2.修改两个账户的金额
        source.setMoney(source.getMoney()-money);//转出账户减钱
        target.setMoney(target.getMoney()+money);//转入账户加钱
        //3.更新两个账户
        accountDao.updateAccount(source);
        int i=1/0;
        accountDao.updateAccount(target);
    }
}

2.3.1.5 Dao实现类使用注解让spring管理

@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public Account findAccountById(Integer accountId) {
        List<Account> list = jdbcTemplate.query("select * from account where id = ? ", new BeanPropertyRowMapper<Account>(Account.class), accountId);
        return list.isEmpty() ? null : list.get(0);
    }

    @Override
    public Account findAccountByName(String name) {
        List<Account> list = jdbcTemplate.query("select * from account where name = ? ", new BeanPropertyRowMapper<Account>(Account.class), name);
        if (list.isEmpty()) {
            //没有这个名称的账户
            return null;
        }
        if (list.size() > 1) {
            //结果集不唯一，不符合我们的约定
            throw new RuntimeException("结果集不唯一，请检查数据");
        }
        return list.get(0);
    }

    @Override
    public void updateAccount(Account account) {
        jdbcTemplate.update("update account set name=?,money=? where id=?", account.getName(), account.getMoney(), account.getId());
    }

}

2.3.2 配置步骤

2.3.2.1 配置数据源和JdbcTemplate

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

<!-- 配置SPRING内置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/spring"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
</bean>

2.3.2.2 配置事务管理器并注入数据源

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!-- 注入数据源 -->
    <property name="dataSource" ref="dataSource"></property>
</bean>

2.3.2.3 在业务层使用@Transactional注解

<!-- 在需要事务的地方使用@Transactional注解
    该注解可以写在接口上，类上和方法上。
    写在接口上，表示该接口的所有实现类都有事务。
    写在类上，表示该类中所有方法都有事务。
    写在方法，表示该方法有事务。
    优先级：就近原则。方法>类>接口
-->

@Service("accountService")
@Transactional(propagation = Propagation.SUPPORTS,readOnly = true)//只读型
public class AccountServiceImpl implements IAccountService {

    @Autowired
    private IAccountDao accountDao;

    @Override
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }

    @Override
    @Transactional(propagation=Propagation.REQUIRED,readOnly=false)//读写型
    public void transfer(String sourceName, String targetName, Float money) {
        //1.根据名称查询账户信息
        Account source = accountDao.findAccountByName(sourceName);
        Account target = accountDao.findAccountByName(targetName);
        //2.转出账户减钱，转入账户加钱
        source.setMoney(source.getMoney() - money);
        target.setMoney(target.getMoney() + money);
        //3.更新账户信息
        accountDao.updateAccount(source);
        int i = 1 / 0;
        accountDao.updateAccount(target);
    }

}

2.3.2.4 在配置文件中开启spring对注解事务的支持

1 2	<!-- 开启spring对注解事务的支持 --> <tx:annotation-driven transaction-manager="transactionManager"/>

2.4 基于纯注解的声明式事务控制（配置方式）

2.4.1 环境搭建

2.4.1.1 拷贝必备的jar包

2.4.1.2 创建一个类用于加载spring的配置并指定要扫描的包

/**
 * 用于初始化spring容器的配置类
 */
@Configuration
@ComponentScan(basePackages="com.wgy")
public class SpringConfiguration {

}

2.4.1.3 准备实体类

/**
 * 账户的实体
 */
public class Account implements Serializable {

    private Integer id;
    private String name;
    private Float money;
    ...
}

2.4.1.4 业务层实现类使用注解让spring管理

/**
 * 账户的业务层实现类
 */
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private IAccountDao accountDao;
    
    @Override
    public Account findAccountById(Integer id) {
        return accountDao.findAccountById(id);
    }
    
    @Override
    public void transfer(String sourceName, String targeName, Float money) {
        //1.根据名称查询两个账户
        Account source = accountDao.findAccountByName(sourceName);
        Account target = accountDao.findAccountByName(targeName);
        //2.修改两个账户的金额
        source.setMoney(source.getMoney()-money);//转出账户减钱
        target.setMoney(target.getMoney()+money);//转入账户加钱
        //3.更新两个账户
        accountDao.updateAccount(source);
        int i=1/0;
        accountDao.updateAccount(target);
    }
}

2.4.1.5 Dao实现类使用注解让spring管理

@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public Account findAccountById(Integer accountId) {
        List<Account> list = jdbcTemplate.query("select * from account where id = ? ", new BeanPropertyRowMapper<Account>(Account.class), accountId);
        return list.isEmpty() ? null : list.get(0);
    }

    @Override
    public Account findAccountByName(String name) {
        List<Account> list = jdbcTemplate.query("select * from account where name = ? ", new BeanPropertyRowMapper<Account>(Account.class), name);
        if (list.isEmpty()) {
            //没有这个名称的账户
            return null;
        }
        if (list.size() > 1) {
            //结果集不唯一，不符合我们的约定
            throw new RuntimeException("结果集不唯一，请检查数据");
        }
        return list.get(0);
    }

    @Override
    public void updateAccount(Account account) {
        jdbcTemplate.update("update account set name=?,money=? where id=?", account.getName(), account.getMoney(), account.getId());
    }

}

2.4.2 配置步骤

2.4.2.1 使用@Bean注解配置数据源和JdbcTemplate

/**
 * 连接数据库的配置类
 *
 * @author wgy
 */
public class JdbcConfig {

    @Bean(name = "jdbcTemplate")
    public JdbcTemplate createJdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    @Bean(name = "dataSource")
    public DataSource createDataSource() {
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/spring");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
    }
}

2.4.2.2 使用@Bean注解配置配置事务管理器

/**
 * 事务控制的配置类
 *
 * @author wgy
 */
public class TransactionManager {

    @Bean(name = "transactionManager")
    public PlatformTransactionManager createTransactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

2.4.2.3 在业务层使用@Transactional注解

<!-- 在需要事务的地方使用@Transactional注解
    该注解可以写在接口上，类上和方法上。
    写在接口上，表示该接口的所有实现类都有事务。
    写在类上，表示该类中所有方法都有事务。
    写在方法，表示该方法有事务。
    优先级：就近原则。方法>类>接口
-->

@Service("accountService")
@Transactional(propagation = Propagation.SUPPORTS,readOnly = true)//只读型
public class AccountServiceImpl implements IAccountService {

    @Autowired
    private IAccountDao accountDao;

    @Override
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }

    @Override
    @Transactional(propagation=Propagation.REQUIRED,readOnly=false)//读写型
    public void transfer(String sourceName, String targetName, Float money) {
        //1.根据名称查询账户信息
        Account source = accountDao.findAccountByName(sourceName);
        Account target = accountDao.findAccountByName(targetName);
        //2.转出账户减钱，转入账户加钱
        source.setMoney(source.getMoney() - money);
        target.setMoney(target.getMoney() + money);
        //3.更新账户信息
        accountDao.updateAccount(source);
        int i = 1 / 0;
        accountDao.updateAccount(target);
    }

}

2.4.2.4 使用@EnableTransactionManagement开启spring对注解事务的的支持

/**
 * spring的配置类，作用就是当bean.xml用
 *
 * @author wgy
 */
@Configuration
@ComponentScan("com.wgy")
@Import({JdbcConfig.class, TransactionManager.class})
@EnableTransactionManagement
public class SpringConfiguration {

}

-------------本文结束感谢您的阅读-------------

本文作者： Wgy
本文标题： Spring(四)
本文链接： https://wgy1993.gitee.io/archives/924a9eab.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 进行许可。转载请注明出处！