在我们日常开发中，经常使用Enable注解来开启某些功能。例如

1. EnableDiscoveryClient

2. EnableFeignClients

3. @EnableAuthorizationServer

4. ....

我们发现这些注解都是用来开启某些功能的，其实如果我们换句话来说可能更好理解，就是用来加载某些配置的。

那么我们来自定义一个Enable注解，首先我们需要对注解有一定的了解，下面是我摘抄的网上的一段说明。

01) @interface

使用 @interface 定义注解时，意味着它实现了 java.lang.annotation.Annotation 接口，即该注解就是一个Annotation。

定义 Annotation 时，@interface 是必须的。

注意：它和我们通常的 implemented 实现接口的方法不同。Annotation 接口的实现细节都由编译器完成。通过 @interface 定义注解后，该注解不能继承其他的注解或接口。

(02) @Documented

类和方法的 Annotation 在缺省情况下是不出现在 javadoc 中的。如果使用 @Documented 修饰该 Annotation，则表示它可以出现在 javadoc 中。

定义 Annotation 时，@Documented 可有可无；若没有定义，则 Annotation 不会出现在 javadoc 中。

(03) @Target(ElementType.TYPE)

前面我们说过，ElementType 是 Annotation 的类型属性。而 @Target 的作用，就是来指定 Annotation 的类型属性。

@Target(ElementType.TYPE) 的意思就是指定该 Annotation 的类型是 ElementType.TYPE。这就意味着，MyAnnotation1 是来修饰"类、接口（包括注释类型）或枚举声明"的注解。

定义 Annotation 时，@Target 可有可无。若有 @Target，则该 Annotation 只能用于它所指定的地方；若没有 @Target，则该 Annotation 可以用于任何地方。

(04) @Retention(RetentionPolicy.RUNTIME)

前面我们说过，RetentionPolicy 是 Annotation 的策略属性，而 @Retention 的作用，就是指定 Annotation 的策略属性。

@Retention(RetentionPolicy.RUNTIME) 的意思就是指定该 Annotation 的策略是 RetentionPolicy.RUNTIME。这就意味着，编译器会将该 Annotation 信息保留在 .class 文件中，并且能被虚拟机读取。

定义 Annotation 时，@Retention 可有可无。若没有 @Retention，则默认是 RetentionPolicy.CLASS。

下面我们说了怎么自定义一个Enable注解，其实Enable的方式有很多种。

我们先介绍最简单的一种，直接引入：

/**
 * 开启天润外呼
 * @author clark
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(TRCallConfig.class)
public @interface EnableTRCall {
}

引入配置类

/**
 * 天润外呼配置类
 * @author clark
 */
@EnableConfigurationProperties({ TRCallProperties.class})
public class TRCallConfig {

    @Autowired
    private TRCallProperties trCallProperties;

    /**
     * 实例化天润外呼业务
     * @return
     */
    @Bean("trCallService")
    CallService trCallService(){
        TRCallServiceImpl trCallService = new TRCallServiceImpl();
        trCallService.setTrCallProperties(trCallProperties);
        return trCallService;
    }
}

那么这样我们就实现了一个自定义的Eable注解了，当然这是比较简单的。

下面我们来说下第二种，根据参数加载不同的配置类的方法。

/**
 * 全局开启外呼注解：与单个开启等价
 * @author clark
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(CallConfigurationSelector.class)
public @interface EnableCall {
    /**
     * 开启类型
     * @return
     */
    String[] type();

}

/**
 * 配置加载
 * @author clark
 */
public class CallConfigurationSelector  implements ImportSelector{

    /**
     * 解析type参数，动态加载配置类
     * @param annotationMetadata
     * @return
     */
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        //获取注解的属性集合
        AnnotationAttributes attributes =
                AnnotationAttributes.fromMap(
                        annotationMetadata.getAnnotationAttributes(EnableCall.class.getName(), false));
        //设置type
        String[] types = attributes.getStringArray("type");
        if(types==null||types.length==0){
            throw new IllegalStateException("type is required");
        }
        List<String> results = new ArrayList<>();
        //处理类型
        for(String type : types) {
            CallType callType = CallType.valueOf(type);
            switch (callType) {
                case CDR:
                    results.add(CDRCallConfig.class.getName());
                    break;
                case TKY:
                    results.add(TKYCallConfig.class.getName());
                    break;
                case TR:
                    results.add(TRCallConfig.class.getName());
                    break;
                case ZC:
                    results.add(ZCCallConfig.class.getName());
                    break;
                default:
                    throw new IllegalStateException("no type is matching");
            }
        }
        return results.toArray(new String[results.size()]);
    }

}

对于Import能引入的类型，我们可以参考源码进行查看。

项目结构：

1.定义一个注解类 EnableScanner

package com.boot.condition.bootcondition.simple;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

/**
 * 〈一句话功能简述〉<br> 
 * 〈扫描包〉
 *
 * @author 26918
 * @create 2018/10/17
 * @since 1.0.0
 */
@SpringBootApplication
@EnableScanner(packages = {"com.boot.condition.bootcondition.simple.entity", "com.boot.condition.bootcondition.simple.bean"})
public class ScannerPackageApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(ScannerPackageApplication.class, args);

        context.close();
    }

}



import org.springframework.context.annotation.Import;

import java.lang.annotation.*;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(ScannerPackageRegistrar.class)
public @interface EnableScanner {

    String[] packages();
}

2.导入需要扫描的注册类 ScannerPackageRegistrar， 将扫描的对象设置到spring容器

import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 〈一句话功能简述〉<br> 
 * 〈〉
 *
 * @author 26918
 * @create 2018/10/17
 * @since 1.0.0
 */
public class ScannerPackageRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        System.out.println("packages value::"+annotationMetadata.getAnnotationAttributes(EnableScanner.class.getName()));

        String[] arrs = (String[]) annotationMetadata.getAnnotationAttributes(EnableScanner.class.getName()).get("packages");
        List<String> packages = Arrays.asList(arrs);
        System.out.println(packages);

        BeanDefinitionBuilder bdb = BeanDefinitionBuilder.rootBeanDefinition(MyBeanDefinitionProcessor.class);
        bdb.addPropertyValue("packages", packages);

        beanDefinitionRegistry.registerBeanDefinition(MyBeanDefinitionProcessor.class.getName(), bdb.getBeanDefinition());
    }
}

3.定义一个MyBeanDefinitionProcessor implements BeanPostProcessor 用于初始回调对象

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
import java.util.List;
/**
 * 〈一句话功能简述〉<br> 
 * 〈bean 初始回调〉
 *
 * @author 26918
 * @create 2018/10/17
 * @since 1.0.0
 */

public class MyBeanDefinitionProcessor implements BeanPostProcessor {

    private List<String> packages;

    public List<String> getPackages() {
        return packages;
    }

    public void setPackages(List<String> packages) {
        this.packages = packages;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        for (String pkg : packages) {
            if(bean.getClass().getName().startsWith(pkg)){
                System.out.println("instance bean:"+bean.getClass().getName());
            }
        }
        return bean;
    }
}

自定义@EnableXXX注解

场景

自定义注解 + AOP 实现接口日志的自动记录（日志记录器），将本项目打包到别的项目上使用时，一开始没有效果，后来发现是因为SpringBoot项目默认注册主程序所在包以及子包的Bean , 而导入的日志记录器里面的所有Bean都没有注入Spring IOC容器 ， 所以在主程序上使用@ComponentScan(basePackages = {“com.lian.song”}) 注解，显式的使得当前项目去注入日志记录器中的Bean ，

但是这样就暴露出一些问题

1 包名暴露了

2 使用起来不是特别的方便

经过大佬的指定，把注入Bean的功能放到日志记录器中，并且使用@EnableLogger注解实现此功能，使用的时候也能见名知意

作用

就是为了解决本项目的Bean不能在本项目注入，而需要在引入项目进行显式注入的问题（本项目的Bean由本项目注入）

自定义

第一步 定义一个配置文件，将本项目中所有Bean都返回并且使其配置文件和Bean定义能够被扫描

@Configuration
public class LoggerConfig {
   // 一定要注入所有的Bean

    @Bean
    public LoggingAspects getLoggingAspects() {
        return new LoggingAspects();
    }

    @Bean
    public LogMapper getLogMapper() {
        return new DefaultLogMapperImpl();
    }

    @Bean
    public LoggingUtils getLoggingUtils() {
        return new LoggingUtils();
    }

    @Bean
    public SpringUtils getSpringUtils() {
        return new SpringUtils();
    }
}

2 自定义一个注解（@EnableXXX），用于在别的项目使用时开启特定功能（本质就是注入特定的功能所需要的Bean）

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(LoggerEnableAutoConfig.class)  //关注@Import() 注解及其导入的配置类
public @interface EnableLogger {

}

到现在为止，知道@EnableLogger注解用于注入项目的Bean , 用在别的项目的主程序上，但是这个注解用在了那个主程序上，别的项目的主程序和本项目的配置文件是怎么勾连上的呢？这时候就是

@Import(LoggerEnableAutoConfig.class)  

发挥作用的时候了

看名字就知道@Import注解导入一个自动配置类（LoggerEnableAutoConfig）

第三步 自定义自动配置类

@Slf4j
@Configuration
public class LoggerEnableAutoConfig implements ImportSelector {
    Logger logger = LoggerFactory.getLogger(LoggerEnableAutoConfig.class);

    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        //判断主程序上是否存在指定注解
        Map<String, Object> attributes = annotationMetadata.getAnnotationAttributes(EnableLogger.class.getName());
        if(attributes == null){
            log.info("@EnableLogger is not used on the main program");
            return new String[0];
        }
        return  new String[]{LoggerConfig.class.getName()};
    }


}

编写一个实现了ImportSelector接口类

ImportSelector接口，查看其具体实现源码（根据AnnotationMetadata元数据注册bean类，即返回的Bean 会自动的被注入，被Spring所管理）

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.
	 * @return the class names, or an empty array if none
	 */
	String[] selectImports(AnnotationMetadata importingClassMetadata);
    
}

这个接口返回的类的全类名对应的Bean都会被注入到IOC容器中

其实现自动配置的方式的底层就是通过@Import注解引入相关配置类，然后再在配置类将所需的bean注册到spring容器中和实现组件相关处理逻辑