深入理解Spring的ImportSelector接口
ImportSelector接口是至spring中導入外部配置的核心接口,在SpringBoot的自動化配置和@EnableXXX(功能性註解)都有它的存在,關於SpringBoot的分析可以參考:深入理解SpringBoot的自動裝配。
一、關於ImportSelector接口
package org.springframework.context.annotation; import org.springframework.core.type.AnnotationMetadata; /** * Interface to be implemented by types that determine which @{@link Configuration} * class(es) should be imported based on a given selection criteria, usually one or more * annotation attributes. * * <p>An {@link ImportSelector} may implement any of the following * {@link org.springframework.beans.factory.Aware Aware} interfaces, and their respective * methods will be called prior to {@link #selectImports}: * <ul> * <li>{@link org.springframework.context.EnvironmentAware EnvironmentAware}</li> * <li>{@link org.springframework.beans.factory.BeanFactoryAware BeanFactoryAware}</li> * <li>{@link org.springframework.beans.factory.BeanClassLoaderAware BeanClassLoaderAware}</li> * <li>{@link org.springframework.context.ResourceLoaderAware ResourceLoaderAware}</li> * </ul> * * <p>ImportSelectors are usually processed in the same way as regular {@code @Import} * annotations, however, it is also possible to defer selection of imports until all * {@code @Configuration} classes have been processed (see {@link DeferredImportSelector} * for details). * * @author Chris Beams * @since 3.1 * @see DeferredImportSelector * @see Import * @see ImportBeanDefinitionRegistrar * @see Configuration */ public interface ImportSelector { /** * Select and return the names of which class(es) should be imported based on * the {@link AnnotationMetadata} of the importing @{@link Configuration} class. */ String[] selectImports(AnnotationMetadata importingClassMetadata); }
該接口文檔上說的明明白白,其主要作用是收集需要導入的配置類,如果該接口的實現類同時實現EnvironmentAware, BeanFactoryAware ,BeanClassLoaderAware或者ResourceLoaderAware,那麽在調用其selectImports方法之前先調用上述接口中對應的方法,如果需要在所有的@Configuration處理完在導入時可以實現DeferredImportSelector接口。
在這裏我舉個Spring中的實例來看一下:
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Import(TransactionManagementConfigurationSelector.class) public @interface EnableTransactionManagement { /** * Indicate whether subclass-based (CGLIB) proxies are to be created ({@code true}) as * opposed to standard Java interface-based proxies ({@code false}). The default is * {@code false}. <strong>Applicable only if {@link #mode()} is set to * {@link AdviceMode#PROXY}</strong>. * <p>Note that setting this attribute to {@code true} will affect <em>all</em> * Spring-managed beans requiring proxying, not just those marked with * {@code @Transactional}. For example, other beans marked with Spring‘s * {@code @Async} annotation will be upgraded to subclass proxying at the same * time. This approach has no negative impact in practice unless one is explicitly * expecting one type of proxy vs another, e.g. in tests. */ boolean proxyTargetClass() default false; /** * Indicate how transactional advice should be applied. The default is * {@link AdviceMode#PROXY}. * @see AdviceMode */ AdviceMode mode() default AdviceMode.PROXY; /** * Indicate the ordering of the execution of the transaction advisor * when multiple advices are applied at a specific joinpoint. * The default is {@link Ordered#LOWEST_PRECEDENCE}. */ int order() default Ordered.LOWEST_PRECEDENCE; }
此註解是開啟聲明式事務的註解,那麽它的@Import所導入的類為TransactionManagementConfigurationSelector,那麽我們看一下其類圖:
由此可知該類實現類ImportSelector接口
二、自定義@EnableXXX註解
在這裏我們先準備兩個Spring的項目工程:spring-project與ssm-project,其中spring-project裏我們先創建好如下結構目錄:
SpringStudySelector
package org.hzgj.spring.study.config; import org.springframework.beans.BeansException; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.BeanFactoryAware; import org.springframework.context.annotation.ImportSelector; import org.springframework.core.type.AnnotationMetadata; public class SpringStudySelector implements ImportSelector, BeanFactoryAware { private BeanFactory beanFactory; @Override public String[] selectImports(AnnotationMetadata importingClassMetadata) { importingClassMetadata.getAnnotationTypes().forEach(System.out::println); System.out.println(beanFactory); return new String[]{AppConfig.class.getName()}; } @Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { this.beanFactory = beanFactory; } }
在這裏我們實現ImportSelector接口和BeanFactoryAware接口,重寫selectImports方法,最後我們返回的是AppConfig的類名,同時打印出相關的註解元數據與BeanFactory
自定義@EnableSpringStudy註解
package org.hzgj.spring.study.annotation; import org.hzgj.spring.study.config.SpringStudySelector; import org.springframework.context.annotation.Import; import java.lang.annotation.*; @Retention(RetentionPolicy.RUNTIME) @Documented @Target(ElementType.TYPE) @Import(SpringStudySelector.class) public @interface EnableSpringStudy { }
在這裏我們仿照@EnableTransactionManagement來實現自定義註解,註意使用@Import導入我們剛才寫的SpringStudySelector
AppConfig
package org.hzgj.spring.study.config; import org.hzgj.spring.study.bean.StudentBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class AppConfig { @Bean public StudentBean studentBean() { StudentBean studentBean = new StudentBean(); studentBean.setId(19); studentBean.setName("admin"); return studentBean; } }
當都完成以後我們打個jar包,準備引入至其他工程:
完成ssm-project工程中的AppConfig配置類
1) 首先我們將剛才的spring.jar導入到ssm-project工程裏
2) 在對應的配置類上添加上spring-project中定義的@EnableSpringStudy註解
@Configuration //表明此類是配置類 @ComponentScan // 掃描自定義的組件(repository service component controller) @PropertySource("classpath:application.properties") // 讀取application.properties @MapperScan("com.bdqn.lyrk.ssm.study.app.mapper") //掃描Mybatis的Mapper接口 @EnableTransactionManagement //開啟事務管理 @EnableSpringStudy public class AppConfig { //....省略配置代碼 }
3)編寫Main方法
public static void main(String[] args) throws IOException { AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class); StudentBean studentBean = applicationContext.getBean(StudentBean.class); System.out.println(studentBean.getName()); }
運行後輸出結果:
org.springframework.context.annotation.Configuration org.springframework.context.annotation.ComponentScan org.springframework.context.annotation.PropertySource org.mybatis.spring.annotation.MapperScan org.springframework.transaction.annotation.EnableTransactionManagement org.hzgj.spring.study.annotation.EnableSpringStudy org.springframework.beans.factory.support.DefaultListableBeanFactory@4b9e13df: defining beans [org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,org.springframework.context.event.internalEventListenerProcessor,org.springframework.context.event.internalEventListenerFactory,appConfig,propertiesConfig,logAspect,studentService]; root of factory hierarchy admin
從這裏我們可以看到ImportSelector接口中的方法參數,可以獲取ssm-project項目下AppConfig的所有註解,並且能夠獲取當前BeanFactory所有配置的Bean
三、ImportSelector源碼分析
這個接口在哪裏調用呢?我們可以來看一下ConfigurationClassParser這個類的processImports方法
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection<SourceClass> importCandidates, boolean checkForCircularImports) { if (importCandidates.isEmpty()) { return; } if (checkForCircularImports && isChainedImportOnStack(configClass)) { this.problemReporter.error(new CircularImportProblem(configClass, this.importStack)); } else { this.importStack.push(configClass); try { for (SourceClass candidate : importCandidates) {
//對ImportSelector的處理 if (candidate.isAssignable(ImportSelector.class)) { // Candidate class is an ImportSelector -> delegate to it to determine imports Class<?> candidateClass = candidate.loadClass(); ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class); ParserStrategyUtils.invokeAwareMethods( selector, this.environment, this.resourceLoader, this.registry); if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
//如果為延遲導入處理則加入集合當中 this.deferredImportSelectors.add( new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector)); } else {
//根據ImportSelector方法的返回值來進行遞歸操作 String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata()); Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames); processImports(configClass, currentSourceClass, importSourceClasses, false); } } else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) { // Candidate class is an ImportBeanDefinitionRegistrar -> // delegate to it to register additional bean definitions Class<?> candidateClass = candidate.loadClass(); ImportBeanDefinitionRegistrar registrar = BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class); ParserStrategyUtils.invokeAwareMethods( registrar, this.environment, this.resourceLoader, this.registry); configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata()); } else {
// 如果當前的類既不是ImportSelector也不是ImportBeanDefinitionRegistar就進行@Configuration的解析處理 // Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar -> // process it as an @Configuration class this.importStack.registerImport( currentSourceClass.getMetadata(), candidate.getMetadata().getClassName()); processConfigurationClass(candidate.asConfigClass(configClass)); } } } catch (BeanDefinitionStoreException ex) { throw ex; } catch (Throwable ex) { throw new BeanDefinitionStoreException( "Failed to process import candidates for configuration class [" + configClass.getMetadata().getClassName() + "]", ex); } finally { this.importStack.pop(); } } }
在這裏我們可以看到ImportSelector接口的返回值會遞歸進行解析,把解析到的類全名按照@Configuration進行處理
深入理解Spring的ImportSelector接口