向Spring容器中注册组件的几种方式

1
2
<context:component-scan base-package="com.scorpios"></context:component-scan>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//excludeFilters = Filter[] ：指定扫描的时候按照什么规则 排除哪些组件
//includeFilters = Filter[] ：指定扫描的时候 只需要包含 哪些组件
//FilterType.ANNOTATION：按照注解
//FilterType.ASSIGNABLE_TYPE：按照给定的类型
//FilterType.CUSTOM：使用自定义规则

@Configuration
//@ComponentScan  value:指定要扫描的包
@ComponentScan(value="com.scorpios",includeFilters = {
	// @Filter(type=FilterType.ANNOTATION,classes={Controller.class}), 
	// @Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),
	@Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})},
	useDefaultFilters = false)	
public class MainConfig {
	
	// 给容器中注册一个Bean;  类型为返回值的类型，id默认是用方法名作为id
	@Bean("person")
	public Person person(){
		return new Person("lisi", 20);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class MyTypeFilter implements TypeFilter {

	/**
	 * metadataReader：读取到的，当前正在扫描的类的信息
	 * metadataReaderFactory:可以获取到其他任何类信息的
	 */
	@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();
		System.out.println("--->"+className);
		// 如果类名中包含er，则加入到Spring容器中，否则不加入容器
		if(className.contains("er")){  
			return true;
		}
		return false;
	}
}

1
2
3
4
public class Color {
	String color;
}

1
2
3
4
5
@Configuration
@Import({Color.class})
public class MainConfig{
}

1
2
3
4
5
@Configuration
@Import({MyImportSelector.class}))
public class MainConfig{
}

1
2
3
4
5
6
7
8
9
10
11
public class MyImportSelector implements ImportSelector {

	//返回值，就是到导入到容器中的组件全类名
	//AnnotationMetadata:当前标注@Import注解的类的所有注解信息
	@Override
	public String[] selectImports(AnnotationMetadata importingClassMetadata) {
		//方法不要返回null值
		return new String[]{"com.scorpios.bean.Color","com.scorpios.bean.Blue"};
	}
}

1
2
3
4
5
@Configuration
@Import({MyImportBeanDefinitionRegistrar.class}))
public class MainConfig{
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

	/**
	 * AnnotationMetadata：当前类的注解信息
	 * BeanDefinitionRegistry：BeanDefinition注册类；
	 * 	把所有需要添加到容器中的bean；
	 * 调用BeanDefinitionRegistry.registerBeanDefinition手工注册进来
	 */
	@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, 
												BeanDefinitionRegistry registry) {
		
		boolean definition = registry.containsBeanDefinition("com.scorpios.bean.Color");
		boolean definition2 = registry.containsBeanDefinition("com.scorpios.bean.Blue");
		if(definition && definition2){
			//指定Bean定义信息；（Bean的类型）
			RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
			//注册一个Bean，指定bean名
			registry.registerBeanDefinition("rainBow", beanDefinition);
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {

	//返回一个Color对象，这个对象会添加到容器中
	@Override
	public Color getObject() throws Exception {
		System.out.println("ColorFactoryBean...getObject...");
		return new Color();
	}

	@Override
	public Class<?> getObjectType() {
		return Color.class;
	}

	//true：这个bean是单实例，在容器中保存一份
	//false：多实例，每次获取都会创建一个新的bean；
	@Override
	public boolean isSingleton() {
		return false;
	}
}

1
2
3
4
5
6
7
8
9
10
11
// 类中组件统一设置。满足当前条件，这个类中配置的所有bean注册才能生效；
@Conditional({WindowsCondition.class})
@Configuration
public class MainConfig {

	@Bean("bill")
	public Person person(){
		return new Person("Bill Gates",62);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//判断是否windows系统
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;
	}

}