【Spring注解】——组件注册

本文将主要针对Spring注解，讲解在组件注册过程会用到一些注解，对于小编本身是基础的回顾和巩固，也希望能帮助到需要的朋友，讲解偏颇之处，还请各位大神指正，小编不胜感激。

1、在容器中注册组件

1.1@Configuration

标注在类上，告诉spring这是一个配置类，代替spring的xml配置文件中<beans>。作用：配置spring容器（应用上下文）

优点

1、使用纯Java代码，不在需要xml

2、在配置中可以享受OO带来的好处

3、类型安全对重构也能提供良好的支持

4、依旧能享受到所有SpringIOC容器提供的功能

1.2@Bean

标注在方法上，相当于spring的xml配置文件中<bean>。作用：注册bean对象bean类

注意：

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配置文件中 <context:component-scan base-package=”**”/>。作用：在定义扫描的路径从中找到标识了需要装配的类自动装配到spring的容器中

2.2通过@ComponentScan指定扫描规则

标注在@ComponentScan后面括号中，作用按照指定规则向spring容器中自动装配bean

excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件，类似于spring中xml配置文件中

<context:component-scan base-package="**">
	<context:exclude-filter type="**" expression="**" />
</context:component-scan>

注解的使用方式

@ComponentScan(value="**",
excludeFilters = {@Filter(type=**,classes={**})}

includeFilters = Filter[] ：指定扫描的时候只需要包含哪些组件，类似于spring中xml配置文件中

<!--use-default-filters="false" 使用只包含哪些组件，需要禁用默认的装配规则-->
    <context:component-scan base-package="**" use-default-filters="false">
        <context:include-filter type="**" expression="**"
    </context:component-scan>

注解的使用方式

@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配置文件中的

<bean class="**" scope="**">

注解使用方式

@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则表示延迟加载
<bean class="***" lazy-init="true">

注解使用方式，延迟装载

@Service("allusersService")
@Lazy
public class AllusersServiceImpl

5、按条件注册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> {

	//返回一个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();
}

1）、默认获取到的是工厂bean调用getObject创建的对象

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应用上下文。

原文链接：https://blog.csdn.net/jiadajing267/article/details/80956849