您好,登录后才能下订单哦!
这篇文章主要讲解了“怎么动态替换Spring容器中的Bean”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“怎么动态替换Spring容器中的Bean”吧!
最近在编写单测时,发现使用 Mock 工具预定义 Service 中方法的行为特别难用,而且无法精细化的实现自定义的行为,因此想要在 Spring 容器运行过程中使用自定义 Mock 对象,该对象能够代替实际的 Bean 的给定方法。
创建一个 Mock 注解,并且在 Spring 容器注册完所有的 Bean 之后,解析 classpath 下所有引入该 Mock 注解的类,使用 Mock 注解标记的 Bean 替换注解中指定名称的 Bean。
这种方式类似于 mybatis-spring 动态解析 @Mapper 注解的方法(MapperScannerRegistrar 实现了@Mapper 注解的扫描),但是不一样的是 mybatis-spring 使用工厂类替换接口类,而我们是用 Mock 的 Bean 替换实际的 Bean。
创建 Mock 注解
/** * 为指定的 Bean 创建 Mock 对象,需要继承原始 Bean */ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface FakeBeanFor { String value(); // 需要替换的 Bean 的名称 }
在 Spring 容器注册完所有的 Bean 后,解析 classpath 下引入 @FakeBeanFor 注解的类,使用 @FakeBeanFor 注解标记的 Bean 替换 value 中指定名称的 Bean。
/** * 从当前 classpath 读取 @FakeBeanFor 注解的类,并替换指定名称的 bean */ @Slf4j @Configuration @ConditionalOnExpression("${unitcases.enable.fake:true}") // 通过 BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry 可以将 Bean 动态注入容器 // 通过 BeanFactoryAware 可以自动注入 BeanFactory public class FakeBeanConfiguration implements BeanDefinitionRegistryPostProcessor, BeanFactoryAware { private BeanFactory beanFactory; @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { log.debug("searching for classes annotated with @FakeBeanFor"); // 自定义 Scanner 扫描 classpath 下的指定注解 ClassPathFakeAnnotationScanner scanner = new ClassPathFakeAnnotationScanner(registry); try { List<String> packages = AutoConfigurationPackages.get(this.beanFactory); // 获取包路径 if (log.isDebugEnabled()) { for (String pkg : packages) { log.debug("Using auto-configuration base package: {}", pkg); } } scanner.doScan(StringUtils.toStringArray(packages)); // 扫描所有加载的包 } catch (IllegalStateException ex) { log.debug("could not determine auto-configuration package, automatic fake scanning disabled.", ex); } } @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory factory) throws BeansException { // empty } @Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { this.beanFactory = beanFactory; } private static class ClassPathFakeAnnotationScanner extends ClassPathBeanDefinitionScanner { ClassPathFakeAnnotationScanner(BeanDefinitionRegistry registry) { super(registry, false); // 设置过滤器。仅扫描 @FakeBeanFor addIncludeFilter(new AnnotationTypeFilter(FakeBeanFor.class)); } @Override public Set<BeanDefinitionHolder> doScan(String... basePackages) { List<String> fakeClassNames = new ArrayList<>(); // 扫描全部 package 下 annotationClass 指定的 Bean Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages); GenericBeanDefinition definition; for (BeanDefinitionHolder holder : beanDefinitions) { definition = (GenericBeanDefinition) holder.getBeanDefinition(); // 获取类名,并创建 Class 对象 String className = definition.getBeanClassName(); Class<?> clazz = classNameToClass(className); // 解析注解上的 value FakeBeanFor annotation = clazz.getAnnotation(FakeBeanFor.class); if (annotation == null || StringUtils.isEmpty(annotation.value())) { continue; } // 使用当前加载的 @FakeBeanFor 指定的 Bean 替换 value 里指定名称的 Bean if (getRegistry().containsBeanDefinition(annotation.value())) { getRegistry().removeBeanDefinition(annotation.value()); getRegistry().registerBeanDefinition(annotation.value(), definition); fakeClassNames.add(clazz.getName()); } } log.info("found fake beans: " + fakeClassNames); return beanDefinitions; } // 反射通过 class 名称获取 Class 对象 private Class<?> classNameToClass(String className) { try { return Class.forName(className); } catch (ClassNotFoundException e) { log.error("create instance failed.", e); } return null; } } }
有点儿不一样的是这是一个配置类,将它放置到 Spring 的自动扫描路径上,就可以自动扫描 classpath 下 @FakeBeanFor 指定的类,并将其加载为 BeanDefinition。
在 FakeBeanConfiguration 上还配置了 ConditionalOnExpression,这样就可以只在单测环境下的 application.properties 文件中设置指定条件使得该 Configuration 生效。
注意:
这里 unitcases.enable.fake:true 默认开启了替换,如果想要默认关闭则需要设置 unitcases.enable.fake:false,并且在单测环境的 application.properties 文件设置 unitcases.enable.fake=true。
举例
假设在容器中定义如下 Service:
@Service public class HelloService { public void sayHello() { System.out.println("hello real world!"); } }
在单测环境下希望能够改变它的行为,但是又不想修改这个类本身,则可以使用 @FakeBeanFor 注解:
@FakeBeanFor("helloService") public class FakeHelloService extends HelloService { @Override public void sayHello() { System.out.println("hello fake world!"); } }
通过继承实际的 Service,并覆盖 Service 的原始方法,修改其行为。在单测中可以这样使用:
@SpringBootTest @RunWith(SpringRunner.class) public class FakeHelloServiceTest { @Autowired private HelloService helloService; @Test public void testSayHello() { helloService.sayHello(); // 输出:“hello fake world!” } }
总结:通过自定义的 Mock 对象动态替换实际的 Bean 可以实现单测环境下比较难以使用 Mock 框架实现的功能,如将原本的异步调用逻辑修改为同步调用,避免单测完成时,异步调用还未执行完成的场景。
需求:通过配置文件,能够使得新的一个service层类替代jar包中原有的类文件。
项目原因,引用了一些成型产品的jar包,已经不能对其进行修改了。
故,考虑采用用新的类替换jar包中的类。
实现思路:在配置文件中配置新老类的全类名,读取配置文件后,通过spring初始化bean的过程中,移除spring容器中老类的bean对象,手动注册新对象进去,bean名称和老对象一致即可。
jar包中的老对象是通过@Service注册到容器中的。
新的类因为是手动配置,不需要添加任何注解。
实现的方法如下:
@Component public class MyBeanPostProcessor implements ApplicationContextAware, BeanPostProcessor { @Autowired private AutowireCapableBeanFactory beanFactory; @Autowired private DefaultListableBeanFactory defaultListableBeanFactory; static HashMap ReplaceClass; static String value = null; static { try { value = PropertiesLoaderUtils.loadAllProperties("你的配置文件路径").getProperty("replaceClass"); } catch (IOException e) { e.printStackTrace(); } System.out.println("properties value........"+value); } @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("对象" + beanName + "开始实例化"); System.out.println("类名" + bean.getClass().getName() + "是啥"); if(StringUtils.contains(value,bean.getClass().getName())){ System.out.println("找到了需要进行替换的类。。。。。。。。。。。"); boolean containsBean = defaultListableBeanFactory.containsBean(beanName); if (containsBean) { //移除bean的定义和实例 defaultListableBeanFactory.removeBeanDefinition(beanName); } String temp = value; String tar_class = temp.split(bean.getClass().getName())[1].split("#")[1].split(",")[0]; System.out.println(tar_class); try { Class tar = Class.forName(tar_class); Object obj = tar.newInstance(); //注册新的bean定义和实例 defaultListableBeanFactory.registerBeanDefinition(beanName, BeanDefinitionBuilder.genericBeanDefinition(tar.getClass()).getBeanDefinition()); //这里要手动注入新类里面的依赖关系 beanFactory.autowireBean(obj); return obj; } catch (Exception e) { e.printStackTrace(); } } return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { return bean; } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { }
配置文件中的格式采用下面的样式 :
replaceClass=gov.df.fap.service.OldTaskBO#gov.df.newmodel.service.NewTaskBO
在启动的时候,会找到容器中的老的bean,将其remove掉,然后手动注册新的bean到容器中。
感谢各位的阅读,以上就是“怎么动态替换Spring容器中的Bean”的内容了,经过本文的学习后,相信大家对怎么动态替换Spring容器中的Bean这一问题有了更深刻的体会,具体使用情况还需要大家实践验证。这里是亿速云,小编将为大家推送更多相关知识点的文章,欢迎关注!
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。