簡介

本文主要整理一些Spring & SpringBoot應用時和相關原理的知識點，對于原始碼不做沒有深入的講解，

1. 思維導圖

右鍵新視窗打開可以放大，

說明

使用@Configuration在java代碼中宣告一個bean——而不是使用xml——實際上很早就有了（至少在《Spring實戰(第3版)》出版時，也就是Spring3.0時），我一直以為是SpringBoot的新特性，

2. Spring

2.1 AOP術語

通知Advice —— 切面要做什么，何時執行，何時，包括方法呼叫前、方法呼叫后、方法成功呼叫后、方法呼叫拋例外后、環繞(Around)，環繞允許提供一些需要跨越方法呼叫前后的功能，如計算呼叫耗時，
連接點Joinpoint —— 應用執行時能插入切面的點，實際上是一個邏輯概念，不體現在配置中，
切點Pointcut —— 執行通知的具體的連接點，
切面Aspect —— 通知+切點
引入Introduction —— 允許為類添加新的方法或屬性，（個人理解即應用使用切面中的方法和屬性，就好像這些方法和屬性是原生的一樣，可以參考<aop:declare-parents>元素）
織入Weaving —— 將切面應用到目標物件創建新的代理物件的程序，Spring使用的是運行時，編譯期和類加載時是其他的方式，

2.2 Bean的生命周期

雖然被稱為生命周期，實際上指的是bean在初始化、回收期間呼叫了哪些方法，如果只看《Spring實戰》，可以看到類似下面的圖（圖源：參考文獻[3]）

具體哪一步做了什么？其實這些方法都是可選的，自定義的bean可以實作，也可以不實作，實作里寫什么似乎都沒問題，參考文獻[3]中的測驗代碼展示了這些方法在bean生命周期中的執行順序，
但是對于Spring框架的bean，就有必要的用途了，這里沒有深入研究，有興趣可以自行讀原始碼，

2.3 Cglib和JdkProxy

2.3.1 與Spring的關系

這是Spring AOP的兩種實作方式，根據官方檔案：

默認使用JdkProxy
對于被代理物件沒有實作任何介面，使用Cglib
可以強制指定使用Cglib，
這樣就可以解釋為什么有的bean實作了介面，有的沒有，但是在同一個工程中可以并存了，

2.3.2 示例代碼

本節代碼改寫自參考文獻[5]，

//用戶管理介面
public interface UserManager {
    //新增用戶抽象方法
    void addUser(String userName,String password);
    //洗掉用戶抽象方法
    void delUser(String userName);
}

//用戶管理實作類,實作用戶管理介面
public class UserManagerImpl implements UserManager{
    @Override
    public void addUser(String userName) {
        System.out.println("呼叫了新增的方法！");
        System.out.println("傳入引數為 userName: "+userName+" password: "+password);
    }
    @Override
    public void delUser(String userName) {
        System.out.println("呼叫了洗掉的方法！");
        System.out.println("傳入引數為 userName: "+userName);
    }   
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import com.lf.shejimoshi.proxy.entity.UserManager;
import com.lf.shejimoshi.proxy.entity.UserManagerImpl;
//JDK動態代理實作InvocationHandler介面
public class JdkProxy implements InvocationHandler {
    private Object target ;//需要代理的目標物件
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("JDK動態代理，監聽開始！");
        Object result = method.invoke(target, args);
        System.out.println("JDK動態代理，監聽結束！");
        return result;
    }
    //定義獲取代理物件方法
    // 因為只是在main()里測驗，宣告為private了 
    private Object getJDKProxy(Object targetObject){
        this.target = targetObject;
        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(), this);
    }
    
    public static void main(String[] args) {
        JdkProxy jdkProxy = new JdkProxy();
        UserManager user = (UserManager) jdkProxy.getJDKProxy(new UserManagerImpl());//獲取代理物件
        user.addUser("admin");
    }   
}

import java.lang.reflect.Method;

import com.lf.shejimoshi.proxy.entity.UserManager;
import com.lf.shejimoshi.proxy.entity.UserManagerImpl;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

//Cglib動態代理，實作MethodInterceptor介面
public class CglibProxy implements MethodInterceptor {
    private Object target;//需要代理的目標物件
    
    //重寫攔截方法
    @Override
    public Object intercept(Object obj, Method method, Object[] arr, MethodProxy proxy) throws Throwable {
        System.out.println("Cglib動態代理，監聽開始！");
        Object invoke = method.invoke(target, arr);//方法執行，引數：target 目標物件 arr引數陣列
        System.out.println("Cglib動態代理，監聽結束！");
        return invoke;
    }
    //定義獲取代理物件方法
    public Object getCglibProxy(Object objectTarget){
        //為目標物件target賦值
        this.target = objectTarget;
        Enhancer enhancer = new Enhancer();
        //設定父類,因為Cglib是針對指定的類生成一個子類，所以需要指定父類
        enhancer.setSuperclass(objectTarget.getClass());
        enhancer.setCallback(this);// 設定回呼 
        Object result = enhancer.create();//創建并回傳代理物件
        return result;
    }
    
    public static void main(String[] args) {
        CglibProxy cglib = new CglibProxy();
        UserManager user =  (UserManager) cglib.getCglibProxy(new UserManagerImpl());
        user.delUser("admin");
    }
    
}

2.3.3 比較

比較一下兩者的區別，這也是常見的面試問題，

	JdkProxy	Cglib
依賴	被代理物件實作了介面（所有介面的方法數總和必須>0[4]）	引入asm、cglib jar ；不能是final類和方法
原理	反射，實作被代理物件介面的匿名內部類，通過InvocationHandler.invoke()包圍被代理物件的方法	引入asm、cglib jar，代理類實作MethodInterceptor，通過底層重寫位元組碼來實作
效率	創建快，運行慢(見下方說明2)	創建慢，運行快

說明

Cglib是如何修改位元組碼，從代碼上是看不出來的，使用的是ASM技術，修改class檔案，可以自行查閱，
JDK1.8及以后，JdkProxy的運行速度已經比Cglib快了（之前則是慢于Cglib），測驗代碼可見參考文獻[6]，

2.3.4 關于org.apoalliance.intercept.MethodInterceptor

我讀了一下之前所用的日志攔截器原始碼，發現其實作的是這節標題的介面：

class CommonInterceptor implements MethodInterceptor {
      @Override
      public Object invoke(MethodInvocation invocation) throws Throwable {
            try {
                   // 攔截器內部邏輯
                  result = invoication.proceed();
            catch(Throwable e) {
                  // 例外處理
            }
            return result;
      }
}

宣告代理鏈

@Configuration
public class InterceptorConfig {

      @Bean
      public CommonInterceptor serviceInterceptor() {
            CommonInterceptor bean = new CommonInterceptor();
            return bean;
      }

      // 代理名稱后綴為servie的實作類
      @Bean
      public BeanNameAutoProxyCreator servieBeanNameAutoProxyCreator() {
            BeanNameAutoProxyCreator creator = new BeanNameAutoProxyCreator();
            creator.setName("*ServieImpl");
            creator.setInterceptorNames("serviceInterceptor");
            creator.setProxyTargetClass(true);
            return creator;
      }
}

查了一些資料，apoalliance包下只是aop的介面規范，不是具體的實作，不要把這里的MethodInterceptor和cglib的MethodInterceptor搞混，

2.4 構造方法注入和設值注入的區別

注：設值注入指的是通過setter注入，
之前看參考文獻[7]，感覺很難懂，試著改換了一種說法：

如果只設定基本型別(int、long等)的值，建議設定默認值而不是通過任何一種注入完成
構造注入不支持大部分的依賴注入，構造注入僅在創建時執行，設值注入的值在后續也可以變化，
設值注入可以支持尚未完整的被依賴的物件，構造注入則不行，可以通過構造注入決定依賴關系，因此如果依賴關系不會發生變更也可以選擇依賴注入，

2.5 ApplicationContext事件

可以通過實作ApplicationEvent類和ApplicationListener介面，進行ApplicationContext的事件處理，這是標準的發送者-監聽者的模型，可以用來處理業務邏輯，將代碼解耦，
但是，發送和接收實際上是同步的，如果有事務，會在同一個事務內，并不能作為異步處理機制^[8]，
示例代碼見參考文獻[9]，

3. SpringBoot

注：作業中我對SpringBoot是偏應用的，研究并不是很深入，

3.1 如何快速搭建一個SpringBoot專案

見參考文獻[10]，實際的程序是借助Spring Initializer這個網路應用程式來生成SpringBoot專案，

3.2 SpringBoot的關鍵注解

所謂核心注解，這里指的是相對Spring本身新增的一些注解，來看看它們有什么作用，
恰好這里提到的注解，都可以打在SpringBoot的啟動類（不限于啟動類），用下面的代碼片段來進行說明，

3.2.1 代碼示例

package com.example.demo;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;

@PropertySource(value = "https://www.cnblogs.com/wuyuegb2312/p/classpath:application.properties")
@MapperScan("com.example.demo.dal")
@SpringBootApplication(scanBasePackages = {"com.example.demo"})
@Import({DemoConfig1.class, DemoConfig2.class,})
public class DemoApplication {
	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, args);
	}
}

3.2.2 @PropertySource

從指定的檔案讀取變數，示例代碼會從resource目錄下讀取application.properties變數的值，檔案的格式如下，既可以用常量，也可以用變數替換，來對不同環境的值作區分，

name=value
env.name=$env.value

如何使用這個值？在要使用的地方獲取即可，

@PropertySource(value = "https://www.cnblogs.com/wuyuegb2312/p/classpath:application.properties")
class TestClass {
	@Resource
	private Environment environment;

      @Test
      public void test() {
            String value = https://www.cnblogs.com/wuyuegb2312/p/environment.getProperty("name"));
      }
}

3.2.2.1 與@Value配合使用

使用@Value可以把組態檔的值直接注入到成員變數中，

@PropertySource("classpath:application.properties")
public class PropertyConfig {

    @Value("${name}")
    private String value;

     ...
}

3.2.2.2 通過@Import參考

3.2.1的示例代碼中，如果類上沒有@PropertySource，但DemoConfig1或DemoConfig2中有@PropertySource，通過@Import可以將它們加載的變數也讀出來，
@Import的作用在下文會繼續介紹，

3.2.2.3 .properties和.yml組態檔

@PropertySource只能匯入.properties組態檔里的內容，對于.yml是不支持的，看了一些文章，得出結論是yml檔案是不需要注解就能匯入，但是需要路徑，
Springboot有兩種核心組態檔，application和bootstrap，都可以用properties或yml格式，區別在于bootstrap比application優先加載，并且不可覆寫，

3.2.3 @MapperScan

這實際上是一個mybatis注解，作用是為指定路徑下的DAO介面，通過sqlmapping.xml檔案，生成實作類，

3.2.4 @SpringBootApplication

@SpringBootApplication是由多個注解組合成的，原始碼如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
      // 略
}

簡單介紹一下這些注解，

3.2.4.1 元注解

最上面四行都是元注解，回憶一下它們的作用^[12]：

@Target 注解可以用在哪，TYPE表示型別，如類、介面、列舉
@Retention 注解的保留時間期限，只有RUNTIME型別可以在運行時通過反射獲取其值
@Documented 該注解在生成javadoc檔案時是否保留
@Inherited 被注解的元素，是否具有繼承性，如子類可以繼承父類的注解而不必顯式的寫下來，

3.2.4.2 @SpringBootConfiguration

標注這是一個SpringBoot的配置類，和@Configuration功能是相通的，從原始碼也可以看出它直接使用了@Configuration，
回憶一下，@Configuration注解的作用是，整合相關的@Bean來實作實體的宣告，用以代替xml的形式，

3.2.4.3 @EnableAutoConfiguration

這個注解是實作自動化配置的核心注解，定義如下

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
      // 略
}

借助@Import引入的AutoConfigurationImportSelector，SpringBoot應用將所有符合條件的@Configuration配置都加載到當前SpringBoot創建并使用的IoC容器，
具體的細節這里不展開了，簡單提一句，加載的是指定的組態檔中META-INF/spring.factories的配置，，

3.2.4.4 @ComponentScan

掃描@Service、@Repository、@Component、@Controller等標注的類，創建bean，
可以設定掃描范圍，決定類哪些生成bean，哪些類不生成，

3.2.5 @Import

將外部資源（bean、@Configuration配置類）匯入到當前IOC容器中，
使用@Import便可以實體化參考的jar中定義的bean了，

3.3 Starter

指的是在依賴中參考的各種starter包，starter可以看作是“依賴jar+配置”打包的結果，目的是降低開發者引入組件的成本，不用自己梳理依賴、撰寫組態檔，
starter遵循“約定大于配置”的原則，使用的組件的配置大部分都有默認值，不宣告也可以直接用，

創建一個Spring boot的簡易步驟（完整的可以看參考文獻[14]）:

創建maven專案
創建proterties類來保存配置資訊
撰寫業務功能類（包含會實體化為bean的類）
撰寫Configuration類，定義bean
在resources 檔案夾下新建目錄 META-INF，在目錄中新建 spring.factories 檔案，并且在 spring.factories 中配置AutoConfiguration
打包

3.4 war包

3.4.1 和jar包的區別

jar 把類和相關的資源封裝
war 代表了一個可部署的Web應用程式

3.4.2 SpringBoot專案打war包部署

通用步驟如下，其中1可能需要移除內嵌tomcat，2有其他形式，因為我作業時都是拿執行緒腳本打包的，沒有實際操作過，下面步驟僅供參考，

pom.xml修改為按war打包
修改main入口方法，繼承一個SpringBootServletInitializer類，并且覆寫configure方法
maven打包
復制到tomcat路徑下（tomcat需要預先配置），使用startup啟動

3.5 Springboot面試題補充

本節內容結合了參考文獻[16]進行補充，上面提到的知識不再重復，

3.5.1 使用Springboot的兩種方式

繼承spring-boot-starter-parent專案

<parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.6.RELEASE</version>
</parent>

匯入spring-boot-dependencies專案依賴

<dependencyManagement>
      <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>1.5.6.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
      </dependencies>
</dependencyManagement>

3.5.2 SpringBoot 需要獨立的容器運行嗎？

可以不需要，內置了 Tomcat/Jetty等容器，
如何使用Jetty？排除掉Tomcat依賴并引入Jetty，并更改一些application配置，兩種容器的比較和替換方式見參考文獻[17]，

3.5.3 運行 SpringBoot 有哪幾種方式？

打包用命令或者放到容器中運行
用 Maven/ Gradle 插件運行
直接執行 main 方法運行

3.5.4 SpringBoot啟動時運行特定代碼的方式

Bean實作介面 ApplicationRunner或者CommandLineRunner即可，

3.5.5 SpringBoot實作熱部署有哪幾種方式？

主要有兩種

Spring Loaded —— 參考依賴（maven plugin），對于注解和xml變動無法感知需要重啟
Spring-boot-devtools —— 參考依賴、更改配置（可選）、啟動idea的自動編譯，注意生產環境插件可能導致gc

3.5.6 Spring Boot 可以兼容老 Spring 專案嗎，如何做？

可以兼容，使用 @ImportResource 注解匯入老 Spring 專案組態檔，

4. SpringBoot啟動原理

SpringBoot的啟動入口在main方法的SpringApplication.run(XXXApplication.class, args)處，
啟動圖（https://www.processon.com/view/link/59812124e4b0de2518b32b6e）如下：

各步是怎么做的，可以看參考文獻[18]，簡單總結下：

注冊各種環境變數配置
注冊各種工廠
注冊各種監聽器
創建背景關系，初始化各種bean

參考文獻

1.AOP -連接點和切點的區別
2.Spring AOP術語：連接點和切點的區別，
3.深究Spring中Bean的生命周期
4.Spring AOP代理用的到底是CGLIB還是JDK動態代理
5. Spring的兩種動態代理：Jdk和Cglib 的區別和實作
6. Spring AOP中的JDK和CGLib動態代理哪個效率更高？
7. 經典面試題-構造方法注入和設值注入有什么區別？
8. Spring的ApplicationEvent
9. spring-第三篇之ApplicationContext的事件機制
10. 使用IDEA搭建一個簡單的SpringBoot專案——詳細程序
11. 淺析PropertySource 基本使用
12. JAVA核心知識點--元注解詳解
13. 簡單講講@SpringBootApplication
14. Spring Boot Starters
15. SpringBoot 打包成war
16. 吐血整理 20 道 Spring Boot 面試題，我經常拿來面試別人！
17. SpringBoot2使用Jetty容器（替換默認Tomcat）
18. SpringBoot啟動流程決議

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/157907.html

標籤：Java

上一篇：常用的 Git 命令，給你準備好了！

下一篇：實戰Springboot內置Tomcat配置調優

Spring和Springboot相關知識點整理

簡介