Spring原理解析 之组件注册

Spring容器简介

Spring IoC 容器是一个管理 Bean 的容器，在 Spring 的 定义中，它要求所有的 IoC 容器都需要实现接口 BeanFactory ，它是一个顶级容器接口 。

在现实中使用的大部分 Spring IoC 容器是 ApplicationContext 接口的实现类。

在 Spring Boot 当中主要是通过注解来装配 Bean 到 Spring IoC 容器中，AnnotationConfigApplicationContext就是一个基于注解的 IoC 容器。

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

组件注册：把Bean对象交给IOC容器管理。

• 1）、包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）[自己写的类]
• 2）、@Bean[导入的第三方包里面的组件]
• 3）、@Import[快速给容器中导入一个组件]
  　1）、@Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名
  　2）、ImportSelector：返回需要导入的组件的全类名数组；
  　3）、ImportBeanDefinitionRegistrar：手动注册bean到容器中
• 4）、使用Spring提供的 FactoryBean（工厂Bean）
  　1）、默认获取到的是工厂bean调用getObject创建的对象
  　2）、要获取工厂Bean本身，我们需要给id前面加一个&
  　　&colorFactoryBean

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

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;
@Configuration
public class MyConfig {
    @Scope("prototype")
    @Lazy
    //给容器中注册一个Bean，类型为返回值的类型，默认是用方法名作为id
    @Bean(name = "pp")
    public Person person(){
        return new Person();
    }
}
//
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class IOCTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
        Person bean = applicationContext.getBean(Person.class);
        System.out.println(bean);
    }
}

代码中用到的注解说明：

• @Configuration： 配置 相当于配置文件，告诉spring这是一个配置类
• @Scope： 调整作用域 ,可取值【singleton,prototype,request,session】
  　　-singleton：单实例(默认值):ioc容器启动会调用方法创建对象放到ioc容器中, 以后每次获取就是直接从容器中拿;
  　　-prototype：多实例,ioc容器启动并不会去调用方法创建对象放在容器中,每次获取的时候才会调用方法创建对象；
  　　-request：同一次请求创建一个实例
  　　-session：同一个session创建一个实例
• @Lazy ：是只针对单实例。
  　　单实例Bean：默认在容器启动的时候创建对象；
  　　懒加载：容器启动不创建对象，第一次使用(获取)Bean创建对象，并初始化；
• @Bean：如果不设置value的话默认是采用方法名 person为组件名

@Conditional 按照条件注册bean

按照一定的条件进行判断，满足条件给容器中注册bean，SpringBoot底层大量使用了这种条件注册注解。

创建注册条件类，编写注册逻辑：

public class LinuxCondition implements Condition {
    @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();
        //registry可以判断容器中的bean注册情况，也可以给容器中注册bean
        boolean definition = registry.containsBeanDefinition("person");
        String property = environment.getProperty("os.name");
        if (property.contains("Linux")) {
            return true;
        }
        return false;
    }
}

public class WindowsCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment environment = context.getEnvironment();
        String property = environment.getProperty("os.name");
        if (property.contains("Windows")) {
            return true;
        }
        return false;
    }
}

// 类中组件统一设置。满足当前条件，这个类中配置的所有bean注册才能生效
// @Conditional({LinuxCondition.class})
@Configuration
public class SpringConfig {

    @Conditional({WindowsCondition.class})
    @Bean
    public User windows() {
        return new User("windows");
    }

    @Conditional({LinuxCondition.class})
    @Bean
    public User linux() {
        return new User("linux");
    }
}

@ComponentScan 自动扫描组件

包扫描注解@ComponentScan，参数如下：

• value：指定要扫描的包
• excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件
• includeFilters = Filter[] ：指定扫描的时候只需要包含哪些组件
  　FilterType.ANNOTATION：按照注解
  　FilterType.ASSIGNABLE_TYPE：按照给定的类型；
  　FilterType.ASPECTJ：使用ASPECTJ表达式
  　FilterType.REGEX：使用正则指定
  　FilterType.CUSTOM：使用自定义规则

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Service;

@Configuration
// 扫描 com.demo.spring 包，排除@Service、@Controller注解的类
@ComponentScan(value = "com.demo.spring", excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Service.class, Controller.class})
})
public class SpringConfig {
}
/
public class IOCTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        String[] names = context.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}
/
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;

@Configuration
// 扫描 com.demo.spring 包，只包含@Controller注解的类，useDefaultFilters参数必须设置false，includeFilters才能生效
@ComponentScan(value = "com.demo.spring", includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class})
},
        useDefaultFilters = false)
public class SpringConfig {
}

FilterType.CUSTOM，使用自定义规则案例：
自定义排除规则，实现 TypeFilter 接口：

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 {
    /**
     * metadataReader：读取到的当前正在扫描的类的信息
     * metadataReaderFactory:可以获取到其他任何类信息的
     */
    @Override
    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);
        // 这里表示类名包含 Controller 被排除
        if (className.contains("Controller")) {
            return true;
        }
        return false;
    }
}

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;

@Configuration
// 扫描 com.demo.spring 包，自定义排除过滤规则
@ComponentScan(value = "com.demo.spring", excludeFilters = {
        @ComponentScan.Filter(type = FilterType.CUSTOM, classes = {MyTypeFilter.class})
})
public class SpringConfig {
}

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

@Import其实是导入Bean定义到BeanDefinitionMap中。

@Import 使用 class 导入

public class Color{}
public class Red{}
上面两个简单的类
---------------------------
@Configuration
@Import({Color.class,Red.class})
//@Import导入组件，id默认是组件的全类名
public class MainConfig2 {
}

@Import 使用 ImportSelector 全类路径名

可以批量导入Bean定义到BeanDefinitionMap中。

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

// 自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {
    // 返回值，就是到导入到容器中的组件全类名
    // AnnotationMetadata：当前标注@Import注解的类的所有注解信息
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.demo.spring.User"};
    }
}
///
@Configuration
// @Import导入组件，id默认是组件的全类名
@Import(value = {HelloController.class, HelloService.class, MyImportSelector.class})
public class SpringConfig {
}

@Import 使用 ImportBeanDefinitionRegistrar 导入

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 {

	/**
	 * AnnotationMetadata：当前类的注解信息
	 * BeanDefinitionRegistry:BeanDefinition注册类；
	 * 		把所有需要添加到容器中的bean；调用
	 * 		BeanDefinitionRegistry.registerBeanDefinition手工注册进来
	 */
	@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		
		boolean definition = registry.containsBeanDefinition("com.atguigu.bean.Red");
		boolean definition2 = registry.containsBeanDefinition("com.atguigu.bean.Blue");
		if(definition && definition2){
			//指定Bean定义信息；（Bean的类型，Bean。。。）
			RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
			//注册一个Bean，指定bean名
			registry.registerBeanDefinition("rainBow", beanDefinition);
		}
	}
}
//
@Import({Color.class,Red.class,MyImportSelector.class,MyImportBeanDefinitionRegistrar.class})

导入ImportSelect的实现类

ImportSelector 接口：返回需要导入的组件的全类名数组。

public interface ImportSelector {
    /**
     * 返回值，就是到导入到容器中的组件全类名
     * AnnotationMetadata:当前标注@Import注解的类的所有注解信息
     */
    String[] selectImports(AnnotationMetadata importingClassMetadata);
}

自定义实现类：

//自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {
    //返回值，就是到导入到容器中的组件全类名
    //AnnotationMetadata:当前标注@Import注解的类的所有注解信息
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        // TODO Auto-generated method stub
        //importingClassMetadata
        //方法不要返回null值
        return new String[]{"com.athome.bean.Blue","com.athome.bean.Yellow"};
    }
}

使用@Import来导入：

@Configuration
@Import({MyImportSelector .class})
public class MyConfing {
}

导入ImportBeandeinitionRegistrart

ImportBeandeinitionRegistrart接口：手动注册bean到容器中。

public interface ImportBeanDefinitionRegistrar {
    /**
     * AnnotationMetadata：当前类的注解信息
     * BeanDefinitionRegistry:BeanDefinition注册类；
     * 把所有需要添加到容器中的bean；调用
     * BeanDefinitionRegistry.registerBeanDefinition手工注册进来*/
    public void registerBeanDefinitions(
            AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);
}

自定义实现类：

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {        
        boolean definition = registry.containsBeanDefinition("com.athome.bean.Red");
        boolean definition2 = registry.containsBeanDefinition("com.athome.bean.Blue");
        if(definition && definition2){
            //指定Bean定义信息；（Bean的类型，Bean。。。）
            RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
            //注册一个Bean，指定bean名
            registry.registerBeanDefinition("rainBow", beanDefinition);
        }
    }
}

使用@Import来导入：

@Configuration
@Import({MyImportBeanDefinitionRegistrar .class})
public class MyConfing {
}

ImportSelector、ImportBeanDefinitionRegistrar 区别

ImportSelector接口作用将方法返回的字符串数组作为bean注入到容器中。
ImportBeanDefinitionRegistrar这个接口作用是，用户可以实现了之后来自定义来注册需要注册的bean。可以设置自定义的BeanNameGeneratorbean名称生成规则。

@EnableXXX与@Import的使用

创建几个动物的实体类：Cat，Dog，Rabbit，Duck。

新建 @EnableAnimal 注解：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface EnableAnimal {
}

@Import 可以导入配置类、ImportSelector 的实现类、ImportBeanDefinitionRegistrar 的实现类、普通类。

导入普通类

直接在 @Import 注解中标注Cat类：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(Cat.class)
public @interface EnableAnimal {
}

启动类标注 @EnableAnimal ，引导启动IOC容器：

@EnableAnimal
@Configuration
public class AnimalConfiguration {
}

public class App {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(AnimalConfiguration.class);
        String[] beanDefinitionNames = ctx.getBeanDefinitionNames();
        Stream.of(beanDefinitionNames).forEach(System.out::println);
    }
}

控制台打印：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
animalConfiguration
com.example.Cat

导入配置类

新建 AnimalRegistrarConfiguration，并标注 @Configuration ：

@Configuration
public class AnimalRegistrarConfiguration {

    @Bean
    public Dog dog(){
        return new Dog();
    }
}

在 @EnableAnimal 的 @Import 注解中加入 AnimalRegistrarConfiguration ：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import({Cat.class, AnimalConfiguration.class})
public @interface EnableAnimal {
}

启动IOC容器，打印结果：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
animalConfiguration
com.example.Cat
com.example.AnimalRegistrarConfiguration
dog

配置类 AnimalRegistrarConfiguration和 Dog 都已注册到IOC容器中。

导入ImportSelector

新建 AnimalImportSelector，实现 ImportSelector 接口：

public class AnimalImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[] {Rabbit.class.getName(), Duck.class.getName()};
    }
}

在 @EnableAnimal 的 @Import 注解中加入 AnimalImportSelector ：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import({Cat.class, AnimalRegistrarConfiguration.class, AnimalImportSelector.class})
public @interface EnableAnimal {
}

启动IOC容器，打印结果：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
animalConfiguration
com.example.Cat
com.example.AnimalRegistrarConfiguration
dog
com.example.Rabbit
com.example.Duck

AnimalImportSelector 没有注册到IOC容器中，Rabbit、Duck 被注册。

导入ImportBeanDefinitionRegistrar

新建 AnimalImportBeanDefinitionRegistrar，实现 ImportBeanDefinitionRegistrar 接口：

public class AnimalImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        registry.registerBeanDefinition("tiger", new RootBeanDefinition(Tiger.class));
    }
}

在 @EnableAnimal 的 @Import 注解中加入 AnimalImportBeanDefinitionRegistrar：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import({Cat.class, AnimalRegistrarConfiguration.class, AnimalImportSelector.class, AnimalImportBeanDefinitionRegistrar.class})
public @interface EnableAnimal {
}

启动IOC容器，打印结果：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
animalConfiguration
com.example.Cat
com.example.AnimalRegistrarConfiguration
dog
com.example.Rabbit
com.example.Duck
tiger

tiger 被注册到 IOC 容器。