接触过Spring的同学肯定都听过IOC。在传统的Java编程中,当需要用到某个对象的时候,我们都是主动地显示创建一个对象实例(new)。使用Spring后就不需要这样做了,因为Spring会帮我们在需要用到某些对象的地方自动注入该对象,而无须我们自己去创建。这种模式俗称控制反转,即IOC(Inversion of Control)。那么Spring是从什么地方获取到我们所需要的对象呢?其实Spring给我们提供了一个IOC容器,里面管理着所有我们需要的对象,组件注册就是我们去告诉Spring哪些类需要交给IOC容器管理。
这里主要记录组件注册的一些细节。
- 通过@Bean注册组件
- 通过@ComponentScan扫描,注册组件
2.1 指定扫描策略
2.2 多扫描策略策略
2.3 自定义扫描策略 - 组件作用域@Scope
- 懒加载@Lazy
- 条件注册组件
5.1 @Conditional
5.2 @Profile - 导入组件
6.1 @Import
6.2 ImportSelector
6.3 ImportBeanDefinitionRegistrar - 使用FactoryBean注册组件
通过@Bean注册组件
在较早版本的Spring中,我们都是通过XML的方式来往IOC容器中注册组件的,下面这段代码大家肯定不会陌生:
// 返回 IOC 容器,基于 XML配置,传入配置文件的位置
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("xxx.xml");
User user = (User) applicationContext.getBean("user");
Spring 4后推荐我们使用Java Config的方式来注册组件。
创建一个User
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class User {
private String name;
private int age;
}
接着创建一个配置类,在里面通过@Bean注解注册User类:
@Configuration
public class WebConfig {
@Bean
public User user() {
return new User("张小龙", 18);
}
}
通过@Bean注解,我们向IOC容器注册了一个名称为user(Bean名称默认为方法名,我们也可以通过@Bean("myUser")方式来将组件名称指定为myUser)。
组件注册完毕后,我们测试一下从IOC容器中获取这个组件。在Spring Boot入口类中编写如下代码:
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
// 返回 IOC 容器,使用注解配置,传入配置类
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
User user = context.getBean(User.class);
System.out.println(user);
}
因为我们是通过注解方式来注册组件的,所以需要使用AnnotationConfigApplicationContext
来获取相应的IOC容器,入参为配置类。
启动项目,看下控制台输出:
User(name=张小龙, age=18)
说明组件注册成功。
我们将组件的名称改为myUser,然后看看IOC容器中,User类型组件是否叫myUser:
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
// 返回 IOC 容器,使用注解配置,传入配置类
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
String[] namesForType = context.getBeanNamesForType(User.class);
Arrays.stream(namesForType).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("top.lconcise.demo")
public class WebConfig {
// @Bean("myUser")
public User user() {
System.out.println("往ioc 容器中注册 user bean ");
return new User("张小龙", 18);
}
}
在配置类中,我们通过@ComponentScan("top.lconcise.demo")配置了扫描路径,并且将User组件注册注释掉了,取而代之的是在User类上加上@Component注解:
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
@Component
public class User {
private String name;
private int age;
}
值得注意的是,我们不能将Spring Boot的入口类纳入扫描范围中,否则项目启动将出错。
接下来我们看下在基于注解的IOC容器中是否包含了这些组件:
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
String[] beanNamesForType = context.getBeanDefinitionNames();
Arrays.stream(beanNamesForType).forEach(System.out::println);
}
启动项目,观察控制台:
webConfig
userService
userController
user
userDao
可见,组件已经成功被扫描进去了,并且名称默认为类名首字母小写。
这里,配置类WebConfig也被扫描并注册了,查看@Configuration源码就会发现原因:
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
String value() default "";
}
指定扫描策略
public class MyTypeFilter implements TypeFilter {
@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();
return StringUtils.hasText("er");
}
}
/**
* Created by liusj on 2019/7/11
* 指定扫描策略.
*/
@Configuration
@ComponentScan(value = "top.lconcise.demo",
excludeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Repository.class}),
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = User.class)})
public class WebConfig3 {
}
多扫描策略配置
/**
* Created by liusj on 2019/7/11
* <p>
* 多扫描策略配置.
*/
@Configuration
//@ComponentScan("top.lconcise.demo")
@ComponentScan("top.lconcise.demo.Service")
@ComponentScan("top.lconcise.demo.controller")
public class WebConfig2 {
// @Bean("myUser")
public User user() {
return new User("张小龙", 18);
}
}
自定义扫描策略
public class MyTypeFilter implements TypeFilter {
@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();
return StringUtils.hasText("er");
}
}
@Configuration
@ComponentScan(value = "top.lconcise.demo",
excludeFilters = {
@ComponentScan.Filter(type = FilterType.CUSTOM, classes = MyTypeFilter.class)})
public class WebConfig4 {
}
组件作用域@Scope
默认情况下,在Spring的IOC容器中每个组件都是单例的,即无论在任何地方注入多少次,这些对象都是同一个。
- singleton:单实例(默认),在Spring IOC容器启动的时候会调用方法创建对象然后纳入到IOC容器中,以后每次获取都是直接从IOC容器中获取(map.get());
- prototype:多实例,IOC容器启动的时候并不会去创建对象,而是在每次获取的时候才会去调用方法创建对象;
- request:一个请求对应一个实例;
- session:同一个session对应一个实例。
@Bean("myUser")
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Lazy
public User user() {
System.out.println("往ioc 容器中注册 user bean ");
return new User("张小龙", 18);
}
懒加载@Lazy
懒加载是针对单例模式而言的,正如前面所说,IOC容器中的组件默认是单例的,容器启动的时候会调用方法创建对象然后纳入到IOC容器中。
@Bean("myUser")
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Lazy
public User user() {
System.out.println("往ioc 容器中注册 user bean ");
return new User("张小龙", 18);
}
条件注册组件
@Conditional
使用@Conditional注解我们可以指定组件注册的条件,即满足特定条件才将组件纳入到IOC容器中。
public class MyCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
String osName = conditionContext.getEnvironment().getProperty("os.name");
return osName != null && osName.contains("Windows");
}
}
@Configuration
public class WebConfig5 {
@Bean
@Conditional(MyCondition.class)
public User user() {
return new User("张小龙", 19);
}
}
@Profile
@Profile可以根据不同的环境变量来注册不同的组件
public interface SweetService {
void eat();
}
@Service
@Profile("java7")
public class Java7SweetServiceImpl implements SweetService {
@Override
public void eat() {
System.out.println("Java7 环境下执行");
}
}
@Service
@Profile("java8")
public class Java8SweetServiceImpl implements SweetService {
@Override
public void eat() {
System.out.println("Java8 环境下执行");
}
}
ConfigurableApplicationContext context1 = new SpringApplicationBuilder(Application.class)
.web(WebApplicationType.NONE)
.profiles("java8")
.run(args);
SweetService bean = context1.getBean(SweetService.class);
bean.eat();
导入组件
@Import
到目前为止,我们可以使用包扫描和@Bean来实现组件注册。除此之外,我们还可以使用@Import来快速地往IOC容器中添加组件。
public class Hello {
}
@Configuration
@Import({Hello.class})
public class WebConfig6 {
}
ImportSelector
通过@Import我们已经实现了组件的导入,如果需要一次性导入较多组件,我们可以使用ImportSelector来实现。
public class MyImportSelector implements ImportSelector {
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
return new String[]{
"top.lconcise.demo.domain.Demo1",
"top.lconcise.demo.domain.Demo2",
"top.lconcise.demo.domain.Demo3"
};
}
}
@Configuration
@Import({MyImportSelector.class})
public class WebConfig7 {
}
ImportBeanDefinitionRegistrar
除了上面两种往IOC容器导入组件的方法外,我们还可以使用ImportBeanDefinitionRegistrar来手动往IOC容器导入组件。
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
final String beanName = "demo4";
boolean contain = beanDefinitionRegistry.containsBeanDefinition(beanName);
if (!contain) {
RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Demo4.class);
beanDefinitionRegistry.registerBeanDefinition(beanName, rootBeanDefinition);
}
}
}
@Configuration
@Import({MyImportBeanDefinitionRegistrar.class})
public class WebConfig8 {
}
使用FactoryBean注册组件
Spring还提供了一个FactoryBean接口,我们可以通过实现该接口来注册组件,该接口包含了两个抽象方法和一个默认方法:
public class Demo5FactoryBean implements FactoryBean<Demo5> {
@Override
public Demo5 getObject() throws Exception {
return new Demo5();
}
@Override
public Class<?> getObjectType() {
return Demo5.class;
}
@Override
public boolean isSingleton() {
return false;
}
}
@Configuration
public class WebConfig9 {
@Bean
public Demo5FactoryBean demo5FactoryBean() {
return new Demo5FactoryBean();
}
}
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
Object demo5FactoryBean = context.getBean("demo5FactoryBean");
System.out.println(demo5FactoryBean.getClass());
Object demo5FactoryBean2 = context.getBean("&demo5FactoryBean");
System.out.println(demo5FactoryBean2.getClass());
源码连接:https://github.com/lbshold/springboot/tree/master/Spring-Register-Bean
网友评论