2021最新 Spring面試題精選（附刷題小程式）

推薦使用小程式閱讀

為了能讓您更加方便的閱讀
本文所有的面試題目均已整理至小程式《面試手冊》
可以通過微信掃描(或長按)下圖的二維碼享受更好的閱讀體驗!

• 推薦使用小程式閱讀
• 1. Spring基礎
  • 1.1 什么是 spring?
  • 1.2 Spring框架的設計目標，設計理念，和核心是什么？
  • 1.3 Spring 框架中都用到了哪些設計模式？
  • 1.4 Spring Framework 中有多少個模塊，它們分別是什么？
  • 1.5 spring context應用背景關系有什么作用？
  • 1.6 Spring 應用程式有哪些不同組件？
  • 1.7 使用 Spring 有哪些方式？
  • 1.8 Spring的優缺點是什么？
  • 1.9 Spring框架中有哪些不同型別的事件？
• 2. Spring IoC
  • 2.1 什么是 Spring IOC 容器？
  • 2.2 控制反轉(IoC)有什么作用？
  • 2.3 可以通過多少種方式完成依賴注入？
  • 2.4 Spring 如何設計容器的，BeanFactory和ApplicationContext的關系詳解?
  • 2.5 IoC 的好處有哪些？
  • 2.6 Spring IoC 的實作機制
  • 2.7 Spring 的 IoC支持哪些功能?
  • 2.8 BeanFactory 和 ApplicationContext有什么區別?
  • 2.9 ApplicationContext通常的實作是什么？
  • 2.10 什么是Spring的依賴注入？
  • 2.11 依賴注入的基本原則是什么？
  • 2.12 依賴注入有什么優勢？
  • 2.13 構造器依賴注入和 Setter方法注入有什么區別？
• 3. Spring Beans
  • 3.1 什么是 spring bean？
  • 3.2 spring 提供了哪些配置方式？
  • 3.3 spring 支持幾種 bean scope？
  • 3.4 spring bean 容器的生命周期是什么樣的？
  • 3.5 什么是 spring 的內部 bean？
  • 3.6 什么是bean裝配？什么是bean的自動裝配？
  • 3.7 自動裝配有哪些方式？
  • 3.8 自動裝配有什么局限？
  • 3.9 使用@Autowired注解自動裝配的程序是怎樣的？
  • 3.10 Spring組態檔包含了哪些資訊？
  • 3.11 Spring基于xml注入bean的幾種方式
  • 3.12 Spring框架中的單例bean是執行緒安全的嗎？
  • 3.13 Spring如何處理執行緒并發問題？
  • 3.14 bean生命周期方法有哪些？ 你能多載它們嗎？
  • 3.15 在 Spring中如何注入一個java集合？
  • 3.16 你可以在Spring中注入一個null 和一個空字串嗎？
• 4. Spring注解
  • 4.1 什么是基于Java的Spring注解配置?
  • 4.2 怎樣開啟注解裝配？
  • 4.3 @Component, @Controller, @Repository, @Service 有何區別？
  • 4.4 @Required 注解有什么作用？
  • 4.5 @Autowired 注解有什么作用？
  • 4.6 @Autowired和@Resource有什么區別？
  • 4.7 @Qualifier注解有什么作用？
  • 4.8 @RequestMapping注解有什么用？
• 5. Spring資料訪問
  • 5.1 解釋物件/關系映射集成模塊
  • 5.2 在Spring框架中如何更有效地使用JDBC？
  • 5.3 解釋JDBC抽象和DAO模塊的作用是什么？
  • 5.4 Spring DAO 有什么用？
  • 5.5 Spring JDBC API 中存在哪些類？
  • 5.6 JdbcTemplate是什么？
  • 5.7 Spring通過什么方式訪問Hibernate？
  • 5.8 如何通過HibernateDaoSupport將Spring和Hibernate結合起來？
  • 5.9 Spring支持的事務管理型別是什么？spring 事務實作方式有哪些？
  • 5.10 Spring事務的實作方式和實作原理是什么？
  • 5.11 Spring的事務傳播行為有那些？
  • 5.12 說一下 Spring 的事務隔離？
  • 5.13 Spring框架的事務管理有哪些優點？
  • 5.14 你更傾向用那種事務管理型別？
• 6. Spring AOP
  • 6.1 什么是AOP？
  • 6.2 Spring AOP and AspectJ AOP 有什么區別？AOP 有哪些實作方式？
  • 6.3 JDK動態代理和CGLIB動態代理的區別是什么？
  • 6.4 如何理解 Spring 中的代理？
  • 6.5 請解釋一下Spring AOP核心的名稱分別是什么意思？
  • 6.6 為什么Spring只支持方法級別的連接點？
  • 6.7 Spring AOP 中，關注點和橫切關注的區別是什么？
  • 6.8 Spring通知有哪些型別？
  • 6.9 什么是切面 Aspect？
  • 6.10 什么是基于XML Schema方式的切面實作？
  • 6.11 什么是基于注解的切面實作？
  • 6.12 有幾種不同型別的自動代理？

1. Spring基礎

1.1 什么是 spring?

Spring是一個輕量級Java開發框架，最早有Rod Johnson創建，目的是為了解決企業級應用開發的業務邏輯層和其他各層的耦合問題，它是一個分層的JavaSE/JavaEE full-stack（一站式）輕量級開源框架，為開發Java應用程式提供全面的基礎架構支持，Spring負責基礎架構，因此Java開發者可以專注于應用程式的開發，

Spring最根本的使命是解決企業級應用開發的復雜性，即簡化Java開發，

Spring可以做很多事情，它為企業級開發提供給了豐富的功能，但是這些功能的底層都依賴于它的兩個核心特性，也就是依賴注入（dependency injection，DI）和面向切面編程（aspect-oriented programming，AOP），

為了降低Java開發的復雜性，Spring采取了以下4種關鍵策略

• 基于POJO的輕量級和最小侵入性編程；
• 通過依賴注入和面向介面實作松耦合；
• 基于切面和慣例進行宣告式編程；
• 通過切面和模板減少樣板式代碼，

1.2 Spring框架的設計目標，設計理念，和核心是什么？

• Spring設計目標：
  Spring為開發者提供一個一站式輕量級應用開發平臺；

• Spring設計理念：
  在JavaEE開發中，支持POJO和JavaBean開發方式，使應用面向介面開發，充分支持OO（面向物件）設計方法；Spring通過IoC容器實作物件耦合關系的管理，并實作依賴反轉，將物件之間的依賴關系交給IoC容器，實作解耦；

• Spring框架的核心：
  IoC容器和AOP模塊，通過IoC容器管理POJO物件以及他們之間的耦合關系；通過AOP以動態非侵入的方式增強服務，

IoC讓相互協作的組件保持松散的耦合，而AOP編程允許你把遍布于應用各層的功能分離出來形成可重用的功能組件，

1.3 Spring 框架中都用到了哪些設計模式？

1. 工廠模式：BeanFactory就是簡單工廠模式的體現，用來創建物件的實體；
2. 單例模式：Bean默認為單例模式，
3. 代理模式：Spring的AOP功能用到了JDK的動態代理和CGLIB位元組碼生成技術；
4. 模板方法：用來解決代碼重復的問題，比如. RestTemplate, JmsTemplate, JpaTemplate，
5. 觀察者模式：定義物件鍵一種一對多的依賴關系，當一個物件的狀態發生改變時，所有依賴于它的物件都會得到通知被制動更新，如Spring中listener的實作–ApplicationListener，

1.4 Spring Framework 中有多少個模塊，它們分別是什么？

Spring 總共大約有 20 個模塊， 由 1300 多個不同的檔案構成， 而這些組件被分別整合在核心容器（Core Container） 、 AOP（Aspect Oriented Programming）和設備支持（Instrmentation） 、資料訪問與集成（Data Access/Integeration） 、 Web、 訊息（Messaging） 、 Test等 幾 個模塊中， 以下是 Spring 5 的模塊結構圖：

• Spring 核心容器
  提供了框架的基本組成部分，包括控制反轉（Inversion of Control，IOC）和依賴注入（Dependency Injection，DI）功能， 它包含以下模塊：

  • Spring Core
  • Spring Bean
  • SpEL (Spring Expression Language)
  • Spring Context

• AOP
  該層支持面向切面編程

• 資料訪問/集成
  該層提供與資料庫互動的支持，它包含以下模塊：

  • JDBC (Java DataBase Connectivity)
  • ORM (Object Relational Mapping)
  • OXM (Object XML Mappers)
  • JMS (Java Messaging Service)
  • Transaction

• Web
  該層提供了創建 Web 應用程式的支持 ， 它包含以下模塊：

  • Web
  • Servlet
  • WSocket
  • Portlet

• Instrumentation
  該層為類檢測和類加載器實作提供支持，

• Test
  該層為使用 JUnit 和 TestNG 進行測驗提供支持，

• 其他模塊

  • Messaging
    該模塊為 STOMP 提供支持 ， 它還支持注解編程模型，該模型用于從
  • WebSocket
    客戶端路由和處理 STOMP 訊息，
  • Aspects
    該模塊為與AspectJ的集成提供支持 ，

1.5 spring context應用背景關系有什么作用？

這是基本的Spring模塊，提供spring 框架的基礎功能，BeanFactory 是 任何以spring為基礎的應用的核心，Spring 框架建立在此模塊之上，它使Spring成為一個容器，

Bean 工廠是工廠模式的一個實作，提供了控制反轉功能，用來把應用的配置和依賴從真正的應用代碼中分離，最常用的就是org.springframework.beans.factory.xml.XmlBeanFactory ，它根據XML檔案中的定義加載beans，該容器從XML 檔案讀取配置元資料并用它去創建一個完全配置的系統或應用，

1.6 Spring 應用程式有哪些不同組件？

Spring 應用一般有以下組件：

• 介面
  定義功能，

• Bean 類
  它包含屬性，setter 和 getter 方法，函式等，

• Spring 面向切面編程（AOP）
  提供面向切面編程的功能，

• Bean 組態檔
  包含類的資訊以及如何配置它們，

• 用戶程式
  它使用介面

1.7 使用 Spring 有哪些方式？

• 作為一個成熟的 Spring Web 應用程式，

• 作為第三方 Web 框架，使用 Spring Frameworks 中間層，

• 用于遠程使用，

• 作為企業級 Java Bean，它可以包裝現有的 POJO（Plain Old Java Objects），

1.8 Spring的優缺點是什么？

• 優點

  • 方便解耦，簡化開發
    Spring就是一個大工廠，可以將所有物件的創建和依賴關系的維護，交給Spring管理，

  • AOP編程的支持
    Spring提供面向切面編程，可以方便的實作對程式進行權限攔截、運行監控等功能，

  • 宣告式事務的支持
    只需要通過配置就可以完成對事務的管理，而無需手動編程，

  • 方便程式的測驗
    Spring對Junit4支持，可以通過注解方便的測驗Spring程式，

  • 方便集成各種優秀框架
    Spring不排斥各種優秀的開源框架，其內部提供了對各種優秀框架的直接支持（如：Struts、Hibernate、MyBatis等），

  • 降低JavaEE API的使用難度
    Spring對JavaEE開發中非常難用的一些API（JDBC、JavaMail、遠程呼叫等），都提供了封裝，使這些API應用難度大大降低，

• 缺點

  • Spring明明一個很輕量級的框架，卻給人感覺大而全
  • Spring依賴反射，反射影響性能
  • 使用門檻升高，入門Spring需要較長時間

1.9 Spring框架中有哪些不同型別的事件？

Spring 提供了以下5種標準的事件：

1. 背景關系更新事件（ContextRefreshedEvent）：
   在呼叫ConfigurableApplicationContext 介面中的refresh()方法時被觸發，
2. 背景關系開始事件（ContextStartedEvent）：
   當容器呼叫ConfigurableApplicationContext的Start()方法開始/重新開始容器時觸發該事件，
3. 背景關系停止事件（ContextStoppedEvent）：
   當容器呼叫ConfigurableApplicationContext的Stop()方法停止容器時觸發該事件，
4. 背景關系關閉事件（ContextClosedEvent）：
   當ApplicationContext被關閉時觸發該事件，容器被關閉時，其管理的所有單例Bean都被銷毀，
5. 請求處理事件（RequestHandledEvent）：
   在Web應用中，當一個http請求（request）結束觸發該事件，如果一個bean實作了ApplicationListener介面，當一個ApplicationEvent 被發布以后，bean會自動被通知，

2. Spring IoC

2.1 什么是 Spring IOC 容器？

控制反轉即IoC (Inversion of Control)，它把傳統上由程式代碼直接操控的物件的呼叫權交給容器，通過容器來實作物件組件的裝配和管理，所謂的“控制反轉”概念就是對組件物件控制權的轉移，從程式代碼本身轉移到了外部容器，

Spring IOC 負責創建物件，管理物件（通過依賴注入（DI），裝配物件，配置物件，并且管理這些物件的整個生命周期

2.2 控制反轉(IoC)有什么作用？

• 管理物件的創建和依賴關系的維護，物件的創建并不是一件簡單的事，在物件關系比較復雜時，如果依賴關系需要程式猿來維護的話，那是相當頭疼的
• 解耦，由容器去維護具體的物件
• 托管了類的產生程序，比如我們需要在類的產生程序中做一些處理，最直接的例子就是代理，如果有容器程式可以把這部分處理交給容器，應用程式則無需去關心類是如何完成代理的

2.3 可以通過多少種方式完成依賴注入？

通常，依賴注入可以通過三種方式完成，即：

• 建構式注入

• setter 注入

• 介面注入（由于在靈活性和易用性比較差，現在從Spring4開始已被廢棄）

2.4 Spring 如何設計容器的，BeanFactory和ApplicationContext的關系詳解?

Spring 作者 Rod Johnson 設計了兩個介面用以表示容器，

• BeanFactory
• ApplicationContext

BeanFactory 簡單粗暴，可以理解為就是個 HashMap，Key 是 BeanName，Value 是 Bean 實體，通常只提供注冊（put），獲取（get）這兩個功能，我們可以稱之為 “低級容器”，

ApplicationContext 可以稱之為 “高級容器”，因為他比 BeanFactory 多了更多的功能，他繼承了多個介面，因此具備了更多的功能，例如資源的獲取，支持多種訊息（例如 JSP tag 的支持），對 BeanFactory 多了工具級別的支持等待，所以你看他的名字，已經不是 BeanFactory 之類的工廠了，而是 “應用背景關系”， 代表著整個大容器的所有功能，該介面定義了一個 refresh 方法，此方法是所有閱讀 Spring 原始碼的人的最熟悉的方法，用于重繪整個容器，即重新加載/重繪所有的 bean，

當然，除了這兩個大介面，還有其他的輔助介面，這里就不介紹他們了，

BeanFactory和ApplicationContext的關系

為了更直觀的展示 “低級容器” 和 “高級容器” 的關系，這里通過常用的 ClassPathXmlApplicationContext 類來展示整個容器的層級 UML 關系，

最上面的是 BeanFactory，下面的 3 個綠色的，都是功能擴展介面，這里就不展開講，

看下面的隸屬 ApplicationContext 粉紅色的 “高級容器”，依賴著 “低級容器”，這里說的是依賴，不是繼承哦，他依賴著 “低級容器” 的 getBean 功能，而高級容器有更多的功能：支持不同的資訊源頭，可以訪問檔案資源，支持應用事件（Observer 模式），

通常用戶看到的就是 “高級容器”， 但 BeanFactory 也非常夠用啦！

左邊灰色區域的是 “低級容器”， 只負載加載 Bean，獲取 Bean，容器其他的高級功能是沒有的，例如上圖畫的 refresh 重繪 Bean 工廠所有配置，生命周期事件回呼等，

小結

說了這么多，不知道你有沒有理解Spring IoC？ 這里小結一下：IoC 在 Spring 里，只需要低級容器就可以實作，2 個步驟：

1. 加載組態檔，決議成 BeanDefinition 放在 Map 里，
2. 呼叫 getBean 的時候，從 BeanDefinition 所屬的 Map 里，拿出 Class 物件進行實體化，同時，如果有依賴關系，將遞回呼叫 getBean 方法 —— 完成依賴注入，

上面就是 Spring 低級容器（BeanFactory）的 IoC，

至于高級容器 ApplicationContext，他包含了低級容器的功能，當他執行 refresh 模板方法的時候，將重繪整個容器的 Bean，同時其作為高級容器，包含了太多的功能，一句話，他不僅僅是 IoC，他支持不同資訊源頭，支持 BeanFactory 工具類，支持層級容器，支持訪問檔案資源，支持事件發布通知，支持介面回呼等等，

2.5 IoC 的好處有哪些？

1. 它將最小化應用程式中的代碼量，
2. 它將使您的應用程式易于測驗，因為它不需要單元測驗用例中的任何單例
3. 或JNDI 查找機制，
4. 它以最小的影響和最少的侵入機制促進松耦合，
5. 它支持即時的實體化和延遲加載服務，

2.6 Spring IoC 的實作機制

Spring 中的 IoC 的實作原理就是工廠模式加反射機制 ，
示例：

interface Fruit {
  public abstract void eat();
}

class Apple implements Fruit {
  public void eat(){
    System.out.println("Apple");
  }
}
class Orange implements Fruit {
  public void eat(){
    System.out.println("Orange");
  }
}
class Factory {
  public static Fruit getInstance(String ClassName) { 
    Fruit f=null;
    try {
      f=(Fruit)Class.forName(ClassName).newInstance(); } catch (Exception e) {
    e.printStackTrace();
    }
    return f;
  }
}

class Client {
  public static void main(String[] a) {
    Fruit f=Factory.getInstance("com.xxx.xxx.Apple");
    if(f!=null){
      f.eat();
    } 
  }
}

2.7 Spring 的 IoC支持哪些功能?

Spring 的 IoC 設計支持以下功能：

• 依賴注入
• 依賴檢查
• 自動裝配
• 支持集合
• 指定初始化方法和銷毀方法
• 支持回呼某些方法（但是需要實作 Spring 介面，略有侵入）

其中，最重要的就是依賴注入，從 XML 的配置上說，即 ref 標簽，對應 Spring RuntimeBeanReference 物件，

對于 IoC 來說，最重要的就是容器，容器管理著 Bean 的生命周期，控制著 Bean 的依賴注入，

2.8 BeanFactory 和 ApplicationContext有什么區別?

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

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

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

• 加載方式
  BeanFactroy采用的是延遲加載形式來注入Bean的，即只有在使用到某個Bean時(呼叫getBean())，才對該Bean進行加載實體化，這樣，我們就不能發現一些存在的Spring的配置問題，如果Bean的某一個屬性沒有注入，BeanFacotry加載后，直至第一次使用呼叫getBean方法才會拋出例外，
  ApplicationContext，它是在容器啟動時，一次性創建了所有的Bean，這樣，在容器啟動時，我們就可以發現Spring中存在的配置錯誤，這樣有利于檢查所依賴屬性是否注入， ApplicationContext啟動后預載入所有的單實體Bean，通過預載入單實體bean ,確保當你需要的時候，你就不用等待，因為它們已經創建好了，
  相對于基本的BeanFactory，ApplicationContext 唯一的不足是占用記憶體空間，當應用程式配置Bean較多時，程式啟動較慢，

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

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

2.9 ApplicationContext通常的實作是什么？

• FileSystemXmlApplicationContext ：
  此容器從一個XML檔案中加載beans的定義，XML Bean 組態檔的全路徑名必須提供給它的建構式，

• ClassPathXmlApplicationContext：
  此容器也從一個XML檔案中加載beans的定義，這里，你需要正確設定classpath因為這個容器將在classpath里找bean配置，

• WebXmlApplicationContext：
  此容器加載一個XML檔案，此檔案定義了一個WEB應用的所有bean，

2.10 什么是Spring的依賴注入？

控制反轉IoC是一個很大的概念，可以用不同的方式來實作，其主要實作方式有兩種：依賴注入和依賴查找

依賴注入：相對于IoC而言，依賴注入(DI)更加準確地描述了IoC的設計理念，所謂依賴注入（Dependency Injection），即組件之間的依賴關系由容器在應用系統運行期來決定，也就是由容器動態地將某種依賴關系的目標物件實體注入到應用系統中的各個關聯的組件之中，組件不做定位查詢，只提供普通的Java方法讓容器去決定依賴關系，

2.11 依賴注入的基本原則是什么？

依賴注入的基本原則是：應用組件不應該負責查找資源或者其他依賴的協作物件，配置物件的作業應該由IoC容器負責，“查找資源”的邏輯應該從應用組件的代碼中抽取出來，交給IoC容器負責，容器全權負責組件的裝配，它會把符合依賴關系的物件通過屬性（JavaBean中的setter）或者是構造器傳遞給需要的物件，

2.12 依賴注入有什么優勢？

依賴注入之所以更流行是因為它是一種更可取的方式：讓容器全權負責依賴查詢，受管組件只需要暴露JavaBean的setter方法或者帶引數的構造器或者介面，使容器可以在初始化時組裝物件的依賴關系，其與依賴查找方式相比，主要優勢為：

• 查找定位操作與應用代碼完全無關，
• 不依賴于容器的API，可以很容易地在任何容器以外使用應用物件，
• 不需要特殊的介面，絕大多數物件可以做到完全不必依賴容器，

2.13 構造器依賴注入和 Setter方法注入有什么區別？

兩種依賴方式都可以使用，構造器注入和Setter方法注入，最好的解決方案是用構造器引數實作強制依賴，setter方法實作可選依賴，

3. Spring Beans

3.1 什么是 spring bean？

1. 它們是構成用戶應用程式主干的物件，
2. Bean 由 Spring IoC 容器管理，
3. 它們由 Spring IoC 容器實體化，配置，裝配和管理，
4. Bean 是基于用戶提供給容器的配置元資料創建，

3.2 spring 提供了哪些配置方式？

• 基于xml配置
  bean 所需的依賴項和服務在 XML 格式的組態檔中指定 ， 這些組態檔通常包含許多 bean 定義和特定于應用程式的配置選項， 它們通常以 bean 標簽開頭，例如：

  <bean id="studentbean" > 
    <property name="name" value="https://www.cnblogs.com/pengfeilu/p/Edureka"></property>
  </bean>
  

• 基于注解配置
  您可以通過在相關的類，方法或欄位宣告上使用注解，將 bean 配置為組件類本身，而不是使用 XML 來描述 bean 裝配， 默認情況下， Spring 容器中未打開注解裝配， 因此，您需要在使用它之前在 Spring 組態檔中啟用它， 例如：

  <beans>
  <context:annotation-config/>
  <!-- bean definitions go here -->
  </beans>
  

• 基于 Java API 配置
  Spring的Java配置是通過使用@Bean和@Configuration來實作 ，

  • @Bean
    注解扮演與元素相同的角色 ，
  • @Configuration 類
    允許通過簡單地呼叫同一個類中的其他@Bean方法來定義bean間依賴關系，

  例如：

  @Configuration
  public class StudentConfig {
    @Bean
    public StudentBean myStudent() {
      return new StudentBean();
    }
  }
  

3.3 spring 支持幾種 bean scope？

Spring bean 支持5種scope：

• Singleton
  每個 Spring IoC 容器僅有一個單實體 ，
• Prototype
  每次請求都會產生一個新的實體，
• Request
  每一次 HTTP 請求都會產生一個新的實體，并且該 bean 僅在當前 HTTP 請求內有效，
• Session
  每一次 HTTP 請求都會產生一個新的 bean，同時該 bean 僅在當前 HTTP session 內有效，
• Global-session
  類似于標準的 HTTP Session 作用域，不過它僅僅在基于 portlet 的 web 應用中才有意義 ， Portlet 規范定義了全域 Session 的概念，它被所有構成某個 portlet web 應用的各種不同的 portlet 所共享， 在 global session 作用域中定義的 bean 被限定于全域 portlet Session 的生命周期范圍內， 如果你在 web 中使用 global session 作用域來標識 bean，那么 web 會自動當成 session 型別來使用，

僅當用戶使用支持Web的ApplicationContext時，最后三個才可用 ，

3.4 spring bean 容器的生命周期是什么樣的？

spring bean 容器的生命周期流程如下：

1、Spring 容器根據配置中的 bean 定義中實體化 bean，
2、Spring 使用依賴注入填充所有屬性，如 bean 中所定義的配置，
3、如果 bean 實作 BeanNameAware 介面，則工廠通過傳遞 bean 的 ID 來呼叫setBeanName()，
4、如果 bean 實作 BeanFactoryAware 介面，工廠通過傳遞自身的實體來呼叫 setBeanFactory()，
5、如果存在與 bean 關聯的任何BeanPostProcessors，則呼叫 preProcessBeforeInitialization() 方法 ，
6、如果為 bean 指定了 init 方法（ 的 init-method 屬性），那么將呼叫它，
7、最后，如果存在與 bean 關聯的任何 BeanPostProcessors，則將呼叫 postProcessAfterInitialization() 方法，
8、如果 bean 實作 DisposableBean 介面，當 spring 容器關閉時，會呼叫 destory()，
9、如果為 bean 指定了 destroy 方法（ 的 destroy-method 屬性），那么將呼叫它，

3.5 什么是 spring 的內部 bean？

只有將 bean 用作另一個 bean 的屬性時，才能將 bean 宣告為內部 bean，為了定義 bean， Spring 的基于 XML 的配置元資料在 或 中提供了 元素的使用 ， 內部 bean 總是匿名的，它們總是作為原型，

例如，假設我們有一個 Student 類，其中參考了 Person 類， 這里我們將只創建一個 Person 類實體并在 Student 中使用它，

Student.java

public class Student {
  private Person person;
  //Setters and Getters
}

Person.java

public class Person {
  private String name;
  private String address;
  //Setters and Getters
}

bean.xml

<bean id=“StudentBean" > 
  <property name="person">
    <!--This is inner bean -->
    <bean >
      <property name="name" value=https://www.cnblogs.com/pengfeilu/p/“Scott"></property> <property name="address" value="https://www.cnblogs.com/pengfeilu/p/Bangalore"></property>
    </bean>
  </property>
</bean>

3.6 什么是bean裝配？什么是bean的自動裝配？

裝配，或bean裝配是指在Spring容器中把bean組裝到一起，前提是容器需要知道bean的依賴關系，如何通過依賴注入來把它們裝配到一起，

在Spring框架中，在組態檔中設定bean的依賴關系是一個很好的機制，Spring 容器能夠自動裝配相互合作的bean，這意味著容器不需要和配置，能通過Bean工廠自動處理bean之間的協作，這意味著 Spring可以通過向Bean Factory中注入的方式自動搞定bean之間的依賴關系，自動裝配可以設定在每個bean上，也可以設定在特定的bean上，

3.7 自動裝配有哪些方式？

Spring容器能夠自動裝配bean，也就是說，可以通過檢查BeanFactory的內容讓Spring自動決議bean的協作者，

自動裝配的不同模式：

• no
  這是默認設定，表示沒有自動裝配 ， 應使用顯式 bean 參考進行裝配 ，
• byName
  它根據 bean 的名稱注入物件依賴項 ， 它匹配并裝配其屬性與 XML 檔案中由相同名稱定義的 bean，
• byType
  它根據型別注入物件依賴項，如 果屬性的型別與 XML 檔案中的一個 bean 名稱匹配，則匹配并裝配屬性，
• 建構式
  它通過呼叫類的建構式來注入依賴項 ，它有大量的引數 ，
• autodetect
  首先容器嘗試通過建構式使用 autowire 裝配，如果不能，則嘗試通過 byType 自動裝配，

3.8 自動裝配有什么局限？

• 覆寫的可能性
  您始終可以使用 和 設定指定依賴項，這將覆寫自動裝配，
• 基本元資料型別
  簡單屬性（如原資料型別，字串和類）無法自動裝配，
• 模糊特性
  自動裝配不如顯式裝配精確，如果有可能，建議使用顯式裝配，

3.9 使用@Autowired注解自動裝配的程序是怎樣的？

使用@Autowired注解來自動裝配指定的bean，在使用@Autowired注解之前需要在Spring組態檔進行配置，<context:annotation-config />，

在啟動spring IoC時，容器自動裝載了一個AutowiredAnnotationBeanPostProcessor后置處理器，當容器掃描到@Autowied、@Resource或@Inject時，就會在IoC容器自動查找需要的bean，并裝配給該物件的屬性，在使用@Autowired時，首先在容器中查詢對應型別的bean：

• 如果查詢結果剛好為一個，就將該bean裝配給@Autowired指定的資料；
• 如果查詢的結果不止一個，那么@Autowired會根據名稱來查找；
• 如果上述查找的結果為空，那么會拋出例外，解決方法時，使用required=false，

3.10 Spring組態檔包含了哪些資訊？

Spring組態檔是個XML 檔案，這個檔案包含了類資訊，描述了如何配置它們，以及如何相互呼叫，

3.11 Spring基于xml注入bean的幾種方式

1. Set方法注入；
2. 構造器注入：
   • 通過index設定引數的位置；
   • 通過type設定引數型別；
3. 靜態工廠注入；
4. 實體工廠；

3.12 Spring框架中的單例bean是執行緒安全的嗎？

不是，Spring框架中的單例bean不是執行緒安全的，

spring 中的 bean 默認是單例模式，spring 框架并沒有對單例 bean 進行多執行緒的封裝處理，

實際上大部分時候 spring bean 無狀態的（比如 dao 類），所有某種程度上來說 bean 也是安全的，但如果 bean 有狀態的話（比如 view model 物件），那就要開發者自己去保證執行緒安全了，最簡單的就是改變 bean 的作用域，把“singleton”變更為“prototype”，這樣請求 bean 相當于 new Bean()了，所以就可以保證執行緒安全了，

• 有狀態就是有資料存盤功能，
• 無狀態就是不會保存資料，

3.13 Spring如何處理執行緒并發問題？

在一般情況下，只有無狀態的Bean才可以在多執行緒環境下共享，在Spring中，絕大部分Bean都可以宣告為singleton作用域，因為Spring對一些Bean中非執行緒安全狀態采用ThreadLocal進行處理，解決執行緒安全問題，

ThreadLocal和執行緒同步機制都是為了解決多執行緒中相同變數的訪問沖突問題，同步機制采用了“時間換空間”的方式，僅提供一份變數，不同的執行緒在訪問前需要獲取鎖，沒獲得鎖的執行緒則需要排隊，而ThreadLocal采用了“空間換時間”的方式，

ThreadLocal會為每一個執行緒提供一個獨立的變數副本，從而隔離了多個執行緒對資料的訪問沖突，因為每一個執行緒都擁有自己的變數副本，從而也就沒有必要對該變數進行同步了，ThreadLocal提供了執行緒安全的共享物件，在撰寫多執行緒代碼時，可以把不安全的變數封裝進ThreadLocal，

3.14 bean生命周期方法有哪些？ 你能多載它們嗎？

有兩個重要的bean 生命周期方法：

• 第一個是setup ：
  它是在容器加載bean的時候被呼叫，
• 第二個方法是 teardown ：
  它是在容器卸載類的時候被呼叫，

bean 標簽有兩個重要的屬性（init-method和destroy-method），用它們你可以自己定制初始化和注銷方法，它們也有相應的注解（@PostConstruct和@PreDestroy），

3.15 在 Spring中如何注入一個java集合？

Spring提供以下幾種集合的配置元素：

1. 型別用于注入一列值，允許有相同的值，
2. 型別用于注入一組值，不允許有相同的值，
3. 型別用于注入一組鍵值對，鍵和值都可以為任意型別，
4. 型別用于注入一組鍵值對，鍵和值都只能為String型別，

3.16 你可以在Spring中注入一個null 和一個空字串嗎？

可以，

4. Spring注解

4.1 什么是基于Java的Spring注解配置?

基于Java的配置，允許你在少量的Java注解的幫助下，進行你的大部分Spring配置而非通過XML檔案，

以@Configuration 注解為例，它用來標記類可以當做一個bean的定義，被Spring IOC容器使用，

另一個例子是@Bean注解，它表示此方法將要回傳一個物件，作為一個bean注冊進Spring應用背景關系，

@Configuration
public class StudentConfig {
    @Bean
    public StudentBean myStudent() {
        return new StudentBean();
    }
}

4.2 怎樣開啟注解裝配？

注解裝配在默認情況下是不開啟的，為了使用注解裝配，我們必須在Spring組態檔中配置 <context:annotation-config/>元素，

4.3 @Component, @Controller, @Repository, @Service 有何區別？

• @Component：
  這將 java 類標記為 bean，它是任何 Spring 管理組件的通用構造型，spring 的組件掃描機制現在可以將其拾取并將其拉入應用程式環境中，

• @Controller：
  這將一個類標記為 Spring Web MVC 控制器，標有它的 Bean 會自動匯入到 IoC 容器中，

• @Service：
  此注解是組件注解的特化，它不會對 @Component 注解提供任何其他行為，您可以在服務層類中使用 @Service 而不是 @Component，因為它以更好的方式指定了意圖，

• @Repository：
  這個注解是具有類似用途和功能的 @Component 注解的特化，它為 DAO 提供了額外的好處，它將 DAO 匯入 IoC 容器，并使未經檢查的例外有資格轉換為 Spring DataAccessException，

4.4 @Required 注解有什么作用？

這個注解表明bean的屬性必須在配置的時候設定，通過一個bean定義的顯式的屬性值或通過自動裝配，若@Required注解的bean屬性未被設定，容器將拋出BeanInitializationException，示例：

public class Employee {
    private String name;
    @Required
    public void setName(String name){
        this.name=name;
    }
    public string getName(){
        return name;
    }
}

4.5 @Autowired 注解有什么作用？

@Autowired默認是按照型別裝配注入的，默認情況下它要求依賴物件必須存在（可以設定它required屬性為false），@Autowired 注解提供了更細粒度的控制，包括在何處以及如何完成自動裝配，它的用法和@Required一樣，修飾setter方法、構造器、屬性或者具有任意名稱和/或多個引數的PN方法，

public class Employee {
    private String name;
    @Autowired
    public void setName(String name) {
        this.name=name;
    }
    public string getName(){
        return name;
    }
}

4.6 @Autowired和@Resource有什么區別？

@Autowired可用于：建構式、成員變數、Setter方法

@Autowired和@Resource之間的區別

• @Autowired默認是按照型別裝配注入的，默認情況下它要求依賴物件必須存在（可以設定它required屬性為false），
• @Resource默認是按照名稱來裝配注入的，只有當找不到與名稱匹配的bean才會按照型別來裝配注入，

4.7 @Qualifier注解有什么作用？

當您創建多個相同型別的 bean 并希望僅使用屬性裝配其中一個 bean 時，您可以使用@Qualifier 注解和 @Autowired 通過指定應該裝配哪個確切的 bean 來消除歧義，

4.8 @RequestMapping注解有什么用？

@RequestMapping 注解用于將特定 HTTP 請求方法映射到將處理相應請求的控制器中的特定類/方法，此注釋可應用于兩個級別：

• 類級別：
  映射請求的 URL
• 方法級別：
  • 映射 URL
  • HTTP 請求方法

5. Spring資料訪問

5.1 解釋物件/關系映射集成模塊

Spring 通過提供ORM模塊，支持我們在直接JDBC之上使用一個物件/關系映射映射(ORM)工具，Spring 支持集成主流的ORM框架，如Hiberate，JDO和 iBATIS，JPA，TopLink，JDO，OJB ，Spring的事務管理同樣支持以上所有ORM框架及JDBC，

5.2 在Spring框架中如何更有效地使用JDBC？

使用Spring JDBC 框架，資源管理和錯誤處理的代價都會被減輕，所以開發者只需寫statements 和 queries從資料存取資料，JDBC也可以在Spring框架提供的模板類的幫助下更有效地被使用，這個模板叫JdbcTemplate

5.3 解釋JDBC抽象和DAO模塊的作用是什么？

通過使用JDBC抽象和DAO模塊，保證資料庫代碼的簡潔，并能避免資料庫資源錯誤關閉導致的問題，它在各種不同的資料庫的錯誤資訊之上，提供了一個統一的例外訪問層，它還利用Spring的AOP 模塊給Spring應用中的物件提供事務管理服務，

5.4 Spring DAO 有什么用？

Spring DAO（資料訪問物件） 使得 JDBC，Hibernate 或 JDO 這樣的資料訪問技術更容易以一種統一的方式作業，這使得用戶容易在持久性技術之間切換，它還允許您在撰寫代碼時，無需考慮捕獲每種技術不同的例外，

5.5 Spring JDBC API 中存在哪些類？

1. JdbcTemplate
2. SimpleJdbcTemplate
3. NamedParameterJdbcTemplate
4. SimpleJdbcInsert
5. SimpleJdbcCall

5.6 JdbcTemplate是什么？

JdbcTemplate 類提供了很多便利的方法解決諸如把資料庫資料轉變成基本資料型別或物件，執行寫好的或可呼叫的資料庫操作陳述句，提供自定義的資料錯誤處理，

5.7 Spring通過什么方式訪問Hibernate？

在Spring中有兩種方式訪問Hibernate：

• 使用 Hibernate 模板和回呼進行控制反轉
• 擴展 HibernateDAOSupport 并應用 AOP 攔截器節點

5.8 如何通過HibernateDaoSupport將Spring和Hibernate結合起來？

用Spring的 SessionFactory 呼叫 LocalSessionFactory，集成程序分三步：

• 配置the Hibernate SessionFactory
• 繼承HibernateDaoSupport實作一個DAO
• 在AOP支持的事務中裝配

5.9 Spring支持的事務管理型別是什么？spring 事務實作方式有哪些？

Spring支持兩種型別的事務管理：

• 編程式事務管理：
  這意味你通過編程的方式管理事務，給你帶來極大的靈活性，但是難維護，

• 宣告式事務管理：
  這意味著你可以將業務代碼和事務管理分離，你只需用注解和XML配置來管理事務，

5.10 Spring事務的實作方式和實作原理是什么？

Spring事務的本質其實就是資料庫對事務的支持，沒有資料庫的事務支持，spring是無法提供事務功能的，真正的資料庫層的事務提交和回滾是通過binlog或者redo log實作的，

5.11 Spring的事務傳播行為有那些？

Spring事務的傳播行為說的是，當多個事務同時存在的時候，spring如何處理這些事務的行為，

1. PROPAGATION_REQUIRED：
   如果當前沒有事務，就創建一個新事務，如果當前存在事務，就加入該事務，該設定是最常用的設定，
2. PROPAGATION_SUPPORTS：
   支持當前事務，如果當前存在事務，就加入該事務，如果當前不存在事務，就以非事務執行，
3. PROPAGATION_MANDATORY：
   支持當前事務，如果當前存在事務，就加入該事務，如果當前不存在事務，就拋出例外，
4. PROPAGATION_REQUIRES_NEW：
   創建新事務，無論當前存不存在事務，都創建新事務，
5. PROPAGATION_NOT_SUPPORTED：
   以非事務方式執行操作，如果當前存在事務，就把當前事務掛起，
6. PROPAGATION_NEVER：
   以非事務方式執行，如果當前存在事務，則拋出例外，
7. PROPAGATION_NESTED：
   如果當前存在事務，則在嵌套事務內執行，如果當前沒有事務，則按REQUIRED屬性執行，

5.12 說一下 Spring 的事務隔離？

spring 有五大隔離級別，默認值為 ISOLATION_DEFAULT（使用資料庫的設定），其他四個隔離級別和資料庫的隔離級別一致：

1. ISOLATION_DEFAULT：用底層資料庫的設定隔離級別，資料庫設定的是什么我就用什么；
2. ISOLATION_READ_UNCOMMITTED：未提交讀，最低隔離級別、事務未提交前，就可被其他事務讀取（會出現幻讀、臟讀、不可重復讀）；
3. ISOLATION_READ_COMMITTED：提交讀，一個事務提交后才能被其他事務讀取到（會造成幻讀、不可重復讀），SQL server 的默認級別；
4. ISOLATION_REPEATABLE_READ：可重復讀，保證多次讀取同一個資料時，其值都和事務開始時候的內容是一致，禁止讀取到別的事務未提交的資料（會造成幻讀），MySQL 的默認級別；
5. ISOLATION_SERIALIZABLE：序列化，代價最高最可靠的隔離級別，該隔離級別能防止臟讀、不可重復讀、幻讀，

臟讀 ：表示一個事務能夠讀取另一個事務中還未提交的資料，比如，某個事務嘗試插入記錄 A，此時該事務還未提交，然后另一個事務嘗試讀取到了記錄 A，

不可重復讀 ：是指在一個事務內，多次讀同一資料，

幻讀 ：指同一個事務內多次查詢回傳的結果集不一樣，比如同一個事務 A 第一次查詢時候有 n 條記錄，但是第二次同等條件下查詢卻有 n+1 條記錄，這就好像產生了幻覺，發生幻讀的原因也是另外一個事務新增或者洗掉或者修改了第一個事務結果集里面的資料，同一個記錄的資料內容被修改了，所有資料行的記錄就變多或者變少了，

5.13 Spring框架的事務管理有哪些優點？

• 為不同的事務API 如 JTA，JDBC，Hibernate，JPA 和JDO，提供一個不變的編程模式，
• 為編程式事務管理提供了一套簡單的API而不是一些復雜的事務API
• 支持宣告式事務管理，
• 和Spring各種資料訪問抽象層很好得集成，

5.14 你更傾向用那種事務管理型別？

大多數Spring框架的用戶選擇宣告式事務管理，因為它對應用代碼的影響最小，因此更符合一個無侵入的輕量級容器的思想，宣告式事務管理要優于編程式事務管理，雖然比編程式事務管理（這種方式允許你通過代碼控制事務）少了一點靈活性，唯一不足地方是，最細粒度只能作用到方法級別，無法做到像編程式事務那樣可以作用到代碼塊級別，

6. Spring AOP

6.1 什么是AOP？

OOP(Object-Oriented Programming)面向物件編程，允許開發者定義縱向的關系，但并適用于定義橫向的關系，導致了大量代碼的重復，而不利于各個模塊的重用，

AOP(Aspect-Oriented Programming)，一般稱為面向切面編程，作為面向物件的一種補充，用于將那些與業務無關，但卻對多個物件產生影響的公共行為和邏輯，抽取并封裝為一個可重用的模塊，這個模塊被命名為“切面”（Aspect），減少系統中的重復代碼，降低了模塊間的耦合度，同時提高了系統的可維護性，可用于權限認證、日志、事務處理等，

6.2 Spring AOP and AspectJ AOP 有什么區別？AOP 有哪些實作方式？

AOP實作的關鍵在于 代理模式，AOP代理主要分為靜態代理和動態代理，靜態代理的代表為AspectJ；動態代理則以Spring AOP為代表，

1. AspectJ是靜態代理的增強，所謂靜態代理，就是AOP框架會在編譯階段生成AOP代理類，因此也稱為編譯時增強，他會在編譯階段將AspectJ(切面)織入到Java位元組碼中，運行的時候就是增強之后的AOP物件，

2. Spring AOP使用的動態代理，所謂的動態代理就是說AOP框架不會去修改位元組碼，而是每次運行時在記憶體中臨時為方法生成一個AOP物件，這個AOP物件包含了目標物件的全部方法，并且在特定的切點做了增強處理，并回呼原物件的方法，

6.3 JDK動態代理和CGLIB動態代理的區別是什么？

Spring AOP中的動態代理主要有兩種方式，JDK動態代理和CGLIB動態代理：

• JDK動態代理只提供介面的代理，不支持類的代理，核心InvocationHandler介面和Proxy類，InvocationHandler 通過invoke()方法反射來呼叫目標類中的代碼，動態地將橫切邏輯和業務編織在一起；接著，Proxy利用 InvocationHandler動態創建一個符合某一介面的的實體, 生成目標類的代理物件，
• 如果代理類沒有實作 InvocationHandler 介面，那么Spring AOP會選擇使用CGLIB來動態代理目標類，CGLIB（Code Generation Library），是一個代碼生成的類別庫，可以在運行時動態的生成指定類的一個子類物件，并覆寫其中特定方法并添加增強代碼，從而實作AOP，CGLIB是通過繼承的方式做的動態代理，因此如果某個類被標記為final，那么它是無法使用CGLIB做動態代理的，

靜態代理與動態代理區別在于生成AOP代理物件的時機不同，相對來說AspectJ的靜態代理方式具有更好的性能，但是AspectJ需要特定的編譯器進行處理，而Spring AOP則無需特定的編譯器處理，

InvocationHandler 的 invoke(Object proxy,Method method,Object[] args)：proxy是最終生成的代理實體; method 是被代理目標實體的某個具體方法; args 是被代理目標實體某個方法的具體入參, 在方法反射呼叫時使用，

6.4 如何理解 Spring 中的代理？

將 Advice 應用于目標物件后創建的物件稱為代理，在客戶端物件的情況下，目標物件和代理物件是相同的，

Advice + Target Object = Proxy

6.5 請解釋一下Spring AOP核心的名稱分別是什么意思？

1. 切面（Aspect）：
   切面是通知和切點的結合，通知和切點共同定義了切面的全部內容， 在Spring AOP中，切面可以使用通用類（基于模式的風格） 或者在普通類中以 @AspectJ 注解來實作，
2. 連接點（Join point）：
   指方法，在Spring AOP中，一個連接點 總是 代表一個方法的執行， 應用可能有數以千計的時機應用通知，這些時機被稱為連接點，連接點是在應用執行程序中能夠插入切面的一個點，這個點可以是呼叫方法時、拋出例外時、甚至修改一個欄位時，切面代碼可以利用這些點插入到應用的正常流程之中，并添加新的行為，
3. 通知（Advice）：
   在AOP術語中，切面的作業被稱為通知，
4. 切入點（Pointcut）：
   切點的定義會匹配通知所要織入的一個或多個連接點，我們通常使用明確的類和方法名稱，或是利用正則運算式定義所匹配的類和方法名稱來指定這些切點，
5. 引入（Introduction）：
   引入允許我們向現有類添加新方法或屬性，
6. 目標物件（Target Object）：
   被一個或者多個切面（aspect）所通知（advise）的物件，它通常是一個代理物件，也有人把它叫做 被通知（adviced） 物件， 既然Spring AOP是通過運行時代理實作的，這個物件永遠是一個 被代理（proxied） 物件，
7. 織入（Weaving）：
   織入是把切面應用到目標物件并創建新的代理物件的程序，在目標物件的生命周期里有多少個點可以進行織入：
   • 編譯期：切面在目標類編譯時被織入，AspectJ的織入編譯器是以這種方式織入切面的，
   • 類加載期：切面在目標類加載到JVM時被織入，需要特殊的類加載器，它可以在目標類被引入應用之前增強該目標類的位元組碼，AspectJ5的加載時織入就支持以這種方式織入切面，
   • 運行期：切面在應用運行的某個時刻被織入，一般情況下，在織入切面時，AOP容器會為目標物件動態地創建一個代理物件，SpringAOP就是以這種方式織入切面，

6.6 為什么Spring只支持方法級別的連接點？

因為Spring基于動態代理，所以Spring只支持方法連接點，Spring缺少對欄位連接點的支持，而且它不支持構造器連接點，方法之外的連接點攔截功能，我們可以利用Aspect來補充，

6.7 Spring AOP 中，關注點和橫切關注的區別是什么？

關注點（concern）是應用中一個模塊的行為，一個關注點可能會被定義成一個我們想實作的一個功能，

橫切關注點（cross-cutting concern）是一個關注點，此關注點是整個應用都會使用的功能，并影響整個應用，比如日志，安全和資料傳輸，幾乎應用的每個模塊都需要的功能，因此這些都屬于橫切關注點，

6.8 Spring通知有哪些型別？

在AOP術語中，切面的作業被稱為通知，實際上是程式執行時要通過SpringAOP框架觸發的代碼段，

Spring切面可以應用5種型別的通知：

1. 前置通知（Before）：在目標方法被呼叫之前呼叫通知功能；
2. 后置通知（After）：在目標方法完成之后呼叫通知，此時不會關心方法的輸出是什么；
3. 回傳通知（After-returning ）：在目標方法成功執行之后呼叫通知；
4. 例外通知（After-throwing）：在目標方法拋出例外后呼叫通知；
5. 環繞通知（Around）：通知包裹了被通知的方法，在被通知的方法呼叫之前和呼叫之后執行自定義的行為，

同一個aspect，不同advice的執行順序：

• 沒有例外情況下的執行順序：
  • around before advice
  • before advice
  • target method 執行
  • around after advice
  • after advice
  • afterReturning
• 有例外情況下的執行順序：
  • around before advice
  • before advice
  • target method 執行
  • around after advice
  • after advice
  • afterThrowing:例外發生
  • java.lang.RuntimeException: 例外發生

6.9 什么是切面 Aspect？

aspect 由 pointcount 和 advice 組成，切面是通知和切點的結合， 它既包含了橫切邏輯的定義, 也包括了連接點的定義. Spring AOP 就是負責實施切面的框架, 它將切面所定義的橫切邏輯編織到切面所指定的連接點中.
AOP 的作業重心在于如何將增強編織目標物件的連接點上, 這里包含兩個作業:

• 如何通過 pointcut 和 advice 定位到特定的 joinpoint 上
• 如何在 advice 中撰寫切面代碼.

可以簡單地認為, 使用 @Aspect 注解的類就是切面.

6.10 什么是基于XML Schema方式的切面實作？

在這種情況下，切面由常規類以及基于XML的配置實作，

6.11 什么是基于注解的切面實作？

在這種情況下(基于@AspectJ的實作)，涉及到的切面宣告的風格與帶有java5標注的普通java類一致，

6.12 有幾種不同型別的自動代理？

1. BeanNameAutoProxyCreator
2. DefaultAdvisorAutoProxyCreator
3. Metadata autoproxying

感謝您的點贊、評論、關注；
您還可以掃碼關注“公眾號”獲取粉絲福利，

標籤：Java

上一篇：ConcurrentHashMap詳解

下一篇：作為一名合格的開發者，必須了解的編程原則有哪些？