springboot原理实战(8)--enable前缀注解之开启特性的原理和案例

简介: springboot原理实战(8)--enable前缀注解之开启特性的原理和案例

目录


本篇文章主要讨论enable前缀的注解的使用方法和实现原理:

主要内容如下:

1dc618a0ed9580ce8bfa6facb208c08f.png


一、前言


在springboot中很多enable开头的注解,如@EnableConfigurationProperties,@EnableAsync等,这些注解的作用就是:启动一个新特性,现在演示2个例子。


二、作用和案例


1.@EnableConfigurationProperties


入口函数上的注解,默认使用的是@SpringBootConfiguration,其实我们也可以使用@EnableAutoConfiguration + @ComponentScan,甚至是@EnableConfigurationProperties +@ComponentScan来注入bean,详细我们可以举个例子,看下:


application.properties


tomcat.host=192.168.157.1
tomcat.port=8080


TomcatProperties 配置类


@SpringBootConfiguration
@ConfigurationProperties(prefix = "tomcat")
public class TomcatProperties {
    private String host;
    private Integer port;
    @Override
    public String toString() {
        return "TomcatProperties{" +
                "tomcat.host='" + host + '\'' +
                ", tomcat.port=" + port +
                '}';
    }
    public String getHost() {
        return host;
    }
    public void setHost(String host) {
        this.host = host;
    }
    public Integer getPort() {
        return port;
    }
    public void setPort(Integer port) {
        this.port = port;
    }
}


测试类:


@SpringBootApplication
public class Demo5Application {
    //案例1;
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Demo5Application.class, args);
        System.out.println(context.getBean(TomcatProperties.class));
        context.close();
 }


运行结果:


5d4c6812c8535adbb050f4ddf2e1bce8.png


改变1:@SpringBootApplication改成 @ComponentScan和@EnableAutoConfiguration看下效果:


@EnableAutoConfiguration
@ComponentScan
public class Demo5Application {
    //案例1;
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Demo5Application.class, args);
        System.out.println(context.getBean(TomcatProperties.class));
        context.close();        
    }
 }


运行结果:也可以注入进来配置文件的属性!


改变2:上面的注解再次把@EnableAutoConfiguration换成

@EnableConfigurationProperties
@EnableConfigurationProperties
@ComponentScan
public class Demo5Application {
    //案例1;
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Demo5Application.class, args);
        System.out.println(context.getBean(TomcatProperties.class));
        context.close();
     }  
}


再次运行:


46a9d80a6e05e4e3b19d57a0ee70bcdf.png

结果显示都可以将属性注入进来,说明一个问题,上面的注解都可以把TomcatProperties这样的配置类对应的配置属性注入进来。

这几个注解都具有这个特性:可以把配置文件的属性注入到bean里面去。

注意的是:需要配合配置类上的@ConfigurationProperties使用。


2.@EnableAync实现异步方法


@EnableAsync 作用: 启用异步方法,一般是和@Async一起使用.

举例说明:


@Component
public class Jeep implements Runnable {
    public void run() {
        try {
            for (int i = 1; i <= 10; i++) {
                System.out.println("======" + i);
                TimeUnit.SECONDS.sleep(1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


@ComponentScan
public class Demo5Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Demo5Application.class, args);
        context.getBean(Runnable.class).run();
        System.out.println("-------end-------------");
        context.close();
    }


运行结果:

1dc618a0ed9580ce8bfa6facb208c08f.png

打印的end是main里面的方法说明是同步执行的,我们来修改下代码:


@Component
public class Jeep implements Runnable {
    @Async
    public void run() {
        try {
            for (int i = 1; i <= 10; i++) {
                System.out.println("======" + i);
                TimeUnit.SECONDS.sleep(1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


@ComponentScan
@EnableAsync
public class Demo5Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Demo5Application.class, args);
        context.getBean(Runnable.class).run();
        System.out.println("-------end-------------");
        context.close();
    }


运行结果,先执行了main,方法,然后慢慢执行,说明是异步执行的。

1dc618a0ed9580ce8bfa6facb208c08f.png

enable*等注解既然这么好用,那么是如何实现的呢?接着分析:


三、enable*等注解能够实现的原理


我们看下@EnableAsync。

1dc618a0ed9580ce8bfa6facb208c08f.png

发现有个@Import注解。


@EnableConfigurationProperties注解:

5d4c6812c8535adbb050f4ddf2e1bce8.png

也有个注解@Import。

再看下@Import,有个value属性,可以指定多个类或者配置类

46a9d80a6e05e4e3b19d57a0ee70bcdf.png66ba272a0bfc97be54a5fa679e3d5482.png


也就是说明:能够自动启用的原因和这个@Import的注解和它里面的value属性有关。

@Import的注解可以导入某个bean(在value属性中指定)或配置类(在value属性中指定)到容器中,而且value属性指定的类有某些特定的功能,我们只要用@import导入就可了。


1.使用import导入一个bean或者配置bean


我们就试试这个import的能不能帮我们导入一个bean或者配置类:

首先定义2个bean和一个配置bean,都没加@Component:


public class User {
}


public class Role {
}


public class MyConfiguration {
    @Bean
    public Runnable createRunnable(){
        return () -> {};
    }
    @Bean
    public Runnable createRunnable2(){
        return () -> {};
    }
}


入口中导入这3个bean:


@ComponentScan
@Import({User.class, Role.class, MyConfiguration.class})
public class App {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(App.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();
    }
}


看下执行结果:

1dc618a0ed9580ce8bfa6facb208c08f.png

全部打印出来了,说明import已经帮我们注入了。


2.使用@import导入一个bean前加点自己的逻辑


刚才我们实践了import导入类了,再进一步考虑下,能不能在导入类前加入自己的逻辑,以前学过直接实现beanDefination等接口,可是这样的话会影响所有的bean。能不能缩小点范围,只影响我们需要导入的类呢?


可以的。思路就是可以定义一个注解,在需要加载的bean上添加注解就可以过滤了。

注解里面用@import导入一些加载bean的处理器,在处理器方法中进行我们自己的逻辑。


这里提到了2点:一个是注解,注解就是我们之前用的enable前缀作为开头的注解。一个处理器。我们看下springboot源码中:

有2类:


①.实现了ImportBeanDefinitionRegistrar接口的处理器


看下@EnableConfigurationProperties注解

5d4c6812c8535adbb050f4ddf2e1bce8.png46a9d80a6e05e4e3b19d57a0ee70bcdf.png


②.实现了ImportSelector接口的处理器


看下:@EnableAsync

1dc618a0ed9580ce8bfa6facb208c08f.png5d4c6812c8535adbb050f4ddf2e1bce8.png


主要是利用importSelector的selectImports方法:

46a9d80a6e05e4e3b19d57a0ee70bcdf.png


③案例:


知道了这两类接口的原理。我们来几个案例:


a.实现ImportSelector导入类并在导入类时一点逻辑


MyImportSelector


selectImports方法的返回值,必须是一个class(全称),该class会被spring容器所托管起来


//selectImports方法的返回值,必须是一个class(全称),该class会被spring容器所托管起来
public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        System.out.println(importingClassMetadata.getAnnotationAttributes(EnableLog.class.getName()));
        /**
         * 这里可以获取直接的详细信息,然后根据信息去动态的返回需要被Spring容器管理的bean
         */
        return new String[]{"com.springboot.demo5.User",Role.class.getName(),MyConfiguration.class.getName()};
    }
}


这个处理器,加入了3个类,并在这3个类注入的时候加点逻辑。


自定义注解@EnableLog


@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import({MyImportSelector.class})
public @interface EnableLog {
    String name() default "";
}


测试入口类:


@ComponentScan
@EnableLog(name="my springboot")
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));
        System.out.println(context.getBeansOfType(Runnable.class));
        context.close();
    }
 }


可以看到通过@EnableLog注解,我们注入了bean,并且打印了我们添加的业务代码:


1dc618a0ed9580ce8bfa6facb208c08f.png


b.实现ImportBeanDefinitionRegistrar导入类


/**
 * registerBeanDefinitions方法的参数有一个BeanDefinitionRegistry,
 * BeanDefinitionRegistry 可以用来往spring容器中注入bean
 * 如此,我们就可以在registerBeanDefinitions方法里面动态的注入bean
 */
public class MyImportBeanDefinitionRegister implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        BeanDefinitionBuilder bdb = BeanDefinitionBuilder.rootBeanDefinition(User.class);
        registry.registerBeanDefinition("user", bdb.getBeanDefinition());
        BeanDefinitionBuilder bdb2 = BeanDefinitionBuilder.rootBeanDefinition(Role.class);
        registry.registerBeanDefinition("role",  bdb2.getBeanDefinition());
        BeanDefinitionBuilder bdb3 = BeanDefinitionBuilder.rootBeanDefinition(MyConfiguration.class);
        registry.registerBeanDefinition(MyConfiguration.class.getName(),  bdb3.getBeanDefinition());
    }
}


@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import({MyImportBeanDefinitionRegister.class})
public @interface EnableLog {
    String name() default "";
}


测试下:


@ComponentScan
@EnableLog(name="my springboot")
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));
        System.out.println(context.getBeansOfType(Runnable.class));
        context.close();
    }
 }


看下结果,同样注入了bean:

5d4c6812c8535adbb050f4ddf2e1bce8.png


四、手动实现个enable*注解案例


案例:我们手动实现个注解,主要在某个包下,我们就打印包下的所有类的权限定名:

准备2个包,和2个bean

1dc618a0ed9580ce8bfa6facb208c08f.png


@Component
public class Cat {
}


@Component
public class Dog {
}


EchoImportBeanDefinitionRegistrar
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.Arrays;
import java.util.List;
import java.util.Map;
public class EchoImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        Map attr = importingClassMetadata.getAnnotationAttributes(EnableEcho.class.getName());
        String[] packAttr = (String[]) attr.get("packages");
        List packages = Arrays.asList(packAttr);
        System.out.println("packages: "+ packages);
        BeanDefinitionBuilder bdb = BeanDefinitionBuilder.rootBeanDefinition(EchoBeanPostProcessor.class);
        bdb.addPropertyValue("packages",packages);
        registry.registerBeanDefinition(EchoBeanPostProcessor.class.getName(), bdb.getBeanDefinition());
    }
}


EchoBeanPostProcessor


public class EchoBeanPostProcessor implements BeanPostProcessor {
    private List packages;
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        for (String pack: packages){
            if (bean.getClass().getName().startsWith(pack)){
                System.out.println("echo bean : " + bean.getClass().getName());
            }
        }
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    public List getPackages() {
        return packages;
    }
    public void setPackages(List packages) {
        this.packages = packages;
    }
}


@EnableEcho


@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import({EchoImportBeanDefinitionRegistrar.class})
public @interface EnableEcho {
    String[] packages() ;
}


测试:


@ComponentScan
@EnableLog(name="my springboot")
@EnableEcho(packages = {"com.springboot.demo5.bean","com.springboot.demo5.vo"})
public class App3 {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(App3.class, args);
        context.close();
    }
}


运行结果:


5d4c6812c8535adbb050f4ddf2e1bce8.png

结果显示如预期。


回顾下:本篇主要介绍了enable前缀注解的使用和原理,主要根据import导入,importSelector或者ImportBeanDefinitionRegistrar实现类为参数,结合我们可以根据enable注解上的参数来控制操作bean,或者在注入bean前加入我们自己的逻辑。


相关文章
|
4天前
|
Java 应用服务中间件 测试技术
深入探索Spring Boot Web应用源码及实战应用
【5月更文挑战第11天】本文将详细解析Spring Boot Web应用的源码架构,并通过一个实际案例,展示如何构建一个基于Spring Boot的Web应用。本文旨在帮助读者更好地理解Spring Boot的内部工作机制,以及如何利用这些机制优化自己的Web应用开发。
30 3
|
4天前
|
安全 Java 开发者
深入理解Spring Boot配置绑定及其实战应用
【4月更文挑战第10天】本文详细探讨了Spring Boot中配置绑定的核心概念,并结合实战示例,展示了如何在项目中有效地使用这些技术来管理和绑定配置属性。
15 1
|
1天前
|
前端开发 Java
audio案例(1),2024年最新springboot项目源码
audio案例(1),2024年最新springboot项目源码
|
2天前
|
Java
Springboot 使用自定义注解结合AOP方式校验接口参数
Springboot 使用自定义注解结合AOP方式校验接口参数
Springboot 使用自定义注解结合AOP方式校验接口参数
|
3天前
|
Java 开发者 Spring
springboot @RequiredArgsConstructor @Lazy解决循环依赖的原理
【5月更文挑战第16天】在Spring Boot中,@RequiredArgsConstructor 和 @Lazy 是两个有用的注解,它们分别用于简化构造函数的生成和控制Bean的加载时间。下面详细解析这两个注解的概念、优缺点以及在实际应用中的示例。
5 1
|
3天前
|
Java 开发者 Spring
springboot DDD的概念以及实战
【5月更文挑战第15天】领域驱动设计(Domain-Driven Design,简称DDD)是一种软件设计方法论,它强调基于业务领域的复杂性来构建软件
10 2
|
4天前
|
存储 缓存 Java
【JavaEE】Spring中注解的方式去获取Bean对象
【JavaEE】Spring中注解的方式去获取Bean对象
3 0
|
4天前
|
存储 Java 对象存储
【JavaEE】Spring中注解的方式去存储Bean对象
【JavaEE】Spring中注解的方式去存储Bean对象
7 0
|
4天前
|
开发框架 监控 Java
深入探索Spring Boot的监控、管理和测试功能及实战应用
【5月更文挑战第14天】Spring Boot是一个快速开发框架,提供了一系列的功能模块,包括监控、管理和测试等。本文将深入探讨Spring Boot中监控、管理和测试功能的原理与应用,并提供实际应用场景的示例。
16 2
|
4天前
|
XML Java 开发者
springboot 启动原理、启动过程、启动机制的介绍
【5月更文挑战第13天】Spring Boot 是一种基于 Java 的框架,用于创建独立的、生产级别的 Spring 应用程序。它的主要目标是简化 Spring 应用的初始搭建和开发过程,同时提供一系列大型项目常见的非功能性特征(如嵌入式服务器、安全性、度量、健康检查和外部化配置)。
18 3