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

最新推荐文章于 2022-04-03 22:15:01 发布
最新推荐文章于 2022-04-03 22:15:01 发布
阅读量1.9w 收藏 2
点赞数
分类专栏： 设计模式 文章标签： 代理模式 动态代理 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_Java_Dog/article/details/117880636
版权

设计模式之代理模式

代理模式

需求: 有一辆坦克 , 想要记录坦克的移动时间和移动记录

原始代码如下

package com.cyc.design.proxy.v01;

import java.util.Random;

/**
 * 问题：我想记录坦克的移动时间
 */
public class Tank implements Movable {

    /**
     * 模拟坦克移动了一段儿时间
     */
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

interface Movable {
    void move();
}

方案一

通过在move的执行前后添加时间记录

package com.cyc.design.proxy.v02;

import java.util.Random;

/**
 * 问题：我想记录坦克的移动时间
 * 最简单的办法：修改代码，记录时间
 * 问题2：如果无法改变方法源码呢？ benchmark
 */
public class Tank implements Movable {

    /**
     * 模拟坦克移动了一段儿时间
     */
    @Override
    public void move() {
        long start = System.currentTimeMillis();

        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    public static void main(String[] args) {
        new Tank().move();
    }
}

interface Movable {
    void move();
}

**问题：**方法虽然简单 ,但是却是要修改源码，如果不修改源码呢？

方案二

使用继承的方式，新建Tank2继承Tank类, 实现move接口, 在执行Tank类的move方法前和方法后, 添加时间记录

package com.cyc.design.proxy.v04;

import java.util.Random;

/**
 * 问题：我想记录坦克的移动时间
 * 最简单的办法：修改代码，记录时间
 * 问题2：如果无法改变方法源码呢？
 * 用继承？
 */
public class Tank implements Movable {

    /**
     * 模拟坦克移动了一段儿时间
     */
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new Tank2().move();
    }
}

class Tank2 extends Tank {
    @Override
    public void move() {
        long start = System.currentTimeMillis();
        super.move();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

interface Movable {
    void move();
}

**问题：**熟悉了设计模式之后，应该记得要慎用继承，因为 继承耦合度太高，不够灵活，现在知识记录了坦克的运行时间，如果要记录坦克的行走记录，坦克发射的炮弹呢，难道还要写多个类去继承吗？

方案三

使用代理模式

新建TankTimeProxy同样实现moveAble接口，里面聚合了一个tank，记录一个起始时间和结束时间，中间调用的是tank的move方法。这种方式看起来就像是一个代理人，例如茅台酒代理人，买茅台酒，并不是去向酒厂就买，而是通过茅台酒代理人（经销商）去买，代理人再去向茅台厂购买。

package com.cyc.design.proxy.v05;

import java.util.Random;

/**
 * 问题：我想记录坦克的移动时间
 * 最简单的办法：修改代码，记录时间
 * 问题2：如果无法改变方法源码呢？
 * 用继承？
 * v05:使用代理
 */
public class Tank implements Movable {

    /**
     * 模拟坦克移动了一段儿时间
     */
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new TankTimeProxy(new Tank()).move();
    }
}

class TankTimeProxy implements Movable {

    Tank tank;

    public TankTimeProxy(Tank tank) {
        this.tank = tank;
    }

    @Override
    public void move() {
        long start = System.currentTimeMillis();
        tank.move();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

interface Movable {
    void move();
}

**问题：**这个代理只能代理坦克的移动时间。

方案四

同样新建一个TankLogProxy代理，记录坦克的行进日志

package com.cyc.design.proxy.v06;

import java.util.Random;

/**
 * 问题：我想记录坦克的移动时间
 * 最简单的办法：修改代码，记录时间
 * 问题2：如果无法改变方法源码呢？
 * 用继承？
 * v05:使用代理
 * v06:代理有各种类型
 * 问题：如何实现代理的各种组合？继承？Decorator?
 */
public class Tank implements Movable {

    /**
     * 模拟坦克移动了一段儿时间
     */
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new TankTimeProxy().move();
    }
}
//时间代理
class TankTimeProxy implements Movable {
    Tank tank;
    @Override
    public void move() {
        long start = System.currentTimeMillis();
        tank.move();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}
//行进日志代理
class TankLogProxy implements Movable {
    Tank tank;
    @Override
    public void move() {
        System.out.println("start moving...");
        tank.move();
        System.out.println("stopped!");
    }
}

interface Movable {
    void move();
}

问题: 如何既能记录行进时间的日志又能记录行进日志的?

方法: 使用嵌套, 方向没错, 但是两个代理类里面都聚合了tank对象, 又怎么能将两个代理类聚合在一起呢?

方案五

两个代理不再代理具体的tank类，而是代理moveAble接口，这样的话，便可实现以上需求。

这也就是静态代理

在这里插入图片描述

package com.cyc.design.proxy.v07;


import java.util.Random;

/**
 * 问题：我想记录坦克的移动时间
 * 最简单的办法：修改代码，记录时间
 * 问题2：如果无法改变方法源码呢？
 * 用继承？
 * v05:使用代理
 * v06:代理有各种类型
 * 问题：如何实现代理的各种组合？继承？Decorator?
 * v07:代理的对象改成Movable类型-越来越像decorator了
 *
 */
public class Tank implements Movable {

    /**
     * 模拟坦克移动了一段儿时间
     */
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {

        new TankLogProxy(
                new TankTimeProxy(
                       new Tank()
                )
        ).move();
    }
}

class TankTimeProxy implements Movable {
    Movable m;

    public TankTimeProxy(Movable m) {
        this.m = m;
    }

    @Override
    public void move() {
        long start = System.currentTimeMillis();
        m.move();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

class TankLogProxy implements Movable {
    Movable m;

    public TankLogProxy(Movable m) {
        this.m = m;
    }

    @Override
    public void move() {
        System.out.println("start moving...");
        m.move();
        long end = System.currentTimeMillis();
        System.out.println("stopped!");
    }
}

interface Movable {
    void move();
}

*问题: ** 如果想让LogProxy可以重用，不仅可以代理Tank，还可以代理任何其他可以代理的类型 Object （毕竟日志记录，时间计算是很多方法都需要的东西），这时该怎么做呢？

方案六(动态代理)

分离代理行为与被代理对象

package com.cyc.design.proxy.v08;


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

/**
 * 问题：我想记录坦克的移动时间
 * 最简单的办法：修改代码，记录时间
 * 问题2：如果无法改变方法源码呢？
 * 用继承？
 * v05:使用代理
 * v06:代理有各种类型
 * 问题：如何实现代理的各种组合？继承？Decorator?
 * v07:代理的对象改成Movable类型-越来越像decorator了
 * v08:如果有stop方法需要代理...
 * 如果想让LogProxy可以重用，不仅可以代理Tank，还可以代理任何其他可以代理的类型 Object
 * （毕竟日志记录，时间计算是很多方法都需要的东西），这时该怎么做呢？
 * 分离代理行为与被代理对象
 * 使用jdk的动态代理
 */
public class Tank implements Movable {

    /**
     * 模拟坦克移动了一段儿时间
     */
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Tank tank = new Tank();

        //reflection 通过二进制字节码分析类的属性和方法

        Movable m = (Movable)Proxy.newProxyInstance(Tank.class.getClassLoader(),
                new Class[]{Movable.class}, //tank.class.getInterfaces()
                new LogHander(tank)
        );

        m.move();
    }
}

class LogHander implements InvocationHandler {

    Tank tank;

    public LogHander(Tank tank) {
        this.tank = tank;
    }
    //getClass.getMethods[]
    /**
     * @param proxy 生成的代理对象, 也就是那个m
     * @param method 要代理的方法
     * @param args 方法需要的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("method " + method.getName() + " start..");
        Object o = method.invoke(tank, args);
        System.out.println("method " + method.getName() + " end!");
        return o;
    }
}


interface Movable {
    void move();
}

package com.cyc.design.proxy.v08;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Random;

/**
 * 问题：我想记录坦克的移动时间
 * 最简单的办法：修改代码，记录时间
 * 问题2：如果无法改变方法源码呢？
 * 用继承？
 * v05:使用代理
 * v06:代理有各种类型
 * 问题：如何实现代理的各种组合？继承？Decorator?
 * v07:代理的对象改成Movable类型-越来越像decorator了
 * v08:如果有stop方法需要代理...
 * 如果想让LogProxy可以重用，不仅可以代理Tank，还可以代理任何其他可以代理的类型 Object
 * （毕竟日志记录，时间计算是很多方法都需要的东西），这时该怎么做呢？
 * 分离代理行为与被代理对象
 * 使用jdk的动态代理
 */
public class Tank implements Movable {

    /**
     * 模拟坦克移动了一段儿时间
     */
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Tank tank = new Tank();

        //reflection 通过二进制字节码分析类的属性和方法

        Movable m = (Movable)Proxy.newProxyInstance(Tank.class.getClassLoader(),
                new Class[]{Movable.class}, //tank.class.getInterfaces()
                new LogHander(tank)
        );

        m.move();
    }
}

class LogHander implements InvocationHandler {

    Tank tank;

    public LogHander(Tank tank) {
        this.tank = tank;
    }
    //getClass.getMethods[]
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("method " + method.getName() + " start..");
        Object o = method.invoke(tank, args);
        System.out.println("method " + method.getName() + " end!");
        return o;
    }
}


interface Movable {
    void move();
}

查看输出结果:

method move start..
Tank moving claclacla...
method move end!

这里使用到了JDK的动态代理, 点进去newProxyInstance

在这里插入图片描述

第一个参数表示, 需要哪一个ClassLoader将new 出来的代理对象加载到内存，第二个参数，表示这个代理对象需要实现哪些接口。第三个参数，Invocationhandler，调用处理器，指的是，被代理对象的方法被调用的时候， 需要做什么处理。

**问题: ** 根据代码, 观察发现, 并没有地方调用LogHander的invoke方法, method move start…和method move end!是如何输出的呢? 要弄清楚这个问题, 继续往下研究

方案七(动态代理)



/**
 * 问题：我想记录坦克的移动时间
 * 最简单的办法：修改代码，记录时间
 * 问题2：如果无法改变方法源码呢？
 * 用继承？
 * v05:使用代理
 * v06:代理有各种类型
 * 问题：如何实现代理的各种组合？继承？Decorator?
 * v07:代理的对象改成Movable类型-越来越像decorator了
 * v08:如果有stop方法需要代理...
 * 如果想让LogProxy可以重用，不仅可以代理Tank，还可以代理任何其他可以代理的类型
 * （毕竟日志记录，时间计算是很多方法都需要的东西），这时该怎么做呢？
 * 分离代理行为与被代理对象
 * 使用jdk的动态代理
 *
 * v09: 横切代码与业务逻辑代码分离 AOP
 * v10: 通过反射观察生成的代理对象
 * jdk反射生成代理必须面向接口，这是由Proxy的内部实现决定的
 */
public class Tank implements Movable {

    /**
     * 模拟坦克移动了一段儿时间
     */
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Tank tank = new Tank();

        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");//jdk 1.8
//        System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles","true"); jdk 1.8以上

        Movable m = (Movable)Proxy.newProxyInstance(Tank.class.getClassLoader(),
                new Class[]{Movable.class}, //tank.class.getInterfaces()
                new TimeProxy(tank)
        );

        m.move();

    }
}

class TimeProxy implements InvocationHandler {
    Movable m;

    public TimeProxy(Movable m) {
        this.m = m;
    }

    public void before() {
        System.out.println("method start..");
    }

    public void after() {
        System.out.println("method stop..");
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //Arrays.stream(proxy.getClass().getMethods()).map(Method::getName).forEach(System.out::println);

        before();
        Object o = method.invoke(m, args);
        after();
        return o;
    }

}

interface Movable {
    void move();
}

在这里插入图片描述

在当前项目目录下 , 会生成该代理对象的类, idea自动将其反编译,

查看

在这里插入图片描述

在这里插入图片描述

观察代码 , 发现他生成了move方法, 以为他调用动态代理时, 指定了被代理对象实现movable接口, 所以, 这里生成了move方法, 点击去Proxy类, 发现InvocationHandler就是上图中指定的当前LogProxyHandler

所以原理为: 当我们new代理类对象的时候, InvocationHandler传进去, 调用super.h就被指定为, 当m.move方法执行时 , 首选调用LogProxyHandler

JDK动态代理逻辑图

在这里插入图片描述

源码分析

  • 从 Proxy.newProxyInstance点进去

在这里插入图片描述

  • 重点是下面的getProxyConstructor这个方法,

在这里插入图片描述

  • 点击进入getProxyConstructor

在这里插入图片描述

proxyCache.sub(intf).computeIfAbsent 这句话的意思是 , 每次生成代理的时候 , 如果这个代理已经在代理缓存池中存在 , 则直接从缓存池中拿。 computeIfAbsent , 意为 : 如果没有，则通过计算得出该代理。再往下， 有proxyBuild的build方法，这才是在去生成代理，点击进入build方法，

在这里插入图片描述

  • 点击进入defineProxyClass

在这里插入图片描述

  • 点击进入generateProxyClass

在这里插入图片描述

  • gen.generateClassFile() 是直接操作编译生成的字节码文件，点击进入

在这里插入图片描述

  • 在经过一系列的操作后，在methods.add(pm.generateMethod());将方法加入进去。

在这里插入图片描述

点击进入method.add方法

在这里插入图片描述

在这里插入图片描述

最终进入到asm, 归根结底 , JDK动态代理是又asm实现

ASM是一个通用的Java字节码操作和分析框架。 它可以用于修改现有类或直接以二进制形式动态生成类。 ASM提供了一些常见的字节码转换和分析算法，可以从中构建自定义复杂转换和代码分析工具。 ASM提供与其他Java字节码框架类似的功能，但专注于性能。 因为它的设计和实现尽可能小而且快，所以它非常适合在动态系统中使用

JDK动态代理缺陷在于被代理的类必须实现某个接口

CGLIB动态代理

cglib 全称Code Generation Library ,是一个强大的,高性能,高质量的Code生成类库。它可以在运行期扩展Java类与实现Java接口。

代码实现

package com.cyc.design.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;
import java.util.Random;

/**
 * CGLIB实现动态代理不需要接口
 */
public class Main {
    public static void main(String[] args) {
        //增强器
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(Tank.class);
        //设置回调
        enhancer.setCallback(new TimeMethodInterceptor());
        Tank tank = (Tank)enhancer.create();
        tank.move();
    }
}

class TimeMethodInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        System.out.println(o.getClass().getSuperclass().getName());
        //输出 com.cyc.design.cglib.Tank, 说明cglib动态代理, 生成的是被代理对象的一个子类
        //这么看来 ,cglib也有缺陷 如果被代理对象是final类型,那么cglib就无法动态代理该类
        //cglib底层, 使用的也是asm
        System.out.println("before");
        Object result = null;
        result = methodProxy.invokeSuper(o, objects);
        System.out.println("after");
        return result;
    }
}

class Tank {
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

输出 com.cyc.design.cglib.Tank, 说明cglib动态代理, 生成的是被代理对象的一个子类，这么看来 ，cglib也有缺陷 如果被代理对象是final类型，那么cglib就无法动态代理该类
同样，和JDK动态代理一样，cglib底层, 使用的也是asm。

面对final类型的类 ， asm就可以实现器动态代理，因为asm在读取完成器二进制码文件后， 可以对其进行修改，此时，可以删除器final关键字，便可对其实现动态代理。

spring aop

代码演示：

package com.cyc.design.spring.v1;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * spring aop test
 */

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("app.xml");
        Tank t = (Tank)context.getBean("tank");
        t.move();
    }
}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">

    <bean id="tank" class="com.cyc.design.spring.v1.Tank"/>
    <bean id="timeProxy" class="com.cyc.design.spring.v1.TimeProxy"/>

    <aop:config>
        <!--ref="timeProxy" 表示要切入的类是id为timeProxy指定的TimeProxy-->
        <aop:aspect id="time" ref="timeProxy">
            <!--切点位置-->
            <aop:pointcut id="onmove" expression="execution(void com.cyc.design.spring.v1.Tank.move())"/>
            <!--执行前,调用before方法-->
            <aop:before method="before" pointcut-ref="onmove"/>
            <!--执行后,调用after方法-->
            <aop:after method="after" pointcut-ref="onmove"/>
        </aop:aspect>
    </aop:config>

</beans>

实现方式: 当Tank.move执行前 , spring 发现在配置文件中有该方法的切点, 并且有执行前和执行后要执行的方法。

这种配置文件的方式，如果需要进行切面的类很多，那么维护配置文件就是一件很麻烦的事。由此引出了下面的基于注解的方式。

基础注解的AOP

package com.cyc.design.spring.v2;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * spring aop test
 */

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("app_auto.xml");
        Tank t = (Tank)context.getBean("tank");
        t.move();
    }
}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">

    <aop:aspectj-autoproxy/>

    <bean id="tank" class="com.cyc.design.spring.v2.Tank"/>
    <bean id="timeProxy" class="com.cyc.design.spring.v2.TimeProxy"/>


</beans>

Spring

  • AOP+IOC
  • bean工厂+灵活装配+动态行为拼接(织入), 成就了spring在java框架中的一哥地位
意田天
关注
专栏目录
大话设计模式—代理模式
lmb55的专栏
03-19 1895
在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。我们创建具有现有对象的对象，以便向外界提供功能接口。大话设计模式中程杰老师的给出的解释是代理模式：为其他对象提供一种代理以控制对这个对象的访问。主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安
【白话设计模式十四】代理模式(Proxy)
weixin_34092370的博客
04-01 168
为什么80%的码农都做不了架构师？>>> ...
Java代理模式 三种实现方案
smilerro的博客
11-26 491
设计模式–代理模式 文章目录设计模式--代理模式什么是代理模式代理模式的作用Java中实现代理模式的方式静态代理动态代理cgilb代理 什么是代理模式 在代理模式（Proxy Pattern）即一个类代表另一个类的功能。属于设计模式中的结构型模式。 在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。 代理模式的作用 代理模式的作用在于某些情况下我们不方便或不希望直接访问某个对象，或者希望在使用某对象之前之后增加一些扩展的处理时，可以为目标对象创建一个代理对象，使用代理对象来完成并扩展目标对象
设计模式之代理模式：三种代理模式的实现方式
that_is_cool的博客
07-10 5990
设计模式之代理模式：三种代理模式的实现方式    前言：代理模式和另外一种设计模式--装饰者模式十分相像，他们都是在不修改目标对象源代码的基础上，对源代码的一次重构。只是，代理模式，关注的是目标对象的使用，他有目标的控制权，而装饰者模式，只是对目标对象功能的增强，仅此而已，不拥有目标对象的控制权。    代理模式有三种实现方式：继承目标对象的同一个接口，引入目标对象，重写方法；使用JDK动态代理的...
设计模式之代理模式Proxy
04-01
代理模式是设计模式中的一种结构型模式，它在对象交互中起到了中介的作用，允许通过代理对象来控制对原对象的访问。代理模式的核心思想是为一个对象提供一个替身，以便增加新的功能或者控制对原对象的访问。这种模式...
设计模式之代理模式proxy.zip
12-29
代理模式是一种常用的设计模式，它在软件开发中扮演着重要的角色。代理模式允许我们为一个对象创建一个代理，这个代理对象在客户端和目标对象之间起到中介的作用，可以增强或控制对目标对象的访问。代理模式的主要...
Android设计模式之代理模式Proxy浅显易懂的详细说明
01-05
代理模式也是平时比较常用的设计模式之一,代理模式其实就是提供了一个新的对象,实现了对真实对象的操作,或成为真实对象的替身.在日常生活中也是很常见的.例如A要租房,为了省麻烦A会去找中介,中介会替代A去筛选房子,A...
设计模式之代理模式proxy
02-23
**设计模式之代理模式（Proxy Pattern）** 设计模式是软件工程中的一种最佳实践，它是在特定情境下解决常见问题的模板。代理模式是其中一种行为设计模式，它的核心思想是为一个对象提供一个替身或者代理，以控制对...
c++-设计模式之代理模式（Proxy）
最新发布
09-20
代理模式（Proxy Pattern）是一种结构型设计模式，用于为其他对象提供一种代理以控制对这个对象的访问。代理模式通常用于保护、延迟加载、记录请求等场景，可以在不改变原有对象的情况下为其增加新的功能。 代理...
设计模式——代理模式
huyiju的博客
08-21 331
目录 1：什么是代理模式 2：JDK代理模式实现 2.1：JDK静态代理 2.2：JDK动态代理 3：动态代理缺点 4： Cglib代理方案（字节码增强） 4.1：代码实现 5：动态代理和Cblib对比 1：什么是代理模式 代理模式是23中设计模式中的一种，我们在应用中访问B对象，B对象有增删改查方法，我们想要在B对象的某一个方法前置后置执行一些我们需要的操作，方法1可以直...
23种设计模式-代理模式
老杨叔叔
06-05 1267
1.产生背景 2.概念 3.目的 4.解决方案 5. 类图 6.优缺点 优点： 7.应用场景 8.现实案例 9. 注意事项 1.产生背景 为什么需要代理模式 假如你是一个业主，有一套500万的房子需要出售；你希望找一个合适的客户，签个合同，收了钱，然后把房子过户给客户就可以了； 但是，有太多的客户天天找你需要看房，询问，而且大部分都是没有诚意的客户，...
设计模式详解（九）——代理模式
weixin_41951205的博客
10-13 252
一、场景问题 某教务系统想要在用户业务操作前添加权限验证，以及操作过程的日志记录。请设计出一套合理的程序解决方案。 二、解决方案 1、传统解决方案 1.1、实现思路 在业务操作的前面添加权限校验，校验通过才能执行业务操作，在业务操作过程中添加相应的日志记录代码。 代码展示 权限校验器 public class AccessValidator { /** * 权限校验 * @param role 角色 * @author xianzilei **/
Java设计模式----------动态代理原理源码分析
Chenjay‘s Blog
04-13 466
上篇文章ava设计模式----------代理模式中，介绍了两种代理模式（静态代理和动态代理）的应用场景和实际应用案例。本篇文章中，对动态代理的原理做进行深入的分析。关于动态代理，初看可能会比较费解，大概有如下几个疑问：代理是怎么形成的，代理类在哪里？TimeHandler类是做什么用的，在哪里被调用了？客户端调用的时候，写的是调用m.move();，程序是如何执行到了TimeHandler对象的...
代理模式
T_coding的博客
04-15 573
目录 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....
10分钟看懂动态代理设计模式
weixin_33778778的博客
03-02 3713
动态代理是Java语言中非常经典的一种设计模式，也是所有设计模式中最难理解的一种。本文将通过一个简单的例子模拟JDK动态代理实现，让你彻底明白动态代理设计模式的本质，文章中可能会涉及到一些你没有学习过的知识点或概念。如果恰好遇到了这些知识盲点，请先去学习这部分知识，再来阅读这篇文章。 什么是代理 从字面意思来看，代理比较好理解，无非就是代为处理的意思。举个例子，你在上大学的时候，总是喜欢逃课。...
设计模式之-代理模式
小猪的互联网江湖
01-06 2023
代理模式详解 特点： 1、 执行者、 被代理人 2、 对于被代理人来说， 这件事情是一定要做的， 但是我自己又不想做或者没有时间做， 找代理。 3、 需要获取到被代理的人个人资料。 4、关心过程 穷举法： 租房中介： 中介和你 火车票黄牛： 黄牛和你 媒人： 媒婆和你 明星经纪人： 经纪人和明星 刘德华要开演唱会（长沙） 、 准备工作和善后工作 总结: 做了一件什么事情呢
代理设计模式（Proxy）
学习笔记
04-20 2271
1.概述 在面向对象编程的过程中，“本人”和“代理人”都是对象。如果“本人”对象太忙的了，有些工作自己无法亲自完成，就将其交给“代理人”对象负责。 在处理请求的时候“代理人”会尽量处理客户的请求，只有自己不能处理时，才会把工作交给“本人”。例如：可以在“代理人”判断请求的是否合法和处理异常等，“本人”要实现线程同步，则可以在“代理人”中实现同步，具体的请求处理在交给“本人”处理。 2.实...
自动驾驶汽车的规划与控制
热门推荐
人无远虑，必有近忧
04-03 1万+
1. 概念与意义 自动驾驶汽车作为一个复杂的软硬件结合系统,其安全,可靠地运行需要车载硬件,传感器集成、感知、预测以及规划控制等多个模块的协同配合工作。感知预测和规划控制的紧密配合非常重要。这里的规划与控制(Planning&.Control)在广义上可以划分成自动驾驶汽车路由寻径(Routing),行为决策(Behavioral Decision),运动规划(Motion Planning),以及控制(Control)等几个部分。 2. 路径规划 路由寻径、行为决策,运动规划三个部分又可统称
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

意田天

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值