转载

Spring Boot注解学习之@SpringBootApplication(二)

@ComponentScan

在讲述 @Configuration 启动容器+ @Component 注册 Bean 小节中简单介绍了 @ComponentScan 注解的使用。

@ComponentScan 的功能其实就是自动扫描并加载符合条件的组件或 bean 定义，最终将这些 bean 定义加载到容器中。 我们可以通过 backPackages 等属性指定@ComponentScan 自动扫描的范围，如果不指定，则默认 Spring 框架实现从声明@ComponentScan 所在类的 package 进行扫描，默认情况下是不指定的，所以 SpringBoot 的启动类最好在 root package 下。

首先看下 @ComponentScan 的源码： 

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
    @AliasFor("basePackages")
    String[] value() default {};

    @AliasFor("value")
    String[] basePackages() default {};

    Class<?>[] basePackageClasses() default {};

    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

    Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;

    ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;

    String resourcePattern() default "**/*.class";

    boolean useDefaultFilters() default true;

    ComponentScan.Filter[] includeFilters() default {};

    ComponentScan.Filter[] excludeFilters() default {};

    boolean lazyInit() default false;

    @Retention(RetentionPolicy.RUNTIME)
    @Target({})
    public @interface Filter {
        FilterType type() default FilterType.ANNOTATION;

        @AliasFor("classes")
        Class<?>[] value() default {};

        @AliasFor("value")
        Class<?>[] classes() default {};

        String[] pattern() default {};
    }
}
复制代码

重点有以下几个属性：

  • basePackages 与 value：用于指定包的路径进行扫描；
  • basePackageClasses：用于指定某个类的包的路径进行扫描；
  • nameGenerator：bean 的名称的生成器；
  • useDefaultFilters：是否开启对@Component，@Repository，@Service，@Controller 的类进行检测，默认为 true；
  • includeFilters：包含的过滤条件 FilterType.ANNOTATION:按照注解过滤； FilterType.ASSIGNABLE_TYPE：按照给定的类型；FilterType.ASPECTJ：使用 ASPECTJ 表达式；FilterType.REGEX：正则；FilterType.CUSTOM：自定义规则 。
  • excludeFilters：排除的过滤条件，用法和 includeFilters 一样。

属性

basePackages 与 value 

@ComponentScan(basePackages = “”)     //单个
@ComponentScan(basePackages = {“com.example.dao”，“aaa”,“…”})   //多个
//value 同理
复制代码

注意：可以省略 “ basePackages = ”。

@Configuration
@ComponentScan("com.example.dao")
public class MyConfig {}

@Configuration
@ComponentScan("com.example.dao","com.example.service")
public class MyConfig {}

@Configuration
@ComponentScan("com.example.*")   //通配符匹配所有的包
public class MyConfig {}
复制代码

basePackageClasses 

@ComponentScan(basePackageClasses = “”)   //单个
@ComponentScan(basePackageClasses = {“HelloController.class”，“bbb”,“…”})  //多个
复制代码

注意：不可以省略“basePackageClasses =”

@Configuration
@ComponentScan(basePackageClasses = HelloController.class)
public class MyConfig {
}
复制代码

includeFilters

接下来我们用以下代码进行测试。

Repository 的注解类：

package com.example.dao;
@Repository
public class BusinessDAO {

    public void update(){
        System.out.println("调用了 dao 层的 update 方法....");
    }
}
复制代码

Service 的注解类：

package com.example.service;
@Service
public class BusinessService {
    @Autowired
    private BusinessDAO businessDAO;

    public void service(){
        System.out.println("调用了 service 层的 service() 方法 .....");
        businessDAO.update();
    }
}
复制代码

Controller 的注解类：

package com.example.controller;
@Controller
public class BusinessController {

    @Autowired
    private BusinessService service;

    public void request() {
        System.out.println(" 调用了 Controller 的 request() 方法...");
        service.service();
    }
}
复制代码

Configuration 配置类：

package com.example.configuration;
@Configuration
//@ComponentScan(basePackages = {"com.example.dao","com.example.service","com.example.controller"})
@ComponentScan(value = {"com.example.dao","com.example.service","com.example.controller"},
        includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = Repository.class)},
        useDefaultFilters = false)
public class ScanConfig {

}
复制代码

测试类代码：

public class ScanConfigTest {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ScanConfig.class);
        String[] definitionNames = context.getBeanDefinitionNames();
        for(String name:definitionNames){
            System.out.println(name);
        }
    }
}
复制代码

执行结果为：

19:22:48.157 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'scanConfig'
19:22:48.162 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'businessDAO'
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
scanConfig
businessDAO
复制代码

根据结果分析： 除了 spring 本身注册的一些 bean 之外，可以看到最后一行，已经将 ScanConfig 这个类和 BusinessDAO 注册进容器中了。

includeFilters 的参数是一个 Filter[] 数组，然后指定 FilterType 的类型为 ANNOTATION，也就是通过注解来过滤，最后的 value 则是 Repository 注解类。配置之后，在 spring 扫描的时候，就会筛选 com.example 下的三个包中，所有被 @Repository 注解标注的类。

注意：需要设置 useDefaultFilters 为 false，否则@ComponentScan 注解会将 被 @Component、@Repository、@Service 和 @Controller 标注的类都注册进容器中。同时因为我们在 Controller 和 Service 注解的类中关联了其他的类(@Autowired)，所以最好在 includeFilters 的 Filter 属性中不要设置为 Controller.class 或 Service.class。

excludeFilters

修改配置类：

@Configuration
//@ComponentScan(basePackages = {"com.example.dao","com.example.service","com.example.controller"})
@ComponentScan(value = {"com.example.dao","com.example.service","com.example.controller"},
        excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = Controller.class)})
public class ScanConfig {

}
复制代码

同 excludeFilters 属性类似， 配置之后，在 spring 扫描的时候，就会跳过 com.example 下的三个包中，所有被 @Controller 注解标注的类。

执行结果为：

19:44:39.191 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'scanConfig'
19:44:39.195 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'businessDAO'
19:44:39.195 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'businessService'
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
scanConfig
businessDAO
businessService
复制代码

添加自定义过滤规则

在前面使用过 @Filter 注解，里面的 type 属性是一个 FilterType 的枚举类型：

public enum FilterType {

    ANNOTATION,
    ASSIGNABLE_TYPE,
    ASPECTJ,
    REGEX,
    CUSTOM
}
复制代码

使用 CUSTOM 类型，就可以实现自定义过滤规则。

package com.example.filter;
public class CustomTypeFilter implements TypeFilter {
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        // 获取当前扫描到的类的注解元数据
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        // 获取当前扫描到的类的元数据
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        // 获取当前扫描到的类的资源信息
        Resource resource = metadataReader.getResource();

        if (classMetadata.getClassName().contains("Business")){
            return true;
        }
        return false;
    }
}
复制代码

增加 Service 注解修饰的类：

package com.example.service;
@Service
public class UserService {
}
复制代码

修改配置类：

@Configuration
@ComponentScan(value = {"com.example.dao","com.example.service","com.example.controller"},
        excludeFilters = {@ComponentScan.Filter(type = FilterType.CUSTOM,classes = CustomTypeFilter.class)})
public class ScanConfig {

}
复制代码

执行测试类代码，结果为：

19:56:25.419 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'scanConfig'
19:56:25.424 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'userService'
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
scanConfig
userService
复制代码

这里简单对扫描到的类名进行判断，如果类名包含”Business“的就符合条件，就会被剔除，不会注入到容器中。

@Component

1、不指定 bean 的名称，默认为类名首字母小写 university

@Component
public class BeanWithComponent {

    public void sayHello(){

        System.out.println("BeanWithComponent sayHello...");
    }

    public void start(){
        System.out.println("BeanWithComponent 初始化。。。");
    }

    public void cleanUp(){
        System.out.println("BeanWithComponent 销毁。。。");
    }
}
复制代码

获取 bean 方式：

@Autowired
BeanWithComponent beanWithComponent;
复制代码

或

ApplicationContext context = new AnnotationConfigApplicationContext(ComfigureWithScan.class);
BeanWithComponent bean = (BeanWithComponent) context.getBean("beanWithComponent");
复制代码

2、指定 bean 的名称

@Component("bean2")
public class BeanWithComponent {

}
复制代码

获取 bean 方式：

@Autowired
BeanWithComponent bean2;
复制代码

或

ApplicationContext context = new AnnotationConfigApplicationContext(ComfigureWithScan.class);
BeanWithComponent bean = (BeanWithComponent) context.getBean("bean2");
复制代码

总结

@ComponentScan 注解有以下特性：

  • 自定义扫描路径下边带有 @Controller ， @Service ， @Repository ， @Component 注解加入 spring 容器

  • 通过 includeFilters 加入扫描路径下没有以上注解的类加入 spring 容器

  • 通过 excludeFilters 过滤出不用加入 spring 容器的类

  • 自定义增加了@Component 注解的注解方式

接下来讲述一下关于@ComponentScan 注解的两个扩展。

@ComponentScans

源码如下：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
public @interface ComponentScans {
    ComponentScan[] value();
}
复制代码

配置类：

@Configuration
@ComponentScans(value = @ComponentScan("com.example.dao"))
public class ScanConfig {

}
复制代码

执行结果为：

20:07:45.908 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'scanConfig'
20:07:45.914 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'businessDAO'
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
scanConfig
businessDAO
复制代码

context:component-scan

上述代码我们是通过 @Configuration + @ComponentScan 注解来实现 spring 加载，当然也可以在配置文件中加上扫描的配置。

spring-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    <!--<context:component-scan base-package="com.example.dao" annotation-config="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
    </context:component-scan>-->
    <context:component-scan base-package="com.example.dao" />
    <context:component-scan base-package="com.example.controller" />
    <context:component-scan base-package="com.example.service" />
</beans>
复制代码

修改测试类代码：

public class ScanConfigTest {

    public static void main(String[] args) {
        ApplicationContext  context = new ClassPathXmlApplicationContext("spring-context.xml");
        String[] definitionNames = context.getBeanDefinitionNames();
        for(String name:definitionNames){
            System.out.println(name);
        }
    }
}
复制代码

运行得到以下结果：

14:59:12.773 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'businessDAO'
14:59:12.778 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'businessController'
14:59:12.789 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'businessService'
14:59:12.789 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'userService'
businessDAO
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
businessController
businessService
userService
复制代码

关于 的使用，关于属性的详细讲解可以参考： 详解

注意： 中有一个 annotation-config 属性，该属性主要是隐式地向 Spring 容器注册 internalConfigurationAnnotationProcessor 、 internalAutowiredAnnotationProcessor 、 internalCommonAnnotationProcessor 、 internalEventListenerProcessor 以及 internalEventListenerFactory 这五个 bean 类。

当 annotation-config 属性值设为 false 时，即不会注册这五个类。但是 @ComponentScan 注解没有该属性。 这是因为在几乎所有情况下，使用 @ComponentScan 时，都假定使用默认的注释配置处理（例如，处理@Autowired 和 friends ）。 此外，在使用 AnnotationConfigApplicationContext 时，注释配置处理器始终会被注册，这意味着在 @ComponentScan 级别禁用它们的任何尝试都将被忽略。

SpringBootApplication 注解中4个方法

@SpringBootApplication不仅包括上面的三个重要注解，还包含有4个方法:

Spring Boot注解学习之@SpringBootApplication(二) 
Class[] exclude() default {};
String[] excludeName() default {};
String[] scanBasePackages() default {};
Class[] scanBasePackageClasses() default {};

小结

这里总结下 @SpringBootApplication 中的三个重要注解的特征：

  • @Configuration

定义 Spring Ioc 容器的配置类。

  • @EnableAutoConfiguration

从 classpath 中搜寻所有 META/spring.factories 配置文件，并将其中 org.springframework.boot.autoconfigure.EnableAutoConfiguration 对应的配置项，也就是一个自动配置类列表加载到 Ioc 容器中。 简单说，就是 @EnawebleAutoConfiguration 让 Spring Boot 根据类路径下的 jar 包依赖为当前项目进行自动配置，例如，添加了 spring-boot-starter-web 依赖，会自动添加 Tomcat 和 Spring MVC 的依赖。而对于所有标注 @Configuration 的配置类，统一使用 ConfigurationClassParser 解析的。

  • @ComponentScan

自动扫描并加载符合条件的组件或者 bean 定义。

参考文献

spring4.0之二：@Configuration的使用

springboot系列文章之SpringBootApplication注解

原文  https://juejin.im/post/5dee4ea46fb9a0161104c0a2
正文到此结束
所属分类： 编程技术 Java

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 java-demo Maven教程 springcloud-demo hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 ANTLR教程 SpringCloud Ant教程 java实例教程 Hazelcast教程 XStream教程 Elastic-Job-Lite 深入浅出MyBatis ibaties教程 SVN教程 rabittmq教程 Hadoop教程 solr教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 使用 Docker 打包和运行 Vue 应用
  2. 2 Dependency Check命令行方式扫描jar包的安全漏洞
  3. 3 maven使用Dependency-Check来扫描安全漏洞
  4. 4 使用sonarqube分析代码质量
  5. 5 使用screw来对比数据库表和字段差异
  6. 6 Spring Boot 实现防盗链功能
  7. 7 在Spring Boot中的实现国际化（i18n）
  8. 8 一个用于 SMB/CIFS 网络的 Java 库-JCIFS
  9. 9 Spring Boot 3.x嵌入MongoDB 进行测试
  10. 10 java如何解析和生成yaml文件？
网站信息
  • 文章总数：82,737 篇
  • 文件总数：284,312 个
  • 标签总数：2,416 个
  • 分类总数：85 个
  • 留言数量：2,559 条
  • 在线人数：638 人
  • 运行天数：4,439天
  • 最后更新：2024年12月22日15点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG