為什么一個大學生可以把Spring講得這么通透？

昨天晚上聽朋友聊天，一個剛畢業的大學生去面試，非常有自信，講完了spring后直接被錄用了，我都蒙了，啥樣的回答能直接征服面試官啊，仔細一問了解了一下程序，內心直呼牛逼，

什么是 Spring 框架

它是很多模塊的集合，使用這些模塊可以很方便地協助我們進行開發，這些模塊是：核心容器、資料訪問/集成,、Web、AOP（面向切面編程）、工具、訊息和測驗模塊，比如：Core Container 中的 Core 組件是Spring 所有組件的核心，Beans 組件和 Context 組件是實作IOC和依賴注入的基礎，AOP組件用來實作面向切面編程，

核心技術 ：依賴注入(DI)，AOP，事件(events)，資源，i18n，驗證，資料系結，型別轉換，SpEL，
測驗 ：模擬物件，TestContext框架，Spring MVC 測驗，WebTestClient，
資料訪問 ：事務，DAO支持，JDBC，ORM，編組XML，
Web支持 : Spring MVC和Spring WebFlux Web框架，
集成 ：遠程處理，JMS，JCA，JMX，電子郵件，任務，調度，快取，
語言 ：Kotlin，Groovy，動態語言

這里也整理了其他大廠的面試題，需要的朋友可以點擊：點這個！點這個！暗號：csdn

Spring 的優點？

• spring屬于低侵入式設計，代碼的污染極低；
• spring的DI機制將物件之間的依賴關系交由框架處理，減低組件的耦合性；
• Spring提供了AOP技術，支持將一些通用任務，如安全、事務、日志、權限等進行集中式管理，從而提供更好的復用，
• spring對于主流的應用框架提供了集成支持，

列舉一些重要的Spring模塊？

Spring Core： 基礎,可以說 Spring 其他所有的功能都需要依賴于該類別庫，主要提供 IoC 依賴注入功能，
Spring Aspects ： 該模塊為與AspectJ的集成提供支持，
Spring AOP ：提供了面向切面的編程實作，
Spring JDBC : Java資料庫連接，
Spring JMS ：Java訊息服務，
Spring ORM : 用于支持Hibernate等ORM工具，
Spring Web : 為創建Web應用程式提供支持，
Spring Test : 提供了對 JUnit 和 TestNG 測驗的支持，

@RestController vs @Controller

單獨使用 @Controller 不加 @ResponseBody的話一般使用在要回傳一個視圖的情況，這種情況屬于比較傳統的Spring MVC 的應用，對應于前后端不分離的情況，

@RestController =@Controller +@ResponseBody

談談自己對于 Spring IoC 和 AOP 的理解

IOC
IoC（Inverse of Control:控制反轉）是一種設計思想，就是 將原本在程式中手動創建物件的控制權，交由Spring框架來管理， IoC 在其他語言中也有應用，并非 Spring 特有， IoC 容器是 Spring 用來實作 IoC 的載體， IoC 容器實際上就是個Map（key，value）,Map 中存放的是各種物件，

將物件之間的相互依賴關系交給 IoC 容器來管理，并由 IoC 容器完成物件的注入，這樣可以很大程度上簡化應用的開發，把應用從復雜的依賴關系中解放出來， IoC 容器就像是一個工廠一樣，當我們需要創建一個物件的時候，只需要配置好組態檔/注解即可，完全不用考慮物件是如何被創建出來的，

在實際專案中一個 Service 類可能有幾百甚至上千個類作為它的底層，假如我們需要實體化這個 Service，你可能要每次都要搞清這個 Service 所有底層類的建構式，這可能會把人逼瘋，如果利用 IoC 的話，你只需要配置好，然后在需要的地方參考就行了，這大大增加了專案的可維護性且降低了開發難度，

AOP
AOP(Aspect-Oriented Programming:面向切面編程)能夠將那些與業務無關，卻為業務模塊所共同呼叫的邏輯或責任（例如事務處理、日志管理、權限控制等）封裝起來，便于減少系統的重復代碼，降低模塊間的耦合度，并有利于未來的可拓展性和可維護性，

Spring AOP就是基于動態代理的，如果要代理的物件，實作了某個介面，那么Spring AOP會使用JDK Proxy，去創建代理物件，而對于沒有實作介面的物件，就無法使用 JDK Proxy 去進行代理了，這時候Spring AOP會使用Cglib ，這時候Spring AOP會使用 Cglib 生成一個被代理物件的子類來作為代理

Spring AOP 和 AspectJ AOP 有什么區別？

? Spring AOP 屬于運行時增強，而 AspectJ 是編譯時增強，Spring AOP 基于代理(Proxying)，而 AspectJ 基于位元組碼操作(Bytecode Manipulation)，

? Spring AOP 已經集成了 AspectJ ，AspectJ 應該算的上是 Java 生態系統中最完整的 AOP 框架了，AspectJ 相比于 Spring AOP 功能更加強大，但是 Spring AOP 相對來說更簡單，

? 如果我們的切面比較少，那么兩者性能差異不大，但是，當切面太多的話，最好選擇 AspectJ ，它比Spring AOP 快很多，

Spring 中的 bean 的作用域有哪些?

• singleton : 唯一 bean 實體，Spring 中的 bean 默認都是單例的，
• prototype : 每次請求都會創建一個新的 bean 實體，
• request : 每一次HTTP請求都會產生一個新的bean，該bean僅在當前HTTP request內有效，
• session : 每一次HTTP請求都會產生一個新的 bean，該bean僅在當前 HTTP session 內有效，
• global-session：全域session作用域，僅僅在基于portlet的web應用中才有意義，Spring5已經沒有了，Portlet是能夠生成語意代碼(例如：HTML)片段的小型Java Web插件，它們基于portlet容器，可以像servlet一樣處理HTTP請求，但是，與 servlet 不同，每個 portlet都有不同的會話，

Spring中的Bean是執行緒安全的嘛？

? 對于單例Bean,所有執行緒都共享一個單例實體Bean,因此是存在資源的競爭，

? 如果單例Bean,是一個無狀態Bean，也就是執行緒中的操作不會對Bean的成員執行查詢以外的操作，那么這個單例Bean是執行緒安全的，比如Spring mvc 的 Controller、Service、Dao等，這些Bean大多是無狀態的，只關注于方法本身，

? 對于有狀態的bean，Spring官方提供的bean，一般提供了通過ThreadLocal去解決執行緒安全的方法，比如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等，

? 容器本身并沒有提供Bean的執行緒安全策略，因此可以說Spring容器中的Bean本身不具備執行緒安全的特性，因此是否執行緒安全完全取決于Bean本身的特性，

@Component 和 @Bean 的區別是什么？

1. 作用物件不同: @Component 注解作用于類，而@Bean注解作用于方法，
2. @Component通常是通過類路徑掃描來自動偵測以及自動裝配到Spring容器中（我們可以使用 @ComponentScan注解定義要掃描的路徑從中找出標識了需要裝配的類自動裝配到 Spring 的 bean 容器中），@Bean注解通常是我們在標有該注解的方法中定義產生這個 bean,@Bean告訴了Spring這是某個類的示例，當我需要用它的時候還給我，
3. @Bean 注解比 Component 注解的自定義性更強，而且很多地方我們只能通過 @Bean注解來注冊bean，比如當我們參考第三方庫中的類需要裝配到 Spring容器時，則只能通過 @Bean來實作，

將一個類宣告為Spring的 bean 的注解有哪些?

我們一般使用 @Autowired 注解自動裝配 bean，要想把類標識成可用于 @Autowired 注解自動裝配的 bean 的類,采用以下注解可實作：

• @Component ：通用的注解，可標注任意類為 Spring 組件，如果一個Bean不知道屬于哪個層，可以使用@Component注解標注，
• @Repository : 對應持久層即 Dao 層，主要用于資料庫相關操作，
• @Service : 對應服務層，主要涉及一些復雜的邏輯，需要用到 Dao層，
• @Controller : 對應 Spring MVC 控制層，主要用戶接受用戶請求并呼叫 Service 層回傳資料給前端頁面，

Spring 中的 bean 生命周期?

• Bean 容器找到組態檔中 Spring Bean 的定義，
• Bean 容器利用 Java Reflection API 創建一個Bean的實體，
• 如果涉及到一些屬性值 利用 set()方法設定一些屬性值，
• 如果 Bean 實作了 BeanNameAware 介面，呼叫 setBeanName()方法，傳入Bean的名字，
• 如果 Bean 實作了 BeanClassLoaderAware 介面，呼叫 setBeanClassLoader()方法，傳入
  ClassLoader物件的實體，
• 與上面的類似，如果實作了其他 *.Aware介面，就呼叫相應的方法，
• 如果有和加載這個 Bean 的 Spring 容器相關的 BeanPostProcessor
  物件，執行postProcessBeforeInitialization() 方法
• 如果Bean實作了InitializingBean介面，執行afterPropertiesSet()方法，
• 如果 Bean 在組態檔中的定義包含 init-method 屬性，執行指定的方法，
• 如果有和加載這個 Bean的 Spring 容器相關的 BeanPostProcessor物件，執行postProcessAfterInitialization() 方法
• 當要銷毀 Bean 的時候，如果 Bean 實作了 DisposableBean 介面，執行 destroy() 方法，
• 當要銷毀 Bean 的時候，如果 Bean 在組態檔中的定義包含 destroy-method 屬性，執行指定的方法，

SpringMVC 作業原理

• 客戶端（瀏覽器）發送請求，直接請求到 DispatcherServlet，
• DispatcherServlet 根據請求資訊呼叫 HandlerMapping，決議請求對應的 Handler，
• 決議到對應的 Handler（也就是我們平常說的 Controller 控制器）后，開始由 HandlerAdapter 配接器處理，
• HandlerAdapter 會根據 Handler來呼叫真正的處理器開處理請求，并處理相應的業務邏輯，
• 處理器處理完業務后，會回傳一個 ModelAndView 物件，Model 是回傳的資料物件，View 是個邏輯上的 View，
• ViewResolver 會根據邏輯 View 查找實際的 View，
• DispaterServlet 把回傳的 Model 傳給 View（視圖渲染），
• 把 View 回傳給請求者（瀏覽器）

需要的朋友可以點擊：點這個！點這個！暗號：csdn

Spring 管理事務的方式有幾種？

1. 編程式事務，在代碼中硬編碼，(不推薦使用)
2. 宣告式事務，在組態檔中配置（推薦使用）

宣告式事務又分為兩種：

1. 基于XML的宣告式事務
2. 基于注解的宣告式事務

Spring 事務中的隔離級別有哪幾種?

• TransactionDefinition.ISOLATION_DEFAULT: 使用后端資料庫默認的隔離級別，Mysql 默認采用的REPEATABLE_READ隔離級別 Oracle 默認采用的 READ_COMMITTED隔離級別.
• TransactionDefinition.ISOLATION_READ_UNCOMMITTED:最低的隔離級別，允許讀取尚未提交的資料變更，可能會導致臟讀、幻讀或不可重復讀
• TransactionDefinition.ISOLATION_READ_COMMITTED:允許讀取并發事務已經提交的資料，可以阻止臟讀，但是幻讀或不可重復讀仍有可能發生
• TransactionDefinition.ISOLATION_REPEATABLE_READ: 對同一欄位的多次讀取結果都是一致的，除非資料是被本身事務自己所修改，可以阻止臟讀和不可重復讀，但幻讀仍有可能發生，
• TransactionDefinition.ISOLATION_SERIALIZABLE: 最高的隔離級別，完全服從ACID的隔離級別，所有的事務依次逐個執行，這樣事務之間就完全不可能產生干擾，也就是說，該級別可以防止臟讀、不可重復讀以及幻讀，但是這將嚴重影響程式的性能，通常情況下也不會用到該級別，

Spring 事務中哪幾種事務傳播行為?

支持當前事務的情況：

TransactionDefinition.PROPAGATION_REQUIRED： 如果當前存在事務，則加入該事務；如果當前沒有事務，則創建一個新的事務，

TransactionDefinition.PROPAGATION_SUPPORTS： 如果當前存在事務，則加入該事務；如果當前沒有事務，則以非事務的方式繼續運行，

TransactionDefinition.PROPAGATION_MANDATORY： 如果當前存在事務，則加入該事務；如果當前沒有事務，則拋出例外，（mandatory：強制性）

不支持當前事務的情況：

TransactionDefinition.PROPAGATION_REQUIRES_NEW： 創建一個新的事務，如果當前存在事務，則把當前事務掛起，

TransactionDefinition.PROPAGATION_NOT_SUPPORTED： 以非事務方式運行，如果當前存在事務，則把當前事務掛起，

TransactionDefinition.PROPAGATION_NEVER： 以非事務方式運行，如果當前存在事務，則拋出例外，

其他情況：

TransactionDefinition.PROPAGATION_NESTED： 如果當前存在事務，則創建一個事務作為當前事務的嵌套事務來運行；如果當前沒有事務，則該取值等價于TransactionDefinition.PROPAGATION_REQUIRED，

BeanFactory和ApplicationContext有什么區別？

? BeanFactory和ApplicationContext是Spring的兩大核心介面，都可以當做Spring的容器，其中ApplicationContext是BeanFactory的子介面，

1. BeanFactory：是Spring里面最底層的介面，包含了各種Bean的定義，讀取bean配置檔案，管理bean的加載、實體化，控制bean的生命周期，維護bean之間的依賴關系，ApplicationContext介面作為BeanFactory的派生，除了提供BeanFactory所具有的功能外，還提供了更完整的框架功能：

? ①繼承MessageSource，因此支持國際化，
? ②統一的資源檔案訪問方式，
? ③提供在監聽器中注冊bean的事件，
? ④同時加載多個組態檔，
? ⑤載入多個（有繼承關系）背景關系 ，使得每一個背景關系都專注于一個特定的層次，比如應用的web層，

2. ①BeanFactroy采用的是延遲加載形式來注入Bean的，即只有在使用到某個Bean時(呼叫getBean())，才對該Bean進行加載實體化，這樣，我們就不能發現一些存在的Spring的配置問題，如果Bean的某一個屬性沒有注入，BeanFacotry加載后，直至第一次使用呼叫getBean方法才會拋出例外，

②ApplicationContext，它是在容器啟動時，一次性創建了所有的Bean，這樣，在容器啟動時，我們就可以發現Spring中存在的配置錯誤，這樣有利于檢查所依賴屬性是否注入， ApplicationContext啟動后預載入所有的單實體Bean，通過預載入單實體bean ,確保當你需要的時候，你就不用等待，因為它們已經創建好了，

③相對于基本的BeanFactory，ApplicationContext 唯一的不足是占用記憶體空間，當應用程式配置Bean較多時，程式啟動較慢，

3. BeanFactory通常以編程的方式被創建，ApplicationContext還能以宣告的方式創建，如使用ContextLoader，

4. BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但兩者之間的區別是：BeanFactory需要手動注冊，而ApplicationContext則是自動注冊，

<!-- 將CellPhone部署成prototype的范圍 -->
<bean id="cellPhone"  scope="prototype" />
<bean id="developer" >
    <!-- getPhone方法回傳CellPhone，每次呼叫將獲取新的CellPhone -->
    <lookup-method name="getPhone" bean="cellPhone" />
</bean>
  
  public class CellPhone implements Phone {
    public CellPhone() {
        System.out.println("Spring實體化依賴的Bean...CellPhone實體");
    }
    public return call() {
        return "正在打電話...";
    }
}

  public abstract class Developer implements Person {
    public Developer() {
        System.out.println("Spring實體化主調的Bean...Developer實體");
    }
    //定義一個抽象方法，該方法將由Spring實作
    public abstract Phone getPhone();
    @Override
    public void call() {
        System.out.println("正在使用 " + getPhone() + " 打電話");
        System.out.println(getPhone().call());
    }
}

  public class Test {
    public static void main(String args[]) {
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Developer d = context.getBean("developer", Developer.class);
        d.call();
        d.call();
    }
}

在applicationgContext.xml檔案中定義了一個bean，id為authService，通過ApplicationContext實體物件的getBean方法獲取到這個bean，這個背后的實作原理是什么？

Spring容器啟動的時候會決議applicationgContext.xml，將xml中定義的bean(如authService)決議成Spring內部的BeanDefinition，并以beanName(如authService)為key，BeanDefinition(如authService相應的BeanDefinition)為value存盤到DefaultListableBeanFactory中的beanDefinitionMap屬性中(其實它就是一個ConcurrentHashMap型別的屬性)，同時將beanName存入beanDefinitionNames中(List型別)，然后遍歷beanDefinitionNames中的beanName，進行bean的實體化并填充屬性，在實體化的程序中，如果有依賴沒有被實體化將先實體化其依賴，然后實體化本身，實體化完成后將實體存入單例bean的快取中，當呼叫getBean方法時，到單例bean的快取中查找，如果找到并經過轉換后回傳這個實體(如AuthService的實體)，之后就可以直接使用了，

說一下xml檔案的決議程序？

代碼中指定要加載的xml檔案后，Spring容器初始化的程序中，通過ResourceLoader介面實作類，例如ClassPathXmlApplicationContext，將xml檔案路徑轉換成對應的Resource檔案，例如ClassPathResource，然后通過DocumentLoader對Resource檔案進行轉換，轉換成Document檔案，接著通過DefaultBeanDefinitionDocumentReader對Document進行決議，并使用BeanDefinitionParserDelegate對元素進行決議，決議xml中bean定義的各個元素，存入BeanDefinition中，

那你再詳細說一下這個BeanDefinition是什么？

一個物件的生命周期要想被Spring容器管理，那么它的類資訊必須先轉成Spring內部的資料結構，BeanDefinition就是Spring框架內部用來描述物件的類資訊的資料結構，例如類名、scope、屬性、建構式引數串列、依賴的bean、是否是單例類、是否是懶加載等，其實就是將Bean的定義資訊存盤到這個BeanDefinition相應的屬性中，后面對Bean的操作就直接對BeanDefinition進行，例如拿到這個BeanDefinition后，可以根據里面的類名、建構式、建構式引數，使用反射進行物件創建，BeanDefinition是一個介面，是一個抽象的定義，實際使用的是其實作類，如ChildBeanDefinition、RootBeanDefinition、GenericBeanDefinition等，BeanDefinition繼承了AttributeAccessor，說明它具有處理屬性的能力；BeanDefinition繼承了BeanMetadataElement，說明它可以持有Bean元資料元素，作用是可以持有XML檔案的一個bean標簽對應的Object，

剛剛你有說到DefaultListableBeanFactory，它在Spring框架中的作用是什么？

DefaultListableBeanFactory是整個Bean加載的核心部分，是Spring注冊及加載Bean的默認實作，DefaultListableBeanFactory間接實作了BeanFactory介面，而在BeanFactory介面中定義了很多和bean操作相關的方法，例如getBean、containsBean、isSingleton等，所以DefaultListableBeanFactory也相應持有了這些操作，

那BeanFactory又是什么？

BeanFactory是用于訪問Spring Bean容器的根介面，是一個單純的Bean工廠，也就是常說的ioc容器的頂層定義，各種ioc容器是在其基礎上為了滿足不同需求而擴展的，包括經常使用的ApplicationContext，

如何理解BeanFactory和FactoryBean？

BeanFactory定義了ioc容器的最基本形式，并提供了ioc容器應遵守的的最基本的介面，也就是Spring ioc所遵守的最底層和最基本的編程規范，它只是個介面，并不是ioc容器的具體實作，它的職責包括：實體化、定位、配置應用程式中的物件及建立這些物件間的依賴，

再來說說FactoryBean，一般情況下，Spring通過反射機制利用bean的class屬性實體化Bean，然而在某些情況下，實體化Bean程序比較復雜，如果按照傳統的方式，則需要在bean的定義中提供大量的配置資訊，而配置這種方式的靈活性是受限的，這時采用編碼的方式可能會是一個比較合適的方案，Spring為此提供了FactoryBean的工廠類介面，用戶可以通過實作該介面定制實體化Bean的邏輯，

如果想在初始化前修改bean的屬性，如何實作？

自定義一個BeanFactoryPostProcessor，讓它實作BeanFactoryPostProcessor介面，并實作postProcessBeanFactory方法，在這個方法中可以在初始化前修改bean的屬性，

這個自定義的BeanFactoryPostProcessor是如何自動呼叫的？

在Spring容器初始化的程序中會自動觸發，具體代碼在AbstractApplicationContext類中會呼叫invokeBeanFactoryPostProcessors方法，在這個方法中篩選出所有實作BeanFactoryPostProcessor介面的類名稱，然后遍歷呼叫這些實作類的postProcessBeanFactory方法，

如果想在bean被初始化時進行攔截，進行額外初始化操作，如何實作？

自定義BeanPostProcessor，讓它實作BeanPostProcessor介面，在這個介面中定義了兩個方法：postProcessBeforeInitialization和postProcessAfterInitialization，postProcessBeforeInitialization方法會在afterPropertiesSet和自定義的初始化方法之前執行，通過實作這個方法，在方法的內部進行初始化之前的額外操作，postProcessAfterInitialization方法會在afterPropertiesSet和自定義的初始化方法之后執行，通過實作這個方法，在方法的內部進行初始化之后的額外操作，

在Spring容器初始化的程序中，所有定義的bean都會被初始化嗎？

不是，默認只初始化所有未初始化的非懶加載的單例Bean，scope為其它值的bean會在使用到的時候進行初始化，如prototype，

有看過Spring中bean初始化的原始碼嗎？

看過，單例bean的初始化，通過反射進行實體物件的創建，在進行屬性填充時，如果依賴的物件沒有創建，則先創建依賴物件，最后將bean實體加入單例bean實體的快取中，

在bean實體化的程序中，Spring是如何解決回圈依賴的？

Spring只對單例bean的回圈依賴進行了解決，同時如果是通過建構式注入造成的回圈依賴，Spring也沒有辦法解決，只是拋出BeanCurrentlyInCreationException例外，如果是通過setter方式注入而產生的回圈依賴，Spring在創建bean物件時，通過提前暴露一個ObjectFactory用來回傳一個創建中的bean物件，從而使其它bean能夠參考到這個bean，

還有Redis、MySQL、Liunx、Spring、Redis以及BATJ面試真題詳解等，需要的話可以點擊：點這個！點這個！暗號：csdn

還有Java核心知識點+全套架構師學習資料和視頻+一線大廠面試寶典+面試簡歷模板可以領取+阿里美團網易騰訊小米愛奇藝快手嗶哩嗶哩面試題+Spring原始碼合集+Java架構實戰電子書，