Spring AOP五种增强

概念：

AOP，面向切面编程，就是当你已经完成，或者更加注意一些核心功能的时候。需要使用的编程过程，这个使用，你会发现，一个核心的业务，是由一个核心功能，和若干个额外服务类型的功能，统一组成的，比如数据验证，再比如日志的记录。

其实在场景中，我们的核心功能是针对数据库的操作，可能是增删过程。而服务类功能，比如记录日志，或者输入内容的验证过程。其实不是非有不可。没有这个功能，核心功能也能正常执行。

这个时候，我们就要考虑一个问题，这些必要或者非必要的额外功能，是不是要写在你的核心代码过程当中啊?

我们现在，将核心业务，做一个简単的切分

• 核心功能

• 辅助功能

---

spring-AOP 的实现：

1、明确名词

切点（pointcut） 在某些个核心方法之前，之后等位置

• 切点表达式：pointcut = execution(* com.lanou.test.service. * . * (…))
• execution(返回值 全包名.类名.方法名 (参数集合))

增强（advisor） 辅助功能

织入（aspect） 将辅助功能，安装在切点上的过程

2、AOP增强的五种类型：

• 前置增强：before
• 后置增强：after
• 环绕增强：around
• 异常增强：throw
• 返回增强：after returning

---

通过实现接口的方式实现增强

1、前置增强：

通过实现 MethodBeforeAdvice接口，然后编写前置通知的内容。

before方法参数的含义：

• Method method：要被增强的方法
• Object[] objects：切点方法的参数
• Object o：要代理的类的对象（就是要执行方法的对象）

所以前置通知可以拿到参数，并且修改参数或对参数做一些判断

package com.lanou.test.advice;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class MyBeforAdvice implements MethodBeforeAdvice {

    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
//        如果传入的参数不是shiruntao的话，就不执行切点方法
        if (objects[0].equals("shiruntao")) {
            System.out.println("我是AOP ");
        } else {
            throw new Exception("参数不是shiruntao");
        }
    }
}

2、后置增强：

通过实现 AfterReturningAdvice, AfterAdvice 接口，然后编写后置通知的内容。

afterReturning方法参数的含义：

• Object o：返回值对象

• Method method：要被增强的方法

• Object[] objects：切点方法的参数

• Object o1：要代理的类的对象（就是要执行方法的对象）

所以后置通知可以拿到返回值，并且可以修改返回值

package com.lanou.test.advice;

import org.springframework.aop.AfterAdvice;
import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class MyAfterAdvice implements AfterReturningAdvice, AfterAdvice {

    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("你好，我是返回后置通知");
    }
}

3、配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       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
       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">

    <bean id="service" class="com.lanou.test.service.LoginService"></bean>

    <bean id="myBeforeAdvice" class="com.lanou.test.advice.MyBeforeAdvice"></bean>

    <bean id="myAfterAdvice" class="com.lanou.test.advice.MyAfterAdvice"></bean>
    

    <aop:config>
<!--        切点设置 - execution(返回值 全包名.类名.方法名 (参数集合))-->
        <aop:pointcut id="methodsBefore" expression="execution(* com.lanou.test.service.*.*(..))"/>
<!--        给切点上设置前置增强-->
        <aop:advisor advice-ref="myBeforeAdvice" pointcut-ref="methodsBefore"></aop:advisor>
<!--        给切点上设置后置增强-->
        <aop:advisor advice-ref="myAfterAdvice" pointcut="execution(* com.lanou.test.service.*.*(..))"></aop:advisor>
    </aop:config>


</beans>

4、测试用例：

package com.lanou.test.advice;

import org.springframework.aop.AfterAdvice;
import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class MyAfterAdvice implements AfterReturningAdvice, AfterAdvice {
    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("你好，我是返回后置通知");
    }
}




package com.lanou.test.advice;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class MyBeforeAdvice implements MethodBeforeAdvice {

    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("Boss 好帅");
    }
}

5、执行结果：

Boss 好帅
this is my logic
你好，我是返回后置通知
Boss 好帅
我是haha方法hajja
你好，我是返回后置通知

---

通过AspectJ实现增强

创建描述增强的类：

package com.lanou.test.advicor;

public class MyAdvicor  {
    
    //前置通知
    public void before(JoinPoint joinPoint) { 
        System.out.println("before"); 
        System.out.println(joinPoint.getArgs().length); //参数长度是1
        System.out.println(joinPoint.getSignature().getName()); //方法的名字
        System.out.println(joinPoint.getTarget());  //要被代理的对象		目标类对象
        System.out.println(joinPoint.getThis());    //执行代理目标的对象		代理类对象 
    }

    //后置通知
    public void after(JoinPoint joinPoint) {
        System.out.println("after");
    }
    
    //后置返回通知
    public void afterReturning(JoinPoint joinPoint) {
        System.out.println("afterReturning");
    }
	
    //异常通知
    public void afterThrowing(JoinPoint joinPoint) {
        System.out.println("afterThrowing");
    }
}

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       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
       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">

    <bean id="service" class="com.lanou.test.service.LoginService"></bean>

    <bean id="myAdvisor" class="com.lanou.test.advicor.MyAdvicor"></bean>


    <aop:config>
<!--        切点设置 - execution(返回值 全包名.类名.方法名 (参数集合))-->
        <aop:pointcut id="test" expression="execution(* com.lanou.test.service.*.*(..))"/>
        <aop:aspect ref="myAdvisor">
            <aop:before method="before" pointcut-ref="test"></aop:before>
            <aop:after method="after" pointcut-ref="test"></aop:after>
            <aop:after-returning method="afterReturning" pointcut-ref="test"></aop:after-returning>
            <aop:after-throwing method="afterReturning" pointcut-ref="test"></aop:after-throwing>
<!--            <aop:around method="around" pointcut-ref="test"></aop:around>-->
        </aop:aspect>

     </aop:config>

执行结果：

before
我是lodic方法
after
afterReturning

around通知可以修改参数也可以修改返回值。

---

通过注解实现增强

创建描述增强的类：

import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

@Aspect
@Configuration   /  @Component
public class MyAdvicor  {

    @Before("execution(* com.lanou.test.service.*.*(..))")
    public void before(JoinPoint joinPoint) {
        System.out.println("before");
        System.out.println(joinPoint.getArgs().length); //参数长度是1
        System.out.println(joinPoint.getSignature().getName()); //方法的名字
        System.out.println(joinPoint.getTarget());  //要被代理的对象
        System.out.println(joinPoint.getThis());    //执行代理目标的对象
    }

    @After("execution(* com.lanou.test.service.*.*(..))")
    public void after(JoinPoint joinPoint) {
        System.out.println("after");
    }

    @AfterReturning("execution(* com.lanou.test.service.*.*(..))")
    public void afterReturning(JoinPoint joinPoint) {
        System.out.println("afterReturning");
    }

    @AfterThrowing("execution(* com.lanou.test.service.*.*(..))")
    public void afterThrowing(JoinPoint joinPoint) {
        System.out.println("afterThrowing");
    }

    @Around("execution(* com.lanou.test.service.*.*(..))")
    public void around(JoinPoint joinPoint) {
        System.out.println("around");
    }
}

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       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
       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">

    <context:component-scan base-package="com.lanou.test"></context:component-scan>

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>


</beans>

---

AOP中两种动态代理的区别

jdk动态代理：生成代理对象快，只能根据接口生成

CGLIB动态代理：执行快，

• xml中开启CGLIB动态代理

<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>