本文主要是對 Spring 的一個基本使用，建議閱讀時間 5min。

歷史的選擇

Spring 作為一個基礎(chǔ)的框架，是在 Java EE 開發(fā)歷史中，是成千上萬公司選擇。單獨使用 Spring 的非常少了，很多都是用 Spring-Boot/Spring-Cloud 來開發(fā)，但是 Spring 基礎(chǔ)依然是我們使用的基石。我們將一起來聊一聊 Spring 的基本使用。首先我們一起來了解一下 Spring 框架整體架構(gòu)圖如下：

1. 數(shù)據(jù)訪問/集成，包括 JDBC 、ORM、OXM、JMS 和 Transaction 模塊；
2. WEB 模塊，包括 WebSocket、Servlet、Web、Porlet 模塊；
3. 核心容器，包括 Bean 模塊、Core 模塊、Context 模塊 和 SpEL 模塊；
4. 其他部分，包括：AOP、Test 等模塊

Spring 同類框架

• Micronaut
• Quarkus

Spring 核心功能

核心功能：控制反轉(zhuǎn)（IOC） 、AOP 非核心功能：事件驅(qū)動、國際化、資源管理，數(shù)據(jù)綁定、類型轉(zhuǎn)換 、SpEL、單元測試等。

PS：核心功能，在本文會有使用實踐。

Spring Bean 容器

控制反轉(zhuǎn)（IOC）是 Spring 框架的核心功能之一，其本質(zhì)的就是將用戶創(chuàng)建 Bean 的過程賦予給 IOC 容器去完成，實現(xiàn) Bean 創(chuàng)建權(quán)利的反轉(zhuǎn)為容器來創(chuàng)建 Bean 和依賴 Bean 。

Bean 創(chuàng)建

Spring 容器創(chuàng)建 Bean 只需要三個步驟：

1. 定義 Bean
2. 創(chuàng)建 Bean 容器/Bean 工廠
3. 獲取 Bean 對象

舉一個例子：

public class TestMain {

    public static void main(String[] args){
        ApplicationContext applicationContext =
                new AnnotationConfigApplicationContext(AppConfig.class);
        Student student = applicationContext.getBean(Student.class);
        student.study();
        student.sleep();
        student.study();
    }
}
@Configuration
@Import(Student.class)
class AppConfig {
}
@Component
class Student {

    private String name;

    private Integer source;

    public void study(){
        System.out.println("學(xué)習(xí)中...");
    }
    public void sleep(){
        System.out.println("休息中...");
    }
    // setter getter
}

運行上面的代碼我們可以得到一下結(jié)果：

學(xué)習(xí)中...
休息中...
學(xué)習(xí)中...

上面的代碼執(zhí)行什么呢？其實我們可以將 ApplicationContext理解為 Spring 容器對象，然后我們在 AppConfig 配置類中去定義 Spring 容器去幫助我們加載那些 Bean ，最后我們通過 getBean 方法獲取我們注冊的 Bean 對象。如下圖：

在這個過程中使用到那些關(guān)鍵的接口/類呢？

• BeanFactory? 是 Bean 的抽象工廠，也就是我們ApplicationContext 的一個父接口。
• BeanDefinition? 是 Bean 的定義信息， 比如 beanName, className, isAbstract? 等 Bean 定義信息。

注入依賴 （DI）

Spring IOC 容器主要是解決了 Bean 的創(chuàng)建和依賴管理的問題。我們常見的有兩種依賴注入方式：

1. 屬性注入
2. 構(gòu)造方法注入

屬性注入

通過成員屬性的方式實現(xiàn) Bean 的自動注入

@Component
class Student {
    @Autowired
    private Address address;
    // ...
}

@Component
class Address {
    // ...
}

• 通過@Component可以將 Student 、Address 類標(biāo)記為一個 bean 對象。
• 通過@Autowired可以將依賴 Bean 自動注入進(jìn)來。

構(gòu)造方法注入

通過構(gòu)造方法實現(xiàn) Bean 的自動注入。

@Component
class Student {
    
 public Student(Address address){
        this.address = address;
    }
}

@Component
class Address {
    // ...
}

Spring 的 IOC 解決了什么問題？

1. 容器化，Spring包含并管理應(yīng)用中對象的生命周期和配置（配置成單例還是原型，以及什么時候使用什么時候銷毀）。
2. 方便解耦，簡化開發(fā)，Spring就是一個大工廠，可以將所有對象創(chuàng)建和依賴關(guān)系維護(hù)交給Spring管理，實現(xiàn)松耦合。符合高內(nèi)聚低耦合的思想，這個特性也叫IOC（控制反轉(zhuǎn)）。
3. AOP編程的支持，Spring提供面向切面的編程，可以方便的實現(xiàn)對程序進(jìn)行權(quán)限攔截、運行監(jiān)控等功能，是通過動態(tài)代理和CGlib實現(xiàn)的，底層原理是反射。
4. 聲明式事務(wù)的支持，通過AOP來實現(xiàn)。不需通過編程的方式而進(jìn)行管理事務(wù)，這樣就不需要在業(yè)務(wù)邏輯代碼中摻雜事務(wù)管理的代碼，只需在配置文件中做相關(guān)的事務(wù)規(guī)則聲明，便可將事務(wù)規(guī)則應(yīng)用到業(yè)務(wù)邏輯中。
5. 方便程序的測試，Spring對Junit4的支持，可以通過注解方便的測試Spring程序。
6. 方便集成各種優(yōu)秀框架，Spring不排斥各種優(yōu)秀的開源框架，其內(nèi)部提供了對各種優(yōu)秀框架的直接支持（如Struts2、Hibernate、MyBatis等）。
7. 異常處理，Spring提供方便的API把具體技術(shù)相關(guān)的異常轉(zhuǎn)化為一致的unchecked異常（比如由JDBC、Hibernate或者JDO拋出的異常）。SpringMVC也有一個異常集中處理的思想，將異常拋給SpringMVC框架，由框架來處理異常。
8. 降低JavaEE API的使用難度，Spring對JavaEE開發(fā)中非常難用的一些API（JDBC、JavaMail、遠(yuǎn)程調(diào)用等），都提供了封裝，使這些API應(yīng)用難度大大降低。

Spring AOP 面向切面

AOP(Aspect Oriented Programming)是面向切面的意思。

理解 AOP

Java 是一個面向?qū)ο螅∣OP）的編程語言，但是它有一個弊端就是需要為多個不具有繼承關(guān)系的對象引入一個公共行為時，例如：日志記錄、權(quán)限驗證、事務(wù)管理、訪問統(tǒng)計等公共行為，這樣不便于維護(hù)，而且有大量重復(fù)代碼，AOP 可以實現(xiàn)和 AOP 的互補。

舉個例子： 我們有兩個邏輯登錄業(yè)務(wù)、訂單業(yè)務(wù)，需要在他們調(diào)用前后進(jìn)行：權(quán)限驗證、日志記錄等公共邏輯。

1. 通過 OOP 的方式實現(xiàn)我們需要做一個邏輯模板：權(quán)限驗證，具體邏輯（登錄、訂單），日志記錄。
2. 通過 AOP 的方式實現(xiàn)我們只需針對具體邏輯（登錄、訂單）前后做一個自定義切點，進(jìn)行權(quán)限驗證、日志記錄。

如下圖：

經(jīng)過 AOP 方式處理過后，我們可以減少公共對象的引用、通過非繼承的方式來處理切入邏輯的攔截，實現(xiàn)公共邏輯和業(yè)務(wù)的邏輯的松耦合關(guān)系。

AOP 實現(xiàn)

Spring 通過代理的方式去實現(xiàn) AOP，Java 代理的兩種模式：靜態(tài)代理、動態(tài)代理。

• 靜態(tài)代理：靜態(tài)代理是指在程序運行前，可以理解為是 .java 文件編譯后就存在代理類的字節(jié)碼 .class 文件。
• 動態(tài)代理：動態(tài)代理指在程序運行期間通過 JVM 反射等動態(tài)機(jī)制，在運行期生成代理對象確定代理邏輯。

Spring 的兩種代理模式：

• JDK 代理：核心類JdkDynamicAopProxy。
• GCLIB 代理：核心類ObjenesisCglibAopProxy。

兩種代理的選擇：如果 Bean 實現(xiàn)了接口就采用 JDK 代理， 如果沒有實現(xiàn)就采用 GCLIB 代理。

AOP 使用

假設(shè)已經(jīng)有一個 UserService 類提供了登錄業(yè)務(wù)，我們需要對該業(yè)務(wù)做一個【權(quán)限驗證】、【日志記錄】這兩個公共邏輯，在不修改 UserService 類代碼的前提下就可以通過 AOP 來解決。示例如下：

// 1. 測試類
public class AopTest {
    public static void main(String[] args){
        ApplicationContext applicationContext =
                new AnnotationConfigApplicationContext(AopConfig.class);
        UserService userService = applicationContext.getBean(UserService.class);
        userService.login("admin", "123456");
    }
}
// 2. 配置類
@EnableAspectJAutoProxy
@Configuration
@Import({UserService.class, ValidateAspect.class})
class AopConfig {
}
// 業(yè)務(wù)類
@Component
class UserService {
    public String login(String username, String password){
        System.out.println("username：" + username + ",password:" + password);
        return "ok";
    }
}
// Aspect
@Aspect
@Component
class ValidateAspect {

    @Pointcut("execution(public * io.zhengsh.simu.spring.UserService.*(..))")
    public void servicePoint(){
        // Do nothing
    }


    @Around("servicePoint()")
    public Object doAroundService(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("validate param invoke !!!");
        return joinPoint.proceed();
    }
}

maven 依賴

<!-- Spring核心依賴 -->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
  </dependency>
  <!-- Spring beans包-->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
  </dependency>
  <!-- Spring 容器包 -->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
  </dependency>

  <!-- aop -->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
  </dependency>

  <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.9.1</version>
  </dependency>

參考文檔

• Spring 官方文檔
• 駱駝?wù)碚f-Spring AOP
• Java－為什么使用Spring框架