代理模式

给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。

使用代理模式的优点：

可以实现中介隔离，客户类可以使用代理对象在客户类和委托对象之间起到中介的作用（代理类和委托类实现相同接口）。遵循开闭原则，可以通过代理类扩展委托类的功能。

静态代理：

服务类接口：

public interface OriginService {

    String doSomeThing();
}

委托类：

public class OriginWorker implements OriginService {

    @Override
    public String doSomeThing() {
        System.out.println("do something");
        return "i am origin worker";
    }
}

代理类：

public class OriginWorkerProxy implements OriginService{

    private OriginService originService;

    public OriginWorkerProxy(OriginService originService) {
        this.originService = originService;
    }

    @Override
    public String doSomeThing() {
        System.out.println("pre");
        return originService.doSomeThing();
    }
}

测试方法：

public class Main {

    public static void main(String[] args) {
        OriginWorker originWorker = new OriginWorker();
        OriginWorkerProxy originWorkerProxy = new OriginWorkerProxy(originWorker);
        originWorkerProxy.doSomeThing();
    }
}

可以实现编程阶段对类的功能进行扩展，但是使用的时候需要创建代理类，不易管理，接口改变，代理类也需要变动。

动态代理：（JDK、CGLIB）

JDK动态代理：

动态代理类：

public class DynamicProxyHandler implements InvocationHandler {

    private Object object;

    public DynamicProxyHandler(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("pre");
        Object result = method.invoke(object, args);
        System.out.println("after");
        return result;
    }
}

测试类：

public class DynamicProxyMain {

    public static void main(String[] args) {
        OriginService originWorker = new OriginWorker();
        OriginService proxy = (OriginService) Proxy
                .newProxyInstance(OriginService.class.getClassLoader(), new Class[] { OriginService.class }, new DynamicProxyHandler(originWorker));
        proxy.doSomeThing();
    }
}

jdk动态代理需要委托类实现接口才可以。

CGLIB：

代理类：

public class CglibProxy implements MethodInterceptor {

    private Object target;

    public Object getInstance(final Object object) {
        this.target = object;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("pre");
        Object result = methodProxy.invoke(target, objects);
        System.out.println("after");
        return result;
    }
}

测试类：

public class CglibDynamicMain {

    public static void main(String[] args) {
        OriginWorker originWorker = new OriginWorker();
        CglibProxy cglibProxy = new CglibProxy();
        OriginWorker workerProxy = (OriginWorker) cglibProxy.getInstance(originWorker);
        workerProxy.doSomeThing();
    }
}

Cglib根据委托类动态生成一个子类，代理委托类，所以不可以代理final修饰的类。Cglib可以代理没有实现接口的类。