Spring和Spring Boot相關知識整理

1、思維導圖

在這裡插入圖片描述

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

2、 Spring

（1）AOP術語

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

（2） Bean的生命週期
雖然被稱為生命週期，實際上指的是bean在初始化、回收期間呼叫了哪些方法。如果只看《Spring實戰》，可以看到類似下面的圖
在這裡插入圖片描述

（3） Cglib和JdkProxy

1、與Spring的關係

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

預設使用JdkProxy
對於被代理物件沒有實現任何介面，使用Cglib
可以強制指定使用Cglib。這樣就可以解釋為什麼有的bean實現了介面，有的沒有，但是在同一個工程中可以並存了。

2、範例程式碼

//使用者管理介面
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");
    }
    
}

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

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

說明： Cglib是如何修改位元組碼，從程式碼上是看不出來的。使用的是ASM技術，修改class檔案，可以自行查閱。 JDK1.8及以後，JdkProxy的執行速度已經比Cglib快了（之前則是慢於Cglib）。

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搞混。

（4）構造方法注入和設值注入的區別

注：設值注入指的是通過setter注入。

換一種說法：

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

（5）ApplicationContext事件

可以通過實現ApplicationEvent類和ApplicationListener介面，進行ApplicationContext的事件處理。這是標準的傳送者-監聽者的模型，可以用來處理業務邏輯，將程式碼解耦。
但是，傳送和接收實際上是同步的，如果有事務，會在同一個事務內，並不能作為非同步處理機制。

3. SpringBoot

（1）SpringBoot的關鍵註解

所謂核心註解，這裡指的是相對Spring本身新增的一些註解，來看看它們有什麼作用。
恰好這裡提到的註解，都可以打在SpringBoot的啟動類（不限於啟動類），用下面的程式碼片段來進行說明。
程式碼範例：

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 = "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);
   }
}

（2） @PropertySource

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

name=value
env.name=$env.value

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

@PropertySource(value = "classpath:application.properties")
class TestClass {
	@Resource
	private Environment environment;

      @Test
      public void test() {
            String value = environment.getProperty("name"));
      }
}

（3）與@Value配合使用

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

@PropertySource("classpath:application.properties")
public class PropertyConfig {
    @Value("${name}")
    private String value;
     ...
}

（4）通過@Import參照

在（1）的範例程式碼中，如果類上沒有@PropertySource，但DemoConfig1或DemoConfig2中有@PropertySource，通過@Import可以將它們載入的變數也讀出來。

（5）properties和.yml組態檔

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

（6）@MapperScan

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

（7）@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 {
      // 略
}

簡單介紹一下這些註解：

1.元註解

最上面四行都是元註解。回憶一下它們的作用：

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

2.@SpringBootConfiguration

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

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的設定。

4.@ComponentScan

掃描@Service、@Repository、@Component、@Controller等標註的類，建立bean。
可以設定掃描範圍，決定類哪些生成bean，哪些類不生成。

5.@Import

將外部資源（bean、@Configuration設定類）匯入到當前IOC容器中。
使用@Import便可以範例化參照的jar中定義的bean了。

4、Starter

指的是在依賴中參照的各種starter包。starter可以看作是「依賴jar+設定」打包的結果，目的是降低開發者引入元件的成本，不用自己梳理依賴、編寫組態檔。
starter遵循「約定大於設定」的原則，使用的元件的設定大部分都有預設值，不宣告也可以直接用。

建立一個Spring boot的簡易步驟：

建立maven專案
建立proterties類來儲存設定資訊
編寫業務功能類（包含會範例化為bean的類）
編寫Configuration類，定義bean
在resources 資料夾下新建目錄 META-INF，在目錄中新建 spring.factories 檔案，並且在
spring.factories 中設定AutoConfiguration
打包

5、war包

（1）和jar包的區別

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

（2）SpringBoot專案打war包部署
通用步驟如下，其中1可能需要移除內嵌tomcat，2有其他形式，因為我工作時都是拿執行緒指令碼打包的，沒有實際操作過，下面步驟僅供參考。

pom.xml修改為按war打包
修改main入口方法，繼承一個SpringBootServletInitializer類，並且覆蓋configure方法
maven打包
複製到tomcat路徑下（tomcat需要預先設定），使用startup啟動

6、Springboot面試題補充

（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>

SpringBoot 需要獨立的容器執行嗎？

可以不需要，內建了 Tomcat/Jetty等容器。
如何使用Jetty？排除掉Tomcat依賴並引入Jetty，並更改一些application設定。

執行 SpringBoot 有哪幾種方式？

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

SpringBoot啟動時執行特定程式碼的方式

Bean實現介面 ApplicationRunner或者CommandLineRunner即可。

SpringBoot實現熱部署有哪幾種方式？
主要有兩種：
Spring Loaded —— 參照依賴（maven plugin）。對於註解和xml變動無法感知需要重新啟動；
Spring-boot-devtools —— 參照依賴、更改設定（可選）、啟動idea的自動編譯。注意生產環境外掛可能導致gc。
Spring Boot 可以相容老 Spring 專案嗎，如何做？
可以相容，使用 @ImportResource 註解匯入老 Spring 專案組態檔。

7、 SpringBoot啟動原理

SpringBoot的啟動入口在main方法的SpringApplication.run(XXXApplication.class, args)處。
啟動圖：
在這裡插入圖片描述
簡單總結下：

註冊各種環境變數設定
註冊各種工廠
註冊各種監聽器
建立上下文，初始化各種bean

其實知識都是學來的，多學些就行，工作中能學到的跟多，但是首先得有個好的工作，有個好的工作機會，而有個好的工作，又離不開技術的高低，技術的高低又得靠學習來提升，所以這都是相輔相成的，不給自己投資就得不到高的回報。

我這整理有很多的Java面試題，也有Java的學習資料和途徑，有需要的可以點選進入，暗號：cszq，可以免費提供！
在這裡插入圖片描述