【Spring5】AOP

3 AOP

面向切面编程，利用AOP可以对业务的各个逻辑进行隔离，从而使得业务逻辑各部分的耦合度之间降低，提高程序的可重用性，同时提高开发的效率。

目的：不通过修改源代码，在主干功能上增加新功能

AOP底层原理

1.动态代理实现类方法增强

(1)有接口的情况：通过JDK方式创建接口实现类的代理对象

public class JDKProxy {
    public static void main(String[] args) {
        Class[] interfaces = {UserDao.class};

        UserDaoImpl userDao = new UserDaoImpl();
//        创建接口实现类的代理对象
//        代理的含义：不需要下面的接口实现类直接实现接口，而是通过代理的方式实现接口
//        UserDao userDao1 = new UserDaoImpl();

//        newProxyInstance返回接口实现类，第一个参数为当前类的类加载器，第二个参数是要实现接口的class数组，第三个参数为增强逻辑后的接口实现类的代理类
        UserDao userDao1 = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));

        System.out.println(userDao1.add(1, 1));
    }
}

代理的含义：不需要下面的接口实现类直接实现接口，而是通过代理的方式实现接口
UserDao userDao1 = new UserDaoImpl();
UserDao userDao1 = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));

newProxyInstance返回接口实现类，第一个参数为当前类的类加载器，第二个参数是要实现接口的class数组，第三个参数为增强逻辑后的接口实现类的代理类

编写增强逻辑的接口实现类的代理类
obj表示代理对象的被代理方

class UserDaoProxy implements InvocationHandler {
    private Object obj;
    UserDaoProxy(Object obj) {
        this.obj = obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法执行前");
        Object res = method.invoke(obj, args);
        System.out.println(res);
        System.out.println("方法执行后");
        return res;
    }
}

(2)没有接口的情况：通过CGLIB创建当前类的子类的代理对象


AOP操作术语

1 连接点：类中可以被增强的方法

2 切入点：实际被真正增强的方法

3 通知（增强）：实际增强的逻辑部分称为通知（增强）

前置通知：

后置通知：

环绕通知：

异常通知：try-catch

最终通知：finally

4 切面

切面是一个动作：把通知应用到切入点的过程

AOP操作：基于AsepectJ实现AOP

AsepectJ不是Spring的组成部分，独立于AOP框架，通常一起使用进行AOP操作。

两种形式：基于xml配置文件方式、基于注解方式

导入jar包

spring-aspects-5.2.6.RELEASE.jar

com.springsource.net.sf.cglib-2.2.0.jar

com.springsource.org.aopalliance-1.0.0.jar

com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

切入点表达式

作用：知道哪个类的哪个方法应该增强

语法结构：execution([权限修饰符][返回类型][类全路径][方法名称] ( [参数列表] ) )

*表示所有

步骤

①创建类和增强类

②进行通知的配置，开启注解组件扫描

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/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.hikaru"></context:component-scan>

③添加创建类和增强类对象的注解，并在增强类上添加注解Aspect

@Component
public class User {
    public void add() {
        System.out.println("add...");
    }
}

@Component
@Aspect
public class UserProxy {

}

④在Spring配置文件中开启生成代理对象

<!--开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

⑤配置不同类型的通知

@Component
@Aspect
public class UserProxy {
    @Before(value = "execution(* com.hikaru.User.add())")
    public void before() {
        System.out.println("before...");
    }

    @After(value = "execution(* com.hikaru.User.add(..))")
    public void after() {
        System.out.println("after...");
    }

    @AfterReturning(value = "execution(* com.hikaru.User.add(..))")
    public void afterReturn() {
        System.out.println("after return...");
    }

    @AfterThrowing(value = "execution(* com.hikaru.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing...");
    }
    @Around(value = "execution(* com.hikaru.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前");
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后");
    }
}

环绕之前
before...
add...
环绕之后
after...
after return...

After与AfterReturning的区别：

After无论有没有异常都会输出，AfterReturning只有没有异常正常返回时才会输出。

异常时的结果：

环绕之前
before...
after...
afterThrowing...

公共切入点抽取：重用切入点定义

在增强类中：

    @Pointcut(value = "execution(* com.hikaru.User.add())")
    public void PointDemo() {

    }

通知中使用公共切入点

    @Before(value = "PointDemo()")
    public void before() {
        System.out.println("before...");
    }

有多个增强类对同一个类的同一个方法进行增强，应设置类优先级

在增强类上添加注解@Order(数字特征值)，值越小表示优先级越高

使用xml实现AOP操作

略

使用配置类代替配置文件开启Aspect生成代理对象，实现完全注解开发

@Configuration
@ComponentScan(value = {"com.hikaru"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class SpringConfig {

}

    @Test
    public void test() {
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        User user = context.getBean("user", User.class);
        user.add();
    }