设计模式之代理模式

概念：通过代理对象访问目标对象。

现实意义：1、约见某球星，不能直接见，通过联系其经纪人约见。经纪人就扮演代理的角色。2、通过代理访问墙外网络。

编程中的意义：如果想扩展别人写好的方法，最好不去修改它，而是通过代理来扩展。

好处：在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。

示意图：

代理模式有三种，静态代理、动态代理和CGLib代理。

1、静态代理

最简单的是静态代理，静态代理说明此代理是死的，必须事先实现好。同时代理对象和目标对象必须实现相同的接口。就好比某经纪人只代理足球明星。且同时只能是一个人的代理，要么是C罗，要么是梅西。

接口：

package com.alex.proxyInterface;

public interface Subject {
    void request();
}

目标类：

package com.alex.proxyIMPL;

import com.alex.proxyInterface.Subject;

public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("google 搜索 美女");
    }
}

代理类：

package com.alex.proxyIMPL;

import com.alex.proxyInterface.Subject;

public class ProxySubject implements Subject {
    private Subject subject;

    public ProxySubject(Subject realSubject){
        this.subject = realSubject;
    }
    @Override
    public void request() {
        System.out.println("向服务器代理发出请求");
        subject.request();
        System.out.println("代理服务器响应请求");
    }
}

测试类：

package com.alex;

import com.alex.proxyIMPL.ProxySubject;
import com.alex.proxyIMPL.RealSubject;
import com.alex.proxyInterface.Subject;

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

总结：静态代理实现了代理的基本功能:在不改目标代码的前提下，通过调用相同的方法调用并扩展了目标代码的功能。

缺点：必须与目标对象实现相同的接口。接口的方法一旦增加，目标对象和代理对象都要维护，代理与目标对象耦合性高。

怎么解决？动态代理。

2、动态代理

动态代理，顾名思义，代理类动态生成。如何动态生成？通过反射（Mark，另起一篇文章学习反射）。这样就实现了代理类与接口和目标类的解耦。意味着用这一个代理工厂类就可以做很多事，而不是像静态代理一样需要创建很多的代理类。

接口类和目标类同上。此外需要一个生产代理的工厂类ProxyFactory。

package com.alex.DynamicProxyDemo;

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

public class ProxyFactory {
    private Object target;
    public ProxyFactory(Object object){
        this.target = object;
    }
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("通过代理发起请求");
                Object proxyinstance = method.invoke(target
                        ,args);
                System.out.println("代理请求结束");
                return proxyinstance;
            }
        });
    }
}

测试类：

package com.alex.DynamicProxyDemo;

public class DynamicProxyTest {
    public static void main(String[] args){
        RealSubject target = new RealSubject();
        ISubject myProxy = (ISubject) new ProxyFactory(target).getProxyInstance();
        myProxy.request();
    }
}

3、CGLib代理

动态代理虽然已经很好地与接口和目标实现类解耦。但是只能代理实现接口的类。还有很多未实现接口的类如何代理呢？使用CGLib代理实现。

CGLib与JDK动态代理的主要区别是：CGLib的代理类与目标类是父子关系，而JDK动态代理中是实现相同接口的关系。CGLib通过继承和底层ASM的字节码增强工具Ehancer自动生成代理类。JDK动态代理则通过接口和反射自动生成代理类。是代理模式基于两种不同思想的实现。

目标类：

package com.alex.CGLibProxy;

public class TargetClass {
    public void request(){
        System.out.println("google 搜索 美女");
    }
}

代理工厂类：

package com.alex.CGLibProxy;

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 ProxyFactory implements MethodInterceptor {
    private Object target;
    public ProxyFactory(Object target){
        this.target = target;
    }

    public Object getProxyInstance(){
        Enhancer enhancer = new Enhancer();//字节码增强工具类
        enhancer.setCallback(this);//设置回调函数
        enhancer.setSuperclass(target.getClass());//设置父类
        return enhancer.create();
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("代理请求开始");
        Object instance = method.invoke(target,objects);
        System.out.println("代理请求结束");
        return instance;
    }
}

测试类：

package com.alex.CGLibProxy;

public class CGLibTest {
    public static void main(String[] args){
        TargetClass target = new TargetClass();
        TargetClass proxyClass = (TargetClass) new ProxyFactory(target).getProxyInstance();
        proxyClass.request();
    }
}

注意：

1.代理的类不能为final,否则报错
2.目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法。