课程Spring注解驱动学习笔记（二） 注册组件-及组件导入

@Scope-设置组件作用域

beans.xml中可以添加scope属性修改组件的作用域

<bean id="person" class="com.atguigu.bean.Person"  scope="prototype" >
	<property name="age" value="18"></property>
	<property name="name" value="zhangsan"></property>
</bean>

@Scope调整作用域

• prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。每次获取的时候才会调用方法创建对象；
• singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。以后每次获取就是直接从容器（map.get()）中拿；
• request：同一次请求创建一个实例；
• session：同一个session创建一个实例。

@Scope("prototype")
@Bean("person")
public Person person(){
	return new Person("张三", 25);
}

 

@Lazy-bean懒加载

懒加载：单实例bean：默认在容器启动的时候创建对象；
容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；

@Lazy
@Bean("person")
public Person person() {
	return new Person("张三", 25);
}

 

@Conditional-按照条件注册bean

@Conditional({Condition}) ： 按照一定的条件进行判断，满足条件给容器中注册bean
添加两个bean：如果系统是windows，给容器中注册("bill")
如果是linux系统，给容器中注册("linus")

@Conditional(WindowsCondition.class)
@Bean("bill")
public Person person01() {
	return new Person("Bill Gates", 62);
}

@Conditional(LinuxCondition.class)
@Bean("linus")
public Person person02() {
	return new Person("linus", 48);
}

创建一个类LinuxCondition.class实现Condition接口

//判断是否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.class实现Condition接口

//判断是否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;
	}
}

测试类

@Test
public void test03() {
	String[] namesForType = applicationContext.getBeanNamesForType(Person.class);
	ConfigurableEnvironment environment = applicationContext.getEnvironment();
	//动态获取环境变量的值；Windows 7
	String property = environment.getProperty("os.name");
	System.out.println(property);
	for (String name : namesForType) {
		System.out.println(name);
	}
	Map<String, Person> persons = applicationContext.getBeansOfType(Person.class);
	System.out.println(persons);
}

运行结果

Windows 7
bill
{bill=Person [name=Bill Gates, age=62]}

修改环境变量，运行结果如下

linux
linus
{linus=Person [name=linus, age=48]}

@Conditional注解不止可以添加到方法上还可以添加到类上，作用于类的所有方法。

 

给容器中快速导入一个组件

给容器中注册组件；
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

@Import

@Import({ Color.class, Red.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class })

 MyImportSelector.java

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

MyImportBeanDefinitionRegistrar.java

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

使用FactoryBean

创建一个bean

@Bean
public ColorFactoryBean colorFactoryBean() {
	return new ColorFactoryBean();
}

//创建一个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;
	}
}