Spring进阶（十）

目录

为什么要用代理

jdk动态代理详解

cglib代理详解

CGLIB和JDK动态代理的区别 

详解代理（jdk动态代理和cglib动态代理），spring中用到的挺多的，比如上篇文章中的lookup-method和replaced-method，以及后面我们要学的aop、spring中的事务、spring中解析@configuration注解等等，这些都是依靠代理来实现的，所以我们先把代理拿出来讲讲，有利于我们理解其他内容。

为什么要用代理

我们先来看一个案例：

public interface IService {
    void m1();
    void m2();
    void m3();
}

public class ServiceA implements IService{
    @Override
    public void m1() {
        System.out.println("ServiceA中的m1方法");
    }

    @Override
    public void m2() {
        System.out.println("ServiceA中的m2方法");
    }

    @Override
    public void m3() {
        System.out.println("ServiceA中的m3方法");
    }
}

public class ServiceB implements IService{
    @Override
    public void m1() {
        System.out.println("ServiceB中的m1方法");
    }

    @Override
    public void m2() {
        System.out.println("ServiceB中的m2方法");
    }

    @Override
    public void m3() {
        System.out.println("ServiceB中的m3方法");
    }
}

@SpringBootTest
class AgencyApplicationTests {

    @Test
    void contextLoads() {
        IService serviceA = new ServiceA();
        serviceA.m1();
        serviceA.m2();
        serviceA.m3();

        IService serviceB = new ServiceB();
        serviceB.m1();
        serviceB.m2();
        serviceB.m3();
    }
}

上面代码很简单，我们就不做赘述了，运行以后输出：

ServiceA中的m1方法
ServiceA中的m2方法
ServiceA中的m3方法
ServiceB中的m1方法
ServiceB中的m2方法
ServiceB中的m3方法

上面是我们原本的程序，突然领导有个需求：

调用IService接口中的任何方法的时候，需要记录方法的耗时。 此时你会怎么做呢？ IService接口有2个实现类ServiceA和ServiceB，我们可以在这两个类的所有方法中加上统计耗时的代码，如果IService接口有几十个实现，是不是要修改很多代码，所有被修改的方法需重新测试？是不是非常痛苦，不过上面这种修改代码的方式倒是可以解决问题，只是增加了很多工作量（编码 & 测试）。 突然有一天，领导又说，要将这些耗时统计发送到监控系统用来做监控报警使用。 此时是不是又要去一个修改上面的代码？又要去测试？此时的系统是难以维护。 还有假如上面这些类都是第三方以jar包的方式提供给我们的，此时这些类都是class文件，此时我们无法去修改源码。

比较好的方式：可以为IService接口创建一个代理类，通过这个代理类来间接访问IService接口的实现类，在这个代理类中去做耗时及发送至监控的代码，代码如下：

// IService的代理类
public class ServiceProxy implements IService{
    //目标对象，被代理的对象
    private IService target;

    public ServiceProxy(IService target){
        this.target=target;
    }

    @Override
    public void m1() {
        long startTime = System.nanoTime();
        this.target.m1();
        long endTime = System.nanoTime();
        System.out.println("耗时:"+(endTime-startTime));
    }

    @Override
    public void m2() {
        long startTime = System.nanoTime();
        this.target.m2();
        long endTime = System.nanoTime();
        System.out.println("耗时:"+(endTime-startTime));
    }

    @Override
    public void m3() {
        long startTime = System.nanoTime();
        this.target.m3();
        long endTime = System.nanoTime();
        System.out.println("耗时:"+(endTime-startTime));
    }
}

ServiceProxy是IService接口的代理类，target为被代理的对象，即实际需要访问的对象，也实现了 IService接口，上面的3个方法中加了统计耗时的代码，当我们需要访问IService的其他实现类的时候， 可以通过ServiceProxy来间接的进行访问 

@SpringBootTest
class AgencyApplicationTests {

    @Test
    void contextLoads() {
        IService serviceA = new ServiceProxy(new ServiceA());//@1
        serviceA.m1();
        serviceA.m2();
        serviceA.m3();

        IService serviceB = new ServiceProxy(new ServiceB());//@2
        serviceB.m1();
        serviceB.m2();
        serviceB.m3();
    }
}

上面代码重点在于@1和@2，创建的是代理对象ServiceProxy，ServiceProxy构造方法中传入了被代理访问的对象，现在我们访问ServiceA或者ServiceB，都需要经过 ServiceProxy ，运行输出：

ServiceA中的m1方法
耗时:45200
ServiceA中的m2方法
耗时:13000
ServiceA中的m3方法
耗时:10400
ServiceB中的m1方法
耗时:24200
ServiceB中的m2方法
耗时:10600
ServiceB中的m3方法
耗时:9300

上面实现中我们没有去修改ServiceA和ServiceB中的方法，只是给IService接口创建了一个代理类，通过代理类去访问目标对象，需要添加的一些共有的功能都放在代理中，当领导有其他需求的时候，我们只需修改ServiceProxy的代码，方便系统的扩展和测试。

假如现在我们需要给系统中所有接口都加上统计耗时的功能，若按照上面的方式，我们需要给每个接口创建一个代理类，此时代码量和测试的工作量也是巨大的，那么我们能不能写一个通用的代理类，来满足上面的功能呢？继续往下看

jdk动态代理详解

jdk中为实现代理提供了支持，主要用到2个类： 

java.lang.reflect.Proxy

java.lang.reflect.InvocationHandler 

注：jdk自带的代理使用上面有个限制，只能为接口创建代理类，如果需要给具体的类创建代理类，需要用后面要说的cglib 

下面我们来熟悉几个方法：

getProxyClass方法

为指定的接口创建代理类，返回代理类的Class对象

public static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces)
/*
参数说明：
loader：定义代理类的类加载器
interfaces：指定需要实现的接口列表，创建的代理默认会按顺序实现interfaces指定的接口
*/

newProxyInstance方法

创建代理类的实例对象

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

这个方法先为指定的接口创建代理类，然后会生成代理类的一个实例，最后一个参数比较特殊，是 InvocationHandler类型的，这个是个接口如下：

public Object invoke(Object proxy, Method method, Object[] args)throws Throwable;

上面方法会返回一个代理对象，当调用代理对象的任何方法的时候，会就被 InvocationHandler 接口 的 invoke 方法处理，所以主要代码需要卸载 invoke 方法中，稍后会有案例细说。

isProxy方法 

判断指定的类是否是一个代理类

public static boolean isProxyClass(Class<?> cl)

getInvocationHandler方法

获取代理对象的 InvocationHandler 对象

public static InvocationHandler getInvocationHandler(Object proxy)throws IllegalArgumentException

创建代理：方式一

步骤：

1.调用Proxy.getProxyClass方法获取代理类的Class对象

2.使用InvocationHandler接口创建代理类的处理器

3.通过代理类和InvocationHandler创建代理对象

4.上面已经创建好代理对象了，接着我们就可以使用代理对象了

案例：

public interface IService {
    void m1();
    void m2();
    void m3();
}

    @Test
    public void test() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //获取接口对应的代理类
        Class<IService> proxyClass = (Class<IService>) Proxy.getProxyClass(IService.class.getClassLoader(), IService.class);

        //创建代理类的处理器
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("我是InvocationHandler,调用的方法是" + method.getName());
                return null;
            }
        };
        //创建代理实例    Class.getConstructor.newInstance
        IService proxyService = proxyClass.getConstructor(InvocationHandler.class).newInstance(invocationHandler);

        proxyService.m1();
        proxyService.m2();
        proxyService.m3();
    }

我是InvocationHandler,调用的方法是m1
我是InvocationHandler,调用的方法是m2
我是InvocationHandler,调用的方法是m3

创建代理：方式二

步骤：

1.使用InvocationHandler接口创建代理类的处理器

2.使用Proxy类的静态方法newProxyInstance直接创建代理对象

3.使用代理对象

案例：

    @Test
    public void test2() {
        // 1. 创建代理类的处理器
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) {
                System.out.println("我是InvocationHandler，被调用的方法是：" + method.getName());
                return null;
            }
        };
        
        // 2. 创建代理实例
        IService proxyService = (IService) Proxy.newProxyInstance(IService.class.getClassLoader(), new Class[]{IService.class}, invocationHandler);

        // 3. 调用代理的方法
        proxyService.m1();
        proxyService.m2();
        proxyService.m3();
    }

我是InvocationHandler，被调用的方法是：m1
我是InvocationHandler，被调用的方法是：m2
我是InvocationHandler，被调用的方法是：m3

案例：任意接口中的方法耗时统计

下面我们通过jdk动态代理实现一个通用的代理，解决统计所有接口方法耗时的问题。

主要的代码在代理处理器 InvocationHandler 实现上面，如下：

public class CostTimeInvocationHandler implements InvocationHandler {

    private Object target;

    public CostTimeInvocationHandler(Object target){
        this.target=target;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long startTime = System.nanoTime();
        Object result=method.invoke(this.target,args);
        long endTime = System.nanoTime();
        System.out.println(this.target.getClass() + ".m1()方法耗时(纳秒):" + (endTime - startTime));
        return result;
    }

    /**
     * 用来创建targetInterface接口的代理对象
     *
     * @param target 需要被代理的对象
     * @param targetInterface 被代理的接口
     * @param <T>
     * @return
     */
    public static <T> T createProxy(Object target, Class<T> targetInterface) {
        if (!targetInterface.isInterface()) {
            throw new IllegalStateException("targetInterface必须是接口类型!");
        } else if (!targetInterface.isAssignableFrom(target.getClass())) {
            throw new IllegalStateException("target必须是targetInterface接口的实现类!");
        }
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), new CostTimeInvocationHandler(target));
    }
}

上面主要是 createProxy 方法用来创建代理对象，2个参数：

target：目标对象，需要实现targetInterface接口 targetInterface：需要创建代理的接口 invoke方法中通过 method.invoke(this.target, args) 调用目标方法，然后统计方法的耗时。

    @Test
    public void costTimeProxy() {
        IService serviceA = CostTimeInvocationHandler.createProxy(new ServiceA(), IService.class);
        IService serviceB = CostTimeInvocationHandler.createProxy(new ServiceB(), IService.class);
        
        serviceA.m1();
        serviceA.m2();
        serviceA.m3();
        
        serviceB.m1();
        serviceB.m2();
        serviceB.m3();
    }

 运行输出：

ServiceA中的m1方法
class com.example.Bean.ServiceA.m1()方法耗时(纳秒):57700
ServiceA中的m2方法
class com.example.Bean.ServiceA.m1()方法耗时(纳秒):16500
ServiceA中的m3方法
class com.example.Bean.ServiceA.m1()方法耗时(纳秒):12600
ServiceB中的m1方法
class com.example.Bean.ServiceB.m1()方法耗时(纳秒):14900
ServiceB中的m2方法
class com.example.Bean.ServiceB.m1()方法耗时(纳秒):13900
ServiceB中的m3方法
class com.example.Bean.ServiceB.m1()方法耗时(纳秒):30000

Proxy使用注意：

• jdk中的Proxy只能为接口生成代理类，如果你想给某个类创建代理类，那么Proxy是无能为力的， 此时需要我们用到下面要说的cglib了。
• Proxy类中提供的几个常用的静态方法大家需要掌握
• 通过Proxy创建代理对象，当调用代理对象任意方法时候，会被InvocationHandler接口中的 invoke方法进行处理，这个接口内容是关键

cglib代理详解

什么是cglib

jdk动态代理只能为接口创建代理，使用上有局限性。实际的场景中我们的类不一定有接口，此时如果我 们想为普通的类也实现代理功能，我们就需要用到cglib来实现了。

cglib是一个强大、高性能的字节码生成库，它用于在运行时扩展Java类和实现接口；本质上它是通过动态的生成一个子类去覆盖所要代理的类（非final修饰的类和方法）。Enhancer可能是CGLIB中最常用的 一个类，和jdk中的Proxy不同的是，Enhancer既能够代理普通的class，也能够代理接口。Enhancer创建一个被代理对象的子类并且拦截所有的方法调用（包括从Object中继承的toString和hashCode方 法）。Enhancer不能够拦截final方法，例如Object.getClass()方法，这是由于Java final方法语义决定的。基于同样的道理，Enhancer也不能对final类进行代理操作。 

7个案例来演示cglib常见的用法

• 案例1：拦截所有方法（MethodInterceptor）

public class ServiceA {
    
    public void test1(){
        System.out.println("test1被调用了");
    }


    public void test2(){
        System.out.println("test2被调用了");
    }
}

public class cglibDome1 {

    @Test
    //使用Enhancer来给某个类创建代理类步骤
    public void test1(){
        //1.创建Enhancer对象
        Enhancer enhancer = new Enhancer();
        //2.通过setSuperclass来设置父类型，即需要给哪个类创建代理类
        enhancer.setSuperclass(ServiceA.class);
        //3.设置回调，需要Callback接口,此处我们实现的是MethodInterceptor，是Callback的子接口
        //当调用代理对象的任何方法时，都会被MethodInterceptor的invoke方法处理
        enhancer.setCallback(new MethodInterceptor() {
            /**
             * Object o     代理对象
             * Method method        被代理的类的方法，即ServiceA中的方法
             * Object[] objects     调用方法传递的参数
             * MethodProxy methodProxy      方法代理对象
             */
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("调用方法："+method);
                Object result = methodProxy.invokeSuper(o,objects);
                return result;
            }
        });
        //4.获取代理对象：通过enhancer.create()获取代理对象，返回值是Object类型，需强转
        ServiceA proxy = (ServiceA) enhancer.create();
        //5.调用代理对象的方法
        proxy.test1();
        proxy.test2();
    }
}

1. 上面代码中的注释很详细，列出了给指定的类创建代理的具体步骤，整个过程中主要用到了 Enhancer类和 MethodInterceptor 接口。
2. enhancer.setSuperclass 用来设置代理类的父类，即需要给哪个类创建代理类，此处是 ServiceA
3. enhancer.setCallback 传递的是 MethodInterceptor 接口类型的参数， MethodInterceptor 接口有个 intercept 方法，这个方法会拦截代理对象所有的方法调用。
4. 还有一个重点是 Object result = methodProxy.invokeSuper(o, objects)；可以调用被代理类，也就是ServiceA类中的具体的方法，从方法名称的意思可以看出是调用父类，实际对某个类创建代理，cglib底层通过修改字节码的方式为ServiceA类创建了一个子类。

运行输出：

• 案例2：拦截所有方法（MethodInterceptor）

public class ServiceB {

    public void test1(){
        System.out.println("test1被调用了");
        this.test2();
    }


    public void test2(){
        System.out.println("test2被调用了");
    }
}

public class cglibDome2 {

    @Test
    public void test2(){

        Enhancer enhancer = new Enhancer();

        enhancer.setSuperclass(ServiceB.class);

        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("调用方法："+method);
                Object result = methodProxy.invokeSuper(o, objects);
                return result;
            }
        });
        ServiceB proxy = (ServiceB) enhancer.create();
        proxy.test1();
    }
}

运行后输出：

注意看案例一和案例二的区别，案例二中我们通过代理调用的只有test1方法，而test2方法是由test1调用的。

从控制台的输出也验证了两个方法都被拦截器拦截处理了

spring中的@configuration注解就是采用这种方式实现的，给大家上个@configuration案例眼熟一下： 

 

@Configuration
public class Config {

    @Bean
    public C1 c1(){
        return new C1();
    }

    @Bean
    public C2 c2(){
        C1 c1 = this.c1(); //@1
        return new C2(c1);
    }

    @Bean
    public C3 c3(){
        C1 c1 = this.c1(); //@2
        return new C3(c1);
    }

    public static class C1{

    }

    public static class C2{
        private C1 c1;

        public C2(C1 c1) {
            this.c1 = c1;
        }
    }

    public static class C3{

        private C1 c1;

        public C3(C1 c1) {
            this.c1 = c1;
        }
    }
}

上面代码中C2和C3依赖于C1，都是通过构造器注入C1，注意代码中的@1和@2都是调用c1方法获取容器中的C1，如何确保多次获取的C1都是一个的？这个地方就是使用cglib代理拦截@Bean注解 的方法来实现的。

• 案例3：拦截所有方法并返回固定值（FixedValue）

当调用某个类的任何方法的时候，都希望返回一个固定的值，此时可以使用 FixedValue 接口，如下：

public class ServiceC {

    public String test1(){
        System.out.println("test1被调用了");
        return "ServiceC:test1";
    }


    public String test2(){
        System.out.println("test2被调用了");
        return "ServiceC:test2";
    }
}

public class cglibDome3 {

    @Test
    public void test3(){

        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(ServiceC.class);
        enhancer.setCallback(new FixedValue() {
            @Override
            public Object loadObject() throws Exception {
                return "测试";
            }
        });
        ServiceC proxy= (ServiceC) enhancer.create();
        System.out.println(proxy.test1());
        System.out.println(proxy.test2());
        System.out.println(proxy);
    }
}

运行输出：

可以看出输出的都是一个固定值

• 案例4：直接放行，不做任何操作（NoOp.INSTANCE）

Callback 接口下面有个子接口 org.springframework.cglib.proxy.NoOp ，将这个作为Callback的 时候，被调用的方法会直接放行，像没有任何代理一样，感受一下效果：

public class ServiceD {

    public void test1(){
        System.out.println("test1被调用了");
    }


    public void test2(){
        System.out.println("test2被调用了");
    }
}

public class cglibDome4 {

    @Test
    public void test4(){

        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(ServiceD.class);
        enhancer.setCallback(NoOp.INSTANCE);
        ServiceD proxy = (ServiceD) enhancer.create();
        proxy.test1();
        proxy.test2();
    }
}

运行后输出：

从输出中可以看出，被调用的方法没有被代理做任何处理，直接进到目标类ServiceD的方法中了 

• 案例5：不同的方法使用不同的拦截器（CallbackFilter）

有个类如下：

public class ServiceE {

    public void insert1() {
        System.out.println("我是insert1");
    }
    public void insert2() {
        System.out.println("我是insert2");
    }
    public String get1() {
        System.out.println("我是get1");
        return "get1";
    }
    public String get2() {
        System.out.println("我是get2");
        return "get2";
    }

}

需求，给这个类创建一个代理需要实现下面的功能：

• 以insert开头的方法需要统计方法耗时
• 以get开头的的方法直接返回固定字符串 "固定字符串"

下来看代码，然后再解释：

public class cglibDome5 {

    @Test
    public void test5() {

        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(ServiceE.class);
        //创建2个Callback
        Callback[] callbacks = {
                new MethodInterceptor() {
                    @Override
                    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                        long startTime = System.nanoTime();
                        Object result = methodProxy.invokeSuper(o, objects);
                        long endTime = System.nanoTime();
                        System.out.println(method.getName() + "消耗时间：" + (endTime - startTime));
                        return result;
                    }
                },
                new FixedValue() {
                    @Override
                    public Object loadObject() throws Exception {
                        return "固定字符串";
                    }
                }
        };
        //调用enhancer的setCallbacks传递Callback数组
        enhancer.setCallbacks(callbacks);

         /**
          *
          * 设置过滤器CallbackFilter
          * CallbackFilter用来判断调用方法的时候使用callbacks数组中的哪个Callback来处理当前方法
          * 返回的是callbacks数组的下标
         */
        enhancer.setCallbackFilter(new CallbackFilter() {
            @Override
            public int accept(Method method) {
                return 0;
            }
        });
        enhancer.setCallbackFilter(new CallbackFilter() {
            @Override
            public int accept(Method method) {
                String name = method.getName();
                return name.startsWith("insert") ? 0 : 1;
            }
        });

        ServiceE proxy = (ServiceE) enhancer.create();
        System.out.println("-----------------");
        proxy.insert1();
        System.out.println("-----------------");
        proxy.insert2();
        System.out.println("-----------------");
        System.out.println(proxy.get1());
        System.out.println("-----------------");
        System.out.println(proxy.get2());
        System.out.println("-----------------");

    }
}

运行输出：

代码说明： 由于需求中要对不同的方法做不同的处理，所以需要有2个Callback对象，当调用代理对象的方法的时候，具体会走哪个Callback呢，此时会通过 CallbackFilter 中的 accept 来判断，这个方法返回callbacks数组的索引 。

• 案例6：对案例5的优化（CallbackHelper） 

cglib中有个CallbackHelper类，可以对案例5的代码进行优化，CallbackHelper类相当于对一些代码进 行了封装，方便实现案例5的需求，实现如下：

public class cglibDome5Plus {

    @Test
    public void test5() {

        Enhancer enhancer = new Enhancer();

        Callback costTimeCallback = new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                long startTime = System.nanoTime();
                Object result = methodProxy.invokeSuper(o, objects);
                long endTime = System.nanoTime();
                System.out.println(method.getName() + "消耗时间：" + (endTime - startTime));
                return result;
            }
        };

        Callback fixedValueCallback = new FixedValue() {
            @Override
            public Object loadObject() throws Exception {
                return "固定字符串";
            }
        };

        CallbackHelper callbackHelper = new CallbackHelper(ServiceE.class, null) {
            @Override
            protected Object getCallback(Method method) {
                return method.getName().startsWith("get") ? fixedValueCallback : costTimeCallback;
            }
        };

        enhancer.setSuperclass(ServiceE.class);
        enhancer.setCallbacks(callbackHelper.getCallbacks());
        enhancer.setCallbackFilter(callbackHelper);

        ServiceE proxy = (ServiceE) enhancer.create();
        System.out.println("-----------------");
        proxy.insert1();
        System.out.println("-----------------");
        proxy.insert2();
        System.out.println("-----------------");
        System.out.println(proxy.get1());
        System.out.println("-----------------");
        System.out.println(proxy.get2());
        System.out.println("-----------------");

    }
}

• 案例7：实现通用的统计任意类方法耗时代理类

public class CostTimeProxy implements MethodInterceptor {
    //目标对象
    private Object target;

    public CostTimeProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        long starTime = System.nanoTime();
        //调用被代理对象（即target）的方法，获取结果
        Object result = method.invoke(target, objects); //@1
        long endTime = System.nanoTime();
        System.out.println(method + "，耗时(纳秒)：" + (endTime - starTime));
        return result;
    }

    /**
     * 创建任意类的代理对象
     *
     * @param target
     * @param <T>
     * @return
     */
    public static <T> T createProxy(T target) {
        CostTimeProxy costTimeProxy = new CostTimeProxy(target);
        Enhancer enhancer = new Enhancer();
        enhancer.setCallback(costTimeProxy);
        enhancer.setSuperclass(target.getClass());
        return (T) enhancer.create();
    }
}

public class CostTimeProxyTest {
    @Test
    public void test(){
        ServiceA proxy = CostTimeProxy.createProxy(new ServiceA());
        proxy.test1();
        proxy.test2();

    }
}

CGLIB和JDK动态代理的区别 

• Java动态代理只能够对接口进行代理，不能对普通的类进行代理（因为所有生成的代理类的父类为 Proxy，Java类继承机制不允许多重继承）；CGLIB能够代理普通类；
• Java动态代理使用Java原生的反射API进行操作，在生成类上比较高效；CGLIB直接对字节码进行操作，在类的执行过程中比较高效