一、序

去年我们部门的工作重点是业务需求。邻近业务高峰期，各种业务需求扑面而来。业务高峰期过后，业务模型逐渐稳定成熟。加班加点堆砌出来的业务代码难免会有些bug或者代码设计不合理，子业务模块边界不清晰，业务之间强耦合的情况，所以今年的任务主要是保证服务的稳定性的前提下，对业务代码进行迁移，对边界重新划分，对子模块进行重构。
在做一个模块重构的过程中，由于涉及到多数据源的应用，所以想用切面 + mybatis的mapper 方式来实现。在写切面的时候发现了一个问题，后来根据这个问题发现了自己的基础知识还存在一些坑。所以就把导致问题原因的本质从中剥离出来，进行探索和讨论。

二、代码场景

2.1 代码

接口定义 UserService

public interface UserService {
    List getUserList();
}

实现类 UserServiceImpl

@Service("userService")
public class UserServiceImpl implements UserService {

    @Resource
    private UserDao userDao;

    public List getUserList() {
        return userDao.getUserList();
    }
}

对外暴露 http 测试接口
ps:注意此处注入的类型是 UserServiceImpl

@Controller
@RequestMapping("/user")
public class UserController {

    @Resource
    private UserServiceImpl userService;

    @RequestMapping(
            value = "/list",
            produces = MediaType.APPLICATION_JSON_UTF8_VALUE,
            method = RequestMethod.GET)
    @ResponseBody
    public String getUserList() {
        return new Response().data(GsonUtils.toJson(userService.getUserList())).toString();
    }
}

切面定义 LoggerAspect

@Component("loggerAspect")
public class LoggerAspect {

    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕通知的之前部分");
        Object proceed = pjp.proceed();
        System.out.println("环绕通知的之后部分");
        return proceed;
    }
}

Spring使用xml方式配置AOP

2.2 原因解析

显而易见，代码想表达的意思是给 userService对象执行方法的时候添加一个环绕切面。到目前为止，配置和代码看似没问题，但是启动会报错。

控制台打印的启动Error

Error creating bean with name 'userController': Injection of resource dependencies failed; nested exception is org.springframework.beans.factory.BeanNotOfRequiredTypeException: Bean named 'userService' must be of type [com.yiru.service.impl.UserServiceImpl], but was actually of type [com.sun.proxy.$Proxy20]

这个异常的意思是：注入 UserService 属性过程中出现异常，期望 userService 对象的类型是 UserServiceImpl，但实际却是 $Proxy20。

为什么呢？

Q1：为什么实际类型会是 $Proxy20 ？
Q2：为什么 UserService 能够承接住类型为 $Proxy20 的对象？

该如何改正呢？

先说结论：如果使用切面的话，被切入的 Bean 的被注入方式和切面的代理方式有关。
还是以上方代码为例

如果在 UserController 中注入时写 private UserService useService，也就是用接口的类型去作为引用类型，那么使用 JDK 或者 CGlib 两种代理方式都可以
如果写 private UserServiceImpl userService，也就是用实现类的类型去作为引用类型，就只能用 CGlib 的方式，如果使用 JDK 的代理方式，则会出现上文的异常

2.3 解决方法

2.3.1 修改注入时属性的引用类型

@Controller
@RequestMapping("/user")
public class UserController {

    @Resource
    private UserService userService;

    @RequestMapping(
            value = "/list",
            produces = MediaType.APPLICATION_JSON_UTF8_VALUE,
            method = RequestMethod.GET)
    @ResponseBody
    public String getUserList() {
        return new Response().data(GsonUtils.toJson(userService.getUserList())).toString();
    }
}

2.3.2 修改 AOP 切面的代理方式

如果 aop 配置没有加 proxy-target-class 属性设置，spring 会以默认的方式（JDK Proxy）创建代理对象

三、原因解析

根据上方现象，我们已经得出两个结论：

无论是接口还是实现类哪种属性的引用类型，CGlib 的代理方式都支持
JDK代理方式只支持接口类型作为引用类型

以及两个问题：

Q1：为什么实际类型会是 $Proxy20 ？
Q2：为什么 UserService 能够承接住类型为 $Proxy20 的对象？

A1：如果我们不使用切面的话，Spring 的注入行为就像我们自己在代码里面 new 一样。需要注入什么类，就将该类配置到 Spring中，配置的方式可以用xml的bean配置，也可以用@Service注解。最终的效果相当于：

private UserService userService = new UserServiceImpl;

如果我们使用了切面，就不再是单纯的注入指定对象了。AOP的底层原理是动态代理，在注入之前，首先对 UserServiceImpl 进行代理，生成一个代理对象，然后再将代理对象注入到相应的位置。
此处有引出另外一个问题。

Q3：为什么代理对象能够赋值给接口类型？
这个问题的答案需要去探索 JDK 的 Proxy 底层的运作原理。

3.1 Java 中动态代理原理

为了容易理解，提供一个Demo
代理接口 UserService

public interface UserService {
    void hello();
}

实现类 UserServiceImpl

public class UserServiceImpl implements UserService {
    @Override
    public void hello() {
        System.out.println("hello");
    }
}

main方法

public class ProxyDemo {

    public static void main(String[] args) {
        Object proxy = Proxy.newProxyInstance(
                ProxyDemo.class.getClassLoader(),
                new Class[]{UserService.class},
                new InvocationHandler() {

                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        System.out.println("before invoke");
                        Object result = method.invoke(new UserServiceImpl(), args);
                        System.out.println("after invoke");
                        return result;
                    }
                });

        System.out.println("proxy className: " + proxy.getClass().getName());
        System.out.println("proxy instanceof UserService: " + (proxy instanceof UserService));

        UserService userService = (UserService) proxy;
        userService.hello();
    }
}

运行结果

proxy className: com.sun.proxy.$Proxy0
proxy instanceof UserService: true
before invoke
hello
after invoke

    @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h) throws IllegalArgumentException {
        //如果h为空将抛出异常
        Objects.requireNonNull(h);

        final Class[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
             //在这里对某些安全权限进行检查，确保我们有权限对预期的被代理类进行代理
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        //获取代理类的 Class 对象
        Class cl = getProxyClass0(loader, intfs);

        //使用指定的invocationHandler调用构造方法
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //调用代理对象的构造函数（代理对象的构造函数$Proxy0(InvocationHandler h)，通过字节码反编译可以查看生成的代理类）
            final Constructor cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            //假如代理类的构造函数是private的，就使用反射来set accessible
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            //生成代理类的实例，并把MyInvocationHander的实例作为构造函数参数传入
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

核心分为三步：

运行时获取需要生成代理对象的 Class 对象
通过 Class 对象获取所需构造器
将 InvocationHandler 实例作为参数，通过构造器创建代理对象

获取代理类的细节，中间省略掉一部分，只挑与本主题相关的关键代码，想知道具体代码流程可自行 debug。

private static final class ProxyClassFactory
        implements BiFunction[], Class>
    {
        // 代理类的名字的前缀统一为“$Proxy”
        private static final String proxyClassNamePrefix = "$Proxy";

        // // 每个代理类前缀后面都会跟着一个唯一的编号，如$Proxy0、$Proxy1、$Proxy2，$Proxy后面加上独有的数字，该数字要求是线程安全的，可以详细了解AtomicLong是如何保证线程安全的
        private static final AtomicLong nextUniqueNumber = new AtomicLong();

        @Override
        public Class apply(ClassLoader loader, Class[] interfaces) {

            Map, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class intf : interfaces) {

                //验证类加载器加载接口得到对象是否与由apply函数参数传入的对象相同
                Class interfaceClass = null;
                try {
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
                //验证这个Class对象是不是接口
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                //验证这个接口是否重复
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }

            String proxyPkg = null;     // 声明代理类所在的package
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            //记录一个非公共代理接口的包，以便在同一个包中定义代理类。同时验证所有非公共代理接口都在同一个包中
            for (Class intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                // 如果全是公共代理接口，那么生成的代理类就在com.sun.proxy package下
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            //为代理类生成一个name  package name + 前缀+唯一编号，如 com.sun.proxy.$Proxy0.class
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            //根据上方代码创建好的 ClassName 和传进来的 interfaces，创建所需代理类的字节码数组
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                //将字节码数组转换成运行时所需的 Class 对象，并返回
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                /*
                 * A ClassFormatError here means that (barring bugs in the
                 * proxy class generation code) there was some other
                 * invalid aspect of the arguments supplied to the proxy
                 * class creation (such as virtual machine limitations
                 * exceeded).
                 */
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

根据上方源码追踪，可以得到结论：

代理类的 Class 对象是运行时生成的
生成的时候，传入的 UserService.class 接口类型作为参数之一，所以生成的 Class 对象与 UserService.class 之间存在血缘关系
所以用上述 Class 对象创建的代理对象是 UserService 的一个实现类
创建出来的代理对象与 UserServiceImpl.class 没有直系血缘关系，UserServiceImpl 的实例仅仅是作为执行被代理方法的内容，提供给代理对象。代理类与UserServiceImpl之间是亲兄弟，两者等级相同，都是 UserService 的直系子类。
所以，当 UserController 中注入类型为 UserServiceImpl 的时候，使用 JDK 的代理方式会出现异常，因为无法将运行时生成的代理对象赋值给 UserServiceImpl 类型，理由为第四条。

3.2 CGlib 动态代理

CGlib动态代理的原理是在运行时生成一个被代理对象的子类，所以在 UserController 中属性类型使用 UserServiceImpl 是可以的，同理，使用 UserService 也是可以的，因为运行时生成的代理对象、UserServiceImpl 和 UserService 是一条继承线。爸爸能 hold 住的，爷爷更加能 hold 住。

3.3 总结

两种代理方式中三者的关系可以参考下图

两种代理方式中三者的相互关系

ps：上述内容有些可能描述不清楚，还望参考以下博客进行理解。如描述有错误，还望留言，我会虚心积极改正，谢谢~

Spring与JDK动态代理

一、序