【Spring注解】——组件注册
本文将主要针对Spring注解，讲解在组件注册过程会用到一些注解，对于小编本身是基础的回顾和巩固，也希望能帮助到需要的朋友，讲解偏颇之处，还请各位大神指正，小编不胜感激。
1、在容器中注册组件
1.1@Configuration
标注在类上，告诉spring这是一个配置类，代替spring的xml配置文件中
优点
1、使用纯Java代码，不在需要xml
2、在配置中可以享受OO带来的好处
3、类型安全对重构也能提供良好的支持
4、依旧能享受到所有SpringIOC容器提供的功能
1.2@Bean
标注在方法上，相当于spring的xml配置文件中
注意：
1、@Bean注解在返回实例的方法上，如果没有通过@Bean指定bean的名称，则默认与标注的方法名相同
2、@Bean注解默认作用域为单例singleton作用域，但是可以通过@Scope("prototype")设置为原型作用域（ps：@Scope下文有讲解）
3、@Bean的作用注册对象，也可以使用@Component，@Controller，@Service，@Repository等注解注册Bean，但是需要配置@ComponentScan注解进行自动扫描
2、扫描组件
2.1@ComponentScan(value)
标注在类上，相当于spring的xml配置文件中
2.2通过@ComponentScan指定扫描规则
标注在@ComponentScan后面括号中，作用按照指定规则向spring容器中自动装配bean
excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件，类似于spring中xml配置文件中
注解的使用方式
@ComponentScan(value="**",
excludeFilters = {@Filter(type=**,classes={**})}includeFilters = Filter[] ：指定扫描的时候只需要包含哪些组件，类似于spring中xml配置文件中
注解的使用方式
@ComponentScan(value="**",excludeFilters = {@Filter(type=**,classes={**})},useDefaultFilters = false)}@Filter包含的过滤类型
FilterType.ANNOTATION：按照注解
FilterType.ASSIGNABLE_TYPE：按照给定的类型；
FilterType.ASPECTJ：使用ASPECTJ表达式
FilterType.REGEX：使用正则指定
FilterType.CUSTOM：使用自定义规则当使用自定义规则的时候即@Filter=FilterType.CUSTOM，自定义的类需要实现TypeFilter接口，然后按自己的需要重写过滤规则
Demo，过滤类名中包含er的类
import java.io.IOException;
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;
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")){
return true;
}
return false;
}
}//只装配类名中包含er的类
@ComponentScan(value="**",
excludeFilters = {@Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})},
useDefaultFilters = false)2.3@ComponentScans，装配多个@ComponentScan装配规则
在Java8以前不允许在一个类上定义两个相同的注解，可以使用@ComponentScans，装配多个@ComponentScan装配规则
@ComponentScans(
value = {@ComponentScan(value="**",
excludeFilters ={@Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})},useDefaultFilters = false)}
)3、设置组件作用域
3.1@Scope(value)
标注类上或者装载类的方法上，spring容器中bean默认是单例的，但是可以通过@Scope调整作用域，相当于spring中xml配置文件中的
注解使用方式
@Service("allusersService")
@Scope("prototype")
public class AllusersServiceImpl{}作用域
prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。
每次获取的时候才会调用方法创建对象；
singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。
以后每次获取就是直接从容器（map.get()）中拿，
request：同一次请求创建一个实例
session：同一个session创建一个实例4、设置组件加载方式
4.1@Lazy懒加载
单实例bean：默认在容器启动的时候创建对象；
懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；
标注类上或者装载类的方法上，当第一次使用获取Bean才创建对象并初始化，相当spring中xml配置文件中
//默认为false，即立即加载，设置为true则表示延迟加载
注解使用方式，延迟装载
@Service("allusersService")
@Lazy
public class AllusersServiceImpl5、按条件注册bean
5.1@Conditional({Condition})
按照一定的条件进行判断，满足条件给容器中注册bean
在spring4中引入，用到带有@Bean注解的方法上，如果给定的条件计算结果为true，则会创建这个bean，否则这个bean就会被忽略。
条件化的创建bean，例如判断环境是为linux，如果是则注册
@Conditional(LinuxCondition.class)
@Bean("linus")
public Person person02(){
return new Person("linus", 48);
}作为条件的bean，在实现的时候需要实现spring提供的Condition接口
//判断是否linux系统
public class LinuxCondition implements Condition {
/**
* ConditionContext：判断条件能使用的上下文（环境）
* AnnotatedTypeMetadata：注释信息
*/
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();
String property = environment.getProperty("os.name");
//可以判断容器中的bean注册情况，也可以给容器中注册bean
boolean definition = registry.containsBeanDefinition("person");
if(property.contains("linux")){
return true;
}
return false;
}
}Spring中@Profile注解根据环境注册bean，本质上也是利用@Conditional注解实现
6、给容器中导入组件
6.1@Import
@Import导入组件，id默认是组件的全类名，相对于@Bean是一种更快捷的方式
@Configuration
//@Import导入组件，id默认是组件的全类名
@Import({Color.class,Red.class})
public class MainConfig{}6.2@ImportSelector
返回需要导入的组件全类名数组
自定义的类需要使用@Import注解导入
自定义实现ImportSelector接口的方法
//自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {
//返回值，就是到导入到容器中的组件全类名
//AnnotationMetadata:当前标注@Import注解的类的所有注解信息
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
//importingClassMetadata
//方法不要返回null值
return new String[]{"com.jia.bean.Blue","com.jia.bean.Yellow"};
}
}@Configuration
@Import({MyImportSelector.class})
public class MainConfig{}6.3@ImportBeanDefinitionRegistrar
手动注册bean到容器中，自定义逻辑实现bean的注册
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
/**
* AnnotationMetadata：当前类的注解信息
* BeanDefinitionRegistry:BeanDefinition注册类；
* 把所有需要添加到容器中的bean；调用
* BeanDefinitionRegistry.registerBeanDefinition手工注册进来
*/
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
boolean definition = registry.containsBeanDefinition("com.jia.bean.Red");
boolean definition2 = registry.containsBeanDefinition("com.jia.bean.Blue");
if(definition && definition2){
//指定Bean定义信息；（Bean的类型，Bean。。。）
RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
//注册一个Bean，指定bean名
registry.registerBeanDefinition("rainBow", beanDefinition);
}
}
}@Configuration
@Import({MyImportBeanDefinitionRegistrar.class})
public class MainConfig{}7、使用FactoryBean容器注册组件
创建一个spring定义的FactoryBean
import org.springframework.beans.factory.FactoryBean;
//创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean {
//返回一个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();
}2）、要获取工厂Bean本身，我们需要给id前面加一个&
&colorFactoryBean
//工厂Bean获取的是调用getObject创建的对象
Object bean2 = applicationContext.getBean("colorFactoryBean");
Object bean3 = applicationContext.getBean("colorFactoryBean");
System.out.println("bean的类型："+bean2.getClass());
System.out.println(bean2 == bean3);
Object bean4 = applicationContext.getBean("&colorFactoryBean");
System.out.println(bean4.getClass());8、加载spring的应用上下文
AnnotationConfigApplicationContext实现基于Java的配置类加载spring的应用上下文。避免使用application.xml进行配置，相比xml配置,更加便捷。
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);管理注解Bean定义的容器有两个：
AnnotationConfigApplicationContext和 AnnotationConfigWebApplicationContex。这两个类是专门处理Spring注解方式配置的容器，直接依赖于注解作为容器配置信息来源的IoC容器。
AnnotationConfigWebApplicationContext是AnnotationConfigApplicationContext的web版本，两者的用法以及对注解的处理方式几乎没有什么差别，在后续的文章小编会进行更加详细的讲解。
总结
给容器中注册组件：
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
5、使用AnnotationConfigApplicationContext使用配置文件加载spring应用上下文。