1. 代理模式

1.1 介绍

**代理模式的作用是为某对象提供一种代理以控制对该对象的访问。**即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。

由于静态代理会导致类文件大量增多，所以 Java 中动态代理使用的较多。

代理模式的类型：

远程代理：将工作委托给远程对象来完成
保护代理
缓存代理：这个很好理解，就是通过存储来加速调用，
虚拟代理：这种代理主要是为方法增加功能，比如记录一些性能指标等，或进行延迟初始化

1.2 优缺点

优点

职责清晰
高扩展性
智能化

缺点

由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。2.实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

1.3 使用场景

按职责来划分，通常有以下使用场景： 1、远程代理。 2、虚拟代理。 3、Copy-on-Write 代理。 4、保护（Protect or Access）代理。 5、Cache代理。 6、防火墙（Firewall）代理。 7、同步化（Synchronization）代理。 8、智能引用（Smart Reference）代理。

1.4 注意事项

和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。
和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。
和外观模式的区别：**外观模式是为了对外界屏蔽内部细节，代理模式是为了访问或控制访问。**代理模式类似于正向代理，而外观模式类似于反向代理。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6UHBRagy-1630428233542)(…/…/images/设计模式代理模式uml图.jpg)]

2. 案例代码

现在，我的娃娃机试用期过了，现在要收费了，想要不同的娃娃需要支付对应的金钱，当给钱越多时，给出的娃娃越好越漂亮。

// 布娃娃类
public class Ragdoll {
   
    public String getName(){
   
        return "xx";
    };
    
    public  static Ragdoll getRagdoll(String ragdollName){
   
        if(ragdollName == "太平公主"){
   
            return new ragdoll_1();
        }else if(ragdollName == "白雪公主"){
   
            return new ragdoll_2();
        }else if(ragdollName == "铁扇公主"){
   
            return new ragdoll_3();
        }
        
        return new ragdoll_1();
    }
}

class ragdoll_1 extends Ragdoll{
   
    public String getName(){
   
        return "太平公主";
    }
}

class ragdoll_2 extends Ragdoll{
   
    public String getName(){
   
        return "白学公主";
    }
}

class ragdoll_3 extends Ragdoll{
   
    public String getName(){
   
        return "铁扇公主";
    }
}

// 负责给我我想要的娃娃
public class CraneMachine {
   
    public static Ragdoll getRagdoll(int money){
   
        if(money < 20){
    // 限流
            System.out.println("钱不够，请凑够钱再来");
            return null;
        }else if(money < 100){
     // 反向代理
            System.out.println("找到某个小工厂，生产了一个普通娃娃");
            return Ragdoll.getRagdoll("白雪公主");
        }else if(money < 200){
   
            System.out.println("找到某个大工厂，生产了一个高级娃娃");
            return Ragdoll.getRagdoll("太平公主");
        }else if(money < 300){
   
            System.out.println("找到某个大工厂，生产了一个高级娃娃,还给娃娃穿上了衣服");
            return Ragdoll.getRagdoll("铁扇公主");
        }
        return null;
    }
}

/** * 代理模式 * *@Author cly *@Date 2021/08/31 15:31 *@Version 1.0 */
public class Proxy {
   
    public static void main(String[] args) {
   
        Ragdoll ragdoll = CraneMachine.getRagdoll(250);
        System.out.println("你的娃娃是:"+ragdoll.getName());
    }
}

**静态代理需要为每一个对象都创建一个代理类，增加了维护成本以及开发成本，**那么为了解决这个问题，动态代理就出来了，动态代理不要再固定为每一个需要代理的类而创建一个代理类

2.2 动态代理

动态代理合理的避免了静态代理的那种方式，不用事先为要代理的类而构建好代理类。而是在运行时通过反射机制创建。

在写动态代理事需要理解两个东西：Proxy 可以理解为就是调度器，InvocationHandler 增强服务接口可以理解为代理器。所以我个人理解动态代理其实就是一种行为的监听。

2.2.1 jdk的动态代理

java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来增强处理。

package com.cly.designPattern.proxyPattern;

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

interface BaseService {
   
    void mainService();
}

class Cicada implements BaseService {
   
    @Override
    public void mainService() {
   
        System.out.println("主要业务，以蝉为例，当蝉出现业务调用时，螳螂监听到");
    }
}

class PrayingMantis implements InvocationHandler {
   

    private BaseService baseService;
    // 这里采用的是构建传参数，可以用反射，举的第一个例子有样式代码
    public PrayingMantis(BaseService baseService) {
   
        this.baseService = baseService;
    }

    // 螳螂主要业务，也就是监听对象
    @Override
    public Object invoke(Object listener, Method method, Object[] args) throws Throwable {
   
        method.invoke(baseService,args);
        secondaryMain();	// 增强处理
        return null;
    }
    // 这里理解增强业务，即我们可以在实现InvocationHandler里面添加其他的业务，比如日志等等。
    private void secondaryMain(){
   
        System.out.println("螳螂捕蝉 - 次要业务");
    }
}

public class Test_2 {
   

    public static BaseService newInstanc(Class classFile) {
   
        // 1. 创建蝉，真实类对象
        BaseService trueCicada = new Cicada();
        // 2.创建代理类 螳螂
        InvocationHandler prayingMantis = new PrayingMantis(trueCicada);
        // 3.向Jvm索要代理对象 其实就是监听的对象，
        Class classArray[] = {
   BaseService.class};
        BaseService baseService = (BaseService) Proxy.newProxyInstance(classFile.getClassLoader(), classArray, prayingMantis);
        return baseService;
    }

    // 测试Demo
    public static void main(String[] args) {
   
        BaseService baseService  = newInstanc(Cicada.class);
        baseService.mainService();
        // 测试结果 ：主要业务
        // 螳螂捕蝉 - 次要业务
    }
}

2.2.2 cglib动态代理

我们了解到，“代理”的目的是构造一个和被代理的对象有同样行为的对象，一个对象的行为是在类中定义的，对象只是类的实例。所以构造代理，不一定非得通过持有、包装对象这一种方式。上面的jdk动态代理就是此方向的，而cglib动态代理则是通过继承实现的

class CglibProxy implements MethodInterceptor {
   
    private Object target;

    @Override
    public Object intercept(Object o, Method method, Object[] arr, MethodProxy methodProxy) throws Throwable {
   
        System.out.println("Cglib动态代理，监听开始！");
        Object invoke = method.invoke(target, arr);//方法执行，参数：target 目标对象 arr参数数组
        System.out.println("Cglib动态代理，监听结束！");
        return invoke;
    }

    public Object getCglibProxy(Object objectTarget){
   
        //为目标对象target赋值
        this.target = objectTarget;
        Enhancer enhancer = new Enhancer();
        //设置父类,因为Cglib是针对指定的类生成一个子类，所以需要指定父类
        enhancer.setSuperclass(objectTarget.getClass());
        enhancer.setCallback(this);// 设置回调 
        Object result = enhancer.create();//创建并返回代理对象
        return result;
    }
}
public class Test_3 {
   
    public static void main(String[] args) {
   
        CglibProxy proxy = new CglibProxy();
        BaseService cglibProxy = (BaseService) proxy.getCglibProxy(new Cicada());
        cglibProxy.mainService();
    }
}

2.2.3 jdk动态代理和cglib动态代理的对比

CGLib所创建的动态代理对象在实际运行时候的性能要比JDK动态代理高不少，有研究表明，大概要高10倍；
但是CGLib在创建对象的时候所花费的时间却比JDK动态代理要多很多，有研究表明，大概有8倍的差距；
因此，对于singleton的代理对象或者具有实例池的代理，因为无需频繁的创建代理对象，所以比较适合采用CGLib动态代理，反正，则比较适用JDK动态代理。
spring默认使用jdk动态代理，如果类没有接口，则使用cglib。
由于CGLIB的大部分类是直接对Java字节码进行操作，这样生成的类会在Java的永久堆中，因此可能产生永久堆满，触发内存溢出

3. 源码实现

3.1 JDK动态代理

JDK 中的动态代理的使用，实现 InvocationHandler 接口，只能代理接口的实现类

代理模式~

文章目录