前言

springboot团队之所以默认的代理模式设置成cglib代理，是因为他们认为使用cglib更不容易出现转换错误

This was changed in 1.4 (see https://github.com/spring-projects/spring-boot/issues/5423). We’ve generally found cglib proxies less likely to cause unexpected cast exceptions.

整体逻辑

先梳理一下整体的逻辑

jdk动态代理demo

interface IUserService{
     void getUser();
}
class UserServiceImpl implements IUserService{
    @Override
    public void getUser() {
        System.out.println("usersevice的getUser方法");
    }
}

通过上面的图,在bean后置处理器的时候拿到当前的bean对象然后进行代理,最终返回代理对象;

//创建jdk代理的方法

  /**
     * 第一种 jDk
     */
    public static Object createJdkProxy(Object currentObj){
        return Proxy.newProxyInstance(SpringProxyDemo.class.getClassLoader(),currentObj.getClass().getInterfaces(),new Invoke(currentObj));
    }

handler 在方法前后需要增强的功能 ;

class Invoke implements InvocationHandler {
 
    private Object o;//真实的对象
 
    public Invoke(Object object){
        this.o = object;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法前后打印日志:--------before");
        Object invoke = method.invoke(o, args); //执行对象的方法
        System.out.println("方法前后打印日志--------after");
        return invoke;
    }
}

模拟一下:

通过反射创建对象 : userService

aop增强打印日志: userService对象传入handler里面 ,该对象才是真正执行方法的对象,返回代理对象

进行方法调用

public static void main(String[] args) throws Exception{
        //1.这里类似于spring,简写哈:Spring - BeanDefine 根据里面的class信息进行反射创建对象
        Class<UserServiceImpl> userServiceClass = UserServiceImpl.class;
        UserServiceImpl userService = userServiceClass.newInstance();
        //这里相当于spring的bean对象,现在要在service方法前后增加日志,所以要用aop, 调用bean的后置处理器
        //创建代理对象 - 并返回,此时bean工厂里面的实例就是该代理对象
        IUserService userServiceProxy = (IUserService)createJdkProxy(userService);
        //调用方法
        userServiceProxy.getUser();
    }

看一下执行结果:

CGLBdemo

通过上面的图,在bean后置处理器的时候拿到当前的bean对象然后进行代理,最终返回代理对象;

class Inteceptor implements MethodInterceptor{
 
    private Object obj;
    public Inteceptor(Object object){
        this.obj = object;
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("CGLB-方法前后打印日志:--------before");
        Object invoke = methodProxy.invoke(obj, objects); //执行对象的方法
        System.out.println("CGLB-方法前后打印日志--------after");
        return invoke;
    }
}

  public static Object createCGLBProxy(Object currentObj){
        Enhancer enhancer = new Enhancer();
        // 设置enhancer对象的父类
        enhancer.setSuperclass(currentObj.getClass());
        // 设置enhancer的回调对象
        enhancer.setCallback(new Inteceptor(currentObj));
        // 创建代理对象
         return  enhancer.create();
    }

public static void main(String[] args) throws Exception{
        //1.这里类似于spring,简写哈:Spring - BeanDefine 根据里面的class信息进行反射创建对象
        Class<UserServiceImpl> userServiceClass = UserServiceImpl.class;
        UserServiceImpl userService = userServiceClass.newInstance();
        //这里已经创建对象了,现在要在service方法前后增加日志,所以要用aop, 调用bean的后置处理器
        //创建代理对象 - 并返回,此时bean工厂里面的实例就是该代理对象
        UserServiceImpl cglbProxy = (UserServiceImpl)createCGLBProxy(userService);
        cglbProxy.getUser();
 
    }