SpringAOP JDK动态代理

最新推荐文章于 2024-04-27 09:13:51 发布

你是我的日月星河

最新推荐文章于 2024-04-27 09:13:51 发布

阅读量2.9k

点赞数 3

分类专栏：记录学习SpringMVC、SpringFramework 文章标签： java spring 代理模式

本文链接：https://blog.csdn.net/weixin_46281472/article/details/125629339

版权

记录学习SpringMVC、SpringFramework 专栏收录该内容

15 篇文章 6 订阅

订阅专栏

1、本篇博客的背景和目的

目前我本人正在学习SpringFramework的知识，这也是这个专栏的主题。我前面的几篇博文中，简单的认识了一下SpringFramework，记录了SpringFramework的环境搭建，记录了SpringIOC如何加载配置文件，记录了SpringIOC三种Bean对象的实例化方法。还记录了SpringIOC手动装配（注入）的方法之一：set方法注入。还有另外三个不太常用的SpringIOC手动注入的方法。其实目前大部分都使用的是自动注入的方法，手动注入使用的不多。就算是使用手动注入的方法，使用的主流也是：set方法注入。自动注入的方法主要是使用两个注解，@Autowired注解或者是@Resource注解。两个注解我都记录到了。还记录了如何使用SpringIOC扫描器，SpringIOC中Bean对象的作用域和生命周期，SpringTask的概念和简单使用，SpringAOP的静态代理的概念和简单使用。本篇博客我简单的记录一下SpringAOP的JDK动态代理的概念和简单使用。

2、我的上一篇文章

我的上一篇文章记录的是SpringAOP静态代理的内容，有兴趣的读者可以移步前往查看，链接如下：

SpringAOP静态代理_你是我的日月星河的博客-CSDN博客_spring 静态代理https://blog.csdn.net/weixin_46281472/article/details/125250824?spm=1001.2014.3001.5501

3、动态代理的概念和优点

相比于静态代理（在静态代理中，对于类的每一个接口，我们都要单独写一个代理类），动态代理在创建代理对象上更加的灵活。

有需求，有问题，才会有解决方法和改进创新。那么产生动态代理的问题根源或者需求是什么呢？在静态代理中，由于每个接口都需要我们单独的写一个代理类，比较麻烦，因此我们就想，我们能不能写一个类，我们只需要把委托对象（目标对象），还有全部接口（共同行为，其实委托对象中就已经包含接口了）作为参数传给这个类的方法，然后这个方法就可以给我们返回一个我们想要的代理对象呢，并且这个代理对象可以给我们代理全部的共同行为，像是租房，结婚等？

动态代理类的字节码在程序运行时由JAVA反射机制动态产生。会根据需要，通过反射机制，在程序运行期动态的为目标对象（委托对象）创建代理对象，无需程序员手动编写代理对象所属类的代码。

动态代理不仅简化了编程工作，而且提高了软件系统的可扩展性，因为反射机制的使用使得可以生成任意类型的代理对象。

动态代理的实现方式有两种，分别是：JDK动态代理和CGLIB动态代理。

动态代理的目标对象是不固定的（也就是说把任何一个目标对象或者说是委托对象作为参数传递给生成代理对象的对象的方法，都会给我们返回一个我们想要的代理对象）；使用动态代理以后，会在应用程序执行的时候，动态的创建目标对象（这一点我还不是很理解为什么，欢迎读者留言）；代理对象依然会增强目标对象的行为；

4、JDK动态代理的概念和特点

先说一个需要注意的点：JDK动态代理的目标对象必须要有接口实现，也就是说：委托类必须要继承接口。

在JDK中，有一个Proxy类（名词，代理人）。Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态的生成实现类（对这个类的其他方法我了解的也不是很多，我们可以看JDK的在线API文档，百度搜一下好像挺多的）。这个类提供的有一个静态方法：newProxyInstance()方法。这个方法的目的就是给我们的目标对象（委托对象）返回一个代理对象。

newProxyInstance()方法需要有三个参数：1、类加载器（ClassLoader对象）2、接口集合（一个Interface对象的数组，就是需要代理对象代理那些共同行为，也是委托对象继承的共同行为接口）3、一个InvocationHandler接口对象（当然可以是它的一个实现类对象）。这个接口中有一个invoke()方法。invoke()方法起到的作用很大，当代理对象调用共同行为方法的时候，invoke()方法就会被自动调用执行。下面粘贴一张图片：

5、我的示例代码

1、首先看一下我的文件结构（里面有一些是多余的），如下所示：

里面有一些类是用不到的，读者如果想要跟着敲的话可以不用管，只需要使用下面记录到的代码就可以。

2、然后是我的POM文件（其实没有依赖，因为只使用到了JDK，没有使用框架什么的）：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.dcy</groupId>
    <artifactId>spring_AOP</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

</project>

其实上面的POM文件就指定了项目所用的JDK的版本。

3、能够返回代理对象的类JdkProxy类：

package com.dcy.dynamic;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JdkProxy {

    //这个是我们的目标对象 ，也就是委托类（对象） 由于目标对象是不确定的，因此设置为 Object类型
    private Object target;
    //下面我们通过带参构造传递我们的目标对象
    public JdkProxy(Object target) {
        this.target = target;
    }


    public Object getProxy(){//这个方法的目的就是  得到代理对象
        //我们需要调用Proxy类的newProxyInstance静态方法得到代理对象，当然是需要参数的。
        //首先需要一个类加载器参数
        ClassLoader loader=this.getClass().getClassLoader();
        //下面我们需要明确， 让代理对象实现那些接口？
        Class<?>[] interfaces = target.getClass().getInterfaces();
        //还需要一个 InvocationHandler接口，表示代理实例的调用处理程序实现的接口
        InvocationHandler invocationHandler=new InvocationHandler() {//这是一个接口，我们就不写实现类了，
            //直接实现它的方法
            //当代理对象调用方法时，invoke方法就会被执行一次
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("invoke方法被调用。。。。。。");
                //method是目标方法， proxy是代理对象， args是目标方法需要的参数
                System.out.println(method.getName());//这个方法的名字就是 toRentHouse
                //下面我们还需要调用  目标对象中的 toRentHouse方法 ；通过反射中提供的invoke方法，调用指定对象的
                //指定方法
                //
                Object result=method.invoke(target,args);//这个方法有两个参数 方法所在对象，方法所需参数
                //method这个方法的方法名是根据我们再main方法中的调用情况的，得到的代理对象类调用的是什么方法，
                //method方法的方法名就是什么
                System.out.println("程序走到这一步，证明委托类的方法已经被调用了， 后面代理类可以多一些操作");
                //我们这个return的是方法的返回值
                return result;
            }

        };
        //下面我们调用方法，得到代理对象，
        //参数依次是  类加载器，代理类要实现那些接口，InvocationHandler接口
        Object object= Proxy.newProxyInstance(loader,interfaces,invocationHandler);
        /*
        通过调用Proxy类中的静态方法 newProxyInstance()方法来得到代理对象
         */
        return object;
    }
}

上面的代码中，首先是一个私有成员变量，这个存储的是我们的目标对象。由于目标对象的所属类不确定，因此使用Object类。

然后是一个构造方法，将目标对象传进来，代理对象的生成需要用到这个目标对象。

然后是一个getProxy（）方法，这个方法用于返回一个目标对象的代理对象。在这个方法里面，我们肯定是要使用到Proxy类的newInstanceProxy()方法用于生成代理对象的。

既然要使用newInstanceProxy()方法，那么就需要给它所需的参数。第一个参数是一个类加载器对象（具体的可以看注释），第二个参数是一个接口数组，也就是目标对象实现继承的接口有哪些（也就是共同行为有哪些），第三个参数是一个InvocationHandler接口对象（这个接口还是有点复杂的），当然这个参数需要是一个它的实现类。这里我就简单的在getProxy()方法里面实现了这个接口，并作为参数。这个接口有一个非常重要的invoke()方法需要实现。当使用返回的代理对象调用共同行为方法的时候，invoke()方法就会被自动触发执行！！！invoke()方法有三个参数，分别是代理类对象，某个方法，还有某个方法的所需参数。

具体的可以认真看我代码里面的注释，这个方法就是我们使用返回的代理对象调用共同行为方法的时候的方法。我们可以使用反射执行这个被调用的方法！！！需要有这个方法所属的对象，当然就是我们的目标对象（也就是委托对象），还有这个方法所需的参数。使用的是反射机制中的invoke()方法来执行这个公共行为方法。

最后invoke()方法的返回值是共同行为方法的返回值。

4、共同行为接口RentHouse租房：

package com.dcy.statics;

/*
这个是父类或者是父接口   也就是委托类和代理类共同的行为
 */
public interface RentHouse {

    public void toRentHouse();

    public String toRentHouse2(String name);
}

上面是共同行为接口的代码，只有两个方法，一个没有返回值没有参数的方法，一个有返回值有参数的方法。

5、委托类You代码：

package com.dcy.statics;

/*
静态代理
下面这个是我们的 目标对象  也就是 委托类
 */
public class You implements RentHouse{
    @Override
    public void toRentHouse() {
        System.out.println("我要租一个两室一厅");
    }

    @Override
    public String toRentHouse2(String name) {
        System.out.println(name+"要第二次租房");
        return "好的吧";
    }
}

委托类继承了共同行为接口，并且实现了其中的方法，代码如上所示。代码比较简单，我就不解释了。

6、在Main方法里面测试一下：

package com.dcy.dynamic;

import com.dcy.statics.RentHouse;
import com.dcy.statics.You;

public class Starter {
    public static void main(String[] args) {
        //目标对象
        RentHouse you =new You();
        //下面得到代理类
        JdkProxy proxy=new JdkProxy(you);
        //下面我们要得到一个目标对象的代理对象
        //这里使用RentHouse接收，可以理解为它们还是实现了这个租房的共同接口
        RentHouse object = (RentHouse) proxy.getProxy();
        //通过代理对象调用方法
        object.toRentHouse();
        //通过代理对象调用toRentHouse2()方法，这个方法有返回值，也有形参
        String message = object.toRentHouse2("小明");
        System.out.println(message);

        //这里我要多说一下，如果没有接口实现，那么就不能通过JDK动态代理生成代理对象
        //后面不是有一个  getInterfaces方法嘛   没有接口实现，不能得到接口类型，也就是没有共同行为啊
        //并且，我们使用的是Proxy类的newProxyInstance静态方法得到代理对象的，这个方法就需要有接口类型作为参数
        //也就是JDK动态代理必须有接口实现
    }
}

首先new了一个目标对象（委托对象），使用的是RentHouse的类型。然后将目标对象作为参数传入new出来的能够返回代理对象的JdkProxy对象中。然后就可以得到一个代理对象。得到的这个代理对象还是RentHouse类型。

然后就可以调用共同行为方法，实际上还是调用了委托对象的方法，我们在invoke()方法中也确实是这样编写的代码。这个时候invoke()方法就会被自动触发执行！！

7、程序运行的结果如下图所示：

6、一个注意的点

多说一下：如果没有接口实现，那么就不能通过JDK动态代理生成代理对象

代码里面用到了一个 getInterfaces()方法如果没有接口实现，不能得到接口类型，也就是没有共同行为啊

并且，我们使用的是Proxy类的newProxyInstance静态方法得到代理对象的，这个方法就需要有接口类型作为参数也就是JDK动态代理必须有接口实现，必须有接口的形式表示的共同行为。

7、我的下一篇博文

你是我的日月星河

关注

3
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringAOP JDK动态代理

目前我本人正在学习SpringFramework的知识，这也是这个专栏的主题。我前面的几篇博文中，简单的认识了一下SpringFramework，记录了SpringFramework的环境搭建，记录了SpringIOC如何加载配置文件，记录了SpringIOC三种Bean对象的实例化方法。还记录了SpringIOC手动装配（注入）的方法之一：set方法注入。还有另外三个不太常用的SpringIOC手动注入的方法。其实目前大部分都使用的是自动注入的方法，手动注入使用的不多。就算是使用手动注入的方法，使用的主流
复制链接

扫一扫