关于 JAVA的代理 静态代理 动态代理 cglib 的学习

想到之前学习spring的时候,了解有aop面向切面编程的知识点，但自己却一直没有深刻去理解,今天学习了一下，发现和动态代理有关，然后就在网上一顿搜索，自己对代理的相关知识又清晰了不少。

一.代理模式：是JAVA常用的一种设计模式。

特征：

1.代理类与委托类有同样的接口。

2.代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类,以及事后处理消息等。

3.代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。 

分类方法：按照代理的创建时期分类。 

1.静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。 
2.动态代理：在程序运行时，运用反射机制动态创建而成。 

二.静态代理(代码示例):

1.接口类：

public interface Skill {

    public void program();

    public void translate();

}

2.具体业务实现类：

public class SkillImpl implements Skill {


    @Override
    public void program() {
        System.out.println("I use JAVA  \n");
    }

    @Override
    public void translate() {
        System.out.println("I am good at French \n");
    }
}

3.代理类:

public class SkillProxy  implements  Skill{

    private SkillImpl skillImpl;


    public SkillProxy(SkillImpl skillImpl) {
        this.skillImpl = skillImpl;
    }


    @Override
    public void program() {
        System.out.println("发生动作之前 program \n");
        skillImpl.program();
        System.out.println("发生动作之后 program \n");
    }

    @Override
    public void translate() {

        System.out.println("发生动作之前 translate \n");
        skillImpl.translate();
        System.out.println("发生动作之后 translate \n");

    }
}

4.调用类：

public class Test {

    public static void main(String[] args) {

        SkillImpl skillImpl =new SkillImpl();
        SkillProxy skillProxy=new SkillProxy(skillImpl);
        skillProxy.program();
        skillProxy.translate();
    }

}

5.运行结果：

6.分析：一个代理过程完成了，但再一想，这么一个代理类只能为一个接口服务，心里面不太开心啊。同样的JAVA创作者肯定也想到了，动动手指，给了我们动态代理的方法。这样就能解决一个代理类只能代理一个接口的和代码重复的问题。下面让我们启程动态代理之旅。

三.动态代理(JDK动态代理)：与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。

1.接口类(沿用上文的 Skill )：

public interface Mode {

    public void open();

    public  void close();

}

2.接口实现类(沿用上文的SKillImpl）：

public class ModeImpl implements Mode{



    @Override
    public void open() {

        System.out.println("以牺牲硬盘生命力模式快速开机");

    }

    @Override
    public void close() {

        System.out.println("直接断电关机");

    }

}

3.动态代理类（主角）：

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

public class DynamicProxy implements InvocationHandler{

    private Object target;

    public Object band(Object target) {
        this.target = target;

        //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        Object result=null;

        System.out.println("执行之前");

        result=method.invoke(target,args);

        System.out.println("执行之后");

        return result;
    }

}

4.调用类：

public class Test {

    public static void main(String[] args) {

        DynamicProxy dynamicProxy=new DynamicProxy();

        
        Skill skill = (Skill) dynamicProxy.band(new SkillImpl());

        skill.translate();
        skill.program();
        
        Mode mode=(Mode) dynamicProxy.band(new ModeImpl());
        mode.open();
        mode.close();
      //两次代理不同的几口只需要一个代理类

    }




}

5.运行结果：

6.分析：JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用下面的cglib动态代理了。 

四.动态代理(cglib动态代理)：对没有实现接口且没有final修饰的类我们采用的动态代理方式。

当时获取的cglib：

compile group: 'cglib', name: 'cglib', version: '3.2.5'

1.一般类：

public class Car {

    public void speedup(){

        System.out.println("我真正在加速！！");

    }


}

2.实现 MenthodInterceptor接口的类

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 ProxyCglib implements MethodInterceptor {
    private Object target;


    public Object getProxyInstance(Object target) {

        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("方法执行之前");
        proxy.invokeSuper(obj,args);
        System.out.println("方法执行之后");
        return null;
    }
}

3.调用类：

public class Test {

    public static void main(String[] args) {


        ProxyCglib proxyCglib=new ProxyCglib();
        Car proxycar=(Car) proxyCglib.getProxyInstance(new Car());
        proxycar.speedup();


    }


}

4.运行结果：

五.辅助知识:

JDK动态代理中包含一个类和一个接口： 
InvocationHandler接口： 
public interface InvocationHandler { 
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; 
} 
参数说明： 
Object proxy：指被代理的对象。 
Method method：要调用的方法 
Object[] args：方法调用时所需要的参数 


可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。 


Proxy类： 
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法： 
public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, 
InvocationHandler h) 
                               throws IllegalArgumentException 
参数说明： 
ClassLoader loader：类加载器 
Class[] interfaces：得到全部的接口 
InvocationHandler h：得到InvocationHandler接口的子类实例 


Ps:类加载器 
在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器; 
Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的； 
Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类; 
AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。