JDK中的动态代理

一、概述

我们都知道实现代理的两种方式，一种是静态代理，一种是动态代理，我们都知道静态代理有一个很大的缺点扩展性不好，当需求发生变化的时候，我们就需要写很多的代理类，也就是因为这个原因，动态代理就应运而生了。动态代理的的使用还是非常广泛的，比如 spring 框架中，移动端的 Retrofit 框架，都运用了动态代理，就是因为运用了动态代理，使我们的代码简洁了很多。那么怎样去实现动态代理，其实实现动态代理常见的方法有两种，一种是 JDK 提供的实现，一种是通过 cjlib 实现，那本篇文章主要讲的是通过 JDK 提供的方法实现动态代理。

二、步骤

JDK 实现代理模式需要 4 步：

1、创建被代理的类，以及接口

2、创建一个实现 InvocationHandle 的类，这个类必须实现 invoke 方法

3、调用 Porxy.newProxyInstance 方法生成代理类

4、通过上一步生成的代理类调用被代理类的方法，实现代理

那我们一步一步进行，首先我们先创建一个接口和一个被代理的类

public interface UserServiceInterface {

    public void getUserName(int id);

    public void getAge(int id);

}

下面创建一个被代理的类：

public class UserServiceImpl implements UserServiceInterface{
    @Override
    public void getUserName(int id) {
        System.out.println("我的名字是小明");
    }

    @Override
    public void getAge(int id) {
        System.out.println("小明的年龄为11");
    }
}

加入我们想在查询名字方法之前输入从哪个表查询的，在查询之后我们需要把这个结果告诉老师，那么我们就需要代理 UserServiceImpl ,然后在他的方法前和方法后加入逻辑

所以我们需要使用 proxy 生成一个代理类，然后这个代理类需要通过 invocationhandler 插入代码，那我们先编写一下 invocationhandler 的代码：

/**
 * Created by andya on 2017/12/13.
 */
public class InvocationHandlerTest implements InvocationHandler{


    private Object target;

    public InvocationHandlerTest(Object target){
        super();
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if("getUserName".equals(method.getName())){
            //处理被代理对象之前的业务逻辑
            System.out.println("我们将通过urser表查询小明");
            method.invoke(target,args);                //调用被代理对象的方法
            //处理代理对象被代理之后的业务逻辑
            System.out.println("小明的名字将告诉老师");
            return null;
        }else if("getAge".equals(method.getName())){
            //处理被代理对象之前的业务逻辑
            System.out.println("我们将通过urser表查询小明年龄");
            method.invoke(target,args);               //调用被代理对象的方法
            //处理代理对象被代理之后的业务逻辑
            System.out.println("小明的年龄将告诉老师");
            return null;
        }else {
            return null;
        }
    }
}

上面的代码首先是一个构造方法，这个构造方法中传递的就是被代理的对象，第二个方法就比较重要了，我们先看一下这个方法中的参数，第一个参数 proxy 是我们生成的代理对象的实例，第二个参数里面包含了我们代理方法的一些参数，第三个参数表示我们代理方法被调用的时候接收的参数。

上面第二步已经实现了，下面我们看一下第三步和第四步的实现：

public class Main {

    public static void main(String[] args){
        UserServiceImpl userService = new UserServiceImpl();
        InvocationHandlerTest invocationHandlerTest = new InvocationHandlerTest(userService);   //传递一个被代理对象到 invocationhandler
        UserServiceInterface userServiceInterface = (UserServiceInterface) Proxy.newProxyInstance(UserServiceInterface.class.getClassLoader(),   
                new Class<?>[] { UserServiceInterface.class },invocationHandlerTest);      //生成代理类
        userServiceInterface.getAge(1);            //调用被代理对象的方法
        userServiceInterface.getUserName(1);
    }
}

上面的注释已经很清楚了，下面我们看一下运行结果：

可以看到我们插入的功能已经实现了。这样我们通过 JDK  实现动态代理就完成了。

三、实现方式

当我看到这个运行结果的时候很疑惑，为什么他可以实现这种功能，其实如果你看了他生成的 class 就会觉得很简单，我们看一下他生

public final class ProxySubject extends Proxy
        implements Subject
{
    private static Method m1;
    private static Method m0;
    private static Method m3;
    private static Method m2;
    private static Method m4;
    public ProxySubject(InvocationHandler invocationhandler)
    {
        super(invocationhandler);
    }
    public final boolean equals(Object obj)
    {
        try
        {
            return ((Boolean)super.h.invoke(this, m1, new Object[] {
                    obj
            })).booleanValue();
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }
    public final int hashCode()
    {
        try
        {
            return ((Integer)super.h.invoke(this, m0, null)).intValue();
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }
    public final void getUserName()
    {
        try
        {
            super.h.invoke(this, m3, null);
            return;
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }
    public final void getAge()
    {
        try
        {
            super.h.invoke(this, m3, null);
            return;
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }
    public final String toString()
    {
        try
        {
            return (String)super.h.invoke(this, m2, null);
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }
    static
    {
        try
        {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {
                    Class.forName("java.lang.Object")
            });
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
            m3 = Class.forName("Subject").getMethod("getUserName", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m4 = Class.forName("Subject").getMethod("getAge",new Class[0]);
        }
        catch(NoSuchMethodException nosuchmethodexception)
        {
            throw new NoSuchMethodError(nosuchmethodexception.getMessage());
        }
        catch(ClassNotFoundException classnotfoundexception)
        {
            throw new NoClassDefFoundError(classnotfoundexception.getMessage());
        }
    }
}

这就是他生成的代理 class ，我们可以看到我们的 getUserName 和 getAge 方法里面都调用了 h.invoke 这个方法，那这个 h 就是我们自己编写的 invocationhandler，那这样就很清晰了，当我们调用代理对象的 getUserName 实际上调用的就是 invocationhandler 的 invoke 的方法，所以我们在编写 invoke 方法里面的代码会被执行。