服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|JavaScript|易语言|

服务器之家 - 编程语言 - Java教程 - 创建动态代理对象bean,并动态注入到spring容器中的操作

创建动态代理对象bean,并动态注入到spring容器中的操作

2021-08-10 10:54lichuangcsdn Java教程

这篇文章主要介绍了创建动态代理对象bean,并动态注入到spring容器中的操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧

使用过Mybatis的同学,应该都知道,我们只需要编写mybatis对应的接口和mapper XML文件即可,并不需要手动编写mapper接口的实现。这里mybatis就用到了JDK动态代理,并且将生成的接口代理对象动态注入到Spring容器中。

这里涉及到几个问题。也许有同学会有疑问,我们直接编写好类,加入@Component等注解不是可以注入了吗?或者在配置类(@Configuration)中直接声明该Bean类型不也可以注入吗?

但具体到mybatis,这里我们用的是接口。由于spring实例化对象时,如果没有特殊情况,默认都是通过反射形式来实例化Bean。而接口是无法直接通过Class.newInstance()方式进行实例化的。

第二个问题,如果手动声明Bean,其实也可以。但是会比较麻烦。因为我们还要手动创建代理对象,可能还需要给该对象的属性,比如(sqlSessionFactory,dataSource)设置对应的Bean实例。这些都会比较麻烦。况且Mapper接口可能会有很多个。

下面,我也写一个简单例子。用于说明如何将动态代理生成的接口实例,动态的注入到Spring容器中,并且能正常调用这2个接口里面的方法,获取调用结果。

解释下这里为什么说是动态注入?因为我们事先并不知道会有多少个这样的Bean,可以通过指定包路径,来扫描特定路径下的Bean。

整个代码结构如下:

创建动态代理对象bean,并动态注入到spring容器中的操作

如图所示,我有2个接口CalculateService和TestService,这2个接口并没有对应的实现类。现在我们通过动态代理生成实例,然后注入到TestController中

首先是创建一个SpringBoot maven工程

TestController源码

  1. package com.company.controller;
  2. import com.company.service.CalculateService;
  3. import com.company.service.TestService;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.web.bind.annotation.RequestMapping;
  6. import org.springframework.web.bind.annotation.RestController;
  7. @RestController
  8. public class TestController {
  9.  
  10. @Autowired
  11. private TestService testService;
  12.  
  13. @Autowired
  14. private CalculateService calculateService;
  15.  
  16. @RequestMapping("/test")
  17. public String getHello() {
  18. String testList = testService.getList("code123","name456");
  19. String calculateResult = calculateService.getResult("测试");
  20. return (testList + "," +calculateResult);
  21. }
  22. }

handler包下的ServiceBeanDefinitionRegistry源码:

  1. package com.company.handler;
  2. import org.springframework.beans.BeansException;
  3. import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
  4. import org.springframework.beans.factory.support.BeanDefinitionBuilder;
  5. import org.springframework.beans.factory.support.BeanDefinitionRegistry;
  6. import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
  7. import org.springframework.beans.factory.support.GenericBeanDefinition;
  8. import org.springframework.context.ApplicationContext;
  9. import org.springframework.context.ApplicationContextAware;
  10. import org.springframework.context.ResourceLoaderAware;
  11. import org.springframework.core.env.Environment;
  12. import org.springframework.core.io.Resource;
  13. import org.springframework.core.io.ResourceLoader;
  14. import org.springframework.core.io.support.ResourcePatternResolver;
  15. import org.springframework.core.io.support.ResourcePatternUtils;
  16. import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
  17. import org.springframework.core.type.classreading.MetadataReader;
  18. import org.springframework.core.type.classreading.MetadataReaderFactory;
  19. import org.springframework.stereotype.Component;
  20. import org.springframework.util.ClassUtils;
  21. import java.io.IOException;
  22. import java.util.LinkedHashSet;
  23. import java.util.Set;
  24.  
  25. /**
  26. * 用于Spring动态注入自定义接口
  27. * @author lichuang
  28. */
  29. @Component
  30. public class ServiceBeanDefinitionRegistry implements BeanDefinitionRegistryPostProcessor,ResourceLoaderAware,ApplicationContextAware {
  31. @Override
  32. public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
  33. //这里一般我们是通过反射获取需要代理的接口的clazz列表
  34. //比如判断包下面的类,或者通过某注解标注的类等等
  35. Set<Class<?>> beanClazzs = scannerPackages("com.company.service");
  36. for (Class beanClazz : beanClazzs) {
  37. BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(beanClazz);
  38. GenericBeanDefinition definition = (GenericBeanDefinition) builder.getRawBeanDefinition();
  39.  
  40. //在这里,我们可以给该对象的属性注入对应的实例。
  41. //比如mybatis,就在这里注入了dataSource和sqlSessionFactory,
  42. // 注意,如果采用definition.getPropertyValues()方式的话,
  43. // 类似definition.getPropertyValues().add("interfaceType", beanClazz);
  44. // 则要求在FactoryBean(本应用中即ServiceFactory)提供setter方法,否则会注入失败
  45. // 如果采用definition.getConstructorArgumentValues(),
  46. // 则FactoryBean中需要提供包含该属性的构造方法,否则会注入失败
  47. definition.getConstructorArgumentValues().addGenericArgumentValue(beanClazz);
  48.  
  49. //注意,这里的BeanClass是生成Bean实例的工厂,不是Bean本身。
  50. // FactoryBean是一种特殊的Bean,其返回的对象不是指定类的一个实例,
  51. // 其返回的是该工厂Bean的getObject方法所返回的对象。
  52. definition.setBeanClass(ServiceFactory.class);
  53.  
  54. //这里采用的是byType方式注入,类似的还有byName等
  55. definition.setAutowireMode(GenericBeanDefinition.AUTOWIRE_BY_TYPE);
  56. registry.registerBeanDefinition(beanClazz.getSimpleName(), definition);
  57. }
  58. }
  59.  
  60. private static final String DEFAULT_RESOURCE_PATTERN = "**/*.class";
  61. private MetadataReaderFactory metadataReaderFactory;
  62.  
  63. /**
  64. * 根据包路径获取包及子包下的所有类
  65. * @param basePackage basePackage
  66. * @return Set<Class<?>> Set<Class<?>>
  67. */
  68. private Set<Class<?>> scannerPackages(String basePackage) {
  69. Set<Class<?>> set = new LinkedHashSet<>();
  70. String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
  71. resolveBasePackage(basePackage) + '/' + DEFAULT_RESOURCE_PATTERN;
  72. try {
  73. Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
  74. for (Resource resource : resources) {
  75. if (resource.isReadable()) {
  76. MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
  77. String className = metadataReader.getClassMetadata().getClassName();
  78. Class<?> clazz;
  79. try {
  80. clazz = Class.forName(className);
  81. set.add(clazz);
  82. } catch (ClassNotFoundException e) {
  83. e.printStackTrace();
  84. }
  85. }
  86. }
  87. } catch (IOException e) {
  88. e.printStackTrace();
  89. }
  90. return set;
  91. }
  92.  
  93. protected String resolveBasePackage(String basePackage) {
  94. return ClassUtils.convertClassNameToResourcePath(this.getEnvironment().resolveRequiredPlaceholders(basePackage));
  95. }
  96.  
  97. @Override
  98. public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  99.  
  100. }
  101.  
  102. private ResourcePatternResolver resourcePatternResolver;
  103. private ApplicationContext applicationContext;
  104.  
  105. @Override
  106. public void setResourceLoader(ResourceLoader resourceLoader) {
  107. this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
  108. this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);
  109. }
  110.  
  111. @Override
  112. public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  113. this.applicationContext = applicationContext;
  114. }
  115.  
  116. private Environment getEnvironment() {
  117. return applicationContext.getEnvironment();
  118. }
  119. }

ServiceFactory源码:

  1. package com.company.handler;
  2. import org.springframework.beans.factory.FactoryBean;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Proxy;
  5.  
  6. /**
  7. * 接口实例工厂,这里主要是用于提供接口的实例对象
  8. * @author lichuang
  9. * @param <T>
  10. */
  11. public class ServiceFactory<T> implements FactoryBean<T> {
  12. private Class<T> interfaceType;
  13. public ServiceFactory(Class<T> interfaceType) {
  14. this.interfaceType = interfaceType;
  15. }
  16.  
  17. @Override
  18. public T getObject() throws Exception {
  19. //这里主要是创建接口对应的实例,便于注入到spring容器中
  20. InvocationHandler handler = new ServiceProxy<>(interfaceType);
  21. return (T) Proxy.newProxyInstance(interfaceType.getClassLoader(),
  22. new Class[] {interfaceType},handler);
  23. }
  24.  
  25. @Override
  26. public Class<T> getObjectType() {
  27. return interfaceType;
  28. }
  29.  
  30. @Override
  31. public boolean isSingleton() {
  32. return true;
  33. }
  34. }

ServiceProxy源码

  1. package com.company.handler;
  2. import com.alibaba.fastjson.JSON;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.util.Arrays;
  6.  
  7. /**
  8. * 动态代理,需要注意的是,这里用到的是JDK自带的动态代理,代理对象只能是接口,不能是类
  9. * @author lichuang
  10. */
  11.  
  12. public class ServiceProxy<T> implements InvocationHandler {
  13. private Class<T> interfaceType;
  14. public ServiceProxy(Class<T> intefaceType) {
  15. this.interfaceType = interfaceType;
  16. }
  17.  
  18. @Override
  19. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  20. if (Object.class.equals(method.getDeclaringClass())) {
  21. return method.invoke(this,args);
  22. }
  23. System.out.println("调用前,参数:{}" + args);
  24. //这里可以得到参数数组和方法等,可以通过反射,注解等,进行结果集的处理
  25. //mybatis就是在这里获取参数和相关注解,然后根据返回值类型,进行结果集的转换
  26. Object result = JSON.toJSONString(args);
  27. System.out.println("调用后,结果:{}" + result);
  28. return result;
  29. }
  30. }

另外2个接口源码:

  1. package com.company.service;
  2. public interface CalculateService {
  3. String getResult(String name);
  4. }

TestService接口

  1. package com.company.service;
  2. public interface TestService {
  3. String getList(String code, String name);
  4. }

我们DEBUG运行,可以看到程序正常运行,两个Service接口都已正常的注入到控制器中了,程序也能正常返回接口。

创建动态代理对象bean,并动态注入到spring容器中的操作

创建动态代理对象bean,并动态注入到spring容器中的操作

补充:Spring动态 注入/删除 Bean

我们通过getBean来获得对象,但这些对象都是事先定义好的,我们有时候要在程序中动态的加入对象.因为如果采用配置文件或者注解,我们要加入对象的话,还要重启服务,如果我们想要避免这一情况就得采用动态处理bean,包括:动态注入,动态删除。

1 动态注入bean思路

在具体进行代码实现的时候,我们要知道,Spring管理bean的对象是BeanFactory,具体的是DefaultListableBeanFactory,在这个类当中有一个注入bean的方法:registerBeanDefinition,在调用registerBeanDefinition方法时,需要BeanDefinition参数,那么这个参数怎么获取呢?

Spring提供了BeanDefinitionBuilder可以构建一个BeanDefinition,那么我们的问题就是如何获取BeanFactory了,这个就很简单了,只要获取到ApplicationContext对象即可获取到BeanFacory了。

2. 动态注入实现代码

综上所述,如果我们要编写一个简单里的例子的话,那么分以个几个步骤进行编码即可进行动态注入了:

1、获取ApplicationContext;

2、通过ApplicationContext获取到BeanFacotory;

3、通过BeanDefinitionBuilder构建BeanDefiniton;

4、调用beanFactory的registerBeanDefinition注入beanDefinition;

5、使用ApplicationContext.getBean获取bean进行测试;

我们需要先定义个类进行测试,比如TestService代码如下:

  1. package com.kfit.demo.service;
  2. public class TestService {
  3. private String name;
  4. public String getName() {
  5. return name;
  6. }
  7. public void setName(String name) {
  8. this.name = name;
  9. }
  10. public void print(){
  11. System.out.println("动态载入bean,name="+name);
  12. }
  13. }

那么下面我们的目标就是动态注入TestService了,根据以上的分析,我们进行编码,具体代码如下:

  1. //获取context.
  2. ApplicationContext ctx = (ApplicationContext) SpringApplication.run(App.class, args);
  3.  
  4. //获取BeanFactory
  5. DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory)ctx.getAutowireCapableBeanFactory();
  6.  
  7. //创建bean信息
  8. BeanDefinitionBuilderbeanDefinitionBuilder =BeanDefinitionBuilder.genericBeanDefinition(TestService.class);
  9. beanDefinitionBuilder.addPropertyValue("name","张三");
  10.  
  11. //动态注册bean
  12. defaultListableBeanFactory.registerBeanDefinition("testService",beanDefinitionBuilder.getBeanDefinition());
  13.  
  14. //获取动态注册的bean
  15. TestService testService =ctx.getBean(TestService.class);
  16. testService.print();

执行代码

  1. 动态载入bean,name=张三

到这里,就证明我们的代码很成功了。

3 多次注入同一个bean的情况

多次注入同一个bean的,如果beanName不一样的话,那么会产生两个Bean;如果beanName一样的话,后面注入的会覆盖前面的。

第一种情况:beanName一样的代码:

  1. beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(TestService.class);
  2. beanDefinitionBuilder.addPropertyValue("name","李四");
  3. defaultListableBeanFactory.registerBeanDefinition("testService", beanDefinitionBuilder.getBeanDefinition());

运行看控制台:

  1. 动态载入bean,name=李四

第二种情况:beanName不一样的代码:

  1. beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(TestService.class);
  2. beanDefinitionBuilder.addPropertyValue("name","李四");
  3. defaultListableBeanFactory.registerBeanDefinition("testService1",beanDefinitionBuilder.getBeanDefinition());
  4. TestService testService =ctx.getBean(TestService.class);
  5. testService.print();

此时如果没有更改别的代码直接运行的话,是会报如下错误的:

Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [com.kfit.demo.service.TestService] is defined: expected single matching bean but found 2: testService1,testService

大体意思就是在按照 byType getBean的时候,找到了两个bean,这时候就不知道要获取哪个了,所以在获取的时候,我们就要使用byName指定我们是要获取的testService还是testService1,只需要修改一句代码:

  1. TestService testService =ctx.getBean("testService");

一般重复注入一个新Bean的情况较少,多数情况都是讲已有的Bean注入到容器中,

  1. applicationContext.getAutowireCapableBeanFactory().applyBeanPostProcessorsAfterInitialization(obj, obj.getClass().getName());
  2. beanFactory.registerSingleton(obj.getClass().getName(), obj);

第一行:让obj完成Spring初始化过程中所有增强器检验,只是不重新创建obj,

第二行:将obj以单例的形式入驻到容器中,此时通过obj.getClass().getName()或obj.getClass()都可以拿到放入Spring容器的Bean。

4 动态删除

相对于动态注入,动态删除就很简单了,直接奉上代码:

  1. //删除bean.
  2. defaultListableBeanFactory.removeBeanDefinition("testService");

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。如有错误或未考虑完全的地方,望不吝赐教。

原文链接:https://blog.csdn.net/lichuangcsdn/article/details/89694363

延伸 · 阅读

精彩推荐