帮我们找房租房买房的代理模式

前言

大家好，看到这个标题大家应该想到了是中介，中介可以帮我们租房找房买房办手续等等，让我们在整个租房买房过程中轻松很多。生活中还有售票黄牛、婚介、经纪人、快递、事务代理、非侵入式日志监听等，都是代理模式的实际体现。

代理模式（Proxy Pattern）是指为其他对象提供一种代理，以控制对这个对象的访问，属于结构型模式。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之前起到中介的作用。

通用UML类图：

使用代理模式主要有两个目的：一是保护目标对象，二是增强目标对象。代理模式分为静态代理和动态代理，下面我们来分别看下。

静态代理

就拿中介来举例子，创建顶层接口IPerson。

public interface IPerson {
    void findHouse();
}

张三要租房了，实现IPerson接口，创建ZhangSan类。

public class ZhangSan implements IPerson {
    @Override
    public void findHouse() {
        System.out.println("张三要求：离地铁站近、面积大");
    }
}

但是张三初来乍到，对当地不熟悉，需要中介来帮他找，创建一个中介类HouseProxy，同样实现IPerson接口。这里面需要把张三对象传进来，然后中介帮他找房。

public class HouseProxy implements IPerson {

    private ZhangSan zhangsan;

    public HouseProxy(ZhangSan zhangsan) {
        this.zhangsan = zhangsan;
    }

    @Override
    public void findHouse() {
        System.out.println("中介开始帮你找房");
        zhangsan.findHouse();
        System.out.println("成功找到啦");
    }
}

写个测试类测试一下

    public static void main(String[] args) {
        HouseProxy proxy = new HouseProxy(new ZhangSan());
        proxy.findHouse();
    }

运行结果如下图：

静态代理的应用我们每天都在用，小伙伴在写service层的时候，会把dao层给注入进来，就像这样一样，其实这个就是静态代理。

public class Service{

    @Autowired
    private OrderDAO dao;
    
    public void insertOrder() {
        //处理业务逻辑
        ...
        dao.insertOrder();
        //处理业务逻辑
        ...
    }
}

静态代理有缺点：

（1）代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。

（2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法，违背了开闭原则。

动态代理

基于上面的问题就出现了动态代理，动态代理的底层实现一般不用我们自己亲自去实现，已经有很多现成的API。在Java生态中，目前最普遍使用的是JDK自带的代理和Cglib提供的类库。下面我们来分别演示一下写法。

JDK动态代理

首先创建一个中介类JDKIntermediary：

public class JDKIntermediary implements InvocationHandler {

    private IPerson target;

    public IPerson getInstance(IPerson target) {
        this.target = target;
        Class<?> clazz = target.getClass();
        return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(this.target, args);
        after();
        return result;
    }

    private void before() {
        System.out.println("我是中介，我要开始给你找房了");
    }

    private void after() {
        System.out.println("成功找到啦..");
    }

}

再创建一个李四类：

public class LiSi implements IPerson {

    @Override
    public void findHouse() {
        System.out.println("李四要求：便宜");
    }

}

测试代码如下：

    public static void main(String[] args) {
        JDKIntermediary intermediary = new JDKIntermediary();
        IPerson zhangsan = intermediary.getInstance(new ZhangSan());
        zhangsan.findHouse();

        IPerson lisi = intermediary.getInstance(new LiSi());
        lisi.findHouse();
    }

运行结果如下：

CGLib

还是以中介为例，创建CGlibIntermediary类：

public class CGlibIntermediary implements MethodInterceptor {

    public Object getInstance(Class<?> clazz) {
        //相当于Proxy，代理的工具类
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object obj = methodProxy.invokeSuper(o, objects);
        after();
        return obj;
    }

    private void before() {
        System.out.println("我是中介，我要开始给你找房了");
    }

    private void after() {
        System.out.println("成功找到啦..");
    }

}

创建一个客户类Customer：

public class Customer {

    public void zufang() {
        System.out.println("找一个预算两千的房子");
    }

}

有一个小细节，CGLib代理的目标对象不需要实现任何接口，它是通过动态继承目标对象实现动态代理的。来看测试代码：

    public static void main(String[] args) {
        Customer obj = (Customer) new CGlibIntermediary().getInstance(Customer.class);
        obj.zufang();
    }

执行结果：

动态代理在Spring中的应用

大家知道在Spring中事务的底层是AOP，而AOP的底层用的就是动态代理，这里有两个重要的类 JdkDynamicAopProxy 和 CglibAopProxy，它们的类图如下：

Spring中使用代理的原则是：

• 当Bean有实现接口时，Spring就会用JDK动态代理
• 当Bean没有实现接口时，Spring会选择CGLib代理
• Spring可以通过配置强制使用CGLib代理，只需要在Spring的配置文件中加入如下代码：

<aop:aspectj-autoproxy proxy-target-class="true"/>

JDK和CGLib动态代理对比

（1）JDK动态代理实现了被代理对象的接口，CGLib代理继承了被代理对象。

（2）JDK动态代理和CGLib代理都在运行期生成字节码文件，JDK动态代理直接写Class字节码，CGLib代理使用ASM框架写Class字节码，CGLib代理实现更复杂，生成代理类比JDK动态代理效率低。

（3）JDK动态代理调用代理代理方法是通过反射机制调用的，CGLib代理是通过FastClass机制直接调用方法的，CGLib代理的执行效率更高。

代理模式的优缺点

最后说下代码模式的优缺点，优点：

• 代理模式能将代理对象与真实被调用目标对象分离。
• 在一定程度上降低了系统的耦合性，扩展性好。
• 可以起到保护目标对象的功能。
• 可以增强目标对象的功能。
  缺点：
• 代理模式会造成系统设计中类的数量增加。
• 在客户端和目标对象中增加一个代理对象，会导致请求速度变慢。
• 增加了系统复杂度。
  本文及其他设计模式的源码在此链接下，https://github.com/xuhaoj/pattern-demo ，谢谢大家的观看，如果觉得不错，请点一个赞！