Spring注解驱动-组件注册（一）

新建maven项目，加入Spring依赖。在com.atguigu.bean包下创建Person类，添加age，name两个属性。

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.12.RELEASE</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13-beta-3</version>
    <scope>test</scope>
</dependency>

1.@Configuration&@Bean给容器中注册组件

1.配置文件的做法

编写beans.xml配置文件和测试类，在配置文件中，我们将Person这个类注入到IOC容器在，在测试方法中进行获取并输出。

<?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.xsd">
    <bean id="person" class="com.atguigu.bean.Person">
        <property name="age" value="24"/>
        <property name="name" value="王劭阳"/>
    </bean>
</beans>

@Test
public void testXML() {
    // 获取Spring容器
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
    // 从Spring容器中获取person
    Person person = (Person) applicationContext.getBean("person");
    System.out.println(person);
}

2.注解的做法

编写一个配置类，通过@Configuration和@Bean注解方式注入组件。

package com.atguigu.config;

import com.atguigu.bean.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

// @Configuration注解表示当前类是一个配置类
@Configuration
public class MainConfig1 {
    // @Bean表示向容器中注册一个bean，类型就是返回值的类型，默认使用方法名作为bean的id
    // 有两种方式修改id的值，一种是修改方法名，另一种是是在@Bean上添加具体值指定
    @Bean("newPersonName")
    public Person person() {
        return new Person(24, "王劭阳");
    }
}

编写测试方法。

@Test
public void testConfigurationAndBean() {
    // 指定配置类
    AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(MainConfig1.class);
    Person person = annotationConfigApplicationContext.getBean(Person.class);
    System.out.println(person);
    String[] beanNamesForType = annotationConfigApplicationContext.getBeanNamesForType(Person.class);
    for(String type : beanNamesForType) {
        // 查看容器中Person这个bean的id
        System.out.println(type);
    }
}

2.@ComponentScan-自动扫描组件&指定扫描规则

1.配置文件的做法

在xml配置文件中，加入下面一行进行包扫描，base-package指明要扫描的路径，会扫描到@Controller、@Service、@Repository、@Component注解的类。扫描到的类就注入了Spring容器，默认情况下，bean的id值为类名首字母小写。可以使用excludeFilters或includeFilters设置过滤规则，在使用includeFilters规则的时候，需要将use-default-filters指定为false。

<context:component-scan base-package="com.atguigu"/>

2.注解的做法

在MainConfig1.java配置类上添加@ComponentScan注解，可以指定扫描的位置，还可以使用excludeFilters和includeFilters设置排除或包含规则，在使用includeFilters规则时，还需要额外将useDefaultFilters的值设置为false才能生效。

// @ComponentScan表示开启组件扫描
@ComponentScan(value = "com.atguigu",
        // 设置排除规则
        excludeFilters = {
        // 按照注解方式排除，排除@Controller注解标注的类
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {
                Controller.class
        })
})

// @ComponentScan表示开启组件扫描
@ComponentScan(value = "com.atguigu",
        // 取消默认过滤器
        useDefaultFilters = false,
        // 设置包含规则
        includeFilters = {
        // 按照注解方式包含，只包含@Controller注解标注的类
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {
                Controller.class
        })
})

在类路径下加入controller，service，dao，并带上相应注解。

@Test
public void testComponentScan() {
    // 指定配置类
    AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(MainConfig1.class);
    // 查看容器中的所有类
    String[] beanDefinitionNames = annotationConfigApplicationContext.getBeanDefinitionNames();
    for(String name : beanDefinitionNames) {
        System.out.println(name);
    }
}

在JDK8版本及以上，@ComponentScan注解上会看到一个@Repeatable注解，表示这个注解可以重复注解，通过写多个@ComponentScan指定复杂的策略。如果不是JDK8版本及以上，那么，可以通过@ComponentScans来指定多个@ComponentScan。

3.自定义TypeFilter指定过滤规则

前面的规则中只提到了FilterType.ANNOTATION，其实，还有4种：ASSIGNABLE_TYPE（按照类型）、ASPECTJ（按照ASPECTJ表达式）、REGEX（按照正则表达式）、CUSTOM（自定义）。

要想实现CUSTOM类型的FilterType，需要写一个MyTypeFilter并实现TypeFilter接口，通过match()方法的返回值判断当前类是否加入到容器中。在配置类中，指定Filter的type为FilterType.CUSTOM以及classes为MyTypeFilter.class，让自定义配置生效。

package com.atguigu.config;

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;

import java.io.IOException;

public class MyTypeFilter implements TypeFilter {
    /**
     * @param metadataReader        读取到当前正在扫描的类信息
     * @param metadataReaderFactory 读取到其他任何的类信息
     * @return 是否加入到容器中
     * @throws IOException
     */
    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=" + className);
        // 将类名中带Filter的加入到容器中
        return className.contains("Filter");
    }
}

指定扫描包中的每一个类都要经过MyTypeFilter，判断当前类是否需要放入容器。

4.@Scope-设置组件作用域

新建一个MainConfig2.java文件。

package com.atguigu.config;

import com.atguigu.bean.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

@Configuration
public class MainConfig2 {
    @Bean
    // 指定bean的scope：
    // singleton：单例（默认）：IOC容器启动的时候，将对象创建好放到IOC容器中，每次获取，都从容器中拿（饿汉式）
    // prototype：多例：IOC容器启动的时候，不去创建，而是在每次获取的时候，都会调用方法创建实例
    // request：在web环境中，每次请求创建一个实例
    // session：在web环境中，每次会话创建一个实例
    @Scope("prototype")
    public Person person() {
        System.out.println("向容器中添加Person");
        return new Person(24, "王劭阳");
    }
}

 编写测试方法，当scope是prototype的时候，person1和person2是不同的对象。

@Test
public void testScope() {
    // 指定配置类
    AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
    System.out.println("容器创建完成");
    Object person1 = annotationConfigApplicationContext.getBean("person");
    Object person2 = annotationConfigApplicationContext.getBean("person");
    System.out.println(person1 == person2);
}

5.@Lazy-bean懒加载

前面提到，在IOC容器初始化的时候，会将bean放到IOC容器中，我们可以使用@Lazy注解控制bean初始化的时机，在第一次获取bean对象时候，才做初始化。只需要添加@Lazy注解即可。

6.@Conditional-按照条件注册bean

根据操作系统的类型，注入不同的bean。编写LinuxCondition.java和WindowsCondition.java，实现Condition接口的matches()方法，根据方法返回值判断，当前bean是否加入容器中。

package com.atguigu.condition;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class LinuxCondition implements Condition {
    /**
     * @param conditionContext 上下文环境
     * @param annotatedTypeMetadata 注解原数据信息
     * @return 是否添加进容器
     */
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        // 获取beanFactory
        ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
        // 获取类加载器
        ClassLoader classLoader = conditionContext.getClassLoader();
        // 当前环境信息
        Environment environment = conditionContext.getEnvironment();
        // bean定义注册类
        BeanDefinitionRegistry registry = conditionContext.getRegistry();
        // 操作系统
        String property = environment.getProperty("os.name");
        return property.contains("linux");
    }
}

package com.atguigu.condition;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class WindowsCondition implements Condition {
    /**
     * @param conditionContext 上下文环境
     * @param annotatedTypeMetadata 注解原数据信息
     * @return 是否添加进容器
     */
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        // 获取beanFactory
        ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
        // 获取类加载器
        ClassLoader classLoader = conditionContext.getClassLoader();
        // 当前环境信息
        Environment environment = conditionContext.getEnvironment();
        // bean定义注册类
        BeanDefinitionRegistry registry = conditionContext.getRegistry();
        // 操作系统
        String property = environment.getProperty("os.name");
        return property.contains("Windows");
    }
}

 在配置类上使用@Condition注解。

@Bean
@Conditional({WindowsCondition.class})
public Person bill() {
    return new Person(100, "bill");
}
@Bean
@Conditional({LinuxCondition.class})
public Person linus() {
    return new Person(100, "linus");
}

编写测试类进行测试，当前运行环境是Windows，所以注入了name为bill的bean，如果要测试Linux下，需要在VM options里，添加"-Dos.name=linux"参数模拟Linux环境，此时，注入了name为linus的bean。通过conditionContext.getRegistry()获取到registry后，可以利用registry判断容器中bean的注册情况，也可以利用它给容器中注册bean。

@Conditional注解不仅可以添加在方法上，还可以添加在类上，当@Conditional添加在配置类上时，只有当Condition满足条件，下面的配置才会生效。

@Test
public void testConditional() {
    // 指定配置类
    AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
    ConfigurableEnvironment environment = annotationConfigApplicationContext.getEnvironment();
    String property = environment.getProperty("os.name");
    System.out.println("当前系统：" + property);
    // 根据类型获取bean的name
    String[] beanNamesForType = annotationConfigApplicationContext.getBeanNamesForType(Person.class);
    for (String name : beanNamesForType) {
        System.out.println(name);
    }
}

7.@Import-给容器中快速导入一个组件

给容器中注册组件的三种方式：

1. 自己写的类：包扫描+组件注解（@Controller、@Service、@Repository、@Component）
2. 第三方包中的组件，使用@Bean进行注册，也就是new一个对象返回
3. 使用@Import快速给容器中导入一个组件

在bean下创建一个Color类，在配置类上加上@Import(Color.class)，就可以把这个类放进容器中，id默认是全类名。@Import的括号里是数组的形式，所以可以写多个类名，表示一次需要导入多个组件。

8.@Import-使用ImportSelector

ImportSelector注解也可以快速导入类，编写MyImportSelector实现ImportSelector接口，在selectImports()方法中，将需要导入的类的全类名放到数组中返回。还需要将MyImportSelector.class加到@Import里。

9.@Import-使用ImportBeanDefinitionRegistrar

ImportBeanDefinitionRegistrar接口有一个registerBeanDefinitions()方法，可以通过beanDefinitionRegistry的注册方法手动将bean注册到容器中。创建MyImportBeanDefinitionRegistar实现ImportBeanDefinitionRegistar接口，实现registerBeanDefinitions()方法。将MyImportBeanDefinitionRegistar.class添加到@Import里。

package com.atguigu.config;

import com.atguigu.bean.Color;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    /**
     * @param annotationMetadata     当前类的注解信息
     * @param beanDefinitionRegistry BeanDefinition注册类
     * 把所有需要添加到容器中的bean，通过beanDefinitionRegistry.registerBeanDefinition()注册进来
     */
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        // 使用beanDefinitionRegistry可以判断当前容器中已经包含的类
        boolean containsBeanDefinition = beanDefinitionRegistry.containsBeanDefinition("com.atguigu.bean.Color");
        if (containsBeanDefinition) {
            // 获取bean的定义信息
            RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Color.class);
            // 调用注册方法手动注册，支持自定义bean名字
            beanDefinitionRegistry.registerBeanDefinition("ColorBean", rootBeanDefinition);
        }
    }
}

10.使用FactoryBean注册组件

通过FactoryBean生成Bean注入到容器中。编写ColorFactoryBean.java实现FactoryBean接口，实现getObject()方法，在getObject()方法里，会有一个返回值，这个返回值也被注入到容器中。

package com.atguigu.bean;

import org.springframework.beans.factory.FactoryBean;

// 创建一个工厂用于生成bean
public class ColorFactoryBean implements FactoryBean<Color> {
    // 返回一个Color对象，这个对象会添加到容器中
    public Color getObject() throws Exception {
        System.out.println("ColorFactoryBean.getObject");
        return new Color();
    }

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

    // 表示创建的Bean是否是单实例的
    public boolean isSingleton() {
        return true;
    }
}

将ColorFactoryBean注入到容器中。编写测试方法。

@Test
public void testFactoryBean() {
    // 指定配置类
    AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
    // 获取工厂Bean，实际上获取到的是工厂bean通过getObject()方法创建出来的Bean，而不是工厂bean
    Object colorFactoryBean = annotationConfigApplicationContext.getBean("com.atguigu.bean.ColorFactoryBean");
    System.out.println("工厂bean生成的bean：" + colorFactoryBean.getClass());
    // 获取工厂Bean本身，需要加一个&前缀
    Object bean = annotationConfigApplicationContext.getBean("&com.atguigu.bean.ColorFactoryBean");
    System.out.println("工厂bean本身：" + bean.getClass());
}