使用过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中
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);
}
}
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> 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> Set>
*/
private Set> scannerPackages(String basePackage) {
Set> 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<&＃63;> 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();
}
}
package com.company.handler; import org.springframework.beans.factory.FactoryBean; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; /** * 接口实例工厂，这里主要是用于提供接口的实例对象 * @author lichuang * @param*/ public class ServiceFactory implements FactoryBean { private Class interfaceType; public ServiceFactory(Class 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 getObjectType() { return interfaceType; } @Override public boolean isSingleton() { return true; } }
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 ServiceProxyimplements InvocationHandler { private Class interfaceType; public ServiceProxy(Class 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; } }
package com.company.service;
public interface CalculateService {
String getResult(String name);
}
package com.company.service;
public interface TestService {
String getList(String code, String name);
}
我们DEBUG运行，可以看到程序正常运行，两个Service接口都已正常的注入到控制器中了，程序也能正常返回接口。
补充：Spring动态 注入/删除 Bean
我们通过getBean来获得对象,但这些对象都是事先定义好的,我们有时候要在程序中动态的加入对象.因为如果采用配置文件或者注解，我们要加入对象的话,还要重启服务,如果我们想要避免这一情况就得采用动态处理bean,包括：动态注入,动态删除。
在具体进行代码实现的时候，我们要知道，Spring管理bean的对象是BeanFactory，具体的是DefaultListableBeanFactory，在这个类当中有一个注入bean的方法：registerBeanDefinition，在调用registerBeanDefinition方法时，需要BeanDefinition参数，那么这个参数怎么获取呢？
Spring提供了BeanDefinitionBuilder可以构建一个BeanDefinition，那么我们的问题就是如何获取BeanFactory了，这个就很简单了，只要获取到ApplicationContext对象即可获取到BeanFacory了。
综上所述，如果我们要编写一个简单里的例子的话，那么分以个几个步骤进行编码即可进行动态注入了：
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=张三
到这里，就证明我们的代码很成功了。
多次注入同一个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。
相对于动态注入，动态删除就很简单了，直接奉上代码：
//删除bean.
defaultListableBeanFactory.removeBeanDefinition("testService");
以上为个人经验，希望能给大家一个参考，也希望大家多多支持。如有错误或未考虑完全的地方，望不吝赐教。
京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有 