Java的基本使用之异常处理

Java的基本使用之异常处理
1、Java中异常的基本概念

异常是一种类，因此它本身带有类型信息。异常可以在任何地方抛出，但只需要在上层捕获。

在 Java 中抛出异常的目的是为了在代码执行发生错误的时候，停止，或者进行处理，以及抛出信息帮助程序员定位出现bug的位置。所以，我们需要在可能发生异常的地方抛出异常并进行捕获处理。

Java 中异常的继承关系如下：

由上图可知，Throwable是异常体系的根，它继承自Object。

所有异常都可以调用 e.printStackTrace() 方法进行简单打印输出。

1.1、Error 和 Exception

Throwable有两个体系：Error和Exception。

1.1.1、Error

Error表示严重的错误，程序对此一般无能为力，例如：
- OutOfMemoryError：内存耗尽
- NoClassDefFoundError：无法加载某个Class
- StackOverflowError：栈溢出
1.1.2、Exception

而Exception则是运行时的错误，它可以被捕获并处理。

Exception分为两大类：
1. RuntimeException以及它的子类；
2. 非RuntimeException（包括IOException、ReflectiveOperationException等等）
1.3、哪些异常需要被捕获

有些异常是应用程序逻辑处理的一部分，应该捕获并处理。例如：
- NumberFormatException：数值类型的格式错误
- FileNotFoundException：未找到文件
- SocketException：读取网络失败
还有一些异常是程序逻辑编写不对造成的，应该修复程序本身。例如：
- NullPointerException：对某个null的对象调用方法或字段。空指针异常，如果一个对象为null，调用其方法或访问其字段就会产生NullPointerException。指针这个概念实际上源自C语言，Java语言中并无指针。我们定义的变量实际上是引用，Null Pointer更确切地说是Null Reference，
- IndexOutOfBoundsException：数组索引越界
Java规定：
- 必须捕获的异常：包括Exception及其子类，但不包括RuntimeException及其子类，这种类型的异常称为Checked Exception。
- 不需要捕获的异常：包括Error及其子类，RuntimeException及其子类。
2、捕获异常（try{...} catch(){...}）

在Java中，凡是可能抛出异常的语句，都可以用try ... catch进行捕获。通过捕获异常就可以针对异常情况做操作，并且避免后面的程序被中断。

只要是在方法抛出的 Checked Exception，如果不在该方法的调用层捕获，那就应该抛出来，然后在更高的调用层捕获。所有未捕获的异常，最终也必须在main()方法中捕获或者在 main 方法中抛出然后由 JVM 进行处理，否则会编译报错。main()方法是最后捕获异常的机会，不推荐在 main 方法中抛出异常。

在捕获了异常后我们应该进行相应的操作，至少应该打印记录异常。
```
public static void main(String[] args) {
    try {
        ...
    } catch (Exception e) {
        e.printStackTrace();
    }
}
```
我们可以使用多个 catch 语句，每个catch分别捕获对应的Exception及其子类。JVM在捕获到异常后，会从上到下匹配catch语句，匹配到某个catch后，执行catch代码块，然后不再继续匹配。简单地说就是多个catch语句只有一个能被执行。

存在多个catch的时候，子类必须写在前面，否则永远捕获不到该子类异常。
```
public static void main(String[] args) {
    try {
        process1();
    } catch (UnsupportedEncodingException e) {         //子类应该写在前面，否则永远捕获不到
        System.out.println("Bad encoding");
    } catch (IOException | NumberFormatException e) {  //处理不同异常的代码一样时，我们可以用 | 把它们写在一起
        System.out.println("Bad input");
    } 
}
```
2.1、finally 语句

Java 的try ... catch机制还提供了finally语句，finally语句块保证有无错误都会执行。
```
public static void main(String[] args) {
    try {
        ...
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        System.out.println("END");
    }
}
```
finally 语句不是必须的，可写可不写，并且它总是最后执行的，finally 语句是用来保证一些代码必须执行的。

你也可以只使用try ... finally，而不写catch语句，例如：
```
//下面方法声明了可能抛出的异常，所以可以不写catch。
void process(String file) throws IOException {
    try {
        ...
    } finally {
        System.out.println("END");
    }
}
```
在catch语句块中抛出异常，finally语句仍然会执行：
```
public class Main {
    public static void main(String[] args) {
        try {
            Integer.parseInt("abc");
        } catch (Exception e) {
            System.out.println("catched");
            throw new RuntimeException(e);
        } finally {
            System.out.println("finally");
        }
    }
}

//上述代码执行结果如下：
catched
finally
Exception in thread "main" java.lang.RuntimeException: java.lang.NumberFormatException: For input string: "abc"
    at Main.main(Main.java:8)
Caused by: java.lang.NumberFormatException: For input string: "abc"
    at ...
```
先打印了catched，后打印finally，然后再输出异常信息。说明先执行了catch语句，然后又执行了finally语句块，最后才抛出了异常并且在 JVM 中捕获。因此，在catch中抛出异常，不会影响finally的执行。JVM会先执行finally，然后才抛出异常。

3、抛出异常

当某个方法抛出了异常时，如果在调用该方法时没有捕获异常，那就应该抛出来，由更上层来进行捕获，以此类推，直到遇到某个try ... catch被捕获为止。所有未捕获的异常，最终也必须在main()方法中捕获或者在 main 方法中抛出然后由 JVM 进行处理，否则会编译报错。

3.1、如何抛出异常

抛出异常分两步：
1. 创建某个Exception的实例；
2. 用throw语句抛出。
代码示例：
```
public void process2(String s) {
    if (s==null) {
        NullPointerException e = new NullPointerException("异常信息");
        throw e;
        //一般写成一行即可
        throw new NullPointerException("异常信息");
    }
}
```
子类重写父类的方法时，子类方法不能抛出比父类方法更大的异常。

3.2、异常转换

如果一个方法使用 catch 捕获了某个异常后，又在 catch 语句中抛出新的异常，此时就相当于把抛出的异常类型“转换”了，此时如果在其他方法中捕获新异常，旧异常的信息不会被捕获到。
```
public class Main {
    public static void main(String[] args) {
        try {
            process1();
        } catch (Exception e) {  //此时输出process1方法的异常，并不会输出process2方法中的异常信息
            e.printStackTrace();
        }
    }

    static void process1() {
        try {
            process2();
        } catch (NullPointerException e) {  //捕获process2方法的异常并转换
            throw new IllegalArgumentException();
        }
    }

    static void process2() {
        throw new NullPointerException();
    }
}
```
这样新的异常就会丢失原始异常信息，我们无法看不到原始异常NullPointerException的信息。

为了能追踪到完整的异常栈，在构造异常的时候，把原始的Exception实例传进去，新的Exception就可以持有原始Exception信息。对上述代码改进如下：
```
public class Main {
    public static void main(String[] args) {
        try {
            process1();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static void process1() {
        try {
            process2();
        } catch (NullPointerException e) {
            throw new IllegalArgumentException(e);  //这里将原始的异常传了进去
        }
    }

    static void process2() {
        throw new NullPointerException();
    }
}

//运行上述代码，打印出的异常栈类似以下信息：
//Caused by: Xxx，说明捕获的IllegalArgumentException并不是造成问题的根源，根源在于NullPointerException，是在Main.process2()方法抛出的。
java.lang.IllegalArgumentException: java.lang.NullPointerException
    at Main.process1(Main.java:15)
    at Main.main(Main.java:5)
Caused by: java.lang.NullPointerException
    at Main.process2(Main.java:20)
    at Main.process1(Main.java:13)
```
在代码中获取原始异常可以使用Throwable.getCause()方法。如果返回null，说明已经是“根异常”了。

捕获到异常并再次抛出时，一定要留住原始异常，否则很难定位第一案发现场！有了完整的异常栈的信息，我们才能快速定位并修复代码的问题。

4、打印异常信息（e.printStackTrace()）

所有异常都可以通过printStackTrace()打印出方法的调用栈，打印信息类似下面：
```
java.lang.NumberFormatException: null
    at java.base/java.lang.Integer.parseInt(Integer.java:614)
    at java.base/java.lang.Integer.parseInt(Integer.java:770)
    at Main.process2(Main.java:16)
    at Main.process1(Main.java:12)
    at Main.main(Main.java:5)
```
上述信息表示：NumberFormatException是在java.lang.Integer.parseInt方法中被抛出的，从下往上看，调用层次依次是：
1. main()调用process1()；
2. process1()调用process2()；
3. process2()调用Integer.parseInt(String)；
4. Integer.parseInt(String)调用Integer.parseInt(String, int)。
每层调用都给出了源代码的行号，可直接定位。

5、使用日志（JDK Logging）

日志就是Logging，它的目的是为了取代System.out.println()。

5.1、使用日志的好处
1. 可以设置输出样式，避免自己每次都写"ERROR: " + var
2. 可以设置输出级别，禁止某些级别输出。例如，只输出错误日志
3. 可以被重定向到文件，存档，这样可以在程序运行结束后查看日志，便于追踪问题
4. 可以根据配置文件调整日志，无需修改代码
5. 可以按包名控制日志级别，只输出某些包打的日志等等。。。
5.2、如何使用日志

Java 标准库内置了日志包java.util.logging，我们可以直接用。
```
import java.util.logging.Level;
import java.util.logging.Logger;

public class Hello {
    public static void main(String[] args) {
        Logger logger = Logger.getGlobal();
        logger.info("start process...");
        logger.warning("memory is running out...");
        logger.fine("ignored.");
        logger.severe("process will be terminated...");
    }
}

//打印以下信息：
Mar 02, 2019 6:32:13 PM.Hello main  //自动打印出时间、调用类、调用方法等很多有用的信息。
INFO: start process...
Mar 02, 2019 6:32:13 PM.Hello main
WARNING: memory is running out...
Mar 02, 2019 6:32:13 PM.Hello main
SEVERE: process will be terminated...
```
上面的输出当中，logger.fine()没有打印。这是因为，日志的输出可以设定级别。JDK 的 Logging 定义了7个日志级别，从严重到普通。默认级别是 INFO，INFO 级别以下的日志，不会被打印出来。使用日志级别的好处在于，调整级别，就可以屏蔽掉很多调试相关的日志输出。

日志级别如下：
- SEVERE
- WARNING
- INFO
- CONFIG
- FINE
- FINER
- FINEST
Java标准库内置的Logging有以下局限：Logging系统在JVM启动时读取配置文件并完成初始化，一旦开始运行main()方法，就无法修改配置；配置不太方便，需要在JVM启动时传递参数-Djava.util.logging.config.file=<config-file-name>。因此，Java标准库内置的Logging使用并不是非常广泛。

6、使用 Commons Logging

和Java标准库提供的日志不同，Commons Logging是一个第三方日志库，它可以挂接不同的日志系统，并通过配置文件指定挂接的日志系统。默认情况下，Commons Loggin自动搜索并使用Log4j，如果没有找到Log4j，再使用JDK Logging。

Commons Logging是一个第三方提供的库，要想使用必须先把它下载下来，链接：https://commons.apache.org/proper/commons-logging/download_logging.cgi

下载后，解压，找到commons-logging-1.2.jar这个文件，将 jar 文件放在项目根目录下，并且在 Libraries 中引入该 jar 文件，然后即可使用
```
//先通过LogFactory获取Log类的实例，然后使用Log实例的方法打日志
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class Main {
    public static void main(String[] args) {
        Log log = LogFactory.getLog(Main.class);
        log.info("start...");
        log.warn("end.");
    }
}
```
Commons Logging定义了6个日志级别，默认级别是INFO，即INFO级别以下的都不会打印出来
- FATAL
- ERROR
- WARNING
- INFO
- DEBUG
- TRACE
7、使用 Log4j

Log4j是一种非常流行的日志框架，Commons Logging可以作为“日志接口”来使用，而真正的“日志实现”可以使用Log4j。

当我们使用 Log4j 输出一条日志时，Log4j 自动通过不同的 Appender 把同一条日志输出到不同的目的地

使用Log4j的时候我们可以通过配置文件来让 Log4j 读取配置文件并按照我们的配置来输出日志，例如：
```
<?xml version="1.0" encoding="UTF-8"?>
<Configuration>
    <Properties>
        
        <Property name="log.pattern">%d{MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36}%n%msg%n%n</Property>
        
        <Property name="file.err.filename">log/err.log</Property>
        <Property name="file.err.pattern">log/err.%i.log.gz</Property>
    </Properties>

    
    <Appenders>
        
        <Console name="console" target="SYSTEM_OUT">
            
            <PatternLayout pattern="${log.pattern}" />
        </Console>
        
        <RollingFile name="err" bufferedIO="true" fileName="${file.err.filename}" filePattern="${file.err.pattern}">
            <PatternLayout pattern="${log.pattern}" />
            <Policies>
                
                <SizeBasedTriggeringPolicy size="1 MB" />
            </Policies>
            
            <DefaultRolloverStrategy max="10" />
        </RollingFile>
    </Appenders>

    <Loggers>
        <Root level="info">
            
            <AppenderRef ref="console" level="info" />
            
            <AppenderRef ref="err" level="error" />
        </Root>
    </Loggers>
</Configuration>
```
有了配置文件还不够，因为Log4j也是一个第三方库，我们需要从这里（https://www.liaoxuefeng.com/wiki/1252599548343744/1264739436350112）下载Log4j，解压后，把以下3个jar包添加至项目依赖中
- log4j-api-2.x.jar
- log4j-core-2.x.jar
- log4j-jcl-2.x.jar
把Commons Logging 添加至项目依赖中，Commons Logging会自动发现并使用Log4j。要打印日志，只需要按Commons Logging的写法写即可，不需要改动任何代码，就可以得到Log4j的日志输出。

在开发阶段，始终使用Commons Logging接口来写入日志，并且开发阶段无需引入Log4j。如果需要把日志写入文件，只需要把正确的配置文件和Log4j相关的jar包放入classpath，就可以自动把日志切换成使用Log4j写入，不需要修改任何代码。

参考：https://www.liaoxuefeng.com/wiki/1252599548343744/1264739436350112
相关阅读:
[codevs 1243][网络提速（最短路分层思想）
[codevs 1183][泥泞的道路（二分+spfa）
[codevs 2488]绿豆蛙的归宿（拓扑排序）
[codevs 1961]躲避大龙（dfs)
4、userCF和itemCF对比，冷启动
 query简洁弹出层代码
 css 积累1
localStorage,sessionStorage
tr th td
（转存）面向切面编程（AOP）的理解
原文地址：https://www.cnblogs.com/wenxuehai/p/12838076.html

Java的基本使用之异常处理

1、Java中异常的基本概念

1.1、Error 和 Exception

1.1.1、Error

1.1.2、Exception

1.3、哪些异常需要被捕获

2、捕获异常（try{...} catch(){...}）

2.1、finally 语句

3、抛出异常

3.1、如何抛出异常

3.2、异常转换

4、打印异常信息（e.printStackTrace()）

5、使用日志（JDK Logging）

5.1、使用日志的好处

5.2、如何使用日志

6、使用 Commons Logging

7、使用 Log4j