Spring IOC容器設計理念與常見底層核心註解

時間 2019-11-08

標籤 spring ioc 容器設計理念常見底層核心註解欄目 Spring 简体版

原文原文鏈接

1、Spring 框架總體功能介紹

Spring Framework是一個Java平臺，爲開發Java應用程序提供全面的基礎架構支持。Spring處理基礎架構，所以您能夠專一於您的應用程序。java

Spring容許您從「普通舊Java對象」（POJO）構建應用程序，並以非侵入方式將企業服務應用於POJO。此功能適用於Java SE編程模型以及完整和部分Java EE。正則表達式

做爲應用程序開發人員，您能夠從Spring平臺中受益的示例以下：spring

使Java方法在數據庫事務中執行，而沒必要處理事務API。
使本地Java方法成爲遠程過程，而無需處理遠程API。
使本地Java方法成爲管理操做，而無需處理JMX API。
使本地Java方法成爲消息處理程序，而無需處理JMS API。

Spring Framework由大約20個模塊組成的功能組成。這些模塊分爲核心容器，數據訪問/集成，Web，AOP（面向方面編程），儀器，消息傳遞和測試，以下圖所示。數據庫

1. Spring Core Container

模塊做用: Core 和 Beans 模塊是框架的基礎部分，提供 IoC (轉控制)和依賴注入特性。這裏的基礎概念是 BeanFactory，它提供對 Factory 模式的經典實現來消除對程序’性單例模式的須要，並真正地容許你從程序邏輯中分離出依賴關係和配置。express

1.1 Core

主要包含 Spring 框架基本的核心工具類， Spring 的其餘組件都要用到這個包裏的類， Core模塊是其餘組件的基本核心。編程

1.2 Beans (BeanFacotry的做用)

它包含訪問配置文件、建立和管理 bean 以及進行 Inversion of Control I Dependency Injection ( IoC/DI )操做相關的全部類。數組

1.3 Context(處理BeanFactory，仍是ApplicationContext的做用)

構建於 Core 和 Beans 模塊基礎之上，提供了一種相似JNDI 註冊器的框架式的對象訪問方法。 Context 模塊繼承了 Beans 的特性，爲 Spring 核心提供了大量擴展，添加了對國際化(例如資源綁定)、事件傳播、資源加載和對 Context 的透明創建的支持。 Context 模塊同時也支持 J2EE 的一些特性，ApplicationContext 接口是 Context 模塊的關鍵bash

本質區別:(使用BeanFacotry的bean是延時加載的,ApplicationContext是非延時加載的)服務器

1.4 Expression Language

模塊提供了強大的表達式語言，用於在運行時查詢和操縱對象。它是 JSP 2.1 規範中定義的 unifed expression language 的擴展。該語言支持設直/獲取屬性的值，屬性的分配，方法的調用，訪問數組上下文( accessiong the context of arrays )、容器和索引器、邏輯和算術運算符、命名變量以及從Spring的 IoC 容器中根據名稱檢索對象。它也支持 list 投影、選擇和通常的 list 聚合session

2. Spring Data Access/Integration

2.1 JDBC

模塊提供了一個 JDBC 抽象層，它能夠消除冗長的 JDBC 編碼和解析數據庫廠商特有的錯誤代碼。這個模塊包含了 Spring 對 JDBC 數據訪問進行封裝的全部類

2.2 ORM 模塊爲流行的對象-關係映射 API

如 JPA、 JDO、 Hibernate、 MyBatis 等，提供了一個交互層。利用 ORM 封裝包，能夠混合使用所有 Spring 提供的特性進行 O/R 映射，如簡單聲明性事務管理。

2.3 OXM 模塊提供了一個對 ObjecνXML 映射實現的抽象層

Object/XML 映射實現包括 JAXB、 Castor、 XMLBeans、 JiBX 和 XStrearn

2.4 JMS ( Java Messaging Service )

模塊主要包含了一些製造和消費消息的特性。

2.5 Transaction

支持編程和聲明性的事務管理，這些事務類必須實現特定的接口，並且對全部的 POJO 都適用

3. Spring Web

Web 模塊:提供了基礎的面向 Web 的集成特性。例如，多文件上傳、使用 servlet listeners 初始化

IoC 容器以及一個面向 Web 的應用上下文。它還包含 Spring 遠程支持中 Web 的相關部分。

4. Spring Aop

Aspects 模塊提供了對 AspectJ 的集成支持。
Instrumentation 模塊提供了 class instrumentation 支持和 classloader 實現，使得能夠在特定的應用服務器上使用

5. Spring Test

Test 模塊支持使用 JUnit 和 TestNG 對 Spring 組件進行測試

6. Spring 容器繼承圖

7. 控制反轉和依賴注入

什麼是控制反轉？

這裏有必要先了解軟件設計的一個重要思想：依賴倒置原則(Dependency Inversion Principle )

什麼事依賴倒置原則？假設咱們設計一輛汽車:先設計輪子，而後根據輪子大小設計底盤，接着根據底盤設計車身，最後根據車身設計好整個汽車。這裏就出現了一個「依賴」關係:汽車依賴車身，車身依賴底盤，底盤依賴輪子

上圖看上去沒有什麼毛病?可是萬一輪胎尺寸改了,那麼地盤須要改，地盤改了，車身也改了，讓後整個汽車構造都改了. 而後汽車公司倒閉了......................

董事長依賴總經理掙錢，總經理依賴部門經理掙錢，部門經理依賴員工爭取，那麼員工離職了怎麼辦??????????

反過來............假如汽車公司決定修改輪胎的咱們就只須要改動輪子的設計，而不須要動底盤，車身，汽車的設計了。

IOC 的思想最核心的地方在於，資源不禁使用資源的雙方管理，而是不使用資源的第三方管理。這樣能夠帶來不少好處，以下：

資源集中管理，實現資源的可配置和易管理
下降了使用資源的雙方的依賴程度，也就是耦合度

2、Spring IOC 容器底層註解使用

一、xml配置文件的形式 VS 配置類的形式

1⃣ 基於xml的形式定義Bean的信息

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
//定義一個Bean的信息
<bean id="car" class="com.niuh.compent.Car"></bean>
</beans>
複製代碼

去容器中讀取Bean

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

2⃣ 基於讀取配置類的形式定義Bean信息

@Configuration
public class MainConfig {
    @Bean
    public Person person(){
        return new Person();
    }
}
複製代碼

注意: 經過@Bean的形式是使用的話， bean的默認名稱是方法名，若@Bean(value="bean的名稱") 那麼bean的名稱是指定的

去容器中讀取Bean的信息(傳入配置類)

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

二、在配置類上寫@CompentScan註解來進行包掃描

@Configuration
@ComponentScan(basePackages = {"com.niuh.testcompentscan"}) 
public class MainConfig {
}
複製代碼

1⃣ 排除用法 excludeFilters（排除@Controller註解的和NiuhService的）

@Configuration
@ComponentScan(basePackages = {"com.niuh.testcompentscan"},excludeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class}),
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,value = {NiuhService.class}) })
public class MainConfig {
}
複製代碼

2⃣ 包含用法 includeFilters，注意：若使用包含的用法，須要把useDefaultFilters屬性設置爲false（true表示掃描所有）

@Configuration
@ComponentScan(basePackages = {"com.niuh.testcompentscan"},includeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class, Service.class}) },useDefaultFilters = false)
public class MainConfig {
}
複製代碼

3⃣ @ComponentScan.Filter type的類型

*   註解形式的FIlterType.ANNOTATION @Controller @Service @Repository @Compent
*   指定類型的FilterType.ASSIGNABLE_TYPE @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,value = {NiuhService.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 NiuhFilterType 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();
       if(classMetadata.getClassName().contains("dao")) { 
            return true;
       }
       return false; 
    }
}

@ComponentScan(basePackages = {"com.niuh.testcompentscan"},includeFilters = { @ComponentScan.Filter(type = FilterType.CUSTOM,value = NiuhFilterType.class)},useDefaultFilters = false)
public class MainConfig {
}
複製代碼

三、配置Bean的做用域對象

1⃣ 在不指定@Scope的狀況下，全部的bean都是單實例的bean，並且是餓漢加載（啓動啓動實例就建立好了）

@Bean
public Person person() {
    return new Person(); 
}
複製代碼

2⃣ 指定@Scope爲prototype 表示爲多實例，並且仍是懶漢加載模式（IOC容器啓動的時候，並不會建立對象，而是在第一次使用的時候纔會建立）

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

3⃣ @Scope 指定的做用域方法取值

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

四、Bean的懶加載 @lazy

主要針對單實例的bean ，容器啓動的時候，不建立對象，在第一次使用的時候纔會建立該對象

@Bean
@Lazy
public Person person() {
    return new Person(); 
}
複製代碼

五、@Conditional 進行條件判斷等

場景,有二個組件NiuhAspect 和 NiuhLog ，個人NiuhLog組件是依賴於NiuhAspect的組件應用:本身建立一個NiuhCondition的類實現Condition接口

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

public class MainConfig {
    @Bean
    public NiuhAspect niuhAspect() {
        return new NiuhAspect();
    }
    //當切 容器中有niuhAspect的組件，那麼niuhLog纔會被實例化. @Bean
    @Conditional(value = NiuhCondition.class)
    public NiuhLog niuhLog() {
        return new NiuhLog(); 
    }
} 
複製代碼

六、往IOC容器中添加組件的方式

1⃣ 經過@CompentScan + @Controller @Service @Respository @compent

適用場景：針對咱們本身寫的組件能夠經過該方式來進行加載到容器中。

2⃣ 經過@Bean 的方式來導入組件（適用於導入第三方組件的淚）

3⃣ 經過@Import 來導入組建（導入組件的id爲全類名路徑）

@Configuration
@Import(value = {Person.class, Car.class}) 
public class MainConfig {
}
複製代碼

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

public class NiuhImportSelector implements ImportSelector { 
    //能夠獲取導入類的註解信息
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.niuh.testimport.compent.Dog"}; 
    }
} 

@Configuration
@Import(value = {Person.class, Car.class, NiuhImportSelector.class}) 
public class MainConfig {
}
複製代碼

經過@Import的 ImportBeanDefinitionRegister導入組件 (能夠指定bean的名稱)

public class NiuhBeanDefinitionRegister implements ImportBeanDefinitionRegistrar { 
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { //建立一個bean定義對象
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Cat.class);
        //把bean定義對象導入到容器中
        registry.registerBeanDefinition("cat",rootBeanDefinition); 
    }
}

@Configuration
//@Import(value = {Person.class, Car.class})
//@Import(value = {Person.class, Car.class, TulingImportSelector.class})
@Import(value = {Person.class, Car.class, NiuhImportSelector.class, NiuhBeanDefinitionRegister.class}) 
public class MainConfig {
}
複製代碼

4⃣ 經過實現FactoryBean 接口來實現註冊組建

public class CarFactoryBean implements FactoryBean<Car> {
    //返回bean的對象
    @Override
    public Car getObject() throws Exception {
        return new Car(); 
    }
    //返回bean的類型
    @Override
    public Class<?> getObjectType() {
        return Car.class; 
   }
    //是否爲單例
    @Override
    public boolean isSingleton() {
        return true; 
    }
}
複製代碼

七、Bean的初始化方法和銷燬方法

1⃣ 什麼是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容器的管理.

2⃣ 經過InitializingBean 和 DisposableBean 的2個接口實現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方法"); 
    }
}
複製代碼

3⃣ 經過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標註的方法"); 
    }
}
複製代碼

4⃣ 經過Spring的BeanPostProcessor的 bean的後置處理器會攔截全部bean建立過程

postProceessBeforInitialization 在init方法以前調用

postProcessAfterInitialization 在init方法以後調用

@Component
public class NiuhBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("TulingBeanPostProcessor...postProcessBeforeInitialization:"+beanName);
        return bean; 
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("TulingBeanPostProcessor...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的使用

自動注入：

//一個Dao
@Repository
public class NiuhDao { 
}

@Service
public class NiuhService {
    @Autowired
    private NiuhDao niuhDao;
}
複製代碼

結論：

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

@Autowired

private NiuhDao niuhDao;
複製代碼

好比，容器中有二個NiuhDao類型的組件，一個叫niuhDao，一個叫niuhDao2

那麼咱們經過@AutoWired 來修飾的屬性名稱時niuhDao，那麼就加載容器的niuhDao組件，若屬性名稱爲niuhDao2那麼就加載niuhDao2組件。

2⃣ 假設咱們須要指定特定的組件來進行裝配，咱們能夠經過使用@Qualifilter("niuhDao")來指定裝配的組件或者在配置類上的@Bean加上@Primary註解

@Autowired 
@Qualifier("niuhDao") 
private NiuhDao niuhDao2;
複製代碼

3⃣ 假設容器中即沒有niuhDao 和 niuhDao2，那麼在裝配的時候就會拋出異常

No qualifying bean of type 'com.niuh.testautowired.NiuhDao' available

若咱們想不拋異常，咱們須要指定 required爲false的時候能夠了

@Autowired(required = false)
@Qualifier("niuhDao") 
private NiuhDao niuhDao2;
複製代碼

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 setNiuhLog(NiuhLog niuhLog) {
    this.niuhLog = niuhLog; 
}
複製代碼

標註在構造方法上

@Autowired
public NiuhAspect(NiuhLog niuhLog) {
    this.niuhLog = niuhLog; 
}
複製代碼

標註在配置類上的入參中（能夠不寫）

@Bean
public NiuhAspect niuhAspect(@Autowired NiuhLog niuhLog) {
    NiuhAspect niuhAspect = new NiuhAspect(niuhLog);
    return niuhAspect; 
}
複製代碼

十、咱們本身的組件須要使用spring ioc 的底層組件的時候，好比ApplicationContext等，咱們能夠經過實現XXXAware接口來實現

@Component
public class NiuhCompent 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 註解來根據環境激活標識不一樣的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; 
    }
}
複製代碼

激活切換環境的方法

方法一：經過運行時jvm參數來切換 -Dspring.profiles.active=test|dev|prod

方法二：經過代碼方式來激活

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