动态代理技术

在学习动态代理之前，需要了解的是一种常用的设计模式--代理模式，而对于代理，根据创建代理类的时间点，又可以分为静态代理和动态代理。

代理模式

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

静态代理

静态代理是由程序员创建或特定工具自动生成源代码，也就是在编译时就已经将接口，被代理类，代理类等确定下来。在程序运行之前，代理类的.class文件就已经生成，缺点是接口与代理类是1v1，有多个接口需要代理，就需要新建多个代理类，比较繁琐。

静态代理的列子

显示方法运行的时间

UserServiceTarget 目标类实现了UserService
TimeHandler 包含了重复代码，间接调用目标
UserServiceProxy 代理类实现了UserService

接口

public interface UserService {
    public void b();
    public void c();
}

委托类实现接口

// 目标类
public class UserServiceTarget implements UserService {

    public void b() {
        System.out.println("b");
    }

    public void c() {
        System.out.println("c");
    }
}

代理类实现接口

// 静态代理 - 自己编码实现的代理类
// 动态代理 - jdk可以在运行期间，动态地生成这个代理类
// proxy 代理 (封装复杂逻辑，它去间接调用 TimeHandler 和 业务代码), 让使用者觉得简单
public class UserServiceProxy implements UserService {

    public void b() {
        try {
            TimeHandler timeHandler = new TimeHandler();
            //得到方法 类名.class.getMethod(方法名)
            Method b = UserServiceTarget.class.getMethod("b");
            //反射调用，传递方法，下面的计算类里就可以调用此方法
            timeHandler.invoke(b);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }

    public void c() {
        try {
            TimeHandler timeHandler = new TimeHandler();
            Method c = UserServiceTarget.class.getMethod("c");
            timeHandler.invoke(c);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}

计算时间的代码

public class TimeHandler {

    private UserServiceTarget userService = new UserServiceTarget();

    //  b() c()
    public void invoke(Method method) {
        System.out.println("==================================");
        long start = System.nanoTime();

        // 调用这个方法 method 
        // 正常调用： 对象.方法名(参数)
        // 反射调用： 方法.invoke(对象, 参数); 
        try {
            //调用 UserServiceTarget 中的方法
            method.invoke(userService);
        } catch (Exception e) {
            e.printStackTrace();
        }
        long end = System.nanoTime();
        System.out.println("花费了： " + (end - start));
    }
}

测试类

public class TestTimeHandler {
    public static void main(String[] args) {
        UserServiceProxy proxy = new UserServiceProxy();
        proxy.b();
        proxy.c();
    }
}

结果

==================================
b
花费了： 201800
==================================
c
花费了： 65691

动态代理（Dynamic Proxy ）

原始编写java 代码的方式是从java文件编译为class文件，然后class文件经过翻译后变为机器语言，而动态代理就是体现了class文件到机器语言这一过程。

原始编写java 代码的方式

.java -> javac -> *.class -> 类加载

动态代理

.class -> 类加载

动态代理例子

显示方法运行的时间

UserServiceTarget 目标类实现了UserService
TestDynamicProxy 包含了计算时间代码，间接调用目标
UserServiceProxy 代理类实现了UserService

接口

public interface UserService {

    public void a(int x, int y);
    public void b();
    public void c();
}

目标类（委托类）

// 目标类
public class UserServiceTarget implements UserService {


    public void a(int x, int y) {
        System.out.println("a");
    }

    public void b() {
        System.out.println("b");
    }

    public void c() {
        System.out.println("c");
    }
}

测试类

import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

// dynamic 动态的
// proxy 代理
public class TestDynamicProxy {

    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        // 1. 生成了类的字节码
        // 参数1 string 表示代理类的名字，随意起
        // 参数2 class[] 表示代理类要实现的接口
        // 返回的结果就是 代理类 的字节码
        byte[] bytes = ProxyGenerator.generateProxyClass("UserServiceProxy2", new Class[]{UserService.class});

        // 2. 执行类加载
        // 类加载的最终结果体现为 Class 类对象, 要借助类加载器
        ClassLoader cl = new ClassLoader() {
            @Override
            protected Class<?> findClass(String name) throws ClassNotFoundException {
                return defineClass(name, bytes, 0, bytes.length);
            }
        };
        Class c = cl.loadClass("UserServiceProxy2"); // 进行类加载, 获得了 UserServiceProxy 类对象

        // 3. 创建代理类实例对象
        // 不能正常创建它的实例对象， new UserServiceProxy2();

        // 获取代理类的构造方法
        Constructor constructor = c.getConstructor(InvocationHandler.class);

        UserServiceTarget target = new UserServiceTarget();
        // 创建实例对象, 强制转换为它的接口类型
        UserService proxy = (UserService)constructor.newInstance(new InvocationHandler() {
            @Override
            // method 就是 a , b, c 等方法对象
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("进入了 invoke");
                long start = System.nanoTime();

                // 方法.invoke(目标, 参数); 通过这行代码调用目标类的方法
                method.invoke(target, args);

                long end = System.nanoTime();
                System.out.println("花费了:" + (end - start));
                return null;
            }
        });

        // 4. 使用代理对象
        proxy.b();
        proxy.c();
        proxy.a(10,20);
    }
}

结果

进入了 invoke
b
花费了:682903
进入了 invoke
c
花费了:233935
进入了 invoke
a
花费了:267017

以上两种代理方法可以看出，静态代理中的方法实现太过繁琐（业务逻辑多），相比之下，动态代理的业务逻辑就简洁多了。

总结

简而言之，动态代理也就是间接的调用委托的方法，并完善方法的过程，这样使代码简洁，并且在编码时，代理逻辑与业务逻辑相互独立，个不影响，没有侵入，没有耦合（耦合也就是一处代码修改，另一处代码也要修改，如果偶合性强，那么修改一处代码时，需要改多处代码，才可以把程序修改完毕，反之则修改处少）。

java--动态代理技术