Proxy

简介

代理模式的定义：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

静态代理

创建接口

interface Factory{
    void Product();
}

创建被代理类

//被代理类
class Nike implements  Factory{

    @Override
    public void Product() {
        System.out.println("生产NIKE产品");
    }
}

//代理类，用于增强方法
class ProxyFactory implements Factory{

    private Factory factory;

    public ProxyFactory(Factory factory) {
        this.factory = factory;
    }
    @Override
    public void Product() {
        System.out.println("准备一些生产NIKE产品的材料");
        factory.Product(); //调用的是被代理类的方法
        System.out.println("处理一下生产后的事情");
    }
}

测试

public class Test1 {
    @org.junit.Test
    public void test1(){
        NikeFactory nikeFactory = new NikeFactory();
        ProxyFactory proxyFactory = new ProxyFactory(nikeFactory);
        proxyFactory.Product();
    }
}

缺点：静态代理时，每一个被代理类都需要各自创建一个代理类

动态代理

创建接口

interface NewFactory{
    void Product();
}

创建被代理类

class LiNing implements NewFactory{

    @Override
    public void Product() {
        System.out.println("生产LiNing产品");
    }
}

创建一个类用来生成代理对象

class ProxyFactory2{
    //根据被代理类获取代理类
    public static Object getProxyFactory(Object obj){
        MyInvocationHandler handler = new MyInvocationHandler(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }
}
class MyInvocationHandler implements InvocationHandler{
    private Object obj; //被代理类对象

    public MyInvocationHandler(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始准备工作");
        Object invoke = method.invoke(obj, args);  //调用被代理类obj中的方法
        System.out.println("开始结束工作");
        return invoke;
    }
}

测试

public class Test2 {
    public static void main(String[] args) {
        LiNing liNing = new LiNing();
        NewFactory proxyFactory = (NewFactory) ProxyFactory2.getProxyFactory(liNing); //获取被代理类
        proxyFactory.Product();

        Nike nike = new Nike();
        Factory proxyFactory1 = (Factory) ProxyFactory2.getProxyFactory(nike);
        proxyFactory1.Product();

    }
}

cglib代理

创建代理工厂

public class CglibProxyFactory {
    public static Object getProxyInstance(MyMethodInterceptor myMethodInterceptor,Class clazz ){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(myMethodInterceptor);
        Object o = enhancer.create();
        return o;
    }
}

MyMethodInterceptor

public class MyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("开始准备工作");
        Object o1 = methodProxy.invokeSuper(o, objects);
        System.out.println("开始结束工作");
        return o1;
    }
}

测试

MyMethodInterceptor myMethodInterceptor = new MyMethodInterceptor();
Nike proxyInstance = (Nike) CglibProxyFactory.getProxyInstance(myMethodInterceptor,nike.getClass());
proxyInstance.Product();

总结

代理模式就是为了增强方法，其中JDK代理和Cglib动态代理的区别如下：

• 如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
• 如果目标对象实现了接口，可以强制使用CGLIB实现AOP
  就是说，JDK代理只能代理那些有接口的，通过实现同一个接口实现，而CGLIB则是通过继承被代理类来生成代理对象。