一、@Enable* 启用某个特性的注解

1、EnableConfigurationProperties

回顾属性装配

application.properties中添加

tomcat.host=192.168.2.1

tomcat.port=8080

增加属性类TomcatProperties

package com.lhx.spring.springboot_enable;

import org.springframework.boot.context.properties.ConfigurationProperties;

import org.springframework.stereotype.Component;

@Component

@ConfigurationProperties(prefix = "tomcat")

public class TomcatProperties {

    private String host;

    private String port;

    public String getHost() {

        return host;

    }

    public void setHost(String host) {

        this.host = host;

    }

    public String getPort() {

        return port;

    }

    public void setPort(String port) {

        this.port = port;

    }

    @Override

    public String toString() {

        return "TomcatProperties [host=" + host + ", port=" + port + "]";

    }

}

在App中添加代码

@SpringBootApplication

public class App {

    public static void main(String[] args) {

        ConfigurableApplicationContext context = SpringApplication.run(App.class, args);

        System.out.println(context.getBean(TomcatProperties.class));

        context.close();

    }

}

查看注解SpringBootApplication，其中使其起作用的是@EnableAutoConfiguration，继续追踪代码，其实生效的是：@EnableConfigurationProperties

故以上代码配置

@ComponentScan

@EnableConfigurationProperties

public class App {

    public static void main(String[] args) {

        ConfigurableApplicationContext context = SpringApplication.run(App.class, args);

        System.out.println(context.getBean(TomcatProperties.class));

        context.close();

    }

}

注解：是用来启用一个特性的，特性可以把配置文件的属性注入到Bean类中，一般和@ConfigurationProperties一起使用

2、EnableAsync

增加一个异步打印类

package com.lhx.spring.springboot_enable;

import java.util.concurrent.TimeUnit;

import org.springframework.stereotype.Component;

@Component

public class Jeep implements Runnable {

    @Override

    public void run() {

        try {

            for (int i = 0; i < 10; i++) {

                System.out.println("---------------"+i);

                TimeUnit.SECONDS.sleep(1);

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

在App中调用

@ComponentScan

@EnableConfigurationProperties

public class App {

    public static void main(String[] args) {

        ConfigurableApplicationContext context = SpringApplication.run(App.class, args);

        System.out.println(context.getBean(TomcatProperties.class));

        context.getBean(Runnable.class).run();

        System.out.println("------end------");

        context.close();

    }

}

发现此时并没有异步执行

需要在异步打印类中启用@EnableAsync，并在具体方法上标注@Async即可

package com.lhx.spring.springboot_enable;

import java.util.concurrent.TimeUnit;

import org.springframework.scheduling.annotation.Async;

import org.springframework.scheduling.annotation.EnableAsync;

import org.springframework.stereotype.Component;

@Component

@EnableAsync

public class Jeep implements Runnable {

    @Override

    @Async

    public void run() {

        try {

            for (int i = 0; i < 10; i++) {

                System.out.println("---------------"+i);

                TimeUnit.SECONDS.sleep(1);

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

这时在调用App方法即可异步

注解：启用异步，一般和Async一起使用

二、原理

1、注解Import

　　跟踪EnableAsync或EnableConfigurationProperties进入发现，共同注解@Import。　　

/*

 * Copyright 2002-2016 the original author or authors.

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package org.springframework.context.annotation;

import java.lang.annotation.Documented;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

 * Indicates one or more {@link Configuration @Configuration} classes to import.

 *

 * <p>Provides functionality equivalent to the {@code <import/>} element in Spring XML.

 * Allows for importing {@code @Configuration} classes, {@link ImportSelector} and

 * {@link ImportBeanDefinitionRegistrar} implementations, as well as regular component

 * classes (as of 4.2; analogous to {@link AnnotationConfigApplicationContext#register}).

 *

 * <p>{@code @Bean} definitions declared in imported {@code @Configuration} classes should be

 * accessed by using {@link org.springframework.beans.factory.annotation.Autowired @Autowired}

 * injection. Either the bean itself can be autowired, or the configuration class instance

 * declaring the bean can be autowired. The latter approach allows for explicit, IDE-friendly

 * navigation between {@code @Configuration} class methods.

 *

 * <p>May be declared at the class level or as a meta-annotation.

 *

 * <p>If XML or other non-{@code @Configuration} bean definition resources need to be

 * imported, use the {@link ImportResource @ImportResource} annotation instead.

 *

 * @author Chris Beams

 * @author Juergen Hoeller

 * @since 3.0

 * @see Configuration

 * @see ImportSelector

 * @see ImportResource

 */

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface Import {

    /**

     * {@link Configuration}, {@link ImportSelector}, {@link ImportBeanDefinitionRegistrar}

     * or regular component classes to import.

     */

    Class<?>[] value();

}

　　import作用：Indicates one or more {@link Configuration @Configuration} classes to import.

　　用来导入一个或多个类（bean被spring容器托管）、或者配置类（配置类里面的Bean都会被spring容器托管）

　　Enable*其实就是使用了Import，Import其实就是导入了配置类

示例

新建一个User类

package com.lhx.spring.springboot_enable;

public class User {

}

新建一个Role类

package com.lhx.spring.springboot_enable;

public class Role {

}

使用Import在App中导入

package com.lhx.spring.springboot_enable;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.context.properties.EnableConfigurationProperties;

import org.springframework.context.ConfigurableApplicationContext;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Import;

@ComponentScan

@Import(User.class)

public class App2 {

    public static void main(String[] args) {

        ConfigurableApplicationContext context = SpringApplication.run(App2.class, args);

        System.out.println(context.getBean(User.class));

        System.out.println(context.getBean(Role.class));

        context.close();

    }

}

可以看到导入一个，另一个会失败

也可以导入配置类

package com.lhx.spring.springboot_enable;

import org.springframework.context.annotation.Bean;

public class MyConfiguration {

    @Bean

    public Runnable createRunnable() {

        return () -> {

        };

    }

    @Bean

    public Runnable createRunnable2() {

        return () -> {

        };

    }

}

导入

@Import({User.class,Role.class,MyConfiguration.class})

2、ImportSelector接口

作用：方法selectImports的返回值，必须是一个class（全称），改class会被Spring容器托管

/*

 * Copyright 2002-2013 the original author or authors.

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

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

}

示例

创建一个MyImportSelector

package com.lhx.spring.springboot_enable;

import org.springframework.context.annotation.ImportSelector;

import org.springframework.core.type.AnnotationMetadata;

public class MyImportSelector implements ImportSelector {

    @Override

    public String[] selectImports(AnnotationMetadata importingClassMetadata) {

        return new String[] {"com.lhx.spring.springboot_enable.User",Role.class.getName(),MyConfiguration.class.getName()};

    }

}

在App中使用

package com.lhx.spring.springboot_enable;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.context.properties.EnableConfigurationProperties;

import org.springframework.context.ConfigurableApplicationContext;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Import;

import org.springframework.context.annotation.ImportSelector;

@ComponentScan

@Import(MyImportSelector.class)

public class App3 {

    public static void main(String[] args) {

        ConfigurableApplicationContext context = SpringApplication.run(App3.class, args);

        System.out.println(context.getBean(User.class));

        System.out.println(context.getBean(Role.class));

        System.out.println(context.getBeansOfType(Runnable.class));

        context.close();

    }

}

增加一个Enable开头的注解，可以结合注解使用

增加一个注解EnableLog

package com.lhx.spring.springboot_enable;

import java.lang.annotation.Documented;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

import org.springframework.context.annotation.Import;

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Import(MyImportSelector2.class)

public @interface EnableLog {

    String name();

}

增加一个ImportSelector实现MyImportSelector2

package com.lhx.spring.springboot_enable;

import org.springframework.context.annotation.ImportSelector;

import org.springframework.core.type.AnnotationMetadata;

public class MyImportSelector2 implements ImportSelector {

    @Override

    public String[] selectImports(AnnotationMetadata importingClassMetadata) {

        System.out.println(importingClassMetadata.getAllAnnotationAttributes(EnableLog.class.getName()));

        return new String[] { "com.lhx.spring.springboot_enable.User", Role.class.getName(),

                MyConfiguration.class.getName() };

    }

}

使用

package com.lhx.spring.springboot_enable;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.context.properties.EnableConfigurationProperties;

import org.springframework.context.ConfigurableApplicationContext;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Import;

import org.springframework.context.annotation.ImportSelector;

@ComponentScan

@EnableLog(name="my annon")

public class App4 {

    public static void main(String[] args) {

        ConfigurableApplicationContext context = SpringApplication.run(App4.class, args);

        System.out.println(context.getBean(User.class));

        System.out.println(context.getBean(Role.class));

        System.out.println(context.getBeansOfType(Runnable.class));

        context.close();

    }

}

3、ImportBeanDefinitionRegistrar

作用：方法的参数有一个BeanDefinitionRegistry，BeanDefinitionRegistry可以用来网Spring容器中注入Bean，如此，就可以动态注入bean

/*

 * Copyright 2002-2013 the original author or authors.

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package org.springframework.context.annotation;

import org.springframework.beans.factory.support.BeanDefinitionRegistry;

import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;

import org.springframework.core.type.AnnotationMetadata;

/**

 * Interface to be implemented by types that register additional bean definitions when

 * processing @{@link Configuration} classes. Useful when operating at the bean definition

 * level (as opposed to {@code @Bean} method/instance level) is desired or necessary.

 *

 * <p>Along with {@code @Configuration} and {@link ImportSelector}, classes of this type

 * may be provided to the @{@link Import} annotation (or may also be returned from an

 * {@code ImportSelector}).

 *

 * <p>An {@link ImportBeanDefinitionRegistrar} may implement any of the following

 * {@link org.springframework.beans.factory.Aware Aware} interfaces, and their respective

 * methods will be called prior to {@link #registerBeanDefinitions}:

 * <ul>

 * <li>{@link org.springframework.context.EnvironmentAware EnvironmentAware}</li>

 * <li>{@link org.springframework.beans.factory.BeanFactoryAware BeanFactoryAware}

 * <li>{@link org.springframework.beans.factory.BeanClassLoaderAware BeanClassLoaderAware}

 * <li>{@link org.springframework.context.ResourceLoaderAware ResourceLoaderAware}

 * </ul>

 *

 * <p>See implementations and associated unit tests for usage examples.

 *

 * @author Chris Beams

 * @since 3.1

 * @see Import

 * @see ImportSelector

 * @see Configuration

 */

public interface ImportBeanDefinitionRegistrar {

    /**

     * Register bean definitions as necessary based on the given annotation metadata of

     * the importing {@code @Configuration} class.

     * <p>Note that {@link BeanDefinitionRegistryPostProcessor} types may <em>not</em> be

     * registered here, due to lifecycle constraints related to {@code @Configuration}

     * class processing.

     * @param importingClassMetadata annotation metadata of the importing class

     * @param registry current bean definition registry

     */

    public void registerBeanDefinitions(

            AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);

}

自定义实现MyImportBeanDefinitionRegistrar

package com.lhx.spring.springboot_enable;

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.annotation.ImportBeanDefinitionRegistrar;

import org.springframework.core.type.AnnotationMetadata;

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    @Override

    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

        registry.registerBeanDefinition("user",

                BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition());

        registry.registerBeanDefinition("role",

                BeanDefinitionBuilder.rootBeanDefinition(Role.class).getBeanDefinition());

        registry.registerBeanDefinition(MyConfiguration.class.getName(),

                BeanDefinitionBuilder.rootBeanDefinition(MyConfiguration.class).getBeanDefinition());

    }

}

此时就可以在EnableLog上使用

package com.lhx.spring.springboot_enable;

import java.lang.annotation.Documented;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

import org.springframework.context.annotation.Import;

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

//@Import(MyImportSelector2.class)

@Import(MyImportBeanDefinitionRegistrar.class)

public @interface EnableLog {

    String name();

}

示例

代码地址：https://github.com/bjlhx15/spring-boot.git 中的 springboot-enable即可

007-Spring Boot-@Enable*注解的工作原理-EnableConfigurationProperties、ImportSelector、ImportBeanDefinitionRegistrar的更多相关文章

Spring的@Enable*注解的工作原理
转自:https://blog.csdn.net/chengqiuming/article/details/81586948 一列举几个@Enable*注解的功能 @EnableAspectJAut ...
Spring Boot @Enable*注解源码解析及自定义@Enable*
Spring Boot 一个重要的特点就是自动配置,约定大于配置,几乎所有组件使用其本身约定好的默认配置就可以使用,大大减轻配置的麻烦.其实现自动配置一个方式就是使用@Enable*注解,见其名知 ...
Spring高级特性之三：@Enable*注解的工作原理
Spring Boot中阐述热插拔技术的时候,简单地提及@Enable*注解.随着多种框架的应用及深入了解,@Enable*这个注解在各种框架中应用相当普及. 那么@Enable*注解工作原理是怎么样 ...
Spring高级话题-@Enable***注解的工作原理
出自:http://blog.csdn.net/qq_26525215 @EnableAspectJAutoProxy @EnableAspectJAutoProxy注解激活Aspect自动代理 & ...
springBoot @Enable*注解的工作原理
使用注解实现异步 RunnableDemo类 package com.boot.enable.bootenable; import org.springframework.scheduling.ann ...
@Enable*注解的工作原理
@EnableAspectJAutoProxy @EnableAsync @EnableScheduling @EnableWebMv @EnableConfigurationProperties @ ...
深度剖析Spring Boot自动装配机制实现原理
在前面的分析中,Spring Framework一直在致力于解决一个问题,就是如何让bean的管理变得更简单,如何让开发者尽可能的少关注一些基础化的bean的配置,从而实现自动装配.所以,所谓的自动装 ...
EnableAutoConfiguration注解的工作原理（org.springframework.boot.autoconfigure.EnableAutoConfiguration=core.bean.MyConfig）
EnableAutoConfiguration注解的工作原理(org.springframework.boot.autoconfigure.EnableAutoConfiguration=core.b ...
Spring Boot常用注解总结
Spring Boot常用注解总结 @RestController和@RequestMapping注解 @RestController注解,它继承自@Controller注解.4.0之前的版本,Spr ...

随机推荐

jQuery之筛选方法
1. 父parent.子children.find <div class="yeye"> <div class="father"> &l ...
iOS之Run Loop详解
转自标哥的技术博客(www.henishuo.com) 前言做了一年多的IOS开发,对IOS和Objective-C深层次的了解还十分有限,大多还停留在会用API的级别,这是件挺可悲的事情.想学好一 ...
netperf编译./configure时报错 "error: cannot guess build type；you nust specify one"
问题: 解决办法-亲测可用: 尝试:./configure --build=mingw提示无法辨别 checking build system type... Invalid configuratio ...
python函数带不带括号的问题
Python带括号返回的是该函数的返回值不带括号返回的是该函数的位置信息等
002-printf 命令用法
printf 命令的用法,大部分结合awk命令使用是格式化的输出的命令 %s 输入字符串 \n 换行 \t \r 回车键 [root@zabbix lianxi]# printf %s [root@ ...
jenkins git项目clean before checkout 和 wipe out repository & force clone
clean before checkout:会先执行一遍git clone,删除一些untracked文件和目录,比如删除上一次打包编译产生的文件 wipe out repository & ...
php内置函数分析array_diff()
PHP_FUNCTION(array_diff) { zval *args; int argc, i; uint32_t num; HashTable exclude; zval *value; ze ...
DevOps书单：调研了101名专家，推荐这39本必读书籍
任何一个领域都遵循从新人到熟手,从熟手到专家的路径.在成长过程中,DevOps人经常会陷入没人带,没人管,找不到职业方向的迷茫. DevOps是在商业演进与企业协作的进化过程中诞生的一个全新职业,被很 ...
HTML与CSS中的颜色与单位个人分享
颜色与单位 Web安全色有216中其中色彩有210中,非色彩6中前景色与背景色前景色就是设置字体的颜色背景色就是为指定元素设置背景色 - 浏览器默认背景色的颜色为透明色颜色的命名 1.使用单词 ...
【bzoj 4554】【Tjoi2016&Heoi2016】【NOIP2016模拟7.12】游戏
题目分析当没有石头的时候,就用二分图匹配来做. 但现在加入了石头, 所以,求出每行和每列联通快的个数,如果有一块平地,包括在某个行联通块以及某个列联通块中,连边. //无聊打了网络流,匈牙利也可以 ...

007-Spring Boot-@Enable*注解的工作原理-EnableConfigurationProperties、ImportSelector、ImportBeanDefinitionRegistrar