Spring学习笔记二、@Scope、@Lazy、@Conditional 说明及代码实现

一、说明

package com.hao.config;

import com.hao.bean.Person;
import com.hao.condition.LinuxCondition;
import com.hao.condition.MacOSXCondition;
import org.springframework.context.annotation.*;

/**
 * @author haoxiansheng
 * @date 2020-05-28
 */
@Configuration
//@Conditional({MacOSXCondition.class}) 配置在类上满足条件这个类中的所有bean才会加载到容器中
public class MainConfig2 {

    /**
     * 默认都是单实例的
     * @return
     * 1、@Scope
     * 1）prototype:多实例的 IOC容器并不会去调用方法去创建对象在容器中，每次获取的时候才会调用方法创建对象
     * 2）singleton:单实例的（默认值）IOC 容器启动会调用方法创建对象放到IOC 容器中
     *           以后每次获取从容器中拿
     *
     *  2、懒加载：单实例bean,默认在容器启动的时候创建对象
     *            懒加载：容器启动不会创建对象，第一次获取Bean 创建对象，并初始化。
     */
    //@Scope("prototype")
    @Lazy
    @Bean("person")
    public Person person() {
        System.out.println("给容器中添加person..."); // 生产环境用打日志的方式
        return new Person("lisi", 3);
    }

    /**
     * 1、@Conditional({condition})：按照一定的条件判断，满足条件给容器中注册bean
     */
    @Conditional({MacOSXCondition.class})
    @Bean("haoxiansheng")
    public Person person01() {
        return new Person("haoxiansheng", 24);
    }
    @Conditional({LinuxCondition.class})
    @Bean("shahaizi")
    public Person person02() {
        return new Person("shahaizi", 24);
    }
}


二、测试
package com.hao.test;

import com.hao.bean.Person;
import com.hao.config.MainConfig;
import com.hao.config.MainConfig2;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.core.env.Environment;

import java.util.Map;

/**
 * @author haoxiansheng
 * @date 2020-05-28
 */
public class IOCTest {
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);

    @SuppressWarnings("resource")
    @Test
    public void testo1() {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String name : beanDefinitionNames) {
            System.out.println(name);
        }
        Object person = applicationContext.getBean("person");
        Object person1 = applicationContext.getBean("person");
        System.out.println(person1);
    }

    @SuppressWarnings("resource")
    @Test
    public void test02() {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
        System.out.println("ioc容器创建完成");
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for(String name: beanDefinitionNames) {
            System.out.println(name);
        }

        Object person = applicationContext.getBean("person");
        Object person1 = applicationContext.getBean("person");
    }

    @SuppressWarnings("resource")
    @Test
    public void test03() {
        String[] beanNamesForType = applicationContext.getBeanNamesForType(Person.class);
        for (String name: beanNamesForType) {
            System.out.println(name);
        }
        Environment environment = applicationContext.getEnvironment();
        System.out.println(environment.getProperty("os.name"));
        Map<String, Person> beansOfType = applicationContext.getBeansOfType(Person.class);
        System.out.println(beansOfType);
    }

}


三、三个Conditional
package com.hao.condition;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

/**
 * @author haoxiansheng
 * @date 2020-05-28
 */
public class LinuxCondition implements Condition {
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        Environment environment = conditionContext.getEnvironment();
        return environment.getProperty("os.name").contains("Linux");
    }
}




package com.hao.condition;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

/**
 * @author haoxiansheng
 * @date 2020-05-28
 */
public class MacOSXCondition implements Condition {

    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        Environment environment = conditionContext.getEnvironment();
        return environment.getProperty("os.name").contains("Mac OS X");
    }
}



package com.hao.condition;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;

import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

/**
 * @author haoxiansheng
 * @date 2020-05-28
 */
public class WindowsCondition implements Condition {
    /**
     *
     * @param conditionContext 能使用的上下文环境
     * @param annotatedTypeMetadata 当前标注了Condition的注解信息
     * @return
     */
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        // 是否为Windows 系统
        // 1、获取到ioc使用的beanFactory 工厂
        ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
        // 2、获取类加载器
        ClassLoader classLoader = conditionContext.getClassLoader();
        // 3、获取环境变量
        Environment environment = conditionContext.getEnvironment();
        // 4、获取到bean定义的注册类
        BeanDefinitionRegistry registry = conditionContext.getRegistry();
        // 5、判断容器中的注册情况
        boolean person = registry.containsBeanDefinition("person");
        String property = environment.getProperty("os.name");
        return  property.contains("Windows");
    }
}

说明Person代码 在上一节中有