Aop切面编程（2）--代理模式

🕗 发布于 2024-07-13 14:50 代理模式 java 开发语言

1、代理模式的理解：不修改A对象的代码的基础上，对A代码块进行拓展。通过创建ProxyA代理对象，拓展A对象并调用A对象的核心功能；

即：不修改对象的源码基础上，创建代理对象，进行功能的附加和增强；

2、代理的分类：1）静态代理；2）动态代理（jdk,cglib）；

3、静态代理：在编译的过程中就已经将代理对象、被代理对象、接口确定下来了，class文件已经生成了；

实现步骤：
1、定义一个接口及其实现类；
2、创建一个代理类同样实现这个接口
3、将目标对象注注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。

3.1）定义一个接口及方法ParentPrint：

package com.example.demo.proxy;

public interface ParentPrint {
    void print(String content);
}

3.2）定义一个被代理的类，并实现接口ParentPrint,其中print方法就是我们需要代理的核心方法；

package com.example.demo.proxy;


public class Printer implements  ParentPrint {

    @Override
    public void print(String content) {
        System.out.println(content);
    }
}

3.3）定义代理类，构造一个有参数的构造器，并重写print方法（其中通过传入的参数调用被代理对象的print方法）。

package com.example.demo.proxy;

/*
1、首先需要代理类ProxyStaticPrinter和被代理类Printer同时实现一个共同的接口 ；
2、代理类ProxyStaticPrinter需要在构造方法中注入接口定义对象，并重写代理的方法print（前置后置处理）,在其中加入注入对象的print方法；
3、实例化代理对象ProxyStaticPrinter，实例化被代理对象Printer；
4、将被代理对象通过参数注入到代理对象（ProxyStaticPrinter）有参构造器中；
5、代理对象调用处理过的方法；
*/
public class ProxyStaticPrinter implements ParentPrint {

    private ParentPrint parentPrint;


    public ProxyStaticPrinter(ParentPrint parentPrint) {
        this.parentPrint = parentPrint;
    }

    @Override
    public void print(String content) {
        System.out.println("前置操作");
        parentPrint.print(content);
        System.out.println("后置操作");
    }

}

3.4）测试，定义一个代理对象，将代理对象通过参数传入被代理的对象中；

    //测试
    public static void main(String[] args) {
        ParentPrint parentPrint = new Printer();
        ParentPrint ProxyParentPrint = new ProxyStaticPrinter(parentPrint);
        ProxyParentPrint.print("测试");
    }

运行

3.5）总结：

将目标对象注注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问；

优点：被代理类无需实现接口
缺点：只能代理这个类，要想代理其他类，要想代理其他类需要写新的代理方法。

4、动态代理：动态代理包含了jdk动态代理和cglib动态代理；

4.1）jkd动态代理：

实现步骤：
1、定义一个接口及其实现类；
2、自定义 InvocationHandler 并重写invoke方法，在 invoke 方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑；
3、通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象；

4.1.1）定义一个接口

package com.example.demo.proxy;

public interface ParentPrint {
    void print(String content);
}

4.1.2）定义一个接口及方法ParentPrint：

package com.example.demo.proxy;

public interface ParentPrint {
    void print(String content);
}

4.1.3）定义一个被代理的类，并实现接口ParentPrint,其中print方法就是我们需要代理的核心方法；

package com.example.demo.proxy;


public class Printer implements  ParentPrint {

    @Override
    public void print(String content) {
        System.out.println(content);
    }
}

4.1.4）定义一个代理类ProxyJdkPrinter并实现InvocationHandler，实现invoke方法，最终调用method.invoke(parentPrint,args)；

注意该Proxy类中是静态方法，且接收的三个参数依次为：

ClassLoader loader：指定当前目标对象使用类加载器，获取加载器的方法是固定的。
Class<?>[] interfaces：目标对象实现的接口的类型，使用泛型方式确认类型。
InvocationHandler：事件处理，执行目标对象的方法时，会触发事件处理器的方法，会把当前执行目标对象的方法作为参数传入。

package com.example.demo.proxy;

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


/*jdk动态代理：前提目标类必须有父接口（接口：ParentPrint,目标类：Printer）
1、创建ProxyJdkPrinter类，继承接口InvocationHandler创建代理类的调用处理程序；
2、同样引入代理类的参数对象private ParentPrint parentPrint;
3、实现invoke方法，最终调用method.invoke(parentPrint,args)；
4、测试：
实例化代理类p1；
将p1放入代理类ProxyJdkPrinter；
通过Proxy类的WuDaInvocationHandler方法创建代理对象；
代理对象调用被代理的方法；
* */
public class ProxyJdkPrinter implements InvocationHandler {

    private ParentPrint parentPrint;


    public ProxyJdkPrinter(ParentPrint parentPrint) {
        this.parentPrint = parentPrint;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String name = method.getName();
        if(name.equals("print")){
            System.out.println("jdk增加操作");
        }
        return method.invoke(parentPrint,args);
    }

}

4.1.5）测试，invoke() 方法: 当我们的动态代理对象调用原生方法的时候，最终实际上调用到的是 invoke() 方法，然后 invoke() 方法代替我们去调用了被代理对象的原生方法。

    public static void main(String[] args) {
        ParentPrint p1 = new Printer();
        ProxyJdkPrinter proxyJdkPrinter = new ProxyJdkPrinter(p1);
        //newProxyInstance:创建代理实例对象
        //三个参数：
        //1、 目标类的类加载器 2、目标类的父接口  3、handler
        ParentPrint proxyPrint = (ParentPrint)Proxy.newProxyInstance(p1.getClass().getClassLoader(), p1.getClass().getInterfaces(), proxyJdkPrinter);
        proxyPrint.print("测试");
    }

运行

4.1.6）总结：

通过java提供的Proxy类帮我们创建代理对象，基于接口的动态代理需要利用JDK中的API，在JVM内存中动态的构建Proxy对象；
优点：可以生成所有实现接口的代理对象
缺点：JDK反射生成代理必须面向接口, 这是由Proxy的内部实现决定的。生成代理的方法中你必须指定实现类的接口，它根据这个接口来实现代理类生成的所实现的接口。

4.2）cglib动态代理：当目标没有实现类的时候，可以使用；

实现步骤：

1、定义一个类；
2、自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和 JDK 动态代理中的 invoke 方法类似；
3、通过 Enhancer 类的 create()创建代理类；

4.2.1)定义一个被代理类Printer

package com.example.demo.proxy;


public class Printer1 {

    public void print(String content) {
        System.out.println(content);
    }
}

4.2.2)定义一个代理类ProxyCglibPrinter，并实现MethodInterceptor

package com.example.demo.proxy;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

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


/*cglib动态代理：（目标对象不需要实现接口）
实现MethodInterceptor 接口，在调用目标对象的方法时，就可以实现在调用方法之前、调用方法过程中、调用方法之后对其进行控制。
1.创建目标对象target；
2.创建interceptor对象
3.创建Enhancer对象，它以目标类和interceptor作为原料，生产出代理对象
4、enhancer设置参数setSuperclass，setCallback
5、创建代理类proxy,调用需要代理的方法；
* */
public class ProxyCglibPrinter implements MethodInterceptor {


    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        String name = method.getName();
        if(name.equals("print")){
            System.out.println("cglib增加操作");
        }
        methodProxy.invokeSuper(o,objects);
        return null;
    }

}

4.2.3）测试

    public static void main(String[] args) {
        Printer1 target = new Printer1();
        ProxyCglibPrinter interceptor = new ProxyCglibPrinter();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(interceptor);
        Printer1 proxy = (Printer1)enhancer.create();
        proxy.print("测试");
    }

运行

4.2.4)总结：

无需代理类实现接口，使用Cblib中的Enhancer来生成代理对象子类，并实现MethodInterceptor中的intercept方法，在此方法中可以实现增强功能。

如果目标对象需要实现接口，则使用JDK代理。
如果目标对象不需要实现接口，则使用Cglib代理。

5、综上所述，再次总结：

静态代理：

jdk动态代理：

cglib动态代理：

原文地址：https://blog.csdn.net/qq_39522120/article/details/140343909

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：从代理模式到注解开发
下一篇：Memcached与Redis：缓存解决方案的较量与选择

网络安全在线网站/靶场：全面探索与实践
CyberPatriot 是由美国空军协会（AFA）赞助的一项全国性网络安全教育计划，主要面向中小学生。该平台通过模拟真实的网络环境，帮助学生们学习如何检测和防御网络攻击。
阅读更多2024-11-17
Javascript垃圾回收机制-运行机制（大厂内部培训版本）
分代式机制把一些新、小、存活时间短的对象作为新生代，采用一小块内存频率较高的快速清理，而一些大、老、存活时间长的对象作为老生代，使其很少接受检查，新老生代的回收机制及频率是不同的，可以说此机制的出现很
阅读更多2024-11-17
算法练习：438. 找到字符串中所有字母异位词
找到字符串中所有字母异位词详解
阅读更多2024-11-17
ubuntu固定ip
ifconfig。
阅读更多2024-11-17
【每日 C/C++ 问题】
适用于两个相关的类型之间的自动转换，类型不相关时编译器会识别出来并报错。
阅读更多2024-11-17
sb.append(a + b)；与sb.append(a).append(b)；详解
sb.append(a + b);与sb.append(a).append(b); 详解
阅读更多2024-11-17
Java学习教程，从入门到精通，Java中super关键字的语法知识点及案例（31）
super是Java中的一个关键字，主要用于引用当前对象的父类或超类。通过super，可以在子类中访问父类的成员变量、方法和构造函数。
阅读更多2024-11-17
6. Keepalived配置Nginx自动重启，实现7x24提供服务
Keepalived配置Nginx自动重启，实现7x24提供服务实现步骤
阅读更多2024-11-17
unity3d————场景异步加载
本文介绍了Unity中场景切换的两种方法：同步切换和异步切换。同步切换在切换场景时会删除当前场景的所有对象并加载下一个场景的信息，可能导致卡顿。因此，异步切换被引入来解决这个问题。异步切换有两种实现方
阅读更多2024-11-17
Android Studio 控制台输出的中文显示乱码
安卓在调试阶段，需要查看app运行时的输出信息、出错提示信息。乱码，会极大的阻碍开发者前进的信心，不能及时的根据提示信息定位问题，因此我们需要查看没有乱码的打印信息。代码运行报错的时候，Build O
阅读更多2024-11-17

Aop切面编程（2）--代理模式

相关文章