国产无码综合区,色欲AV无码国产永久播放,无码天堂亚洲国产AV,国产日韩欧美女同一区二区

Spring注解驅(qū)動開發(fā)之常用注解案例_告別在XML中配置Bean

2年前作者：小袁搬碼分類：Toy博客閱讀(27)違法舉報

這篇具有很好參考價值的文章主要介紹了Spring注解驅(qū)動開發(fā)之常用注解案例_告別在XML中配置Bean。希望對大家有所幫助。如果存在錯誤或未考慮完全的地方，請大家不吝賜教，您也可以點擊"舉報違法"按鈕提交疑問。

Spring注解驅(qū)動開發(fā)之常用注解案例

注解驅(qū)動開發(fā)就是不再使用Spring的bean.xml文件，改為純使用注解的方式開發(fā)

1. 組件注冊注解

1.1 @Configuration和@Bean注解

@Configuration

此注解為配置類注解，相當(dāng)于spring.xml文件，即配置類==配置文件
@Bean

給容器中注冊一個Bean;類型為返回值的類型，id默認是用方法名作為id

示例

package com.yuan.annotation.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import com.yuan.annotation.bean.Person;

//配置類==配置文件
@Configuration  //告訴Spring這是一個配置類
public class MainConfig {
	//給容器中注冊一個Bean;類型為返回值的類型，id默認是用方法名作為id
	@Bean("person")
	public Person personA() {
		return new Person(1,"張三",33);
	}
}

Person類(后續(xù)注解配置類中都會以此類舉例),Person.java

package com.yuan.annotation.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
@NoArgsConstructor
@AllArgsConstructor
@Data
@ToString
public class Person {
	private Integer id;
	private String name;
	private Integer age;
}

測試類

package com.yuan.annotation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.yuan.annotation.bean.Person;
import com.yuan.annotation.config.MainConfig;

public class MainTest {
	private static ApplicationContext applicationContext;

	public static void main(String[] args) {
		applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
		/*
		 * Person person = applicationContext.getBean(Person.class);
		 * System.out.println(person);
		 */
		
		String [] nameTypes =  applicationContext.getBeanNamesForType(Person.class);
		
		for(String s : nameTypes) {
			System.out.println(s);
		}
		
		Person person = (Person) applicationContext.getBean("person");
		System.out.println(person);
	}
}

1.2 自動掃描組件和指定掃描規(guī)則

@ComponentScan 自動掃描組件注解，jdk8+版本，此注解可以在同一個類上多寫幾次，jdk8以下版本可以使用@ComponentScans注解

jdk8+版本示例

//配置類==配置文件
@Configuration  //告訴Spring這是一個配置類
@ComponentScan(value = "com.yuan.annotation",includeFilters= {
		@Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
},useDefaultFilters=false) //指定要掃描的包
@ComponentScan(.....)
@ComponentScan(.....)
@ComponentScans(value = { @ComponentScan(value="xx.xxx") })
public class MainConfig {
	//給容器中注冊一個Bean;類型為返回值的類型，id默認是用方法名作為id
	@Bean("person")
	public Person personA() {
		return new Person(1,"張三",33);
	}
}

jdk8以下版本示例

//配置類==配置文件
@Configuration  //告訴Spring這是一個配置類
@ComponentScans(value = { @ComponentScan(value="xx.xxx") })
public class MainConfig {
	...
}

value：數(shù)組類型，指定要掃描的包
includeFilters：Filter數(shù)組類型，指定掃描時包含哪些組件,使用此屬性時，@ComponentScan的useDefaultFilters屬性值設(shè)置false才能起作用，即useDefaultFilters=false；useDefaultFilters=true為默認值，掃描所有
excludeFilters：Filter數(shù)組類型，指定掃描時排除哪些組件

package com.yuan.annotation.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;
import org.springframework.context.annotation.ComponentScan.Filter;

import com.yuan.annotation.bean.Person;

//配置類==配置文件
@Configuration  //告訴Spring這是一個配置類
//@ComponentScan(value= {"com.yuan.annotation.bean","com.yuan.annotation.dao","com.yuan.annotation.service"})
@ComponentScan(value = "com.yuan.annotation",includeFilters= {
		@Filter(type = FilterType.ANNOTATION,classes = Controller.class)
}) //指定要掃描的包


public class MainConfig {
	//給容器中注冊一個Bean;類型為返回值的類型，id默認是用方法名作為id
	@Bean("person")
	public Person personA() {
		return new Person(1,"張三",33);
	}
}

1.3 自定義TypeFilter指定過濾規(guī)則

FilterType.ANNOTATION:按照注解(常用)
FilterType.ASSIGNABLE_TYPE：按照指定的類型(常用)
FilterType.ASPECTJ：使用ASPECTJ表達式
FilterType.CUSTOM：使用用戶自定義規(guī)則
FilterType.REGEX：使用正則表達式

自定義規(guī)則類，如：MyTypeFilter.java

自定義過濾規(guī)則類需要實現(xiàn)TypeFilter接口

package com.yuan.annotation.config;

import java.io.IOException;

import org.springframework.core.io.Resource;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;

public class MyTypeFilter implements TypeFilter {
    
	/*
	 * metadataReader:讀取到的當(dāng)前正在掃描的類
	 * metadataReaderFactory：可以獲取到其他任何類信息的
	 */
	@Override
	public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
			throws IOException {
		//獲取當(dāng)前類注解的信息
		AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
		//獲取當(dāng)前正在掃描的類的信息
		
		ClassMetadata classMetadata = metadataReader.getClassMetadata();
		
		//獲取當(dāng)前類資源(類的路徑)
		Resource resource = metadataReader.getResource();
		
		String className = classMetadata.getClassName();
		System.out.println("--->"+className);
        
		//如果className中包含er，表示匹配成功
		if(className.contains("er")) {
			return true;
		}
		return false;
	}
}

配置類，MainConfig.java

package com.yuan.annotation.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.ComponentScans;

import com.yuan.annotation.bean.Person;
import com.yuan.annotation.service.BookService;

//配置類==配置文件
@Configuration  //告訴Spring這是一個配置類
@ComponentScan(value = "com.yuan.annotation",includeFilters= {
		@Filter(type = FilterType.CUSTOM,classes = {MyTypeFilter.class})
},useDefaultFilters=false) //指定要掃描的包

@ComponentScans(value = { @ComponentScan(value="xx.xxx") })
public class MainConfig {
	//給容器中注冊一個Bean;類型為返回值的類型，id默認是用方法名作為id
	@Bean("person")
	public Person personA() {
		return new Person(1,"張三",33);
	}
}

測試類IOCTest.java

package com.yuan.annotation.test;

import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.yuan.annotation.config.MainConfig;

public class IOCTest {
	private AnnotationConfigApplicationContext applicationContext;

	@Test
	public void test01() {
		applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
		
		String [] definitionNames =  applicationContext.getBeanDefinitionNames();
		
		for(String beanName : definitionNames) {
			System.out.println(beanName);
		}
	}
}

打印結(jié)果：

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
mainConfig
person
myTypeFilter
bookController
bookService

1.4 @Scope設(shè)置組件的作用域

配置類，ScopeConfig.java

package com.yuan.annotation.config;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

import com.yuan.annotation.bean.Person;

@Configuration
public class ScopeConfig {
	/**
	 * @see ConfigurableBeanFactory#SCOPE_PROTOTYPE
	 * @see ConfigurableBeanFactory#SCOPE_SINGLETON
	 * @see org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST
	 * @see org.springframework.web.context.WebApplicationContext#SCOPE_SESSION
	 * 
	 * singleton: 單實例(默認),IOC容器啟動時會調(diào)用方法創(chuàng)建對象放到IOC容器中
	 * prototype: 多實例的，IOC啟動時不會去調(diào)用方法創(chuàng)建對象放在容器中，每次獲取的時候才會調(diào)用方法創(chuàng)建對象
	 * request: 同一次請求創(chuàng)建一個實例
	 * session: 同一次會話創(chuàng)建一個實例
	 * 
	 */
	@Scope("prototype")
	@Bean("person")
	public Person person() {
		System.out.println("給容器中添加Person對象....");
		return new Person(1,"張三",22);
	}
}

測試類，IOCTest.java

package com.yuan.annotation.test;

import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.yuan.annotation.bean.Person;
import com.yuan.annotation.config.MainConfig;
import com.yuan.annotation.config.ScopeConfig;

public class IOCTest {
	private AnnotationConfigApplicationContext applicationContext;

	@Test
	public void test02() {
		applicationContext = new AnnotationConfigApplicationContext(ScopeConfig.class);
		/*
		 * String [] definitionNames = applicationContext.getBeanDefinitionNames();
		 * for(String beanName : definitionNames) { System.out.println(beanName); }
		 */
		  //默認為單實例的 
		  Person person = (Person) applicationContext.getBean("person");
		  Person person2 = (Person) applicationContext.getBean("person");
		  System.out.println(person == person2);
	}
}

1.5 @Lazy注解，bean懶加載注解

package com.yuan.annotation.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

import com.yuan.annotation.bean.Person;

@Configuration
public class LazConfig {
	
	/**
	 * @Lazy:懶加載，針對scope為單實例的bean而言
	 * 單實例bean，默認容器啟動的時候創(chuàng)建
	 * 懶加載：容器啟動時不創(chuàng)建對象，第一次使用(獲取)Bean對象，并初始化
	 * @return
	 */
	@Lazy
	@Bean
	public Person person() {
		return new Person(1,"張三",22);
	}
}

1.6 @Conditional-按照條件注冊bean

@Conditional({Condation}) : 按照一定的條件進行判斷，滿足條件給容器中注冊bean

案例:根據(jù)操作系統(tǒng)的創(chuàng)始人來實例對應(yīng)的Person

需要定義兩個Condition類，如LinuxCondition.java和WindowsCondition.java

LinuxCondition.java和WindowsCondition.java必須實現(xiàn)Condition接口
WindowsCondition.java

package com.yuan.annotation.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;

/**
 * 判斷是否為Windows系統(tǒng)
 * @author jinshengyuan
 *
 */
public class WindowsCondition implements Condition{
	/**
	 * ConditionContext : 判斷條件能使用的上下文(環(huán)境)
	 * AnnotatedTypeMetadata : 注解信息
	 */
	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		//判斷是否Linux系統(tǒng)
		//1.能獲取到IOC使用的beanFactory
		ConfigurableListableBeanFactory beanFactory =  context.getBeanFactory();
		
		//2.獲取類加載器
		ClassLoader classLoader = context.getClassLoader();
		
		//3.獲取當(dāng)前環(huán)境信息
		Environment environment = context.getEnvironment();
		
		//4.獲取bean定義的注冊類
		BeanDefinitionRegistry registry = context.getRegistry();
		//可以判斷容器中的bean注冊情況,也可以給容器中注冊bean
		boolean beanDefinition = registry.containsBeanDefinition("person");
		
		String property = environment.getProperty("os.name");
		
		//如果property中包含Windows，則返回true
		if(property.contains("Windows")) {
			return true;
		}		
		return false;
	}
}

LinuxCondition.java

package com.yuan.annotation.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;

/**
 * 判斷是否為Linux系統(tǒng)
 * @author jinshengyuan
 *
 */
public class LinuxCondition implements Condition {
    
	/**
	 * ConditionContext : 判斷條件能使用的上下文(環(huán)境)
	 * AnnotatedTypeMetadata : 注解信息
	 */
	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		//判斷是否Linux系統(tǒng)
		//1.能獲取到IOC使用的beanFactory
		ConfigurableListableBeanFactory beanFactory =  context.getBeanFactory();
		
		//2.獲取類加載器
		ClassLoader classLoader = context.getClassLoader();
		
		//3.獲取當(dāng)前環(huán)境信息
		Environment environment = context.getEnvironment();
		
		//4.獲取bean定義的注冊類
		BeanDefinitionRegistry registry = context.getRegistry();
		//可以判斷容器中的bean注冊情況,也可以給容器中注冊bean
		boolean beanDefinition = registry.containsBeanDefinition("person");
		
		String property = environment.getProperty("os.name");
		
		//如果property中包含Linux，則返回true
		if(property.contains("Linux")) {
			return true;
		}
		
		return false;
	}
}

@Conditional注解配置類

package com.yuan.annotation.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

import com.yuan.annotation.bean.Person;
import com.yuan.annotation.condition.LinuxCondition;
import com.yuan.annotation.condition.WindowsCondition;

@Configuration
public class ConditionalConfig {
	
	/**
	 * @Conditional({Condation}) : 按照一定的條件進行判斷，滿足條件給容器中注冊bean
	 * @Conditional可以標(biāo)注在類上，也可以標(biāo)注在方法上
	 * 標(biāo)注在類上：類中組件統(tǒng)一設(shè)置，滿足當(dāng)前條件，這個類中配置的所有bean才能生效
	 * 需求:
	 * 如果系統(tǒng)是Windows，給容器中注冊("bill")
	 * 如果是Linux系統(tǒng)，給容器中注冊("linus")
	 */
    //如果為Windows系統(tǒng)則實例化bill類
	@Conditional({WindowsCondition.class})
	@Bean("bill")
	public Person person() {
		return new Person(1,"Bill Gates",65);
	}
	//如果為Linx系統(tǒng)則實例化linus類
	@Conditional({LinuxCondition.class})
	@Bean("linus")
	public Person person1() {
		return new Person(1,"linus",48);
	}
}

測試類

package com.yuan.annotation.test;

import java.util.Map;

import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

import com.yuan.annotation.bean.Person;
import com.yuan.annotation.config.ConditionalConfig;
import com.yuan.annotation.config.MainConfig;
import com.yuan.annotation.config.ScopeConfig;

public class IOCTest {
	private AnnotationConfigApplicationContext applicationContext;
	
	@Test
	public void test03() {
		applicationContext = new AnnotationConfigApplicationContext(ConditionalConfig.class);
		ConfigurableEnvironment environment =  applicationContext.getEnvironment();
		//動態(tài)獲取環(huán)境變量的值：Windows 10
		String osName = environment.getProperty("os.name");
		System.out.println(osName);
		
		//獲取已定義的bean
		String [] definitionNames = applicationContext.getBeanDefinitionNames();
		for(String beanName : definitionNames) {
			System.out.println(beanName); 			  
		}
		  
		Map<String, Person> map = applicationContext.getBeansOfType(Person.class);
		System.out.println(map);
	}
}

輸出結(jié)果

由于是Windows 10，則只有bill類被實例化

Windows 10
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
conditionalConfig
bill
{bill=Person(id=1, name=Bill Gates, age=65)}

2. 給容器中注冊組件的方式

2.1 包掃描+組件標(biāo)注注解

@Controller/@Service/@Repository/@Component）[只適用于自己寫的類]

2.2 @Bean

[導(dǎo)入的第三方包里面的組件]

2.3 @Import[快速給容器中導(dǎo)入一個組件]

2.3.1 @Import(要導(dǎo)入到容器中的組件)

容器中就會自動注冊這個組件，id默認是全類名(如下面的com.yuan.bean.Color)

定義一個Color.java類

package com.yuan.bean;

/**
 * color 類
 */
public class Color {
}

在ColorMainConfig.java中使用@Import注解向容器中注入Color類

package com.yuan.config;

import com.yuan.bean.Color;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

/**
 * @Author: Jinsheng·yuan
 * @CreateDate: 2020/1/14 21:59
 * @Description: 使用@Import 注冊組件
 */
@Configuration
@Import(Color.class) //注入單個組件
//@Import({Color.class,Red.class}) //注入多個組件
public class ColorMainConfig {
}

單元測試

package com.yuan.test;

import com.yuan.config.ColorMainConfig;
import com.yuan.config.MainConfig;
import com.yuan.config.MyConfigTwo;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author: Jinsheng·yuan
 * @CreateDate: 2020/1/14 21:59
 * @Description: 使用@Import 注冊組件
 */
public class IOCTest {
    private AnnotationConfigApplicationContext applicationContext;

    /**
     * 使用@Import注解向容器注入組件測試 
     */
    @Test
    public void testImport(){
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ColorMainConfig.class);
        printBeans(applicationContext);
    }
    /**
     * 打印IOC中注入的所有組件
     * @param applicationContext
     */
    public void printBeans(AnnotationConfigApplicationContext applicationContext ){
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
    }
}

測試打印結(jié)果

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
colorMainConfig #自定義配置類bean
com.yuan.bean.Color #注入組件(bean)的全類名

2.3.2 ImportSelector:返回需要導(dǎo)入的組件的全類名數(shù)組；

自定義邏輯返回要導(dǎo)入的組件，需要實現(xiàn)ImportSelector接口,結(jié)合@Import注解一起使用

自定義MyImportSelector.java

package com.yuan.condition;

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

/**
 * @Author: Jinsheng·yuan
 * @CreateDate: 2020/1/14 22:15
 * @Description: 實現(xiàn)ImportSelector接口來自定義邏輯返回要導(dǎo)入的組件
 */
public class MyImportSelector implements ImportSelector {
    /**
     *
     * @param importingClassMetadata 當(dāng)前標(biāo)注@Import注解的類的所有注解信息
     * @return 返回值就是導(dǎo)入容器中的組件的全類名
     */
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        //可獲取標(biāo)注@Import注解類的所有注解信息
        System.out.println("importingClassMetadata.getClassName():"+importingClassMetadata.getClassName());
        System.out.println("importingClassMetadata.getAnnotations():"+importingClassMetadata.getAnnotations());

        //return new String[0]; //這里不能返回null,可以返回一個空數(shù)組
        return new String[]{"com.yuan.bean.Blue","com.yuan.bean.Yellow"};//導(dǎo)入容器中的組件的全類名
    }
}

配置類

package com.yuan.config;

import com.yuan.bean.Color;
import com.yuan.condition.MyImportSelector;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

/**
 * @Author: Jinsheng·yuan
 * @CreateDate: 2020/1/14 21:59
 * @Description: 使用@Import 注冊組件
 */
@Configuration
@Import({Color.class, MyImportSelector.class})
public class ColorMainConfig {
}

IOCTest.java測試結(jié)果

mportingClassMetadata.getClassName():com.yuan.config.ColorMainConfig
importingClassMetadata.getAnnotations():org.springframework.core.annotation.TypeMappedAnnotations@36b4fe2a
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
colorMainConfig
com.yuan.bean.Color
com.yuan.bean.Blue
com.yuan.bean.Yellow

2.3.3 ImportBeanDefinitionRegistrar:手動注冊bean到容器中

通過實現(xiàn)ImportBeanDefinitionRegistrar接口，手動注冊bean到容器中,需要結(jié)合**@Import注解使用**文章來源地址http://www.zghlxwxcb.cn/news/detail-811121.html

MyImportBeanDefinitionRegistrar.java

package com.yuan.condition;

import com.yuan.bean.Student;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

/**
 * @Author: Jinsheng·yuan
 * @CreateDate: 2020/1/14 22:48
 * @Description: 通過實現(xiàn)ImportBeanDefinitionRegistrar接口,手動注冊bean到容器中
 */
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    /**
     *
     * @param importingClassMetadata 當(dāng)前類的注解信息
     * @param registry BeanDefinition注冊類
     * @param importBeanNameGenerator
     */
   /* @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
		//此方法還未理解透
    }*/

    /**
     *
     * @param importingClassMetadata 當(dāng)前類的注解信息
     * @param registry BeanDefinition注冊類，
     *        把所有需要添加到容器中的Bean，用 registry.registerBeanDefinition()手工注冊進來
     *
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //registry.registerBeanDefinition();
        boolean red = registry.containsBeanDefinition("com.yuan.bean.Red");
        boolean blue = registry.containsBeanDefinition("com.yuan.bean.Blue");
        //如果存在Red與Blue類,則注冊自定義的student類
        if(red && blue){
            //指定bean的定義信息(就是Bean的類型)
            RootBeanDefinition beanDefinition = new RootBeanDefinition(Student.class);
            //自定義bean的名字為student
            registry.registerBeanDefinition("student",beanDefinition);
        }
    }
}

配置類ColorMainConfig.java

package com.yuan.config;

import com.yuan.bean.Color;
import com.yuan.bean.Red;
import com.yuan.condition.MyImportBeanDefinitionRegistrar;
import com.yuan.condition.MyImportSelector;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

import javax.swing.text.rtf.RTFEditorKit;

/**
 * @Author: Jinsheng·yuan
 * @CreateDate: 2020/1/14 21:59
 * @Description: 使用@Import 注冊組件
 */
@Configuration
@Import({Color.class, Red.class,MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
public class ColorMainConfig {
}

測試結(jié)果

importingClassMetadata.getClassName():com.yuan.config.ColorMainConfig
importingClassMetadata.getAnnotations():org.springframework.core.annotation.TypeMappedAnnotations@574b560f
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
colorMainConfig
com.yuan.bean.Color
com.yuan.bean.Red
com.yuan.bean.Blue
com.yuan.bean.Yellow
student  #手工注冊到容器的bean

3.使用Spring提供的 FactoryBean（工廠Bean）;

3.1 默認獲取到的是工廠bean調(diào)用getObject創(chuàng)建的對象

3.2 要獲取工廠Bean本身，要獲取工廠Bean本身，我們需要給id前面加一個&,如：&colorFactoryBean

自定義ColorFactorBean.java，實現(xiàn)FactoryBean接口

package com.yuan.bean;

import org.springframework.beans.factory.FactoryBean;

/**
 * @Author: Jinsheng·yuan
 * @CreateDate: 2020/1/14 23:15
 * @Description: 創(chuàng)建一個Spring定義的FactoryBean
 */
public class ColorFactorBean implements FactoryBean<Color> {
    /**
     * 是單例么？
     * true:是，這個bean在容器中只會保留一份；
     * false: 多實例，每次都會創(chuàng)建一個新的bean
     * @return
     */
    @Override
    public boolean isSingleton() {
        return false;
    }

    /**
     *
     * @return
     * @throws Exception
     */
    @Override
    public Color getObject() throws Exception {
        return new Color();
    }

    /**
     * 返回一個Color對象，這個對象會創(chuàng)建到容器中
     * @return
     */
    @Override
    public Class<?> getObjectType() {
        return Color.class;
    }
}

主配置類中注冊ColorFactorBean

package com.yuan.config;

import com.yuan.bean.Color;
import com.yuan.bean.ColorFactorBean;
import com.yuan.bean.Red;
import com.yuan.condition.MyImportBeanDefinitionRegistrar;
import com.yuan.condition.MyImportSelector;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

import javax.swing.text.rtf.RTFEditorKit;

/**
 * @Author: Jinsheng·yuan
 * @CreateDate: 2020/1/14 21:59
 * @Description: 使用@Import 注冊組件
 */
@Configuration
@Import({Color.class, Red.class,MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
public class ColorMainConfig {

    /**
     * 注入ColorFactorBean對象
     * @return
     */
    @Bean
    public ColorFactorBean colorFactorBean(){
        return new ColorFactorBean();
    }
}

測試

package com.yuan.test;

import com.yuan.config.ColorMainConfig;
import com.yuan.config.MainConfig;
import com.yuan.config.MyConfigTwo;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author: Jinsheng·yuan
 * @CreateDate: 2020/1/14 21:59
 * @Description: 使用@Import 注冊組件
 */
public class IOCTest {
    private AnnotationConfigApplicationContext applicationContext;

    /**
     * 使用@Import注解向容器注入組件測試
     */
    @Test
    public void testImport(){
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ColorMainConfig.class);
        Object colorFactorBean = applicationContext.getBean("colorFactorBean");
        Object colorFactorBean1 = applicationContext.getBean("colorFactorBean");
        System.out.println(colorFactorBean == colorFactorBean1); //是否為同意對象
        //1. 獲取Bean的類型,默認獲取的的是工廠bean調(diào)用 getObject()對象創(chuàng)建的bean，如下獲取的為:com.yuan.bean.Color
        System.out.println("colorFactorBean的類型："+colorFactorBean.getClass());
        //2. 若要獲取工廠bean本身,則需要給bean的id前面加一個 & ,如&colorFactorBean
        Object factoryBean = applicationContext.getBean("&colorFactorBean");
        System.out.println("colorFactorBean本身的類型:"+factoryBean.getClass());
        printBeans(applicationContext);
    }

    /**
     * 打印IOC中注入的所有組件
     * @param applicationContext
     */
    public void printBeans(AnnotationConfigApplicationContext applicationContext ){
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
    }
}

測試結(jié)果

importingClassMetadata.getClassName():com.yuan.config.ColorMainConfig
importingClassMetadata.getAnnotations():org.springframework.core.annotation.TypeMappedAnnotations@574b560f
false
colorFactorBean的類型：class com.yuan.bean.Color
colorFactorBean本身的類型:class com.yuan.bean.ColorFactorBean
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
colorMainConfig
com.yuan.bean.Color
com.yuan.bean.Red
com.yuan.bean.Blue
com.yuan.bean.Yellow
colorFactorBean
student

到了這里，關(guān)于Spring注解驅(qū)動開發(fā)之常用注解案例_告別在XML中配置Bean的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！

本文來自互聯(lián)網(wǎng)用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務(wù)，不擁有所有權(quán)，不承擔(dān)相關(guān)法律責(zé)任。如若轉(zhuǎn)載，請注明出處：如若內(nèi)容造成侵權(quán)/違法違規(guī)/事實不符，請點擊違法舉報進行投訴反饋，一經(jīng)查實，立即刪除！

分享到：

領(lǐng)支付寶紅包贊助服務(wù)器費用

Spring注解驅(qū)動開發(fā)(二)
注：此筆記為尚硅谷Spring注解驅(qū)動教程(雷豐陽源碼級講解)學(xué)習(xí)筆記，并同時參考[https://blog.csdn.net/xjhqre/article/details/123264069]博主文章，其中包含個人的筆記和理解，僅做學(xué)習(xí)筆記之用。簡述： 1、實例化一個Bean－－也就是我們常說的new； 2、按照Spring上下文對實例化的Bean進
2024年02月03日
瀏覽(21)
spring注解驅(qū)動開發(fā)（二）
17、Bean的生命周期 bean的生命周期：bean的創(chuàng)建—初始化—銷毀的過程容器負責(zé)管理bean的生命周期我們可以自定義初始化和銷毀方法，容器在bean進行到當(dāng)前生命周期的時候來調(diào)用我們自定義的初始化和銷毀方法構(gòu)造（對象創(chuàng)建）單實例：在容器啟動時創(chuàng)建對象多實例：在每
2024年02月14日
瀏覽(20)
spring注解驅(qū)動開發(fā)（一）
Spring常用注解（絕對經(jīng)典） 1、需要導(dǎo)入的spring框架的依賴 2、@Configuration 設(shè)置類為配置類 3、AnnotationConfigApplicationContext 通過配置類獲取上下文環(huán)境applicationContext 可以通過getBeanDefinitionNames()獲得配置類中配置的各類Bean 也可以使用getBeanNamesForType()通過類型來獲得bean的name（id）
2024年02月14日
瀏覽(20)
Spring5學(xué)習(xí)隨筆-高級注解（@ComponentScan、@Configuration.....），替換XML配置文件
學(xué)習(xí)視頻：【孫哥說Spring5：從設(shè)計模式到基本應(yīng)用到應(yīng)用級底層分析，一次深入淺出的Spring全探索。學(xué)不會Spring？只因你未遇見孫哥】 Spring在3.x提供的新的注解，用于替換XML配置文件。問題：配置Bean在應(yīng)用的過程中替換了XML具體的什么內(nèi)容？ AnnotationConfigApplicationContext 配
2024年02月05日
瀏覽(20)
Spring CORS 跨域使用與原理(@CrossOrigin注解，Java配置類方式，xml方式)
出于安全原因，瀏覽器禁止AJAX調(diào)用當(dāng)前源之外的資源。跨域資源共享(CORS)是由大多數(shù)瀏覽器實現(xiàn)的W3C規(guī)范，它允許您以一種靈活的方式指定授權(quán)哪種跨域請求，而不是使用一些不太安全、功能不太強大的hack(如IFrame或JSONP)。 Spring Framework 4.2 GA為CORS提供了一流的開箱即用支持
2024年02月08日
瀏覽(21)
spring注解驅(qū)動開發(fā)（BEAN注冊方式與生命周期）
目錄容器中注冊BEAN的方式 BEAN生命周期包掃描+組件標(biāo)注注解 @ComponentScan(basePackages = {\\\"com.an.spring.condition\\\"}) @Service @Component @Controller @Repository @BEan方式【導(dǎo)入第三方包里面的組件】 @Import快速給容器中導(dǎo)入一個組件。 1）、@IMport（要導(dǎo)入到容器中的組件），容器就會注入這個組
2024年02月07日
瀏覽(48)
Spring-mvc的參數(shù)傳遞與常用注解的解答及頁面的跳轉(zhuǎn)方式---綜合案例
目錄一.slf4j--日志二.常用注解 ??? ? ?2.1.@RequestMapping ??????2.2.@RequestParam ??????2.3.@RequestBody ??????2.4.@PathVariable 三.參數(shù)的傳遞 3.1 基礎(chǔ)類型 3.2 復(fù)雜類型 3.3?@RequestParam 3.4? @PathVariable 3.5 @RequestBody 3.6 增刪改查? 四.返回值? ????????? 4.1 void 返回值? ?4.2 String
2024年02月09日
瀏覽(28)
[Java學(xué)習(xí)日記]日志、類加載器、XML、DTD與schema、XML解析、XPath、單元測試、Assert、BeforeAfter、注解、自定義注解、注解案例
下面的案例中只是做一個簡單的了解，不做深入理解啦目錄一.使用Logback寫日志二.類加載器三.XML 四.XML編寫規(guī)定：DTD與schema 五.XML解析六.XPath 七.單元測試七.Assert（斷言）：檢驗方法結(jié)果八.使用before與after注解備份與還原數(shù)據(jù) 九.注解十.自定義注解十一.注解案例：用注
2024年02月04日
瀏覽(29)
Spring5系列學(xué)習(xí)文章分享---第三篇（AOP概念+原理+動態(tài)代理+術(shù)語+Aspect+操作案例（注解與配置方式））
開篇: 歡迎再次來到 Spring 5 學(xué)習(xí)系列！在這個博客中，我們將深入研究 Spring 框架的AOP概念+原理+動態(tài)代理+術(shù)語+Aspect+操作案例（注解與配置方式）。概念什么是AOP （1）面向切面編程（方面），利用 AOP 可以對業(yè)務(wù)邏輯的各個部分進行隔離，從而使得業(yè)務(wù)邏輯各部分之間的
2024年01月24日
瀏覽(28)
企業(yè)級信息系統(tǒng)開發(fā)學(xué)習(xí)1.3——利用注解配置取代Spring配置文件
一、利用注解配置類取代Spring配置文件（一）打開項目 Maven項目 - SpringDemo （二）創(chuàng)建新包在net.huawei.spring包創(chuàng)建day03子包（三）拷貝類與接口將day02子包的類與接口拷貝到day03子包（四）創(chuàng)建注解配置類在day03子包里創(chuàng)建SpringConfig類，取代Spring配置文件 package net.huawei.spri
2024年02月09日
瀏覽(22)