一、背景

我们自己开发了一个第三方的jar包,想和Spring整合起来,并注入到Spring容器中。自己的jar包中,需要加入到Spring容器的类上都加入了一个自定义注解@CustomImport(beanName=""),beanName属性的值表示需要注入到Spring容器中的名字。

二、实现方案

1、基于@ComponentScan注解实现

使用此种方案比较简单,直接使用@ComponentScan(includeFilters = {@ComponentScan.Filter(value = CustomImport.class)})即可将我们自定义的注解加入到Spring容器中。 此种方案略。

2、基于ImportBeanDefinitionRegistrar和FactoryBean实现

1、实现此接口(ImportBeanDefinitionRegistrar),可以将我们自己的BeanDefinition对象加到BeanDefinitionRegistry中,等待后续Spring初始化对象。

注:

​ 1. 我们可以从自定义的注解中获取到一些属性,然后来个性化我们要初始化的Bean是什么样的。

​ 2. 实现ImportBeanDefinitionRegistrar的类配合上@Configuration@Import注解,可以在程序启动的时候加载这个类。

2、实现此接口(FactoryBean),可以让我们自定义实例化出我们要构建的Bean。

3、注意

可能有些人会说,我用@ComponentScan就可以搞定的事情,为何还要选择基于第二种方法实现,这个不是多此一举吗?这个其实我主要是记录这样的一个思路。比如:Mybatis和Spring整合后,只需要申明一个@Mapper就可以自定加入到Spring管理中(MapperScannerRegistrar),那么这是怎么实现的呢?应该是和上方的方案2类似。

三、实现步骤

1、自定义一个注解 CustomImport,被此注解标注的类,表示需要加入到Spring容器中。

  1. CustomImport 注解可以增加一些额外的属性,比如beanName表示注入到Spring容器时,bean的名字。

2、写一个类实现CustomImportFactoryBean,表示如何实例化出CustomImport注解标注的类。

  1. 构造化对象。
  2. 构造出的对象需要自己完成初始化操作,如果需要用到Spring的里的对象,可以获取到ApplicationContext然后获取注入。

3、写一个类实现ImportBeanDefinitionRegistrar,扫描出所有的CustomImport的类,然后构造出BeanDefinition,加入到Spring容器中。

  1. 构造BeanDefinition时的BeanClass属性需要指定上一个的CustomImportFactoryBean的class。
  2. ClassPathBeanDefinitionScanner可以扫描包。

4、自定义一个注解EnableCustomImport,启动类上加入此注解后,实现ImportBeanDefinitionRegistrar的调用。

  1. 此注解上需要使用@Import标注

1、自定义注解CustomImport

/**
 * 此注解标注的类也会自动加入到 Spring 管理中。
 *
 * @author huan.fu 2021/4/14 - 上午9:23
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CustomImport {
    /**
     * 这个bean注入到Spring容器中的名字
     */
    String beanName();
}

2、实现CustomImportFactoryBean构建对象

package com.huan.study.framewrok;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

/**
 * 工厂Bean,用于构建 CustomImport 注解标注的类,如何进行实例化
 *
 * @author huan.fu 2021/4/14 - 上午9:44
 */
public class CustomImportFactoryBean implements FactoryBean<Object>, ApplicationContextAware {

    private Class<?> type;
    private String beanName;
    private ApplicationContext applicationContext;

    /**
     * 此处构建的对象,如果需要依赖Spring Bean的话,需要自己构建进去,默认不会自动注入,即默认情况下@Autowired注解不生效
     */
    @Override
    public Object getObject() throws Exception {
        Object instance = this.type.getDeclaredConstructor().newInstance();
        applicationContext.getAutowireCapableBeanFactory().autowireBean(instance);
        return instance;
    }

    @Override
    public Class<?> getObjectType() {
        return type;
    }

    public Class<?> getType() {
        return type;
    }

    public void setType(Class<?> type) {
        this.type = type;
    }

    public String getBeanName() {
        return beanName;
    }

    public void setBeanName(String beanName) {
        this.beanName = beanName;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

3、编写ImportBeanDefinitionRegistrar

package com.huan.study.framewrok;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.annotation.AnnotationAttributes;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.filter.AnnotationTypeFilter;

import java.util.Map;
import java.util.Optional;
import java.util.Set;

/**
 * @author huan.fu 2021/4/14 - 上午9:25
 */
public class CustomImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {

    private static final Logger log = LoggerFactory.getLogger(CustomImportBeanDefinitionRegistrar.class);

    private Environment environment;
    private ResourceLoader resourceLoader;

    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) {
        if (!annotationMetadata.hasAnnotation(EnableCustomImport.class.getName())) {
            return;
        }
        Map<String, Object> annotationAttributesMap = annotationMetadata.getAnnotationAttributes(EnableCustomImport.class.getName());
        AnnotationAttributes annotationAttributes = Optional.ofNullable(AnnotationAttributes.fromMap(annotationAttributesMap)).orElseGet(AnnotationAttributes::new);
        // 获取需要扫描的包
        String[] packages = retrievePackagesName(annotationMetadata, annotationAttributes);
        // useDefaultFilters = false,即第二个参数 表示不扫描 @Component、@ManagedBean、@Named 注解标注的类
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry, false, environment, resourceLoader);
        // 添加我们自定义注解的扫描
        scanner.addIncludeFilter(new AnnotationTypeFilter(CustomImport.class));
        // 扫描包
        for (String needScanPackage : packages) {
            Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(needScanPackage);
            try {
                registerCandidateComponents(registry, candidateComponents);
            } catch (ClassNotFoundException e) {
                log.error(e.getMessage(), e);
            }
        }
    }

    /**
     * 获取需要扫描的包
     */
    private String[] retrievePackagesName(AnnotationMetadata annotationMetadata, AnnotationAttributes annotationAttributes) {
        String[] packages = annotationAttributes.getStringArray("packages");
        if (packages.length > 0) {
            return packages;
        }
        String className = annotationMetadata.getClassName();
        int lastDot = className.lastIndexOf('.');
        return new String[]{className.substring(0, lastDot)};
    }

    /**
     * 注册 BeanDefinition
     */
    private void registerCandidateComponents(BeanDefinitionRegistry registry, Set<BeanDefinition> candidateComponents) throws ClassNotFoundException {
        for (BeanDefinition candidateComponent : candidateComponents) {
            if (candidateComponent instanceof AnnotatedBeanDefinition) {
                AnnotatedBeanDefinition annotatedBeanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                AnnotationMetadata annotationMetadata = annotatedBeanDefinition.getMetadata();
                Map<String, Object> customImportAnnotationAttributesMap = annotationMetadata.getAnnotationAttributes(CustomImport.class.getName());
                AnnotationAttributes customImportAnnotationAttributes = Optional.ofNullable(AnnotationAttributes.fromMap(customImportAnnotationAttributesMap)).orElseGet(AnnotationAttributes::new);
                String beanName = customImportAnnotationAttributes.getString("beanName");
                String className = annotationMetadata.getClassName();
                Class<?> clazzName = Class.forName(className);
                AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(CustomImportFactoryBean.class)
                        .addPropertyValue("type", clazzName)
                        .addPropertyValue("beanName", beanName)
                        .setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE)
                        .setRole(BeanDefinition.ROLE_INFRASTRUCTURE)
                        .getBeanDefinition();
                registry.registerBeanDefinition(beanName, beanDefinition);

            }
        }
    }


    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }
}

4、编写@EnableCustomImport

/**
 * 启用自动导入
 *
 * @author huan.fu 2021/4/14 - 上午9:29
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(CustomImportBeanDefinitionRegistrar.class)
public @interface EnableCustomImport {

    String[] packages() default {};
}

5、运行一个小的案例,获取测试结果

运行自定义注解案例,获得测试结果

四、完成代码

1、https://gitee.com/huan1993/spring-cloud-parent/tree/master/springboot/bean-definition-registrar

五、参考链接

1、https://stackoverflow.com/questions/4970297/how-to-get-beans-created-by-factorybean-spring-managed


huan1993
204 声望30 粉丝

java工程师