Spring-AOP

Aspect Oriented Programming 面向切面编程，一种编程范式，组织开发者如何组织程序结构

能在不改动原始设计的基础上为其增强功能，无入侵式

基本概念

• 连接点（JoinPoint）：原始类执行的方法 update()、 delete()...
• 切入点（Poincut）：进行功能增强的需要切入的方法，方法在没有增强之前不是切入点，但是是连接点
• 通知方法（Advice）：在切入点后执行的操作，也就是增强的共性功能
• 通知类：通知方法所在的类就叫做通知类

AOP流程

工作流

1. Spring 容器启动

2. 读取所有切面配置中的切入点

3. 初始化 Bean ， 判定 Bean 对应的类中的方法是否匹配到任意切入点

   匹配成功，创建原始对象

   匹配失败，创建原始对象的代理对象

4. 获取 Bean 执行方法

   获取的 Bean 是原始对象，调用执行方法，完成操作

   获取的 Bean 是代理对象，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

目标对象 Target ： 被代理的对象，也叫原始对象

代理对象 Proxy：代理后生成的对象，由Spring帮助我们创建代理对象

Aop切入点

• 切入点：要进行增强的方法

• 切入点表达式：要进行增强的方法扫描方式

  方式一：执行接口的方法

  @Pointcut("execution(void com.yuadh.dao.BookDao.update()"")
  

  方法二：执行实现类的方法

  @Pointcut("execution(void com.yuadh.dao.impl.bookDaoImpl.update()"")
  

标准格式

• 动作关键词
• 访问修饰符
• 返回值
• 包名
• 类/接口名
• 方法名
• 参数：多个参数类型用逗号隔开
• 异常名：方法定义中抛出指定异常

@Pointcut("execution(public User com.yuadh.service.UserService.findById(int)")

通配符

• * ： 单个独立的任意符号，可以独立出现，也可以作为前缀或后缀的通配符出现

  execution(public * com.yuadh.*.UserService.find*(*))
  

  匹配 com.yuadh 包下任意包中的 UserService 类或接口 中所有带 find开头带一个参数的方法，返回值任意

• .. ：多个连续的任意符号，可以独立出现，常用于简化包与参数的书写

  execution (public User com..UserService.findById(..))
  

  匹配 com 包下任意包中的 UserService 类或接口中所有为 findById 的方法，解构所有可迭代

• + ：专用于匹配子类类型

  execution (* *..*Sercive+.*(..))
  

注意事项

• 描述接入点通常 描述接口 ， 而不描述实现类
• 访问控制修饰符正对接口开发均采用 public 描述，也可以省略
• 返回值类型对于增删改查使用精准类型加速匹配，常用 * 做单个包扫描匹配，或精准匹配
• 包名书写尽量不适用 .. 匹配，常用 *
• 接口名/类名 书写名称与模块相关的采用 * 匹配
• ...

Aop通知类型

Aop 通知抽取了共性功能，根据共性功能的位置不同，最终运行代码时要将其加入到合理的位置

• 前置通知：在切入点方法执行前执行
• 后置通知：在切入点执行之后执行，无论切入点方法内部是否出现异常，后置通知都会执行
• 环绕通知：手动调用切入点方法并对其进行增强的通知方式
• 返回后通知：在切入点方法执行之后，如果切入点方法内部发生异常后不会执行
• 抛出异常后通知：在切入点执行之后，只有当切入点方法内部出现异常后才会执行

前置通知

名称： @Before

作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法之前运行

@Before("pt()")
public void before() {
    System.out.println("before advice ...");
}

后置通知

名称 ： @After

作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法之前运行

@After("pt()")
public void after() {
    System.out.println("after advice ...");
}

环绕通知

名称： @Around

作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前后运行

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("around before advice ...");
    Object ret = pjp.proceed();
    System.out.println("around after advice ...");
    return ret;
}

1. 环绕通知方法形参必须是 ProceedingJoinPoint，表示正在执行的连接点，使用该对象的 proceed() 方法之后表示对原始对象方法调用通过，返回值为原始对象的返回值
2. 环绕通知方法的返回值建议写成 Object 类型，用于将原始对象方法 的返回值进行返回，哪里使用代理对象就返回到哪里

返回后通知

名称：@AfterReturning

作用：当前通知方法在原始切入点方法正常执行完毕后执行，出现异常不会执行

@AfterReturning("pt()")
public void afterReturning() {
    System.out.println("afterReturning advice ...");
}

抛出异常通知

名称：@AfterThrowing

作用：当前通知方法在原始切入点方法运行抛出异常后执行

@AfterThrowing("pt()")
public void afterThrowing() {
    System.out.println("afterThrowing advice ...");
}

快速开始

导入坐标

<dependencies>
    <!--spring核心依赖，会将spring-aop传递进来-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
    <!--切入点表达式依赖，目的是找到切入点方法，也就是找到要增强的方法-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>
</dependencies>

准备实现类

public interface BookDao {
    public void save();
    public void update();
}

@Repository
public class BookDaoImpl implements BookDao {

    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save ...");
    }
    public void update(){
        System.out.println("book dao update ...");
    }
}

定义通知类，定义加强方法

//通知类必须配置成Spring管理的bean
@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {
    //设置切入点，@Pointcut注解要求配置在方法上方
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}

    //设置在切入点pt()的前面运行当前操作(前置通知)
    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

配置类开启Aop使能

@Configuration
@ComponentScan("com.itheima")
//开启注解开发AOP功能
@EnableAspectJAutoProxy
public class SpringConfig {
}

测试类

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update();
    }
}

AOP示例

万次执行效率

 @Around("pt()")
    public void method01(ProceedingJoinPoint pjp) throws Throwable {
        Signature signature = pjp.getSignature();
        String className = signature.getDeclaringTypeName();
        String methodName = signature.getName();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            pjp.proceed();
        }
        long end = System.currentTimeMillis();
        System.out.println("万次执行"+className+"."+methodName+"==>"+(end-start));
    }

Aop数据获取

获取参数

方式一

@Before("pt()")
public void before(JoinPoint jp) {
    Object[] args = jp.getArgs(); //获取连接点方法的参数们
    System.out.println(Arrays.toString(args));
}

方式二

 @Around("pt()")
    public Object method02(ProceedingJoinPoint jp) throws Throwable {
        Object[] args = jp.getArgs();
        System.out.println(Arrays.toString(args));
        Object ret = jp.proceed();
        return  ret;
    }

注意原始方法需要有参数才能获取到

获取返回值

@AfterReturning(value = "pt()",returning = "ret")
public void afterReturning(JoinPoint jp,int ret) {
    System.out.println("test");
    System.out.println("afterReturning advice ..."+ret);
}

注意原始方法需要有返回值

环绕通知返回

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    // 手动调用连接点方法，返回值就是连接点方法的返回值
    Object ret = pjp.proceed();
    return ret;
}

获取异常

异常的捕获需要异常出现在原始方法的执行中

@AfterThrowing(value = "pt()",throwing = "t")
public void afterThrowing(Throwable t) {//变量名要和throwing = "t"的属性值一致
    System.out.println("afterThrowing advice ..."+ t);
}

捕获处理

@Around("pt()")
public Object around(ProceedingJoinPoint pjp)  {
    Object ret = null;
    //此处需要try...catch处理，catch中捕获到的异常就是连接点方法中抛出的异常
    try {
        ret = pjp.proceed();
    } catch (Throwable t) {
        t.printStackTrace();
    }
    return ret;
}

密码去除空格案例

需求：对密码右边多余的空格做兼容处理

准备DAO和Service

public interface ResourcesDao {
    boolean readResources(String url, String password);
}
@Repository
public class ResourcesDaoImpl implements ResourcesDao {
    @Override
    public boolean readResources(String url, String password) {
        System.out.println(password.length());
        //模拟校验
        return password.equals("root");
    }
}

public interface ResourcesService {
    public boolean openURL(String url ,String password);
}
@Service
public class ResourcesServiceImpl implements ResourcesService {
    @Autowired
    private ResourcesDao resourcesDao;
    @Override
    public boolean openURL(String url, String password) {
        return resourcesDao.readResources(url,password);
    }
}

通知类设置

@Component
@Aspect
public class DataAdvice {
    @Pointcut("execution(* com.yuadh.*.*.*(..))")
    private void servicePt(){}
    @Around("DataAdvice.servicePt()")
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            if(args[i].getClass().equals(String.class)){
                args[i] = args[i].toString().trim();
            }
        }
        Object ret = pjp.proceed(args);
        return ret;
    }
}

测试类

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        ResourcesService resourcesService = ctx.getBean(ResourcesService.class);
        boolean flag = resourcesService.openURL("http://pan.baidu.com/haha", "root ");
        System.out.println(flag);
    }
}

AOP事务处理

事务简介

事务作用： 在数据层保障一系列的数据库操作同时成功或失败

Spring-AOP事务处理： 在数据层和业务层

快速开始

环境准备

public interface AccountDao {

    @Update("update tbl_account set money = money + #{money} where name = #{name}")
    void inMoney(@Param("name") String name, @Param("money") Double money);

    @Update("update tbl_account set money = money - #{money} where name = #{name}")
    void outMoney(@Param("name") String name, @Param("money") Double money);
}

public interface AccountService {
    /**
     * 转账操作
     * @param out 传出方
     * @param in 转入方
     * @param money 金额
     */
    public void transfer(String out,String in ,Double money) ;
}

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    public void transfer(String out,String in ,Double money) {
        accountDao.outMoney(out,money);
        int i = 1/0;
        accountDao.inMoney(in,money);
    }
}

数据库和实体类的准备

业务层添加Spring事务管理

public interface AccountService {
    //配置当前接口方法具有事务
    @Transactional
    public void transfer(String out,String in ,Double money) ;
}

表示开启事务，一般添加到方法上或接口上表示开启所有方法的事务

设置事务管理器添加到IOC容器

//配置事务管理器，mybatis使用的是jdbc事务
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
    DataSourceTransactionManager dtm = new DataSourceTransactionManager();
    transactionManager.setDataSource(dataSource);
    return transactionManager;
}

配置类开启事务使能切面

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {

    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",100D);
    }
}

事务扩展

转账业务追加日志案例

需求：实现任意两个账户转账操作时添加记录日志

环境准备

USE spring_db;
CREATE TABLE tbl_log(
	id INT PRIMARY KEY AUTO_INCREMENT,
	info VARCHAR(255),
	createDate DATE
);

public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional
    void log(String out, String in, Double money);
}

@Service
  public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;
    public void log(String out,String in,Double money ) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}

public interface LogDao {
    @Insert("insert into tbl_log (info,createDate) values(#{info},now())")
    void log(String info);
}

注意此处 LogService 开启的事务传播行为要设置为

@Transactional(propagation = Propagation.REQUIRES_NEW)
void log(String out, String in, Double money);

设置 logService 的插入

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    @Autowired
    private LogService logService;

    public void transfer(String out,String in ,Double money) {
        try{
            accountDao.outMoney(out,money);
            int i = 1/0;
            accountDao.inMoney(in,money);
        }finally {
            logService.log(out,in,money);
        }
    }
}

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",50D);
    }
}

事务传播行为

AOP总结

概念：AOP 面向切面编程，一种编程范式

作用：在不动原始设计的基础方法上为方法进行增强

核心概念：

• 代理（Proxy）
• 连接点 （JoinPoint）
• 切入点（Poincut）
• 通知（Advice）
• 切面（Aspect）
• 目标对象（Target）

语法概念：

• execution
• 通配符

五种通知类型

• 前置通知
• 后置通知
• 环绕通知（依赖形参 ProceedingJoinPoint，会隔离原始方法执行，返回值设置为Object，可以对原始方法调用进行异常捕获处理）
• 返回后通知
• 抛出异常后通知