设计模式——代理模式（Proxy Pattern）

定义：代理模式是指为其他对象提供一个代理，控制对这个对象的访问，保护目标对象，增强对象功能。代理对象在目标对象和客户端之间起中介作用。属于结构型设计模式。

生活中的代理模式：房产中介、快递小哥、黄牛党。

适应场景：当需要保护目标对象，增强目标对象功能时需要用到代理模式。

代理模式的优点：

• 代理模式能将代理对象与真实被调用目标对象分离
• 一定程度上降低了系统的耦合程度，易于扩展
• 代理可以起到保护目标对象，增强目标对象职责的作用

代理模式的缺点：

• 代理会造成系统中类的数量增加
• 在客户端和目标对象之间增加了一个代理对象，请求处理速度变慢
• 增加了系统的复杂度

Spring中应用代理的原则：

• 当Bean有实现接口时，Spring就会用JDK的动态代理
• 当Bean没有实现接口时，Spring就会使用CGLib代理
• Spring可以通过配置强制使用CGLib，只需要在Spring的配置文件中加入以下代码
  <aop:aspectj-autoproxy proxy-target-class="true"/>

静态代理与动态代理的区别：

• 使用静态代理，如果被代理类增加了新的方法，代理类需要同步增加，违背了开闭原则
• 动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则
• 若动态代理需要对目标类的增强逻辑进行扩展，无须修改代理类的代码

静态代理

静态代理，每个被代理的对象都需要一个对应的代理类。如下面例子，张三父亲就是替张三找对象的代理，李四父亲就是替李四找对象的代理，如果王五需要找对象，那么也需要一个人作为他的代理，这样代理类很多。所以需要一个专门做这种事情的人或者行业来代理大家找对象，比如媒婆、红娘、婚恋网之类的代理。所以动态代理因此引入。

public interface IPerson {
    void findLove();
}
public class ZhangSan implements IPerson {
    @Override
    public void findLove() {
        System.out.println("张三找对象：胸大腰细屁股翘");
    }
}
// 张三的父亲就是替张三找对象的代理
public class ZhangSanFather implements IPerson {
    private ZhangSan zhangSan;
    public ZhangSanFather(ZhangSan zhangSan) {
        this.zhangSan = zhangSan;
    }
    @Override
    public void findLove() {
        System.out.println("张三父亲到处打听物色儿媳妇");
        zhangSan.findLove();
        System.out.println("感觉可以，开始交往");
    }
}
public class LiSi implements IPerson {
    @Override
    public void findLove() {
        System.out.println("李四找对象：肤白貌美大长腿");
    }
}
// 李四的父亲就是替李四找对象的代理
public class LiSiFather implements IPerson {
    private LiSi liSi;
    public LiSiFather(LiSi liSi) {
        this.liSi = liSi;
    }
    @Override
    public void findLove() {
        System.out.println("李四父亲到处打听无色儿媳妇");
        liSi.findLove();
        System.out.println("感觉不错开始交往");
    }
}
public class Test {
    public static void main(String[] args) {
        ZhangSanFather zhangSanFather = new ZhangSanFather(new ZhangSan());
        zhangSanFather.findLove();
        LiSiFather liSiFather = new LiSiFather(new LiSi());
        liSiFather.findLove();
    }
}

动态代理

目前现成的动态代理有JDK提供的还有Cglib提供的动态代理组件。

JDK Proxy

public class JdkProxy implements InvocationHandler {
    private IPerson person;
    public IPerson getInstance(IPerson person) {
        this.person = person;
        Class<?> clazz = person.getClass();
        return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object object = method.invoke(this.person, args);
        after();
        return object;
    }
    private void after() { System.out.println("after"); }
    private void before() { System.out.println("before"); }
}

public interface IPerson {
    void findLove();
}
public class ZhangSan implements IPerson {
    @Override
    public void findLove() {System.out.println("张三找对象：胸大腰细屁股翘");}
}
public class LiSi implements IPerson {
    @Override
    public void findLove() {System.out.println("李四找对象：肤白貌美大长腿");    }
}


public class Test {
    public static void main(String[] args) {
        JdkProxy jdkProxy = new JdkProxy();
        IPerson zhangsan = jdkProxy.getInstance(new ZhangSan());
        zhangsan.findLove();
        IPerson lisi = jdkProxy.getInstance(new LiSi());
        lisi.findLove();
    }
}

Cglib Proxy

maven依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib-nodep</artifactId>
    <version>2.2</version>
</dependency>

public class CglibProxy implements MethodInterceptor {
    public Object getInstance(Class<?> clazz) {
        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 object = methodProxy.invokeSuper(o, objects);
        after();
        return object;
    }
    private void after() { }
    private void before() { }
}

public interface IPerson {
    void findLove();
}
public class ZhangSan implements IPerson {
    @Override
    public void findLove() {System.out.println("张三找对象：胸大腰细屁股翘");}
}
public class LiSi implements IPerson {
    @Override
    public void findLove() {System.out.println("李四找对象：肤白貌美大长腿");}
}


public class Test {
    public static void main(String[] args) {
        ZhangSan zhangSan = (ZhangSan) new CglibProxy().getInstance(ZhangSan.class);
        zhangSan.findLove();
    }
}

面试题

JDK proxy和Cglib proxy的区别：

• JDK实现被代理对象的接口，读取接口的信息，必须要求代理目标实现一个接口
  Cglib采用继承的方式，覆盖父类方法
• 思想都是通过生成字节码，生成一个新类，去实现增强代码逻辑的功能
• JDK proxy对于用户而言，依赖性更强，必须要有一个接口实现，调用相对复杂
  Cglib对目标类没有任何要求，但是不能代理final修饰的方法
• Cglib生成代理逻辑复杂，但是调用效率高，性能也高，底层没有用到反射
  JDK proxy生成代理逻辑简单，执行效率较低，每次都要反射动态调用

静态代理和动态代理？

静态代理，一个代理只能服务一个类型的对象，当有n个业务，需要n个静态代理类，不利于业务扩展，代理类很多；

而动态代理，一个代理类可以服务所有业务对象，通过切面来实现；

动态代理的实现？

JDK动态代理，拿到被代理类的引用，获取它的所有接口，反射获取；

JDK Proxy重新生成一个新的类，实现了被代理类的所有方法；

动态生成Java代码，把增强逻辑加入到新生成代码中；

编译生成新的Java代码的class文件；

加载并重新运行新的class，得到类就是全新类；