Sping之AOP实现原理剖析

最新推荐文章于 2023-05-10 14:55:26 发布

西瓜皮防摔

最新推荐文章于 2023-05-10 14:55:26 发布

阅读量284

点赞数

分类专栏： Spring 文章标签：代理模式 java 开发语言

本文链接：https://blog.csdn.net/qq_38020591/article/details/121950457

版权

Spring 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章目录

前言
一、SpringAOP术语简介
二、SpringAOP的简单实现
三、SpringAOP的实现原理
总结

前言

AOP，全称Aspect Oriented Programming，即面向切面编程，是一种区别于OOP（面向对象编程）的另一种编程思想，同时也是对OOP的补充。OOP思想将系统以纵向的角度抽象为各个对象的交互，AOP思想则从横向的角度将程序抽象为切面关注点。图示：
在这里插入图片描述

AOP的理念是在不修改现有对象源代码的前提下，去对业务做增强处理。这个思想其实就是设计模式中的Proxy代理模式，而AOP正是代理模式的一种实现，这里根据AOP对源代码的修改时机将其分大致分为两类：

静态 AOP 实现， AOP 框架在编译阶段对程序源代码进行修改，生成了静态的 AOP 代理类（生成的 *.class
文件已经被改掉了，需要使用特定的编译器），典型的AspectJ。
动态 AOP 实现， AOP 框架在运行阶段对动态生成代理对象（在内存中以 JDK 动态代理，或 CGlib 动态地生成 AOP
代理类），如 SpringAOP。

一、SpringAOP术语简介

Aspect：切面，即一个横跨多个核心逻辑的功能，或者称之为系统关注点；
Joinpoint：连接点，即定义在应用程序流程的何处插入切面的执行；
Pointcut：切入点，即一组连接点的集合；
Advice：增强，指特定连接点上执行的动作；
Introduction：引介，指为一个已有的Java对象动态地增加新的接口；
Weaving：织入，指将切面整合到程序的执行流程中；
Interceptor：拦截器，是一种实现增强的方式；
Target Object：目标对象，即真正执行业务的核心逻辑对象；
AOP Proxy：AOP代理，是客户端持有的增强后的对象引用。

拦截器类型：

@Before：这种拦截器先执行拦截代码，再执行目标代码。如果拦截器抛异常，那么目标代码就不执行了；
@After：这种拦截器先执行目标代码，再执行拦截器代码。无论目标代码是否抛异常，拦截器代码都会执行；
@AfterReturning：和@After不同的是，只有当目标代码正常返回时，才执行拦截器代码；
@AfterThrowing：和@After不同的是，只有当目标代码抛出了异常时，才执行拦截器代码；
@Around：能完全控制目标代码是否执行，并可以在执行前后、抛异常后执行任意拦截代码，可以说是包含了上面所有功能。

二、SpringAOP的简单实现

1、使用AspectJ定义方式实现

1.1、引入依赖包

在这里插入图片描述

<!--    引入AOP依赖包    -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>${spring.version}</version>
    </dependency>

1.2.编写切面类（以日志切面为例）

**
 * TODO：
 *
 * @Version 1.0
 * @Author HJL
 * @Date 2021/12/15 14:46
 */
@Aspect
@Component
public class LoggingAspect {
    // 在执行UserService的每个方法前执行:
    @Before("execution(public * service.UserService.*(..))")
    public void doAccessCheck() {
        System.err.println("执行前检查！");
    }

    // 在执行MailService的每个方法前后执行:
    @Around("execution(public * service.MailService.*(..))")
    public Object doLogging(ProceedingJoinPoint pjp) throws Throwable {
        System.err.println("环绕开始： " + pjp.getSignature());
        Object retVal = pjp.proceed();
        System.err.println("环绕结束： " + pjp.getSignature());
        return retVal;
    }
}

在类上使用@Aspect注解，标识该类是一个切面类，同时在具体的切入方法上使用拦截器标识，这里使用的是AspectJ的切入正则表达式来定义：
在这里插入图片描述

1.3.在启动类中添加@EnableAspectJAutoProxy注解

@EnableAspectJAutoProxy注解的作用：自动查找带有@Aspect的Bean，然后根据每个方法的@Before、@Around等注解把AOP注入到特定的Bean中。

@Configuration
@ComponentScan({"service","validator","aop"})
@EnableAspectJAutoProxy
public class Application {

    public static void main(String[] args) {
//        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        ApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
        UserService userService = context.getBean(UserService.class);
//        User user = userService.login("zhangsan@example.com", "123456","zhangsan");
        userService.register("huangmou@qq.com","123456","黄某");
//        System.out.println(user.getName());
    }
}

1.4、测试结果

在这里插入图片描述

2、使用注解方式实现

2.1、定义注解类

@Target(METHOD)
@Retention(RUNTIME)
public @interface MetricTime {
    String value();
}

2.2 编写切面类（以性能监控为例）

@Aspect
@Component
public class MetricAspect {

    @Around("@annotation(metricTime)")
    public Object metric(ProceedingJoinPoint joinPoint, MetricTime metricTime) throws Throwable {
        String name = metricTime.value();
        long start = System.currentTimeMillis();
        try {
            return joinPoint.proceed();
        } finally {
            long t = System.currentTimeMillis() - start;
            // 写入日志或发送至JMX:
            System.err.println("[性能监控] " + name + ": " + t + "ms");
        }
    }
}

2.3 在用户注册方法上标记注解

 // 监控register()方法性能:
    @MetricTime("用户注册")
    public User register(String email, String password, String name) {
        validators.validate(email,password,name);//注册信息验证
	...
	}

2.4 运行结果

在这里插入图片描述

三、SpringAOP的实现原理

SpringAOP的实现机制分为JDK的动态代理实现方式和CGlib的动态代理实现方式：

1、JDK动态代理

1.JDK动态代理实现原理

JDK实现动态代理需要两个组件：

其一是InvocationHandler接口，该接口位于java.lang.reflect包下，内部有一个invoke方法，我们在使用JDK的动态代理时，需要编写一个类，去实现这个接口，然后重写invoke方法；

package java.lang.reflect;
public interface InvocationHandler {
   public Object invoke(Object proxy, Method method, Object[] args)
       throws Throwable;
}

其二是Proxy类，通过这个类的newProxyInstance方法，返回一个代理对象，生成的代理类实现了原来那个类的所有接口，并对接口的方法进行了代理；然后代理对象调用这些方法时，底层将通过反射，调用我们实现的invoke方法

package java.lang.reflect;
public class Proxy implements java.io.Serializable {
	protected Proxy(InvocationHandler h){...}
	public static Class<?> getProxyClass(ClassLoader loader,
                                         Class<?>... interfaces){...}
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)  {...}                                   
}

优点：

JDK动态代理是JDK原生的，不需要任何依赖即可使用；
通过反射机制生成代理类的速度要比CGLib操作字节码生成代理类的速度更快；

缺点：

JDK动态代理，被代理的类必须实现了接口，否则无法代理；
JDK动态代理无法为没有在接口中定义的方法实现代理。假设我们有一个实现了接口的类，我们为它的一个不属于接口中的方法配置了切面，Spring仍然会使用JDK的动态代理，但是由于配置了切面的方法不属于接口，为这个方法配置的切面将不会被织入。
JDK动态代理执行代理方法时，需要通过反射机制进行回调，此时方法执行的效率比较低；

2.JDK动态代理简单实现

2.1 创建代理对象接口

public interface Subject {

    public void printEmail();

    public String printCSDN(String info);

}

2.2 实现被代理的类

public class RealSubject implements Subject {

    @Override
    public void printEmail(){
        System.out.println("打印邮件");
    }

    @Override
    public String printCSDN(String info){
        return "成功打印CSDN:" + info;
    }
}

2.3 实现处理器类（继承InvocationHandler接口）

public class InvocationHandlerImpl implements InvocationHandler {

    private Object subject;//需要代理的对象

    /**
     * 构造方法，给我们要代理的真实对象赋初值
     * @param subject
     */
    public InvocationHandlerImpl(Object subject)
    {
        this.subject = subject;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.err.println("打印前检查！");
        //当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
        Object returnValue = method.invoke(subject, args);
        System.err.println("打印完毕通知");
        return returnValue;
    }

}

2.4 通过Proxy类生成代理类

public class DynamicProxyTest {

    public static void main(String[] args) {
        //代理的真实对象
        Subject realSubject = new RealSubject();

        /**
         * InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
         * 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用.
         * 即：要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法
         */
        InvocationHandler handler = new InvocationHandlerImpl(realSubject);

        ClassLoader loader = realSubject.getClass().getClassLoader();
        Class[] interfaces = realSubject.getClass().getInterfaces();
        /**
         * 该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
         */
        Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler);
        System.out.println("动态代理对象的类型：" + subject.getClass().getName());
        subject.printEmail();
        subject.printCSDN("JDK动态代理实现原理");
    }


}

2.5 运行结果

在这里插入图片描述

2、CGlib动态代理

1、CGlib动态代理原理

CGLib采用底层的字节码技术（ASM字节码生成框架）, 可以为一个类创建子类, 在子类中采用方法拦截的技术拦截所有父类方法的调用, 并织入横切逻辑.

优点;

使用CGLib代理的类，不需要实现接口，因为CGLib生成的代理类是直接继承自需要被代理的类；
CGLib生成的代理类是原来那个类的子类，这就意味着这个代理类可以为原来那个类中，所有能够被子类重写的方法进行代理；
CGLib生成的代理类，和我们自己编写并编译的类没有太大区别，对方法的调用和直接调用普通类的方式一致，所以CGLib执行代理方法的效率要高于JDK的动态代理；

缺点:

由于CGLib的代理类使用的是继承，这也就意味着如果需要被代理的类是一个final类，则无法使用CGLib代理；
由于CGLib实现代理方法的方式是重写父类的方法，所以无法对final方法，或者private方法进行代理，因为子类无法重写这些方法；
CGLib生成代理类的方式是通过操作字节码，这种方式生成代理类的速度要比JDK通过反射生成代理类的速度更慢；

2、CGlib动态代理简单实现

2.1 引入cglib的依赖包

  <!--cglib代理依赖包-->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

2.2 创建被代理类

public class CGLib_Subject {
    public void print() {
        System.out.println("I am CGLib_Subject");
    }
}

2.3 创建被代理类

public class CglibProxy implements MethodInterceptor {
    private Enhancer enhancer = new Enhancer();
    public Object getProxy(Class clazz){
        //设置需要创建子类的类
        enhancer.setSuperclass(clazz);
        enhancer.setCallback( this);
        //通过字节码技术动态创建子类实例
        return enhancer.create();
    }
    //实现MethodInterceptor接口方法
    public Object intercept(Object obj, Method method, Object[] args,
                            MethodProxy proxy) throws Throwable {
        System.out.println("代理前处理业务");
        //通过代理类调用父类中的方法
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("代理后处理业务");
        return result;
    }
}

2.4 编写测试

public class CGLibTest {
    public static void main(String[] args) {
        CglibProxy proxy = new CglibProxy();
        //通过生成子类的方式创建代理类
        CGLib_Subject proxyImp = (CGLib_Subject)proxy.getProxy(CGLib_Subject.class);
        proxyImp.print();
    }
}