动态代理类注册为Spring Bean的坑

背景介绍：

最近在搭建一个公共项目，类似业务操作记录上报的功能，就想着给业务方提供统一的sdk，在sdk中实现客户端和服务端的交互封装，对业务方几乎是无感的。访问关系如下图：

访问关系示意图
这里采用了http的方式进行交互，但是，如果每次接口调用都需要感知http的封装，一来代码重复度较高，二来新增或修改接口也需要同步更改客户端代码，就有点不太友好，维护成本较高；能否实现像调用本地方法一样调用远程服务（RPC）呢，当然是可以的，并且也有好多可以参考的例子。例如，feign client的实现思路，定义好服务端的接口，通过Java代理的方式创建代理类，在代理类中统一封装了http的调用，并且将代理类作为一个bean注入到Spring容器中，使用的时候就只要获取bean调用相应的方法即可。
写个简单的例子来验证一下：

假设有个远程服务，提供了如下接口：

1. package com.example.remoteserviceproxydemo;
3. /**
4. * IRemoteService
5. * @author beetle_shu
6. */
7. public interface IRemoteService {
9.     /**
10.      * getGreetingName
11.      * @return
12.      */
13.     String getGreetingName();
15.     /**
16.      * sayHello
17.      * @param name
18.      * @return
19.      */
20.     String sayHello(String name);
22. }

复制代码

接下来，我们自定义一个InvocationHandler 来实现远程方法的调用

1. package com.example.remoteserviceproxydemo;
3. import java.lang.reflect.InvocationHandler;
4. import java.lang.reflect.Method;
6. /**
7. * RemoteServiceInvocationHandler
8. * @author beetle_shu
9. */
10. public class RemoteServiceInvocationHandler implements InvocationHandler {
12.     @Override
13.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
14.         // 如果是远程http服务调用，通常有以下几步：
15.         // 1. 解析方法和参数：可以通过自定义注解，在方法上定义远程服务地址，请求方式GET/POST等信息
16.         // 2. 采用httpclient，OkHttp，或者restTemplate进行远程服务调用
17.         // 3. 解析http响应，反序列化成对应接口方法的返回对象
18.         // 这里，我们就不真正调用服务了，伪代码只是验证下被调用的方法是不是我们自己定义的，
19.         // 如果是的话返回当前方法名，如果不是的话，抛出异常，程序中断
20.         checkMethod(method);
21.         String methodName = method.getName();
22.         String param = "";
23.         if (args != null && args.length > 0) {
24.             param = String.valueOf(args[0]);
25.         }
26.         return methodName + ":" + param;
27.     }
29.     private void checkMethod(Method method) {
30.         Method[] methods = IRemoteService.class.getDeclaredMethods();
31.         for (Method m : methods) {
32.             if (m.getName().equals(method.getName())) {
33.                 return;
34.             }
35.         }
36.         throw new RuntimeException("method which is not declared, " + method.getName());
37.     }
38. }

复制代码

紧接着，通过java.lang.reflect.Proxy代理类创建一个代理对象，代理远程服务的调用，同时把该对象注册为Spring bean，加入Spring容器

1. package com.example.remoteserviceproxydemo;
3. import org.springframework.context.annotation.Bean;
4. import org.springframework.context.annotation.Configuration;
6. import java.lang.reflect.Proxy;
8. @Configuration
9. public class RemoteServiceProxyDemoConfiguration {
11.     @Bean
12.     public IRemoteService getRemoteService() {
13.         return (IRemoteService) Proxy.newProxyInstance(IRemoteService.class.getClassLoader(),
14.                 new Class[] { IRemoteService.class }, new RemoteServiceInvocationHandler());
15.     }
16. }

复制代码

最后，我们创建一个Controller来调用测试一下：

1. package com.example.remoteserviceproxydemo;
3. import org.springframework.web.bind.annotation.GetMapping;
4. import org.springframework.web.bind.annotation.PathVariable;
5. import org.springframework.web.bind.annotation.PostMapping;
6. import org.springframework.web.bind.annotation.RestController;
8. import javax.annotation.Resource;
10. @RestController
11. public class DemoController {
13.     @Resource
14.     private IRemoteService iRemoteService;
16.     @GetMapping("/getGreetingName")
17.     public String getGreetingName() {
18.         return iRemoteService.getGreetingName();
19.     }
21.     @PostMapping("/sayHello/{name}")
22.     public String sayHello(@PathVariable("name") String name) {
23.         return iRemoteService.sayHello(name);
24.     }
25. }

复制代码

1. ###
2. GET http://localhost:8080/getGreetingName
4. HTTP/1.1 200
5. Content-Type: text/plain;charset=UTF-8
6. Content-Length: 16
7. Date: Thu, 06 Oct 2022 12:28:45 GMT
8. Connection: close
10. getGreetingName:
12. ###
13. POST http://localhost:8080/sayHello/ketty
15. HTTP/1.1 200
16. Content-Type: text/plain;charset=UTF-8
17. Content-Length: 14
18. Date: Thu, 06 Oct 2022 12:30:40 GMT
19. Connection: close
21. sayHello:ketty

复制代码

通过测试我们可以看到，通过代理实现了远程接口的封装和调用，至此，一切正常，好像没毛病！！！可是，过了段时间就有同事找过来说依赖了我的sdk导致应用无法正常启动了。。。
问题分析：

通过报错的堆栈信息及debug跟踪，最后找到问题在Spring bean的创建过程中，registerDisposableBeanIfNecessary注册实现了Disposable Bean接口或者指定了destroy method的bean，亦或者是被指定的DestructionAwareBeanPostProcessor处理的bean，在bean销毁的时候执行对应的方法；我们看下如下代码片段：

1. /**
2. * Determine whether the given bean requires destruction on shutdown.
3. * <p>The default implementation checks the DisposableBean interface as well as
4. * a specified destroy method and registered DestructionAwareBeanPostProcessors.
5. * @param bean the bean instance to check
6. * @param mbd the corresponding bean definition
7. * @see org.springframework.beans.factory.DisposableBean
8. * @see AbstractBeanDefinition#getDestroyMethodName()
9. * @see org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor
10. */
11. protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) {
12.         return (bean.getClass() != NullBean.class && (DisposableBeanAdapter.hasDestroyMethod(bean, mbd) ||
13.       // 判断是否有DestructionAwareBeanPostProcessors处理该bean
14.                         (hasDestructionAwareBeanPostProcessors() && DisposableBeanAdapter.hasApplicableProcessors(
15.                                         bean, getBeanPostProcessorCache().destructionAware))));
16. }

复制代码

继续跟踪到 DisposableBeanAdapter.hasApplicableProcessors

1. /**
2. * Check whether the given bean has destruction-aware post-processors applying to it.
3. * @param bean the bean instance
4. * @param postProcessors the post-processor candidates
5. */
6. public static boolean hasApplicableProcessors(Object bean, List<DestructionAwareBeanPostProcessor> postProcessors) {
7.         if (!CollectionUtils.isEmpty(postProcessors)) {
8.                 for (DestructionAwareBeanPostProcessor processor : postProcessors) {
9.       // 每个processor根据自己的具体情况实现requiresDestruction方法，默认是返回true
10.                         if (processor.requiresDestruction(bean)) {
11.                                 return true;
12.                         }
13.                 }
14.         }
15.         return false;
16. }

复制代码

接下来，我们稍微改下代码来重现下该问题，加入spring-boot-starter-data-jpa 以及 mapper-spring-boot-starter依赖，重新启动应用之后，意想不到的事情发生了：

1. // 应用启动报错了，这个异常正是我们代理处理类中定义的，
2. // 说明应用启动的时候，调用了iRemoteService非声明的方法，这里打印出来的是【hashCode】方法
3. Caused by: org.springframework.beans.factory.BeanCreationException:
4. Error creating bean with name 'iRemoteService' defined in class path resource
5. [com/example/remoteserviceproxydemo/RemoteServiceProxyDemoConfiguration.class]:
6. Unexpected exception during bean creation; nested exception is java.lang.RuntimeException:
7. method which is not declared, hashCode

复制代码

通过以上代码分析，我们找到了调用的地方，PersistenceAnnotationBeanPostProcessor.requiresDestruction` 方法，这里最终会执行注册bean的hashCode方法，由于是代理类，所以会执行InvocationHandler的invoke方法；而hashCode方法并不是我们IRemoteService接口类中声明的方法，所以会在checkMethod中抛出异常

1. @Override
2. public boolean requiresDestruction(Object bean) {
3.   // 这里extendedEntityManagersToClose是ConcurrentHashMap
4.         return this.extendedEntityManagersToClose.containsKey(bean);
5. }
7. // ConcurrentHashMap的containsKey方法
8. /**
9. * Tests if the specified object is a key in this table.
10. *
11. * @param  key possible key
12. * @return {@code true} if and only if the specified object
13. *         is a key in this table, as determined by the
14. *         {@code equals} method; {@code false} otherwise
15. * @throws NullPointerException if the specified key is null
16. */
17. public boolean containsKey(Object key) {
18.     return get(key) != null;
19. }
21. /**
22. * Returns the value to which the specified key is mapped,
23. * or {@code null} if this map contains no mapping for the key.
24. *
25. * <p>More formally, if this map contains a mapping from a key
26. * {@code k} to a value {@code v} such that {@code key.equals(k)},
27. * then this method returns {@code v}; otherwise it returns
28. * {@code null}.  (There can be at most one such mapping.)
29. *
30. * @throws NullPointerException if the specified key is null
31. */
32. public V get(Object key) {
33.     Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
34.     // 这里可以看到，调用了hashCode方法，由于该bean是代理类，
35.     // 所以会执行RemoteServiceInvocationHandler的invoke方法，
36.     // 从而抛出自定义异常throw new RuntimeException("method which is not declared, " + method.getName());
37.     int h = spread(key.hashCode());
38.     if ((tab = table) != null && (n = tab.length) > 0 &&
39.         (e = tabAt(tab, (n - 1) & h)) != null) {
40.         if ((eh = e.hash) == h) {
41.             if ((ek = e.key) == key || (ek != null && key.equals(ek)))
42.                 return e.val;
43.         }
44.         else if (eh < 0)
45.             return (p = e.find(h, key)) != null ? p.val : null;
46.         while ((e = e.next) != null) {
47.             if (e.hash == h &&
48.                 ((ek = e.key) == key || (ek != null && key.equals(ek))))
49.                 return e.val;
50.         }
51.     }
52.     return null;
53. }

复制代码

解决方法：

• 不用代理类，写个具体实现类
  这种方法跟我们初衷有点相背离，以后接口新增修改也都要改sdk中的实现类，具体实现如下：
  1. package com.example.remoteserviceproxydemo;
  3. import java.lang.reflect.Proxy;
  5. // 定义具体的实现类
  6. public class RemoteServiceImpl implements IRemoteService {
  8.     private IRemoteService iRemoteService;
  10.     public RemoteServiceImpl() {
  11.         this.iRemoteService = (IRemoteService) Proxy.newProxyInstance(IRemoteService.class.getClassLoader(),
  12.                 new Class[] { IRemoteService.class }, new RemoteServiceInvocationHandler());
  13.     }
  15.     @Override
  16.     public String getGreetingName() {
  17.         return iRemoteService.getGreetingName();
  18.     }
  20.     @Override
  21.     public String sayHello(String name) {
  22.         return iRemoteService.sayHello(name);
  23.     }
  24. }

  复制代码
  1. package com.example.remoteserviceproxydemo;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  6. import java.lang.reflect.Proxy;
  8. @Configuration
  9. public class RemoteServiceProxyDemoConfiguration {
  11.     @Bean("iRemoteService")
  12.     public IRemoteService getRemoteService() {
  13. // 注册的bean也改为具体实现类，这样就可以绕过代理类没有【hashCode】方法的问题了
  14.         return new RemoteServiceImpl();
  15. //        return (IRemoteService) Proxy.newProxyInstance(IRemoteService.class.getClassLoader(),
  16. //                new Class[] { IRemoteService.class }, new RemoteServiceInvocationHandler());
  17.     }
  19. }

  复制代码
• 用代理类，在invoke方法中对【hashCode】方法调用做特殊处理
  这种方法也是参考feign的实现，改起来也比较简单，invoke方法进来先判断是hashCode/equals/toString方法，就执行重写的hashCode/equals/toString方法，改写RemoteServiceInvocationHandler如下 ：
  1. package com.example.remoteserviceproxydemo;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  7. /**
  8. * RemoteServiceInvocationHandler
  9. * @author beetle_shu
  10. */
  11. public class RemoteServiceInvocationHandler implements InvocationHandler {
  13.     @Override
  14.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  15.         // 新增对hashCode/equals/toString方法的处理
  16.         if ("equals".equals(method.getName())) {
  17.             try {
  18.                 Object otherHandler =
  19.                         args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
  20.                 // 可以根据实际情况重写【equals】方法
  21.                 return this.equals(otherHandler);
  22.             } catch (IllegalArgumentException e) {
  23.                 return false;
  24.             }
  25.         } else if ("hashCode".equals(method.getName())) {
  26.             // 可以根据实际情况重写【hashCode】方法
  27.             return this.hashCode();
  28.         } else if ("toString".equals(method.getName())) {
  29.             // 可以根据实际情况重写【toString】方法
  30.             return this.toString();
  31.         }
  32.         // 如果是远程http服务调用，通常有以下几步：
  33.         // 1. 解析方法和参数：可以通过自定义注解，在方法上定义远程服务地址，请求方式GET/POST等信息
  34.         // 2. 采用httpclient，OkHttp，或者restTemplate进行远程服务调用
  35.         // 3. 解析http响应，反序列化成对应接口方法的返回对象
  36.         // 这里，我们就不真正调用服务了，伪代码仅返回当前方法名
  37.         checkMethod(method);
  38.         String methodName = method.getName();
  39.         String param = "";
  40.         if (args != null && args.length > 0) {
  41.             param = String.valueOf(args[0]);
  42.         }
  43.         return methodName + ":" + param;
  44.     }
  46.     private void checkMethod(Method method) {
  47.         Method[] methods = IRemoteService.class.getDeclaredMethods();
  48.         for (Method m : methods) {
  49.             if (m.getName().equals(method.getName())) {
  50.                 return;
  51.             }
  52.         }
  53.         throw new RuntimeException("method which is not declared, " + method.getName());
  54.     }
  55. }

  复制代码
• 用FactoryBean的getObject返回代理类，并且自定义BeanDefinitionRegistrar注册bean
  这种方法也是我比较推荐的，很好的利用了Spring的扩展，进行动态bean的注册；当然，结合第2种方法一起实现，应该会完美：
  1. package com.example.remoteserviceproxydemo;
  3. import org.springframework.beans.factory.FactoryBean;
  5. import java.lang.reflect.Proxy;
  7. /**
  8. * 定义RemoteServiceFactoryBean
  9. * @author beetle_shu
  10. */
  11. public class RemoteServiceFactoryBean implements FactoryBean<IRemoteService> {
  13.     @Override
  14.     public IRemoteService getObject() throws Exception {
  15.         return (IRemoteService) Proxy.newProxyInstance(IRemoteService.class.getClassLoader(),
  16.                 new Class[] { IRemoteService.class }, new RemoteServiceInvocationHandler());
  17.     }
  19.     @Override
  20.     public Class<?> getObjectType() {
  21.         return IRemoteService.class;
  22.     }
  24.     @Override
  25.     public boolean isSingleton() {
  26.         return true;
  27.     }
  28. }

  复制代码
  自定义BeanDefinitionRegistryPostProcessor 并且通过FactoryBean注册iRemoteService
  1. package com.example.remoteserviceproxydemo;
  3. import org.springframework.beans.BeansException;
  4. import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
  5. import org.springframework.beans.factory.support.BeanDefinitionBuilder;
  6. import org.springframework.beans.factory.support.BeanDefinitionRegistry;
  7. import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
  9. /**
  10. * RemoteServiceBeanDefinitionRegistryPostProcessor
  11. * @author beetle_shu
  12. */
  13. public class RemoteServiceBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
  15.     @Override
  16.     public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
  17.         BeanDefinitionBuilder definitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(RemoteServiceFactoryBean.class);
  18.         registry.registerBeanDefinition("iRemoteService", definitionBuilder.getBeanDefinition());
  19.     }
  21.     @Override
  22.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  24.     }
  25. }

  复制代码
  修改下配置类，通过@Import加载RemoteServiceBeanDefinitionRegistryPostProcessor
  1. package com.example.remoteserviceproxydemo;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.Import;
  7. import java.lang.reflect.Proxy;
  9. @Configuration
  10. @Import(RemoteServiceBeanDefinitionRegistryPostProcessor.class)
  11. public class RemoteServiceProxyDemoConfiguration {
  13. //    @Bean("iRemoteService")
  14. //    public IRemoteService getRemoteService() {
  15. ////        return new RemoteServiceImpl();
  16. //        return (IRemoteService) Proxy.newProxyInstance(IRemoteService.class.getClassLoader(),
  17. //                new Class[] { IRemoteService.class }, new RemoteServiceInvocationHandler());
  18. //    }
  20. }

  复制代码
• 重写PersistenceAnnotationBeanPostProcessor
  个人不太建议用这种方式，除非对Spring框架有比较透彻的理解以及对源代码有比较高的把控度，具体实现可以参考该大神的文章：https://www.huluohu.com/posts/202102252023/
  

总结：

虽说是个小问题也比较细节，但是，整个过程梳理下来还是涉及到很多的知识点：Spring boot启动过程；Spring bean的生命周期；Spring boot扩展BeanPostProcessor; FactoryBean的用法；动态注册Spring bean的几种方法；Java反射及代理等等。通过这些知识的梳理，重新回顾的同时也学到了一些新的知识，希望以后能多抓住这种排查问题和分析问题的机会，多多总结，少踩坑。
参考：

• 如何记忆 Spring Bean 的生命周期 https://juejin.cn/post/6844904065457979405
  
• 三万字盘点Spring/Boot的那些扩展点 https://mdnice.com/writing/97dd3ca064304bc9b8d3231dbba2f3b8
  
• jpa调用远程代理类的hashcode方法导致无法初始化的问题 https://www.huluohu.com/posts/202102252023/
  
• 动态注册bean，Spring官方套路：使用BeanDefinitionRegistryPostProcessor https://zhuanlan.zhihu.com/p/30590254
  
• 使用BeanDefinitionRegistryPostProcessor动态注入BeanDefinition https://www.jianshu.com/p/b4bec64ada70
  

代码示例：


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！