Spring源码-5.aop代理

  • 👏作者简介:大家好,我是爱吃芝士的土豆倪,24届校招生Java选手,很高兴认识大家
  • 📕系列专栏:Spring源码、JUC源码
  • 🔥如果感觉博主的文章还不错的话,请👍三连支持👍一下博主哦
  • 🍂博主正在努力完成2023计划中:源码溯源,一探究竟
  • 📝联系方式:nhs19990716,加我进群,大家一起学习,一起进步,一起对抗互联网寒冬👀

编译器增强

java 复制代码
ConfigurableApplicationContext context = SpringApplication.run(A.class, args);
MyService service = context.getBean(MyService.class);

log.debug("service class: {}", service.getClass());
service.foo();

context.close();

@Service
public class MyService {

    private static final Logger log = LoggerFactory.getLogger(MyService.class);

    public static void foo() {
        log.debug("foo()");
    }
}

@Aspect // ⬅️注意此切面并未被 Spring 管理
public class MyAspect {

    private static final Logger log = LoggerFactory.getLogger(MyAspect.class);

    @Before("execution(* com.itheima.service.MyService.foo())")
    public void before() {
        log.debug("before()");
    }
}

当我们运行的时候,实际上,相当于foo方法就被代理增强了

输出:

scss 复制代码
before()
foo()

而看到 MyAspect类,其实并没有被Spring管理,但是还是能实现代理的能力,这是怎么回事呢?

这说明aop的实现不仅仅只有动态一种。

其实这里是使用aspectj编译器来进行的增强,编译器的原理其实就是把我们的myService类改写了

在编译好的target中可以看到,实际上foo方法是被编译器改写了的。

其父方法的class当中加入了前置增强,当目标文件都被改写了的时候,就不需要被代理了。

而前面所将的@aspect 其实和spring没什么关系,实现这个只需要在编译器中加入 aspectj-maven-plugin 插件

xml 复制代码
			<plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>aspectj-maven-plugin</artifactId>
                <version>1.14.0</version>
                <configuration>
                    <complianceLevel>1.8</complianceLevel>
                    <source>8</source>
                    <target>8</target>
                    <showWeaveInfo>true</showWeaveInfo>
                    <verbose>true</verbose>
                    <Xlint>ignore</Xlint>
                    <encoding>UTF-8</encoding>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <!-- use this goal to weave all your main classes -->
                            <goal>compile</goal>
                            <!-- use this goal to weave all your test classes -->
                            <goal>test-compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

这种增强其实是有好处的,能够突破代理的限制,因为代理的增强其实是通过方法重写来实现的。

jdk是 实现了 接口,而cglib是重写了父方法,本质上都是重写

但是如果该方法是静态方法呢?那么其实是不能增强的,而我们的编译增强其实是可以做到的。

静态方法

动态代理无法直接代理静态方法,是因为静态方法是属于类级别的,而不是属于实例级别的。

在java中,动态代理是通过创建一个实现了特定接口的代理对象来实现的。由于静态方法不属于任何实例,所以无法通过动态代理来代理静态方法。

而我们的编译增强就可以对静态方法进行代理!

java 复制代码
	public static void foo() {
        log.debug("foo()");
    }

如果 运行不能实现,需要先clean,然后重新运行。

构造方法

**动态代理同样无法修改构造方法,因为构造方法是在对象创建时被调用的,而代理对象只能在对象创建后才能被创建。**在Java中,代理对象是通过调用java.lang.reflect.Proxy.newProxyInstance()方法来创建的,该方法需要一个接口列表作为参数,并使用这些接口来创建代理对象。由于构造方法是在对象创建时被调用的,因此代理对象无法修改构造方法。

以一段例子来解释:

java 复制代码
public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }
}

@Aspect
public class PersonAspect {
    @Before("execution(Person.new(String)) && args(name)")
    public void beforeConstruct(String name) {
        System.out.println("Creating a new person with name " + name);
    }
}

public class Test {
    public static void main(String[] args) {
        Person person = new Person("Alice");
    }
}

输出:

csharp 复制代码
Creating a new person with name Alice

可以看到,编译增强也可以对构造方法增强。

类加载增强

在类加载阶段,是把你原始的字节码进行了一个增强

同理:

java 复制代码
ConfigurableApplicationContext context = SpringApplication.run(A10.class, args);
        MyService service = context.getBean(MyService.class);

        // ⬇️MyService 并非代理, 但 foo 方法也被增强了, 做增强的 java agent, 在加载类时, 修改了 class 字节码
        log.debug("service class: {}", service.getClass());
        service.foo();
        
@Service
public class MyService {

    private static final Logger log = LoggerFactory.getLogger(MyService.class);

    final public void foo() {
        log.debug("foo()");
        this.bar();
    }

    public void bar() {
        log.debug("bar()");
    }
}

@Aspect // ⬅️注意此切面并未被 Spring 管理
public class MyAspect {

    private static final Logger log = LoggerFactory.getLogger(MyAspect.class);

    @Before("execution(* com.itheima.service.MyService.*())")
    public void before() {
        log.debug("before()");
    }


}

运行时需要在 VM options 里加入 -javaagent:C:/Users/manyh/.m2/repository/org/aspectj/aspectjweaver/1.9.7/aspectjweaver-1.9.7.jar 把其中 C:/Users/manyh/.m2/repository 改为你自己 maven 仓库起始地址

输出:

before
foo
before
bar

一个方法调用另一个方法

类加载阶段代理也突破了一个限制,就是 如果目标类中 在一个方法内调用了自己的另外的方法,内部的方法调用是不会走动态代理的增强的。

**这是因为动态代理是基于接口或父类进行代理的,它是通过生成一个代理类来实现对目标类方法的代理。****当目标类内部调用自己的方法时,实际上是在目标类的内部方法中直接调用,而不经过代理类。**因此,动态代理无法拦截这种内部方法调用。(换一句话话说,动态代理是一种重写,无论jdk实现接口还是cglib重写父类,所以其内部方法的调用不经过代理类

**如果你需要在目标类的内部方法调用时也应用代理的增强逻辑,可以考虑将内部方法提取到一个独立的类中,并通过代理来调用该独立类的方法。**这样就能确保内部方法的调用也经过代理的增强。

类加载阶段代理是指在类加载的过程中,通过一些技术手段来替换原始类的定义,从而实现对原始类行为的控制和修改。在这个过程中,可以利用代理技术来使一个方法调用另一个方法被代理。

AOP实现之proxy

JdkProxy

java 复制代码
public class JdkProxyDemo {

    interface Foo {
        void foo();
    }

    /**
     * 准备了一个代增强的目标类
     *
     * 这是一个静态代理
     */
    static class Target implements Foo {
        public void foo() {
            System.out.println("target foo");
        }
    }
}

以上实际上就是一个接口的实现类,实现了这个接口,如果将其进行增强呢?

接下来介绍jdk自带的一种代理方法 , 但是其也有一个弊端,就是只能针对接口进行代理

首先介绍对应Proxy.newProxyInstance 方法的参数:

创建一个新的代理实例 一共有三个参数、第一个参数 是类加载器

类加载器可以用当前的类加载器,为什么需要一个类加载器呢?

其实我们的代理类 和 普通类是有差别的,普通类先写java源代码、然后编译成Java的字节码,最后经过类加载,然后可以使用。

而代理类没有源代码,是在运行期间直接生成了代理类的字节码,生成的字节码也需要加载后才可以运行。

所以类加载器的作用主要是用来加载运行期间动态生成的字节码。

参数二 就是你将来要生成的代码,要实现什么接口,这是个数组,也就代表着将来可以一次性实现多个接口

参数三 是一个 InvocationHandler 的接口,因为代理也创建出来了,也实现了我们的接口,接下来就是实现接口中的抽象方法
其中还有三个参数,分别代表 代理对象自己、正在执行的方法对象、方法传过来的实际参数
java 复制代码
ClassLoader loader = JdkProxyDemo.class.getClassLoader();// 用来加载在运行期间动态生成的字节码

Foo proxy = (Foo) Proxy.newProxyInstance(loader, new Class[]{Foo.class}, (p, method, args) -> {
            System.out.println("before...");
            Object result = method.invoke(target, args);
            System.out.println("after....");
            return result; 
        });

至此一个jdk版本的动态代理其实也就讲解完成了

但是需要注意的一点就是 jdk 动态代理要求目标必须实现接口,生成的代理类实现相同接口,因此代理与目标之间是平级兄弟关系,所以哪怕将Target 改成final也没关系,因为不是子类(这个和cglib有很大的区别!!!

java 复制代码
System.out.println(proxy.getClass());

proxy.foo();

static final class Target implements Foo {
        public void foo() {
            System.out.println("target foo");
        }
    }

在接口代理中,代理对象实现了被代理接口,并且通过重写接口中的方法来实现增强逻辑。当调用代理对象的方法时,实际上是调用了代理对象中重写的方法,从而实现了增强功能。

CglibProxy

java 复制代码
public class CglibProxyDemo {

    static class Target {
        public void foo() {
            System.out.println("target foo");
        }
    }
}

接下来介绍的这个CglibProxy 和 jdk的有很大的不同,前面提到的jdk代理其实是 平行关系,而 cglib是父子继承关系。

其中 Enhancer.create 方法共有两个参数

参数一 代理的父类
参数二 共有四个参数 代理类自己、代理类中的方法、参数、方法对象
java 复制代码
Target proxy = (Target) Enhancer.create(Target.class, (MethodInterceptor) (p, method, args, methodProxy) -> {
            System.out.println("before...");
            Object result = method.invoke(target, args); // 用方法反射调用目标
            System.out.println("after...");
            return result;
        });
java 复制代码
// 最后使用的时候,再转换成父类型

proxy.foo();

cglib 不要求目标实现接口,它生成的代理类是目标的子类,因此代理与目标之间是子父关系 限制⛔:根据上述分析 final 类无法被 cglib 增强。如果方法是final的话,也不能增强,因为是子父的关系,必然是通过方法重写来实现的,因为final是不能被继承 和 重写的。而jdk中是平级的兄弟关系

但是其实可以观察到,参数二还有四个参数,其中method 和 methodProxy很像,它们两个具体有什么不同呢?

java 复制代码
//        Target target = new Target();

Target proxy = (Target) Enhancer.create(Target.class, (MethodInterceptor) (p, method, args, methodProxy) -> {
            System.out.println("before...");
//            Object result = method.invoke(target, args); // 用方法反射调用目标
            // methodProxy 它可以避免反射调用
//            Object result = methodProxy.invoke(target, args); // 内部没有用反射, 需要目标 (spring)
            Object result = methodProxy.invokeSuper(p, args); // 内部没有用反射, 需要代理
            System.out.println("after...");
            return result;
        });

具体如下,主要是内部需不需要反射的问题,更加详细的解释将会在后续文章中进行介绍。

相关推荐
monkey_meng27 分钟前
【遵守孤儿规则的External trait pattern】
开发语言·后端·rust
Estar.Lee42 分钟前
时间操作[计算时间差]免费API接口教程
android·网络·后端·网络协议·tcp/ip
新知图书1 小时前
Rust编程与项目实战-模块std::thread(之一)
开发语言·后端·rust
盛夏绽放2 小时前
Node.js 和 Socket.IO 实现实时通信
前端·后端·websocket·node.js
Ares-Wang2 小时前
Asp.net Core Hosted Service(托管服务) Timer (定时任务)
后端·asp.net
Rverdoser3 小时前
RabbitMQ的基本概念和入门
开发语言·后端·ruby
Tech Synapse4 小时前
Java根据前端返回的字段名进行查询数据的方法
java·开发语言·后端
.生产的驴4 小时前
SpringCloud OpenFeign用户转发在请求头中添加用户信息 微服务内部调用
spring boot·后端·spring·spring cloud·微服务·架构
微信-since811924 小时前
[ruby on rails] 安装docker
后端·docker·ruby on rails
代码吐槽菌6 小时前
基于SSM的毕业论文管理系统【附源码】
java·开发语言·数据库·后端·ssm