基于注解的spring开发之组件注册

@Configuration注解这个相当于配置文件，即告诉spring这个一个配置类。
@Bean
给容器注册一个Bean;类型为返回值的类型，id默认是用方法名作为id.

@Configuration
public class MainConfig {
    @Bean
    public Person per(){
        return new Person("李四",22 );
    }
}

这个基本就相当于以前采用的xml配置文件如下：

<bean id="per" class="com.learn.entity.Person">
     <property name="name" value="李四" />
     <property name="age" value="22"/>
</bean>

@ComponentScan
自动包扫描注解
value:指定要扫描的包
excludeFilters=Filter[] 指定扫描的时候按照什么规则排除哪些组件。
includeFilters=Filter[] 指定扫描的时候只需要包含哪些组件。（注意的是包扫描默认的是扫描所有的，也就是use-default-filters=”true”，所以需要设置为false。这个和配置文件一样）
- FilterType.ANNOTATION ：按照注解的方式
- FilterType.ASSIGNABLE_TYPE：按照给定的类型
- FilterType.CUSTOM：使用自定义规则。使用这个需要是TypeFilter的实现类
  FilterType.CUSTOM使用案例如下：

public class MyFilterCustom implements TypeFilter {
    /**
     * metadataReader 读取到的当前正在扫描的类的信息
     * metadataReaderFactory 可以获取到其它任何类的信息
     */
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
            throws IOException {
        //获取当前类注解的信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        //获取当前正在扫描的类的信息
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        //获取当前类资源（类路径）
        Resource resource = metadataReader.getResource();
        String className = classMetadata.getClassName();
        System.out.println("当前扫描的类的信息"+className);
        if(className.contains("Controller")){
            return true;
        }
        return false;
    }
}

@Configuration
@ComponentScans(value={
        @ComponentScan(value="com.learn",
                includeFilters={
                        @Filter(type=FilterType.CUSTOM,classes={MyFilterCustom.class})
                        },useDefaultFilters=false)
})
public class MainConfig {
    @Bean
    public Person per(){
        return new Person("李四",22 );
    }
}

FilterType.ASPECTJ：使用ASPECTJ表达式（基本用不到）
FilterType.REGEX ：使用正则表达式

@Configuration
@ComponentScan(value="com.learn",
includeFilters={
       @Filter(type=FilterType.ANNOTATION,
               classes={Controller.class}
               )},useDefaultFilters=false)
public class MainConfig {
   @Bean
   public Person per(){
       return new Person("李四",22 );
   }
}

@ComponentScans 这个就是多个scan的几个集合，也就是可以定义多个规则。如果是jdk1.8以后的，本身也是可以多些几次scan。不用scans也可以

@Configuration
@ComponentScans(value={
        @ComponentScan(value="com.learn",
                includeFilters={
                        @Filter(type=FilterType.ANNOTATION,
                                classes={Controller.class}
                                )},useDefaultFilters=false)
})
public class MainConfig {
    @Bean
    public Person per(){
        return new Person("李四",22 );
    }
}

@Scope 作用范围
- prototype 多实例的备注：IOC容器启动并不会去调用方法创建对象放在容器中，而是在每次获取的时候才会调用方法创建对象，且每次创建的都是一个新的，即多实例。
- singleton 单实例的（默认值）备注：默认在单实例的情况下，IOC容器启动的时候会调用方法创建对象，放入iOC容器中。以后每次获取就是从容器中拿，即对象都是一个。
- request 同一次请求创建一个实例（web环境中才能用到，且基本不用）
- session 同一个session创建一个实例（web环境中才能用到，且基本不用）

默认单例的情况:

@Configuration
public class MainConfig2 {
    @Bean
    public Person person(){
        return new Person("张三", 28);
    }
}

使用多例的情况:

@Configuration
public class MainConfig2 {
    @Bean
    @Scope("prototype")  //多例
    public Person person(){
        return new Person("张三", 28);
    }
}

@Lazy 懒加载，针对单实例的bean
懒加载：容器启动不创建对象。第一次使用（获取bean）创建的对象，并初始化。

@Configuration
public class MainConfig2 {
    @Bean
    @Lazy
    public Person person(){
        System.out.println("调用了person方法");
        return new Person("张三", 28);
    }
}

@Conditional 按照一定的条件进行判断，满足条件给容器中注册bean。

@Configuration
public class MainConfig2 {

    @Bean("win")
    @Conditional(WindowConditional.class)
    public Person person1(){
        return new Person("Windows", 70);
    }
    @Bean("Lin")
    @Conditional(LinuxConditional.class)
    public Person person2(){
        return new Person("Linux", 80);
    }
}