沉澱再出發:Spring的架構理解

時間 2019-11-19

原文原文鏈接

沉澱再出發:Spring的架構理解

1、前言

在Spring以前使用的EJB框架太龐大和重量級了，開發成本很高，由此spring應運而生。關於Spring，學過java的人基本上都會慢慢接觸到，而且在面試的時候也是常常遇到的，由於這個技術極大地方便了咱們的開發和部署，而且由此衍生出來的框架和思想在不少地方都有使用，好比Spring mvc，Spring boot，Spring cloud等等框架以及IoC和AOP這兩個Spring最本質的思想。能夠說一切的本質都是爲了高內聚，鬆耦合，將不一樣的事物之間儘可能的分割清楚，經過某一種額外的比較好修改的文檔來記錄這二者的聯繫，而後經過框架來將二者在聯繫起來，這樣作看似麻煩實則便於咱們擴展、維護和變動，很是的方便，而且把冗餘的代碼動態的裝飾接入點，更加方便了代碼的擴展、可維護性和可讀性，只須要一個代理便可。在這兩種思想之上，spring又構建了一些列的實現方式，經過IoC的Beans組件，以及Context這個讓Beans運行的上下文，以及Core這個Beans的經常使用工具，使得一切都以Beans爲核心，搭建出了最本質的框架，而後由這三者支撐了更加頂層的、複雜的技術，極大地方便了框架的擴展和維護。這也是spring長盛不衰的緣由了。html

2、Spring的框架

Spring是一個開源的輕量級Java SE/Java EE開發應用框架，其目的是用於簡化企業級應用程序開發。在傳統應用程序開發中，一個完整的應用是由一組相互協做的對象組成。因此開發一個應用除了要開發業務邏輯以外，最多的是關注如何使這些對象協做來完成所需功能，並且要低耦合、高內聚。業務邏輯開發是不可避免的，那若是有個框架出來幫咱們來建立對象及管理這些對象之間的依賴關係。雖然「抽象工廠、工廠方法設計模式」能夠幫咱們建立對象，「生成器模式」能夠幫咱們處理對象間的依賴關係，可是這些又須要咱們建立另外一些工廠類、生成器類，另外管理這些類，增長了咱們的負擔，若是能經過配置方式來建立對象，管理對象之間依賴關係，咱們不須要經過工廠和生成器來建立及管理對象之間的依賴關係，這樣咱們就能減小許多工做，加速開發，能節省出不少時間來幹其餘事。Spring框架剛出來時主要就是來完成這個功能。
Spring框架除了幫咱們管理對象及其依賴關係，還提供像通用日誌記錄、性能統計、安全控制、異常處理等面向切面編程的能力，還能幫咱們管理最頭疼的數據庫事務，它自己提供了一套簡單的JDBC訪問實現，還能與第三方數據庫訪問框架集成（如Hibernate、JPA），與各類Java EE技術整合（如Java Mail、任務調度等等），提供一套本身的web層框架Spring MVC、並且還能很是簡單的與第三方web框架集成。從這裏咱們能夠認爲Spring是一個超級粘合平臺，除了本身提供功能外，還提供粘合其餘技術和框架的能力，從而使咱們能夠更自由的選擇到底使用什麼技術進行開發。並且無論是JAVA SE（C/S架構）應用程序仍是JAVA EE（B/S架構）應用程序均可以使用這個平臺進行開發。
java

2.一、框架的本質

Spring 框架中的核心組件只有三個：Core、Context 和 Beans。它們構建起了整個 Spring 的骨骼架構。沒有它們就不可能有 AOP、Web 等上層的特性功能。若是在它們三個中選出核心的話，那就非 Beans 組件莫屬了，其實 Spring 就是面向 Bean 的編程（BOP,Bean Oriented Programming），Bean 在 Spring 中才是真正的主角。Bean 在 Spring 中做用就像 Object 對 OOP 的意義同樣，沒有對象的概念就像沒有面向對象編程，Spring 中沒有 Bean 也就沒有 Spring 存在的意義。就像一次演出舞臺都準備好了可是卻沒有演員同樣。爲何要 Bean 這種角色 Bean 或者爲什麼在 Spring 如此重要，這由 Spring 框架的設計目標決定，Spring 爲什麼如此流行，咱們用 Spring 的緣由是什麼，想一想會發現原來 Spring 解決了一個很是關鍵的問題，它可讓你把對象之間的依賴關係轉而用配置文件來管理，也就是依賴注入機制。而這個注入關係在一個叫 IoC 容器中管理，那 IoC 容器就是被 Bean 包裹的對象。Spring 正是經過把對象包裝在 Bean 中而達到對這些對象的管理以及一些列額外操做的目的。它這種設計策略徹底相似於 Java 實現 OOP 的設計理念，固然了 Java 自己的設計要比 Spring 複雜太多太多，可是都是構建一個數據結構，而後根據這個數據結構設計他的生存環境，並讓它在這個環境中按照必定的規律在不停的運動，在它們的不停運動中設計一系列與環境或者與其餘個體完成信息交換。這樣想來咱們用到的其餘框架都是大慨相似的設計理念。web

2.二、核心組件的協同工做

把 Beans 比做一場演出中的演員的話，那 Context 就是這場演出的舞臺背景，而 Core 應該就是演出的道具了。只有它們在一塊兒才能具有演出一場好戲的最基本條件。固然有最基本的條件還不能使這場演出脫穎而出，還要表演的節目足夠的精彩，這些節目就是 Spring 能提供的特點功能了。咱們知道 Bean 包裝的是 Object，而 Object 必然有數據，如何給這些數據提供生存環境就是 Context 要解決的問題，對 Context 來講就是要發現每一個 Bean 之間的關係，爲它們創建這種關係而且要維護好這種關係。因此 Context 就是一個 Bean 關係的集合，這個關係集合又叫 Ioc 容器，一旦創建起這個 Ioc 容器後 Spring 就能夠工做了。那 Core 組件又有什麼用武之地呢？其實 Core 就是發現、創建和維護每一個 Bean 之間的關係所須要的一些列的工具，從這個角度看來，Core 這個組件叫 Util 更能理解。面試

2.三、Bean 組件

Bean 組件在 Spring 的 org.springframework.beans 包下。這個包下的全部類主要解決了三件事：Bean 的定義、Bean 的建立以及對 Bean 的解析。對 Spring 的使用者來講惟一須要關心的就是 Bean 的建立，其餘兩個由 Spring 在內部幫你完成了，對你來講是透明的。Spring Bean 的建立時典型的工廠模式，它的頂級接口是 BeanFactory，下圖是這個工廠的繼承層次關係：spring

BeanFactory 有三個子類：ListableBeanFactory、HierarchicalBeanFactory 和 AutowireCapableBeanFactory。可是咱們能夠發現最終的默認實現類是 DefaultListableBeanFactory，實現了全部的接口。那爲什麼要定義這麼多層次的接口呢？查閱這些接口的源碼和說明發現，每一個接口都有使用的場合，它主要是爲了區分在 Spring 內部對象的傳遞和轉化過程當中，對對象的數據訪問所作的限制。例如 ListableBeanFactory 接口表示這些 Bean 是可列表的，而 HierarchicalBeanFactory 表示的這些 Bean 是有繼承關係的，也就是每一個 Bean 有可能有父 Bean。AutowireCapableBeanFactory 接口定義 Bean 的自動裝配規則。這四個接口共同定義了 Bean 的集合、Bean 之間的關係以及 Bean 行爲。Bean 的定義主要有 BeanDefinition 描述。數據庫

Bean的做用域

Spring定義了多種Bean做用域，能夠基於這些做用域建立bean，包括：編程

    單例（Singleton）：在整個應用中，只建立bean的一個實例。
    原型（Prototype）：每次注入或者經過Spring應用上下文獲取的時候，都會建立一個新的bean實例。
    會話（Session）：在Web應用中，爲每一個會話建立一個bean實例。
    請求（Rquest）：在Web應用中，爲每一個請求建立一個bean實例。

聲明Bean

@Component 組件，沒有明確的角色
@Service 在業務邏輯層使用
@Repository 在數據訪問層使用
@Controller 在展示層使用(MVC -> Spring MVC)使用
在這裏，能夠指定bean的id名：Component(「yourBeanName」)
同時，Spring支持將@Named做爲@Component註解的替代方案。
二者之間有一些細微的差別，可是在大多數場景中，它們是能夠互相替換的。

2.四、Context 組件

Context 做爲 Spring 的 Ioc 容器，基本上整合了 Spring 的大部分功能，或者說是大部分功能的基礎。Context 在 Spring 的 org.springframework.context 包下， Context 組件實際上就是給 Spring 提供一個運行時的環境，用以保存各個對象的狀態。下面看一下這個環境是如何構建的。ApplicationContext 是 Context 的頂級父類，除了能標識一個應用環境的基本信息外，還繼承了五個接口，這五個接口主要是擴展了 Context 的功能。設計模式

ApplicationContext 繼承了 BeanFactory，這也說明了 Spring 容器中運行的主體對象是 Beans，另外 ApplicationContext 繼承了 ResourceLoader 接口，使得 ApplicationContext 能夠訪問到任何外部資源。
ApplicationContext 的子類主要包含兩個方面：安全

1  ConfigurableApplicationContext 表示該 Context 是可修改的，也就是在構建 Context 中用戶能夠動態添加或修改已有的配置信息，它下面又有多個子類，其中常用的是可更新的 Context，即 AbstractRefreshableApplicationContext 類。
2  WebApplicationContext 顧名思義，就是爲 web 準備的 Context ，能夠直接訪問到 ServletContext，一般狀況下，這個接口使用的少。

再往下分就是按照構建 Context 的文件類型，接着就是訪問 Context 的方式。這樣一級一級構成了完整的 Context 等級層次。
整體來講 ApplicationContext 必需要完成如下幾件事：服務器

1   標識一個應用環境
2   利用 BeanFactory 建立 Bean 對象
3   保存對象關係表
4   可以捕獲各類事件

2.五、Core 組件

Core 組件做爲 Spring 的核心組件，其中包含了不少的關鍵類，其中一個重要組成部分就是定義了資源的訪問方式。這種把全部資源都抽象成一個接口的方式很值得在之後的設計中拿來學習。下面就重要看一下這個部分在 Spring 的做用。

Resource 接口封裝了各類可能的資源類型，也就是對使用者來講屏蔽了文件類型的不一樣。對資源的提供者來講，如何把資源包裝起來交給其餘人用這也是一個問題，咱們看到 Resource 接口繼承了 InputStreamSource 接口，這個接口中有個 getInputStream 方法，返回的是 InputStream 類。這樣全部的資源都被能夠經過 InputStream 這個類來獲取，因此也屏蔽了資源的提供者。另外還有一個問題就是加載資源的問題，也就是資源的加載者要統一，這個任務是由 ResourceLoader 接口完成，它屏蔽了全部的資源加載者的差別，只須要實現這個接口就能夠加載全部的資源，默認實現是 DefaultResourceLoader。

Context 和 Resource 創建關係：Context 是把資源的加載、解析和描述工做委託給了 ResourcePatternResolver 類來完成，至關於一個接頭人，把資源的加載、解析和資源的定義整合在一塊兒便於其餘組件使用。Core 組件中還有不少相似的方式。

2.六、IoC 容器如何工做

前面介紹了 Core 組件、Bean 組件和 Context 組件的結構與相互關係，下面這裏從使用者角度看一下它們是如何運行的，以及咱們如何讓 Spring 完成各類功能。

如何建立 BeanFactory 工廠

IoC容器實際上就是Context組件結合其餘兩個組件共同構建了一個 Bean 關係網，構建的入口就在 AbstractApplicationContext 類的 refresh 方法中。這個方法的代碼以下：

 1 public void refresh() throws BeansException, IllegalStateException {
 2     synchronized (this.startupShutdownMonitor) {
 3         // Prepare this context for refreshing.
 4         prepareRefresh();
 5         // Tell the subclass to refresh the internal bean factory.
 6         ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 7         // Prepare the bean factory for use in this context.
 8         prepareBeanFactory(beanFactory);
 9         try {
10             // Allows post-processing of the bean factory in context subclasses.
11             postProcessBeanFactory(beanFactory);
12             // Invoke factory processors registered as beans in the context.
13             invokeBeanFactoryPostProcessors(beanFactory);
14             // Register bean processors that intercept bean creation.
15             registerBeanPostProcessors(beanFactory);
16             // Initialize message source for this context.
17             initMessageSource();
18             // Initialize event multicaster for this context.
19             initApplicationEventMulticaster();
20             // Initialize other special beans in specific context subclasses.
21             onRefresh();
22             // Check for listener beans and register them.
23             registerListeners();
24             // Instantiate all remaining (non-lazy-init) singletons.
25             finishBeanFactoryInitialization(beanFactory);
26             // Last step: publish corresponding event.
27             finishRefresh();
28         }
29         catch (BeansException ex) {
30             // Destroy already created singletons to avoid dangling resources.
31             destroyBeans();
32             // Reset 'active' flag.
33             cancelRefresh(ex);
34             // Propagate exception to caller.
35             throw ex;
36         }
37     }
38 }

這個方法就是構建整個 Ioc 容器過程的完整的代碼，瞭解裏面的每一行代碼基本上就瞭解大部分 Spring 的原理和功能了。主要包含這樣幾個步驟：

1  構建 BeanFactory，以便於產生所需的「演員」
2  註冊可能感興趣的事件
3  建立 Bean 實例對象
4  觸發被監聽的事件

建立和配置 BeanFactory，這裏 refresh 也就是刷新配置，前面介紹了 Context 有可更新的子類，這裏正是實現這個功能，當 BeanFactory 已存在是就更新，若是沒有就新建立。下面是更新 BeanFactory 的方法代碼：

 1 protected final void refreshBeanFactory() throws BeansException {
 2     if (hasBeanFactory()) {
 3         destroyBeans();
 4         closeBeanFactory();
 5     }
 6     try {
 7         DefaultListableBeanFactory beanFactory = createBeanFactory();
 8         beanFactory.setSerializationId(getId());
 9         customizeBeanFactory(beanFactory);
10         loadBeanDefinitions(beanFactory);
11         synchronized (this.beanFactoryMonitor) {
12             this.beanFactory = beanFactory;
13         }
14     }
15     catch (IOException ex) {
16         throw new ApplicationContextException(
17             "I/O error parsing bean definition source for "
18             + getDisplayName(), ex);
19     }
20 }

這個方法實現了 AbstractApplicationContext 的抽象方法 refreshBeanFactory，這段代碼清楚的說明了 BeanFactory 的建立過程。注意 BeanFactory 對象的類型的變化，前面介紹了它有不少子類，在什麼狀況下使用不一樣的子類這很是關鍵。BeanFactory 的原始對象是 DefaultListableBeanFactory，設計到後面對這個對象的多種操做。除了 BeanFactory 相關的類外，還發現了與 Bean 的 register 相關。這在 refreshBeanFactory 方法中有一行 loadBeanDefinitions(beanFactory) 將找到答案，這個方法將開始加載、解析 Bean 的定義，也就是把用戶定義的數據結構轉化爲 IoC 容器中的特定數據結構。

建立 BeanFactory 時序圖:

Bean 的解析和登記流程時序圖:

建立好 BeanFactory 後，接下去添加一些 Spring 自己須要的一些工具類，這個操做在 AbstractApplicationContext 的 prepareBeanFactory 方法完成。AbstractApplicationContext 中接下來的三行代碼對 Spring 的功能擴展性起了相當重要的做用。前兩行主要是讓咱們能夠對已經構建的 BeanFactory 的配置作修改，後面一行就是讓咱們對之後再建立 Bean 的實例對象時添加一些自定義的操做。因此它們都是擴展了 Spring 的功能，因此咱們要學習使用 Spring 必須對這一部分搞清楚。

如何建立 Bean 實例並構建 Bean 的關係網

下面是 Bean 的實例化代碼，是從 finishBeanFactoryInitialization 方法開始的。

 1 protected void finishBeanFactoryInitialization(
 2     ConfigurableListableBeanFactory beanFactory) {
 3  
 4     // Stop using the temporary ClassLoader for type matching.
 5     beanFactory.setTempClassLoader(null);
 6  
 7     // Allow for caching all bean definition metadata, not expecting further changes.
 8     beanFactory.freezeConfiguration();
 9  
10     // Instantiate all remaining (non-lazy-init) singletons.
11     beanFactory.preInstantiateSingletons();
12 }

從上面代碼中能夠發現 Bean 的實例化是在 BeanFactory 中發生的。preInstantiateSingletons 方法的代碼以下：

 1 public void preInstantiateSingletons() throws BeansException {
 2     if (this.logger.isInfoEnabled()) {
 3         this.logger.info("Pre-instantiating singletons in " + this);
 4     }
 5     synchronized (this.beanDefinitionMap) {
 6         for (String beanName : this.beanDefinitionNames) {
 7             RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
 8             if (!bd.isAbstract() && bd.isSingleton()
 9                 && !bd.isLazyInit()) {
10                 if (isFactoryBean(beanName)) {
11                     final FactoryBean factory =
12                         (FactoryBean) getBean(FACTORY_BEAN_PREFIX+ beanName);
13                     boolean isEagerInit;
14                     if (System.getSecurityManager() != null
15                         && factory instanceof SmartFactoryBean) {
16                         isEagerInit = AccessController.doPrivileged(
17                             new PrivilegedAction<Boolean>() {
18                             public Boolean run() {
19                                 return ((SmartFactoryBean) factory).isEagerInit();
20                             }
21                         }, getAccessControlContext());
22                     }
23                     else {
24                         isEagerInit = factory instanceof SmartFactoryBean
25                             && ((SmartFactoryBean) factory).isEagerInit();
26                     }
27                     if (isEagerInit) {
28                         getBean(beanName);
29                     }
30                 }
31                 else {
32                     getBean(beanName);
33                 }
34             }
35         }
36     }
37 }

這裏出現了一個很是重要的 Bean—— FactoryBean，能夠說 Spring 一大半的擴展的功能都與這個 Bean 有關，這是個特殊的 Bean 是一個工廠 Bean，能夠產生 Bean 的 Bean，這裏的產生 Bean 是指 Bean 的實例，若是一個類繼承 FactoryBean 用戶只要實現它的 getObject 方法，就能夠本身定義產生實例對象的方法。然而在 Spring 內部這個 Bean 的實例對象是 FactoryBean，經過調用這個對象的 getObject 方法就能獲取用戶自定義產生的對象，從而爲 Spring 提供了很好的擴展性。Spring 獲取 FactoryBean 自己的對象是在前面加上 & 來完成的。如何建立 Bean 的實例對象以及如何構建 Bean 實例對象之間的關聯關係式 Spring 中的一個核心關鍵，下面是這個過程的流程圖。

若是是普通的 Bean 就直接建立它的實例，是經過調用 getBean 方法。下面是建立 Bean 實例的時序圖：

還有一個很是重要的部分就是創建 Bean 對象實例之間的關係，這也是 Spring 框架的核心競爭力，什麼時候、如何創建它們之間的關係：

IoC 容器的擴展點

如今還有一個問題就是如何讓這些 Bean 對象有必定的擴展性，就是能夠加入用戶的一些操做。那麼有哪些擴展點呢？ Spring 又是如何調用到這些擴展點的？對 Spring 的 Ioc 容器來講，主要有這麼幾個。BeanFactoryPostProcessor， BeanPostProcessor。它們分別是在構建 BeanFactory 和構建 Bean 對象時調用。還有就是 InitializingBean 和 DisposableBean，他們分別是在 Bean 實例建立和銷燬時被調用。用戶能夠實現這些接口中定義的方法，Spring 就會在適當的時候調用他們。還有一個是 FactoryBean 他是個特殊的 Bean，這個 Bean 能夠被用戶更多的控制。這些擴展點一般也是咱們使用 Spring 來完成咱們特定任務的地方，如何精通 Spring 就看你有沒有掌握好 Spring 有哪些擴展點，而且如何使用他們，要知道如何使用他們就必須瞭解他們內在的機理。能夠用下面一個比喻來解釋。
咱們把 Ioc 容器比做一個箱子，這個箱子裏有若干個球的模子，能夠用這些模子來造不少種不一樣的球，還有一個造這些球模的機器，這個機器能夠產生球模。那麼他們的對應關係就是：BeanFactory 是那個造球模的機器，球模就是 Bean，而球模造出來的球就是 Bean 的實例。那前面所說的幾個擴展點又在什麼地方呢？ BeanFactoryPostProcessor 對應到當造球模被造出來時，你將有機會能夠對其作出適當的修正，也就是他能夠幫你修改球模。而 InitializingBean 和 DisposableBean 是在球模造球的開始和結束階段，你能夠完成一些預備和掃尾工做。BeanPostProcessor 就可讓你對球模造出來的球作出適當的修正。最後還有一個 FactoryBean，它但是一個神奇的球模。這個球模不是預先就定型了，而是由你來給他肯定它的形狀，既然你能夠肯定這個球模型的形狀，固然他造出來的球確定就是你想要的球了，這樣在這個箱子裏你能夠發現全部你想要的球。

Ioc 容器如何使用

咱們使用 Spring 必需要首先構建 Ioc 容器，沒有它 Spring 沒法工做，ApplicatonContext.xml 就是 IoC 容器的默認配置文件，Spring 的全部特性功能都是基於這個 Ioc 容器工做的，好比AOP。IoC 它實際上就是爲你構建了一個魔方，Spring 爲你搭好了骨骼架構，這個魔方到底能變出什麼好的東西出來，這必需要有你的參與。那咱們怎麼參與？這就是前面說的要了解 Spring 中有哪些擴展點，咱們經過實現那些擴展點來改變 Spring 的通用行爲。至於如何實現擴展點來獲得咱們想要的個性結果，Spring 中有不少例子，其中 AOP 的實現就是 Spring 自己實現了其擴展點來達到了它想要的特性功能。

經過從 Spring 的幾個核心組件入手，試圖找出構建 Spring 框架的骨骼架構，進而分析 Spring 在設計時的一些設計理念，是否從中找出一些好的設計思想，對咱們之後程序設計能提供一些思路。接着再詳細分析了 Spring 中是如何實現這些理念的，以及在設計模式上是如何使用的。經過分析 Spring 給我一個很大的啓示就是這套設計理念其實對咱們有很強的借鑑意義，它經過抽象複雜多變的對象，進一步作規範，而後根據它定義的這套規範設計出一個容器，容器中構建它們的複雜關係，其實如今有不少狀況均可以用這種相似的處理方法。

3、Spring的特性

3.一、一些概念

1   應用程序：是能完成咱們所須要功能的成品，好比購物網站、OA系統。
2   框架：是能完成必定功能的半成品，好比咱們可使用框架進行購物網站開發；框架作一部分功能，咱們本身作一部分功能，這樣應用程序就建立出來了。並且框架規定了你在開發應用程序時的總體架構，提供了一些基礎功能，還規定了類和對象的如何建立、如何協做等，從而簡化咱們開發，讓咱們專一於業務邏輯開發。
3   非侵入式設計：從框架角度能夠這樣理解，無需繼承框架提供的類，這種設計就能夠看做是非侵入式設計，若是繼承了這些框架類，就是侵入設計，若是之後想更換框架，以前寫過的代碼幾乎沒法重用，若是非侵入式設計則以前寫過的代碼仍然能夠繼續使用。
4   輕量級及重量級：輕量級是相對於重量級而言的，輕量級通常就是非入侵性的、所依賴的東西很是少、資源佔用很是少、部署簡單等等，其實就是比較容易使用，而重量級正好相反。
5   POJO：POJO（Plain Old Java Objects）簡單的Java對象，它能夠包含業務邏輯或持久化邏輯，但不擔當任何特殊角色且不繼承或不實現任何其它Java框架的類或接口。
6   容器：在平常生活中容器就是一種盛放東西的器具，從程序設計角度看就是裝對象的的對象，由於存在放入、拿出等操做，因此容器還要管理對象的生命週期。
7   控制反轉：即Inversion of Control，縮寫爲IoC，控制反轉還有一個名字叫作依賴注入（Dependency Injection），就是由容器控制程序之間的關係，而非傳統實現中，由程序代碼直接操控。
8   Bean：通常指容器管理的對象，在Spring中指Spring IoC容器管理的對象。

3.二、Spring的優勢

很是輕量級的容器：以集中的、自動化的方式進行應用程序對象建立和裝配，負責對象建立和裝配，管理對象生命週期，能組合成複雜的應用程序。Spring容器是非侵入式的（不須要依賴任何Spring特定類），並且徹底採用POJOs進行開發，使應用程序更容易測試、更容易管理。並且核心JAR包很是小，Spring3.0.5不到1M，並且不須要依賴任何應用服務器，能夠部署在任何環境（Java SE或Java EE）。
AOP：面向切面編程提供從另外一個角度來考慮程序結構以完善面向對象編程（OOP），便可以經過在編譯期間、裝載期間或運行期間實如今不修改源代碼的狀況下給程序動態添加功能的一種技術。通俗點說就是把可重用的功能提取出來，而後將這些通用功能在合適的時候織入到應用程序中；好比安全，日誌記錄，這些都是通用的功能，咱們能夠把它們提取出來，而後在程序執行的合適地方織入這些代碼並執行它們，從而完成須要的功能並複用了這些功能。
簡單的數據庫事務管理：在使用數據庫的應用程序當中，本身管理數據庫事務是一項很讓人頭疼的事，並且很容易出現錯誤，Spring支持可插入的事務管理支持，並且無需JavaEE環境支持，經過Spring管理事務能夠把咱們從事務管理中解放出來來專一業務邏輯。
JDBC抽象及ORM框架支持：Spring使JDBC更加容易使用；提供DAO（數據訪問對象）支持，很是方便集成第三方ORM框架，好比Hibernate，Mybatis等；而且徹底支持Spring事務和使用Spring提供的一致的異常體系。
靈活的Web層支持：Spring自己提供一套很是強大的MVC框架，並且能夠很是容易的與第三方MVC框架集成，好比Struts等。
簡化各類技術集成：提供對Java Mail、任務調度、JMX、JMS、JNDI、EJB、動態語言、遠程訪問、Web Service等的集成。