Spring注解开发之组件注册（一）
前言
现今SpringBoot、SpringCloud技术非常火热，作为Spring之上的框架，他们大量使用到了Spring的一些底层注解、原理，比如@Conditional、@Import、@EnableXXX等。如果掌握这些底层原理、注解，那么我们对这些高层框架就能做到高度定制，使用的游刃有余。
组件注册-@Configuration&@Bean给容器中注册组件
在我们使用配置文件xml的方式，我们首先需要一个spring的核心配置文件, 然后使用ClassPathXmlApplicationContext加载配置文件
- spring配置文件
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
<bean id="person" class="com.atguigu.bean.Person" scope="prototype" >
<property name="age" value="${}">property>
<property name="name" value="zhangsan">property>
bean>
beans>
ClassPathXmlApplicationContext读取配置文件
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
Person bean = (Person) applicationContext.getBean("person");
System.out.println(bean);
而我们使用spring注解方式开发时首先需要一个类，对类使用@Configuration注解，告诉spring这是一个配置类，并使用AnnotationConfigApplicationContext加载该配置类。
- java配置类
//配置类==配置文件
@Configuration //告诉Spring这是一个配置类
public class MainConfig {
//给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
@Bean("person")
public Person person01(){
return new Person("lisi", 20);
}
}
- 使用
AnnotationConfigApplicationContext读取配置类
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
Person bean = applicationContext.getBean(Person.class);
System.out.println(bean);
组件注册-@ComponentScan-自动扫描组件&指定扫描规则
我们在xml的配置文件中，使用@ComponentScan来达到相同的效果
- 使用
@ComponentScan注解指定扫描的包
@Configuration
@ComponentScan(value="com.sanfeng")
public class MainConfig {
//给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
@Bean("person")
public Person person01(){
return new Person("lisi", 20);
}
}
@ComponentScan一些常用的属性
excludeFilters = Filter[]：指定扫描的时候按照什么规则排除那些组件
includeFilters = Filter[]：指定扫描的时候只需要包含哪些组件
需要配置@Filter注解使用
@ComponentScan(value="com.atguigu",includeFilters = {
@Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
@Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),
},useDefaultFilters = false)
//excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件
//includeFilters = Filter[] ：指定扫描的时候只需要包含哪些组件
//Filter: 过滤器
//FiltetType: 过滤规则
//FilterType.ANNOTATION：按照注解
//FilterType.ASSIGNABLE_TYPE：按照给定的类型；
//FilterType.ASPECTJ：使用ASPECTJ表达式
//FilterType.REGEX：使用正则指定
//FilterType.CUSTOM：使用自定义规则
public class MainConfig {
//给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
@Bean("person")
public Person person01(){
return new Person("lisi", 20);
}
}
- 使用自定义规则进行过滤
使用自定义规则进行过滤我们需要一个指定过滤规则的类，该类需要继承spring的TypeFilter接口并实现match方法，如下：
// 自定义过滤规则
public class MyTypeFilter implements TypeFilter {
/**
* metadataReader：读取到的当前正在扫描的类的信息
* metadataReaderFactory:可以获取到其他任何类信息的
*/
@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
throws IOException {
// TODO Auto-generated method stub
//获取当前类注解的信息
AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
//获取当前正在扫描的类的类信息
ClassMetadata classMetadata = metadataReader.getClassMetadata();
//获取当前类资源（类的路径）
Resource resource = metadataReader.getResource();
String className = classMetadata.getClassName();
System.out.println("--->"+className);
if(className.contains("er")){ //扫描包名中包含er的包
return true;
}
return false;
}
}
// 使用自定义过滤规则
@Configuration
@ComponentScan(value="com.atguigu",includeFilters = {
@Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})
},useDefaultFilters = false)
public class MainConfig {
@Bean(value="person")
public Person person() {
return new Person("bill", 64);
}
}
组件注册-@Scope-设置组件作用域
@Scope:调整作用域
prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。每次获取的时候才会调用方法创建对象；singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。以后每次获取就是直接从容器（map.get()）中拿，request：同一次请求创建一个实例session：同一个session创建一个实例
常用的就是prototype和singleton
@Scope("prototype")
@Bean("person")
public Person person(){
System.out.println("给容器中添加Person....");
return new Person("张三", 25);
}
组件注册-@Lazy-bean懒加载
懒加载：
- 单实例bean：默认在容器启动的时候创建对象；
- 懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；
@Lazy
@Bean(value="person")
public Person person() {
System.out.println("创建一个Person类对象");
return new Person("bill", 64);
}
组件注册-@Conditional-按照条件注册bean
@Conditional({Condition}) ： 按照一定的条件进行判断，满足条件给容器中注册bean
@Conditional需要一个Condition类的值或数组，Condition是Spring内部的一个接口，我们需要实现Condtion接口
// 如果当前环境是Windows环境才将该Bean注册到Spring环境中
@Conditional(WindowsCondition.class)
@Bean("bill")
public Person person01(){
return new Person("Bill Gates",62);
}
// 如果当前环境是Linux环境才将该Bean注册到Spring环境中
@Conditional(LinuxCondition.class)
@Bean("linus")
public Person person02(){
return new Person("linus", 48);
}
- LinuxCondition
//判断是否linux系统
public class LinuxCondition implements Condition {
/**
* ConditionContext：判断条件能使用的上下文（环境）
* AnnotatedTypeMetadata：注释信息
*/
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
// TODO是否linux系统
//1、能获取到ioc使用的beanfactory
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
//2、获取类加载器
ClassLoader classLoader = context.getClassLoader();
//3、获取当前环境信息
Environment environment = context.getEnvironment();
//4、获取到bean定义的注册类
BeanDefinitionRegistry registry = context.getRegistry();
String property = environment.getProperty("os.name");
//可以判断容器中的bean注册情况，也可以给容器中注册bean
boolean definition = registry.containsBeanDefinition("person");
if(property.contains("linux")){
return true;
}
return false;
}
}
- WindowsCondition
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;
}
}
@Conditional注解可以使用在方法上，也可以使用在配置类上，在配置类上表示只有满足条件，该配置类中的Bean在会注册到Spring容器中，否则都不注册
组件注册-@Import-给容器中快速导入一个组件
在做Spring开发时，我们经常需要使用第三方库，我们可以使用@Import快速将第三方库注册到Spring容器中
假设下面两个类为第三方类
public class Yellow {
}
public class Red{
}
public class Blue {
}
我们可以使用@Import将其快速注册到Spring容器中
@Configuration
@Import({Yellow.class,Red.class,Blue.class})
//@Import导入组件，id默认是组件的全类名
public class MainConfig2{
}
@Import注解还可以接受一个ImportSelector类，该类是Spring的一个接口，通过实现该接口，我们可以指定需要导入的组件
//自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {
//返回值，就是到导入到容器中的组件全类名
//AnnotationMetadata:当前标注@Import注解的类的所有注解信息
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
// TODO Auto-generated method stub
//importingClassMetadata
//方法不要返回null值
// 返回需要导入的组件的全类名数组
return new String[]{"com.sanfeng.bean.Blue","com.sanfeng.bean.Yellow"};
}
}
@Import({Red.class,MyImportSelector.class)
//@Import导入组件，id默认是组件的全类名
public class MainConfig2 {
}
@Import注解还接受一个ImportBeanDefinitionRegistrar类，该类可以让我们手动将Bean注册到Spring容器中，这也是Spring的一个接口类，需要我们手动实现它
public class RainBow {
}
// ===========================
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
/**
* AnnotationMetadata：当前类的注解信息
* BeanDefinitionRegistry:BeanDefinition注册类；
* 把所有需要添加到容器中的bean；调用
* BeanDefinitionRegistry.registerBeanDefinition手工注册进来
*/
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
boolean definition = registry.containsBeanDefinition("com.sanfeng.bean.Red");
boolean definition2 = registry.containsBeanDefinition("com.sanfeng.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})
//@Import导入组件，id默认是组件的全类名
public class MainConfig2 {
}
组件注册-使用FactoryBean注册组件
使用Spring的FactoryBean接口也可以将主键注册到Spring中
//创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {
//返回一个Color对象，这个对象会添加到容器中
@Override
public Color getObject() throws Exception {
// TODO Auto-generated method stub
System.out.println("ColorFactoryBean...getObject...");
return new Color();
}
@Override
public Class<?> getObjectType() {
// TODO Auto-generated method stub
return Color.class;
}
//是单例？
//true：这个bean是单实例，在容器中保存一份
//false：多实例，每次获取都会创建一个新的bean；
@Override
public boolean isSingleton() {
// TODO Auto-generated method stub
return false;
}
}
// ---------------------------------
@Bean
public ColorFactoryBean colorFactoryBean(){
return new ColorFactoryBean();
}
- 注意:
*当我们使用applicaiton.getBean("colorFactoryBean")默认获取到的是工厂bean调用getObject创建的对象，如上面的Color对象- 要获取工厂Bean本身，我们需要给id前面加一个&,
&colorFactoryBean
- 要获取工厂Bean本身，我们需要给id前面加一个&,
总结：Spring注册组件的方法
给容器中注册组件；
- 包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）[自己写的类]
- @Bean[导入的第三方包里面的组件]
- @Import[快速给容器中导入一个组件]
- @Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名
- ImportSelector:返回需要导入的组件的全类名数组；
- ImportBeanDefinitionRegistrar:手动注册bean到容器中
- 使用Spring提供的 FactoryBean（工厂Bean）;
- 默认获取到的是工厂bean调用getObject创建的对象
- 要获取工厂Bean本身，我们需要给id前面加一个&，如
&colorFactoryBean