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

阿新 • • 發佈：2022-05-27

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

參考：https://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。

參考：https://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
連結：https://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注入？參考作者：https://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預編譯前後傳引數的區別？參考作者：https://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));
原文連結：https://blog.csdn.net/wsjzzcbq/article/details/83447948

PageHelper的使用

PageHelper參考自：https://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 字串，配置管理器確定返回結果，倒著執⾏⼀系列的攔截器。

返回結果給客戶端。

（圖片來自：https://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可用來進行字元編碼的過濾，檢查使用者是否登陸的過濾，禁止頁面快取等。
    （此處引用自）原文連結：https://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包含了許多專案中需要用到的依賴，它們能快速持續的執行，都是一系列得到支援的管理傳遞性依賴。

原文連結：https://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 上查詢