@TOC# Spring系列
記錄在程式走的每一步___auth:huf

最近在復習Spring核心原理; 順手記錄;

一、Spring創建Bean的生命周期

在Spring的入口開始

package com.example;
import com.example.service.StudentService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext run = SpringApplication.run(DemoApplication.class, args);
        StudentService studentService = (StudentService) run.getBean("studentService");
        System.out.println(studentService);
    }
}

直接使用SpringBoot, 在ConfigurableApplicationContext 進行加載 StudentService 以下是StudentService的物體類 StudentService 獲取直接從Spring容器中獲取. 跟直接new 出來的類有天壤之別; 其中一大塊就是屬性注入問題; 屬性注入就要提起 關于BeanDefinition 與 Bean之間的關系 在后面的文章中會詳細介紹; 本期文章中不會有體現;

package com.example.service;
import com.example.entity.Student;
public interface StudentService {
...
}

package com.example.service.impl;
import com.example.service.StudentService;
@Service(value="studentService")
public class StudentServiceImpl implements StudentService {
..
}

以下是一個Bean的生命周期圖<簡化版>

1: 利用該類的構造方法來實體化一個物件(如果說有多個構造方法,那么Spring會自行選擇,選擇規則是 在沒有@Autowired的時候 就會選擇默認的,在沒有默認的, 就會選擇唯一一個 如果有多個就會報錯,此時需要在構造方法內指定@Autowired);

2: 得到一個物件后 查看其屬性是否被 @Autowired注解 ; 如果有那么Spring會從容器中尋找該物件進行注入;

3: 依賴注入之后,Spring會自行判斷該物件是否實作了BeanNameAware,BeanClassLoaderAware,BeanFactoryAware介面 如果有.那么就會調取其實作方法setBeanName()、setBeanClassLoader()、 setBeanFactory();那Spring就會呼叫這些方法并傳入相應的引數（Aware回呼）

4:Aware回呼后,那么就會判斷該類是否存在PostConstruct注解 了，如果存在，Spring會呼叫當前物件的此方法（初始化前）

5:緊接著，Spring會判斷該物件是否實作了InitializingBean介面，如果實作了，就 表示當前物件必須實作該介面中的afterPropertiesSet()方法，那Spring就會呼叫當前物件中的afterPropertiesSet()方法（初始化）;

6:最后判斷:Spring是否需要Aop,如果不需要.那么類就創建完畢(此時是普通物件);如果需要;那么就會 動態代理 由代理類來實作AOP;此時就是代理物件; 這個需要注意 普通物件與代理物件的區別! 代理物件 實際是就是為了實作AOP; 最后附上代碼圖 Debug進行解釋

Spring中使用Cglib 進行動態代理的呢;此處以偽代碼進行解釋

package com.example.service.impl;
import com.example.entity.Student;
import com.example.service.StudentService;
/**
 * 此處為cglib自己生產的代理類 并且繼承
 * auth:huf
 */
public class StudentServiceProxy extends StudentServiceImpl{
    StudentService target;// 使用的是是前面創建的Java普通物件;注意是普通物件
    public int insert(Student stu){
        /**
         * AOP的前置動作;Before
         */
        //這個地方insert并非使用super.insert方法;
        target.insert(stu);
        /**
         * AOP的后置動作;
         */
    }
}

AOP大致流程

AOP就是進行動態代理，在創建一個Bean的程序中，Spring在最后一步會去判斷當前正在 創建的這個Bean是不是需要進行AOP，如果需要則會進行動態代理，如何判斷當前Bean物件需不需要進行AOP:
1. 找出所有的切面Bean
2. 遍歷切面中的每個方法，看是否寫了@Before、@After等注解
3. 如果寫了，則判斷所對應的Pointcut是否和當前Bean物件的類是否匹配
4. 如果匹配則表示當前Bean物件有匹配的的Pointcut，表示需要進行AOP 利用cglib進行AOP的大致流程：
1). 生成代理類StudentServiceProxy，代理類繼承StudentServiceImpl
2). 代理類中重寫了父類的方法，比如StudentServiceImpl中的insert()方法
3). 代理類中還會有一個target屬性，該屬性的值為被代理物件（也就是通過 UserService類推斷構造方法實體化出來的物件，進行了依賴注入、初始化等步驟的 物件）
4). 代理類中的test()方法被執行時的邏輯如下： a. 執行切面邏輯（@Before） b. 呼叫target.insert() 當我們從Spring容器得到StudentServiceImpl的Bean物件時，拿到的就是UserServiceProxy所生 成的物件，也就是代理物件， StudentServiceImpl代理物件.insert()—>執行切面邏輯—>target.insert()，注意target物件不是代理 物件，而是被代理物件，

在復習程序中 修正之前跟一名同事 哲哲 說的 一個Spring原理:
注:Spring會根據入參的型別和入參的名字去Spring中找Bean物件,（以單例Bean為例， Spring會從單例池那個Map中去找）：
1. 先根據入參型別找，如果只找到一個，那就直接用來作為入參
2. 如果根據型別找到多個，則再根據入參名字來確定唯一一個
3. 最終如果沒有找到，則會報錯，無法創建當前Bean物件
//在什么時候會有多個Bean同時存在在一個容器中: 代碼舉例

package com.example.config;
import com.example.entity.Student;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * BeanTest
 */
@Configuration
public class BeanTestConfig {
    /**
     * 這種情況下 容器就會存在多個Bean并且 相互是獨立的  
     * 先通過型別進行查找. 這時候會找到三個Bean 
     * 然后再通過名字 student1 最終定位到一個Bean; 
     * @return
     */
    @Bean
    public Student student1(){
        return  new Student();
    }
    @Bean
    public Student student2(){
        return  new Student();
    }
}

總結

Spring中的 Bean的生命周期大致如上. Spring @Transactional 也是通過AOP實作的;其原理 就是把autocommit 由true改為false; 由代理類進行Commit; Spring原理 會持續更新 更新時間為每個星期 三篇左右;