Spring注解-1.组件注册

目录

一、注解的引入

二、@Configuration/@Bean/@ComponentScan

三、@Scope/@Lazy

四、@Conditional/@Import/工厂Bean

---

一、注解的引入

        这是一个使用xml配置文件对spring进行配置注册Bean的例子：

    <context:property-placeholder location="classpath:person.properties"/>
	<!-- 包扫描、只要标注了@Controller、@Service、@Repository，@Component -->
	<context:component-scan base-package="com.anno" use-default-filters="false"/>
	<bean id="person" class="com.anno.bean.Person"  scope="prototype" >
		<property name="age" value="18"></property>
		<property name="name" value="zhangsan"></property>
	</bean>

        //方式1.配置文件
        ApplicationContext context1=new ClassPathXmlApplicationContext("beans.xml");
        Person bean1 = (Person) context1.getBean("person");
        System.out.println(bean1);

        我们可以采取注解的方式来实现：

@Configuration
public class MainConfig {

    @Bean("person")
    public Person Person(){
        return new Person("zhouping",18);
    }

        //方式2.注解（配置类）
        AnnotationConfigApplicationContext context2 = new AnnotationConfigApplicationContext(MainConfig.class);
        Person bean2 = (Person) context2.getBean("person");
        System.out.println(bean2);

二、@Configuration/@Bean/@ComponentScan

        @Configuration ：指明这是一个Spring配置类

        @ComponentScan : 开启组件扫描。参数：

                value（默认）- 包路径

                excludeFilters - 排除哪些组件

                includeFilters - 包含哪些组件

                （还可以自定义过滤的规则，这里不演示了）

        也可以使用 @ComponentScans 注解，对不同的包配置不同的组件扫描策略：

@ComponentScans( value = { 
    @ComponentScan(value="com.anno",includeFilters = {             
        @ComponentScan.Filter(type=FilterType.ANNOTATION,classes={Controller.class}),     
        @ComponentScan.Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}), 
        @ComponentScan.Filter(type= FilterType.CUSTOM,classes={MyTypeFilter.class}) },useDefaultFilters = false) } )

        @Bean ：注册Bean  ，参数：

                value（默认）- 指定id，默认是方法名 

                initMethod - 指定初始化时执行的方法

                destroyMethod - 指定销毁时执行的方法

示例：

@ComponentScan("com.anno")
@Configuration
public class MainConfig {
    @Bean("person")
    public Person Person(){
        return new Person("zhouping",18);
    }
}

三、@Scope/@Lazy

        @Scope ：设置Bean作用域，参数：

                prototype-多实例（懒汉式）

                singleton-单实例（默认，饿汉式）

                request-每次请求创建一个

                session-同一个session创建一个实例

                application：在当前web应用范围内有效

                socket：每一次 WebSocket 会话产生一个新的 bean

        @Lazy ：开启Bean的懒加载。

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

可以在@Bean上加注解@Lazy 设置Bean懒加载

示例：

    @Lazy
    @Bean("person")
    @Scope("Singleton")
    public Person Person(){
        return new Person("zhouping",18);
    }

四、@Conditional/@Import/工厂Bean

        @Conditional ：按照一定的条件进行判断，满足条件给容器中注册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);
    }

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

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

        @Import ：快速给容器中导入一个组件。

                容器中就会自动注册这个组件，id默认是全类名

                ImportSelector: 返回需要导入的组件的全类名数组；

                ImportBeanDefinitionRegistrar: 手动注册bean到容器中。

        示例：

//自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {

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

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）：也用于给容器中注册组件。

1）、默认获取到的是工厂bean调用getObject创建的对象
2）、要获取工厂Bean本身，我们需要给id前面加一个&

        示例：

         FactoryBean的实现类：

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

	AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
    Object bean3 = applicationContext.getBean("colorFactoryBean");//Color类型
	Object bean4 = applicationContext.getBean("&colorFactoryBean");//colorFactoryBean类型