2. 程式人生 > 實用技巧 >[Java Spring] Implementing Spring Security

[Java Spring] Implementing Spring Security

阿新 • • 發佈：2020-12-01

引入

說到異常先寫一個demo

public class Introduce {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("請輸入被除數：");
        int divisor = scanner.nextInt();
        System.out.print("請輸入除數：");
        int dividend = scanner.nextInt();
        System.out.println(div(divisor, dividend));
        System.out.println("繼續執行----------------");
    }

    public static int div(int divisor, int dividend) {
        return divisor / dividend;
    }
}

正常情況下沒問題，比如

萬一手欠把除數輸成0，那麼執行結果就變成這樣


或者：

像上面那樣在程式執行期間出現了不正常的情況而導致程式無法正常執行就稱作為異常，出現異常之後的程式碼也就不能執行！

那如何解決呢？第一種方案是可以用if-else來解決

public class Solution {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("請輸入被除數：");
        if (scanner.hasNextInt()) {
            int divisor = scanner.nextInt();
            System.out.print("請輸入除數：");
            if (scanner.hasNextInt()) {
                int dividend = scanner.nextInt();
                if (dividend != 0) {
                    System.out.println(div(divisor, dividend));
                } else {
                    System.out.println("除數不能為0");
                }
            } else {
                System.out.println("錄入的不是int資料！");
            }
        } else {
            System.out.println("錄入的不是int資料！");
        }
        System.out.println("繼續執行----------------");
    }

    public static int div(int divisor, int dividend) {
        return divisor / dividend;
    }
}

try-catch語句

看完之後是不是感覺這個if巢狀程式碼有些臃腫，業務程式碼也與處理異常的程式碼混在一起；可讀性還很差；最重要的是程式設計師無法想到所有可能發生異常情況。基於if-else處理機制的缺點，java提供了一套處理異常機制

public class Solution2 {
    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner(System.in);
            System.out.print("請輸入被除數：");
            int divisor = scanner.nextInt();
            System.out.print("請輸入除數：");
            int dividend = scanner.nextInt();
            System.out.println(div(divisor, dividend));
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("繼續執行----------------");
    }

    public static int div(int divisor, int dividend) {
        return divisor / dividend;
    }
}

這段程式碼的try-catch塊包圍的程式碼就是用來處理異常的也叫做捕獲異常，try塊用來處理可能出現異常的程式碼，catch塊用來處理try塊中出現的異常

語法：try{
		可疑程式碼，將異常生成對應的異常物件，傳遞給catch塊   
	 }catch(異常){
    	異常處理
	 }

發生情況：try塊中出現異常，則異常之後的程式碼不會執行，直接執行catch塊中的語句

​ try塊中沒出現異常，catch塊中的語句不會執行

​ catch中的異常型別和你給出的異常型別匹配的話，會執行catch塊中的語句

​ catch中的異常型別和你給出的異常型別不匹配的話，則相當於沒進行異常處理，catch塊中和之後的程式碼不會執行

//catch中處理異常
public class Catch {
    public static void main(String[] args) {
        try {
            int[] num = {42, 25, 32, 20, 14, 18};
            System.out.println(num[num.length]);
        } catch (Exception e) {
            //第一種：空處理，什麼都不寫

            //第二種：輸出自定義異常資訊
            System.out.println("程式碼出現異常！");

            //第三種：列印異常資訊
            System.out.println(e.toString());//列印異常的全限定名(包名+類名)
            System.out.println(e.getMessage());// 顯示異常描述資訊,這段程式碼提示你陣列長度是6
            e.printStackTrace();//顯示異常的詳細資訊
            
            //第四種：丟擲異常
            throw e;
        }
    }
}

另外try-catch語句還可以進行巢狀，catch語句也可以有多個形成多層catch

public class MultipleCatch {
    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner(System.in);
            System.out.print("請輸入被除數：");
            int divisor = scanner.nextInt();
            System.out.print("請輸入除數：");
            int dividend = scanner.nextInt();
            new MultipleCatch().div(divisor, dividend);
            //多層catch分別匹配InputMismatchException和ArithmeticException異常，匹配到哪一個就執行哪一個，如果沒匹配到相當於沒處理異常
        } catch (InputMismatchException e) {
            e.printStackTrace();
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } finally {
            System.out.println("繼續執行----------------");
        }
    }

    public void div(int num1, int num2) {
        System.out.println(num1 / num2);
    }
}

下面這個InputStream和OutputStream不知道是什麼，這沒關係，重點是演示try-catch語句

public class NestedTryCatch {
    public static void main(String[] args) {
        //InputStream和OutputStream都是一個流
        InputStream inputStream = null;
        OutputStream outputStream = null;
        try {
            inputStream = new FileInputStream(new File("F:\\study"));
            outputStream = new FileOutputStream(new File("F:\\study"));
            //多層catch，子類異常必須寫在父類異常上面
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch(Exception e) {
            e.printStackTrace();
        } finally {
            try {
                //流使用完畢需要關閉，這裡就是一個巢狀try-catch語句
                inputStream.close();
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

上面的多層匹配分別匹配FileNotFoundException、IOException和Exception異常，匹配到哪一個就執行哪一個

值得注意的是這幾個異常有繼承關係的，FileNotFoundException繼承自IOException，它也是接著繼承Exception的

異常體系

再看一下繼承體系

編譯時異常：就指程式編譯時產生的異常，必須處理，否則程式碼不能通過執行

執行時異常：執行之後才可能出現的異常，可以不做處理，一般是程式的邏輯錯誤，儘量避免！

越往上就是父類能處理的異常範圍越大，所以就可以想象出為什麼子類異常必須寫在父類，如果同級別的異常就不用關心順序

異常程式碼之後可能還有程式碼語句，但try-catch語句塊可能執行完之後後續程式碼不會執行

  1. throw丟擲異常

  2. catch語句塊沒有捕獲成功

  3. try語句塊中有return語句

public class Try {
    public static void main(String[] args) {
        try {
            String[] str = {"a", "b", "c", "d"};
            //System.out.println(str[str.length]);
            System.out.println(str.length);
            return;
        } catch (Exception e) {
            //throw e;
        }
        System.out.println("後續程式碼-------------");
    }
}

finally語句

但就想異常程式碼處理之後，無論異常資訊是否捕獲成功，後續的程式碼都會執行，可以加finally語句

public class Finally {
    public static void main(String[] args) {
        int num = 10;
        try {
            System.out.println(num); //執行結果：10
            return;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("後續程式碼-------------");
            num += 100;
            System.out.println(num); //執行結果：110，因為先執行finally再執行try中的return
        }
    }
}
//finally塊一般操作關閉資料庫資源，關閉IO流資源，關閉socket資源。

在進行異常捕獲的時候，return語句位置的不同其實可能會造成結果不同

//1、try中有return，finally中沒有return
public class Test01 {
    public static void main(String[] args){
        System.out.println(test());
    }

    private static int test(){
        int num = 10;
        try{
            System.out.println("try");
            return num += 80;
        }catch(Exception e){
            System.out.println("error");
        }finally{
            if (num > 20){
                System.out.println("num>20 : " + num);
            }
            System.out.println("finally");
        }
        return num;
    }
}

/*
執行結果：
	try
	num>20 : 90
	finally
	90
	
	這裡把return num += 80拆分成兩個語句了，num+=80和return，看一下class反編譯的程式碼
*/
public class Test1 {
    public TryTest() {
    }

    public static void main(String[] args) {
        System.out.println(test());
    }

    private static int test() {
        int num = 10;

        try {
            System.out.println("try");
            num += 80;
            int var1 = num;
            return var1;
        } catch (Exception var5) {
            System.out.println("error");
        } finally {
            if (num > 20) {
                System.out.println("num>20 : " + num);
            }

            System.out.println("finally");
        }
        return num;
    }
}


//2、try和finally中均有return
public class Test2 {
    public static void main(String[] args) {
        System.out.println(test());
    }

    private static int test() {
        int num = 10;
        try {
            System.out.println("try");
            return num += 80;
        } catch (Exception e) {
            System.out.println("error");
        } finally {
            if (num > 20) {
                System.out.println("num>20 : " + num);
            }
            System.out.println("finally");
            num = 100;
            return num;
        }
    }
}

/*
執行結果：
	try
	num>20 : 90
	finally
	100
	
	這裡同樣把return num += 80拆分成兩個語句了，num+=80和return，而且try中的return被省略了，直接執行finally中的return語句，得到返回值。看一下class反編譯的程式碼
*/
public class Test2 {
    public Test2() {
    }

    public static void main(String[] args) {
        System.out.println(test());
    }

    private static int test() {
        int num = 10;

        try {
            System.out.println("try");
            num += 80;
        } catch (Exception var5) {
            System.out.println("error");
        } finally {
            if (num > 20) {
                System.out.println("num>20 : " + num);
            }

            System.out.println("finally");
            int num = 100;
            return num;
        }
    }
}


//3、finally中改變返回值num,但是不返回
public class Test3 {
    public static void main(String[] args){
        System.out.println(test());
    }

    private static int test(){
        int num = 10;
        try{
            System.out.println("try");
            return num;
        }catch(Exception e){
            System.out.println("error");
        }finally{
            if (num > 20){
                System.out.println("num>20 : " + num);
            }
            System.out.println("finally");
            num = 100;
        }
        return num;
    }
}

/*
執行結果：
	try
	finally
	10
	
	finally沒有return時，這裡把num的值用第三方變數儲存起來了，finally執行結束return的是那個第三方變數，還是看一下class反編譯的程式碼
*/
public class Test3 {
    public Test3() {
    }

    public static void main(String[] args) {
        System.out.println(test());
    }

    private static int test() {
        byte num = 10;

        try {
            System.out.println("try");
            byte var1 = num;
            return var1;
        } catch (Exception var5) {
            System.out.println("error");
        } finally {
            if (num > 20) {
                System.out.println("num>20 : " + num);
            }

            System.out.println("finally");
            num = 100;
        }

        return num;
    }
}

//將num的值包裝在Num類中
public class Test4 {
    public static void main(String[] args){
        System.out.println(test().num);
    }

    private static Num test(){
        Num number = new Num();
        try{
            System.out.println("try");
            return number;
        }catch(Exception e){
            System.out.println("error");
        }finally{
            if (number.num > 20){
                System.out.println("number.num>20 : " + number.num);
            }
            System.out.println("finally");
            number.num = 100;
        }
        return number;
    }
}

class Num{
    public int num = 10;
}

/*
執行結果：
	try
	finally
	100

	這裡finally也沒有return，這裡第三方變數儲存的是建立物件的那個地址值，finally執行結束建立的物件改變值，還是看一下class反編譯的程式碼
*/
public class Test4 {
    public Test4() {
    }

    public static void main(String[] args) {
        System.out.println(test().num);
    }

    private static Num test() {
        Num number = new Num();

        try {
            System.out.println("try");
            Num var1 = number;
            return var1;
        } catch (Exception var5) {
            System.out.println("error");
        } finally {
            if (number.num > 20) {
                System.out.println("number.num>20 : " + number.num);
            }

            System.out.println("finally");
            number.num = 100;
        }

        return number;
    }
}

class Num {
    public int num = 10;

    Num() {
    }
}

throws

java除了提供了try-catch塊這種捕獲異常的解決方案，還提供了一種宣告丟擲異常的解決方案throws，即自己不處理這些異常，而是丟給呼叫方處理，如果整個程式的執行過程中都沒有異常的處理的話，最終異常會拋給jvm，不太友好，一般都要對異常進行處理

public class ThrowsDemo {
    public static void main(String[] args) throws Exception {
        new ThrowsDemo().test();
    }
    public void test() throws FileNotFoundException {
        FileInputStream inputStream=new FileInputStream("F:\\study\\test.txt");
    }
}

⾃定義異常

開發人員還可以⾃定義異常，⼀般通過繼承Exception的⼦類的⽅式實現，本質上是覆蓋原有異常API的資訊

public class CustomException extends Exception{

    static final long serialVersionUID = -70348971907L;

    public CustomException(String message) {
        super(message);
    }
}

//模擬一下餘額不足的情況
public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int money = scanner.nextInt();
        new Test().getMoney(money, 2000);
    }

    public int getMoney(int money, int price) {
        if (money < price) {
            try {
                throw new CustomException("餘額不⾜！");
            } catch (CustomException e) {
                e.printStackTrace();
            }
        }
        System.out.println("繼續執行程式~~~");
        return money;
    }
}

自定義異常的步驟：

  1. 繼承於現的異常結構：RuntimeException 、Exception

  2. 提供全域性常量：serialVersionUID

  3. 編寫構造方法，可以傳入自己想列印的異常資訊

  4. 呼叫的時候通過throw向外丟擲異常

如果繼承的是執行時異常，那麼在使用的時候無需額外處理；如果繼承的是檢查異常，那麼使用的時候需要try-catch捕獲或者throws向上拋

throw和throws的區別：

  1. 位置不同：throw：方法內部，throws: 方法的宣告處
  2. 內容不同：throw+異常物件（檢查異常，執行時異常）；throws+異常的型別（可以多個型別，用，拼接）
  3. 作用不同：throw：異常出現的源頭，製造異常。throws:在方法的宣告處，告訴方法的呼叫者，這個方法中可能會出現我宣告的這些異常。然後呼叫者對這個異常進行處理，要麼自己處理要麼再繼續向外丟擲異常

jdk7新寫法

  1. 在JDK1.7以後，異常新處理方式：可以並列用|符號連線

  1. try-with-resources語句

Java裡，對於檔案操作IO流、資料庫連線等開銷非常昂貴的資源，用完之後必須及時通過close方法將其關閉，否則資源會一直處於開啟狀態，可能會導致記憶體洩露等問題。

關閉資源的常用方式就是在finally塊裡是釋放，即呼叫close方法。比如，我們經常會寫這樣的程式碼：

public static void test() {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        File f = new File("F:\\demo.txt");
        FileWriter fw = null;
        BufferedWriter bw = null;
        try {
            fw=new FileWriter(f);
            bw = new BufferedWriter(fw);
            String s = br.readLine();
            while (!s.equals("exit")) {
                bw.write(s);
                bw.newLine();//檔案中換行
                s = br.readLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        //4.關閉流：
        try {
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

從Java 7開始，jdk提供了一種更好的方式關閉資源，使用try-with-resources語句，改寫一下上面的程式碼，效果如下：

 public static void test2(){
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        try(FileWriter fw=new FileWriter(new File("F:\\demo.txt"));
            BufferedWriter bw=new BufferedWriter(fw)){
            String s = br.readLine();
            while (!s.equals("exit")) {
                bw.write(s);
                bw.newLine();
                s = br.readLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

是不是感覺簡潔了好多，其實這就是一個語法糖，它將在編譯時編譯成關閉資源的程式碼。我們將上述例子中的程式碼編譯成class檔案，再反編譯回java檔案，就能看到如下程式碼：

 public static void test2() {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        File f = new File("F:\\demo.txt");

        try {
            FileWriter fw = new FileWriter(f);
            Throwable var4 = null;

            try {
                BufferedWriter bw = new BufferedWriter(fw);
                Throwable var6 = null;

                try {
                    for(String s = br.readLine(); !s.equals("exit"); s = br.readLine()) {
                        bw.write(s);
                        bw.newLine();
                    }
                } catch (Throwable var31) {
                    var6 = var31;
                    throw var31;
                } finally {
                    if (bw != null) {
                        if (var6 != null) {
                            try {
                                bw.close();
                            } catch (Throwable var30) {
                                var6.addSuppressed(var30);
                            }
                        } else {
                            bw.close();
                        }
                    }

                }
            } catch (Throwable var33) {
                var4 = var33;
                throw var33;
            } finally {
                if (fw != null) {
                    if (var4 != null) {
                        try {
                            fw.close();
                        } catch (Throwable var29) {
                            var4.addSuppressed(var29);
                        }
                    } else {
                        fw.close();
                    }
                }
            }
        } catch (IOException var35) {
            var35.printStackTrace();
        }
    }

除了異常程式碼，我們看到其實關閉流的處理是底層幫我們處理的

相關推薦

[Java Spring] Implementing Spring Security

pom.xml: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId>

（65）java Spring Cloud+Spring boot+mybatis企業快速開發架構之使用Spring Security給Spring Boot Admin開啟認證

監控類的資料 Web 管理端最好不要設定成直接通過輸入訪問地址就可以訪問，必須得進行使用者認證才行，以保證資料的安全性。Spring Boot Admin 開啟認證也可以藉助於 spring-boot-starter-security。獲取原始碼

使用Java 8，Spring Boot和Angular建立簡單的Web應用程式

入門條件 · Java 8已安裝。 · 任何Java IDE（最好是STS或IntelliJ IDEA）。 · 使用HTML，CSS和JavaScript，基本瞭解基於Java和Spring的Web開發和UI開發。

使用Java註解模擬spring ioc容器過程解析

使用註解,簡單模擬spring ioc容器。通過註解給物件屬性注入值。 專案結構 annotation 包,用於存放自定義註解

Java控制反轉 - spring webmvc

概述 本文基於示例的方式解釋控制反轉，再看控制反轉之前，我們先看下常規控制流程，以資料庫訪問為例

禁用 Spring Boot 中引入安全元件 spring-boot-starter-security 的方法

1、當我們通過 maven 或 gradle 引入了 Spring boot 的安全元件 spring-boot-starter-security，Spring boot 預設開啟安全元件，這樣我們就需要先登入了，但是在開發過程中，我們並不想經常的登入（每重啟一次服務必

spring boot:spring security用mysql資料庫實現RBAC許可權管理(spring boot 2.3.1)

一，用資料庫實現許可權管理要注意哪些環節? 1，需要生成spring security中user類的派生類，用來儲存使用者id和暱稱等資訊，

spring boot:spring security給使用者登入增加自動登入及圖形驗證碼功能(spring boot 2.3.1)

一，圖形驗證碼的用途? 1，什麼是圖形驗證碼？ 驗證碼（CAPTCHA）是“Completely Automated Public Turing test to tell Computers and Humans Apart”（全自動區分計算機和人類的圖靈測試）的縮寫，它是用

Java學習之Spring MVC入門

Java學習之Spring MVC入門 0x00 前言 前面寫了SSM 的兩大框架，分別是Mybatis和Spring，這裡來寫一下Spring MVC框架的相關內容。

java 註解結合 spring aop 實現自動輸出日誌

auto-log auto-log 是一款為 java 設計的自動日誌監控框架。 創作目的 經常會寫一些工具，有時候手動加一些日誌很麻煩，引入 spring 又過於大材小用。

使用Java方法配置Spring程式碼解析

使用Java的方式配置Spring 我們現在要完全不使用Spring的xml配置，全權使用Java來配置Spring！

Java學習之spring MVC常用註解

Java學習之spring MVC常用註解 0x00 前言 續上篇文章的內容繼續來記錄spring mvc會常用到的一些註解。

Java學習之Spring Boot入門

Java學習之Spring Boot入門 0x00 前言 學習完ssm的整合後，開始來學習Spring Boot，在前面學習Spring的時候會發現使用Spring開發中配置Spring的環境會非常的繁瑣，而Spring boot的出現就解決了這個問題。

spring boot:spring security實現oauth2+jwt管理認證授權及oauth2返回結果格式化(spring boot 2.3.3)

一，為什麼oauth2要整合jwt? 1,OAuth2的token技術有一個最大的問題是不攜帶使用者資訊，所以資源伺服器不能進行本地驗證，

spring boot:spring security+oauth2+sso+jwt實現單點登入(spring boot 2.3.3)

一,sso的用途 ？ 1，如果有多個應用系統，使用者只需要登入一次就可以訪問所有相互信任的應用系統。不需要每次輸入使用者名稱稱和使用者密碼，也不需要建立並記憶多套使用者名稱稱和使用者密碼。

JAVA知識點梳理-Spring

九、Spring 篇 \\99. Spring 中 ApplicationContext 和 BeanFactory 的區別 BeanFactory： 是Spring裡面最低層的介面，提供了最簡單的容器的功能，只提供了例項化物件和拿物件的功能；

金九銀十大廠面試錦集180道（Java基礎+框架+spring全家桶+分散式+微服務+資料庫）

前言 很多小夥伴在面試前可能會很焦慮，不知道自己的技術行不行，能不能通過大廠的面試，也不知道要刷什麼面試題，這裡小編整理了很多常考面試題，因為篇幅有限，這裡只總結一些最常見的面試題，答案放在文

Java 如何從spring容器中獲取注入的bean物件

1.使用場景 　　控制層呼叫業務層時，控制層需要拿到業務層在spring容器中注入的物件

JAVA實戰篇 Spring中的事務管理的簡單應用

技術標籤：Spring-aop動態代理Spring進階資料庫javaspringmybatis動態代理 Spring中的事務管理

spring boot + spring Security + redis + token 爬坡

spring boot + spring Security + redis + token 爬坡 分為幾個部分 spring boot 基本配置 controller介面部分  安全校驗部分(包括session或者自定義token的形式) redis的token存放於取出  , 在資料庫取使用者資