结构型模式--代理模式【Proxy Pattern】

叁歲伎倆 2022-05-28 02:13 187阅读 0赞

## 代理模式 ##

>  *  给某一个对象提供一个代理，并由代理对象控制对原对象的引用。
>  *  为其他对象提供一种代理以控制对这个对象的访问。

### 分类 ###

*  远程代理：为不同地理的对象提供局域网代表对象（例子：通过远程代理可以监控各个店铺，使之可以直观的了解店里的情况）
 *  虚拟代理：根据需要将资源消耗很大的对象进行延迟，真正需要的时候进行创建 (类似于新闻网站加载时，图片加载不出来先用一张空的图片代替)
 *  保护代理：控制用户的访问权限
 *  智能引用代理：提供对目标对象提供额外的服务（火车票代售处）

### 代理模式的实现方式 ###

*  静态代理
 *  动态代理

### 代理模式应用场合 ###

> 系统启动时的延迟加载  
> 远程调用的网络代理  
> 考虑安全因素的安全代理  
> Spring AOP  
> C3P0数据库连接池

### 类图 ###

![这里写图片描述][70]

*  Subject接口的实现

public interface Subject { 
      public void visit();
    }

*  实现了Subject接口的两个类：

public class RealSubject implements Subject { 
    
        private String name = "tianming";
        
        @Override
        public void visit() { 
            System.out.println(name);
        }
    }
    
    public class ProxySubject implements Subject{ 
    
        private Subject subject;
    
        public ProxySubject(Subject subject) { 
            this.subject = subject;
        }
    
        @Override
        public void visit() { 
            subject.visit();
        }
    }

*  具体的调用如下

public class TestProxyPattern { 
    
        public static void main(String[] args) { 
            ProxySubject subject = new ProxySubject(new RealSubject());
            subject.visit();
        }
    }

### 动态代理 ###

Spring AOP的底层使用了两种代理机制

>  *  JDK 的动态代理：针对实现了接口的类产生代理。
>  *  CGlib 的动态代理：针对没有实现接口的类产生代理，应用的是底层的字节码增强的技术 生成当前类的子类对象

动态代理有别于静态代理，是根据代理的对象，动态创建代理类。这样，就可以避免静态代理中代理类接口过多的问题。动态代理的实现方式，是通过反射来实现的，借助Java自带的*java.lang.reflect.Proxy*,通过固定的规则生成【基于JDK的动态代理】。

其步骤如下：

1.  编写一个委托类的接口，即静态代理的（Subject接口）
2.  实现一个真正的委托类，即静态代理的（RealSubject类）
3.  创建一个动态代理类，实现*java.lang.reflect.InvocationHandler*接口，并重写该invoke方法
4.  在测试类中，生成动态代理的对象。

第一二步骤，和静态代理一样，不过说了。第三步，代码如下：

public class DynamicProxy implements InvocationHandler { 
        private Object object;
        public DynamicProxy(Object object) { 
            this.object = object;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            System.out.println(">>>>before invoking");
            Object result = method.invoke(this.object, args);
            System.out.println(">>>>after invoking");
            return result;
        }
        
        // 返回一个被修改过的对象
        public static Object agent(Class interfaceClazz, Object proxy) { 
            return Proxy.newProxyInstance(interfaceClazz.getClassLoader(), new Class[]{ interfaceClazz},
                    new DynamicProxy(proxy));
        }
    }

第四步，创建动态代理的对象

//注意一定要返回接口，不能返回实现类否则会报错
    Subject subject = (Subject) DynamicProxy.agent(Subject.class, new RealSubject());
    subject.visit();

创建动态代理的对象，需要借助*Proxy.newProxyInstance*。该方法的三个参数分别是：

1.  ClassLoader loader表示当前使用到的classloader。
2.  Class<?>\[\] interfaces表示目标对象实现的一组接口。
3.  InvocationHandler h表示当前的InvocationHandler实现实例对象。

> **可以看到对于不同的实现类来说，可以用同一个动态代理类来进行代理，实现了“一次编写到处代理”的效果。但是这种方法有个缺点，就是被代理的类一定要是实现了某个接口的，这很大程度限制了本方法的使用场景。**

## 框架应用 ##

*  [MyBatis之MapperMethod][MyBatis_MapperMethod]

--------------------

参考文档：

1.  https://www.cnblogs.com/qifengshi/p/6566752.html
2.  https://www.cnblogs.com/puyangsky/p/6218925.html

[70]: /images/20220528/20cf20fa3b234457be3a3eba89604baf.png
[MyBatis_MapperMethod]: https://blog.csdn.net/thebigdipperbdx/article/details/83051361