深入学习Spring组件注册

接触过Spring的同学肯定都听过IOC。在传统的Java编程中，当需要用到某个对象的时候，我们都是主动显式创建一个对象实例（new）。使用Spring后就不需要这样做了，因为Spring会帮我们在需要用到某些对象的地方自动注入该对象，而无须我们自己去创建。这种模式俗称控制反转，即IOC（Inversion of Control）。那么Spring是从什么地方获取到我们所需要的对象呢？其实Spring给我们提供了一个IOC容器，里面管理着所有我们需要的对象，组件注册就是我们去告诉Spring哪些类需要交给IOC容器管理。

这里主要记录组件注册的一些细节。

通过@Bean注册组件

在较早版本的Spring中，我们都是通过XML的方式来往IOC容器中注册组件的，下面这段代码大家肯定不会陌生：

//返回IOC容器，基于XML配置，传入配置文件的位置ApplicationContextapplicationContext=newClassPathXmlApplicationContext("xxx.xml");Useruser=(User)applicationContext.getBean("user");

Spring 4后推荐我们使用Java Config的方式来注册组件。

为了演示，我们搭建一个简单Spring Boot应用，然后引入Lombok依赖（编辑器也需要安装Lombok插件），然后创建一个User类：

@ToString@AllArgsConstructor@DatapublicclassUser{privateStringname;privateIntegerage;}

接着创建一个配置类，在里面通过@Bean注解注册User类：

@ConfigurationpublicclassWebConfig{@Bean()publicUseruser(){returnnewUser("ycf",18);}}

通过@Bean注解，我们向IOC容器注册了一个名称为user（Bean名称默认为方法名，我们也可以通过@Bean("myUser")方式来将组件名称指定为myUser）。

组件注册完毕后，我们测试一下从IOC容器中获取这个组件。在Spring Boot入口类中编写如下代码：

@SpringBootApplicationpublicclassDemoApplication{publicstaticvoidmain(String[]args){SpringApplication.run(DemoApplication.class,args);//返回IOC容器，使用注解配置，传入配置类ApplicationContextcontext=newAnnotationConfigApplicationContext(WebConfig.class);Useruser=context.getBean(User.class);System.out.println(user);}}

因为我们是通过注解方式来注册组件的，所以需要使用AnnotationConfigApplicationContext来获取相应的IOC容器，入参为配置类。

启动项目，看下控制台输出：

User(name=ycf,age=18)

说明组件注册成功。

我们将组件的名称改为myUser，然后看看IOC容器中，User类型组件是否叫myUser：

@SpringBootApplicationpublicclassDemoApplication{publicstaticvoidmain(String[]args){SpringApplication.run(DemoApplication.class,args);ApplicationContextcontext=newAnnotationConfigApplicationContext(WebConfig.class);//查看User这个类在Spring容器中叫啥玩意String[]beanNames=context.getBeanNamesForType(User.class);Arrays.stream(beanNames).forEach(System.out::println);}}//输出myUser

使用@ComponentScan扫描

在使用XML配置组件扫描的时候，我们都是这样配置的：

<context:component-scanbase-package=""></context:component-scan>

其中base-package指定了扫描的路径。路径下所有被@Controller、@Service、@Repository和@Component注解标注的类都会被纳入IOC容器中。

现在我们脱离XML配置后，可以使用@ComponentScan注解来扫描组件并注册。

在使用@ComponentScan扫描之前，我们先创建一个Controller，Service，Dao，并标注上相应的注解。

然后修改配置类：

@Configuration@ComponentScan("cn.ycf.demo")publicclassWebConfig{//@Bean("myUser")//publicUseruser(){//returnnewUser("mrbird",18);//}}

在配置类中，我们通过@ComponentScan("cn.ycf.demo")配置了扫描路径，并且将User组件注册注释掉了，取而代之的是在User类上加上@Component注解：

@ToString@AllArgsConstructor@NoArgsConstructor@Data@ComponentpublicclassUser{privateStringname;privateIntegerage;}

值得注意的是，我们不能将Spring Boot的入口类纳入扫描范围中，否则项目启动将出错。

接下来我们看下在基于注解的IOC容器中是否包含了这些组件：

@SpringBootApplicationpublicclassDemoApplication{publicstaticvoidmain(String[]args){SpringApplication.run(DemoApplication.class,args);ApplicationContextcontext=newAnnotationConfigApplicationContext(WebConfig.class);//查看基于注解的IOC容器中所有组件名称String[]beanNames=context.getBeanDefinitionNames();Arrays.stream(beanNames).forEach(System.out::println);}}//输出//webConfig//userController//userMapper//user//userService

可见，组件已经成功被扫描进去了，并且名称默认为类名首字母小写。

这里，配置类WebConfig也被扫描并注册了，查看@Configuration源码就会发现原因：

@ToString@AllArgsConstructor@DatapublicclassUser{privateStringname;privateIntegerage;}0

指定扫描策略

@ComponentScan注解允许我们指定扫描策略，即指定哪些被扫描，哪些不被扫描，查看其源码可发现这两个属性：

@ToString@AllArgsConstructor@DatapublicclassUser{privateStringname;privateIntegerage;}1

其中Filter也是一个注解:

@ToString@AllArgsConstructor@DatapublicclassUser{privateStringname;privateIntegerage;}2

接下来我们使用excludeFilters来排除一些组件的扫描：

@ToString@AllArgsConstructor@DatapublicclassUser{privateStringname;privateIntegerage;}3

上面我们指定了两种排除扫描的规则：

根据注解来排除（type = FilterType.ANNOTATION）,这些注解的类型为classes = {Controller.class, Repository.class}。即Controller和Repository注解标注的类不再被纳入到IOC容器中。

根据指定类型类排除（type = FilterType.ASSIGNABLE_TYPE），排除类型为User.class，其子类，实现类都会被排除。

启动项目，观察控制台：

@ToString@AllArgsConstructor@DatapublicclassUser{privateStringname;privateIntegerage;}4

可见排除成功。

除了上面两种常用的规则外，我们还可以使用别的规则，查看FilterType源码：

@ToString@AllArgsConstructor@DatapublicclassUser{privateStringname;privateIntegerage;}5

可看到，我们还可以通过ASPECTJ表达式，REGEX正则表达式和CUSTOM自定义规则（下面详细介绍）来指定扫描策略。

includeFilters的作用和excludeFilters相反，其指定的是哪些组件需要被扫描：

@ToString@AllArgsConstructor@DatapublicclassUser{privateStringname;privateIntegerage;}6

上面配置了只将Service纳入IOC容器，并且需要用useDefaultFilters = false来关闭Spring默认的扫描策略才能让我们的配置生效（Spring Boot入口@SpringBootApplication注解包含的默认的扫描策略）。

多扫描策略配置

在Java 8之前，我们可以使用@ComponentScans来配置多个@ComponentScan以实现多扫描规则配置：

而在Java 8中，新增了@Repeatable注解，使用该注解修饰的注解可以重复使用，查看@ComponentScan源码会发现其已经被该注解标注：

所以除了使用@ComponentScans来配置多扫描规则外，我们还可以通过多次使用@ComponentScan来指定多个不同的扫描规则。

自定义扫描策略

自定义扫描策略需要我们实现org.springframework.core.type.filter.TypeFilter接口，创建MyTypeFilter实现该接口：

@ToString@AllArgsConstructor@DatapublicclassUser{privateStringname;privateIntegerage;}7

该接口包含match方法，其两个入参MetadataReader和MetadataReaderFactory含义如下：

MetadataReader：当前正在扫描的类的信息；

MetadataReaderFactory：可以通过它来获取其他类的信息。

当match方法返回true时说明匹配成功，false则说明匹配失败。继续完善这个过滤规则：

@ToString@AllArgsConstructor@DatapublicclassUser{privateStringname;privateIntegerage;}8

上面指定了当被扫描的类名包含er时候，匹配成功，配合excludeFilters使用意指当被扫描的类名包含er时，该类不被纳入IOC容器中。

我们在@ComponentScan中使用这个自定义的过滤策略：

@ToString@AllArgsConstructor@DatapublicclassUser{privateStringname;privateIntegerage;}9

因为User，UserMapper，UserService和UserController等类的类名都包含er，所以它们都没有被纳入到IOC容器中。

组件作用域@Scope

默认情况下，在Spring的IOC容器中每个组件都是单例的，即无论在任何地方注入多少次，这些对象都是同一个，我们来看下例子。

首先将User对象中的@Component注解去除，然后在配置类中配置User Bean：

@ConfigurationpublicclassWebConfig{@Bean()publicUseruser(){returnnewUser("ycf",18);}}0

接着多次从IOC容器中获取这个组件，看看是否为同一个：

@ConfigurationpublicclassWebConfig{@Bean()publicUseruser(){returnnewUser("ycf",18);}}1

在Spring中我们可以使用@Scope注解来改变组件的作用域：

singleton：单实例（默认）,在Spring IOC容器启动的时候会调用方法创建对象然后纳入到IOC容器中，以后每次获取都是直接从IOC容器中获取（map.get()）；

prototype：多实例，IOC容器启动的时候并不会去创建对象，而是在每次获取的时候才会去调用方法创建对象；

request：一个请求对应一个实例；

session：同一个session对应一个实例。

懒加载@Lazy

懒加载是针对单例模式而言的，正如前面所说，IOC容器中的组件默认是单例的，容器启动的时候会调用方法创建对象然后纳入到IOC容器中。

在User Bean注册的地方加入一句话以观察：

@ConfigurationpublicclassWebConfig{@Bean()publicUseruser(){returnnewUser("ycf",18);}}2

测试：

@ConfigurationpublicclassWebConfig{@Bean()publicUseruser(){returnnewUser("ycf",18);}}3

将User Bean改为懒加载的方式：

@ConfigurationpublicclassWebConfig{@Bean()publicUseruser(){returnnewUser("ycf",18);}}4

可看到，容器创建完的时候，User Bean这个组件并未添加到容器中。

所以懒加载的功能是，在单例模式中，IOC容器创建的时候不会马上去调用方法创建对象并注册，只有当组件第一次被使用的时候才会调用方法创建对象并加入到容器中。

测试一下：

@ConfigurationpublicclassWebConfig{@Bean()publicUseruser(){returnnewUser("ycf",18);}}5

结果证实了我们的观点。

条件注册组件

@Conditional

使用@Conditional注解我们可以指定组件注册的条件，即满足特定条件才将组件纳入到IOC容器中。

在使用该注解之前，我们需要创建一个类，实现Condition接口：

@ConfigurationpublicclassWebConfig{@Bean()publicUseruser(){returnnewUser("ycf",18);}}6

该接口包含一个matches方法，包含两个入参:

ConditionContext：上下文信息；

AnnotatedTypeMetadata：注解信息。

简单完善一下这个实现类:

@ConfigurationpublicclassWebConfig{@Bean()publicUseruser(){returnnewUser("ycf",18);}}7

接着将这个条件添加到User Bean注册的地方：

@ConfigurationpublicclassWebConfig{@Bean()publicUseruser(){returnnewUser("ycf",18);}}8

在Windows环境下，User这个组件将被成功注册，如果是别的操作系统，这个组件将不会被注册到IOC容器中。

@Profile

@Profile可以根据不同的环境变量来注册不同的组件，下面我们来学一下它的用法。

导入组件

@Import

到目前为止，我们可以使用包扫描和@Bean来实现组件注册。除此之外，我们还可以使用@Import来快速地往IOC容器中添加组件。

创建一个新的类Hello：

@ConfigurationpublicclassWebConfig{@Bean()publicUseruser(){returnnewUser("ycf",18);}}9

然后在配置类中导入这个组件：

@SpringBootApplicationpublicclassDemoApplication{publicstaticvoidmain(String[]args){SpringApplication.run(DemoApplication.class,args);//返回IOC容器，使用注解配置，传入配置类ApplicationContextcontext=newAnnotationConfigApplicationContext(WebConfig.class);Useruser=context.getBean(User.class);System.out.println(user);}}0

查看IOC容器中所有组件的名称：

@SpringBootApplicationpublicclassDemoApplication{publicstaticvoidmain(String[]args){SpringApplication.run(DemoApplication.class,args);//返回IOC容器，使用注解配置，传入配置类ApplicationContextcontext=newAnnotationConfigApplicationContext(WebConfig.class);Useruser=context.getBean(User.class);System.out.println(user);}}1

可看到，通过@Import我们可以快速地往IOC容器中添加组件，Id默认为全类名。

ImportSelector

通过@Import我们已经实现了组件的导入，如果需要一次性导入较多组件，我们可以使用ImportSelector来实现。

新增三个类Apple，Banana和Watermelon，代码略。

查看ImportSelector源码：

@SpringBootApplicationpublicclassDemoApplication{publicstaticvoidmain(String[]args){SpringApplication.run(DemoApplication.class,args);//返回IOC容器，使用注解配置，传入配置类ApplicationContextcontext=newAnnotationConfigApplicationContext(WebConfig.class);Useruser=context.getBean(User.class);System.out.println(user);}}2

ImportSelector是一个接口，包含一个selectImports方法，方法返回类的全类名数组（即需要导入到IOC容器中组件的全类名数组），包含一个AnnotationMetadata类型入参，通过这个参数我们可以获取到使用ImportSelector的类的全部注解信息。

我们新建一个ImportSelector实现类MyImportSelector：

@SpringBootApplicationpublicclassDemoApplication{publicstaticvoidmain(String[]args){SpringApplication.run(DemoApplication.class,args);//返回IOC容器，使用注解配置，传入配置类ApplicationContextcontext=newAnnotationConfigApplicationContext(WebConfig.class);Useruser=context.getBean(User.class);System.out.println(user);}}3

上面方法返回了新增的三个类的全类名数组，接着我们在配置类的@Import注解上使用MyImportSelector来把这三个组件快速地导入到IOC容器中：

@SpringBootApplicationpublicclassDemoApplication{publicstaticvoidmain(String[]args){SpringApplication.run(DemoApplication.class,args);//返回IOC容器，使用注解配置，传入配置类ApplicationContextcontext=newAnnotationConfigApplicationContext(WebConfig.class);Useruser=context.getBean(User.class);System.out.println(user);}}4

查看容器中是否已经有这三个组件:

@SpringBootApplicationpublicclassDemoApplication{publicstaticvoidmain(String[]args){SpringApplication.run(DemoApplication.class,args);//返回IOC容器，使用注解配置，传入配置类ApplicationContextcontext=newAnnotationConfigApplicationContext(WebConfig.class);Useruser=context.getBean(User.class);System.out.println(user);}}5

组件已经成功导入。

ImportBeanDefinitionRegistrar

除了上面两种往IOC容器导入组件的方法外，我们还可以使用ImportBeanDefinitionRegistrar来手动往IOC容器导入组件。

查看其源码：

@SpringBootApplicationpublicclassDemoApplication{publicstaticvoidmain(String[]args){SpringApplication.run(DemoApplication.class,args);//返回IOC容器，使用注解配置，传入配置类ApplicationContextcontext=newAnnotationConfigApplicationContext(WebConfig.class);Useruser=context.getBean(User.class);System.out.println(user);}}6

ImportBeanDefinitionRegistrar是一个接口，包含一个registerBeanDefinitions方法，该方法包含两个入参：

AnnotationMetadata：可以通过它获取到类的注解信息；

BeanDefinitionRegistry：Bean定义注册器，包含了一些和Bean有关的方法：

@SpringBootApplicationpublicclassDemoApplication{publicstaticvoidmain(String[]args){SpringApplication.run(DemoApplication.class,args);//返回IOC容器，使用注解配置，传入配置类ApplicationContextcontext=newAnnotationConfigApplicationContext(WebConfig.class);Useruser=context.getBean(User.class);System.out.println(user);}}7

这里我们需要借助BeanDefinitionRegistry的registerBeanDefinition方法来往IOC容器中注册Bean。该方法包含两个入参，第一个为需要注册的Bean名称（Id）,第二个参数为Bean的定义信息，它是一个接口，我们可以使用其实现类RootBeanDefinition来完成：

为了演示ImportBeanDefinitionRegistrar的使用，我们先新增一个类，名称为Strawberry，代码略。

然后新增一个ImportBeanDefinitionRegistrar实现类MyImportBeanDefinitionRegistrar：

@SpringBootApplicationpublicclassDemoApplication{publicstaticvoidmain(String[]args){SpringApplication.run(DemoApplication.class,args);//返回IOC容器，使用注解配置，传入配置类ApplicationContextcontext=newAnnotationConfigApplicationContext(WebConfig.class);Useruser=context.getBean(User.class);System.out.println(user);}}8

在上面的实现类中，我们先通过BeanDefinitionRegistry的containsBeanDefinition方法判断IOC容器中是否包含了名称为strawberry的组件，如果没有，则手动通过BeanDefinitionRegistry的registerBeanDefinition方法注册一个。

定义好MyImportBeanDefinitionRegistrar后，我们同样地在配置类的@Import中使用它：

@SpringBootApplicationpublicclassDemoApplication{publicstaticvoidmain(String[]args){SpringApplication.run(DemoApplication.class,args);//返回IOC容器，使用注解配置，传入配置类ApplicationContextcontext=newAnnotationConfigApplicationContext(WebConfig.class);Useruser=context.getBean(User.class);System.out.println(user);}}9

查看容器中是否已经有这个组件:

User(name=ycf,age=18)0

组件已经注册成功。

使用FactoryBean注册组件

Spring还提供了一个FactoryBean接口，我们可以通过实现该接口来注册组件，该接口包含了两个抽象方法和一个默认方法：

为了演示FactoryBean的使用，我们新增一个Cherry类，代码略。

然后创建FactoryBean的实现类CherryFactoryBean:

User(name=ycf,age=18)1

getObject返回需要注册的组件对象，getObjectType返回需要注册的组件类型，isSingleton指明该组件是否为单例。如果为多例的话，每次从容器中获取该组件都会调用其getObject方法。

定义好CherryFactoryBean后，我们在配置类中注册这个类：

User(name=ycf,age=18)2

测试从容器中获取：

User(name=ycf,age=18)3

可看到，虽然我们获取的是Id为cherryFactoryBean的组件，但其获取到的实际是getObject方法里返回的对象。

如果我们要获取cherryFactoryBean本身，则可以这样做：

User(name=ycf,age=18)4

为什么加上&前缀就可以获取到相应的工厂类了呢，查看BeanFactory的源码会发现原因: