Spring学习(三)--------AOP注解操作以及事务管理

基于 aspectj 的注解操作AOP

1.使用注解方式实现 aop 操作
第一步 创建对象

package studyDay3.aop;

public class Book {
    public void add() {
        System.out.println("add....");
    }
}

package studyDay3.aop;

public class MyBook {
    public void before1() {
        System.out.println("before......");
    }
}

	<!-- 创建对象 -->
    <bean id="book" class="studyDay3.aop.Book"/>
    <bean id="myBook" class="studyDay3.aop.MyBook"/>

第二步 在spring 核心配置文件中，开启 aop 操作

    <!-- 开启 AOP 操作-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

第三步 在增强类上面使用注解完成 aop

package studyDay3.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class MyBook {

    @Before(value = "execution(* studyDay3.aop.Book.*(..))")
    //在方法上面使用注解完成 增强配置
    public void before1() {
        System.out.println("before......");
    }
}

Spring 的事务管理

事务概念

1.什么是事务？
一组事务，要么全部成功要么全部失败
2.事务的特性？
原子性，一致性，隔离性，持久性
3.不考虑隔离性产生读问题
脏读，幻读，不可重复读
4.解决读问题
(1)设置隔离级别

Spring 事务管理 api

1.spring 事务管理两种方式
第一种 编程式事务管理(不用)
第二种 声明式事务管理
(1)基于xml 配置文件实现
(2)基于注解实现
2 spring 事务管理的 api
接口 PlatformTransactionManager 事务管理器
(1)spring 针对不同的 dao 层框架，提供接口不同的实现类
(2) 首先配置事务管理器

搭建转账环境

1.创建数据库，添加数据

2.创建 service 和 dao 类，完成注入关系
(1) service 层又叫业务逻辑层
(2) dao 层，单纯对数据库操作层，在 dao 层不添加业务
(3)需求：小王 转账 1000 给 小马
小王少1000
小马 多1000

package service;

import dao.OrdersDao;

public class OrdersService {

    private OrdersDao ordersDao;

    public void setOrdersDao(OrdersDao ordersDao) {
        this.ordersDao = ordersDao;
    }

    //调用dao的方法
    //业务逻辑,写转账业务
    public void accountMoney() {

        //小王少 1000
        ordersDao.lessMoney();
        //小马多 1000
        ordersDao.moreMoney();

    }
}

package dao;

import org.springframework.jdbc.core.JdbcTemplate;

public class OrdersDao {

    //注入模版
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    /**
     * 做对数据库操作的方法,不写业务操作
     */
    //少钱的方法
    public void lessMoney() {
        String sql = "update account set salary=salary-? where username = ?";
        jdbcTemplate.update(sql, 1000, "小王");
    }

    //多钱的方法
    public void moreMoney() {
        String sql = "update account set salary=salary+? where username = ?";
        jdbcTemplate.update(sql, 1000, "小马");
    }
}

3.产生问题
(1)如果小王少了1000之后，出现异常，小马不会多1000，钱丢失了
4.解决
(1)添加事务解决，出现异常进行回滚操作
声明式事务管理(xml配置)
配置文件使用的是aop思想
第一步配置事务管理器

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

第二步配置事务增强

<!-- 配置事务增强-->
    <bean id="txadvice" transaction-manager="transactionManager">
	    <!-- 做事务操作-->
	    <tx:attributes>
	    	<!-- 设置事务操作的方法匹配规则-->
	    	<tx:method name="account*" propagation="REQUIRED"/> 
	    </tx:attributes>
    </bean>

第三步配置切面

	<!-- 配置配切面-->
	<aop:config>
        <!-- 切入点-->
        <aop:pointcut id="pointcut1" expression="execution(* service.OrdersService.*(..))"/>
        <!-- 切面-->
        <aop:advisor advice-ref="txadvice" pointcut-ref="pointcut1"/>
    </aop:config>

声明式事务管理(注解)
第一步 配置事务管理器

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

第二步 配置事务注解

<!-- 开启事务注解 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

第三步 在要使用事务的方法所在类上面添加注解

@Transactional
public class OrdersService {

Spring事务的传播特性

什么是事务的传播特性？

当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。
spring 一共有7种传播特性
TransactionDefinition.PROPAGATION_REQUIRED: 如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
TransactionDefinition.PROPAGATION_SUPPORTS: 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
TransactionDefinition.PROPAGATION_MANDATORY: 如果当前存在事务，则加入该事务;如果当前没有事务，则抛出异常。(mandatory:强制性)
不支持当前事务的情况:
TransactionDefinition.PROPAGATION_REQUIRES_NEW: 创建一个新的事务，如果当前存在事务，则把当前事务挂起。
TransactionDefinition.PROPAGATION_NOT_SUPPORTED: 以非事务方式运行，如果当前存在事务，则把当前事务挂起。
TransactionDefinition.PROPAGATION_NEVER: 以非事务方式运行，如果当前存在事务，则抛出异常。
TransactionDefinition.PROPAGATION_NESTED: 如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。