spring 注解笔记

1、@Configuration

用于定义配置类,可替换xml配置文件,被注解的类内部包含有一个或多个被@Bean注解的方法，这些方法将会被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类进行扫描，并用于构建bean定义，初始化Spring容器。

2、@Bean

一般都在@Configuration指定下，替换xml中<bean>标签

3、@Import

将指定的Bean加入到IOC容器之中进行管理，有3种方式导入

类型一 : 导入某个配置类

类型二 : 导入某个ImportSelector接口实现类

类型三 : 导入某个ImportBeanDefinitionRegistrar接口实现类

3.1 导入配置类最简单，如下

@Import(Student.class)

作用就是new Student() 调用无参构造函数，其他都没做。

@Import上面的使用方式属于静态的导入依赖，如果用动态导入呢，比如要导入很多类，你总不至于每个写class，100个呢？吃不消，所以动态解决比如都写在一个properties配置文件中，扫描到全部导入。

这个时候就要用ImportSelector接口实现类

3.2 ImportSelector接口实现类

就只需要实现selectImports方法就行

public interface ImportSelector {
    String[] selectImports(AnnotationMetadata var1);
}

只需要注意返回的数组是全名getName()

public class MyImportSelector implements ImportSelector
{
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata)
    {
        return new String[]{Student.class.getName(), Address.class.getName()};
    }
}

@Configuration
@Import(MyImportSelector.class)
public class MainConfig
{

}

@Import还是要导入自定的MyImportSelector

Spring Boot就是这个原理用selectImports来扫描指定的文件导入

public String[] selectImports(AnnotationMetadata annotationMetadata) 
{
  if (!this.isEnabled(annotationMetadata)) {
      return NO_IMPORTS;
  } else {
      AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
      AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
      return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
  }
}

4、@Conditional

spring boot中最常用的注解，是用来判断条件的。

它的作用是按照一定的条件进行判断，满足条件给容器注册bean。

源码如下：

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
    Class<? extends Condition>[] value();
}

Condition是个接口，很明显填入的条件class必须实现Condition

然后实现matches方法，根据返回值true和false来判断是否注入。true为注入。

举例：

@Configuration
public class MyConfig
{
    @Bean
    @Conditional(WindowsEnvironment.class)
    public Student student()
    {
        Student student = new Student();
        return student;
    }
}

public class WindowsEnvironment implements Condition
{
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata)
    {
        Environment environment = conditionContext.getEnvironment();
        System.out.println("environment:" + environment.getProperty("os.name"));
        return true;
    }
}

如果WindowsEnvironment的matches返回false,则不注册。

4.1、@ConditionalOnClass

继承于@Conditional

当给定的类名在类路径上存在，则实例化当前Bean

可以避免因为Class Not Found导致的编译异常了

源码：

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional({OnClassCondition.class})
public @interface ConditionalOnClass {
    Class<?>[] value() default {};

    String[] name() default {};
}

既可以在Class上也可以在Method上。

public class Curose
{
    private String name;

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }
}

@Configuration
@ConditionalOnClass(value = Curose.class)
public class MyConfig
{
    @Bean
    public Person person()
    {
        return new Person();
    }

    @Bean
    public Student student()
    {
        Student student = new Student();
        return student;
    }
}

因为存在Curose类，所以@ConditionalOnClass 存在class则加载MyConfig配置。

其中@ConditionalOnClass 可以写name，这个会更加便捷动态加载Class，其中name要写包名+类名。

@ConditionalOnClass(name = "service.Curose")

4.2、@ConditionalOnMissingClass

当给定的类名在类路径上不存在，则实例化当前Bean

4.3、@ConditionalOnBean

 当给定的在bean存在时,则实例化当前Bean

 源码如下：

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional({OnBeanCondition.class})
public @interface ConditionalOnBean {
    Class<?>[] value() default {};

    String[] type() default {};

    Class<? extends Annotation>[] annotation() default {};

    String[] name() default {};

    SearchStrategy search() default SearchStrategy.ALL;

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

从上面的源代码中可以看出继承于@Conditional，判断是否加载bean逻辑都在OnBeanCondition.class中

可以用于Type和Method

例子：

1、用于Type中既class上

为了测试方便，我写了2个Configuration类MyConfig和MyConfig1

@Configuration
@ConditionalOnBean({Curose.class})
public class MyConfig
{
    @Bean
    public Student student()
    {
        Student student = new Student();
        return student;
    }
}

@Configuration
public class MyConfig1
{
    @Bean
    public Curose curose()
    {
        Curose curose = new Curose();
        return curose;
    }
}

主程序加载配置类

public class ConditionalMain
{
    public static void main(String[] args)
    {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig1.class, MyConfig.class);
        String[] beanDefinitionNames = context.getBeanDefinitionNames();
        for (String name : beanDefinitionNames)
        {
            System.out.println(name);
        }
    }
}

AnnotationConfigApplicationContext 中加载的顺序注意下，我是先加载MyConfig1,再加载MyConfig,所以先会执行MyConfig1配置类再执行MyConfig

在MyConfig上加入注解@ConditionalOnBean({Curose.class})，说明了如果Curose Bean类在Ioc容器中是否存在，如果存在则加载这配置类，如果不存在，则不会加载配置类，既不会执行以下代码。这也是我为啥MyConfig1配置类写在前面的原因，首先加载了

MyConfig1配置，既将Curose类加入了容器中，ConditionalOnBean返回的是存在，既会加载MyConfig配置。

运行结果：

myConfig1
myConfig
curose
student

如果将上面的配置顺序换下，则不会加载MyConfig配置。

new AnnotationConfigApplicationContext(MyConfig.class, MyConfig1.class);

运行结果：

myConfig1
curose

如果换成@ConditionalOnMissingBean({Curose.class}) 则正好相反，不存在加载配置，存在则不加载配置

2、用于Method 方法上

于加载类上的区别在于，类上不启作用则全部不会不执行，写在方法上则表示这个方法不会执行而已。

例子：

@Configuration
public class MyConfig
{
    @Bean
    public Person person()
    {
        return new Person();
    }

    @Bean
    @ConditionalOnBean({Curose.class})
    public Student student()
    {
        Student student = new Student();
        return student;
    }
}

加入了一个Person类

执行结果：

myConfig1
myConfig
curose
person
student

全部都加载了

如果MyConfig1和MyConfig顺序相反下则student不会加载。

在方法上还有一个作用，如果是方法注入，如果没有这个注解必会抛出空指针异常，加入了则不会不执行就不会有异常，等待你加入即可

例子：

@Configuration
public class MyConfig
{
    @Bean
    public Student student(Person person)
    {
        String name = person.getName();
        Student student = new Student();
        return student;
    }
}

getName() 必然会出现空异常，因为Person类还没加载到Ioc容器中。

@Configuration
public class MyConfig
{
    @Bean
    @ConditionalOnBean(Person.class)
    public Student student(Person person)
    {
        String name = person.getName();
        Student student = new Student();
        return student;
    }
}

加入了@ConditionalOnBean(Person.class) 后则Person不存在就不会执行了，等你哪天加载就执行，在Springboot 中很多应用就是这么干的，比如redis缓存。一开始创建项目就已经有RedisAutoConfiguration配置了，等你在pom.xml 加入spring-boot-starter-data-redis启动器后就会生效了。

 生效代码如下:

@Configuration
public class MyConfig
{
    @Bean
    public Person person()
    {
        return new Person();
    }

    @Bean
    @ConditionalOnBean(Person.class)
    public Student student(Person person)
    {
        String name = person.getName();
        Student student = new Student();
        return student;
    }
}

如果被Person在放Student下面就不会生效了，说明加载顺序是从上至下的。

@Configuration
public class MyConfig
{
    @Bean
    @ConditionalOnBean(Person.class)
    public Student student(Person person)
    {
        String name = person.getName();
        Student student = new Student();
        return student;
    }

    @Bean
    public Person person()
    {
        return new Person();
    }
}

 以上student就不会加载到Ioc容器中。

4.4、@ConditionalOnMissingBean

当给定的在bean不存在时,则实例化当前Bean

4.5 、@ConditionalOnProperty

spring boot使用@ConditionalOnProperty注解来控制@Configuration是否生效

源代码：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
@Documented
@Conditional({OnPropertyCondition.class})
public @interface ConditionalOnProperty {
    String[] value() default {};  //数组，获取对应property名称的值，与name不可同时使用

    String prefix() default "";  //property名称的前缀

    String[] name() default {}; //数组，property完整名称或部分名称（可与prefix组合使用，组成完整的property名称），与value不可同时使用

    String havingValue() default "";  //可与name组合使用，比较获取到的属性值与havingValue给定的值是否相同，相同才加载配置

    boolean matchIfMissing() default false;  //缺少该property时是否可以加载。如果为true，没有该property也会正常加载；反之报错
}

例子：

创建了TestConfig.class，并设置了ConditionalOnProperty prefix = "context.test"

@Configuration
@ConditionalOnProperty(prefix = "context.test", name = "name", havingValue = "true")
public class TestConfig
{
    @Bean
    public UserContext userContext(){
        return new UserContext();
    }
}

直接执行会报错，因为找不到Property中的context.test.name

在yml配置中写了

context.test.name: true

就可以正常运行了。由name+havingValue进行绑定

如果将true写成false就会失败。

如果改写成value属性：

@ConditionalOnProperty(prefix = "context.test", value = "name")

也是返回true，加载配置。

 如果将配置去除，加上matchIfMissing = true也是能运行成功加载配置的。

@ConditionalOnProperty(prefix = "context.test", value = "name", matchIfMissing = true)

注解	说明
@ConditionalOnSingleCandidate	当给定类型的bean存在并且指定为Primary的给定类型存在时,返回true
@ConditionalOnMissingBean	当给定的类型、类名、注解、昵称在beanFactory中不存在时返回true.各类型间是or的关系
@ConditionalOnBean	与上面相反，要求bean存在
@ConditionalOnMissingClass	当给定的类名在类路径上不存在时返回true,各类型间是and的关系
@ConditionalOnClass	与上面相反，要求类存在
@ConditionalOnCloudPlatform	当所配置的CloudPlatform为激活时返回true
@ConditionalOnExpression	spel表达式执行为true
@ConditionalOnJava	运行时的java版本号是否包含给定的版本号.如果包含,返回匹配,否则,返回不匹配
@ConditionalOnProperty	要求配置属性匹配条件
@ConditionalOnJndi	给定的jndi的Location 必须存在一个.否则,返回不匹配
@ConditionalOnNotWebApplication	web环境不存在时
@ConditionalOnWebApplication	web环境存在时
@ConditionalOnResource	要求制定的资源存在