创建动态代理对象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");

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

(0)

相关推荐

  • springboot2.x解决运行顺序及Bean对象注入顺序的问题

    1 前言 通过指定接口,重写指定方法,可以在Bean对应的生命周期方法中执行相应的程序 2 测试 本文将分析几个Bean对象,为它们设置优先级(通过@Order),然后再打断点调试,测试各种生命周期方法的运行的顺序 在项目当中最让人头疼的就是bean对象不被注入的问题,通过本文,你可以很好的解决这个问题. 先看看本程序使用的依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="

  • 解决Spring Boot 多模块注入访问不到jar包中的Bean问题

    情景描述 一个聚合项目spring-security-tutorial,其中包括4个module,pom如下所示: <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://mav

  • springboot 实现bean手动注入操作

    1.springboot启动类实现接口ApplicationListener<ContextRefreshedEvent>,实现方法onApplicationEvent,初始化上下文 package test.projectTest; import org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration; import org.springframework.boot.SpringApplication; import or

  • 普通类注入不进spring bean的解决方法

    解决问题:我在做移动端accessToken的使用遇到一个问题,就是普通类死活注入不进去spring bean,我和同事雷杰通过各种注解,xml配置搞了好久都搞不定,这里插个眼,有空补一下spring,得深入研究一下 解决办法:后面通过一个spring工具类搞定,这里贴上代码 1.引入这个springUtil类 2.通过构造方法注入 贴上SpringUtils代码: package com.dt.base.weixin.util; import org.springframework.aop.f

  • spring boot拦截器注入不了java bean的原因

    一.如何实现拦截器 在Spring Boot项目中,拦截器经常被用来做登陆验证,日志记录等操作.拦截器是Spring提供的,所以可以将拦截器注成bean,由IOC容器来管理.实现拦截器的方式很简单,主要由以下两个步骤: 自定义拦截器类实现HandlerInterceptor接口 自定义WebMvc配置类实现WebMvcConfigurer接口,添加自定义拦截器类 简要实现代码如下: 自定义拦截器 LoginInterceptor: public class LoginInterceptor im

  • Java 如何从spring容器中获取注入的bean对象

    1.使用场景 控制层调用业务层时,控制层需要拿到业务层在spring容器中注入的对象 2.代码实现 import org.apache.struts2.ServletActionContext; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.context.ApplicationContext; import org.springframework.context.suppo

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

    使用过Mybatis的同学,应该都知道,我们只需要编写mybatis对应的接口和mapper XML文件即可,并不需要手动编写mapper接口的实现.这里mybatis就用到了JDK动态代理,并且将生成的接口代理对象动态注入到Spring容器中. 这里涉及到几个问题.也许有同学会有疑问,我们直接编写好类,加入@Component等注解不是可以注入了吗?或者在配置类(@Configuration)中直接声明该Bean类型不也可以注入吗? 但具体到mybatis,这里我们用的是接口.由于spring

  • JAVA使用动态代理对象进行敏感字过滤代码实例

    这篇文章主要介绍了JAVA使用动态代理对象进行敏感字过滤代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 package com.hopetesting.web.filter; import javax.servlet.*; import javax.servlet.annotation.WebFilter; import java.io.BufferedReader; import java.io.FileNotFoundExcepti

  • 如何动态替换Spring容器中的Bean

    目录 动态替换Spring容器中的Bean 原因 方案 实现 Spring中bean替换问题 动态替换Spring容器中的Bean 原因 最近在编写单测时,发现使用 Mock 工具预定义 Service 中方法的行为特别难用,而且无法精细化的实现自定义的行为,因此想要在 Spring 容器运行过程中使用自定义 Mock 对象,该对象能够代替实际的 Bean 的给定方法. 方案 创建一个 Mock 注解,并且在 Spring 容器注册完所有的 Bean 之后,解析 classpath 下所有引入该

  • SpringBoot普通类获取spring容器中bean的操作

    前言 在spring框架中,是无法在普通类中通过注解注入实例的,因为sping框架在启动的时候,就会将标明交给spring容器管理的类进行实例化,并梳理他们彼此的依赖关系,进行注入,没有交给spring容器管理的普通类,是不会进行注入的,即使你使用了注入的相关注解.这个时候,如果我们需要在普通类中获取spring容器中的实例,就需要一些特定的方法,这里将整理一下如何在springboot中实现这样的方法. 创建springboot工程demo 项目结构图示 项目结构说明 service包下为de

  • Spring容器中添加bean的5种方式

    目录 @Configuration + @Bean @Componet + @ComponentScan @Import注解导入 @Import直接导入类 @Import + ImportSelector @Import + ImportBeanDefinitionRegistrar @Import + DeferredImportSelector 使用FactoryBean接口 使用 BeanDefinitionRegistryPostProcessor 小结 我们知道平时在开发中使用Spri

  • Spring容器中已经存在的Bean替换示例

    目录 一.背景 二.需求 三.实现思路 四.实现步骤 1.模拟第三方jar包实现并加入Spring容器中 2.自己提供一个实现 3.替换掉jar包默认的实现 4.进行测试 一.背景 我们在开发的过程中,经常会引入别人写的jar包实现某些功能.而别人的jar包一般都自动注入Spring容器中,假设别人都是通过@Bean或@Component注入的,并且没有加入@ConditionalXXX等注解,导致自己无法替换掉别人的实现,假设这个时候我就是想替换掉,那么该如何实现呢? 二.需求 由上图可知,我

  • 浅谈spring容器中bean的初始化

    当我们在spring容器中添加一个bean时,如果没有指明它的scope属性,则默认是singleton,也就是单例的. 例如先声明一个bean: public class People { private String name; private String sex; public String getName() { return name; } public void setName(String name) { this.name = name; } public String get

  • JSP 获取spring容器中bean的两种方法总结

    JSP 获取spring容器中bean的方法总结 方案1(Web中使用): ApplicationContext ct = WebApplicationContextUtils.getRequiredWebApplicationContext(ServletActionContext.getServletContext()); logService = (ISysLogService) ct.getBean("sysLogServiceImpl"); 说明:getRequiredWeb

  • 普通对象使用spring容器中的对象的实现方法

    引语: 工作中有时候需要在普通的对象中去调用spring管理的对象,但是在普通的java对象直接使用@Autowired或者@Resource的时候会发现被注入的对象是null,会报空指针.我们可以简单的理解为spring是一个公司,它管理的对象就是它的员工,而普通的java对象是其他公司的员工,如果其他公司要找spring公司的员工一起共事没有经过spring公司的同意肯定是不行的. 解决方式: 方法一:如果这个普通对象可以被spring管理的话,最好是直接交给spring管理,这样sprin

随机推荐