跟萌新一起学设计模式（十一）之代理模式

最新推荐文章于 2024-08-14 23:12:09 发布

没入门的菜鸟

最新推荐文章于 2024-08-14 23:12:09 发布

阅读量148

点赞数

分类专栏：萌新设计模式代理模式文章标签： java 设计模式

本文链接：https://blog.csdn.net/weixin_45889311/article/details/109208299

版权

萌新同时被 3 个专栏收录

15 篇文章 0 订阅

订阅专栏

设计模式

15 篇文章 0 订阅

订阅专栏

代理模式

1 篇文章 0 订阅

订阅专栏

设计模式（十一）之代理模式

案例说明

我们有一个面点师的实体类，里面有一个制作面包的方法，我们调用这个方法时，不仅想要制作面包，还需要在之前采购原料、之后吃面包，但我们不想或者是不能改变这个面点师类里面的代码，所以我们就可以考虑使用代理模式来解决问题。

代理模式一般分为静态代理模式、动态代理模式和cglib代理模式（有些地方会把cglib归为动态代理模式），我们先看一下静态代理模式的类图和代码：
静态代理模式

在面点师实体类之上定义了接口让面点师实体类来实现，代理类实现面点师接口并将面点师接口组合到代理类中，通过调用代理类的makeBread方法来调用代理类中额外的操作和Baker中的makeBread方法。

面点师接口

public interface IBaker {

    public void makeBread();

}

面点师实体类

public class Baker implements IBaker{
    @Override
    public void makeBread() {
        System.out.println("面点师在做面包");
    }
}

代理类将面点师接口组合进去，并调用了自己额外的操作和Baker中的makeBread方法。

public class BakerProxy implements IBaker{

    private IBaker iBaker;

    public BakerProxy(IBaker iBaker){
        this.iBaker = iBaker;
    }

    @Override
    public void makeBread() {
        System.out.println("面点师做面包之前先去采购了食材");
        iBaker.makeBread();
        System.out.println("面点师做完面包后自己索性一口吃掉了");
    }
    
}

客户端

public class Client {
    public static void main(String[] args) {
        IBaker iBaker = new Baker();
        // 拿到代理对象
        BakerProxy bakerProxy = new BakerProxy(iBaker);
        bakerProxy.makeBread();
    }
}

测试看出，代理对象完成了原本的操作并在强自定义了额外的操作。

D:\jdk8\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=64541:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath D:\jdk8\jre\lib\charsets.jar;D:\jdk8\jre\lib\deploy.jar;D:\jdk8\jre\lib\ext\access-bridge-64.jar;D:\jdk8\jre\lib\ext\cldrdata.jar;D:\jdk8\jre\lib\ext\dnsns.jar;D:\jdk8\jre\lib\ext\jaccess.jar;D:\jdk8\jre\lib\ext\jfxrt.jar;D:\jdk8\jre\lib\ext\localedata.jar;D:\jdk8\jre\lib\ext\nashorn.jar;D:\jdk8\jre\lib\ext\sunec.jar;D:\jdk8\jre\lib\ext\sunjce_provider.jar;D:\jdk8\jre\lib\ext\sunmscapi.jar;D:\jdk8\jre\lib\ext\sunpkcs11.jar;D:\jdk8\jre\lib\ext\zipfs.jar;D:\jdk8\jre\lib\javaws.jar;D:\jdk8\jre\lib\jce.jar;D:\jdk8\jre\lib\jfr.jar;D:\jdk8\jre\lib\jfxswt.jar;D:\jdk8\jre\lib\jsse.jar;D:\jdk8\jre\lib\management-agent.jar;D:\jdk8\jre\lib\plugin.jar;D:\jdk8\jre\lib\resources.jar;D:\jdk8\jre\lib\rt.jar;D:\ideaworkspace\design_pattern\design\target\classes;D:\dev_tools\repository\org\projectlombok\lombok\1.16.10\lombok-1.16.10.jar;D:\dev_tools\repository\cglib\cglib\3.3.0\cglib-3.3.0.jar;D:\dev_tools\repository\org\ow2\asm\asm\7.1\asm-7.1.jar com.wd.proxy.staticproxy.Client
面点师做面包之前先去采购了食材
面点师在做面包
面点师做完面包后自己索性一口吃掉了

Process finished with exit code 0

动态代理模式

动态代理模式与静态代理模式的区别在于，动态代理无需实现面点师接口，利用JDK的反射机制来调用Baker中的makeBread方法，而静态代理是通过实例对象直接调用，IBaker与Baker完全没有变动。

代理类

public class BakerProxy {

    private IBaker iBaker;

    public BakerProxy(IBaker iBaker){
        this.iBaker = iBaker;
    }

    public Object getProxyInstance(){
        return Proxy.newProxyInstance(iBaker.getClass().getClassLoader(),
                iBaker.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("面点师做面包之前先去采购了食材");
                        Object retuanValue = method.invoke(iBaker, args);
                        System.out.println("面点师做完面包后自己索性一口吃掉了");
                        return retuanValue;
                    }
                });
    }
}

代理对象调用makeBread方法时，即是通过getProxyInstance来调用自定义的操作和Baker中的makeBread方法。

客户端

public class Client {
    public static void main(String[] args) {
        IBaker iBaker= new Baker();
        BakerProxy bakerProxy = new BakerProxy(iBaker);
        // 拿到代理对象
        IBaker proxyInstance = (IBaker)bakerProxy.getProxyInstance();
        proxyInstance.makeBread();
        System.out.println(proxyInstance.getClass());
    }
}

测试可见，我们拿到的确实是一个代理对象。

D:\jdk8\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=64748:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath D:\jdk8\jre\lib\charsets.jar;D:\jdk8\jre\lib\deploy.jar;D:\jdk8\jre\lib\ext\access-bridge-64.jar;D:\jdk8\jre\lib\ext\cldrdata.jar;D:\jdk8\jre\lib\ext\dnsns.jar;D:\jdk8\jre\lib\ext\jaccess.jar;D:\jdk8\jre\lib\ext\jfxrt.jar;D:\jdk8\jre\lib\ext\localedata.jar;D:\jdk8\jre\lib\ext\nashorn.jar;D:\jdk8\jre\lib\ext\sunec.jar;D:\jdk8\jre\lib\ext\sunjce_provider.jar;D:\jdk8\jre\lib\ext\sunmscapi.jar;D:\jdk8\jre\lib\ext\sunpkcs11.jar;D:\jdk8\jre\lib\ext\zipfs.jar;D:\jdk8\jre\lib\javaws.jar;D:\jdk8\jre\lib\jce.jar;D:\jdk8\jre\lib\jfr.jar;D:\jdk8\jre\lib\jfxswt.jar;D:\jdk8\jre\lib\jsse.jar;D:\jdk8\jre\lib\management-agent.jar;D:\jdk8\jre\lib\plugin.jar;D:\jdk8\jre\lib\resources.jar;D:\jdk8\jre\lib\rt.jar;D:\ideaworkspace\design_pattern\design\target\classes;D:\dev_tools\repository\org\projectlombok\lombok\1.16.10\lombok-1.16.10.jar;D:\dev_tools\repository\cglib\cglib\3.3.0\cglib-3.3.0.jar;D:\dev_tools\repository\org\ow2\asm\asm\7.1\asm-7.1.jar com.wd.proxy.dynamicproxy.Client
面点师做面包之前先去采购了食材
面点师在做面包
面点师做完面包后自己索性一口吃掉了
class com.sun.proxy.$Proxy0

Process finished with exit code 0

cglib代理模式

cglib代理模式的不同之处在于，被代理的面点师实体类不需要再去实现一个接口，在被代理类没有接口的场景下能够使用。

首先导入cglib的依赖

        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

面点师实体类

public class Baker{

    public void makeBread() {
        System.out.println("面点师在做面包");
    }
    
}

代理类，实现了MethodInterceptor

public class BakerProxy implements MethodInterceptor {

    private Baker baker;

    public BakerProxy(Baker baker){
        this.baker = baker;
    }

    public Object getProxyInstance(){
        //1. 创建一个工具类
        Enhancer enhancer = new Enhancer();
        //2. 设置父类
        enhancer.setSuperclass(baker.getClass());
        //3. 设置回调函数
        enhancer.setCallback(this);
        //4. 创建子类对象，即代理对象
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("面点师做面包之前先去采购了食材");
        Object returnValue = method.invoke(baker, objects);
        System.out.println("面点师做完面包后自己索性一口吃掉了");
        return returnValue;
    }
    
}

我们是通过一个工具类Enhancer来拿到代理对象，在代理对象调用makeBread方法时就被监听到并调用intercept方法。

客户端

public class Client {
    public static void main(String[] args) {
        Baker baker = new Baker();
        // 拿到代理对象
        Baker bakerProxy = (Baker)new BakerProxy(baker).getProxyInstance();
        bakerProxy.makeBread();
        System.out.println(bakerProxy.getClass());
    }
}

测试

D:\jdk8\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=64962:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath D:\jdk8\jre\lib\charsets.jar;D:\jdk8\jre\lib\deploy.jar;D:\jdk8\jre\lib\ext\access-bridge-64.jar;D:\jdk8\jre\lib\ext\cldrdata.jar;D:\jdk8\jre\lib\ext\dnsns.jar;D:\jdk8\jre\lib\ext\jaccess.jar;D:\jdk8\jre\lib\ext\jfxrt.jar;D:\jdk8\jre\lib\ext\localedata.jar;D:\jdk8\jre\lib\ext\nashorn.jar;D:\jdk8\jre\lib\ext\sunec.jar;D:\jdk8\jre\lib\ext\sunjce_provider.jar;D:\jdk8\jre\lib\ext\sunmscapi.jar;D:\jdk8\jre\lib\ext\sunpkcs11.jar;D:\jdk8\jre\lib\ext\zipfs.jar;D:\jdk8\jre\lib\javaws.jar;D:\jdk8\jre\lib\jce.jar;D:\jdk8\jre\lib\jfr.jar;D:\jdk8\jre\lib\jfxswt.jar;D:\jdk8\jre\lib\jsse.jar;D:\jdk8\jre\lib\management-agent.jar;D:\jdk8\jre\lib\plugin.jar;D:\jdk8\jre\lib\resources.jar;D:\jdk8\jre\lib\rt.jar;D:\ideaworkspace\design_pattern\design\target\classes;D:\dev_tools\repository\org\projectlombok\lombok\1.16.10\lombok-1.16.10.jar;D:\dev_tools\repository\cglib\cglib\3.3.0\cglib-3.3.0.jar;D:\dev_tools\repository\org\ow2\asm\asm\7.1\asm-7.1.jar com.wd.proxy.cglib.Client
面点师做面包之前先去采购了食材
面点师在做面包
面点师做完面包后自己索性一口吃掉了
class com.wd.proxy.cglib.Baker$$EnhancerByCGLIB$$c9d72c0c

Process finished with exit code 0

总结

1、静态代理的特点：在不修改目标对象的功能前提下, 能通过代理对象对目标功能扩展；因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类一旦接口增加方法，目标对象与代理对象都要维护；
2、动态代理的特点：代理对象不需要实现接口，但是目标对象要实现接口，否则不能用动态代理；代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象；
3、cglib代理的特点：静态代理和JDK代理模式都要求目标对象去实现一个接口，但是有时候目标对象只是一个单独的对象，并没有实现任何的接口，这个时候可使用目标对象子类来实现代理，这就是Cglib代理；Cglib代理也叫作子类代理，它是在内存中构建一个子类对象从而实现对目标对象功能扩展，有些书也将Cglib代理归属到动态代理；Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口，它广泛的被许多AOP的框架使用，例如Spring AOP，实现方法拦截。

没入门的菜鸟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
跟萌新一起学设计模式（十一）之代理模式

**设计模式（十一）之代理模式**案例说明我们有一个面点师的实体类，里面有一个制作面包的方法，我们调用这个方法时，不仅想要制作面包，还需要在之前采购原料、之后吃面包，但我们不想或者是不能改变这个面点师类里面的代码，所以我们就可以考虑使用代理模式来解决问题。代理模式一般分为静态代理模式、动态代理模式和cglib代理模式（有些地方会把cglib归为动态代理模式），我们先看一下静态代理模式的类图和代码：静态代理模式在面点师实体类之上定义了接口让面点师实体类来实现，代理类实现面点
复制链接

扫一扫

专栏目录