Spring元件註冊

是倩倩不是欠欠發表於2021-02-15
Spring元件

Spring元件註冊

@Configuration

@Configuration註解告訴Spring這是一個配置類

@Bean

@Bean註解是給容器中註冊一個Bean，型別是返回值的型別，id預設是方法名作為id

    @Bean("person")
    public Person person2(){
        System.out.println("create a new bean of person");
        return new Person();
    }

@ComponentScan

@ComponentScan(value = "com.eric",excludeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class, Service.class})

@ComponentScan 的屬性

  • value：指定要掃描的包
  • excludeFilters = Filter[]:指定掃描的時候按照什麼規則排除哪些元件
  • includeFilters = Filter[]:指定掃描的時候只需要包含哪些元件
/**
 * Description: spring-parent
 * 配置類==配置檔案
 *
 * @author caoqianqian
 * @date 2021/2/14
 */
@Configuration //告訴Spring這是一個配置類
@ComponentScan(value = "com.eric",excludeFilters = {
		@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class, Service.class})
})
public class MainConfig {

	//給容器中註冊一個Bean，型別是返回值的型別，id預設是方法名作為id
	@Bean
	public Person person(){
		return new Person("testName",20);
	}
}

@Scope

通過@Scope註解來制定該bean的作用範圍，也可以說是調整作用域,ioc容器中載入的元件預設是單例項的。

作用域範圍即value的可取值範圍

  • prototype 多例項的：ioc容器啟動並不會去呼叫方法建立物件放到容器中，每次獲取的時候才會呼叫方法建立物件。
  • singleton 單例項的（預設值）：
    ioc容器啟動時會呼叫方法建立物件，放到ioc容器中，以後每次獲取就是從容器中(map.get())拿
  • request 同一次請求建立一個例項
  • session 同一個session建立一個例項
//通過@Scope註解來制定該bean的作用範圍，也可以說是調整作用域
        @Scope("singleton")
	@Bean("person")
	public Person person() {
		System.out.println("I'm creating an instance Person");
		return new Person("Person", 28);
	}

@Lazy 懶載入

單例項bean：預設在容器啟動的時候建立物件。
懶載入：容器啟動不建立物件，第一次使用（獲取）bean時建立物件，並初始化。

單例項bean加上懶載入的註解之後容器啟動時不建立物件，第一次使用時才會去建立物件並初始化。

    @Bean("person")
    @Lazy
    public Person person2(){
        System.out.println("create a new bean of person");
        return new Person();
    }

@Conditional

@Conditional按照一定的條件進行判斷，滿足條件給容器中註冊bean

標在方法上，表示這個方法滿足一定條件才會生效。

標在類上，類中元件統一設定，表示滿足當前條件，這個類中配置的所有bean註冊才會生效

判斷是否是Linux系統

public class LinuxCondition implements Condition {
	/**
	 *判斷是否是Linux系統
	 * @param conditionContext 判斷條件能使用的上下文（環境）
	 * @param annotatedTypeMetadata 當前標註註解的註釋資訊
	 * @return
	 */
	@Override
	public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
		//能獲取到ioc使用的beanFactory
		ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
		//獲取類載入器
		ClassLoader classLoader = conditionContext.getClassLoader();
		//獲取當前環境資訊
		Environment environment = conditionContext.getEnvironment();
		//獲取bean定義的註冊類
		BeanDefinitionRegistry registry = conditionContext.getRegistry();

		//判斷容器中bean的註冊情況
		boolean definition = registry.containsBeanDefinition("person");
		RootBeanDefinition beanDefinition = new RootBeanDefinition(Person.class);
		//給容器中註冊bean
		registry.registerBeanDefinition("person2",beanDefinition);
		String property = environment.getProperty("os.name");

		if(property.contains("linux")){
			return true;
		}
		return false;
	}
}

判斷是否是Windows系統

public class WindowsCondition implements Condition {
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        Environment environment = conditionContext.getEnvironment();
        String osName = environment.getProperty("os.name");
        if (osName.contains("Windows")){
            return true;
        }
        return false;
    }
}

配置類

@Configuration
public class MainConfig2 {
    /**
     *Conditional({Condition}):按照一定的條件進行判斷，滿足條件給容器中註冊bean
     * 如果系統是windows，給容器中註冊("bill")
     * 如果系統是linux，給容器中註冊("linus")
     * @return
     */
    @Conditional({WindowsCondition.class})
    @Bean("bill")
    public Person person(){
        return new Person("Bill Gates",62);
    }

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

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

測試方法

        @Test
	public void testCondition() {
		AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MainConfig2.class);
		ConfigurableEnvironment environment = ac.getEnvironment();
		String[] beanNamesForType = ac.getBeanNamesForType(Person.class);
		//動態獲取環境變數的值：windows 7
		String property = environment.getProperty("os.name");
		System.out.println(property);
		for (String p:beanNamesForType) {
			System.out.println(p);
		}
	}

執行結果如下,Windows 7的系統所以bill註冊了進來

Windows 7
bill
person2

@Import

快速匯入元件，id預設是元件的全類名

配置類上加了@Import註解

@Configuration
@Import({Color.class, Dog.class})
public class MainConfig2 {
    /**
     *Conditional({Condition}):按照一定的條件進行判斷，滿足條件給容器中註冊bean
     * 如果系統是windows，給容器中註冊("bill")
     * 如果系統是linux，給容器中註冊("linus")
     * @return
     */
    @Conditional({WindowsCondition.class})
    @Bean("bill")
    public Person person(){
        return new Person("Bill Gates",62);
    }

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

測試方法

        @Test
	public void testImport() {
		AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MainConfig2.class);
		String[] beanNamesForType = ac.getBeanDefinitionNames();
		for (String p:beanNamesForType) {
			System.out.println(p);
		}
	}

執行結果：除了內部的bean，Color和Dog也被註冊進來了

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
mainConfig2
com.eric.bean.Color
com.eric.bean.Dog
bill
person2

@Import使用ImportSelector

//自定義邏輯返回需要匯入的元件
public class MyImportSelector implements ImportSelector {
    //返回值就是匯入到容器中的元件的全類名
    //AnnotationMetadata 當前標註@Import註解類的所有註解資訊
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        Set<String> annotationTypes = annotationMetadata.getAnnotationTypes();
         for(String str : annotationTypes){
            System.out.println("===="+str);
        }

        return new String[]{"com.eric.bean.Blue","com.eric.bean.Red"};
    }
}

@Import註解加上自定義的元件MyImportSelector

@Configuration
@Import({Color.class, Dog.class,MyImportSelector.class})
public class MainConfig2 {
    /**
     *Conditional({Condition}):按照一定的條件進行判斷，滿足條件給容器中註冊bean
     * 如果系統是windows，給容器中註冊("bill")
     * 如果系統是linux，給容器中註冊("linus")
     * @return
     */
    @Conditional({WindowsCondition.class})
    @Bean("bill")
    public Person person(){
        return new Person("Bill Gates",62);
    }

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

}

測試方法

        @Test
	public void testImport() {
		AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MainConfig2.class);
		String[] beanNamesForType = ac.getBeanDefinitionNames();
		for (String p:beanNamesForType) {
			System.out.println(p);
		}
	}

執行結果：Blue Red 都被註冊進來了

====org.springframework.context.annotation.Configuration
====org.springframework.context.annotation.Import
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
mainConfig2
com.eric.bean.Color
com.eric.bean.Dog
com.eric.bean.Blue
com.eric.bean.Red
bill
person2

@Import使用ImportBeanDefinitionRegistrar

手動註冊bean到容器中

//要被註冊的bean
public class Rainbow {
}

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    /**
     *
     * @param importingClassMetadata    當前類的註解資訊
     * @param registry                  BeanDefinition註冊類
     *        把所有需要新增到容器中的bean，呼叫
     *        BeanDefinitionRegistry.registerBeanDefinition手工註冊進來
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        boolean blueDefinition = registry.containsBeanDefinition("com.eric.bean.Blue");
        if (blueDefinition){
            //指定bean的定義資訊
            RootBeanDefinition beanDefinition = new RootBeanDefinition(Rainbow.class);
            //註冊一個bean，指定bean名
            registry.registerBeanDefinition("rainbow", beanDefinition);
        }
    }
}

配置類：@Import加入了中MyImportBeanDefinitionRegistrar

@Configuration
@Import({Color.class, Blue.class,MyImportBeanDefinitionRegistrar.class})
public class MainConfig2 {
    
}

測試方法：

        @Test
	public void testImport() {
		AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MainConfig2.class);
		String[] beanNamesForType = ac.getBeanDefinitionNames();
		for (String p:beanNamesForType) {
			System.out.println(p);
		}
	}

執行結果：邏輯判斷Blue存在所以rainbow被註冊了進來

mainConfig2
com.eric.bean.Blue
bill
person2
rainbow

使用FactoryBean註冊元件

使用spring提供的FactoryBean（工廠Bean）

建立一個ColorFactoryBean實現FactoryBean介面：

//建立一個Spring定義的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {

    /**
     * 返回一個Color物件,這個物件會新增到容器中
     * @return
     * @throws Exception
     */
    @Override
    public Color getObject() throws Exception {
        System.out.println("ColorFactoryBean=========getObject=====");
        return new Color();
    }

    /**
     * 返回的bean型別
     * @return
     */
    @Override
    public Class<Color> getObjectType() {
        return Color.class;
    }

    /**
     * 是否單例
     * 返回true代表是單例項,在容器中儲存一份
     * false是多例項，每次獲取都會建立一個新的bean
     * @return
     */
    @Override
    public boolean isSingleton() {
        return true;
    }
}

配置類裡註冊該工廠bean

@Configuration
public class MainConfig2 {

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

測試方法：

        @Test
	public void testFactoryBean() {
		AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MainConfig2.class);
		//工廠bean獲取的是呼叫getObject()方法建立的物件
		Object bean1 = ac.getBean("colorFactoryBean");
		Object bean2 = ac.getBean("colorFactoryBean");

		System.out.println("bean的型別："+bean1.getClass());
		//單例項返回true  多例項返回false
		System.out.println(bean1 == bean2);

		//預設獲取到的是工廠bean呼叫getObejct建立的物件
		//要獲取工廠bean本身，我們需要給id前面加一個&標識
		Object bean3 = ac.getBean("&colorFactoryBean");
		System.out.println("bean3的型別："+bean3.getClass());

	}

執行結果： 單例項獲取到的是相同的bean，加&之後獲取到的bean為ColorFactoryBean

ColorFactoryBean=========getObject=====
bean的型別：class com.eric.bean.Color
true
bean3的型別：class com.eric.condition.ColorFactoryBean

總結

給容器中註冊元件：

  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前面加一個&

ok，元件註冊完結，撒花。

相關文章