【Spring】IOC容器註解匯總，你想要的都在這兒了！！

2020 年 9 月 9 日
筆記
spring

寫在前面

之前，我們在【Spring】專題中更新了不少關於Spring註解相關的文章，有些小夥伴反饋說，看歷史文章的話比較零散，經常會忘記自己看到哪一篇了。當打開一篇新文章時，總感覺自己似乎是看到過了，又感覺自己沒有看到過。那怎麼辦呢？為了小夥伴們查看方便，我在這裡將Spring註解的使用方式做個匯總，也算是對之前寫的Spring文章的一個總結吧！

如果文章對你有點幫助，請點個贊，給個在看和轉發，大家的支持是對我持續創作的最大動力。

微信搜索並關注「冰河技術」微信公眾號，每天推送超硬核技術乾貨！

xml配置與類配置

1.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="//www.springframework.org/schema/beans"
xmlns:xsi="//www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="//www.springframework.org/schema/beans //www.springframework.org/schema/beans/sp
	<bean id="person" class="com.binghe.spring.Person"></bean>
</beans>

獲取Person實例如下所示。

public static void main( String[] args ){
	ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
	System.out.println(ctx.getBean("person"));
}

2.類配置

@Configuration
public class MainConfig {
    @Bean
    public Person person(){
    	return new Person();
    }
}

這裡，有一個需要注意的地方：通過@Bean的形式是使用的話， bean的默認名稱是方法名，若@Bean(value=”bean的名稱”)那麼bean的名稱是指定的。

獲取Person實例如下所示。

public static void main( String[] args ){
	AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);
	System.out.println(ctx.getBean("person"));
}

@CompentScan註解

我們可以使用@CompentScan註解來進行包掃描，如下所示。

@Configuration
@ComponentScan(basePackages = {"com.binghe.spring"})
	public class MainConfig {
}

excludeFilters 屬性

當我們使用@CompentScan註解進行掃描時，可以使用@CompentScan註解的excludeFilters 屬性來排除某些類，如下所示。

@Configuration
@ComponentScan(basePackages = {"com.binghe.spring"},excludeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class}),
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,value = {PersonService.class})
})
public class MainConfig {
}

includeFilters屬性

當我們使用@CompentScan註解進行掃描時，可以使用@CompentScan註解的includeFilters屬性將某些類包含進來。這裡需要注意的是：需要把useDefaultFilters屬性設置為false（true表示掃描全部的）

@Configuration
@ComponentScan(basePackages = {"com.binghe.spring"},includeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class, PersonService.class})
},useDefaultFilters = false)
public class MainConfig {
}

@ComponentScan.Filter type的類型

註解形式的FilterType.ANNOTATION @Controller @Service @Repository @Compent
指定類型的 FilterType.ASSIGNABLE_TYPE @ComponentScan.Filter(type =FilterType.ASSIGNABLE_TYPE,value = {Person.class})
aspectj類型的 FilterType.ASPECTJ(不常用)
正則表達式的 FilterType.REGEX(不常用)
自定義的 FilterType.CUSTOM

public enum FilterType {
    //註解形式 比如@Controller @Service @Repository @Compent
    ANNOTATION,
    //指定的類型
    ASSIGNABLE_TYPE,
    //aspectJ形式的
    ASPECTJ,
    //正則表達式的
    REGEX,
    //自定義的
    CUSTOM
}

FilterType.CUSTOM 自定義類型

public class CustomFilterType implements TypeFilter {
@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
    //獲取當前類的註解源信息
    AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
    //獲取當前類的class的源信息
    ClassMetadata classMetadata = metadataReader.getClassMetadata();
    //獲取當前類的資源信息
    Resource resource = metadataReader.getResource();
 	return classMetadata.getClassName().contains("Service");
}
    
@ComponentScan(basePackages = {"com.binghe.spring"},includeFilters = {
@ComponentScan.Filter(type = FilterType.CUSTOM,value = CustomFilterType.class)
},useDefaultFilters = false)
public class MainConfig {
}

配置Bean的作用域對象

不指定@Scope

在不指定@Scope的情況下，所有的bean都是單實例的bean，而且是餓漢加載(容器啟動實例就創建好了)

@Bean
public Person person() {
	return new Person();
}

@Scope為 prototype

指定@Scope為 prototype 表示為多實例的，而且還是懶漢模式加載（IOC容器啟動的時候，並不會創建對象，而是在第一次使用的時候才會創建）

@Bean
@Scope(value = "prototype")
public Person person() {
    return new Person();
}

@Scope取值

singleton 單實例的(默認)
prototype 多實例的
request 同一次請求
session 同一個會話級別

懶加載

Bean的懶加載@Lazy(主要針對單實例的bean 容器啟動的時候，不創建對象，在第一次使用的時候才會創建該對象)

@Bean
@Lazy
public Person person() {
	return new Person();
}

@Conditional條件判斷

場景，有二個組件CustomAspect 和CustomLog ，我的CustomLog組件是依賴於CustomAspect的組件
應用：自己創建一個CustomCondition的類實現Condition接口

public class CustomCondition implements Condition {
/****
@param context
* @param metadata
* @return
*/
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //判斷容器中是否有CustomAspect的組件
        return context.getBeanFactory().containsBean("customAspect");
    }	
} 

public class MainConfig {
    @Bean
    public CustomAspect customAspect() {
        return new CustomAspect();
    } 
    @Bean
    @Conditional(value = CustomCondition.class)
    public CustomLog customLog() {
   		return new CustomLog();
    }
}

向IOC 容器添加組件

（1）通過@CompentScan +@Controller @Service @Respository @compent。適用場景: 針對我們自己寫的組件可以通過該方式來進行加載到容器中。

（2）通過@Bean的方式來導入組件(適用於導入第三方組件的類)

（3）通過@Import來導入組件（導入組件的id為全類名路徑）

@Configuration
@Import(value = {Person.class})
public class MainConfig {
}

通過@Import 的ImportSeletor類實現組件的導入 (導入組件的id為全類名路徑)

public class CustomImportSelector implements ImportSelector {	
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
    	return new String[]{"com.binghe.spring"};
    }
} 
Configuration
@Import(value = {Person.class}
public class MainConfig {
}

通過@Import的 ImportBeanDefinitionRegister導入組件 (可以指定bean的名稱)

public class DogBeanDefinitionRegister implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //創建一個bean定義對象
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Dog.class);
        //把bean定義對象導入到容器中
        registry.registerBeanDefinition("dog",rootBeanDefinition);
    }
} 
@Configuration
@Import(value = {Person.class, Car.class, CustomImportSelector.class, DogBeanDefinitionRegister.class})
public class MainConfig {
}

通過實現FacotryBean接口來實現註冊組件

public class CarFactoryBean implements FactoryBean<Car> {
    @Override
    public Car getObject() throws Exception {
    	return new Car();
    } 
    @Override
    public Class<?> getObjectType() {
    	return Car.class;
    } 

    @Override
    public boolean isSingleton() {
    	return true;
    }
}

Bean的初始化與銷毀

指定bean的初始化方法和bean的銷毀方法

由容器管理Bean的生命周期，我們可以通過自己指定bean的初始化方法和bean的銷毀方法

@Configuration
public class MainConfig {
    //指定了bean的生命周期的初始化方法和銷毀方法.@Bean(initMethod = "init",destroyMethod = "destroy")
    public Car car() {
    	return new Car();
    }
}

針對單實例bean的話，容器啟動的時候，bean的對象就創建了，而且容器銷毀的時候，也會調用Bean的銷毀方法

針對多實例bean的話,容器啟動的時候，bean是不會被創建的而是在獲取bean的時候被創建，而且bean的銷毀不受IOC容器的管理

通過 InitializingBean和DisposableBean實現

通過 InitializingBean和DisposableBean個接口實現bean的初始化以及銷毀方法

@Component
public class Person implements InitializingBean,DisposableBean {
    public Person() {
    	System.out.println("Person的構造方法");
    } 
    @Override
    public void destroy() throws Exception {
    	System.out.println("DisposableBean的destroy()方法 ");
    } 
    @Override
    public void afterPropertiesSet() throws Exception {
    	System.out.println("InitializingBean的 afterPropertiesSet方法");
    }
}

通過JSR250規範

通過JSR250規範提供的註解@PostConstruct 和@ProDestory標註的方法

@Component
public class Book {
    public Book() {
    	System.out.println("book 的構造方法");
    } 
    @PostConstruct
    public void init() {
    	System.out.println("book 的PostConstruct標誌的方法");
    } 
    @PreDestroy
    public void destory() {
    	System.out.println("book 的PreDestory標註的方法");
    }
}

通過BeanPostProcessor實現

通過Spring的BeanPostProcessor的 bean的後置處理器會攔截所有bean創建過程

postProcessBeforeInitialization 在init方法之前調用
postProcessAfterInitialization 在init方法之後調用

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    	System.out.println("CustomBeanPostProcessor...postProcessBeforeInitialization:"+beanName);
   		return bean;
    } 
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("CustomBeanPostProcessor...postProcessAfterInitialization:"+beanName);
        return bean;
    }
}

BeanPostProcessor的執行時機

populateBean(beanName, mbd, instanceWrapper)
initializeBean{
    applyBeanPostProcessorsBeforeInitialization()
    invokeInitMethods{
    isInitializingBean.afterPropertiesSet()
    自定義的init方法
}
applyBeanPostProcessorsAfterInitialization()方法
}

通過@Value +@PropertySource來給組件賦值

public class Person {
    //通過普通的方式
    @Value("獨孤")
    private String firstName;
    //spel方式來賦值
    @Value("#{28-8}")
    private Integer age;
    通過讀取外部配置文件的值
    @Value("${person.lastName}")
    private String lastName;
} 
@Configuration
@PropertySource(value = {"classpath:person.properties"}) //指定外部文件的位置
public class MainConfig {
    @Bean
    public Person person() {
        return new Person();
    }
}

自動裝配

@AutoWired的使用

自動注入

@Repository
public class CustomDao {
} 
@Service
public class CustomService {
    @Autowired
    private CustomDao customDao;
｝

結論:
（1）自動裝配首先時按照類型進行裝配，若在IOC容器中發現了多個相同類型的組件，那麼就按照屬性名稱來進行裝配

@Autowired
private CustomDao customDao;

比如，我容器中有二個CustomDao類型的組件一個叫CustomDao 一個叫CustomDao2那麼我們通過@AutoWired 來修飾的屬性名稱時CustomDao，那麼拿就加載容器的CustomDao組件，若屬性名稱為tulignDao2 那麼他就加載的時CustomDao2組件

（2）假設我們需要指定特定的組件來進行裝配，我們可以通過使用@Qualifier(“CustomDao”)來指定裝配的組件
或者在配置類上的@Bean加上@Primary註解

@Autowired
@Qualifier("CustomDao")
private CustomDao customDao2

（3）假設我們容器中即沒有CustomDao 和CustomDao2,那麼在裝配的時候就會拋出異常

No qualifying bean of type 'com.binghhe.spring.dao.CustomDao' available

若我們想不拋異常，我們需要指定 required為false的時候可以了

@Autowired(required = false)
@Qualifier("customDao")
private CustomDao CustomDao2;

（4）@Resource(JSR250規範)
功能和@AutoWired的功能差不多一樣，但是不支持@Primary 和@Qualifier的支持

（5）@InJect（JSR330規範）
需要導入jar包依賴，功能和支持@Primary功能 ,但是沒有Require=false的功能

<dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <version>1</version>
</dependency>

（6）使用@Autowired 可以標註在方法上

標註在set方法上

//@Autowired
public void setCustomLog(CustomLog customLog) {
	this.customLog = customLog;
}

標註在構造方法上

@Autowired
public CustomAspect(CustomLog customLog) {
	this.customLog = customLog;
}

標註在配置類上的入參中（可以不寫）

@Bean
public CustomAspect CustomAspect(@Autowired CustomLog customLog) {
    CustomAspect customAspect = new CustomAspect(customLog);
    return ustomAspect;
}

XXXAwarce接口

我們自己的組件需要使用spring ioc的底層組件的時候,比如 ApplicationContext等我們可以通過實現XXXAware接口來實現

@Component
public class CustomCompent implements ApplicationContextAware,BeanNameAware {
    private ApplicationContext applicationContext;
    @Override
    public void setBeanName(String name) {
    	System.out.println("current bean name is :【"+name+"】");
    } 
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    	this.applicationContext = applicationContext;
    }
}

@Profile註解

通過@Profile註解來根據環境來激活標識不同的Bean

@Profile標識在類上，那麼只有當前環境匹配，整個配置類才會生效
@Profile標識在Bean上，那麼只有當前環境的Bean才會被激活
沒有標誌為@Profile的bean 不管在什麼環境都可以被激活

@Configuration
@PropertySource(value = {"classpath:ds.properties"})
public class MainConfig implements EmbeddedValueResolverAware {
    @Value("${ds.username}")
    private String userName;
    @Value("${ds.password}")
    private String password;
    private String jdbcUrl;
    private String classDriver;
    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        this.jdbcUrl = resolver.resolveStringValue("${ds.jdbcUrl}");
        this.classDriver = resolver.resolveStringValue("${ds.classDriver}");
    } 
    @Bean
    @Profile(value = "test")
    public DataSource testDs() {
   		return buliderDataSource(new DruidDataSource());
    }
    @Bean
    @Profile(value = "dev")
    public DataSource devDs() {
    	return buliderDataSource(new DruidDataSource());
    } 
    @Bean
    @Profile(value = "prod")
    public DataSource prodDs() {
    	return buliderDataSource(new DruidDataSource());
    } 
    private DataSource buliderDataSource(DruidDataSource dataSource) {
        dataSource.setUsername(userName);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(classDriver);
        dataSource.setUrl(jdbcUrl);
    	return dataSource;
    }
}

激活切換環境的方法

（1）運行時jvm參數來切換

 -Dspring.profiles.active=test|dev|prod

（2）通過代碼的方式來激活

public static void main(String[] args) {
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
    ctx.getEnvironment().setActiveProfiles("test","dev");
    ctx.register(MainConfig.class);
    ctx.refresh();
    printBeanName(ctx);
}

重磅福利

關注「 冰河技術 」微信公眾號，後台回復「設計模式」關鍵字領取《深入淺出Java 23種設計模式》PDF文檔。回復「Java8」關鍵字領取《Java8新特性教程》PDF文檔。回復「限流」關鍵字獲取《億級流量下的分佈式限流解決方案》PDF文檔，三本PDF均是由冰河原創並整理的超硬核教程，面試必備！！

好了，今天就聊到這兒吧！別忘了點個贊，給個在看和轉發，讓更多的人看到，一起學習，一起進步！！

寫在最後

如果你覺得冰河寫的還不錯，請微信搜索並關注「 冰河技術 」微信公眾號，跟冰河學習高並發、分佈式、微服務、大數據、互聯網和雲原生技術，「 冰河技術 」微信公眾號更新了大量技術專題，每一篇技術文章乾貨滿滿！不少讀者已經通過閱讀「 冰河技術 」微信公眾號文章，吊打面試官，成功跳槽到大廠；也有不少讀者實現了技術上的飛躍，成為公司的技術骨幹！如果你也想像他們一樣提升自己的能力，實現技術能力的飛躍，進大廠，升職加薪，那就關注「 冰河技術 」微信公眾號吧，每天更新超硬核技術乾貨，讓你對如何提升技術能力不再迷茫！

Tags: spring