小知识，大挑战！本文正在参与“程序员必备小知识”创作活动
接触过Spring的同学肯定都听过IOC。在传统的Java编程中，当需要用到某个对象的时候，我们都是主动显式创建一个对象实例（new）。使用Spring后就不需要这样做了，因为Spring会帮我们在需要用到某些对象的地方自动注入该对象，而无须我们自己去创建。这种模式俗称控制反转，即IOC（Inversion of Control）。那么Spring是从什么地方获取到我们所需要的对象呢？其实Spring给我们提供了一个IOC容器，里面管理着所有我们需要的对象，组件注册就是我们去告诉Spring哪些类需要交给IOC容器管理。
这里主要记录组件注册的一些细节。
通过@Bean注册组件
在较早版本的Spring中，我们都是通过XML的方式来往IOC容器中注册组件的，下面这段代码大家肯定不会陌生：
// 返回 IOC 容器，基于 XML配置，传入配置文件的位置
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("xxx.xml");
User user = (User) applicationContext.getBean("user");
Spring 4后推荐我们使用Java Config的方式来注册组件。
为了演示，我们搭建一个简单Spring Boot应用，然后引入Lombok依赖（编辑器也需要安装Lombok插件），然后创建一个User类：
@ToString
@AllArgsConstructor
@Data
public class User {
private String name;
private Integer age;
}
接着创建一个配置类，在里面通过@Bean注解注册User类：
@Configuration
public class WebConfig {
@Bean()
public User user() {
return new User("ycf", 18);
}
}
通过@Bean注解，我们向IOC容器注册了一个名称为user（Bean名称默认为方法名，我们也可以通过@Bean("myUser")方式来将组件名称指定为myUser）。
组件注册完毕后，我们测试一下从IOC容器中获取这个组件。在Spring Boot入口类中编写如下代码：
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
// 返回 IOC 容器，使用注解配置，传入配置类
ApplicationContext context =new AnnotationConfigApplicationContext(WebConfig.class);
User user = context.getBean(User.class);
System.out.println(user);
}
}
因为我们是通过注解方式来注册组件的，所以需要使用AnnotationConfigApplicationContext来获取相应的IOC容器，入参为配置类。
启动项目，看下控制台输出：
User(name=ycf, age=18)
说明组件注册成功。
我们将组件的名称改为myUser，然后看看IOC容器中，User类型组件是否叫myUser：
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
// 查看 User 这个类在 Spring 容器中叫啥玩意
String[] beanNames = context.getBeanNamesForType(User.class);
Arrays.stream(beanNames).forEach(System.out::println);
}
}
// 输出 myUser
使用@ComponentScan扫描
在使用XML配置组件扫描的时候，我们都是这样配置的：
<context:component-scan base-package=""></context:component-scan>
其中base-package指定了扫描的路径。路径下所有被@Controller、@Service、@Repository和@Component注解标注的类都会被纳入IOC容器中。
现在我们脱离XML配置后，可以使用@ComponentScan注解来扫描组件并注册。
在使用@ComponentScan扫描之前，我们先创建一个Controller，Service，Dao，并标注上相应的注解。
然后修改配置类：
@Configuration
@ComponentScan("cn.ycf.demo")
public class WebConfig {
// @Bean("myUser")
// public User user() {
// return new User("mrbird", 18);
// }
}
在配置类中，我们通过@ComponentScan("cn.ycf.demo")配置了扫描路径，并且将User组件注册注释掉了，取而代之的是在User类上加上@Component注解：
@ToString
@AllArgsConstructor
@NoArgsConstructor
@Data
@Component
public class User {
private String name;
private Integer age;
}
值得注意的是，我们不能将Spring Boot的入口类纳入扫描范围中，否则项目启动将出错。
接下来我们看下在基于注解的IOC容器中是否包含了这些组件：
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
// 查看基于注解的 IOC容器中所有组件名称
String[] beanNames = context.getBeanDefinitionNames();
Arrays.stream(beanNames).forEach(System.out::println);
}
}
// 输出
// webConfig
// userController
// userMapper
// user
// userService
可见，组件已经成功被扫描进去了，并且名称默认为类名首字母小写。
这里，配置类WebConfig也被扫描并注册了，查看@Configuration源码就会发现原因：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
String value() default "";
}
指定扫描策略
@ComponentScan注解允许我们指定扫描策略，即指定哪些被扫描，哪些不被扫描，查看其源码可发现这两个属性：
/**
* Specifies which types are eligible for component scanning.
* <p>Further narrows the set of candidate components from everything in {@link #basePackages}
* to everything in the base packages that matches the given filter or filters.
* <p>Note that these filters will be applied in addition to the default filters, if specified.
* Any type under the specified base packages which matches a given filter will be included,
* even if it does not match the default filters (i.e. is not annotated with {@code @Component}).
* @see #resourcePattern()
* @see #useDefaultFilters()
*/
Filter[] includeFilters() default {};
/**
* Specifies which types are not eligible for component scanning.
* @see #resourcePattern
*/
Filter[] excludeFilters() default {};
其中Filter也是一个注解:
/**
* Declares the type filter to be used as an {@linkplain ComponentScan#includeFilters
* include filter} or {@linkplain ComponentScan#excludeFilters exclude filter}.
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({})
@interface Filter {
FilterType type() default FilterType.ANNOTATION;
@AliasFor("classes")
Class<?>[] value() default {};
@AliasFor("value")
Class<?>[] classes() default {};
String[] pattern() default {};
}
接下来我们使用excludeFilters来排除一些组件的扫描：
@Configuration
@ComponentScan(value = "cc.mrbird.demo",
excludeFilters = {
@Filter(type = FilterType.ANNOTATION,
classes = {Controller.class, Repository.class}),
@Filter(type = FilterType.ASSIGNABLE_TYPE, classes = User.class)
})
public class WebConfig {
}
上面我们指定了两种排除扫描的规则：
- 根据注解来排除（
type = FilterType.ANNOTATION）,这些注解的类型为classes = {Controller.class, Repository.class}。即Controller和Repository注解标注的类不再被纳入到IOC容器中。 - 根据指定类型类排除（
type = FilterType.ASSIGNABLE_TYPE），排除类型为User.class，其子类，实现类都会被排除。
启动项目，观察控制台：
webConfig
userService
可见排除成功。
除了上面两种常用的规则外，我们还可以使用别的规则，查看FilterType源码：
public enum FilterType {
/**
* Filter candidates marked with a given annotation.
* 筛选用给定注释标记的候选项。
* @see org.springframework.core.type.filter.AnnotationTypeFilter
*/
ANNOTATION,
/**
* Filter candidates assignable to a given type.
* 筛选可分配给给定类型的候选者。
* @see org.springframework.core.type.filter.AssignableTypeFilter
*/
ASSIGNABLE_TYPE,
/**
* Filter candidates matching a given AspectJ type pattern expression.
* 筛选匹配给定AspectJ类型模式表达式的候选项。
* @see org.springframework.core.type.filter.AspectJTypeFilter
*/
ASPECTJ,
/**
* Filter candidates matching a given regex pattern.
* 过滤匹配给定正则表达式模式的候选者。
* @see org.springframework.core.type.filter.RegexPatternTypeFilter
*/
REGEX,
/**
* Filter candidates using a given custom.
* 使用给定的自定义筛选候选项。
* {@link org.springframework.core.type.filter.TypeFilter} implementation.
*/
CUSTOM
}
可看到，我们还可以通过ASPECTJ表达式，REGEX正则表达式和CUSTOM自定义规则（下面详细介绍）来指定扫描策略。
includeFilters的作用和excludeFilters相反，其指定的是哪些组件需要被扫描：
@Configuration
@ComponentScan(value = "cc.mrbird.demo",
includeFilters = {
@Filter(type = FilterType.ANNOTATION, classes = Service.class)
}, useDefaultFilters = false)
public class WebConfig {
}
上面配置了只将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实现该接口：
public class MyTypeFilter implements TypeFilter {
@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
return false;
}
}
该接口包含match方法，其两个入参MetadataReader和MetadataReaderFactory含义如下：
MetadataReader：当前正在扫描的类的信息；MetadataReaderFactory：可以通过它来获取其他类的信息。
当match方法返回true时说明匹配成功，false则说明匹配失败。继续完善这个过滤规则：
public class MyTypeFilter implements TypeFilter {
@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) {
// 获取当前正在扫描的类的注解信息
AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
// 获取当前正在扫描的类的类信息
ClassMetadata classMetadata = metadataReader.getClassMetadata();
// 获取当前正在扫描的类的路径等信息
Resource resource = metadataReader.getResource();
String className = classMetadata.getClassName();
return StringUtils.hasText("er");
}
}
上面指定了当被扫描的类名包含er时候，匹配成功，配合excludeFilters使用意指当被扫描的类名包含er时，该类不被纳入IOC容器中。
我们在@ComponentScan中使用这个自定义的过滤策略：
@Configuration
@ComponentScan(value = "cc.mrbird.demo",
excludeFilters = {
@Filter(type = FilterType.CUSTOM, classes = MyTypeFilter.class)
})
public class WebConfig {
}
// 结果
// webConfig
因为User，UserMapper，UserService和UserController等类的类名都包含er，所以它们都没有被纳入到IOC容器中。
组件作用域@Scope
默认情况下，在Spring的IOC容器中每个组件都是单例的，即无论在任何地方注入多少次，这些对象都是同一个，我们来看下例子。
首先将User对象中的@Component注解去除，然后在配置类中配置User Bean：
@Configuration
public class WebConfig {
@Bean
public User user() {
return new User("ycf", 18);
}
}
接着多次从IOC容器中获取这个组件，看看是否为同一个：
// 返回 IOC 容器，使用注解配置，传入配置类
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
Object user1 = context.getBean("user");
Object user2 = context.getBean("user");
System.out.println(user1 == user2);
// true
在Spring中我们可以使用@Scope注解来改变组件的作用域：
- singleton ：单实例（默认）,在Spring IOC容器启动的时候会调用方法创建对象然后纳入到IOC容器中，以后每次获取都是直接从IOC容器中获取（
map.get()）； - prototype ：多实例，IOC容器启动的时候并不会去创建对象，而是在每次获取的时候才会去调用方法创建对象；
- request ：一个请求对应一个实例；
- session ：同一个session对应一个实例。
懒加载@Lazy
懒加载是针对单例模式而言的，正如前面所说，IOC容器中的组件默认是单例的，容器启动的时候会调用方法创建对象然后纳入到IOC容器中。
在User Bean注册的地方加入一句话以观察：
@Configuration
public class WebConfig {
@Bean
public User user() {
System.out.println("往IOC容器中注册user bean");
return new User("ycf", 18);
}
}
测试：
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
System.out.println("容器创建完毕");
// 往IOC容器中注册user bean
// 容器创建完毕
将User Bean改为懒加载的方式：
@Configuration
public class WebConfig {
@Bean
@Lazy
public User user() {
System.out.println("往IOC容器中注册user bean");
return new User("ycf", 18);
}
}
// 容器创建完毕
可看到，容器创建完的时候，User Bean这个组件并未添加到容器中。
所以懒加载的功能是，在单例模式中，IOC容器创建的时候不会马上去调用方法创建对象并注册，只有当组件 第一次 被使用的时候才会调用方法创建对象并加入到容器中。
测试一下：
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
System.out.println("容器创建完毕");
Object user1 = context.getBean("user");
Object user2 = context.getBean("user");
// 容器创建完毕
// 往IOC容器中注册user bean
结果证实了我们的观点。
条件注册组件
@Conditional
使用@Conditional注解我们可以指定组件注册的条件，即满足特定条件才将组件纳入到IOC容器中。
在使用该注解之前，我们需要创建一个类，实现Condition接口：
public class MyCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
return false;
}
}
该接口包含一个matches方法，包含两个入参:
ConditionContext：上下文信息；AnnotatedTypeMetadata：注解信息。
简单完善一下这个实现类:
public class MyCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
String osName = context.getEnvironment().getProperty("os.name");
return osName != null && osName.contains("Windows");
}
}
接着将这个条件添加到User Bean注册的地方：
@Bean
@Conditional(MyCondition.class)
public User user() {
return new User("ycf", 18);
}
在Windows环境下，User这个组件将被成功注册，如果是别的操作系统，这个组件将不会被注册到IOC容器中。
@Profile
@Profile可以根据不同的环境变量来注册不同的组件，下面我们来学一下它的用法。
导入组件
@Import
到目前为止，我们可以使用包扫描和@Bean来实现组件注册。除此之外，我们还可以使用@Import来快速地往IOC容器中添加组件。
创建一个新的类Hello：
public class Hello {
}
然后在配置类中导入这个组件：
@Configuration
@Import({Hello.class})
public class WebConfig {
...
}
查看IOC容器中所有组件的名称：
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
String[] beanNames = context.getBeanDefinitionNames();
Arrays.stream(beanNames).forEach(System.out::println);
// webConfig
// cn.ycf.demo.domain.Hello
// user
可看到，通过@Import我们可以快速地往IOC容器中添加组件，Id默认为全类名。
ImportSelector
通过@Import我们已经实现了组件的导入，如果需要一次性导入较多组件，我们可以使用ImportSelector来实现。
新增三个类Apple，Banana和Watermelon，代码略。
查看ImportSelector源码：
public interface ImportSelector {
/**
* Select and return the names of which class(es) should be imported based on
* the {@link AnnotationMetadata} of the importing @{@link Configuration} class.
*/
String[] selectImports(AnnotationMetadata importingClassMetadata);
}
ImportSelector是一个接口，包含一个selectImports方法，方法返回类的全类名数组（即需要导入到IOC容器中组件的全类名数组），包含一个AnnotationMetadata类型入参，通过这个参数我们可以获取到使用ImportSelector的类的全部注解信息。
我们新建一个ImportSelector实现类MyImportSelector：
public class MyImportSelector implements ImportSelector {
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[]{
"cc.mrbird.demo.domain.Apple",
"cc.mrbird.demo.domain.Banana",
"cc.mrbird.demo.domain.Watermelon"
};
}
}
上面方法返回了新增的三个类的全类名数组，接着我们在配置类的@Import注解上使用MyImportSelector来把这三个组件快速地导入到IOC容器中：
@Import({MyImportSelector.class})
public class WebConfig {
...
}
查看容器中是否已经有这三个组件:
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
String[] beanNames = context.getBeanDefinitionNames();
Arrays.stream(beanNames).forEach(System.out::println);
// cc.mrbird.demo.domain.Apple
// cc.mrbird.demo.domain.Banana
// cc.mrbird.demo.domain.Watermelon
组件已经成功导入。
ImportBeanDefinitionRegistrar
除了上面两种往IOC容器导入组件的方法外，我们还可以使用ImportBeanDefinitionRegistrar来手动往IOC容器导入组件。
查看其源码：
public interface ImportBeanDefinitionRegistrar {
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);
}
ImportBeanDefinitionRegistrar是一个接口，包含一个registerBeanDefinitions方法，该方法包含两个入参：
AnnotationMetadata：可以通过它获取到类的注解信息；BeanDefinitionRegistry：Bean定义注册器，包含了一些和Bean有关的方法：
public interface BeanDefinitionRegistry extends AliasRegistry {
void registerBeanDefinition(String var1, BeanDefinition var2) throws BeanDefinitionStoreException;
void removeBeanDefinition(String var1) throws NoSuchBeanDefinitionException;
BeanDefinition getBeanDefinition(String var1) throws NoSuchBeanDefinitionException;
boolean containsBeanDefinition(String var1);
String[] getBeanDefinitionNames();
int getBeanDefinitionCount();
boolean isBeanNameInUse(String var1);
}
这里我们需要借助BeanDefinitionRegistry的registerBeanDefinition方法来往IOC容器中注册Bean。该方法包含两个入参，第一个为需要注册的Bean名称（Id）,第二个参数为Bean的定义信息，它是一个接口，我们可以使用其实现类RootBeanDefinition来完成：
为了演示ImportBeanDefinitionRegistrar的使用，我们先新增一个类，名称为Strawberry，代码略。
然后新增一个ImportBeanDefinitionRegistrar实现类MyImportBeanDefinitionRegistrar：
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
final String beanName = "strawberry";
boolean contain = registry.containsBeanDefinition(beanName);
if (!contain) {
RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Strawberry.class);
registry.registerBeanDefinition(beanName, rootBeanDefinition);
}
}
}
在上面的实现类中，我们先通过BeanDefinitionRegistry的containsBeanDefinition方法判断IOC容器中是否包含了名称为strawberry的组件，如果没有，则手动通过BeanDefinitionRegistry的registerBeanDefinition方法注册一个。
定义好MyImportBeanDefinitionRegistrar后，我们同样地在配置类的@Import中使用它：
@Configuration
@Import({MyImportBeanDefinitionRegistrar.class})
public class WebConfig {
...
}
查看容器中是否已经有这个组件:
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
String[] beanNames = context.getBeanDefinitionNames();
Arrays.stream(beanNames).forEach(System.out::println);
// strawberry
组件已经注册成功。
使用FactoryBean注册组件
Spring还提供了一个FactoryBean接口，我们可以通过实现该接口来注册组件，该接口包含了两个抽象方法和一个默认方法：
为了演示FactoryBean的使用，我们新增一个Cherry类，代码略。
然后创建FactoryBean的实现类CherryFactoryBean:
public class CherryFactoryBean implements FactoryBean<Cherry> {
@Override
public Cherry getObject() {
return new Cherry();
}
@Override
public Class<?> getObjectType() {
return Cherry.class;
}
@Override
public boolean isSingleton() {
return false;
}
}
getObject返回需要注册的组件对象，getObjectType返回需要注册的组件类型，isSingleton指明该组件是否为单例。如果为多例的话，每次从容器中获取该组件都会调用其getObject方法。
定义好CherryFactoryBean后，我们在配置类中注册这个类：
@Bean
public CherryFactoryBean cherryFactoryBean() {
return new CherryFactoryBean();
}
测试从容器中获取：
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
Object cherry = context.getBean("cherryFactoryBean");
System.out.println(cherry.getClass());
// class cn.ycf.demo.domain.Cherry
可看到，虽然我们获取的是Id为cherryFactoryBean的组件，但其获取到的实际是getObject方法里返回的对象。
如果我们要获取cherryFactoryBean本身，则可以这样做：
Object cherryFactoryBean = context.getBean("&cherryFactoryBean");
System.out.println(cherryFactoryBean.getClass());
// class cn.ycf.demo.domain.CherryFactoryBean
为什么加上&前缀就可以获取到相应的工厂类了呢，查看BeanFactory的源码会发现原因:
