Spring基础知识之Aop动态代理

代理模式:

　　代理模式是常用的Java设计模式,它的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息,代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对象关联,代理类的对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提供特定的服务,简单的说就是,我们在访问实际对象时,是通过代理对象来访问的.代理模式就是在访问实际对象时,引入一定程度的间接性,因为这种间接性,可以附加多种用途.

代理模式结构图(图片来自<<大话设计模式>>)

 静态代理:

　　静态代理:由程序员创建或特定工具自动生成源代码,也就是在编译时就已经将接口,被代理类,代理类等确定下来,在程序运行之前,代理类.class文件已经生成.

静态代理简单实现:

　　1.首先创建一个接口,这个接口是代理类和被代理类公共的接口,它们有一个共同的实现方法.

public interface Person {
    // 上交班费
    void giveMoney();
}

　　2.创建两个实现类

public class Student implements Person {
    private String name;
    public Student(String name){
        this.name = name;
    }

    public void giveMoney() {
        System.out.println("student: "+name+" giveMoney");
    }
}

public class StudentProxy implements Person {
    //被代理的学生
    Student student;
    public StudentProxy(Person student){
        // 只代理学生对象
        if(student.getClass() == Student.class){
            this.student = (Student)student;
        }
    }
    // 实现被代理类的方法
    public void giveMoney() {
        student.giveMoney();
    }
}

　　3.测试类

public class Test {
    public static void main(String[] args) {
        //被代理对象
        Person student = new Student("张三");
        //生成代理对象,并将张三传给代理对象
        Person monitor = new StudentProxy(student);
        //代理对象调用方法,间接调用被代理对象的方法
        monitor.giveMoney();
    }
}

　　4.测试结果

 　　这里并没有直接通过张三（被代理对象）来执行上交班费的行为，而是通过班长（代理对象）来代理执行了。这就是代理模式.

　　代理模式最主要的就是有一个公共接口（Person），一个具体的类（Student），一个代理类（StudentsProxy）,代理类持有具体类的实例，代为执行具体类实例方法。上面说到，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。这里的间接性就是指不直接调用实际对象的方法，那么我们在代理过程中就可以加上一些其他用途。

public class StudentProxy implements Person {
    //被代理的学生
    Student student;
    public StudentProxy(Person student){
        // 只代理学生对象
        if(student.getClass() == Student.class){
            this.student = (Student)student;
        }
    }
    // 实现被代理类的方法
    public void giveMoney() {
        System.out.println("在执行被代理类方法之前执行");
        student.giveMoney();
    }
}

　　可以看到，只需要在代理类中执行被代理方法之前，执行其他操作就可以了。这种操作，也是使用代理模式的一个很大的优点。最直白的就是在Spring中的面向切面编程（AOP），我们能在一个切点之前执行一些操作，在一个切点之后执行一些操作，这个切点就是一个个方法。这些方法所在类肯定就是被代理了，在代理过程中切入了一些其他操作。

动态代理:

　　 代理类在程序运行时创建的代理方式被称为动态代理。动态代理，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。

动态代理的实现:

　　在java的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过这个类和这个接口可以生成JDK动态代理类和动态代理对象。

　　1.创建一个接口

public interface Person {
    void giveMoney();
}

　　2.创建一个需要被代理的实际类

public class Student implements Person {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    public void giveMoney() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("student "+name +" giveMoney");
    }
}

　　3定义一个检测方法执行时间的工具类

public class MonitorUtil {
    private static ThreadLocal<Long> t1 = new ThreadLocal<Long>();
    public static void start(){
        t1.set(System.currentTimeMillis());
    }
    //结束打印时耗时
    public static void finish(String methodName){
        long finishTime = System.currentTimeMillis();
        System.out.println(methodName+"方法耗时:"+(finishTime - t1.get())+"ms");
    }
}

　　4.创建StudentInvocationHandler类，实现InvocationHandler接口，这个类中持有一个被代理对象的实例target。InvocationHandler中有一个invoke方法，所有执行代理对象的方法都会被替换成执行invoke方法。再在invoke方法中执行被代理对象target的相应方法.

public class StudentInvocationHandler<T> implements InvocationHandler {
    // invocationHandler持有的被代理对象
    T target;

    public StudentInvocationHandler(T target) {
        this.target = target;
    }

    /**
     *
     * @param proxy 代表动态代理对象
     * @param method 代表正在执行的方法
     * @param args 代表调用目标方法时传入的实参
     * @return
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理执行"+method.getName()+"方法");
        //代理过程插入检测方法,计算方法耗时
        MonitorUtil.start();
        Object result = method.invoke(target,args);
        MonitorUtil.finish(method.getName());
        return result;
    }
}

　　5.创建测试类:

public class Test {
    public static void main(String[] args) {
        //创建一个实例对象,这个对象是被代理的对象
        Person student = new Student("张三");
        //创建一个与代理对象相关联的invocationHandler
        InvocationHandler stuHandler = new StudentInvocationHandler<Person>(student);
        //创建一个代理对象stuProxy来代理student,代理对象的每个执行方法都会替换执行InvocationHandler的invoke()方法
        Person stuProxy = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(),new Class[]{Person.class},stuHandler);
        //代理执行方法
        stuProxy.giveMoney();
    }
}

　　6.上面也有说到所有执行代理对象的方法都会被替换成执行invoke方法，也就是说，最后执行的是StuInvocationHandler中的invoke方法.

 　　7.总结:

　　动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。是因为所有被代理执行的方法，都是通过在InvocationHandler中的invoke方法调用的，所以我们只要在invoke方法中统一处理，就可以对所有被代理的方法进行相同的操作了,动态代理的过程中，我们并没有实际看到代理类，也没有很清晰地的看到代理类的具体样子,因为动态代理中被代理对象和代理对象是通过InvocationHandler来完成的代理过程的

　　Java动态代理只能对接口进行代理，Java的继承机制注定了这些动态代理类们无法实现对class的动态代理。

静态代理和动态代理的区别:

　　静态代理:编译时将增强代码植入class文件,因为是编译期进行的增强,所以代码运行时效率比动态代理高,

　　动态代理:运行时生成代理类并加载,效率比静态代理要低,spring中使用了JDK动态代理和cglib两种动态代理的方式来实现代理类的生成.

CGlib代理:

　　CGLIB(Code Generation Library)是一个开源项目！是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。

　　CGLIB是一个强大的高性能的代码生成包。它广泛的被许多AOP的框架使用，例如Spring AOP为他们提供方法的interception（拦截）。CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。

　　CGLIB是无法代理final修饰的方法的.

CGlib的简单实现:

　　1.创建一个业务类,这个类没有实现任何接口.

public class HelloService {
 
    public HelloService() {
        System.out.println("HelloService构造");
    }
 
    /**
     * 该方法不能被子类覆盖,Cglib是无法代理final修饰的方法的
     */
    final public String sayOthers(String name) {
        System.out.println("HelloService:sayOthers>>"+name);
        return null;
    }
 
    public void sayHello() {
        System.out.println("HelloService:sayHello");
    }
}

　　2.自定义一个MethodInterceptor方法实现MethodInterceptor接口;

public class MyMethodInterceptor implements MethodInterceptor{
 
    /**
     * sub：cglib生成的代理对象
     * method：被代理对象方法
     * objects：方法入参
     * methodProxy: 代理方法
     */
    @Override
    public Object intercept(Object sub, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("======插入前置通知======");
        Object object = methodProxy.invokeSuper(sub, objects);
        System.out.println("======插入后者通知======");
        return object;
    }
}

　　3.测试类:

public class Client {
    public static void main(String[] args) {
        // 代理类class文件存入本地磁盘方便我们反编译查看源码
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\code");
        // 通过CGLIB动态代理获取代理对象的过程
        Enhancer enhancer = new Enhancer();
        // 设置enhancer对象的父类
        enhancer.setSuperclass(HelloService.class);
        // 设置enhancer的回调对象
        enhancer.setCallback(new MyMethodInterceptor());
        // 创建代理对象
        HelloService proxy= (HelloService)enhancer.create();
        // 通过代理对象调用目标方法
        proxy.sayHello();
    }
}

　　4.运行结果:

 　　5.总结:

　　实现CGLIB动态代理必须实现MethodInterceptor(方法拦截器)接口,这个接口只有一个intercept()方法，这个方法有4个参数：

　　1）obj表示增强的对象，即实现这个接口类的一个对象；

　　2）method表示要被拦截的方法；

　　3）args表示要被拦截方法的参数；

　　4）proxy表示要触发父类的方法对象；

　　在上面的Client代码中，通过Enhancer.create()方法创建代理对象
JDK动态代理和CGlib代理的区别:

　　JDK动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理.

　　CGlib动态代理是利用asm开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理.

AOP的实现:

　　1.如果目标对象实现了接口,默认情况下会采用JDK动态代理实现AOP

　　2.如果目标对象实现了接口,可以强制使用CGlib实现AOP,实现方法

　　　　1.添加CGlib库,SPRING_HOME/cglib/*.jar

　　　　2,在spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class="true"/>

　　3.如果目标对象没有实现接口,必须采用CGlib库,Spring会自动在JDK动态代理和CGlib之间转换.