代理模式

JS设计模式之代理模式 Star这个类就是明星,StarProxy这个类就是明星经纪人,假如我们是商家,现在我们想请这个明星来参加我们的活动,我们开始和经纪人谈价格,talk出价1w,此时经纪人会做一个判断,如果价格大于等于1w,这个活动就比较适合,可以参加,代理就会去通知明星演出,如果小于1w的话,就不会,这个就是简单的代理模式,我们要访问明星,需要经过经纪人(也就是代理),才能去访问。其实就是给一个对象提供一个代理,如果要访问这个对象必须经过这个代理,先说,这个模式的优点是什么。 阅读详情

目录

 

0.背景介绍

1.代理模式介绍

1.1代理模式定义

1.2代理模式分类

1.3代理模式UML结构图

2.代理模式的Java实现

2.1用例UML结构图

2.2用例代码

3.JDK对代理模式的支持

3.1JDK动态代理用例实现

3.1.1动态代理UML结构图

3.1.2动态代理用例代码

3.2JDK动态代理原理解析

3.3JDK动态代理总结

4.总结


0.背景介绍

NBA巨星,鹈鹕队的当家球星戴维斯通过自己的经纪人里奇-保罗宣布将不会与鹈鹕队续约,顿时引起轩然大波,外界内行对他的行为褒贬不一,为荣誉也好,金钱也罢,球星转会想要去到更大的舞台展现自己无可厚非。对于此类新闻我们不置可否,只是引以为例,其实对于大部分名人来说,不管是演艺界还是体育界,他们都有自己的经纪人,大部分的明星都会通过自己的经纪人来转述或者表达一些本人的想法,经纪人就相当于代理人的作用,代理自己的对象来做一些事情。

在软件设计中,为了解决一个问题或者控制对一个对象行为的访问,我们经常会为此类对象设计一个替身(代理),用以与客户端发生实际的交互,比如网络代理,我们为了解决上网的权限问题,会使用网络代理来访问Internet上面的一些信息,又比如远程代理,我们需要通过远程代理访问远程主机的对象,这些都是我们今天要介绍的代理模式的一种。

1.代理模式介绍

1.1代理模式定义

代理模式:为另一个对象提供一个替身或者占位符来控制对这个对象的访问(比如上面的例子中,明星的所有公共行为都是通过自己的经纪人来转述的,其他人无法代替)

1.2代理模式分类

以下分类引自Java与模式一书

远程代理:为一个位于不同的地址空间的对象提供一个局域代表对象。这个不同的地址空间可以是本机器长,也可以在另一台机器中。

虚拟代理:根据需要创建一个资源消耗较大的对象,使得此对象只在需要时才会被真正创建。

Copy-on-Write代理:虚拟代理的一种,把复制(克隆)拖延到只有在客户端需要时,才真正创建。

保护代理:控制对一个对象的访问,如果需要,可以给不同的用户提供不同级别的使用权限。

Cache代理:为某一个目标操作的结果提供临时的存储空间,以便多个客户端可以共享这些结果。

防火墙代理:保护目标,不让愿意用户接近。

同步化代理:使几个用户能够同时使用一个对象而没有冲突。

智能引用代理:当一个对象被引用时,提供一些额外的操作,比如将此对象的调用次数记录下来等。

本文对上述几种代理模式不会一一详细的介绍,只会介绍所有代理的共同点。

1.3代理模式UML结构图

Subject:抽象主题接口,定义了真实主题以及代理主题的公共接口。

ProxySubject:代理主题,实现了抽象主题接口,内部持有一个具体主题的引用,可以操作真实主题对象,与客户端直接交互,解耦了客户端与真实主题的交互。

RealSubject:真实主题,实现了抽象主题接口。

2.代理模式的Java实现

以下是用Java简单的实现代理模式的用例代码(jdk版本为Java10)

2.1用例UML结构图

Person相当于抽象Subject接口,Star是真实的RealSubject,Broker是代理类

2.2用例代码

抽象接口:Person

public interface Person {

    void request();
}

Person实现类Star

public class Star implements Person {
    @Override
    public void request() {
        System.out.println("大家好我想换一只球队了");
    }
}

Person实现类Broker

public class Broker implements Person {

    private Person person;

    public Broker(Person person) {
        this.person = person;
    }

    @Override
    public void request() {
        System.out.println("大家好,我是经纪人XXX,我的被代理人想说:");
        this.person.request();
    }
}

Client客户端类:

public class Client {
    public static void main(String[] args) {
        Person star=new Star();

        Person broker=new Broker(star);

        broker.request();
    }
}

运行结果如下:

3.JDK对代理模式的支持

以上是用Java简单的实现类代理模式,其实在JDK中天然增加了对代理模式的支持,主要相关的类有两个,一个是Proxy,另一个是InvocationHandler,实现动态代理的主要步骤如下:

  1. 开发人员需要实现InvocationHandler接口来定义自己的InvocationHandler实现类。并且持有一个被代理类的引用。
  2. 通过Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)方法,传入真实主题的信息以及自定义实现的InvocationHandler,动态生成一个代理类。
  3. 通过动态生成的代理类来调用真实主题的目标方法。

3.1JDK动态代理用例实现

3.1.1动态代理UML结构图

其中,Proxy,InvocationHandler是JDK支持的动态代理工具,MyInvocationHandler是我们自己实现的InvocationHandler接口的自定义实现。

3.1.2动态代理用例代码

Person以及Star的代码见上一节

MyInvocationHandler代码

public class MyInnovationHandler implements InvocationHandler {
    private Person person;

    MyInnovationHandler(Person person) {
        this.person = person;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("大家好,我是经纪人XXX,我的被代理人想说:");
        return method.invoke(this.person, args);
    }
}

Client代码

public class ProxyTest {
    public static void main(String[] args) {
        //创建一个真实主题
        Person star = new Star();
        //创建自定义InvocationHandler实现类
        InvocationHandler invocationHandler = new MyInnovationHandler(star);
        //通过Proxy创建动态代理类
        Person person = (Person) Proxy.newProxyInstance(Star.class.getClassLoader(), Star.class.getInterfaces(), invocationHandler);
        //调用主题方法
        person.request();

    }
}

运行结果如下:

可以看到,通过JDK对代理模式的支持,运行结果与上一节中结果是一致的。

3.2JDK动态代理原理解析

通过JDK自带的动态代理来实现代理模式非常简单,本节,我们来剖析以下JDK动态代理的原理,让大家知其然,更知其所以然

动态代理类的主要生成是在Proxy的newProxyInstance(...)方法生成的,下面从这个方法开始讲解下动态代理的原理。

方法源码如下(JDK源码版本为Java10)

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h) {
        //方法入参有3个,分别是真实主题的类加载器,真实主题实现的接口,以及自定义实现的
        //InvocationHandler接口

        //判空操作
        Objects.requireNonNull(h);

        //获取SecurityManager,系统的安全校验,不知道是干啥的,可以忽略
        final Class<?> caller = System.getSecurityManager() == null
                                    ? null
                                    : Reflection.getCallerClass();

        /*
         * Look up or generate the designated proxy class and its constructor.
         */
        //生成Constructor对象,与类的构造方法有关
        Constructor<?> cons = getProxyConstructor(caller, loader, interfaces);

        //根据Constructor对象,以及caller和自定义的InvocationHandler 生成一个代理类
        return newProxyInstance(caller, cons, h);
    }

以上是newProxyInstance方法的源码,在主要代码上面写了注释,里面主要涉及的方法有两个,分别是getProxyConstructor()方法以及newProxyInstance()方法。

下面是getProxyConstructor方法的源码,改方法主要的作用是生成与主题相关的Constructor对象,下面是源码以及源码注释

private static Constructor<?> getProxyConstructor(Class<?> caller,
                                                      ClassLoader loader,
                                                      Class<?>... interfaces)
    {
        // 判断真实主题实现的抽象接口数量,1个走下面逻辑,大于1个走else接口
        if (interfaces.length == 1) {
            
            Class<?> intf = interfaces[0];
            //callser不为空,做安全校验
            if (caller != null) {
                checkProxyAccess(caller, loader, intf);
            }
            //先走缓存,通过ProxyBuilder生成Constructor对象
            return proxyCache.sub(intf).computeIfAbsent(
                loader,
                (ld, clv) -> new ProxyBuilder(ld, clv.key()).build()
            );
        } else {
            // interfaces cloned
            final Class<?>[] intfsArray = interfaces.clone();
            if (caller != null) {
                checkProxyAccess(caller, loader, intfsArray);
            }
            final List<Class<?>> intfs = Arrays.asList(intfsArray);
            return proxyCache.sub(intfs).computeIfAbsent(
                loader,
                (ld, clv) -> new ProxyBuilder(ld, clv.key()).build()
            );
        }
    }

下面看下ProxyBuilder类的build方法源码

  Constructor<?> build() {
            //获取代理类
            Class<?> proxyClass = defineProxyClass(module, interfaces);
            final Constructor<?> cons;
            try {
                //创建代理类的带参构造函数,传入参数是constructorParams
                cons = proxyClass.getConstructor(constructorParams);
            } catch (NoSuchMethodException e) {
                throw new InternalError(e.toString(), e);
            }
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
            return cons;
        }

以上代码片段主要做了以下几件事情

通过defineProxyClass(Module m, List<Class<?>> interfaces)方法动态生成一个代理类,入参主要有两个,一个是Module,一个是需要实现的接口,Module的主要作用是给代理类的包名的时候使用,interfaces是生成的代理类需要实现的接口。看下这个方法的源码

private static Class<?> defineProxyClass(Module m, List<Class<?>> interfaces) {
            String proxyPkg = null;     // package to define proxy class in
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            /*
             * Record the package of a non-public proxy interface so that the
             * proxy class will be defined in the same package.  Verify that
             * all non-public proxy interfaces are in the same package.
             */
              //验证需要实现的所有接口的属性是否是public,如果有一个不是public,则生成的代理类
                //所在的包名跟此非public的接口的包名一致
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;  // non-public, final
                    //给pkg赋值,为非public的接口的包名
                    String pkg = intf.getPackageName();
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                                "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                // 所有的接口都是public,则包名取默认值为:com.sun.proxy
                proxyPkg = m.isNamed() ? PROXY_PACKAGE_PREFIX + "." + m.getName()
                                       : PROXY_PACKAGE_PREFIX;
            } else if (proxyPkg.isEmpty() && m.isNamed()) {
                throw new IllegalArgumentException(
                        "Unnamed package cannot be added to " + m);
            }

            if (m.isNamed()) {
                if (!m.getDescriptor().packages().contains(proxyPkg)) {
                    throw new InternalError(proxyPkg + " not exist in " + m.getName());
                }
            }

            //为生成的代理类取名字的后缀数字,从0开始,
            long num = nextUniqueNumber.getAndIncrement();
            //代理类的名字为包名.$Proxy+后缀数字  比如 com.sun.proxy.$Proxy0
            String proxyName = proxyPkg.isEmpty()
                                    ? proxyClassNamePrefix + num
                                    : proxyPkg + "." + proxyClassNamePrefix + num;

            ClassLoader loader = getLoader(m);
            trace(proxyName, m, loader, interfaces);

            /*
             * Generate the specified proxy class.
             */
            //生成代理类的字节码文件
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                    proxyName, interfaces.toArray(EMPTY_CLASS_ARRAY), accessFlags);
            try {
                Class<?> pc = UNSAFE.defineClass(proxyName, proxyClassFile,
                                                 0, proxyClassFile.length,
                                                 loader, null);
                //放入cache中
                reverseProxyCache.sub(pc).putIfAbsent(loader, Boolean.TRUE);
                return pc;
            } catch (ClassFormatError e) {
                /*
                 * A ClassFormatError here means that (barring bugs in the
                 * proxy class generation code) there was some other
                 * invalid aspect of the arguments supplied to the proxy
                 * class creation (such as virtual machine limitations
                 * exceeded).
                 */
                throw new IllegalArgumentException(e.toString());
            }
        }

以上代码主要生成了动态代理类,主要有代理类的包名,类名,以及字节码文件,字节码文件,生成字节码的过程在此不详细 介绍了。

接下来就是调用代理类的construct方法生成构造器对象,传入参数是constructorParams(此参数是个常量   { InvocationHandler.class })

最后通过调用newProxyInstance方法,返回一个动态代理类的具体实例

下面看下生成的代理类的源码(反编译之后的代码)

import base.pattern.proxy.Person;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Person {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void request() throws  {
        try {
            //调用我们之前传入的MyInnovationHandlerde的invoke方法,方法名是m3,m3在下面
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("base.pattern.proxy.Person").getMethod("request");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

上面是生成的动态代理类的反编译代码,我们需要注意几点

  1. 此动态代理类继承了Proxy类,实现了Person接口,因此也实现了request()方法。
  2. 在request方法中,我们调用了MyInnovationHandler的invoke()方法(在生成代理类的时候传入的),Method是m3。
  3. m3是接口Person的request方法的反射。
  4. 在MyInnovationHandler方法里面我们调用的是Star类的request()方法(看上面MyInnovationHandler的代码即可发现)

UML结构图如下:

3.3JDK动态代理总结

3.1以及3.2节是对JDK动态代理的解析,由于源码比较多,可能解析的没有那么透彻,下面来动态代理的优缺点

优点:实现简单,不需要自己定义代理类,可以动态的生成代理类

缺点:从用例可以看出,JDK动态代理仅仅针对的是接口,为什么?看下最后生成的动态代理类的源码,动态代理类继承了Proxy类,由于Java本身只支持单继承,所以只适用于接口,那么如果针对的不是接口,应该怎么做呢,此时应该使用Cglib来实现(本文暂不讲解Cglib了,将会另外文章讲解)

4.总结

本文主要讲解了代理模式(静态代理)以及JDK支持的动态代理模式的原理以及用例实现,讲解动态代理的时候源码较多,逻辑优点混乱,也可能自身理解的也没有特别透彻,会继续加深学习。

 

【java】深入分析Java反射-动态代理 proxy 1.概述 转载:深入分析Java反射(四)-动态代理 【Java】Java 反射机制浅析 【Java】java代理 静态代理 动态代理 proxy 【java】静态代理 proxy 2.动态代理的简介 Java动态代理机制的出现,使得Java开发人员不用手工编写代理类,只要简单地指定一组接口及委托类对象,便能动态地获得代理类。代理类会负责将所有的方法调用分派到委托对象上反射执行,在分派执行的过程中,开发人员还可以按需调整委托类对象及其功能,这是一套非常灵活有弹性的代理框架。Java动态代理实际上通过反射技. 阅读详情

相关推荐

【Pico手势开发实战】基于SteamVR串流与MRTK3的跨平台交互方案

本文详细介绍了在Pico设备上,结合SteamVR串流与微软MRTK3框架,实现高效跨平台手势交互开发的完整方案。该方案通过在PC端运行Unity项目并串流至头显,利用MRTK3封装的手势识别与交互组件,大幅提升了开发调试效率与性能上限,并确保了未来向其他OpenXR设备的良好兼容性。

weixin_29001683的博客 219

Java设计模式----------动态代理原理源码分析

上篇文章ava设计模式----------代理模式中,介绍了两种代理模式(静态代理和动态代理)的应用场景和实际应用案例。本篇文章中,对动态代理的原理做进行深入的分析。关于动态代理,初看可能会比较费解,大概有如下几个疑问:代理是怎么形成的,代理类在哪里?TimeHandler类是做什么用的,在哪里被调用了?客户端调用的时候,写的是调用m.move();,程序是如何执行到了TimeHandler对象的...

Chenjay‘s Blog 574

手把手教你用Simulink搭建交流异步电机矢量控制模型(附完整仿真文件)

本文详细介绍了如何使用Simulink搭建交流异步电机矢量控制模型,涵盖系统架构设计、关键模块实现、PI调节器参数整定及仿真分析等核心内容。通过实战指南和完整仿真文件,帮助读者掌握矢量控制技术,提升电机控制系统的设计与调试能力。

n4o5p6q7r的博客 252

代理模式:一文彻底搞懂静态代理和动态代理

代理模式(Proxy Pattern)是一种结构型设计模式,它的概念很简单,它通过创建一个代理对象来控制对原始对象的访问。代理模式主要涉及两个角色:代理角色和真实角色。代理类负责代理真实类,为真实类提供控制访问的功能,真实类则完成具体的业务逻辑。这样,当我们不方便或者不能直接访问真实对象时,可以通过代理对象来间接访问。使用代理模式主要有两个目的:一是保护目标对象,二是增强目标对象。代理模式的原理是将真实类的功能封装在代理类中,最基本的方式就是创建一个代理类,代理类实现和真实类相同的接口,并且在代理类中引用真

qq_36756227的博客 1万+

西南交通大学车辆工程专业大四上车辆综合实训ame仿真部分

西南交通大学车辆工程专业大四上车辆综合实训ame仿真建模部分

qq_64814052的博客 1245

Cocos Creator实战:5步搞定棋牌游戏大厅场景开发(附完整代码)

本文详细介绍了使用Cocos Creator 3.8开发棋牌游戏大厅的5个关键步骤,包括工程配置、动态UI系统实现、核心交互功能开发、性能优化及调试发布技巧。通过模块化代码和实战案例,帮助开发者快速构建高交互性的棋牌游戏大厅,提升用户留存率。

weixin_29002209的博客 358

代理模式(详解)

代理模式是一种结构型设计模式,它为对象提供了一个代理,并由代理对象控制对原对象的访问。这可以是出于安全、性能、事务等多种原因。简单来说,代理模式就是通过代理对象来控制对实际对象的访问。代理对象在客户端和目标对象之间起到了中介的作用。代理模式通过引入代理对象,在不修改原始对象的情况下,为其添加额外的功能或控制。无论是静态代理、动态代理还是CGLIB代理,它们都有各自的优缺点,开发者可以根据具体的需求选择合适的代理方式。希望本文能帮助你更好地理解代理模式,并在实际项目中灵活应用。

weixin_67417798的博客 8157

SY6982C 7.4V锂电池1A充电模块原理图设计,已量产

在手持设备、便携工具与小型无人机等场景中,7.4V(2S)锂聚合物电池的应用愈发广泛。这类电池对充电系统的安全性、效率与兼容性提出了明确要求:需支持 USB 5V 输入、1A 安全充电,同时具备多重保护机制。本文将结合一款基于 SY6982C 的充电原理图,深入解析其电路设计与技术亮点。

不脱发的程序猿 368

一文搞懂代理模式

代理模式是常见的设计模式之一,顾名思义,代理模式就是代理对象具备真实对象的功能,并代替真实对象完成相应操作,并能够在操作执行的前后,对操作进行增强处理。(为真实对象提供代理,然后供其他对象通过代理访问真实对象)以下是具体理解!........................

weixin_43953283的博客 3万+

RK3568开发笔记- (TX/RX) RGMII delayline 功能调试

本文详细介绍了RK3568芯片RGMII接口delayline功能的调试过程。针对千兆以太网通信不稳定问题,通过分析RGMII时序要求,利用RK3568内置的delayline功能补偿信号延迟。调试方法包括扫描delayline窗口、测试中间值配置、优化硬件设计等步骤。文章还总结了常见问题解决方案,如PHY选型建议和自动扫描功能配置。最终实现了千兆速率下丢包率降至0.01%以下的目标,为类似开发场景提供了实用参考。

flypig has a dream! 318

西南科技大学数字电子技术实验七(4行串行累加器设计及FPGA实现)FPGA部分

/在k=1时输入1,并在k=0时运算。//在k=1时输入0,并在k=0时运算。//在k=1时输入1,并在k=0时运算。//在k=1时输入0,并在k=0时运算。//在k=1时输入1,并在k=0时运算。//在k=1时输入1,并在k=0时运算。//在k=1时输入0,并在k=0时运算。//在k=1时输入0,并在k=0时运算。三、程序清单(每条语句必须包括注释或在开发窗口注释后截图)四、综合、管脚分配、生成输出文件、下载(所有步骤截图)五、仿真程序清单、波形(波形截图必做,截图!.k(k),//开关。

Welcome To My6n Blog 4334

设计模式之代理模式ProxyPattern(六)

1、什么是代理模式?代理模式是23种设计模式中的一种。代理模式是一种结构型设计模式,它允许为其他对象提供一个替代品或占位符,以控制对这个对象的访问。2、代理模式的角色构成抽象主题(Subject):定义了真实主题和代理主题的共同接口,这样代理类可以通过实现该接口来代理真实主题。真实主题(Real Subject):定义了代理所代表的真实对象。代理(Proxy):持有对真实主题的引用,并实现了与真实主题一样的接口,客户端通过代理来访问真实主题,同时可以在访问真实主题前后进行一些额外操作。

徐泗空的博客 1466

AgentScope Java 2.0 最佳实践:9 个完整示例手把手带你开发 Java‑Agent

本文基于9 个完整示例,深入剖析从基础对话(BasicChatExample)、工具调用(@Tool 注解)、结构化输出(POJO Schema)、ToolGroup 自主管理、MCP 外部工具集成、Hook 生命周期监控、Spring Boot SSE 流式 Web、JsonSession 会话持久化到中断恢复的全链路实战教程。

program哲学 1687

代理模式(ProxyPattern)

代理模式(ProxyPattern) 代理模式 为其他对象提供一种代理以控制对这个对象的访问 远程代理,也就是为一个对象在不同的地址控件提供局部代表。这样可以隐藏一个对象存在于不同地址空间的事实 虚拟代理,根据需要创建开销很大的对象,通过他来存储实例化需要很长时间的真是对象 安全代理 用来控制真实对象访问时的权限 智能指引 指当调用真实的对象时,代理处理另外一些事情 模式动机 在某些情况下,一个客户不想或者不能直接引用一个对 象,此时可以通过一个称之为“代理”的第三者来实现 间接引用。代理对象可以在客户

Sharker_Blog的博客 584

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

代理模式 (ProxyPattern)

文章目录代理模式 (ProxyPattern)代理模式的定义代理模式的优点代理模式的缺点代理模式的结构代理模式的实现普通代理强制代理动态代理AOP使用场景 代理模式 (ProxyPattern) 代理模式的定义 为其他对象提供一种代理以控制对这个对象的访问。 代理模式的优点 真实的角色就是实现实际的业务逻辑,不用关心其他非本职责的事务,通过后期的代理完成一件事务,附带的结果就是编程简洁清晰。 具体主题角色是随时都会发生变化的,只要它实现了接口,甭管它如何变化,都逃不脱如来佛的手掌(接口),那我们的代理类完

有问题的请私信或关注v【技术印记】留言 416

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

设计模式之代理模式(ProxyPattern)

设计模式之代理模式(ProxyPattern) 文章目录设计模式之代理模式(ProxyPattern)一.代理模式(ProxyPattern)二.编程实例1.图片读取案例2.String类访问修饰符[]读写操作区分案例 一.代理模式(ProxyPattern) 代理模式是创建一个代理类,来帮助我们处理真实类,一般来说,这种代理类有点像明星的经纪人,如果你想接触到明星,必须先和他们的经纪人打交道。...

Worthy_Wang的博客 477

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

代理模式-ProxyPattern

前言: 代理模式与装饰者模式: 相同点: 1. 前提条件:装饰者(代理者)与被装饰者(委托者)要继承相同的父类或实现相同的接口。 2. 都可以增强某个类的方法,对程序进行扩展。 不同点: 1. 代理者是为某个对象添加一个代理,以控制对这个对象的访问。而装饰者增强某个类的方法。 2. 代理可以在调用核心方法之前做前置处理...

Jason Blog 197

代理模式(ProxyPattern)

定义 通过一个代理对象或者占位符来控制对原对象的访问。 结构图 角色与理解 代理模式共分为四种角色: Subject(抽象主题角色):真实主题角色与代理主题角色的共同父类,可以是具体类、抽象类、接口,客户端针对抽象主题角色编程 RealSubject(真实主题角色):实现具体业务方法的类,被代理主题角色调用 Proxy(代理主题角色):持有真实主题角色的引用,在调用真实主题角色的具体业务方法之前或者之后添加其它操作 客户端面对抽象主题角色编程,调用抽象主题角色实际上调用的是代

码农架构 422

java设计模式之 代理模式【Proxy Pattern】 详解

首先我们举个例子说明一下什么是策略模式: 什么是代理模式呢?我很忙,忙的没空理你,那你要找我呢就先找我的代理人吧,那代理人总要知道 被代理人能做哪些事情不能做哪些事情吧,那就是两个人具备同一个接口,代理人虽然不能干活,但是被 代理的人能干活呀。 比如西门庆找潘金莲,那潘金莲不好意思答复呀,咋办,找那个王婆做代理,表现在程序上时这样的: 先定义一种类型的女人: package com.cbf4lif...

蛋蛋淡淡定的庄园 299

结构型模型之-代理模式(proxyPattern)

结构型模型之-代理模式(proxyPattern) 参考网址:https://www.runoob.com/design-pattern/proxy-pattern.html 1 代理模式简介 代理模式主要是用中间层控制原生对象的访问 和装饰器模式的区别:装饰器模式为了增强功能,而代理模式是为了加以控制。 2 代理模式图解 3 代理模式简单实现 3.1 代码组成类 Image ProxyImage RealImage TestProxy 3.2 具体代码 Image package com.sh

shufangreal的博客 331

代理模式(proxyPattern)

定义  为其他对象提供一种代理以控制这个对象的访问。在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理模式可以在客户端与目标对象之间起到中介的作用。分类  1.静态代理:由程序员创建或特定工具自动生成源代码,再对其编译。在程序运行前,代理类的.class文件就已经存在了。  2.动态代理:在程序运行时,运用反射机制动态创建而程。UML...

zz_ddup的博客 221

第6章 代理模式【ProxyPattern】

静态代理的目标对象和代理对象需要实现统一个接口或者继承相同的父类。JDK动态代理的代理对象不需要实现接口,但是目标对象需要实现接口。

qq_41846002的博客 424
上一篇: 责任链模式
下一篇: 最近工作一点感想
T_coding
博客等级 码龄8年 4粉丝 8原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值