[email protected]註解 這個相當於配置檔案，即告訴spring這個一個配置類。

[email protected]
給容器註冊一個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>

[email protected]
自動包掃描註解
value:指定要掃描的包
excludeFilters=Filter[] 指定掃描的時候按照什麼規則排除哪些元件。
includeFilters=Filter[] 指定掃描的時候只需要包含哪些元件。（注意的是包掃描預設的是掃描所有的，也就是use-default-filters=”true”，所以需要設定為false。 這個和配置檔案一樣）
FilterType.ANNOTATION ：按照註解的方式
FilterType.ASSIGNABLE_TYPE：按照給定的型別
FilterType.CUSTOM：使用自定義規則。 使用這個需要是TypeFilter的實現類
FilterType.CUSTOM使用 案例如下：

package com.learn.config;

import java.io.IOException;

import org.springframework.core.io.Resource;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import
 
 org.springframework.core.type.filter.TypeFilter;

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 );
    }
}

這個也基本相當於配置檔案:

<context:component-scan base-package="com.learn" use-default-filters="false">
     <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan> 

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

[email protected] 這個就是多個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 );
    }
}

[email protected] 作用範圍

• prototype 多例項的 備註：IOC容器啟動並不會去呼叫方法建立物件放在容器中，而是在每次獲取的時候才會呼叫方法建立物件，且每次建立的都是一個新的，即多例項。
• singleton 單例項的（預設值） 備註：預設在單例項的情況下，IOC容器啟動的時候會呼叫方法建立物件，放入iOC容器中。 以後每次獲取就是從容器中拿，即物件都是一個。
• request 同一次請求建立一個例項（web環境中才能用到，且基本不用）
• session 同一個session建立一個例項（web環境中才能用到，且基本不用）

預設單列的情況:

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

ApplicationContext context = new AnnotationConfigApplicationContext(MainConfig2.class);
        String[] beanDefinitionNames = context.getBeanDefinitionNames();

        for(String beanName:beanDefinitionNames){
            System.out.println("當前bean的名稱:"+beanName);
        }
        System.out.println("一共有"+context.getBeanDefinitionCount()+"個bean被定於了");
        Object obj1=context.getBean("person");
        Object obj2=context.getBean("person");
        System.out.println("obj1,obj2:"+(obj1==obj2));

使用多例的情況:

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

[email protected] 懶載入，針對單例項的bean
懶載入：容器啟動不建立物件。第一次使用（獲取bean）建立的物件，並初始化。

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

ApplicationContext context = new AnnotationConfigApplicationContext(MainConfig2.class);
        String[] beanDefinitionNames = context.getBeanDefinitionNames();

        for(String beanName:beanDefinitionNames){
            System.out.println("當前bean的名稱:"+beanName);
        }
        System.out.println("一共有"+context.getBeanDefinitionCount()+"個bean被定於了");

        System.out.println("-------IOC容器初始化完成，開始呼叫bean----");
        Object obj1=context.getBean("person");
        Object obj2=context.getBean("person");
        System.out.println("obj1,obj2:"+(obj1==obj2));

[email protected] 按照一定的條件進行判斷，滿足條件給容器中註冊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);
    }

}

/***
 * 是否是linux環境
 * @author SpringLi
 *
 */
public class LinuxConditional implements Condition{
    /**
     * ConditionContext  判斷條件能使用的上下文
     * AnnotatedTypeMetadata 註釋資訊
     */
    public boolean matches(ConditionContext context,
            AnnotatedTypeMetadata metadata) {
        //能獲取到IOC使用的beanFactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //獲取類載入器
        ResourceLoader resourceLoader = context.getResourceLoader();
        //獲取當前環境資訊
        Environment environment = context.getEnvironment();
        //獲取bean定義的註冊類
        BeanDefinitionRegistry registry = context.getRegistry();
        String property = environment.getProperty("os.name");
        if(property.contains("Linux")){
            return true;
        }
        return false;
    }
}

public class WindowConditional implements Condition{
    /**
     * ConditionContext  判斷條件能使用的上下文
     * AnnotatedTypeMetadata 註釋資訊
     */
    public boolean matches(ConditionContext context,
            AnnotatedTypeMetadata metadata) {
        //能獲取到IOC使用的beanFactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //獲取類載入器
        ResourceLoader resourceLoader = context.getResourceLoader();
        //獲取當前環境資訊
        Environment environment = context.getEnvironment();
        //獲取bean定義的註冊類
        BeanDefinitionRegistry registry = context.getRegistry();
        String property = environment.getProperty("os.name");
        if(property.contains("Window")){
            return true;
        }
        return false;
    }
}

ApplicationContext context = new AnnotationConfigApplicationContext(MainConfig2.class);
        String[] beanDefinitionNames = context.getBeanDefinitionNames();

        for(String beanName:beanDefinitionNames){
            System.out.println("當前bean的名稱:"+beanName);
        }
        System.out.println("一共有"+context.getBeanDefinitionCount()+"個bean被定於了");