设计模式-代理模式

最新推荐文章于 2024-01-06 11:32:36 发布

小小竹子

最新推荐文章于 2024-01-06 11:32:36 发布

阅读量101

点赞数

分类专栏：笔记文章标签：代理模式 java 开发语言

本文链接：https://blog.csdn.net/qq_44606649/article/details/116420242

版权

笔记专栏收录该内容

27 篇文章 0 订阅

订阅专栏

什么是代理模式？

代理模式的定义：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

举个例子来说明：假如说我现在想买一辆二手车，虽然我可以自己去找车源，做质量检测等一系列的车辆过户流程，但是这确实太浪费我得时间和精力了。我只是想买一辆车而已为什么我还要额外做这么多事呢？于是我就通过中介公司来买车，他们来给我找车源，帮我办理车辆过户流程，我只是负责选择自己喜欢的车，然后付钱就可以了。

代理模式应用场景

远程代理
虚拟代理
安全代理

为什么要用代理模式？

中介隔离作用：在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。
开闭原则，增加功能：代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。
代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后对返回结果的处理等。
代理类本身并不真正实现服务，而是通过调用委托类的相关方法，来提供特定的服务。真正的业务功能还是由委托类来实现，但是可以在业务功能执行的前后加入一些公共的服务。
例如我们想给项目加入缓存、日志这些功能，我们就可以使用代理类来完成，而没必要打开已经封装好的委托类。

有哪几种代理模式？

静态代理
动态代理（JDK代理、接口代理）
Cglib代理（在内存中动态的创建对象，而不需要实现接口，属于动态代理范畴）
如果按照代理创建的时期来进行分类的话，可以分为两种：静态代理、动态代理。静态代理是由程序员创建或特定工具自动生成源代码，再对其编译。在程序员运行之前，代理类.class文件就已经被创建了。动态代理是在程序运行时通过反射机制动态创建的。

1.静态代理

静态代理在使用时，需要定义接口或者父类，被代理对象（即目标对象）与代理对象一起实现相同的接口或者是继承相同父类。
测试案例（黑马程序员讲课演员案例）：演员-经纪人-剧组

/**
 * 一个经纪公司的要求:
 * 能做基本的表演和危险的表演
 */
public interface IActor {
    /**
     * 基本演出
     * @param money
     */
    public void basicAct(float money);
    /**
     * 危险演出
     * @param money
     */
    public void dangerAct(float money);
}


/**
 * 一个演员
 */
//实现了接口，就表示具有接口中的方法实现。即：符合经纪公司的要求
public class Actor implements IActor{
    @Override
    public void basicAct(float money){
        System.out.println("拿到钱，开始基本的表演："+money);
    }
    @Override
    public void dangerAct(float money){
        System.out.println("拿到钱，开始危险的表演："+money);
    }
}

/**
* 代理人
*/
public class ActorProxy implements IActor{

    private IActor actor;
    public ActorProxy(IActor actor) {
        this.actor = actor;
    }

    @Override
    public void basicAct(float money) {
        //如果钱少了不演
        if(money<2000) {

        }
        System.out.println("代理方抽取费用");
        System.out.println("参加普通演出");
    }

    @Override
    public void dangerAct(float money) {
        //如果钱少了不演
        if(money<11000) {

        }
        System.out.println("代理方抽取费用");
        System.out.println("参加危险演出");
    }
}



/**
* 剧组：测试类
*/
public class ProxyTest {
     public static void main(String[] args) {
        IActor actor = new Actor();
        actor.basicAct(2000);
        ActorProxy actorProxy = new ActorProxy(actor);
        actorProxy.basicAct(3000);
    }
}

静态代理总结：

优点：可以做到在符合开闭原则的情况下对目标对象进行功能扩展。
缺点：需要为所有服务创建代理类，工作量太大，不易管理。同时接口一旦发生改变，代理类也得相应修改。

2.动态代理

2.1 基于接口（JDK）动态代理

在动态代理中我们不再需要再手动的创建代理类，我们只需要编写一个动态处理器就可以了。真正的代理对象由JDK在运行时为我们动态的来创建。
　　要求：被代理对象至少实现一个接口

第一步：编写动态处理器

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

public class DynamicProxyHandler implements InvocationHandler {
    private Object object;

    public DynamicProxyHandler(Object object) {
        this.object = object;
    }
    /**
	* 执行被代理对象的任何方法，都会经过该方法。
	* 此方法有拦截的功能。
	* 通过泛型可以代理更多类型
	* 参数：
	* proxy：代理对象的引用。不一定每次都用得到
	* method：当前执行的方法对象
	* args：执行方法所需的参数
	* 返回值：
	* 当前执行方法的返回值
	*/
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        String name = method.getName();
        Float money = (Float) args[0];
        Object rtValue = null;

        if("basicAct".equals(name)){
            //基本演出，没有 2000 不演
            if(money > 2000){
                //看上去剧组是给了 8000，实际到演员手里只有 4000
                //这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
                rtValue = method.invoke(object,money/2);
            }
        }
        if("dangerAct".equals(name)){
            //危险演出,没有 5000 不演
            if(money > 5000){ 
            //看上去剧组是给了 50000，实际到演员手里只有 25000
            //这就是我们没有修改原来 dangerAct 方法源码，对方法进行了增强
                rtValue = method.invoke(object,money/2);
            }
        }
        return rtValue;
    }
}

第二步：编写测试类

public class DybamicProxyText {
    public static void main(String[] args) {
        IActor actor = new Actor();
        IActor proxyActor = (IActor) Proxy.newProxyInstance(
        		IActor.class.getClassLoader(),
                new Class[]{IActor.class},
                new DynamicProxyHandler(actor));
        proxyActor.basicAct(4000);
    }
}
/**  Proxy.newProxyInstance参数含义：
* ClassLoader：和被代理对象使用相同的类加载器。
* Interfaces：和被代理对象具有相同的行为。实现相同的接口。
* InvocationHandler：事件处理，也就是执行目标对象方法时，执行的代理事 件
* 返回：代理对象
* */

对Proxy和InvocationHandler讲解的：https://blog.csdn.net/yaomingyang/article/details/80981004

//更容易理解的写法
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxyHandler{
    private Object object;

    public DynamicProxyHandler(Object object) {
        this.object = object;
    }
    public Object getDynamicProxyObject(){
    	return Proxy.newProxyInstance(//返回代理对象
        		IActor.class.getClassLoader(),
                new Class[]{IActor.class},
                new InvocationHandler (object.getClass().getClassLoader(),
	                object.getClass().getInterfaces(),
	                new InvocationHandler(){
						 @Override
					    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				             Object rtValue = method.invoke(object,money/2);
				             return rtValue;//返回执行结果
					    }
					}
				)
			);
	}
   
}

2.2 CGLIB代理

不需要被代理类实现接口
CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。但因为采用的是继承，所以不能对final修饰的类进行代理。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。
引入cglib-nodep-3.3.0.jar依赖包
第一步：引入cglib的jar包，创建CGLIB代理类
还是那个演员的例子，只不过不需要让他实现接口。

还是那个演员的例子，只不过不让他实现接口。
 import net.sf.cglib.proxy.Enhancer;
 import net.sf.cglib.proxy.MethodInterceptor;
 import net.sf.cglib.proxy.MethodProxy;
 import java.lang.reflect.Method;

public class CGLibProxy  implements MethodInterceptor{

    private Object target;
    //获取代理人
    public Object getInstance(final Object target) {
          this.target = target;
          //创建一个工具类
          Enhancer enhancer = new Enhancer();
          //设置父类
          enhancer.setSuperclass(this.target.getClass());
          //设置回调函数
          enhancer.setCallback(this);
          //创建子类对象，即代理对象
          return enhancer.create();
    }
    /**
     * 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何
     方法进行增强。
     *
     * 参数：
     * 前三个和基于接口的动态代理是一样的。
     * MethodProxy：当前执行方法的代理对象。
     * 返回值：
     * 当前执行方法的返回值
     */

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        String name = method.getName();
        Float money = (Float) objects[0];
        Object rtValue = null;
        if("basicAct".equals(name)){
            if(money > 2000){
                rtValue = method.invoke(target, money/2);
            }
        }
        if("dangerAct".equals(name)){
            if(money > 5000){
                rtValue = method.invoke(target, money/2);
            }
        }
        return rtValue;
    }
}

测试类

public class CGLibProxyTest {
    public static void main(String[] args) {
        Actor actor2 = new Actor();
        CGLibProxy cgLibProxy = new CGLibProxy();
        Actor actor =(Actor) cgLibProxy.getInstance(actor2);
        actor.basicAct(2320);
    }
}

CGLI
B代理总结： CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高，但是CGLIB创建代理对象时所花费的时间却比JDK多得多。所以对于单例的对象，因为无需频繁创建对象，用CGLIB合适，反之使用JDK方式要更为合适一些。同时由于CGLib由于是采用动态创建子类的方法，对于final修饰的方法无法进行代理

在Spring的AOP编程中: 如果加入容器的目标对象有实现接口,用JDK代理；如果目标对象没有实现接口,用Cglib代理。
其他代理模式介绍

防火墙代理：内网通过代理穿透防火墙，实现对公网的访问
缓存代理：
远程代理：远程对象的本地代表，通过他将远成对象当本地对象来调用。远成代理通过网络和真正的远成对象沟通信息
同步代理：主要使用在多线程编程中，完成多线程间同步工作

小小竹子

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
设计模式-代理模式

什么是代理模式？ **代理模式的定义：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。**举个例子来说明：假如说我现在想买一辆二手车，虽然我可以自己去找车源，做质量检测等一系列的车辆过户流程，但是这确实太浪费我得时间和精力了。我只是想买一辆车而已为什么我还要额外做这么多事呢？于是我就通过中介公司来买车，他们来给我找车源，帮我办理车辆过户流程，我只是负责选择自己喜欢的车，然后付钱就可以了。为什么要用代理模式？中介隔离作用：在某些情
复制链接

扫一扫

专栏目录