前言
Java例外處理的十個建議，希望對大家有幫助~
一、盡量不要使用e.printStackTrace(),而是使用log列印，
反例:
try{
// do what you want
}catch(Exception e){
e.printStackTrace();
}
正例：
try{
// do what you want
}catch(Exception e){
log.info("你的程式有例外啦,{}",e);
}
理由：
- printStackTrace()列印出的堆疊日志跟業務代碼日志是交錯混合在一起的，通常排查例外日志不太方便，
- e.printStackTrace()陳述句產生的字串記錄的是堆疊資訊，如果資訊太長太多，字串常量池所在的記憶體塊沒有空間了,即記憶體滿了，那么，用戶的請求就卡住啦~
二、catch了例外，但是沒有列印出具體的exception，無法更好定位問題
反例：
try{
// do what you want
}catch(Exception e){
log.info("你的程式有例外啦");
}
正例：
try{
// do what you want
}catch(Exception e){
log.info("你的程式有例外啦，{}",e);
}
理由：
- 反例中，并沒有把exception出來，到時候排查問題就不好查了啦，到底是SQl寫錯的例外還是IO例外，還是其他呢？所以應該把exception列印到日志中哦~
三、不要用一個Exception捕捉所有可能的例外
反例：
public void test(){
try{
//…拋出 IOException 的代碼呼叫
//…拋出 SQLException 的代碼呼叫
}catch(Exception e){
//用基類 Exception 捕捉的所有可能的例外，如果多個層次都這樣捕捉，會丟失原始例外的有效資訊哦
log.info(“Exception in test,exception:{}”, e);
}
}
正例：
public void test(){
try{
//…拋出 IOException 的代碼呼叫
//…拋出 SQLException 的代碼呼叫
}catch(IOException e){
//僅僅捕捉 IOException
log.info(“IOException in test,exception:{}”, e);
}catch(SQLException e){
//僅僅捕捉 SQLException
log.info(“SQLException in test,exception:{}”, e);
}
}
理由：
- 用基類 Exception 捕捉的所有可能的例外，如果多個層次都這樣捕捉，會丟失原始例外的有效資訊哦
四、記得使用finally關閉流資源或者直接使用try-with-resource
反例：
FileInputStream fdIn = null;
try {
fdIn = new FileInputStream(new File("/jay.txt"));
//在這里關閉流資源？有沒有問題呢？如果發生例外了呢？
fdIn.close();
} catch (FileNotFoundException e) {
log.error(e);
} catch (IOException e) {
log.error(e);
}
正例1：
需要使用finally關閉流資源，如下
FileInputStream fdIn = null;
try {
fdIn = new FileInputStream(new File("/jay.txt"));
} catch (FileNotFoundException e) {
log.error(e);
} catch (IOException e) {
log.error(e);
}finally {
try {
if (fdIn != null) {
fdIn.close();
}
} catch (IOException e) {
log.error(e);
}
}
正例2：
當然，也可以使用JDK7的新特性try-with-resource來處理，它是Java7提供的一個新功能，它用于自動資源管理，
- 資源是指在程式用完了之后必須要關閉的物件，
- try-with-resources保證了每個宣告了的資源在陳述句結束的時候會被關閉
- 什么樣的物件才能當做資源使用呢？只要實作了java.lang.AutoCloseable介面或者java.io.Closeable介面的物件，都OK，
try (FileInputStream inputStream = new FileInputStream(new File("jay.txt")) {
// use resources
} catch (FileNotFoundException e) {
log.error(e);
} catch (IOException e) {
log.error(e);
}
理由：
- 如果不使用finally或者try-with-resource，當程式發生例外，IO資源流沒關閉，那么這個IO資源就會被他一直占著，這樣別人就沒有辦法用了，這就造成資源浪費，
五、捕獲例外與拋出例外必須是完全匹配，或者捕獲例外是拋例外的父類
反例：
//BizException 是 Exception 的子類
public class BizException extends Exception {}
//拋出父類Exception
public static void test() throws Exception {}
try {
test(); //編譯錯誤
} catch (BizException e) { //捕獲例外子類是沒法匹配的哦
log.error(e);
}
正例：
//拋出子類Exception
public static void test() throws BizException {}
try {
test();
} catch (Exception e) {
log.error(e);
}
六、捕獲到的例外，不能忽略它，至少打點日志吧
反例：
public static void testIgnoreException() throws Exception {
try {
// 搞事情
} catch (Exception e) { //一般不會有這個例外
}
}
正例：
public static void testIgnoreException() {
try {
// 搞事情
} catch (Exception e) { //一般不會有這個例外
log.error("這個例外不應該在這里出現的,{}",e);
}
}
理由：
- 雖然一個正常情況都不會發生的例外，但是如果你捕獲到它，就不要忽略呀，至少打個日志吧~
七、注意例外對你的代碼層次結構的侵染（早發現早處理）
反例：
public UserInfo queryUserInfoByUserId(Long userid) throw SQLException {
//根據用戶Id查詢資料庫
}
正例：
public UserInfo queryUserInfoByUserId(Long userid) {
try{
//根據用戶Id查詢資料庫
}catch(SQLException e){
log.error("查詢資料庫例外啦，{}",e);
}finally{
//關閉連接，清理資源
}
}
理由：
- 我們的專案，一般都會把代碼分 Action、Service、Dao 等不同的層次結構，如果你是DAO層處理的例外，盡早處理吧，如果往上 throw SQLException，上層代碼就還是要try catch處理啦，這就污染了你的代碼~
八、自定義封裝例外，不要丟棄原始例外的資訊Throwable cause
我們常常會想要在捕獲一個例外后拋出另一個例外，并且希望把原始例外的資訊保存下來，這被稱為例外鏈，公司的框架提供統一例外處理就用到例外鏈，我們自定義封裝例外，不要丟棄原始例外的資訊，否則排查問題就頭疼啦
反例：
public class TestChainException {
public void readFile() throws MyException{
try {
InputStream is = new FileInputStream("jay.txt");
Scanner in = new Scanner(is);
while (in.hasNext()) {
System.out.println(in.next());
}
} catch (FileNotFoundException e) {
//e 保存例外資訊
throw new MyException("檔案在哪里呢");
}
}
public void invokeReadFile() throws MyException{
try {
readFile();
} catch (MyException e) {
//e 保存例外資訊
throw new MyException("檔案找不到");
}
}
public static void main(String[] args) {
TestChainException t = new TestChainException();
try {
t.invokeReadFile();
} catch (MyException e) {
e.printStackTrace();
}
}
}
//MyException 構造器
public MyException(String message) {
super(message);
}
運行結果如下，沒有了Throwable cause，不好排查是什么例外了啦
正例：
public class TestChainException {
public void readFile() throws MyException{
try {
InputStream is = new FileInputStream("jay.txt");
Scanner in = new Scanner(is);
while (in.hasNext()) {
System.out.println(in.next());
}
} catch (FileNotFoundException e) {
//e 保存例外資訊
throw new MyException("檔案在哪里呢", e);
}
}
public void invokeReadFile() throws MyException{
try {
readFile();
} catch (MyException e) {
//e 保存例外資訊
throw new MyException("檔案找不到", e);
}
}
public static void main(String[] args) {
TestChainException t = new TestChainException();
try {
t.invokeReadFile();
} catch (MyException e) {
e.printStackTrace();
}
}
}
//MyException 構造器
public MyException(String message, Throwable cause) {
super(message, cause);
}
九、運行時例外RuntimeException ，不應該通過catch 的方式來處理，而是先預檢查，比如：NullPointerException處理
反例：
try {
obj.method()
} catch (NullPointerException e) {
...
}
正例：
if (obj != null){
...
}
十、注意例外匹配的順序，優先捕獲具體的例外
注意例外的匹配順序，因為只有第一個匹配到例外的catch塊才會被執行，如果你希望看到，是NumberFormatException例外，就拋出NumberFormatException，如果是IllegalArgumentException就拋出IllegalArgumentException，
反例：
try {
doSomething("test exception");
} catch (IllegalArgumentException e) {
log.error(e);
} catch (NumberFormatException e) {
log.error(e);
}
正例：
try {
doSomething("test exception");
} catch (NumberFormatException e) {
log.error(e);
} catch (IllegalArgumentException e) {
log.error(e);
}
理由：
- 因為NumberFormatException是IllegalArgumentException 的子類，反例中，不管是哪個例外，都會匹配到IllegalArgumentException，就不會再往下執行啦，因此不知道是否是NumberFormatException，所以需要優先捕獲具體的例外，把NumberFormatException放前面~
參考資料
https://juejin.im/post/5ee45107f265da770952788f
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/264144.html
標籤：java