jdk和cglib动态代理

最新推荐文章于 2024-11-01 14:48:20 发布

打分几楼MOTO

最新推荐文章于 2024-11-01 14:48:20 发布

阅读量185

点赞数

分类专栏： spring源码文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_44447372/article/details/126331785

版权

spring源码专栏收录该内容

18 篇文章 1 订阅

订阅专栏

文章目录

动态代理

动态代理

jdk动态代理

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

特点

只能为接口创建代理对象
创建出来的代理都是java.lang.reflect.Proxy的子类

java.lang.reflect.Proxy
java.lang.reflect.InvocationHandler

java.lang.reflect.Proxy

这是jdk动态代理中主要的一个类，里面有一些静态方法会经常用到，我们来熟悉一下：

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

创建代理：方式一

步骤

调用Proxy.getProxyClass方法获取代理类的Class对象
使用InvocationHandler接口创建代理类的处理器
通过代理类和InvocationHandler创建代理对象
上面已经创建好代理对象了，接着我们就可以使用代理对象了

案例

先来个接口IService
public interface IService {
    void m1();
    void m2();
    void m3();
}

创建IService接口的代理对象
@Test
public void m1() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    // 1. 获取接口对应的代理类
    Class<IService> proxyClass = (Class<IService>) Proxy.getProxyClass(IService.class.getClassLoader(), IService.class);
    // 2. 创建代理类的处理器
    InvocationHandler invocationHandler = new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("我是InvocationHandler，被调用的方法是：" + method.getName());
            return null;
        }
    };
    // 3. 创建代理实例
    IService proxyService = proxyClass.getConstructor(InvocationHandler.class).newInstance(invocationHandler);
    // 4. 调用代理的方法
    proxyService.m1();
    proxyService.m2();
    proxyService.m3();
}

运行输出
	我是InvocationHandler，被调用的方法是：m1
	我是InvocationHandler，被调用的方法是：m2
	我是InvocationHandler，被调用的方法是：m3

创建代理：方式二

步骤

1.使用InvocationHandler接口创建代理类的处理器2.使用Proxy类的静态方法newProxyInstance直接创建代理对象3.使用代理对象

案例

@Test
public void m2() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    // 1. 创建代理类的处理器
    InvocationHandler invocationHandler = new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            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();
}

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

下面我们通过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 starTime = System.nanoTime();
        Object result = method.invoke(this.target, args);//@1
        long endTime = System.nanoTime();
        System.out.println(this.target.getClass() + ".m1()方法耗时(纳秒):" + (endTime - starTime));
        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.javacode2018.lesson001.demo16.ServiceA.m1()方法耗时(纳秒):61300
我是ServiceA中的m2方法!
class com.javacode2018.lesson001.demo16.ServiceA.m1()方法耗时(纳秒):22300
我是ServiceA中的m3方法!
class com.javacode2018.lesson001.demo16.ServiceA.m1()方法耗时(纳秒):18700
我是ServiceB中的m1方法!
class com.javacode2018.lesson001.demo16.ServiceB.m1()方法耗时(纳秒):54700
我是ServiceB中的m2方法!
class com.javacode2018.lesson001.demo16.ServiceB.m1()方法耗时(纳秒):27200
我是ServiceB中的m3方法!
class com.javacode2018.lesson001.demo16.ServiceB.m1()方法耗时(纳秒):19800

我们再来的接口，也需要统计耗时的功能，此时我们无需去创建新的代理类即可实现同样的功能，如下：

public interface IUserService {
    /**
     * 插入用户信息
     * @param name
     */
    void insert(String name);
}

public class UserService implements IUserService {
    @Override
    public void insert(String name) {
        System.out.println(String.format("用户[name:%s]插入成功!", name));
    }
}

@Test
public void userService() {
    IUserService userService = CostTimeInvocationHandler.createProxy(new UserService(), IUserService.class);
    userService.insert("路人甲Java");
}

//运行输出
用户[name:路人甲Java]插入成功!
class com.javacode2018.lesson001.demo16.UserService.m1()方法耗时(纳秒):193000

Proxy使用注意

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

cglib动态代理

cglib的特点

cglib弥补了jdk动态代理的不足，jdk动态代理只能为接口创建代理，而cglib非常强大，不管是接口还是类，都可以使用cglib来创建代理
cglib创建代理的过程，相当于创建了一个新的类，可以通过cglib来配置这个新的类需要实现的接口，以及需要继承的父类
cglib可以为类创建代理，但是这个类不能是final类型的，cglib为类创建代理的过程，实际上为通过继承来实现的，相当于给需要被代理的类创建了一个子类，然后会重写父类中的方法，来进行增强，继承的特性大家应该都知道，final修饰的类是不能被继承的，final修饰的方法不能被重写，static修饰的方法也不能被重写，private修饰的方法也不能被子类重写，而其他类型的方法都可以被子类重写，被重写的这些方法可以通过cglib进行拦截增强

cglib整个过程如下

Cglib根据父类,Callback, Filter 及一些相关信息生成key
然后根据key 生成对应的子类的二进制表现形式
使用ClassLoader装载对应的二进制,生成Class对象,并缓存
最后实例化Class对象,并缓存

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

cglib组成结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YUmsGPxL-1660460382442)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20220620143210354.png)]

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

public class Service1 {
    public void m1() {
        System.out.println("我是m1方法");
    }
    public void m2() {
        System.out.println("我是m2方法");
    }
}

public class CglibTest {
    @Test
    public void test1() {
        //使用Enhancer来给某个类创建代理类，步骤
        //1.创建Enhancer对象
        Enhancer enhancer = new Enhancer();
        //2.通过setSuperclass来设置父类型，即需要给哪个类创建代理类
        enhancer.setSuperclass(Service1.class);
        /*3.设置回调，需实现org.springframework.cglib.proxy.Callback接口，
        此处我们使用的是org.springframework.cglib.proxy.MethodInterceptor，也是一个接口，实现了Callback接口，
        当调用代理对象的任何方法的时候，都会被MethodInterceptor接口的invoke方法处理*/
        enhancer.setCallback(new MethodInterceptor() {
            /**
             * 代理对象方法拦截器
             * @param o 代理对象
             * @param method 被代理的类的方法，即Service1中的方法
             * @param objects 调用方法传递的参数
             * @param methodProxy 方法代理对象
             * @return
             * @throws Throwable
             */
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("调用方法:" + method);
                //可以调用MethodProxy的invokeSuper调用被代理类的方法
                Object result = methodProxy.invokeSuper(o, objects);
                return result;
            }
        });
        //4.获取代理对象,调用enhancer.create方法获取代理对象，这个方法返回的是Object类型的，所以需要强转一下
        Service1 proxy = (Service1) enhancer.create();
        //5.调用代理对象的方法
        proxy.m1();
        proxy.m2();
    }
}
    
运行输出：
	调用方法:public void com.javacode2018.lesson001.demo17.Service1.m1()
	我是m1方法
	调用方法:public void com.javacode2018.lesson001.demo17.Service1.m2()
	我是m2方法

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

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

public class Service2 {
    public void m1() {
        System.out.println("我是m1方法");
        //这个类和上面的Service1类似，有点不同是@1，在m1方法中调用了m2方法。
        this.m2(); //@1
    }
    public void m2() {
        System.out.println("我是m2方法");
    }
}

下面来采用案例1中同样的方式来给Service2创建代理，如下：
@Test
public void test2() {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(Service2.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;
        }
    });
    Service2 proxy = (Service2) enhancer.create();
    proxy.m1(); //@1
}

注意上面@1的代码，只调用了m1方法，看一下输出效果：

调用方法:public void com.javacode2018.lesson001.demo17.Service2.m1()
我是m1方法
调用方法:public void com.javacode2018.lesson001.demo17.Service2.m2()
我是m2方法

从输出中可以看出m1和m2方法都被拦截器处理了，而m2方法是在Service1的m1方法中调用的，也被拦截处理了。

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注解的方法来实现的。

Config被cglib代理,c2()调用c1():注意c1()是本类的方法,执行c1()时会重新的调用本类的动态代理
- 配置类里面去调用另外一个bean方法,需要从bean容器里面去拿,所以说需要重复的调用代理的那些代码;如果采用jdk代理,不会执行那些代理的那些代码即不会从bean容器里面去拿,就会重复的创建实例,变成了多例
Config被jdk代理,c2()调用c1():注意c1()是本类的方法,执行c1()时不会调用本类的动态代理

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

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

ackage com.javacode2018.lesson001.demo17;
public class Service3 {
    public String m1() {
        System.out.println("我是m1方法");
        return "hello:m1";
    }
    public String m2() {
        System.out.println("我是m2方法");
        return "hello:m2";
    }
}

@Test
public void test3() {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(Service3.class);
    enhancer.setCallback(new FixedValue() {
        @Override
        public Object loadObject() throws Exception {
            return "路人甲";
        }
    });
    Service3 proxy = (Service3) enhancer.create();
    System.out.println(proxy.m1());//@1
    System.out.println(proxy.m2()); //@2
    System.out.println(proxy.toString());//@3
}

@1、@2、@3调用了代理对象的3个方法，运行输出：
    路人甲
	路人甲
	路人甲

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

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

@Test
public void test6() {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(Service3.class);
    enhancer.setCallback(NoOp.INSTANCE);
    Service3 proxy = (Service3) enhancer.create();
    System.out.println(proxy.m1());
    System.out.println(proxy.m2());
}

运行输出：
	我是m1方法
	hello:m1
	我是m2方法
	hello:m2

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

public class Service4 {
    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开头的的方法直接返回固定字符串欢迎和【路人甲java】一起学spring！

@Test
public void test4() {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(Service4.class);
    //创建2个Callback
    Callback[] callbacks = {
            //这个用来拦截所有insert开头的方法
            new MethodInterceptor() {
                @Override
                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                    long starTime = System.nanoTime();
                    Object result = methodProxy.invokeSuper(o, objects);
                    long endTime = System.nanoTime();
                    System.out.println(method + "，耗时(纳秒):" + (endTime - starTime));
                    return result;
                }
            },
            //下面这个用来拦截所有get开头的方法，返回固定值的
            new FixedValue() {
                @Override
                public Object loadObject() throws Exception {
                    return "路人甲Java";
                }
            }
    };
    enhancer.setCallbackFilter(new CallbackFilter() {
        @Override
        public int accept(Method method) {
            return 0;
        }
    });
    //调用enhancer的setCallbacks传递Callback数组
    enhancer.setCallbacks(callbacks);
    /**
     * 设置过滤器CallbackFilter
     * CallbackFilter用来判断调用方法的时候使用callbacks数组中的哪个Callback来处理当前方法
     * 返回的是callbacks数组的下标
     */
    enhancer.setCallbackFilter(new CallbackFilter() {
        @Override
        public int accept(Method method) {
            //获取当前调用的方法的名称
            String methodName = method.getName();
            /**
             * 方法名称以insert开头，
             * 返回callbacks中的第1个Callback对象来处理当前方法，
             * 否则使用第二个Callback处理被调用的方法
             */
            return methodName.startsWith("insert") ? 0 : 1;
        }
    });
    Service4 proxy = (Service4) 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());
}

运行输出：

	---------------
	我是insert1
	public void com.javacode2018.lesson001.demo17.Service4.insert1()，耗时(纳秒):15396100
	---------------
	我是insert2
	public void com.javacode2018.lesson001.demo17.Service4.insert2()，耗时(纳秒):66200
	---------------
	路人甲Java
	---------------
	路人甲Java
	
代码说明：
	由于需求中要对不同的方法做不同的处理，所以需要有2个Callback对象，当调用代理对象的方法的时候，具体会走哪个Callback呢，	此时会通过CallbackFilter中的accept来判断，这个方法返回callbacks数组的索引。

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

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

@Test
public void test5() {
    Enhancer enhancer = new Enhancer();
    //创建2个Callback
    Callback costTimeCallback = (MethodInterceptor) (Object o, Method method, Object[] objects, MethodProxy methodProxy) -> {
        long starTime = System.nanoTime();
        Object result = methodProxy.invokeSuper(o, objects);
        long endTime = System.nanoTime();
        System.out.println(method + "，耗时(纳秒):" + (endTime - starTime));
        return result;
    };
    //下面这个用来拦截所有get开头的方法，返回固定值的
    Callback fixdValueCallback = (FixedValue) () -> "路人甲Java";
    CallbackHelper callbackHelper = new CallbackHelper(Service4.class, null) {
        @Override
        protected Object getCallback(Method method) {
            return method.getName().startsWith("insert") ? costTimeCallback : fixdValueCallback;
        }
    };
    enhancer.setSuperclass(Service4.class);
    //调用enhancer的setCallbacks传递Callback数组
    enhancer.setCallbacks(callbackHelper.getCallbacks());
    /**
     * 设置CallbackFilter,用来判断某个方法具体走哪个Callback
     */
    enhancer.setCallbackFilter(callbackHelper);
    Service4 proxy = (Service4) 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());
}

运行输出：
	---------------
	我是insert1
	public void com.javacode2018.lesson001.demo17.Service4.insert1()，耗时(纳秒):9777500
	---------------
	我是insert2
	public void com.javacode2018.lesson001.demo17.Service4.insert2()，耗时(纳秒):50600
	---------------
	路人甲Java
	---------------
	路人甲Java

案例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();
    }
}

我们可以直接使用上面的静态方法createProxy来为目标对象target创建一个代理对象，被代理的对象自动实现方法调用耗时统计。

@1：调用被代理对象的方法获取真正的结果。
    
@Test
public void test7() {
    //创建Service1代理
    Service1 service1 = CostTimeProxy.createProxy(new Service1());
    service1.m1();
    //创建Service3代理
    Service3 service3 = CostTimeProxy.createProxy(new Service3());
    System.out.println(service3.m1());
}

我是m1方法
public void com.javacode2018.lesson001.demo17.Service1.m1()，耗时(纳秒)：53200
我是m1方法
public java.lang.String com.javacode2018.lesson001.demo17.Service3.m1()，耗时(纳秒)：49200
hello:m1

案例8:为多个接口创建代理

代码比较简单，定义了2个接口，然后通过cglib来创建一个代理类，代理类会实现这2个接口，通过setCallback来对2个接口的方法进行增强。

public class CglibTest1 {
    interface IService1 {
        void m1();
    }
    interface IService2 {
        void m2();
    }
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        //设置代理对象需要实现的接口
        enhancer.setInterfaces(new Class[]{IService1.class, IService2.class});
        //通过Callback来对被代理方法进行增强
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("方法：" + method.getName());
                return null;
            }
        });
        Object proxy = enhancer.create();
        if (proxy instanceof IService1) {
            ((IService1) proxy).m1();
        }
        if (proxy instanceof IService2) {
            ((IService2) proxy).m2();
        }
        //看一下代理对象的类型
        System.out.println(proxy.getClass());
        //看一下代理类实现的接口
        System.out.println("创建代理类实现的接口如下：");
        for (Class<?> cs : proxy.getClass().getInterfaces()) {
            System.out.println(cs);
        }
    }
}

运行输出

方法：m1
方法：m2
class com.javacode2018.aop.demo2.CglibTest1$IService1$$EnhancerByCGLIB$$1d32a82
创建代理类实现的接口如下：
interface com.javacode2018.aop.demo2.CglibTest1$IService1
interface com.javacode2018.aop.demo2.CglibTest1$IService2
interface org.springframework.cglib.proxy.Factory
  
    
上面创建的代理类相当于下面代码
public class CglibTest1$IService1$$EnhancerByCGLIB$$1d32a82 implements IService1, IService2 {
    @Override
    public void m1() {
        System.out.println("方法：m1");
    }
    @Override
    public void m2() {
        System.out.println("方法：m2");
    }
}

案例9：为类和接口同时创建代理

下面定义了2个接口：IService1和IService2，2个接口有个实现类：Service，然后通过cglib创建了个代理类，实现了这2个接口，并且将Service类作为代理类的父类。

public class CglibTest2 {
    interface IService1 {
        void m1();
    }
    interface IService2 {
        void m2();
    }
    public static class Service implements IService1, IService2 {
        @Override
        public void m1() {
            System.out.println("m1");
        }
        @Override
        public void m2() {
            System.out.println("m2");
        }
    }
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        //设置代理类的父类
        enhancer.setSuperclass(Service.class);
        //设置代理对象需要实现的接口
        enhancer.setInterfaces(new Class[]{IService1.class, IService2.class});
        //通过Callback来对被代理方法进行增强
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                long startime = System.nanoTime();
                Object result = methodProxy.invokeSuper(o, objects); //调用父类中的方法
                System.out.println(method + "，耗时(纳秒):" + (System.nanoTime() - startime));
                return result;
            }
        });
        //创建代理对象
        Object proxy = enhancer.create();
        //判断代理对象是否是Service类型的
        System.out.println("proxy instanceof Service" + (proxy instanceof Service));
        if (proxy instanceof Service) {
            Service service = (Service) proxy;
            service.m1();
            service.m2();
        }
        //看一下代理对象的类型
        System.out.println(proxy.getClass());
        //输出代理对象的父类
        System.out.println("代理类的父类：" + proxy.getClass().getSuperclass());
        //看一下代理类实现的接口
        System.out.println("创建代理类实现的接口如下：");
        for (Class<?> cs : proxy.getClass().getInterfaces()) {
            System.out.println(cs);
        }
    }
}

运行输出
	proxy instanceof Servicetrue
	m1
	public void com.javacode2018.aop.demo2.CglibTest2$Service.m1()，耗时(纳秒):14219700
	m2
	public void com.javacode2018.aop.demo2.CglibTest2$Service.m2()，耗时(纳秒):62800
	class com.javacode2018.aop.demo2.CglibTest2$Service$$EnhancerByCGLIB$$80494536
	代理类的父类：class com.javacode2018.aop.demo2.CglibTest2$Service
	创建代理类实现的接口如下：
	interface com.javacode2018.aop.demo2.CglibTest2$IService1
	interface com.javacode2018.aop.demo2.CglibTest2$IService2
	interface org.springframework.cglib.proxy.Factory
        
输出中可以代理对象的类型是：
	class com.javacode2018.aop.demo2.CglibTest2$Service$$EnhancerByCGLIB$$80494536
        
        
有EnhancerByCGLIB字样的，在调试spring的过程中，发现有这样字样的，基本上都是cglib创建的代理对象。
上面创建的代理类相当于下面代码
public class CglibTest2$Service$$EnhancerByCGLIB$$80494536 extends Service implements IService1, IService2 {
    @Override
    public void m1() {
        long starttime = System.nanoTime();
        super.m1();
        System.out.println("方法m1，耗时(纳秒):" + (System.nanoTime() - starttime));
    }
    @Override
    public void m2() {
        long starttime = System.nanoTime();
        super.m1();
        System.out.println("方法m1，耗时(纳秒):" + (System.nanoTime() - starttime));
    }
}

案例10：LazyLoader的使用

LazyLoader是cglib用于实现懒加载的callback。当被增强bean的方法初次被调用时，会触发回调，之后每次再进行方法调用都是对LazyLoader第一次返回的bean调用，hibernate延迟加载有用到过这个。

public class LazyLoaderTest1 {
    public static class UserModel {
        private String name;
        public UserModel() {
        }
        public UserModel(String name) {
            this.name = name;
        }
        public void say() {
            System.out.println("你好：" + name);
        }
    }
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserModel.class);
        //创建一个LazyLoader对象
        LazyLoader lazyLoader = new LazyLoader() {
            @Override
            public Object loadObject() throws Exception {
                System.out.println("调用LazyLoader.loadObject()方法");
                return new UserModel("路人甲java");
            }
        };
        enhancer.setCallback(lazyLoader);
        Object proxy = enhancer.create();
        UserModel userModel = (UserModel) proxy;
        System.out.println("第1次调用say方法");
        userModel.say();
        System.out.println("第1次调用say方法");
        userModel.say();
    }
}

运行输出
	第1次调用say方法
	调用LazyLoader.loadObject()方法
	你好：路人甲java
	第1次调用say方法
	你好：路人甲java
当第1次调用say方法的时候，会被cglib拦截，进入lazyLoader的loadObject内部，将这个方法的返回值作为say方法的调用者，loadObject中返回了一个路人甲Java的UserModel，cglib内部会将loadObject方法的返回值和say方法关联起来，然后缓存起来，而第2次调用say方法的时候，通过方法名去缓存中找，会直接拿到第1次返回的UserModel，所以第2次不会进入到loadObject方法中了。

将下代码拆分开来
System.out.println("第1次调用say方法");
userModel.say();
System.out.println("第1次调用say方法");
userModel.say();
相当于下面的代码
System.out.println("第1次调用say方法");
System.out.println("调用LazyLoader.loadObject()方法");
userModel = new UserModel("路人甲java");
userModel.say();
System.out.println("第1次调用say方法");
userModel.say();

案例11：LazyLoader实现延迟加载

博客的内容一般比较多，需要用到内容的时候，我们再去加载，下面来模拟博客内容延迟加载的效果。

public class LazyLoaderTest2 {
    //博客信息
    public static class BlogModel {
        private String title;
        //博客内容信息比较多，需要的时候再去获取
        private BlogContentModel blogContentModel;
        public BlogModel() {
            this.title = "spring aop详解!";
            this.blogContentModel = this.getBlogContentModel();
        }
        private BlogContentModel getBlogContentModel() {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(BlogContentModel.class);
            enhancer.setCallback(new LazyLoader() {
                @Override
                public Object loadObject() throws Exception {
                    //此处模拟从数据库中获取博客内容
                    System.out.println("开始从数据库中获取博客内容.....");
                    BlogContentModel result = new BlogContentModel();
                    result.setContent("欢迎大家和我一起学些spring，我们一起成为spring高手！");
                    return result;
                }
            });
            return (BlogContentModel) enhancer.create();
        }
    }
    //表示博客内容信息
    public static class BlogContentModel {
        //博客内容
        private String content;
        public String getContent() {
            return content;
        }
        public void setContent(String content) {
            this.content = content;
        }
    }
    public static void main(String[] args) {
        //创建博客对象
        BlogModel blogModel = new BlogModel();
        System.out.println(blogModel.title);
        System.out.println("博客内容");
        System.out.println(blogModel.blogContentModel.getContent()); //@1
    }
}

@1：调用blogContentModel.getContent()方法的时候，才会通过LazyLoader#loadObject方法从db中获取到博客内容信息
运行输出
	spring aop详解!
	博客内容
	开始从数据库中获取博客内容.....
	欢迎大家和我一起学些spring，我们一起成为spring高手！

案例12：Dispatcher

Dispatcher和LazyLoader作用很相似，区别是用Dispatcher的话每次对增强bean进行方法调用都会触发回调。

public class DispatcherTest1 {
    public static class UserModel {
        private String name;
        public UserModel() {
        }
        public UserModel(String name) {
            this.name = name;
        }
        public void say() {
            System.out.println("你好：" + name);
        }
    }
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(LazyLoaderTest1.UserModel.class);
        //创建一个Dispatcher对象
        Dispatcher dispatcher = new Dispatcher() {
            @Override
            public Object loadObject() throws Exception {
                System.out.println("调用Dispatcher.loadObject()方法");
                return new LazyLoaderTest1.UserModel("路人甲java," + UUID.randomUUID().toString());
            }
        };
        enhancer.setCallback(dispatcher);
        Object proxy = enhancer.create();
        LazyLoaderTest1.UserModel userModel = (LazyLoaderTest1.UserModel) proxy;
        System.out.println("第1次调用say方法");
        userModel.say();
        System.out.println("第1次调用say方法");
        userModel.say();
    }
}

第1次调用say方法
调用Dispatcher.loadObject()方法
你好：路人甲java,514f911e-06ac-4e3b-aee4-595f82c16a5f
第1次调用say方法
调用Dispatcher.loadObject()方法
你好：路人甲java,bc062990-bc16-4226-97e3-b1b321a03468

案例13：通过Dispathcer对类扩展一些接口

下面有个UserService类，我们需要对这个类创建一个代理。代码中还定义了一个接口：IMethodInfo，用来统计被代理类的一些方法信息，有个实现类：DefaultMethodInfo。通过cglib创建一个代理类，父类为UserService，并且实现IMethodInfo接口，将接口IMethodInfo所有方法的转发给DefaultMethodInfo处理，代理类中的其他方法，转发给其父类UserService处理。这个代码相当于对UserService这个类进行了增强，使其具有了IMethodInfo接口中的功能。

public class DispatcherTest2 {
    public static class UserService {
        public void add() {
            System.out.println("新增用户");
        }
        public void update() {
            System.out.println("更新用户信息");
        }
    }
    //用来获取方法信息的接口
    public interface IMethodInfo {
        //获取方法数量
        int methodCount();
        //获取被代理的对象中方法名称列表
        List<String> methodNames();
    }
    //IMethodInfo的默认实现
    public static class DefaultMethodInfo implements IMethodInfo {
        private Class<?> targetClass;
        public DefaultMethodInfo(Class<?> targetClass) {
            this.targetClass = targetClass;
        }
        @Override
        public int methodCount() {
            return targetClass.getDeclaredMethods().length;
        }
        @Override
        public List<String> methodNames() {
            return Arrays.stream(targetClass.getDeclaredMethods()).
                    map(Method::getName).
                    collect(Collectors.toList());
        }
    }
    public static void main(String[] args) {
        Class<?> targetClass = UserService.class;
        Enhancer enhancer = new Enhancer();
        //设置代理的父类
        enhancer.setSuperclass(targetClass);
        //设置代理需要实现的接口列表
        enhancer.setInterfaces(new Class[]{IMethodInfo.class});
        //创建一个方法统计器
        IMethodInfo methodInfo = new DefaultMethodInfo(targetClass);
        //创建会调用器列表，此处定义了2个，第1个用于处理UserService中所有的方法，第2个用来处理IMethodInfo接口中的方法
        Callback[] callbacks = {
                new MethodInterceptor() {
                    @Override
                    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                        return methodProxy.invokeSuper(o, objects);
                    }
                },
                new Dispatcher() {
                    @Override
                    public Object loadObject() throws Exception {
                        /**
                         * 用来处理代理对象中IMethodInfo接口中的所有方法
                         * 所以此处返回的为IMethodInfo类型的对象，
                         * 将由这个对象来处理代理对象中IMethodInfo接口中的所有方法
                         */
                        return methodInfo;
                    }
                }
        };
        enhancer.setCallbacks(callbacks);
        enhancer.setCallbackFilter(new CallbackFilter() {
            @Override
            public int accept(Method method) {
                //当方法在IMethodInfo中定义的时候，返回callbacks中的第二个元素
                return method.getDeclaringClass() == IMethodInfo.class ? 1 : 0;
            }
        });
        Object proxy = enhancer.create();
        //代理的父类是UserService
        UserService userService = (UserService) proxy;
        userService.add();
        //代理实现了IMethodInfo接口
        IMethodInfo mf = (IMethodInfo) proxy;
        System.out.println(mf.methodCount());
        System.out.println(mf.methodNames());
    }
}

运行输出

	新增用户
	2
	[add, update]

案例14：cglib中的NamingPolicy接口

接口NamingPolicy表示生成代理类的名字的策略，通过Enhancer.setNamingPolicy方法设置命名策略。默认的实现类：DefaultNamingPolicy，具体cglib动态生成类的命名控制。DefaultNamingPolicy中有个getTag方法。DefaultNamingPolicy生成的代理类的类名命名规则：

被代理class name + "$$" + 使用cglib处理的class name + "ByCGLIB" + "$$" + key的hashcode
com.javacode2018.aop.demo2.DispatcherTest2$UserService$$EnhancerByCGLIB$$e7ec0be5@17d10166

自定义NamingPolicy，通常会继承DefaultNamingPolicy来实现，spring中默认就提供了一个，如下

public class SpringNamingPolicy extends DefaultNamingPolicy {
    public static final SpringNamingPolicy INSTANCE = new SpringNamingPolicy();
    @Override
    protected String getTag() {
        return "BySpringCGLIB";
    }
}

public class NamingPolicyTest {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(NamingPolicyTest.class);
        enhancer.setCallback(NoOp.INSTANCE);
        //通过Enhancer.setNamingPolicy来设置代理类的命名策略
        enhancer.setNamingPolicy(new DefaultNamingPolicy() {
            @Override
            protected String getTag() {
                return "-test-";
            }
        });
        Object proxy = enhancer.create();
        System.out.println(proxy.getClass());
    }
}

输出

class com.javacode2018.aop.demo2.NamingPolicyTest$$Enhancer-test-$$5946713

Objenesis：实例化对象的一种方式

先来看一段代码，有一个有参构造函数：

public static class User {
    private String name;
    public User(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

大家来思考一个问题：如果不使用这个有参构造函数的情况下，如何创建这个对象？

通过反射？大家可以试试，如果不使用有参构造函数，是无法创建对象的。

cglib中提供了一个接口：Objenesis，通过这个接口可以解决上面这种问题，它专门用来创建对象，即使你没有空的构造函数，都木有问题，它不使用构造方法创建Java对象，所以即使你有空的构造方法，也是不会执行的。

用法比较简单：

@Test
public void test1() {
    Objenesis objenesis = new ObjenesisStd();
    User user = objenesis.newInstance(User.class);
    System.out.println(user);
}

输出

User{name='null'}

大家可以在User类中加一个默认构造函数，来验证一下上面的代码会不会调用默认构造函数？

public User() {
    System.out.println("默认构造函数");
}

再次运行会发现，并不会调用默认构造函数。

如果需要多次创建User对象，可以写成下面方式重复利用
@Test
public void test2() {
    Objenesis objenesis = new ObjenesisStd();
    ObjectInstantiator<User> userObjectInstantiator = objenesis.getInstantiatorOf(User.class);
    User user1 = userObjectInstantiator.newInstance();
    System.out.println(user1);
    User user2 = userObjectInstantiator.newInstance();
    System.out.println(user2);
    System.out.println(user1 == user2);
}

运行输出

User{name='null'}
User{name='null'}
false
代码位置

com.javacode2018.aop.demo2.CreateObjectTest

CGLIB和Java动态代理的区别

Java动态代理只能够对接口进行代理，不能对普通的类进行代理（因为所有生成的代理类的父类为Proxy，Java类继承机制不允许多重继承）；CGLIB能够代理普通类；

‘’’ +
‘}’;
}
}


**大家来思考一个问题：如果不使用这个有参构造函数的情况下，如何创建这个对象？**

通过反射？大家可以试试，如果不使用有参构造函数，是无法创建对象的。

cglib中提供了一个接口：Objenesis，通过这个接口可以解决上面这种问题，它专门用来创建对象，即使你没有空的构造函数，都木有问题，它不使用构造方法创建Java对象，所以即使你有空的构造方法，也是不会执行的。

```java
用法比较简单：

@Test
public void test1() {
    Objenesis objenesis = new ObjenesisStd();
    User user = objenesis.newInstance(User.class);
    System.out.println(user);
}

输出

User{name='null'}

大家可以在User类中加一个默认构造函数，来验证一下上面的代码会不会调用默认构造函数？

public User() {
    System.out.println("默认构造函数");
}

再次运行会发现，并不会调用默认构造函数。

如果需要多次创建User对象，可以写成下面方式重复利用
@Test
public void test2() {
    Objenesis objenesis = new ObjenesisStd();
    ObjectInstantiator<User> userObjectInstantiator = objenesis.getInstantiatorOf(User.class);
    User user1 = userObjectInstantiator.newInstance();
    System.out.println(user1);
    User user2 = userObjectInstantiator.newInstance();
    System.out.println(user2);
    System.out.println(user1 == user2);
}

运行输出

User{name='null'}
User{name='null'}
false
代码位置

com.javacode2018.aop.demo2.CreateObjectTest

CGLIB和Java动态代理的区别

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