基于jdk的动态代理

一. 问题背景

复习spring的时候涉及到动态代理，主要是基于接口的jdk自带的动态代理。采用jdk自带的Proxy类实现。

二. 基于jdk的动态代理

动态代理：使用代理对象去包装目标对象（即原始对象）。目标对象有的东西，代理对象也都有（即代理对象实现目标对象的所有接口或继承目标对象的所有类）。

2.1 获取代理对象的2个方法

jdk自带Proxy类，这是所有代理类的父类。我们就是通过它的2个方法实现动态代理

2.1.1 getProxyClass(ClassLoader loader,Class<?>… interfaces)

获取代理类，然后可以使用代理类创建代理对象（使用反射创建对象）

public static Class<?> getProxyClass(ClassLoader loader,
                                         Class<?>... interfaces)

2.1.2 newProxyInstance(ClassLoader loader,Class<?>[] interfaces, InvocationHandler h)

直接获取到代理类

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

2.2 原理分析

2.3 例子：使用newProxyInstance()实现动态代理

需求：一个计数器，加减乘除，计算前后实现日志输出

代码如下：
Calculate.java

package com.atguigu;

public interface Calculate {

    public int add(int i, int j);
    public int sub(int i, int j);
    public int mul(int i, int j);
    public int div(int i, int j);
}

CalculateImpl.java

package com.atguigu;

public class CalculateImpl implements Calculate {
    @Override
    public int add(int i, int j) {
        return (i+j);
    }

    @Override
    public int sub(int i, int j) {
        return (i-j);
    }

    @Override
    public int mul(int i, int j) {
        return (i*j);
    }

    @Override
    public int div(int i, int j) {
        return (i/j);
    }
}

CalculateProxy.java

package com.atguigu;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;
import java.util.Arrays;

/**
 * 编写代理过程
 */
public class CalculateProxy {
    //1.目标对象  //2.代理对象

    Calculate target;

    public CalculateProxy(Calculate target) {
        this.target = target;//将外部传入的target赋给当前类的目标对象
    }

    //获取代理对象
    public Object getProxy() {
        Object proxy = null;//代理对象

        //获取目标对象的class对象，方便后面使用反射
        Class cls = target.getClass();

        //获取类加载器
        ClassLoader loader = cls.getClassLoader();
        //获取CalculateImpl实现了哪些接口
        Class[] interfaces = cls.getInterfaces();


        //使用Proxy的newProxyInstance()方法创建代理对象
        proxy = Proxy.newProxyInstance(loader, interfaces, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("The method " + method.getName() + " begins with " + Arrays.asList(args));
                Object result = method.invoke(target, args);//将方法调用转回目标对象（原始对象）
                System.out.println("The method " + method.getName() + " ends with " + result);
                return result;
            }
        });

        return proxy;
    }
}

Main.java

 @Test
    public void test9() throws Exception {

        Calculate target = new CalculateImpl();//先获取目标对象

        Object object = new CalculateProxy(target).getProxy();//获取代理对象

        Calculate proxy = (Calculate) object;//强转类型：必须转为接口类型，不能转为接口的实现类

        int result = proxy.add(2, 3);

        System.out.println("result:" + result);

    }

结果如下：

2.4 例子：使用getProxyClass()实现动态代理

公用代码如上，有需要修改的代码如下：

 //获取代理对象
    public Object getProxy() throws Exception {
        Object proxy = null;//代理对象

        //获取目标对象的class对象，方便后面使用反射
        Class cls = target.getClass();

        //获取类加载器
        ClassLoader loader = cls.getClassLoader();
        //获取CalculateImpl实现了哪些接口
        Class[] interfaces = cls.getInterfaces();

        Class<?> proxyClass = Proxy.getProxyClass(loader, interfaces);

        //使用反射创建代理对象
        Constructor<?> declaredConstructor =
                proxyClass.getDeclaredConstructor(InvocationHandler.class);

        proxy = declaredConstructor.newInstance(new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("The method " + method.getName() + " begins with " + Arrays.asList(args));
                Object result = method.invoke(target, args);//将方法调用转回目标对象（原始对象）
                System.out.println("The method " + method.getName() + " ends with " + result);
                return result;
            }
        });

        return proxy;

    }

注意：获取到代理类时，不能直接使用反射的newInstance()创建代理对象，因为生成出来的代理类是有一个有参构造方法必须传入一个InvocationHandler。所以我们要先使用代理类的class对象获取该有参构造器（带形参InvocationHandler），然后使用构造器newInstance（要传入一个形参InvocationHandler）。