Java面試寶典學習筆記【2020】

2022 年 5 月 27 日
筆記
JAVA, Spring+SpringMVC+Mybatis+SpringBoot+SpringCloud, 乾貨, 資料庫, 雜七雜八, 軟體工程大三回顧總結, 閱讀永無止境, 閱讀筆記

Java面試題總結

一、Java基礎

1）Java有沒有goto？

goto是C語言中的，通常與條件語句配合使用，可用來實現條件轉移，構成循環，跳出循環體等功能。Java保留了這個關鍵字但是沒有使用。

2）&和&&的區別？

&和&&都表示邏輯與的關係，同真則真，有假則假。

&&具有短路的功能，即如果第一個表達式為 false，則不再計算第二個表達式。if(x == 33 & ++y>0) y 會增長，if(x ==33 && ++y>0) 不會增長

& 是按位與運算符。當&操作符兩邊的表達式不是 boolean 類型時，&表示按位與操作。

3）靜態變數和實例變數的區別？

在語法定義上的區別：靜態變數前要加 static 關鍵字，而實例變數前則不加。
在程式運行時的區別：實例變數屬於某個對象的屬性，必須創建了實例對象，其中的實例變數才會被分配空間，才能使用這個實例變數。靜態變數不屬於某個實例對象，而是屬於類，所以也稱為類變數，只要程式載入了類的位元組碼，不用創建任何實例對象，靜態變數就會被分配空間，靜態變數就可以被使用了。

4）是否可以從一個 static 方法內部發出對非 static 方法的調用？

不可以。因為非 static 方法是要與對象關聯在一起的，必須創建一個對象後，才可以在該對象上進行方法調用，而 static 方法調用時不需要創建對象，可以直接調用。也就是說，當一個 static 方法被調用時，可能還沒有創建任何實例對象，如果從一個 static 方法中發出對非 static 方法的調用，那個非 static 方法是關聯到哪個對象上的呢？

5）Math類的三個取整方法

Math 類中提供了三個與取整有關的方法：ceil、floor、round，這些方法的作用與它們的英文名稱的含義相對應，例如，ceil 的英文意義是天花板，該方法就表示向上取整，Math.ceil(11.3) 的結果為 12,Math.ceil(-11.3)的結果是-11；floor 的英文意義是地板，該方法就表示向下取整， Math.ceil(11.6)的結果為 11,Math.ceil(-11.6)的結果是-12；最難掌握的是round 方法，它表示「四捨五入」，演算法為Math.floor(x+0.5)，即將原來的數字加上0.5 後再向下取整，所以，Math.round(11.5)的結果為 12，Math.round(-11.5)的結果為-11。

6）請說出作用域 public，private，protected，以及不寫時的區別（不寫是friendly）

7）Overload 和 Override 的區別。

重寫 Override 表示子類中的方法可以與父類中的某個方法的名稱和參數完全相同，通過子類創建的實例對象調用這個方法時，將調用子類中的定義方法，這相當於把父類中定義的那個完全相同的方法給覆蓋了，這也是面向對象編程的多態性的一種表現。

在使用重載時只能通過不同的參數樣式。例如，不同的參數類型，不同的參數個數，不同的參數順序（當然，同一方法內的幾個參數類型必須不一樣，例如可以是 fun(int,float)，但是不能為 fun(int,int)）

被覆蓋和被重載的方法都不能是private。

8）構造器 Constructor 是否可被 override?

構造器 Constructor 不能被繼承，因此不能重寫 Override，但可以被重載 Overload。

9）面向對象的特徵有哪些方面？

面向對象的程式語言有封裝、繼承、抽象、多態等 4 個主要的特徵。

封裝：實現軟體部件的「高內聚、低耦合」，防止程式相互依賴性而帶來的變動影響。在面向對象的程式語言中，對象是封裝的最基本單位，把對同一事物進行操作的方法和相關的方法放在同一個類中，把方法和它操作的數據放在同一個類中。私有的屬性，公有的方法。

例子：面向對象的封裝性，即將對象封裝成一個高度自治和相對封閉的個體，對象狀態（屬性）由這個對象自己的行為（方法）來讀取和改變。一個更便於理解的例子就是，司機將火車剎住了，剎車的動作是分配給司機，還是分配給火車，顯然，應該分配給火車，因為司機自身是不可能有那麼大的力氣將一個火車給停下來的，只有火車自己才能完成這一動作，火車需要調用內部的離合器和剎車片等多個器件協作才能完成剎車這個動作，司機剎車的過程只是給火車發了一個消息，通知火車要執行剎車動作而已。

抽象：抽象就是找出一些事物的相似和共性之處，然後將這些事物歸為一個類，這個類只考慮這些事物的相似和共性之處，並且會忽略與當前主題和目標無關的那些方面，將注意力集中在與當前目標有關的方面。

繼承：在定義和實現一個類的時候，可以在一個已經存在的類的基礎之上來進行，把這個已經存在的類所定義的內容作為自己的內容，並可以加入若干新的內容，或修改原來的方法使之更適合特殊的需要，這就是繼承。繼承是子類自動共享父類數據和方法的機制，這是類之間的一種關係，提高了軟體的可重用性和可擴展性。

多態：多態是指程式中定義的引用變數所指向的具體類型和通過該引用變數發出的方法調用在編程時並不確定，而是在程式運行期間才確定，即一個引用變數到底會指向哪個類的實例對象，該引用變數發出的方法調用到底是哪個類中實現的方法，必須在由程式運行期間才能決定。

10）Java中實現多態的機制是什麼？

父類或介面定義的引用變數可以指向子類或具體實現類的實例對象，而程式調用的方法在運行期才動態綁定，就是引用變數所指向的具體實例對象的方法，也就是記憶體里正在運行的那個對象的方法，而不是引用變數的類型中定義的方法。

11）abstract class 和 interface 有什麼區別？

含有 abstract 修飾符的 class 即為抽象類，abstract 類不能創建的實例對象。含有 abstract 方法的類必須定義為 abstract class，abstract class 類中的方法不必全是抽象的（也就是說可以有一個抽象類，裡面沒有抽象方法），但是不可以是private的。abstract class 類中定義抽象方法必須在具體(Concrete)子類中實現，所以，不能有抽象構造方法或抽象靜態方法（但是可以有普通靜態方法和普通構造方法）。如果的子類沒有實現抽象父類中的所有抽象方法，那麼子類也必須定義為 abstract 類型。

介面（interface）可以說成是抽象類的一種特例，介面中的所有方法都必須是抽象的。介面中的方法定義默認為 public abstract 類型，介面中的成員變數類型默認為 public static final。

簡言之，抽象類本質是是類，可以有普通類有的一些東西，但是介面比抽象類還要抽象，介面中只能有公開的未實現的方法。

一個類可以實現多個介面但是只能繼承一個抽象類。介面不可以有普通成員變數，但是可以有靜態成員變數，介面不可以有靜態方法。介面不可以有構造方法。

總結：介面主要是給出一些方法，如果某個類實現了這個介面，這些功能就會加到這個類上。

抽象類本質上還是類，只不過這個類不清楚自己到底幹了什麼沒幹什麼，因為他自身存在沒有實現完的東西需要留給繼承它的子類去做。

12）什麼是native方法？

簡單地講，一個Native Method就是一個java調用非java程式碼的介面。

Java程式中聲明native修飾的方法，類似於abstract修飾的方法，只有方法簽名，沒有方法實現。編譯該java文件，會產生一個.class文件。

使用javah編譯上一步產生的class文件，會產生一個.h文件。

寫一個.cpp文件實現上一步中.h文件中的方法。

將上一步的.cpp文件編譯成動態鏈接庫文件.dll。

最後就可以使用System或是Runtime中的loadLibrary()方法載入上一步的產生的動態連接庫文件了。

13）談一談對String的理解？

基本數據類型包括 byte、int、char、long、float、double、boolean 和 short。
java.lang.String 類是 final 類型的，因此不可以繼承這個類、不能修改這個類。為了提高效率節省空間，我們應該用 StringBuffer 類

14）數組有沒有 length()這個方法? String 有沒有 length()這個方法？

數組沒有 length()這個方法，有 length 的屬性。String 有有 length()這個方法。

15）這條語句一共創建了多少個對象：String s=”a”+”b”+”c”+”d”;

String s1 = "a"; 
String s2 = s1 + "b"; 
String s3 = "a" + "b";
System.out.println(s2 == "ab"); 
System.out.println(s3 == "ab");

第一條語句列印的結果為 false，第二條語句列印的結果為 true，這說明 javac 編譯可以對字元串常量直接相加的表達式進行優化，不必要等到運行期去進行加法運算處理，而是在編譯時去掉其中的加號，直接將其編譯成一個這些常量相連的結果。
題目中的第一行程式碼被編譯器在編譯時優化後，相當於直接定義了一個」abcd」的字元串，所以， 上面的程式碼應該只創建了一個 String 對象。寫如下兩行程式碼，
String s = “a” + “b” + “c” + “d”; System.out.println(s == “abcd”);
最終列印的結果應該為 true。

16）try {}里有一個 return 語句，那麼緊跟在這個 try 後的 finally {}里的 code 會不會被執行，什麼時候被執行，在 return 前還是後?

package com.test;

public class Test1 {
    public static void main(String[] args) {
        try {
            System.out.println(new Test1().testname());
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public String testname() throws Exception {
        String t = "";

        try {
            t = "try";
            System.out.println("try");
            return t;
        } catch (Exception e) {
            // result = "catch";
            t = "catch";
            return t;
        } finally {

            System.out.println("finally");
            // return t = "finally";
        }
    }
}
列印結果如下：
try
finally
try
將finally中的注釋放開，列印結果如下：
try
finally
finally

參考：//www.cnblogs.com/xh_Blog/p/6518620.html

結論：finally中的程式碼肯定會執行，但是會先執行try中的程式碼，如果try中有return，那麼return的東西會先放到函數棧中，然後再執行finally中的程式碼，

①、如果finally中也有return，則會直接返回並終止程式，函數棧中的return不會被完成！；

②、如果finally中沒有return，則在執行完finally中的程式碼之後，會將函數棧中的try中的return的內容返回並終止程式；

catch同try;

17）error 和 exception 有什麼區別?

error 表示恢復不是不可能但很困難的情況下的一種嚴重問題。比如說記憶體溢出。error不可能指望程式能處理這樣的情況。exception 表示一種設計或實現問題。也就是說，它表示如果程式運行正常，從不會發生的情況。

18）Java 中的異常處理機制的簡單原理和應用。

異常是指 java 程式運行時（非編譯）所發生的非正常情況或錯誤。

Java 對異常進行了分類，不同類型的異常分別用不同的 Java 類表示，所有異常的根類為java.lang.Throwable，Throwable 下面又派生了兩個子類：Error 和 Exception，Error 表示應用程式本身無法克服和恢復的一種嚴重問題，程式只有死的份了，例如，說記憶體溢出和執行緒死鎖等系統問題。Exception 表示程式還能夠克服和恢復的問題，其中又分為系統異常和普通異常，系統異常是軟體本身缺陷所導致的問題，也就是軟體開發人員考慮不周所導致的問題，軟體使用者無法克服和恢復這種問題，但在這種問題下（系統異常）還可以讓軟體系統繼續運行或者讓軟體死掉，例如，數組腳本越界（ArrayIndexOutOfBoundsException），空指針異常（NullPointerException）、類轉換異常（ClassCastException）；普通異常（程式不應該死掉）是運行環境的變化或異常所導致的問題，是用戶能夠克服的問題，例如，網路斷線，硬碟空間不夠，發生這樣的異常後，程式不應該死掉。

java 為系統異常和普通異常提供了不同的解決方案，編譯器強制普通異常必須 try..catch 處理或用 throws 聲明繼續拋給上層調用方法處理，所以普通異常也稱為 checked 異常，而系統異常可以處理也可以不處理，所以，編譯器不強制用 try..catch 處理或用 throws 聲明，所以系統異常也稱為 unchecked 異常。

19）請寫出你最常見到的 5 個 runtime exception。

參考：//blog.csdn.net/qq_20417499/article/details/80222820

ClassNotFoundException找不到類異常
當應用試圖根據字元串形式的類名構造類，而在遍歷CLASSPAH之後找不到對應名稱的class文件時，拋出該異常。

ArrayIndexOutOfBoundsException數組下標越界異常
當使用的數組下標超出數組允許範圍時，拋出該異常。

NullPointerException空指針異常類
String s=null;
int size=s.size();
當應用程式試圖在需要對象的地方使用 null 時，拋出異常。

ArithmeticException算術異常類
int a=5/0;
一個整數「除以零」時，拋出異常。

ClassCastException類型強制轉換異常
Object x = new Integer(0);
System.out.println((String)x);
當試圖將對象強制轉換為不是實例的子類時，拋出該異常。

20）什麼是執行緒安全？

含義：當多個執行緒訪問某個方法時，不管你通過怎樣的調用方式或者說這些執行緒如何交替的執行，我們在主程式中不需要去做任何的同步，這個類的結果行為都是我們設想的正確行為，那麼我們就可以說這個類時執行緒安全的。
如果一段程式碼可以保證多個執行緒訪問的時候正確操作共享數據，那麼它是執行緒安全的。

21）ArrayList 和 Vector 的區別？

共同點：這兩個類都實現了 List 介面（List 介面繼承了 Collection 介面），他們都是有序集合，即存儲在這兩個集合中的元素的位置都是有順序的，相當於一種動態的數組，我們以後可以按位置索引號取出某個元素，並且其中的數據是允許重複的。

區別：

同步性：Vector 是執行緒安全的，也就是說是它的方法之間是執行緒同步的，而 ArrayList 是執行緒序不安全的，它的方法之間是執行緒不同步的。

數據增長：當存儲進它們裡面的元素的個數超過了容量時，Vector 增長原來的一倍，ArrayList 增加原來的 0.5 倍。

22）HashMap 和 HashTable 的區別？

HashMap 是 HashTable 的輕量級實現（非執行緒安全的實現），他們都完成了 Map 介面，主要區別在於 HashMap 允許空（null）鍵值（key）,由於非執行緒安全，在只有一個執行緒訪問的情況下，效率要高於 HashTable。

HashMap 不是執行緒安全的 HashTable 實現了執行緒同步

HashMap 允許出現null的key或者value但是HashTable 不允許

23）Collection 簡述？

為了保存數量不確定的數據，以及保存具有映射關係的數據（也被稱為關聯數組），Java提供了集合類。集合類主要負責保存、盛裝其他數據，因此集合類也被稱為容器類。Java 所有的集合類都位於 java.util 包下，提供了一個表示和操作對象集合的統一構架，包含大量集合介面，以及這些介面的實現類和操作它們的演算法。

集合類和數組不一樣，數組元素既可以是基本類型的值，也可以是對象（實際上保存的是對象的引用變數），而集合里只能保存對象（實際上只是保存對象的引用變數，但通常習慣上認為集合里保存的是對象）。其實你在添加list.add(1)的時候基本數據類型的1被自動裝箱成為了Integer類型。

Java 集合類型分為 Collection 和 Map，它們是 Java 集合的根介面，這兩個介面又包含了一些子介面或實現類。圖 1 和圖 2 分別為 Collection 和 Map 的子介面及其實現類。

24）Collection 和 Collections 的區別？

Collection 是集合類的上級介面，繼承與他的介面主要有 Set 和 List.
Collections 是針對集合類的一個幫助類，他提供一系列靜態方法實現對各種集合的搜索、排序、執行緒安全化等操作。

類比Object和Objects

25）== 和 equals 的區別是什麼？

一、對象類型不同

1、equals()：是超類Object中的方法。

2、==：是操作符。

二、比較的對象不同

1、equals()：用來檢測兩個對象是否相等，即兩個對象的內容是否相等。

2、==：用於比較引用和比較基本數據類型時具有不同的功能，具體如下：

（1）、基礎數據類型：比較的是他們的值是否相等，比如兩個int類型的變數，比較的是變數的值是否一樣。

（2）、引用數據類型：比較的是引用的地址是否相同，比如說新建了兩個User對象，比較的是兩個User的地址是否一樣。

三、運行速度不同

1、equals()：沒有 == 運行速度快。

2、== 運行速度比equals()快，因為 == 只是比較引用。

總結：equals方法比較的是對象的值是否相等，而 == 比較的是引用是否相等，也就是說，如果當兩個對象的值一樣但是引用地址不一樣的時候，用equals比較是true但是用 == 就是false。

補充：Java有 5種引用類型（對象類型）：類介面數組枚舉標註

26）你所知道的集合類都有哪些？主要方法？

Set，大概的方法是 add,remove, contains；

對於 map，大概的方法就是put,remove，contains 等，List 類會有 get(int index)這樣的方法，因為它可以按順序取元素，而 Set 類中沒有 get(int index)這樣的方法。

List 和 Set 都可以迭代出所有元素，迭代時先要得到一個iterator 對象，所以，Set 和 list 類都有一個 iterator 方法，用於返回那個 iterator 對象。

map 可以返回三個集合，一個是返回所有的 key 的集合，另外一個返回的是所有 value 的集合，再一個返回的 key 和 value 組合成的 EntrySet 對象的集合，map 也有 get 方法，參數是 key，返回值是 key 對應的 value。

27）列舉幾個你常用的類、介面和包

Java常用的類：BufferedReader BufferedWriter ，FileReader FileWirter ，Date， Class，、String

java常用的介面：List ，Map ，Set，HttpServletRequest ，HttpServletResponse ，Servlet

java常用的包：java.lang ，java.io ，java.util ，java.sql ，javax.servlet

java.lang：該包提供了Java語言進行程式設計的基礎類，它是默認導入的包。該包裡面的Runnable介面和Object、Math、String、StringBuffer、System、Thread以及Throwable類需要重點掌握，因為它們應用很廣。

java.util：該包提供了包含集合框架、遺留的集合類、事件模型、日期和時間實施、國際化和各種實用工具類（字元串標記生成器、隨機數生成器和位數組）。

java.io：該包通過文件系統、數據流和序列化提供系統的輸入與輸出。

java.sql：該包提供了使用Java語言訪問並處理存儲在數據源（通常是一個關係型資料庫）中的數據API。

javax.servlet：包含了一定數量的類和介面，這些類和介面描述和定義了一個servlet程式和運行時環境的合約。這運行時環境提供給遵循 servlet容器的類的實例。

28）Java 棧和堆的區別

1 棧：為編譯器自動分配和釋放，如函數參數、局部變數、臨時變數等等
2 堆：為成員分配和釋放，由程式設計師自己申請、自己釋放。否則發生記憶體泄露。典型為使用new申請的堆內容。
3 靜態存儲區：記憶體在程式編譯的時候就已經分配好，這塊記憶體在程式的整個運行期間都存在。它主要存放靜態數據、全局數據和常量。

二、JavaWeb

29）解釋一下什麼是 servlet

servlet 有良好的生存期的定義，包括載入和實例化、初始化、處理請求以及服務結束。這個生存期由 javax.servlet.Servlet 介面的 init,service 和 destroy 方法表達。

30）描述一下 servlet 生命周期

Servlet 被伺服器實例化後，容器運行其 init 方法，請求到達時運行其 service 方法，service 方法自動派遣運行與請求對應的 doXXX 方法（doGet，doPost）等，當伺服器決定將實例銷毀的時候調用其 destroy 方法。

31）servlet基本架構

public class ServletName extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

	}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

	}
}

32）SERVLET API 中 forward() 與 redirect()的區別？

前者僅是容器中控制權的轉向，在客戶端瀏覽器地址欄中不會顯示出轉向後的地址；

後者則是完全的跳轉，瀏覽器將會得到跳轉的地址，並重新發送請求鏈接。這樣，從瀏覽器的地址欄中可以看到跳轉後的鏈接地址。

33）jsp 有哪些動作?作用分別是什麼?

jsp:include：在頁面被請求的時候引入一個文件。

jsp:useBean：尋找或者實例化一個 JavaBean。

jsp:setProperty：設置 JavaBean 的屬性。

jsp:getProperty：輸出某個 JavaBean 的屬性。

jsp:forward：把請求轉到一個新的頁面。

jsp:plugin：根據瀏覽器類型為 Java 插件生成 OBJECT 或 EMBED 標記

三、資料庫

34）JdbcUtils (mysql)

import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.net.URLDecoder;
import java.sql.*;
import java.util.Properties;
public class JdbcUtils {
    /**
     *  創建一個jdbc的工具類，簡化創建連接和釋放資源的操作
     */
    private static String url;
    private static String user;
    private static String password;

    //創建靜態程式碼塊，在類載入的時候執行一次，用來讀取配文件
    static {
        try {
            //創建properties集合類
            Properties properties = new Properties();
            //注意，用類載入器來動態獲取src下的配置文件路徑
            ClassLoader classLoader = JdbcUtils.class.getClassLoader();
            URL resource = classLoader.getResource("jdbc.properties");
            String path1 = resource.getPath();
            //用urlDecoder來解決中文jdbc中文路徑亂碼的問題
            String path = URLDecoder.decode(path1, "utf-8");
            System.out.println(path);
            //載入配置文件
           // properties.load(new FileReader("src/jdbc.properties"));
            //用path來動態的獲取路徑
            properties.load(new FileReader(path));
            //獲取資訊
             url = properties.getProperty("url");
             user = properties.getProperty("user");
             password = properties.getProperty("password");
            String driver = properties.getProperty("driver");

            //註冊驅動
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

    //1.定義創建連接的方法
    public  static Connection getConnection(){
        try  {
            System.out.println("url"+url);
            Connection connection = DriverManager.getConnection(url, user, password) ;
            return connection;
        }catch (Exception e){
            return null;
        }

    }
    //2.定義釋放資源的方法

    public static void close(Statement statement ,Connection connection){
        if (statement!=null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(connection!=null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
    //3.釋放資源方法重載
    public static void close(ResultSet rs ,Statement statement ,Connection connection){
        if (rs!=null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (statement!=null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(connection!=null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}

35）Jdbc 連接 oracle

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class dbUtil {
  public static Connection getConnection(){
	  Connection conn=null;
	  
	  try {
		String url="jdbc:oracle:thin:@127.0.0.1:1521:orcl";
		  String user="scott";
		  String password="tiger";
		  
		  Class.forName("oracle.jdbc.driver.OracleDriver");//載入數據驅動
		  conn = DriverManager.getConnection(url, user, password);// 連接資料庫
		  
	} catch (ClassNotFoundException e) {
		e.printStackTrace();
		System.out.println("載入資料庫驅動失敗");
	}catch(Exception e){
		e.printStackTrace();
		System.out.println("連接資料庫失敗");
	}
	  return conn;
  }
  public static void close(Connection conn, PreparedStatement ps, ResultSet rs){
	  try {
		if(rs!=null){
			  rs.close();
		  }
	} catch (SQLException e) {
		e.printStackTrace();
	}
	  
	  try {
			if(ps!=null){
				  ps.close();
			  }
		} catch (SQLException e) {
			e.printStackTrace();
		}
	  
	  try {
			if(conn!=null){
				  conn.close();
			  }
		} catch (SQLException e) {
			e.printStackTrace();
		} 
  }
}

36）大數據量下的分頁解決方法

"select * from students order by id limit " + pageSize*(pageNumber-1) + "," + pageSize;

37）ORM是什麼，有什麼作用？

對象關係映射（Object Relational Mapping，簡稱ORM）模式是一種為了解決面向對象與關係資料庫存在的互不匹配的現象的技術。簡單的說，ORM是通過使用描述對象和資料庫之間映射的元數據，將程式中的對象自動持久化到關係資料庫中。

ORM是面向對象程式設計語言和關係資料庫發展不同步時的中間解決方案。採用ORM框架後，應用程式不再直接訪問底層資料庫，而是以面向對象的方式來操作持久化對象（創建、修改、刪除等），而ORM框架則將這些面向對象的操作轉換成底層的SQL操作。

===

作者：Dcl_Snow
鏈接：//www.jianshu.com/p/90c4ca01824d
來源：簡書
著作權歸作者所有。商業轉載請聯繫作者獲得授權，非商業轉載請註明出處。

===

四、J2EE

38）C/S 與 B/S 區別

１．硬體環境不同
C/S 一般建立在專用的網路上, 小範圍里的網路環境, 區域網之間再通過專門伺服器提供連接和數據交換服務.
B/S 建立在廣域網之上的, 不必是專門的網路硬體環境,例與電話上網, 租用設備. 資訊自己管理. 有比 C/S 更強的適應範圍, 一般只要有作業系統和瀏覽器就行
２．對安全要求不同
C/S 一般面向相對固定的用戶群, 對資訊安全的控制能力很強. 一般高度機密的資訊系統採用 C/S 結構適宜. 可以通過 B/S 發布部分可公開資訊.
B/S 建立在廣域網之上, 對安全的控制能力相對弱, 可能面向不可知的用戶。

３．對程式架構不同
C/S 程式可以更加註重流程, 可以對許可權多層次校驗, 對系統運行速度可以較少考慮.
B/S 對安全以及訪問速度的多重的考慮, 建立在需要更加優化的基礎之上. 比 C/S 有更高的要求 B/S 結構的程式架構是發展的趨勢, 從 MS 的.Net 系列的 BizTalk 2000 Exchange 2000 等, 全面支援網路的構件搭建的系統. SUN 和IBM 推的JavaBean 構件技術等,使 B/S 更加成熟.
４．軟體重用不同
C/S 程式可以不可避免的整體性考慮, 構件的重用性不如在 B/S 要求下的構件的重用性好

B/S 對的多重結構,要求構件相對獨立的功能. 能夠相對較好的重用.就入買來的餐桌可以再利用,而不是做在牆上的石頭桌子
５．系統維護不同
C/S 程式由於整體性, 必須整體考察, 處理出現的問題以及系統升級. 升級難. 可能是再做一個全新的系統
B/S 構件組成,方面構件個別的更換,實現系統的無縫升級. 系統維護開銷減到最小.用戶從網上自己下載安裝就可以實現升級.
６．處理問題不同
C/S 程式可以處理用戶面固定, 並且在相同區域, 安全要求高需求, 與作業系統相關. 應該都是相同的系統
B/S 建立在廣域網上, 面向不同的用戶群, 分散地域, 這是 C/S 無法作到的. 與作業系統平台關係最小.
７．用戶介面不同
C/S 多是建立的 Window 平台上,表現方法有限,對程式設計師普遍要求較高
B/S 建立在瀏覽器上, 有更加豐富和生動的表現方式與用戶交流. 並且大部分難度減低, 減低開發成本.
８．資訊流不同
C/S 程式一般是典型的中央集權的機械式處理, 交互性相對低
B/S 資訊流向可變化, B-B B-C B-G 等資訊、流向的變化, 更像交易中心。

39）WEB伺服器和應用伺服器的區別

應用伺服器處理業務邏輯，web伺服器則主要是讓客戶可以通過瀏覽器進行訪問，處理HTML文件，web伺服器通常比應用伺服器簡單。
WEB伺服器:Apache、IIS、Nginx（也是反向代理伺服器）
應用伺服器:Tomcat、Weblogic、Jboss

舉例：一般來說，大的站點都是將Tomcat與Apache的結合，Apache負責接受所有來自客戶端的HTTP請求，然後將Servlets和JSP的請求轉發給Tomcat來處理。Tomcat完成處理後，將響應傳回給Apache，最後Apache將響應返回給客戶端。

五、MyBatis

40）談談 MyBatis

Mybatis 是一個半自動化的 ORM 框架，它對 jdbc 的操作資料庫的過程進行封裝，使得開發者只需要專註於 SQL 語句本身，而不用去關心註冊驅動，創建 connection 等，Mybatis 通過 xml 文件配置或者註解的方式將要執行的各種 statement 配置起來，並通過 java 對象和 statement 中的sql 進行映射成最終執行的 sql 語句，最後由 Mybatis 框架執行 sql 並將結果映射成 java 對象並返回。每個 MyBatis 應用程式主要都是使用 SqlSessionFactory 實例的，一個 SqlSessionFactory 實例可以通過 SqlSessionFactoryBuilder 獲得。SqlSessionFactoryBuilder 可以從一個 xml 配置文件或者一個預定義的配置類的實例獲得。
Mybatis 分為三層
（1） API 介面層：提供給外部使用的介面 API
（2）數據處理層：負責具體的 SQL
（3）基礎支撐層：負責最基礎的功能支撐，如連接管理，事務管理，配置載入和快取處。理

41）Mybatis 的優點

基於 SQL 語句編程，相當靈活，不會對應用程式或者資料庫的現有設計造成任何影響，SQL 寫在 XML 里，解除 sql 與程式程式碼的耦合，便於統一管理；提供 XML 標籤，支援編寫動態 SQL 語句，並可重用。

與 JDBC 相比，減少了 50%以上的程式碼量，消除了 JDBC 大量冗餘的程式碼，不需要手動開關連接；

很好的與各種資料庫兼容（因為 MyBatis 使用 JDBC 來連接資料庫，所以只要 JDBC 支援的資料庫 MyBatis 都支援）。
能夠與 Spring 很好的集成；

提供映射標籤，支援對象與資料庫的 ORM 欄位關係映射；提供對象關係映射標籤，支援對象關係組件維護。

42）Mybatis 的優點

Sql 語句的編寫工作量較大，尤其當欄位多、關聯表多時，對開發人員編寫 Sql 語句的功底有一定要求。

對性能的要求很高，或者需求變化較多的項目，如互聯網項目，MyBatis 將是不錯的選擇。

43）Mybatis 的編程過程是怎樣的

創建 SqlSessionFactory

通過 SqlSessionFactory 創建 SqlSession

通過 sqlsession 執行資料庫操作

調用 sqlsession.commit()提交事務

調用 sqlsession.close()關閉會話

44）Mybatis 中#和$的區別？

${}是 Properties 文件中的變數佔位符，它可以用於標籤屬性值和 sql 內部，屬於靜態文本替換

{}是 sql 的參數佔位符，Mybatis 會將 sql 中的#{}替換為?號，在 sql 執行前會使用PreparedStatement 的參數設置方法，按序給 sql 的? 號佔位符設置參數值。

方式能夠很大程度防止 sql 注入。

$方式無法防止 Sql 注入。
$方式一般用於傳入資料庫對象，例如傳入表名。

為什麼 # 可以防止SQL注入？參考作者：//www.cnblogs.com/coder-who/

1.什麼是SQL注入

答：SQL注入是通過把SQL命令插入到web表單提交或通過頁面請求的查詢字元串，最終達到欺騙伺服器執行惡意的SQL指令。

　　注入攻擊的本質是把用戶輸入的數據當做程式碼執行。

　　舉例如: 表單有兩個用戶需要填寫的表單數據，用戶名和密碼，如果用戶輸入admin(用戶名)，111(密碼)，若資料庫中存在此用戶則登錄成功。SQL大概是這樣

　　　　　　SELECT * FROM XXX WHERE userName = admin and password = 111

　　　　　但若是遭到了SQL注入，輸入的數據變為 admin or 1 =1 # 密碼隨便輸入，這時候就直接登錄了，SQL大概是這樣

　　　　　　SELECT * FROM XXX WHERE userName = admin or 1 = 1 # and password = 111 ,因為 # 在sql語句中是注釋，將後面密碼的驗證去掉了，而前面的條件中1 = 1始終成立，所以不管密碼正確與否，都能登錄成功。

2.mybatis中的#{} 為什麼能防止sql注入，${}不能防止sql注入

答: #{}在mybatis中的底層是運用了PreparedStatement 預編譯，傳入的參數會以 ? 形式顯示，因為sql的輸入只有在sql編譯的時候起作用，當sql預編譯完後，傳入的參數就僅僅是參數，不會參與sql語句的生成，而${}則沒有使用預編譯，傳入的參數直接和sql進行拼接，由此會產生sql注入的漏洞。

再次理解sql預編譯前後傳參數的區別？參考作者：//blog.csdn.net/weixin_46099269

select * from user where uid=#{id} and password=#{pwd};
這時資料庫就會進行預編譯，並進行一個快取動作，快取一條這樣的語句：
select * from user where uid=? and password=?;
當我們調用這條語句，並實際向#{id}中的id傳了一個值「deftiii」 or 1=1# 時，不需要在編譯，資料庫會直接找對應的表中有沒有名字是「deftiii」 or 1=1# 的用戶，而不再有編譯sql語句的過程。

45）使用 MyBatis 的 mapper 介面調用時有哪些要求？

Mapper介面方法名和 mapper.xml 中定義的每個 sql 的 id 相同

Mapper 介面方法的輸入參數類型和 mapper.xml 中定義的每個 sql 的 parameterType 的類型相同

Mapper 介面方法的輸出參數類型和 mapper.xml 中定義的每個 sql 的 resultType 的類型相同

Mapper.xml 文件中的 namespace 即是 mapper 介面的類路徑。

46）簡述 Mybatis 的 Xml 映射文件和 Mybatis 內部數據結構間的映射關係？

Mybatis 將所有 Xml 配置資訊都封裝到 All-In-One 重量級對象 Configuration 內部。

標籤會被解析為 ParameterMap 對象，其每個子元素會被解析為ParameterMapping 對象。

標籤會被解析為 ResultMap 對象，其每個子元素會被解析為ResultMapping 對象。

每一個select 、insert 、update 、delete 標籤均會被解析為MappedStatement 對象，標籤內的 sql 會被解析為 BoundSql 對象。

47）Mybatis 的 Xml 映射文件中，不同的 Xml 映射文件，id 是否可以重複？

可以！

不同的 Xml 映射文件，如果配置了 namespace，那麼 id 可以重複；如果沒有配置 namespace，那麼 id 不能重複。

48）談談Mybatis 快取

MyBatis包含一個非常強大的查詢快取特性，它可以非常方便地訂製和配置快取。快取可以極大的提升查詢效率。（快取的本質就是把你查詢過的東西暫時保存一下，如果兩次查詢都用的同一個session或者是同一個namespace，那麼同樣的sql語句就不用多次執行了。）

一級快取和二級快取
- 默認情況下，只有一級快取開啟。（SqlSession級別的快取，也稱為本地快取）
- 二級快取需要手動開啟和配置，他是基於namespace級別的快取。
- 為了提高擴展性，MyBatis定義了快取介面Cache。我們可以通過實現Cache介面來自定義二級快取

一級快取失效的四種情況

沒有使用到當前的一級快取，效果就是，還需要再向資料庫中發起一次查詢請求！sqlSession不同。
sqlSession相同，查詢條件不同
1. User user = mapper.queryUserById(1);
2. User user2 = mapper2.queryUserById(2);
sqlSession相同，兩次查詢之間執行了增刪改操作！
sqlSession相同，手動清除一級快取
- session.clearCache(); //手動清除快取

小結

只要開啟了二級快取，我們在同一個Mapper中的查詢，可以在二級快取中拿到數據
查出的數據都會被默認先放在一級快取中
只有會話提交或者關閉以後，一級快取中的數據才會轉到二級快取中

49）Mybatis 分頁

limit分頁

RowBounds 進行分頁，非常方便，不需要在 sql 語句中寫 limit，即可完成分頁功能。但是由於它是在 sql 查詢出所有結果的基礎上截取數據的，所以在數據量大的sql中並不適用，它更適合在返回數據結果較少的查詢中使用。

最核心的是在 mapper 介面層，傳參時傳入 RowBounds(int offset, int limit) 對象，即可完成分頁。

Mybatis分頁插件PageHelper

RowBounds的使用

mapper 介面層程式碼如下

List selectBookByName(Map<String, Object> map, RowBounds rowBounds);
調用如下

List list = bookMapper.selectBookByName(map, new RowBounds(0, 5));
原文鏈接：//blog.csdn.net/wsjzzcbq/article/details/83447948

PageHelper的使用

PageHelper參考自：//www.jianshu.com/p/50fcd7f127f0

在service中,先開啟分頁，然後把查詢結果集放入PageInfo中。

public PageInfo listUserByPage(int pageNum, int pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        List<UserVo> userVoList=userMapper.listUser();
        PageInfo pageInfo=new PageInfo(userVoList);
        return pageInfo;
    }

PageHelper.startPage(pageNum, pageSize);這句非常重要，這段程式碼表示分頁的開始，意思是從第pageNum頁開始，每頁顯示 pageSize條記錄。

PageInfo這個類是插件里的類，這個類裡面的屬性會在輸出結果中顯示,
使用PageInfo這個類,你需要將查詢出來的list放進去

六、Hibernate

50）簡述一下 hibernate 的開發流程

第一步：載入 hibernate 的配置文件，讀取配置文件的參數(jdbc 連接參數，數據庫方言，hbm 表與對象關係映射文件)
第二步：創建 SessionFactory 會話工廠(內部有連接池)
第三步：打開 session 獲取連接，構造 session 對象(一次會話維持一個數據連接，也是一級快取)
第四步：開啟事務
第五步：進行操作
第六步：提交事務
第七步：關閉 session(會話)將連接釋放第八步：關閉連接池

51）Hibernate 和 JDBC 對比

共同點：1.Java資料庫操作中間件，執行緒不安全，顯式事務處理。

不同點：

JDBC 是 SUN 公司提供一套操作資料庫的規範，而Hibernate 是一個基於 jdbc 的主流持久化框架，對 JDBC 訪問資料庫的程式碼做了封裝。
使用的SQL語言不同：JDBC 使用的是基於關係型資料庫的標準 SQL 語言，Hibernate 使用的是 HQL(Hibernate query language)語言。
操作的對象不同：JDBC 操作的是數據，將數據通過 SQL 語句直接傳送到資料庫中執行，Hibernate 操作的是持久化對象，由底層持久化對象的數據更新到資料庫中。
數據狀態不同：
JDBC 操作的數據是「瞬時」的，變數的值無法與資料庫中的值保持一致，而 Hibernate 操作的數據是可持久的，即持久化對象的數據屬性的值是可以跟資料庫中的值保持一致的。

52）說說 hibernate 的三種狀態之間如何轉換？

hibernate 的三種狀態是瞬時狀態、持久狀態、託管狀態：

比如有一個 User 實體類和一張 User 表。當 new 了一個 user 對象，但沒有開啟事務。此時 user就處於瞬時狀態，與資料庫的數據沒有任何聯繫，

當開啟事務後，執行了 session.save()方法後，session 快取中存放了該 user 對象，而資料庫中也有相應的這條數據，此時就轉換為持久狀態。

當事務提交後，session 被銷毀。session 快取中就沒有 user 對象，而資料庫表中有相應記錄，此時為託管狀態。

53）如何搭建一個 Hibernate 的環境

先導入 jar 包與配置文件、hibernate 啟動 session 的工具類。

在配置文件中配置資料庫的基本資訊與資料庫方言

進行測試，先創建實體類和資料庫中的表。創建映射文件，命名規則是實體類名.hbm.xml。位置要與實體類同一包下。在映射文件中配置實體類與資料庫表之間的映射關係。在hibernate.cfg.xml 配置文件中添加映射文件的路徑。

通過 hibernate 的工具類創建 sessionfactory，通過工廠創建 session 對象，通過 session 開啟事務，進行數據操作後，事務提交。

七、Struts2

54）Struts2 執行流程

客戶端發送請求，請求到達服務端，由 struts 的核心控制器ActionServlet攔截請求。

核心控制器調⽤ action 映射器匹配請求路徑和映射路徑，判斷映射路徑是否存在。

核心控制器調⽤ actionProxy 代理器，actionProxy 代理調⽤配置管理器，配置管理器解析
struts.xml，匹配要訪問的 action，返回結果給 actionProxy 。

actionProxy 代理調⽤對應的 action，執⾏業務邏輯操作，調⽤之前執⾏⼀系列的攔截器(封裝請求參數，數據校驗等操作)。

action 返回 string 字元串，配置管理器確定返回結果，倒著執⾏⼀系列的攔截器。

返回結果給客戶端。

（圖片來自：//www.programminghunter.com/）

55）列舉 Struts2 中引入的一些有用的注釋？

@Action 創建動作類
@Actions 為多個動作配置單個類
@Namespace 和@Namespaces 用於創建不同的模組
@Result 用於結果頁面
@ResultPath 用於配置結果頁面位置

56）SpringMVC 和 Struts2 的區別？

Struts2 是類級別的攔截，一個類對應一個 request 上下文，SpringMVC 是方法級別的攔截，一個方法對應一個 request 上下文，而方法同時又跟一個 url 對應，所以說從架構本身上SpringMVC 就容易實現 restful url。
由於 Struts2 需要針對每個 request 進行封裝，把 request，session 等 servlet 生命周期的變數封裝成一個一個 Map，供給每個 Action 使用，並保證執行緒安全，所以在原則上，是比較耗費記憶體的。
攔截器實現機制上，Struts2 有以自己的 interceptor 機制，SpringMVC 用的是獨立的 AOP方式
SpringMVC 的入口是 servlet，而 Struts2 是 filter
- 區別：
  1. servlet流程是短的，url傳來之後，就對其進行處理，之後返回或轉向到某一自己指定的頁面。它主要用來在業務處理之前進行控制；
  2. filter流程是線性的，url傳來之後，檢查之後，可保持原來的流程繼續向下執行，被下一個filter，servlet接收等，而servlet處理之後，不會繼續向下傳遞。filter功能可用來保持流程繼續按照原來的方式進行下去，或者主導流程，而servlet的功能主要是用來主導流程。
  3. filter可用來進行字元編碼的過濾，檢查用戶是否登陸的過濾，禁止頁面快取等。
    （此處引用自）原文鏈接：//blog.csdn.net/weixin_42669555/article/details/81049423
SpringMVC 集成了 Ajax，使用非常方便，只需一個註解@ResponseBody 就可以實現，然後直接返迴響應文本即可。
Spring MVC 和 Spring 是無縫的。
設計思想上，Struts2 更加符合 OOP 的編程思想， SpringMVC 就比較謹慎，在 servlet 上擴展。
SpringMVC 開發效率（幾乎可以認為0配置）和性能高於 Struts2。

八、Spring

57）什麼是 Spring 的依賴注入

IOC（ Inversion of Control ）的⼀個重點是在系統運行中,動態的向某個對象提供它所需要的其他對象。

其中依賴注入（DI Dependency Injection）是實現IOC的一種方式。

a.介面注入

b.setter方法注入

c.構造方法注入

d.註解方式注入

平常我們 new 一個實例，這個實例的控制權是我們程式設計師，而控制反轉是指 new 實例工作不由我們程式設計師來做而是交給 spring 容器來做。

58）Spring 中的設計模式

a. 單例模式——spring 中兩種代理方式，若目標對象實現了若干介面， spring 使用 jdk 的java.lang.reflect.Proxy-Java 類代理。若目標兌現沒有實現任何介面，spring 使用 CGLIB 庫生成目標類的子類。單例模式——在 spring 的配置文件中設置 bean 默認為單例模式。
b. 模板方式模式——用來解決程式碼重複的問題。比如：RestTemplate、JmsTemplate、JpaTemplate
c. 前端控制器模式——spring 提供了前端控制器 DispatherServlet 來對請求進行分發。
d. 試圖幫助（viewhelper）——spring 提供了一系列的 JSP 標籤，高效宏來幫助將分散的程式碼整合在試圖中。
e. 依賴注入——貫穿於 BeanFactory/ApplacationContext 介面的核心理念
f. 工廠模式——在工廠模式中，我們在創建對象時不會對客戶端暴露創建邏輯，並且是通過使用同一個介面來指向新創建的對象。Spring 中使用 beanFactory 來創建對象的實例。

59）怎樣開啟註解裝配？

註解裝配在默認情況下是不開啟的，為了使用註解裝配，我們必須在 Spring 配置文件中配置context:annotation-config/元素。

60）Spring 的常用註解

@Required：該註解應用於設值方法
@Autowired：該註解應用於有值設值方法、非設值方法、構造方法和變數。
@Qualifier：該註解和@Autowired 搭配使用，用於消除特定 bean 自動裝配的歧義。

61）簡單解釋一下 Spring 的 AOP

AOP （ AspectOrientedProgramming ），即面向切面編程，可以說是 OOP（ObjectOrientedProgramming，面向對象編程）的補充和完善。

OOP 引入封裝、繼承、多態等概念來建立一種對象層次結構，用於模擬公共行為的一個集合。不過 OOP 允許開發者定義縱向的關係，但並不適合定義橫向的關係，例如日誌功能。

在 OOP 設計中，它導致了大量程式碼的重複，而不利於各個模組的重用。AOP 技術恰恰相反，它利用一種稱為”橫切” 的技術，剖解開封裝的對象內部，並將那些影響了多個類的公共行為封裝到一個可重用模組，並將其命名為”Aspect”，即切面。所謂”切面”，簡單說就是那些與業務無關，卻為業務模組所共同調用的邏輯或責任封裝起來，便於減少系統的重複程式碼，降低模組之間的耦合度，並有利於未來的可操作性和可維護性。

62）Spring 的通知是什麼？有哪幾種類型？

通知是個在方法執行前或執行後要做的動作，實際上是程式執行時要通過 SpringAOP 框架觸發的程式碼段。Spring 切面可以應用五種類型的通知：
1）before：前置通知，在一個方法執行前被調用。
2）after:在方法執行之後調用的通知，無論方法執行是否成功。
3）after-returning:僅當方法成功完成後執行的通知。
4）after-throwing:在方法拋出異常退出時執行的通知。
5）around:在方法執行之前和之後調用的通知。

九、SpringMVC

63）SpringMVC 的流程

a.用戶向伺服器發送請求，請求被 SpringMVC 前端控制器 DispatchServlet 捕獲；

b.DispatcherServlet 對請求 URL 進行解析，得到請求資源標識符（URL），然後根據該 URL 調用 HandlerMapping 將請求映射到處理器 HandlerExcutionChain；
c.DispatchServlet 根據獲得 Handler 選擇一個合適的 HandlerAdapter 適配器處理；
d.Handler 對數據處理完成以後將返回一個 ModelAndView（）對象給 DisPatchServlet;
e.Handler 返回的 ModelAndView()只是一個邏輯視圖並不是一個正式的視圖，DispatcherSevlet 通過 ViewResolver 試圖解析器將邏輯視圖轉化為真正的視圖 View ;
h.DispatcherServle 通過 model 解析出 ModelAndView()中的參數進行解析最終展現出完整的 view 並返回給客戶端;

64）SpringMVC 的主要組件

前端控制器 DispatcherServlet ，作⽤：接受請求、響應結果相當於轉發器，有了 DispatcherServlet 就減少了其他組件之間的耦合度。
處理器映射器 HandlerMapping，作⽤：根據請求的 URL 來查找 Handler。
處理器適配器 HandlerAdapter，注意：在編寫 Handler 的時候要按照 HandlerAdapter 要求的規則去編寫，這樣適配器 HandlerAdapter 才可以正確的去執⾏ Handler。
處理器 Handler(需要程式設計師開發)。

視圖解析器 ViewResolver。
視圖 View(需要程式設計師開發)。

（65）SpringMVC 的核心4入口類是什麼？Struts1,Struts2 的分別是什麼？

SpringMVC 的是 DispatcherServlet

Struts1 的是 ActionServlet

Struts2 的是 StrutsPrepareAndExecuteFilter

十、SpringBoot

（66）SpringBoot 簡介

Spring Boot 是 Spring 開源組織下的子項目，是 Spring 組件一站式解決方案，它的產⽣簡化了框架的使⽤，所謂簡化，是指簡化了使用 Spring 的難度，簡省了繁重的配置，提供了各種啟動器，開發者能快速上手，所以 SpringBoot 是⼀個服務於框架的框架，服務範圍是簡化配置⽂件。Spring Boot 優點，如：
（1）獨立運行（2）簡化配置（3）自動配置（4）無程式碼生成和 XML 配置（5）應用監控（6）上手容易

（67）SpringBoot 默認啟動方式是什麼？

運⾏帶有 mian ⽅法類。
類上需要加 @SpringBootApplication 注解， main ⽅法中使⽤
SpringApplication.run(類名.class，args);⾃動載入 application.properties ⽂件。

（68）SpringBoot 的配置⽂件有哪幾種格式？它們有什麼區別？

properties 和 yml，它們的區別主要是書寫格式不同。

yml 格式不⽀持@PropertySource 註解導⼊配置。

（69）如何在自定義埠上運行 Spring Boot 應用程式？

為了在自定義埠上運行 Spring Boot 應用程式，您可以在 application.properties 中指定埠。server.port = 8090

（70）SpringBoot 的核心註解是哪個？它主要由哪幾個註解組成的？

啟動類上⾯註解是@SpringBootApplication，它也是 SpringBoot 的核⼼註解，主要包含了以下 3 個註解：包括 @ComponentScan ， @SpringBootConfiguration，@EnableAutoConfiguration。

@EnableAutoConfiguration 的作⽤啟動⾃動的配置， @EnableAutoConfiguration 註解就是SpringBoot 根據你添加的 jar 包來配置你項⽬的默認配置，⽐如根據 spring-boot-starter-web，來判斷你項⽬是否添加了 webmvc 和 tomcat，就會⾃動幫你配置 web 項⽬中所需要的默配置。

@ComponentScan 掃描當前包及其⼦包下被 @Component ， @Controller ， @Service ， @Repository 註解標記的類並納⼊ spring 容器中進⾏管理。

@SpringBootConfiguration 繼承⾃@Configuration，⼆者功能也⼀直，標註當前類是配置類，並會將當前類內聲明的⼀個或多個以@Bean 註解標記的⽅法的實例納⼊到 spring 容器中並且實例名就是⽅法名。

（71）你如何理解 SpringBoot的Starters

Starters可以理解為啟動器，它包含了一系列可以集成到應用裡面的依賴包，
你可以一站式集成Spring及其他技術，而不需要到處找示例程式碼和依賴包。
如你想使用Spring 訪問資料庫，只要加入springboot-starter-data-jpa 啟動器依賴就能使用了。Starters包含了許多項目中需要用到的依賴，它們能快速持續的運行，都是一系列得到支援的管理傳遞性依賴。

原文鏈接：//blog.csdn.net/m0_51684972/article/details/110928657

JPA （Java Persistence【堅持】 API）Java持久化API。是一套Sun公司Java官方制定的ORM 方案,是規範，是標準。

（72）springboot 中常用的 starter 的組件有哪些？

spring-boot-starter-parent 	//boot 項目繼承的父項目模組. 
spring-boot-starter-web 	//boot 項目集成 web 開發模組.
spring-boot-starter-tomcat  //boot 項目集成 tomcat 內嵌伺服器. 
spring-boot-starter-test 	//boot 項目集成測試模組.
mybatis-spring-boot-starter //boot 項目集成 mybatis 框架.
spring-boot-starter-jdbc 	//boot 項目底層集成 jdbc 實現資料庫操作支援.
其他諸多組件，可到 maven 中搜索，或第三方 starter 組件到 github 上查詢

Tags: JAVA Spring+SpringMVC+Mybatis+SpringBoot+SpringCloud 乾貨資料庫雜七雜八軟體工程大三回顧總結閱讀永無止境閱讀筆記