java代理模式

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

　　百度百科《代理模式》

也就是说使用代理对象，是为了在不修改目标对象的基础上，增强主业务逻辑。 

客户类真正的想要访问的对象是目标对象，但客户类真正可以访问的对象是代理对象。客户类对目标对象的访问是通过访问代理对象来实现的。当然，代理类与目标类要实现同一个接口。

例如，有三各类，A,B,C,原本A可以直接访问C，但是因为一些原因C不允许A直接访问，但B可以访问C。A只能通过B来访问C，这就实现了B对C的代理，A通过C的代理类B来访问C并调用其方法

一、静态代理

实现案例：

我们以明星表演为例子，当我们想邀请明星表演要先找到明星代理人，代理人再找明星商量

1.创建明星类接口

public interface Star {
    void show();
}

2.实现明星接口

public class JiaLing implements Star {
    @Override
    public void show() {
        System.out.println("贾玲展示脱口秀");
    }
}

 3.创建代理类，作明星的经纪人对外交涉

public class StarProxy implements Star {
    private Star star;
    public StarProxy(final Star star){
        this.star = star;
    }
    @Override
    public void show() {
        System.out.println("明星展示前请预约");
        star.show();
        System.out.println("明星展示后请支付酬劳");
    }
}

4.编写测试类

public class ProxyTest {
    public static void main(String[] args) {
        Star jiaLing = new JiaLing();
        StarProxy starProxy = new StarProxy(jiaLing);
        starProxy.show();
    }
}

5.运行结果：

 可以看到通过代理类我们并没有访问贾玲的才艺展示方法，但是通过代理人交涉我们确实看到了贾玲的才艺展示，而且在才艺展示的前后都有其他业务相关执行，这就是实现了代理增强

静态代理总结：

优点：我们可以在符合特定逻辑的情况下对目标对象进行功能拓展，实现代理增强

缺点：我们为每一个服务都要创建代理类，工作量太大了，同时接口如果变化，代理类都要跟着修改不易维护和管理。

为了解决以上问题我们有了动态代理的模式

 二、动态代理

在动态代理中我们不再需要手动的一个一个的创建代理类，我们只需要编写一个动态处理器就可以了。真正的代理对象由JDK再运行时为我们动态的来创建。

常见的动态代理有两类：JDK动态代理和CJLIB动态代理

1.JDK动态代理

        1.1编写动态代理处理器 (实现JDK自带的InvocationHandler接口)

public class DynamicProxyHandler implements InvocationHandler {
    private Object object;
    public DynamicProxyHandler(final Object object){
        this.object = object;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("明星展示前请预约");
        Object result = method.invoke(object,args);
        System.out.println("明星展示后请支付酬劳");
        return result;
    }
}

        2.2编写动态代理测试类

public class DynamicProxyTest {
    public static void main(String[] args) {
        Star jiaLing = new JiaLing();
        Star proxyShow = (Star) Proxy.newProxyInstance(Star.class.getClassLoader(),
                new Class[]{Star.class},new DynamicProxyHandler(jiaLing));
        proxyShow.show();
    }
}

注意：Proxy.newProxyInstance()方法接受三个参数：

1.ClassLoader loader ：指定当前目标对象使用的类加载器，获取类加载器的方法是固定的

2.Class<?>[] interface：指定目标对象实现的接口类型，使用泛型方式确定类型

3.InvocationHandler：指定动态处理器，执行目标对象方法时，会触发事件处理器的方法

 

结果：没问题

JDK动态代理总结：

相对于静态代理，JDK动态代理大大减少了我们的开发任务，减少了对业务接口的依赖，降低了耦合度。但其小小的遗憾之处在于始终无法摆脱仅支持interface代理的桎梏。设计如此，它的设计也就注定了这样的遗憾，虽然有遗憾但不可否认它的伟大。

 

2.CJLIB动态代理

 JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要CGLib了。CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。但因为采用的是继承，所以不能对final修饰的类进行代理。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

        2.1创建cjlib代理类：

        (这里实现的接口是MethodInterceptor，是cjlib.jar中的类，所以用cjlib前要导入cjlib的jar包，网上找一找下载下来，如果你的工程是普通项目没有maven等管理还要引入asm.jar才行，否则运行报错)

public class CglibProxy implements MethodInterceptor {
    private Object target;
    public Object getInnstance(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 object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("明显展示前请预约");
        Object result = methodProxy.invoke(object,args);
        System.out.println("明星展示后请支付酬劳");
        return result;
    }
}

         2.2创建cjlib动态代理测试类

public class CglibProxyTest {
    public static void main(String[] args) {
        Star jiaLing = new JiaLing();
        CglibProxy cjlibProxy = new CglibProxy();
        JiaLing starCjlibProxy = (JiaLing) cjlibProxy.getInnstance(jiaLing);
        starCjlibProxy.show();
    }
}

结果：没问题

CJLIB动态代理总结：

CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高，但是CGLIB创建代理对象时所花费的时间却比JDK多得多。所以对于单例的对象，因为无需频繁创建对象，用CGLIB合适，反之使用JDK方式要更为合适一些。同时由于CGLib由于是采用动态创建子类的方法，对于final修饰的方法无法进行代理。