《深入浅出Spring》Spring注解（常用注解）

猿一一

已于 2022-06-18 23:54:34 修改

阅读量193

点赞数

分类专栏： Spring 文章标签： spring java 后端

于 2022-06-16 23:59:23 首次发布

本文链接：https://blog.csdn.net/ysj_2021/article/details/125324785

版权

Spring 专栏收录该内容

28 篇文章 4 订阅

订阅专栏

常用注解

@Configuration

用法
@Configuration这个注解可以加在类上，让这个类的功能等同于一个bean xml配置文件，如下：

@Configuration
public class ConfigBean {
}

上面代码类似于下面的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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
</beans>

通过AnnotationConfigApplicationContext来加载@Configuration修饰的类，如下：

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConfigBean.class);

此时ConfigBean类中没有任何内容，相当于一个空的xml配置文件，此时我们要在ConfigBean类中注册bean，那么我们就要用到@Bean注解了。
总结一下
@Configuration使用步骤：

在类上使用@Configuration注解
通过AnnotationConfigApplicationContext容器来加@Configuration注解修饰的类

@Bean

这个注解类似于bean xml配置文件中的bean元素，用来在spring容器中注册一个bean。

@Bean注解用在方法上，表示通过方法来定义一个bean，默认将方法名称作为bean名称，将方法返回值作为bean对象，注册到spring容器中。

如：

@Bean
public User user1() {
    return new User();
}

@Bean注解还有很多属性，我们来看一下其源码：

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE}) //@1
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Bean {
    @AliasFor("name")
    String[] value() default {};
    @AliasFor("value")
    String[] name() default {};
    @Deprecated
    Autowire autowire() default Autowire.NO;
    boolean autowireCandidate() default true;
    String initMethod() default "";
    String destroyMethod() default AbstractBeanDefinition.INFER_METHOD;
}

@1：说明这个注解可以用在方法和注解类型上面。

每个参数含义：

value和name是一样的，设置的时候，这2个参数只能选一个，原因是@AliasFor导致的

@AliasFor这个注解不清楚的可以看这个文章：详解注解

value：字符串数组，第一个值作为bean的名称，其他值作为bean的别名

autowire：这个参数上面标注了@Deprecated，表示已经过期了，不建议使用了

autowireCandidate：是否作为其他对象注入时候的候选bean，之前的文章中专门介绍过这个属性，不清楚的可以去看看：autowire-candidate详解

initMethod：bean初始化的方法，这个和生命周期有关，

destroyMethod：bean销毁的方法，也是和生命周期相关的，

被@Configuration修饰的类，spring容器中会通过cglib给这个类创建一个代理，代理会拦截所有被@Bean修饰的方法，默认情况（bean为单例）下确保这些方法只被调用一次，从而确保这些bean是同一个bean，即单例的。
如果说一个类不加@Configuration 只用@Bean修饰，那么这些bean对象将不会以单例形式注入到Spring中

spring这块的源码
spring中用下面这个类处理@Configuration这个注解：

org.springframework.context.annotation.ConfigurationClassPostProcessor
这里面重点关注这几个方法：

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory)

@ComponentScan

@ComponentScan用于批量注册bean。

这个注解会让spring去扫描某些包及其子包中所有的类，然后将满足一定条件的类作为bean注册到spring容器容器中。

具体需要扫描哪些包？以及这些包中的类满足什么条件时被注册到容器中，这些都可以通过这个注解中的参数动态配置
先来看一下这个注解的定义：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Repeatable(ComponentScans.class) //@1
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;
    Filter[] includeFilters() default {};
    Filter[] excludeFilters() default {};
    boolean lazyInit() default false;
}

定义上可以看出此注解可以用在任何类型上面，不过我们通常将其用在类上面。

常用参数：

value：指定需要扫描的包，

basePackages：作用同value；value和basePackages不能同时存在设置，可二选一

basePackageClasses：指定一些类，spring容器会扫描这些类所在的包及其子包中的类

nameGenerator：自定义bean名称生成器

resourcePattern：需要扫描包中的那些资源，默认是：*/.class，即会扫描指定包中所有的class文件

useDefaultFilters：对扫描的类是否启用默认过滤器，默认为true

includeFilters：过滤器：用来配置被扫描出来的那些类会被作为组件注册到容器中

excludeFilters：过滤器，和includeFilters作用刚好相反，用来对扫描的类进行排除的，被排除的类不会被注册到容器中

lazyInit：是否延迟初始化被注册的bean

@1：@Repeatable(ComponentScans.class)，这个注解可以同时使用多个。

@ComponentScan工作的过程：
Spring会扫描指定的包，且会递归下面子包，得到一批类的数组
然后这些类会经过上面的各种过滤器，最后剩下的类会被注册到容器中
所以玩这个注解，主要关注2个问题：
第一个：需要扫描哪些包？通过value、backPackages、basePackageClasses这3个参数来控制
第二：过滤器有哪些？通过useDefaultFilters、includeFilters、excludeFilters这3个参数来控制过滤器
这两个问题搞清楚了，就可以确定哪些类会被注册到容器中。
默认情况下，任何参数都不设置的情况下，此时，会将@ComponentScan修饰的类所在的包作为扫描包；默认情况下useDefaultFilters为true，这个为true的时候，spring容器内部会使用默认过滤器，规则是：凡是类上有@Repository、@Service、@Controller、@Component这几个注解中的任何一个的，那么这个类就会被作为bean注册到spring容器中，所以默认情况下，只需在类上加上这几个注解中的任何一个，这些类就会自动交给spring容器来管理了。

@Component、@Repository、@Service、@Controller

先说一下@Component这个注解，看一下其定义：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Component {
    String value() default "";
}

从定义中可以看出，这个注解可以用在任何类型上面。

通常情况下将这个注解用在类上面，标注这个类为一个组件，默认情况下，被扫描的时候会被作为bean注册到容器中。

value参数：被注册为bean的时候，用来指定bean的名称，如果不指定，默认为类名首字母小写。如：类UserService对应的beanname为userService

再来看看@Repository源码如下：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Repository {
    @AliasFor(annotation = Component.class)
    String value() default "";
}

Repository上面有@Component注解。

value参数上面有@AliasFor(annotation =
Component.class)，设置value参数的时候，也相当于给@Component注解中的value设置值。

其他两个注解@Service、@Controller源码和@Repository源码类似。

这4个注解本质上是没有任何差别，都可以用在类上面，表示这个类被spring容器扫描的时候，可以作为一个bean组件注册到spring容器中。

spring容器中对这4个注解的解析并没有进行区分，统一采用@Component注解的方式进行解析，所以这几个注解之间可以相互替换。

spring提供这4个注解，是为了让系统更清晰，通常情况下，系统是分层结构的，多数系统一般分为controller层、service层、dao层。

@controller通常用来标注controller层组件，@service注解标注service层的组件，@Repository标注dao层的组件，这样可以让整个系统的结构更清晰，当看到这些注解的时候，会和清晰的知道属于哪个层，对于spring来说，将这3个注解替换成@Component注解，对系统没有任何影响，产生的效果是一样的。

componentScan 常用的参数

指定需要扫描的包
指定需要扫毛哪些包，可以通过value或者basePackage来配置，二者选其一，都配置运行会报错，下面我们通过value来配置。

@ComponentScan({
        "com.yuan11.controller",
        "com.yuan11.service"
})
public class ScanBean2 {
}

basePackageClasses指定扫描范围

@ComponentScan(basePackageClasses = ScanClass.class)
public class ScanBean6 {
}

includeFilters的使用

Filter[] includeFilters() default {};

是一个Filter类型的数组，多个Filter之间为或者关系，即满足任意一个就可以了，看一下Filter的代码：

@Retention(RetentionPolicy.RUNTIME)
@Target({})
@interface Filter {
    FilterType type() default FilterType.ANNOTATION;
    @AliasFor("classes")
    Class<?>[] value() default {};
    @AliasFor("value")
    Class<?>[] classes() default {};
    String[] pattern() default {};
}

可以看出Filter也是一个注解，参数：

type：过滤器的类型，是个枚举类型，5种类型

ANNOTATION：通过注解的方式来筛选候选者，即判断候选者是否有指定的注解

ASSIGNABLE_TYPE：通过指定的类型来筛选候选者，即判断候选者是否是指定的类型

ASPECTJ：ASPECTJ表达式方式，即判断候选者是否匹配ASPECTJ表达式

REGEX：正则表达式方式，即判断候选者的完整名称是否和正则表达式匹配

CUSTOM：用户自定义过滤器来筛选候选者，对候选者的筛选交给用户自己来判断

value：和参数classes效果一样，二选一

classes：3种情况如下

当type=FilterType.ANNOTATION时，通过classes参数可以指定一些注解，用来判断被扫描的类上是否有classes参数指定的注解

当type=FilterType.ASSIGNABLE_TYPE时，通过classes参数可以指定一些类型，用来判断被扫描的类是否是classes参数指定的类型

当type=FilterType.CUSTOM时，表示这个过滤器是用户自定义的，classes参数就是用来指定用户自定义的过滤器，自定义的过滤器需要实现org.springframework.core.type.filter.TypeFilter接口

pattern：2种情况如下

当type=FilterType.ASPECTJ时，通过pattern来指定需要匹配的ASPECTJ表达式的值

当type=FilterType.REGEX时，通过pattern来自正则表达式的值

栗子：

定义一个注解

package com.yuan11;
import java.lang.annotation.*;
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyBean {
}

创建一个类，使用这个注解标注

package com.yuan11;
@MyBean
public class Service1 {
}

再来一个类，使用spring中的@Compontent标注

package com.yuan11;
import org.springframework.stereotype.Component;
@Component
public class Service2 {
}

再来一个类，使用@CompontentScan标注

package com.yuan11;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.FilterType;
@ComponentScan(includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = MyBean.class)
})
public class ScanBean3 {
}

Service1上标注了@MyBean注解，被注册到容器了，但是Service2上没有标注@MyBean啊，怎么也被注册到容器了？
原因：Service2上标注了@Compontent注解，而@CompontentScan注解中的useDefaultFilters默认是true，表示也会启用默认的过滤器，而默认的过滤器会将标注有@Component、@Repository、@Service、@Controller这几个注解的类也注册到容器中
如果我们只想将标注有@MyBean注解的bean注册到容器，需要将默认过滤器关闭，即：useDefaultFilters=false，我们修改一下ScanBean3的代码如下：

@ComponentScan(
        useDefaultFilters = false, //不启用默认过滤器
        includeFilters = {
                @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = MyBean.class)
        })
public class ScanBean3 {
}

包含指定类型的类
@ComponentScan(
useDefaultFilters = false, //不启用默认过滤器
includeFilters = {
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = IService.class) //@1
})
public class ScanBean4 {
}

这里是引用
@1：被扫描的类满足IService.class.isAssignableFrom(被扫描的类)条件的都会被注册到spring容器中

自定义Filter
有时候我们需要用到自定义的过滤器，使用自定义过滤器的步骤：

1.设置@Filter中type的类型为：FilterType.CUSTOM
2.自定义过滤器类，需要实现接口：org.springframework.core.type.filter.TypeFilter
3.设置@Filter中的classses为自定义的过滤器类型

来看一下TypeFilter这个接口的定义：

@FunctionalInterface
public interface TypeFilter {
    boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
            throws IOException;
}

是一个函数式接口，包含一个match方法，方法返回boolean类型，有2个参数，都是接口类型的，下面介绍一下这2个接口。

MetadataReader接口
类元数据读取器，可以读取一个类上的任意信息，如类上面的注解信息、类的磁盘路径信息、类的class对象的各种信息，spring进行了封装，提供了各种方便使用的方法。

看一下这个接口的定义：

public interface MetadataReader {
    /**
     * 返回类文件的资源引用
     */
    Resource getResource();
    /**
     * 返回一个ClassMetadata对象，可以通过这个读想获取类的一些元数据信息，如类的class对象、是否是接口、是否有注解、是否是抽象类、父类名称、接口名称、内部包含的之类列表等等，可以去看一下源码
     */
    ClassMetadata getClassMetadata();
    /**
     * 获取类上所有的注解信息
     */
    AnnotationMetadata getAnnotationMetadata();
}

MetadataReaderFactory接口:

类元数据读取器工厂，可以通过这个类获取任意一个类的MetadataReader对象。

源码：

public interface MetadataReaderFactory {
    /**
     * 返回给定类名的MetadataReader对象
     */
    MetadataReader getMetadataReader(String className) throws IOException;
    /**
     * 返回指定资源的MetadataReader对象
     */
    MetadataReader getMetadataReader(Resource resource) throws IOException;
}

栗子：

public class MyFilter implements TypeFilter {
    /**
     * @param metadataReader
     * @param metadataReaderFactory
     * @return
     * @throws IOException
     */
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        Class curClass = null;
        try {
            //当前被扫描的类
            curClass = Class.forName(metadataReader.getClassMetadata().getClassName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //判断curClass是否是IService类型
        boolean result = IService.class.isAssignableFrom(curClass);
        return result;
    }
}

@ComponentScan(
        basePackages = {"com.yuan11"},
        useDefaultFilters = false, //不启用默认过滤器
        includeFilters = {
                @ComponentScan.Filter(type = FilterType.CUSTOM, classes = MyFilter.class) //@1
        })
public class ScanBean5 {
}

@1：type为FilterType.CUSTOM，表示Filter是用户自定义的，classes为自定义的过滤器

excludeFilters

类似于includFilters

@ComponentScan重复使用
从这个注解的定义上可以看出这个注解可以同时使用多个，如：

@ComponentScan(basePackageClasses = ScanClass.class)
@ComponentScan(
        useDefaultFilters = false, //不启用默认过滤器
        includeFilters = {
                @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = IService.class)
        })
public class ScanBean7 {
}

还有一种写法，使用@ComponentScans的方式：

@ComponentScans({
        @ComponentScan(basePackageClasses = ScanClass.class),
        @ComponentScan(
                useDefaultFilters = false, //不启用默认过滤器
                includeFilters = {
                        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = IService.class)
                })})
public class ScanBean7 {
}

Spring中这块的源码
@CompontentScan注解是被下面这个类处理的

org.springframework.context.annotation.ConfigurationClassPostProcessor

这个类非常非常关键，主要用户bean的注册，前面我们介绍的@Configuration,@Bean注解也是被这个类处理的。

还有下面这些注解：

@PropertySource
@Import
@ImportResource
@Compontent

以上这些注解都是被ConfigurationClassPostProcessor这个类处理的，内部会递归处理这些注解，完成bean的注册。

以@CompontentScan来说一下过程，第一次扫描之后会得到一批需要注册的类，然后会对这些需要注册的类进行遍历，判断是否有上面任意一个注解，如果有，会将这个类交给ConfigurationClassPostProcessor继续处理，直到递归完成所有bean的注册

总结
@ComponentScan用于批量注册bean，spring会按照这个注解的配置，递归扫描指定包中的所有类，将满足条件的类批量注册到spring容器中
可以通过value、basePackages、basePackageClasses 这几个参数来配置包的扫描范围
可以通过useDefaultFilters、includeFilters、excludeFilters这几个参数来配置类的过滤器，被过滤器处理之后剩下的类会被注册到容器中
指定包名的方式配置扫描范围存在隐患，包名被重命名之后，会导致扫描实现，所以一般我们在需要扫描的包中可以创建一个标记的接口或者类，作为basePackageClasses的值，通过这个来控制包的扫描范围
@CompontScan注解会被ConfigurationClassPostProcessor类递归处理，最终得到所有需要注册的类