2、@ComponentScan

includeFilters：指定在扫描的时候，需要包含哪些组件。

excludeFilters：定在扫描的时候，需要排除哪些组件。

@Configuration
//批量定义多个扫描规则
@ComponentScans(value = {
       @ComponentScan(value = "com.zender", excludeFilters = {
                /**
                 * 这里面是一个@Filter注解数组。
                 * FilterType.ANNOTATION表示的排除的规则:按照注解的方式来进行排除.
                 * 排除规则有：
                 *      FilterType.ANNOTATION：按照注解
                 *      FilterType.ASSIGNABLE_TYPE：按照给定的类型
                 *      FilterType.ASPECTJ：使用ASPECTJ表达式
                 *      FilterType.REGEX：使用正则表达式
                 *      FilterType.CUSTOM：自定义
                 * classes = {Controller.class,Service.class}表示的是标有这些注解的类给排除掉
                 */
                @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Service.class})
        }),
        @ComponentScan(value = "com.zender", includeFilters = {
             	//自定义包扫描，classes中的类必须要实现TypeFilter接口。
                @ComponentScan.Filter(type = FilterType.CUSTOM, classes = MyTypeFilter.class)
        }),
})
public class MainConfig {
    @Bean
    public Person initPerson(){
        Person person = new Person();
        person.setName("张三");
        person.setAge(18);
        return person;
    }
}

3、@Scope

ConfigurableBeanFactory#SCOPE_PROTOTYPE prototype //多实例的 创建时机：调用getBean()获取的时候去创建bean的实例。
ConfigurableBeanFactory#SCOPE_SINGLETON singleton //单实例的 创建时机：IOC容器在启动的时候，就会将容器中所有作用域为单例的bean的实例给创建出来。
// web环境
org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST //同一次请求创建一个实例
org.springframework.web.context.WebApplicationContext#SCOPE_SESSION //同一个session创建的一个实例

4、@Lazy

5、@Conditional

按照条件类动态注册bean。可以写在类上，方法上。

/**
 * 判断是否是Linux系统
 **/
public class LinuxConditional implements Condition {
    /**
     * @param context  判断条件所使用的上线下文环境
     * @param metadata 注释信息
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //1.能获取到IOC容器里面的BeanFactory
        //ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //2.获取类加载器
        //ClassLoader classLoader = context.getClassLoader();
        //3.能获取当前环境的信息
        Environment environment = context.getEnvironment();
        //4.获取到bean定义的注册类
        BeanDefinitionRegistry registry = context.getRegistry();
        //获取操作系统
        String property = environment.getProperty("os.name");
        if (property.contains("linux")) {
            return true;
        }
        return false;
    }
}

//根据条件类返回值来是否加载bean
@Conditional({WindowsConditional.class})
@Bean("zhangsan")
public Person getPerson(){
    Person person = new Person();
    person.setName("张三");
    person.setAge(20);
    return person;
}

//根据条件类返回值来是否加载bean
@Conditional({LinuxConditional.class})
@Bean("lisi")
public Person getPerson2(){
    Person person = new Person();
    person.setName("李四");
    person.setAge(18);
    return person;
}

6、@Import

/**
 * 自定义逻辑返回需要导入的组件
 **/
public class MyImportSelector implements ImportSelector{
    /**
     * importingClassMetadata 当前标注@Import注解的类的所有的注解信息。
     * @return                返回需要的组件的全类名的数组。
     * 返回null会报空指针异常。
     */
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[0];
    }
}

使用ImportBeanDefinitionRegistrar接口注册组件 。

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    /**
     * AnnotationMetadata 当前类的注解信息
     * BeanDefinitionRegistry BeanDefinition注册类
     * 我们把所有需要添加到容器中的bean通过BeanDefinitionRegistry里面的registerBeanDefinition方法来手动的进行注册
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //判断IOC容器里面是否含有这两个组件
        boolean definition = registry.containsBeanDefinition("com.ldc.bean.Red");
        boolean definition2 = registry.containsBeanDefinition("com.ldc.bean.Blue");
        //如果有的话，我就把RainBow的bean的实例给注册到IOC容器中
        if (definition && definition2) {
            //指定bean的定义信息，参数里面指定要注册的bean的类型：RainBow.class
            RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(RainBow.class);
            //注册一个bean，并且指定bean名
            registry.registerBeanDefinition("rainBow", rootBeanDefinition );
        }
    }
}

还有一种注册组件方法，实现FactoryBean接口。

//创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {

    //返回一个Color对象，这个对象会添加到容器中
    @Override
    public Color getObject() throws Exception {
        System.out.println("ColorFactoryBean...getBean...");
        return new Color();
    }

    //返回的类型
    @Override
    public Class<?> getObjectType() {
        return Color.class;
    }

    //控制是否为单例
    // true：表示的就是一个单实例，在容器中保存一份
    // false:多实例，每次获取都会创建一个新的bean
    @Override
    public boolean isSingleton() {
        return true;
    }
}

7、@Autowired、@Component、@Repository、@Service、@Controller