Spring框架系列(2) - Spring簡單例子引入Spring要點

上文中我們簡單介紹了Spring和Spring Framework的組件，那麼這些Spring Framework組件是如何配合工作的呢？本文主要承接上文，向你展示Spring Framework組件的典型應用場景和基於這個場景設計出的簡單案例，並以此引出Spring的核心要點，比如IOC和AOP等；在此基礎上還引入了不同的配置方式， 如XML，Java配置和註解方式的差異。@pdai

• Spring框架系列(2) - Spring簡單例子引入Spring要點
  • Spring框架如何應用
  • 設計一個Spring的Hello World
  • 這個例子體現了Spring的哪些核心要點
    • 控制反轉 - IOC
    • 面向切面 - AOP
  • Spring框架設計如何逐步簡化開發的
    • Java 配置方式改造
    • 註解配置方式改造
    • SpringBoot託管配置
    • 結合Spring歷史版本和SpringBoot看發展
  • 更多文章

Spring框架如何應用

上文中，我們展示了Spring和Spring Framework的組件, 這裏對於開發者來說有幾個問題：

1. 首先，對於Spring進階，直接去看IOC和AOP，存在一個斷層，所以需要整體上構建對Spring框架認知上進一步深入，這樣才能構建知識體系。
2. 其次，很多開發者入門都是從Spring Boot開始的，他對Spring整體框架底層，以及發展歷史不是很瞭解； 特別是對於一些老舊項目維護和底層bug分析沒有全局觀。
3. 再者，Spring代表的是一種框架設計理念，需要全局上理解Spring Framework組件是如何配合工作的，需要理解它設計的初衷和未來趨勢。

如下是官方在解釋Spring框架的常用場景的圖

我加上一些註釋後，是比較好理解的；引入這個圖，重要的原因是爲後面設計一個案例幫助你構建認知。

設計一個Spring的Hello World

結合上面的使用場景，設計一個查詢用戶的案例的兩個需求，來看Spring框架幫我們簡化了什麼開發工作:

1. 查詢用戶數據 - 來看DAO+POJO-> Service 的初始化和裝載。
2. 給所有Service的查詢方法記錄日誌

• 創建一個Maven的Java項目

• 引入Spring框架的POM依賴，以及查看這些依賴之間的關係

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>tech.pdai</groupId>
    <artifactId>001-spring-framework-demo-helloworld-xml</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <spring.version>5.3.9</spring.version>
        <aspectjweaver.version>1.9.6</aspectjweaver.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectjweaver.version}</version>
        </dependency>
    </dependencies>

</project>

• POJO - User

package tech.pdai.springframework.entity;

/**
 * @author pdai
 */
public class User {

    /**
     * user's name.
     */
    private String name;

    /**
     * user's age.
     */
    private int age;

    /**
     * init.
     *
     * @param name name
     * @param age  age
     */
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

• DAO 獲取 POJO， UserDaoServiceImpl (mock 數據)

package tech.pdai.springframework.dao;

import java.util.Collections;
import java.util.List;

import tech.pdai.springframework.entity.User;

/**
 * @author pdai
 */
public class UserDaoImpl {

    /**
     * init.
     */
    public UserDaoImpl() {
    }

    /**
     * mocked to find user list.
     *
     * @return user list
     */
    public List<User> findUserList() {
        return Collections.singletonList(new User("pdai", 18));
    }
}

並增加daos.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userDao" class="tech.pdai.springframework.dao.UserDaoImpl">
        <!-- additional collaborators and configuration for this bean go here -->
    </bean>
    <!-- more bean definitions for data access objects go here -->
</beans>

• 業務層 UserServiceImpl（調用DAO層）

package tech.pdai.springframework.service;

import java.util.List;

import tech.pdai.springframework.dao.UserDaoImpl;
import tech.pdai.springframework.entity.User;

/**
 * @author pdai
 */
public class UserServiceImpl {

    /**
     * user dao impl.
     */
    private UserDaoImpl userDao;

    /**
     * init.
     */
    public UserServiceImpl() {
    }

    /**
     * find user list.
     *
     * @return user list
     */
    public List<User> findUserList() {
        return this.userDao.findUserList();
    }

    /**
     * set dao.
     *
     * @param userDao user dao
     */
    public void setUserDao(UserDaoImpl userDao) {
        this.userDao = userDao;
    }
}

並增加services.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- services -->
    <bean id="userService" class="tech.pdai.springframework.service.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
        <!-- additional collaborators and configuration for this bean go here -->
    </bean>
    <!-- more bean definitions for services go here -->
</beans>

• 攔截所有service中的方法，並輸出記錄

package tech.pdai.springframework.aspect;

import java.lang.reflect.Method;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @author pdai
 */
@Aspect
public class LogAspect {

    /**
     * aspect for every methods under service package.
     */
    @Around("execution(* tech.pdai.springframework.service.*.*(..))")
    public Object businessService(ProceedingJoinPoint pjp) throws Throwable {
        // get attribute through annotation
        Method method = ((MethodSignature) pjp.getSignature()).getMethod();
        System.out.println("execute method: " + method.getName());

        // continue to process
        return pjp.proceed();
    }

}

並增加aspects.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/aop
 http://www.springframework.org/schema/aop/spring-aop.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context.xsd
">

    <context:component-scan base-package="tech.pdai.springframework" />

    <aop:aspectj-autoproxy/>

    <bean id="logAspect" class="tech.pdai.springframework.aspect.LogAspect">
        <!-- configure properties of aspect here as normal -->
    </bean>
    <!-- more bean definitions for data access objects go here -->
</beans>

• 組裝App

package tech.pdai.springframework;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import tech.pdai.springframework.entity.User;
import tech.pdai.springframework.service.UserServiceImpl;

/**
 * @author pdai
 */
public class App {

    /**
     * main interfaces.
     *
     * @param args args
     */
    public static void main(String[] args) {
        // create and configure beans
        ApplicationContext context =
                new ClassPathXmlApplicationContext("aspects.xml", "daos.xml", "services.xml");

        // retrieve configured instance
        UserServiceImpl service = context.getBean("userService", UserServiceImpl.class);

        // use configured instance
        List<User> userList = service.findUserList();

        // print info from beans
        userList.forEach(a -> System.out.println(a.getName() + "," + a.getAge()));
    }
}

• 整體結構和運行app

這個例子體現了Spring的哪些核心要點

那麼Spring框架幫助我們做什麼，它體現了什麼哪些要點呢?

控制反轉 - IOC

來看第一個需求：查詢用戶（service通過調用dao查詢pojo)，本質上如何創建User/Dao/Service等；

• 如果沒有Spring框架，我們需要自己創建User/Dao/Service等，比如：

UserDaoImpl userDao = new UserDaoImpl();
UserSericeImpl userService = new UserServiceImpl();
userService.setUserDao(userDao);
List<User> userList = userService.findUserList();

• 有了Spring框架，可以將原有Bean的創建工作轉給框架, 需要用時從Bean的容器中獲取即可，這樣便簡化了開發工作

Bean的創建和使用分離了。

// create and configure beans
ApplicationContext context =
        new ClassPathXmlApplicationContext("aspects.xml", "daos.xml", "services.xml");

// retrieve configured instance
UserServiceImpl service = context.getBean("userService", UserServiceImpl.class);

// use configured instance
List<User> userList = service.findUserList();

更進一步，你便能理解爲何會有如下的知識點了：

1. Spring框架管理這些Bean的創建工作，即由用戶管理Bean轉變爲框架管理Bean，這個就叫控制反轉 - Inversion of Control (IoC)
2. Spring 框架託管創建的Bean放在哪裏呢？ 這便是IoC Container;
3. Spring 框架爲了更好讓用戶配置Bean，必然會引入不同方式來配置Bean？ 這便是xml配置，Java配置，註解配置等支持
4. Spring 框架既然接管了Bean的生成，必然需要管理整個Bean的生命週期等；
5. 應用程序代碼從Ioc Container中獲取依賴的Bean，注入到應用程序中，這個過程叫 依賴注入(Dependency Injection，DI) ； 所以說控制反轉是通過依賴注入實現的，其實它們是同一個概念的不同角度描述。通俗來說就是IoC是設計思想，DI是實現方式
6. 在依賴注入時，有哪些方式呢？這就是構造器方式，@Autowired, @Resource, @Qualifier... 同時Bean之間存在依賴（可能存在先後順序問題，以及循環依賴問題等）

這邊引入我們後續的相關文章：Spring基礎 - Spring之控制反轉(IOC)

面向切面 - AOP

來看第二個需求：給Service所有方法調用添加日誌（調用方法時)，本質上是解耦問題；

• 如果沒有Spring框架，我們需要在每個service的方法中都添加記錄日誌的方法，比如：

/**
* find user list.
*
* @return user list
*/
public List<User> findUserList() {
    System.out.println("execute method findUserList");
    return this.userDao.findUserList();
}

• 有了Spring框架，通過@Aspect註解 定義了切面，這個切面中定義了攔截所有service中的方法，並記錄日誌； 可以明顯看到，框架將日誌記錄和業務需求的代碼解耦了，不再是侵入式的了

/**
* aspect for every methods under service package.
*/
@Around("execution(* tech.pdai.springframework.service.*.*(..))")
public Object businessService(ProceedingJoinPoint pjp) throws Throwable {
    // get attribute through annotation
    Method method = ((MethodSignature) pjp.getSignature()).getMethod();
    System.out.println("execute method: " + method.getName());

    // continue to process
    return pjp.proceed();
}

更進一步，你便能理解爲何會有如下的知識點了：

1. Spring 框架通過定義切面, 通過攔截切點實現了不同業務模塊的解耦，這個就叫面向切面編程 - Aspect Oriented Programming (AOP)
2. 爲什麼@Aspect註解使用的是aspectj的jar包呢？這就引出了Aspect4J和Spring AOP的歷史淵源，只有理解了Aspect4J和Spring的淵源才能理解有些註解上的兼容設計
3. 如何支持更多攔截方式來實現解耦， 以滿足更多場景需求呢？ 這就是@Around, @Pointcut... 等的設計
4. 那麼Spring框架又是如何實現AOP的呢？ 這就引入代理技術，分靜態代理和動態代理，動態代理又包含JDK代理和CGLIB代理等

這邊引入我們後續的相關文章：Spring基礎 - Spring之面向切面編程(AOP)

Spring框架設計如何逐步簡化開發的

通過上述的框架介紹和例子，已經初步知道了Spring設計的兩個大的要點：IOC和AOP；從框架的設計角度而言，更爲重要的是簡化開發，比如提供更爲便捷的配置Bean的方式，直至0配置（即約定大於配置）。這裏我將通過Spring歷史版本的發展，和SpringBoot的推出等，來幫你理解Spring框架是如何逐步簡化開發的。

Java 配置方式改造

在前文的例子中， 通過xml配置方式實現的，這種方式實際上比較麻煩； 我通過Java配置進行改造：

• User，UserDaoImpl, UserServiceImpl，LogAspect不用改
• 將原通過.xml配置轉換爲Java配置

package tech.pdai.springframework.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import tech.pdai.springframework.aspect.LogAspect;
import tech.pdai.springframework.dao.UserDaoImpl;
import tech.pdai.springframework.service.UserServiceImpl;

/**
 * @author pdai
 */
@EnableAspectJAutoProxy
@Configuration
public class BeansConfig {

    /**
     * @return user dao
     */
    @Bean("userDao")
    public UserDaoImpl userDao() {
        return new UserDaoImpl();
    }

    /**
     * @return user service
     */
    @Bean("userService")
    public UserServiceImpl userService() {
        UserServiceImpl userService = new UserServiceImpl();
        userService.setUserDao(userDao());
        return userService;
    }

    /**
     * @return log aspect
     */
    @Bean("logAspect")
    public LogAspect logAspect() {
        return new LogAspect();
    }
}

• 在App中加載BeansConfig的配置

package tech.pdai.springframework;

import java.util.List;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import tech.pdai.springframework.config.BeansConfig;
import tech.pdai.springframework.entity.User;
import tech.pdai.springframework.service.UserServiceImpl;

/**
 * @author pdai
 */
public class App {

    /**
     * main interfaces.
     *
     * @param args args
     */
    public static void main(String[] args) {
        // create and configure beans
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeansConfig.class);

        // retrieve configured instance
        UserServiceImpl service = context.getBean("userService", UserServiceImpl.class);

        // use configured instance
        List<User> userList = service.findUserList();

        // print info from beans
        userList.forEach(a -> System.out.println(a.getName() + "," + a.getAge()));
    }
}

• 整體結構和運行app

註解配置方式改造

更進一步，Java 5開始提供註解支持，Spring 2.5 開始完全支持基於註解的配置並且也支持JSR250 註解。在Spring後續的版本發展傾向於通過註解和Java配置結合使用.

• BeanConfig 不再需要Java配置

package tech.pdai.springframework.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScans;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @author pdai
 */
@Configuration
@EnableAspectJAutoProxy
public class BeansConfig {

}

• UserDaoImpl 增加了 @Repository註解

/**
 * @author pdai
 */
@Repository
public class UserDaoImpl {

    /**
     * mocked to find user list.
     *
     * @return user list
     */
    public List<User> findUserList() {
        return Collections.singletonList(new User("pdai", 18));
    }
}

• UserServiceImpl 增加了@Service 註解，並通過@Autowired注入userDao.

/**
 * @author pdai
 */
@Service
public class UserServiceImpl {

    /**
     * user dao impl.
     */
    @Autowired
    private UserDaoImpl userDao;

    /**
     * find user list.
     *
     * @return user list
     */
    public List<User> findUserList() {
        return userDao.findUserList();
    }

}

• 在App中掃描tech.pdai.springframework包

package tech.pdai.springframework;

import java.util.List;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import tech.pdai.springframework.entity.User;
import tech.pdai.springframework.service.UserServiceImpl;

/**
 * @author pdai
 */
public class App {

    /**
     * main interfaces.
     *
     * @param args args
     */
    public static void main(String[] args) {
        // create and configure beans
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
                "tech.pdai.springframework");

        // retrieve configured instance
        UserServiceImpl service = context.getBean(UserServiceImpl.class);

        // use configured instance
        List<User> userList = service.findUserList();

        // print info from beans
        userList.forEach(a -> System.out.println(a.getName() + "," + a.getAge()));
    }
}

• 整體結構和運行app

SpringBoot託管配置

Springboot實際上通過約定大於配置的方式，使用xx-starter統一的對Bean進行默認初始化，用戶只需要很少的配置就可以進行開發了。

這個因爲很多開發者都是從SpringBoot開始着手開發的，所以這個比較好理解。我們需要的是將知識點都串聯起來，構築認知體系。

結合Spring歷史版本和SpringBoot看發展

最後結合Spring歷史版本總結下它的發展：

（這樣是不是能夠幫助你在整體上構建了知識體系的認知了呢？）

PS：相關代碼，可以通過這裏直接查看

更多文章

首先， 從Spring框架的整體架構和組成對整體框架有個認知。

• Spring基礎 - Spring和Spring框架組成
  • Spring是什麼？它是怎麼誕生的？有哪些主要的組件和核心功能呢? 本文通過這幾個問題幫助你構築Spring和Spring Framework的整體認知。

其次，通過案例引出Spring的核心（IoC和AOP），同時對IoC和AOP進行案例使用分析。

• Spring基礎 - Spring簡單例子引入Spring的核心
  • 上文中我們簡單介紹了Spring和Spring Framework的組件，那麼這些Spring Framework組件是如何配合工作的呢？本文主要承接上文，向你展示Spring Framework組件的典型應用場景和基於這個場景設計出的簡單案例，並以此引出Spring的核心要點，比如IOC和AOP等；在此基礎上還引入了不同的配置方式， 如XML，Java配置和註解方式的差異。
• Spring基礎 - Spring核心之控制反轉(IOC)
  • 在Spring基礎 - Spring簡單例子引入Spring的核心中向你展示了IoC的基礎含義，同時以此發散了一些IoC相關知識點; 本節將在此基礎上進一步解讀IOC的含義以及IOC的使用方式
• Spring基礎 - Spring核心之面向切面編程(AOP)
  • 在Spring基礎 - Spring簡單例子引入Spring的核心中向你展示了AOP的基礎含義，同時以此發散了一些AOP相關知識點; 本節將在此基礎上進一步解讀AOP的含義以及AOP的使用方式。

基於Spring框架和IOC，AOP的基礎，爲構建上層web應用，需要進一步學習SpringMVC。

• Spring基礎 - SpringMVC請求流程和案例
  • 前文我們介紹了Spring框架和Spring框架中最爲重要的兩個技術點（IOC和AOP），那我們如何更好的構建上層的應用呢（比如web 應用），這便是SpringMVC；Spring MVC是Spring在Spring Container Core和AOP等技術基礎上，遵循上述Web MVC的規範推出的web開發框架，目的是爲了簡化Java棧的web開發。 本文主要介紹SpringMVC的請求流程和基礎案例的編寫和運行。

Spring進階 - IoC，AOP以及SpringMVC的源碼分析

• Spring進階 - Spring IOC實現原理詳解之IOC體系結構設計
  • 在對IoC有了初步的認知後，我們開始對IOC的實現原理進行深入理解。本文將幫助你站在設計者的角度去看IOC最頂層的結構設計
• Spring進階 - Spring IOC實現原理詳解之IOC初始化流程
  • 上文，我們看了IOC設計要點和設計結構；緊接着這篇，我們可以看下源碼的實現了：Spring如何實現將資源配置（以xml配置爲例）通過加載，解析，生成BeanDefination並註冊到IoC容器中的
• Spring進階 - Spring IOC實現原理詳解之Bean實例化(生命週期,循環依賴等)
  • 上文，我們看了IOC設計要點和設計結構；以及Spring如何實現將資源配置（以xml配置爲例）通過加載，解析，生成BeanDefination並註冊到IoC容器中的；容器中存放的是Bean的定義即BeanDefinition放到beanDefinitionMap中，本質上是一個ConcurrentHashMap<String, Object>；並且BeanDefinition接口中包含了這個類的Class信息以及是否是單例等。那麼如何從BeanDefinition中實例化Bean對象呢，這是本文主要研究的內容？
• Spring進階 - Spring AOP實現原理詳解之切面實現
  • 前文，我們分析了Spring IOC的初始化過程和Bean的生命週期等，而Spring AOP也是基於IOC的Bean加載來實現的。本文主要介紹Spring AOP原理解析的切面實現過程(將切面類的所有切面方法根據使用的註解生成對應Advice，並將Advice連同切入點匹配器和切面類等信息一併封裝到Advisor，爲後續交給代理增強實現做準備的過程)。
• Spring進階 - Spring AOP實現原理詳解之AOP代理
  • 上文我們介紹了Spring AOP原理解析的切面實現過程(將切面類的所有切面方法根據使用的註解生成對應Advice，並將Advice連同切入點匹配器和切面類等信息一併封裝到Advisor)。本文在此基礎上繼續介紹，代理（cglib代理和JDK代理）的實現過程。
• Spring進階 - Spring AOP實現原理詳解之Cglib代理實現
  • 我們在前文中已經介紹了SpringAOP的切面實現和創建動態代理的過程，那麼動態代理是如何工作的呢？本文主要介紹Cglib動態代理的案例和SpringAOP實現的原理。
• Spring進階 - Spring AOP實現原理詳解之JDK代理實現
  • 上文我們學習了SpringAOP Cglib動態代理的實現，本文主要是SpringAOP JDK動態代理的案例和實現部分。
• Spring進階 - SpringMVC實現原理之DispatcherServlet初始化的過程
  • 前文我們有了IOC的源碼基礎以及SpringMVC的基礎，我們便可以進一步深入理解SpringMVC主要實現原理，包含DispatcherServlet的初始化過程和DispatcherServlet處理請求的過程的源碼解析。本文是第一篇：DispatcherServlet的初始化過程的源碼解析。
• Spring進階 - SpringMVC實現原理之DispatcherServlet處理請求的過程
  • 前文我們有了IOC的源碼基礎以及SpringMVC的基礎，我們便可以進一步深入理解SpringMVC主要實現原理，包含DispatcherServlet的初始化過程和DispatcherServlet處理請求的過程的源碼解析。本文是第二篇：DispatcherServlet處理請求的過程的源碼解析。