创建动态代理对象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。
整个代码结构如下:
如图所示,我有2个接口CalculateService和TestService,这2个接口并没有对应的实现类。现在我们通过动态代理生成实例,然后注入到TestController中
首先是创建一个SpringBoot maven工程
TestController源码
package com.company.controller; import com.company.service.CalculateService; import com.company.service.TestService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class TestController { @Autowired private TestService testService; @Autowired private CalculateService calculateService; @RequestMapping("/test") public String getHello() { String testList = testService.getList("code123","name456"); String calculateResult = calculateService.getResult("测试"); return (testList + "," +calculateResult); } }
handler包下的ServiceBeanDefinitionRegistry源码:
package com.company.handler; import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor; import org.springframework.beans.factory.support.GenericBeanDefinition; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.context.ResourceLoaderAware; import org.springframework.core.env.Environment; import org.springframework.core.io.Resource; import org.springframework.core.io.ResourceLoader; import org.springframework.core.io.support.ResourcePatternResolver; import org.springframework.core.io.support.ResourcePatternUtils; import org.springframework.core.type.classreading.CachingMetadataReaderFactory; import org.springframework.core.type.classreading.MetadataReader; import org.springframework.core.type.classreading.MetadataReaderFactory; import org.springframework.stereotype.Component; import org.springframework.util.ClassUtils; import java.io.IOException; import java.util.LinkedHashSet; import java.util.Set; /** * 用于Spring动态注入自定义接口 * @author lichuang */ @Component public class ServiceBeanDefinitionRegistry implements BeanDefinitionRegistryPostProcessor,ResourceLoaderAware,ApplicationContextAware { @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { //这里一般我们是通过反射获取需要代理的接口的clazz列表 //比如判断包下面的类,或者通过某注解标注的类等等 Set<Class<?>> beanClazzs = scannerPackages("com.company.service"); for (Class beanClazz : beanClazzs) { BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(beanClazz); GenericBeanDefinition definition = (GenericBeanDefinition) builder.getRawBeanDefinition(); //在这里,我们可以给该对象的属性注入对应的实例。 //比如mybatis,就在这里注入了dataSource和sqlSessionFactory, // 注意,如果采用definition.getPropertyValues()方式的话, // 类似definition.getPropertyValues().add("interfaceType", beanClazz); // 则要求在FactoryBean(本应用中即ServiceFactory)提供setter方法,否则会注入失败 // 如果采用definition.getConstructorArgumentValues(), // 则FactoryBean中需要提供包含该属性的构造方法,否则会注入失败 definition.getConstructorArgumentValues().addGenericArgumentValue(beanClazz); //注意,这里的BeanClass是生成Bean实例的工厂,不是Bean本身。 // FactoryBean是一种特殊的Bean,其返回的对象不是指定类的一个实例, // 其返回的是该工厂Bean的getObject方法所返回的对象。 definition.setBeanClass(ServiceFactory.class); //这里采用的是byType方式注入,类似的还有byName等 definition.setAutowireMode(GenericBeanDefinition.AUTOWIRE_BY_TYPE); registry.registerBeanDefinition(beanClazz.getSimpleName(), definition); } } private static final String DEFAULT_RESOURCE_PATTERN = "**/*.class"; private MetadataReaderFactory metadataReaderFactory; /** * 根据包路径获取包及子包下的所有类 * @param basePackage basePackage * @return Set<Class<?>> Set<Class<?>> */ private Set<Class<?>> scannerPackages(String basePackage) { Set<Class<?>> set = new LinkedHashSet<>(); String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + resolveBasePackage(basePackage) + '/' + DEFAULT_RESOURCE_PATTERN; try { Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath); for (Resource resource : resources) { if (resource.isReadable()) { MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource); String className = metadataReader.getClassMetadata().getClassName(); Class<?> clazz; try { clazz = Class.forName(className); set.add(clazz); } catch (ClassNotFoundException e) { e.printStackTrace(); } } } } catch (IOException e) { e.printStackTrace(); } return set; } protected String resolveBasePackage(String basePackage) { return ClassUtils.convertClassNameToResourcePath(this.getEnvironment().resolveRequiredPlaceholders(basePackage)); } @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { } private ResourcePatternResolver resourcePatternResolver; private ApplicationContext applicationContext; @Override public void setResourceLoader(ResourceLoader resourceLoader) { this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader); this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader); } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.applicationContext = applicationContext; } private Environment getEnvironment() { return applicationContext.getEnvironment(); } }
ServiceFactory源码:
package com.company.handler; import org.springframework.beans.factory.FactoryBean; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; /** * 接口实例工厂,这里主要是用于提供接口的实例对象 * @author lichuang * @param <T> */ public class ServiceFactory<T> implements FactoryBean<T> { private Class<T> interfaceType; public ServiceFactory(Class<T> interfaceType) { this.interfaceType = interfaceType; } @Override public T getObject() throws Exception { //这里主要是创建接口对应的实例,便于注入到spring容器中 InvocationHandler handler = new ServiceProxy<>(interfaceType); return (T) Proxy.newProxyInstance(interfaceType.getClassLoader(), new Class[] {interfaceType},handler); } @Override public Class<T> getObjectType() { return interfaceType; } @Override public boolean isSingleton() { return true; } }
ServiceProxy源码
package com.company.handler; import com.alibaba.fastjson.JSON; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.util.Arrays; /** * 动态代理,需要注意的是,这里用到的是JDK自带的动态代理,代理对象只能是接口,不能是类 * @author lichuang */ public class ServiceProxy<T> implements InvocationHandler { private Class<T> interfaceType; public ServiceProxy(Class<T> intefaceType) { this.interfaceType = interfaceType; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (Object.class.equals(method.getDeclaringClass())) { return method.invoke(this,args); } System.out.println("调用前,参数:{}" + args); //这里可以得到参数数组和方法等,可以通过反射,注解等,进行结果集的处理 //mybatis就是在这里获取参数和相关注解,然后根据返回值类型,进行结果集的转换 Object result = JSON.toJSONString(args); System.out.println("调用后,结果:{}" + result); return result; } }
另外2个接口源码:
package com.company.service; public interface CalculateService { String getResult(String name); }
TestService接口
package com.company.service; public interface TestService { String getList(String code, String name); }
我们DEBUG运行,可以看到程序正常运行,两个Service接口都已正常的注入到控制器中了,程序也能正常返回接口。
补充: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代码如下:
package com.kfit.demo.service; public class TestService { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } public void print(){ System.out.println("动态载入bean,name="+name); } }
那么下面我们的目标就是动态注入TestService了,根据以上的分析,我们进行编码,具体代码如下:
//获取context. ApplicationContext ctx = (ApplicationContext) SpringApplication.run(App.class, args); //获取BeanFactory DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory)ctx.getAutowireCapableBeanFactory(); //创建bean信息 BeanDefinitionBuilderbeanDefinitionBuilder =BeanDefinitionBuilder.genericBeanDefinition(TestService.class); beanDefinitionBuilder.addPropertyValue("name","张三"); //动态注册bean defaultListableBeanFactory.registerBeanDefinition("testService",beanDefinitionBuilder.getBeanDefinition()); //获取动态注册的bean TestService testService =ctx.getBean(TestService.class); testService.print();
执行代码
动态载入bean,name=张三
到这里,就证明我们的代码很成功了。
3 多次注入同一个bean的情况
多次注入同一个bean的,如果beanName不一样的话,那么会产生两个Bean;如果beanName一样的话,后面注入的会覆盖前面的。
第一种情况:beanName一样的代码:
beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(TestService.class); beanDefinitionBuilder.addPropertyValue("name","李四"); defaultListableBeanFactory.registerBeanDefinition("testService", beanDefinitionBuilder.getBeanDefinition());
运行看控制台:
动态载入bean,name=李四
第二种情况:beanName不一样的代码:
beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(TestService.class); beanDefinitionBuilder.addPropertyValue("name","李四"); defaultListableBeanFactory.registerBeanDefinition("testService1",beanDefinitionBuilder.getBeanDefinition()); TestService testService =ctx.getBean(TestService.class); 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,只需要修改一句代码:
TestService testService =ctx.getBean("testService");
一般重复注入一个新Bean的情况较少,多数情况都是讲已有的Bean注入到容器中,
applicationContext.getAutowireCapableBeanFactory().applyBeanPostProcessorsAfterInitialization(obj, obj.getClass().getName()); beanFactory.registerSingleton(obj.getClass().getName(), obj);
第一行:让obj完成Spring初始化过程中所有增强器检验,只是不重新创建obj,
第二行:将obj以单例的形式入驻到容器中,此时通过obj.getClass().getName()或obj.getClass()都可以拿到放入Spring容器的Bean。
4 动态删除
相对于动态注入,动态删除就很简单了,直接奉上代码:
//删除bean. defaultListableBeanFactory.removeBeanDefinition("testService");
以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。如有错误或未考虑完全的地方,望不吝赐教。