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

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<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();
}
}

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;
}
}

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;
}
}

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

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

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);
}
}

//获取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=张三

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

动态载入bean,name=李四

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

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

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

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