1. 引子
try…catch…finally恐怕是大家再熟悉不过的语句了，而且感觉用起来也是很简单，逻辑上似乎也是很容易理解。不过，我亲自体验的“教训”告诉我，这个东西可不是想象中的那么简单、听话。不信？那你看看下面的代码，“猜猜”它执行后的结果会是什么？不要往后看答案、也不许执行代码看真正答案哦。如果你的答案是正确，那么这篇文章你就不用浪费时间看啦。
package Test;
public class TestException {
public TestException() {
}
boolean testEx() throws Exception {
boolean ret = true;
try {
ret = testEx1();
} catch (Exception e) {
System.out.println("testEx, catch exception");
ret = false;
throw e;
} finally {
System.out.println("testEx, finally; return value=" + ret);
return ret;
}
}
boolean testEx1() throws Exception {
boolean ret = true;
try {
ret = testEx2();
if (!ret) {
return false;
}
System.out.println("testEx1, at the end of try");
return ret;
} catch (Exception e) {
System.out.println("testEx1, catch exception");
ret = false;
throw e;
} finally {
System.out.println("testEx1, finally; return value=" + ret);
return ret;
}
}
boolean testEx2() throws Exception {
boolean ret = true;
try {
int b = 12;
int c;
for (int i = 2; i >= -2; i--) {
c = b / i;
System.out.println("i=" + i);
}
return true;
} catch (Exception e) {
System.out.println("testEx2, catch exception");
ret = false;
throw e;
} finally {
System.out.println("testEx2, finally; return value=" + ret);
return ret;
}
}
public static void main(String[] args) {
TestException testException1 = new TestException();
try {
testException1.testEx();
} catch (Exception e) {
e.printStackTrace();
}
}
}
你的答案是什么？是下面的答案吗？
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, catch exception
testEx1, finally; return value=false
testEx, catch exception
testEx, finally; return value=false
如果你的答案真的如上面所说，那么你错啦。^_^，那就建议你仔细看一看这篇文章或者拿上面的代码按各种不同的情况修改、执行、测试，你会发现有很多事情不是原来想象中的那么简单的。现在公布正确答案：
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, finally; return value=false
testEx, finally; return value=false
2.JAVA异常
异常指不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程。Java通 过API中Throwable类的众多子类描述各种不同的异常。因而，Java异常都是对象，是Throwable子类的实例，描述了出现在一段编码中的 错误条件。当条件生成时，错误将引发异常。
Java异常类层次结构图：
图1 Java异常类层次结构图
在 Java 中，所有的异常都有一个共同的祖先 Throwable(可抛出)。Throwable 指定代码中可用异常传播机制通过 Java 应用程序传输的任何问题的共性。
Throwable： 有两个重要的子类：Exception(异常)和 Error(错误)，二者都是 Java 异常处理的重要子类，各自都包含大量子类。
Error(错误):是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM(Java 虚拟机)出现的问题。例如，Java虚拟机运行错误(Virtual MachineError)，当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机(JVM)一般会选择线程终止。
。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误(Virtual MachineError)、类定义错误(NoClassDefFoundError)等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。
Exception(异常):是程序本身可以处理的异常。
Exception 类有一个重要的子类 RuntimeException。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如，若试图使用空值对象引用、除数为零或数组越界，则分别引发运行时异常(NullPointerException、ArithmeticException)和 ArrayIndexOutOfBoundException。
注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。
通常，Java的异常(包括Exception和Error)分为可查的异常(checked exceptions)和不可查的异常(unchecked exceptions)。
可查异常(编译器要求必须处置的异常)：正确的程序在运行中，很容易出现的、情理可容的异常状况。可查异常虽然是异常状况，但在一定程度上它的发生是可以预计的，而且一旦发生这种异常状况，就必须采取某种方式进行处理。
除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。
不可查异常(编译器不要求强制处置的异常):包括运行时异常(RuntimeException与其子类)和错误(Error)。
Exception 这种异常分两大类运行时异常和非运行时异常(编译异常)。程序中应当尽可能去处理这些异常。
运行时异常：都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。
非运行时异常 (编译异常)：是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。
4.处理异常机制
在 Java 应用程序中，异常处理机制为：抛出异常，捕捉异常。
抛出异常：当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。
捕获异常：在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器(exception handler)。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适 的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适 的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。
对于运行时异常、错误或可查异常，Java技术所要求的异常处理方式有所不同。
由于运行时异常的不可查性，为了更合理、更容易地实现应用程序，Java规定，运行时异常将由Java运行时系统自动抛出，允许应用程序忽略运行时异常。
对于方法运行中可能出现的Error，当运行方法不欲捕捉时，Java允许该方法不做任何抛出声明。因为，大多数Error异常属于永远不能被允许发生的状况，也属于合理的应用程序不该捕捉的异常。
对于所有的可查异常，Java规定：一个方法必须捕捉，或者声明抛出方法之外。也就是说，当一个方法选择不捕捉可查异常时，它必须声明将抛出异常。
能够捕捉异常的方法，需要提供相符类型的异常处理器。所捕捉的异常，可能是由于自身语句所引发并抛出的异常，也可能是由某个调用的方法或者Java运行时 系统等抛出的异常。也就是说，一个方法所能捕捉的异常，一定是Java代码在某处所抛出的异常。简单地说，异常总是先被抛出，后被捕捉的。
任何Java代码都可以抛出异常，如：自己编写的代码、来自Java开发环境包中代码，或者Java运行时系统。无论是谁，都可以通过Java的throw语句抛出异常。
从方法中抛出的任何异常都必须使用throws子句。
捕捉异常通过try-catch语句或者try-catch-finally语句实现。
总体来说，Java规定：对于可查异常必须捕捉、或者声明抛出。允许忽略不可查的RuntimeException和Error。
4.1 捕获异常：try、catch 和 finally
1.try-catch语句
在Java中，异常通过try-catch语句捕获。其一般语法形式为：
try {
// 可能会发生异常的程序代码
} catch (Type1 id1){
// 捕获并处置try抛出的异常类型Type1
}
catch (Type2 id2){
//捕获并处置try抛出的异常类型Type2
}
关键词try后的一对大括号将一块可能发生异常的代码包起来，称为监控区域。Java方法在运行过程中出现异常，则创建异常对象。将异常抛出监控区域之 外，由Java运行时系统试图寻找匹配的catch子句以捕获异常。若有匹配的catch子句，则运行其异常处理代码，try-catch语句结束。
匹配的原则是：如果抛出的异常对象属于catch子句的异常类，或者属于该异常类的子类，则认为生成的异常对象与catch块捕获的异常类型相匹配。
例1  捕捉throw语句抛出的“除数为0”异常。
public class TestException {
public static void main(String[] args) {
int a = 6;
int b = 0;
try { // try监控区域
if (b == 0) throw new ArithmeticException(); // 通过throw语句抛出异常
System.out.println("a/b的值是：" + a / b);
}
catch (ArithmeticException e) { // catch捕捉异常
System.out.println("程序出现异常，变量b不能为0。");
}
System.out.println("程序正常结束。");
}
}
运行结果：程序出现异常，变量b不能为0。
程序正常结束。
例1  在try监控区域通过if语句进行判断，当“除数为0”的错误条件成立时引发ArithmeticException异常，创建 ArithmeticException异常对象，并由throw语句将异常抛给Java运行时系统，由系统寻找匹配的异常处理器catch并运行相应异 常处理代码，打印输出“程序出现异常，变量b不能为0。”try-catch语句结束，继续程序流程。
事实上，“除数为0”等ArithmeticException，是RuntimException的子类。而运行时异常将由运行时系统自动抛出，不需要使用throw语句。
例2  捕捉运行时系统自动抛出“除数为0”引发的ArithmeticException异常。
public static void main(String[] args) {
int a = 6;
int b = 0;
try {
System.out.println("a/b的值是：" + a / b);
} catch (ArithmeticException e) {
System.out.println("程序出现异常，变量b不能为0。");
}
System.out.println("程序正常结束。");
}
}
运行结果：程序出现异常，变量b不能为0。
程序正常结束。
例2  中的语句：
System.out.println("a/b的值是：" + a/b);
在运行中出现“除数为0”错误，引发ArithmeticException异常。运行时系统创建异常对象并抛出监控区域，转而匹配合适的异常处理器catch，并执行相应的异常处理代码。
由于检查运行时异常的代价远大于捕捉异常所带来的益处，运行时异常不可查。Java编译器允许忽略运行时异常，一个方法可以既不捕捉，也不声明抛出运行时异常。
例3  不捕捉、也不声明抛出运行时异常。
public class TestException {
public static void main(String[] args) {
int a, b;
a = 6;
b = 0; // 除数b 的值为0
System.out.println(a / b);
}
}
运行结果：
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Test.TestException.main(TestException.java:8)
例4  程序可能存在除数为0异常和数组下标越界异常。
public class TestException {
public static void main(String[] args) {
int[] intArray = new int[3];
try {
for (int i = 0; i <= intArray.length; i++) {
intArray[i] = i;
System.out.println("intArray[" + i + "] = " + intArray[i]);
System.out.println("intArray[" + i + "]模 " + (i - 2) + "的值:  "
+ intArray[i] % (i - 2));
}
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("intArray数组下标越界异常。");
} catch (ArithmeticException e) {
System.out.println("除数为0异常。");
}
System.out.println("程序正常结束。");
}
}
运行结果：
intArray[0] = 0
intArray[0]模 -2的值:  0
intArray[1] = 1
intArray[1]模 -1的值:  0
intArray[2] = 2
除数为0异常。
程序正常结束。
例4  程序可能会出现除数为0异常，还可能会出现数组下标越界异常。程序运行过程中ArithmeticException异常类型是先行匹配的，因此执行相匹配的catch语句：
catch (ArithmeticException e){
System.out.println("除数为0异常。");
}
需要注意的是，一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。
Java通过异常类描述异常类型，异常类的层次结构如图1所示。对于有多个catch子句的异常程序而言，应该尽量将捕获底层异常类的catch子 句放在前面，同时尽量将捕获相对高层的异常类的catch子句放在后面。否则，捕获底层异常类的catch子句将可能会被屏蔽。
RuntimeException异常类包括运行时各种常见的异常，ArithmeticException类和ArrayIndexOutOfBoundsException类都是它的子类。因此，RuntimeException异常类的catch子句应该放在 最后面，否则可能会屏蔽其后的特定异常处理或引起编译错误。
2. try－catch-finally语句
try-catch语句还可以包括第三部分，就是finally子句。它表示无论是否出现异常，都应当执行的内容。try-catch-finally语句的一般语法形式为：
try {
// 可能会发生异常的程序代码
} catch (Type1 id1) {
// 捕获并处理try抛出的异常类型Type1
} catch (Type2 id2) {
// 捕获并处理try抛出的异常类型Type2
} finally {
// 无论是否发生异常，都将执行的语句块
}
例5  带finally子句的异常处理程序。
public class TestException {
public static void main(String args[]) {
int i = 0;
String greetings[] = { " Hello world !", " Hello World !! ",
" HELLO WORLD !!!" };
while (i 
try {
// 特别注意循环控制变量i的设计，避免造成无限循环
System.out.println(greetings[i++]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("数组下标越界异常");
} finally {
System.out.println("--------------------------");
}
}
}
}
运行结果：
Hello world !
--------------------------
Hello World !!
--------------------------
HELLO WORLD !!!
--------------------------
数组下标越界异常
--------------------------
在例5中，请特别注意try子句中语句块的设计，如果设计为如下，将会出现死循环。如果设计为：
try {
System.out.println (greetings[i]); i++;
}
小结：
try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
catch 块：用于处理try捕获到的异常。
finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：
1)在finally语句块中发生了异常。
2)在前面的代码中用了System.exit()退出程序。
3)程序所在的线程死亡。
4)关闭CPU。
3. try-catch-finally 规则(异常处理语句的语法规则)：
1)  必须在 try 之后添加 catch 或 finally 块。try 块后可同时接 catch 和 finally 块，但至少有一个块。
2) 必须遵循块顺序：若代码同时使用 catch 和 finally 块，则必须将 catch 块放在 try 块之后。
3) catch 块与相应的异常类的类型相关。
4) 一个 try 块可能有多个 catch 块。若如此，则执行第一个匹配块。即Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明的异常类型匹配，如果异常对象为某个异常类型或其子类的实例，就执行这个catch代码块，不会再执行其他的 catch代码块
5) 可嵌套 try-catch-finally 结构。
6) 在 try-catch-finally 结构中，可重新抛出异常。
7) 除了下列情况，总将执行 finally 做为结束：JVM 过早终止(调用 System.exit(int))；在 finally 块中抛出一个未处理的异常；计算机断电、失火、或遭遇病毒攻击。
4. try、catch、finally语句块的执行顺序:
1)当try没有捕获到异常时：try语句块中的语句逐一被执行，程序将跳过catch语句块，执行finally语句块和其后的语句；
2)当try捕获到异常，catch语句块里没有处理此异常的情况：当try语句块里的某条语句出现异常时，而没有处理此异常的catch语句块时，此异常将会抛给JVM处理，finally语句块里的语句还是会被执行，但finally语句块后的语句不会被执行；
3)当try捕获到异常，catch语句块里有处理此异常的情况：在try语句块中是按照顺序来执行的，当执行到某一条语句出现异常时，程序将跳到catch语句块，并与catch语句块逐一匹配，找到与之对应的处理程序，其他的catch语句块将不会被执行，而try语句块中，出现异常之后的语句也不会被执行，catch语句块执行完后，执行finally语句块里的语句，最后执行finally语句块后的语句；
图示try、catch、finally语句块的执行：
图2  图示try、catch、finally语句块的执行
4.2 抛出异常
任何Java代码都可以抛出异常，如：自己编写的代码、来自Java开发环境包中代码，或者Java运行时系统。无论是谁，都可以通过Java的throw语句抛出异常。从方法中抛出的任何异常都必须使用throws子句。
1. throws抛出异常
如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。例如汽车在运行时可能会出现故障，汽车本身没办法处理这个故障，那就让开车的人来处理。
throws语句用在方法定义时声明该方法要抛出的异常类型，如果抛出的是Exception异常类型，则该方法被声明为抛出所有的异常。多个异常可使用逗号分割。throws语句的语法格式为：
methodname throws Exception1,Exception2,..,ExceptionN
{
}
方法名后的throws Exception1,Exception2,...,ExceptionN 为声明要抛出的异常列表。当方法抛出异常列表的异常时，方法将不对这些类型及其子类类型的异常作处理，而抛向调用该方法的方法，由他去处理。例如：
import java.lang.Exception;
public class TestException {
static void pop() throws NegativeArraySizeException {
// 定义方法并抛出NegativeArraySizeException异常
int[] arr = new int[-3]; // 创建数组
}
public static void main(String[] args) { // 主方法
try { // try语句处理异常信息
pop(); // 调用pop()方法
} catch (NegativeArraySizeException e) {
System.out.println("pop()方法抛出的异常");// 输出异常信息
}
}
}
使用throws关键字将异常抛给调用者后，如果调用者不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的调用者。
pop方法没有处理异常NegativeArraySizeException，而是由main函数来处理。
Throws抛出异常的规则：
1) 如果是不可查异常(unchecked exception)，即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。
2)必须声明方法可抛出的任何可查异常(checked exception)。即如果一个方法可能出现受可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误
3)仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣。
4)调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。
例如：
void method1() throws IOException{}  //合法
//编译错误，必须捕获或声明抛出IOException
void method2(){
method1();
}
//合法，声明抛出IOException
void method3()throws IOException {
method1();
}
//合法，声明抛出Exception，IOException是Exception的子类
void method4()throws Exception {
method1();
}
//合法，捕获IOException
void method5(){
try{
method1();
}catch(IOException e){…}
}
//编译错误，必须捕获或声明抛出Exception
void method6(){
try{
method1();
}catch(IOException e){throw new Exception();}
}
//合法，声明抛出Exception
void method7()throws Exception{
try{
method1();
}catch(IOException e){throw new Exception();}
}
判断一个方法可能会出现异常的依据如下：
1)方法中有throw语句。例如，以上method7()方法的catch代码块有throw语句。
2)调用了其他方法，其他方法用throws子句声明抛出某种异常。例如，method3()方法调用了method1()方法，method1()方法声明抛出IOException，因此，在method3()方法中可能会出现IOException。
2. 使用throw抛出异常
throw总是出现在函数体中，用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。
我们知道，异常是异常类的实例对象，我们可以创建异常类的实例对象通过throw语句抛出。该语句的语法格式为：
throw new exceptionname;
例如抛出一个IOException类的异常对象：
throw new IOException;
要注意的是，throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象。下面的操作是错误的：
throw new String("exception");
这是因为String 不是Throwable 类的子类。
如果抛出了检查异常，则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。
如果所有方法都层层上抛获取的异常，最终JVM会进行处理，处理也很简单，就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException，则该方法的调用者可选择处理该异常。
package Test;
import java.lang.Exception;
public class TestException {
static int quotient(int x, int y) throws MyException { // 定义方法抛出异常
if (y 
throw new MyException("除数不能是负数"); // 异常信息
}
return x/y; // 返回值
}
public static void main(String args[]) { // 主方法
int  a =3;
int  b =0;
try { // try语句包含可能发生异常的语句
int result = quotient(a, b); // 调用方法quotient()
} catch (MyException e) { // 处理自定义异常
System.out.println(e.getMessage()); // 输出异常信息
} catch (ArithmeticException e) { // 处理ArithmeticException异常
System.out.println("除数不能为0"); // 输出提示信息
} catch (Exception e) { // 处理其他异常
System.out.println("程序发生了其他的异常"); // 输出提示信息
}
}
}
class MyException extends Exception { // 创建自定义异常类
String message; // 定义String类型变量
public MyException(String ErrorMessagr) { // 父类方法
message = ErrorMessagr;
}
public String getMessage() { // 覆盖getMessage()方法
return message;
}
}
4.3 异常链
1) 如果调用quotient(3,-1)，将发生MyException异常，程序调转到catch (MyException e)代码块中执行；
2) 如果调用quotient(5,0)，将会因“除数为0”错误引发ArithmeticException异常，属于运行时异常类，由Java运行时系统自动抛出。quotient()方法没有捕捉ArithmeticException异常，Java运行时系统将沿方法调用栈查到main方法，将抛出的异常上传至quotient()方法的调用者：
int result = quotient(a, b); // 调用方法quotient()
由于该语句在try监控区域内，因此传回的“除数为0”的ArithmeticException异常由Java运行时系统抛出，并匹配catch子句：
catch (ArithmeticException e) { // 处理ArithmeticException异常
System.out.println("除数不能为0"); // 输出提示信息
}
处理结果是输出“除数不能为0”。Java这种向上传递异常信息的处理机制，形成异常链。
Java方法抛出的可查异常将依据调用栈、沿着方法调用的层次结构一直传递到具备处理能力的调用方法，最高层次到main方法为止。如果异常传递到main方法，而main不具备处理能力，也没有通过throws声明抛出该异常，将可能出现编译错误。
3)如还有其他异常发生，将使用catch (Exception e)捕捉异常。由于Exception是所有异常类的父类，如果将catch (Exception e)代码块放在其他两个代码块的前面，后面的代码块将永远得不到执行，就没有什么意义了，所以catch语句的顺序不可掉换。
4.4 Throwable类中的常用方法
注意：catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型，e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:
getCause()：返回抛出异常的原因。如果 cause 不存在或未知，则返回 null。
getMeage()：返回异常的消息信息。
printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值。
有时为了简单会忽略掉catch语句后的代码，这样try-catch语句就成了一种摆设，一旦程序在运行过程中出现了异常，就会忽略处理异常，而错误发生的原因很难查找。
5.Java常见异常
在Java中提供了一些异常用来描述经常发生的错误，对于这些异常，有的需要程序员进行捕获处理或声明抛出，有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类:
1. runtimeException子类:
1、 java.lang.ArrayIndexOutOfBoundsException
数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
2、java.lang.ArithmeticException
算术条件异常。譬如：整数除零等。
3、java.lang.NullPointerException
空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
4、java.lang.ClassNotFoundException
找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
5、java.lang.NegativeArraySizeException  数组长度为负异常
6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常
7、java.lang.SecurityException 安全性异常
8、java.lang.IllegalArgumentException 非法参数异常
2.IOException
IOException：操作输入流和输出流时可能出现的异常。
EOFException   文件已结束异常
FileNotFoundException   文件未找到异常
3. 其他
ClassCastException    类型转换异常类
ArrayStoreException  数组中包含不兼容的值抛出的异常
SQLException   操作数据库异常类
NoSuchFieldException   字段未找到异常
NoSuchMethodException   方法未找到抛出的异常
NumberFormatException    字符串转换为数字抛出的异常
StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常
IllegalAccessException  不允许访问某类异常
InstantiationException  当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常
6.自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。
在程序中使用自定义异常类，大体可分为以下几个步骤。
(1)创建自定义异常类。
(2)在方法中通过throw关键字抛出异常对象。
(3)如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
(4)在出现异常方法的调用者中捕获并处理异常。
在上面的“使用throw抛出异常”例子已经提到了。

展开全部
用正则判断，/**
* 验证手机号码格式是否正确
* @param mobiles
* @return  true 表示正确  false表示不正确
*/
public static boolean isMobileNum(String mobiles) {
Pattern p = Pattern.compile("^((13[0-9])|636f70793231313335323631343130323136353331333337383833(15[0-9])|(18[0-9]))\\d{8}");
Matcher m = p.matcher(mobiles);
return m.matches();
}
当然手机号码好像还有17开头的，对应的正则改一下就好
"^((13[0-9])|(15[0-9])|(18[0-9])|(17[0-9]))\\d{8}"
然后在你的代码里面调用这个方法，如果结果为false，就throw new MyException(“手机号码格式不正确”)一个异常。
异常定义可以去继承Exception/**
* Created by Kevin on 2015/3/30.
*/
public class MyException extends Exception{
private String msg;
public MyException(String msg) {
super(msg);
this.msg = msg;
}
@Override
public String getMessage() {
return msg;
}
}

文章目录
一、关于JSR
1.1什么是JSR？
1.2什么是JSR-303？
1.3JSR-303的作用？
二、从if判断到jsr303
2.1提供一个场景
2.1首先使用if判断
2.3jsr303使用
三、jsr303相关校验注解导图展示
四、@Valid和@Validated的区别
五、@Valid和@Validated高级使用
5.1Valid级联校验
5.2@Validated分组校验
5.2.1什么是分组校验
5.2.2.引出jsr303校验注解的groups方法
5.2.3.@Validated注解value方法开启指定分组校验
5.2.4.检验结果
5.2.5.结论
5.3@Validated分组校验顺序
5.3.1为什么需要？
5.3.2如何实现?
5.4@Validated非实体类校验
5.4.1.使用@Validated注解
5.4.2.GlobalExceptionHandler类添加异常处理方法
5.4.3测试结果
六、自定义注解校验
6.1自定义注解@ListValue
6.2使用自定义注解
6.3请求方法
6.4测试结果
七、补充@PathVariable注解校验
7.1@PathVariable作用
7.2使用正则表达式校验路径变量
7.3自定义类实现ErrorController接口
7.4测试结果
八、导图总结


本文代码已上传gitee：https://gitee.com/shang_jun_shu/springboot-exception-jsr303.git

其他系列博客

Java异常处理（一）一异常处理流程

java异常处理（二）—从字节码层面看throw关键字及try…catch…finally的实现

java异常处理（三）—Springboot全局异常处理(@ControllerAdvice和ErrorController)

一、关于JSR
1.1什么是JSR？
JSR是Java Specification Requests的缩写，意思是Java规范提案，是指向JCP(Java Community Rrocess)提出新增一个标准化技术规范的正式请求。任何人都可以提交JSR，以向Java平台增添新的API和服务。
比如：
Web应用技术

Java Servlet 3.0 (JSR 315)
JavaServer Faces 2.0 (JSR 314)
JavaServer Pages 2.2/Expression Language 2.2 (JSR 245)
Standard Tag Library for JavaServer Pages (JSTL) 1.2 (JSR 52)
Debugging Support for Other Languages 1.0 (JSR 45)

1.2什么是JSR-303？
JSR-303是javaee 6中的一项子规范，叫做Bean Validation，Hibernate Validator 是 Bean Validation的参考实现. Hibernate Validator 提供了 JSR 303 规范中所有内置 constraint 的实现，除此之外还有一些附加的 constraint，目前Springboot内置了Hibernate Validator。
1.3JSR-303的作用？
用于对Java Bean的字段值进行校验，确保输入进来的数据在语义上是正确的，使验证逻辑从业务代码中脱离出来。
JSR303是运行时数据验证框架，验证之后验证的错误信息会马上返回。
二、从if判断到jsr303
2.1提供一个场景
提供一个实体类，该实体类含有一个属性
@Data
public class ExceptionQuery {
    private String userName;
}

要求用户提供的姓名不能为空，下面开始校验该属性
2.1首先使用if判断
@PostMapping("/query")
public Result  getResult(@RequestBody ExceptionQuery query){
    //校验参数
    if (StringUtils.isEmpty(query.getUserName())){
        //抛出异常
    }
    return Result.buildSuccess(query);
}

这个方法本省是没有问题的，但是如果入参有很多属性需要校验，那么程序中就会存在很多if判断，这样显的代码很冗余。有没有方法替代if判断呢？当然是有的，使用jsr303可以解决该问题
2.3jsr303使用
1.为属性加@NotBlank属性
@Data
public class ExceptionQuery {

    @NotBlank(message = "用户姓名必须提交")
    private String userName;

}

注：像@NotBlank一类的校验注解都可以重写message属性
public @interface NotBlank {
    
    //default表明可以重写message属性
    String message() default "{javax.validation.constraints.NotBlank.message}";
    //省略...
}

2.在方法入参参数上加@Valid注解
@PostMapping("/query")
public Result  getResult(@Valid @RequestBody ExceptionQuery query){
    return Result.buildSuccess(query);
}

3.postman测试结果



从输出结果上可以看到重写后的message属性，而对于错误的输出结果Spring也提供了对应类存储错误信息，这个类就是BindingResult，将上面的方法加上BindingResult参数，如下代码
@PostMapping("/query")
public Result  getResult(@Valid @RequestBody ExceptionQuery query, BindingResult result){
    if(result.hasErrors()){
        Map<String,String> map = new HashMap<>();
        result.getFieldErrors().forEach(item->{
            //获取发生错误时的message
            String message = item.getDefaultMessage();
            //获取发生错误的字段
            String field = item.getField();
            map.put(field,message);
            System.out.println(field+":"+message);
        });
        return Result.buildFailure(400,"参数错误",map);
    }
    return Result.buildSuccess(query);
}

输出结果


然而，咱们不能对每个方法都传入一个BindingResult参数，可以使用统一异常处理输出错误信息
4.配合异常处理
首先说下为什么能通过异常处理输出错误信息？

我们定位到一个类MethodArgumentNotValidException，该类也是Spring提供的，包含BindingResult引用，因此该类可以拿到输出的错误信息



异常处理代码
@Slf4j
@RestControllerAdvice(annotations = {RestController.class, Controller.class})
public class GlobalExceptionHandler {
    
    @ResponseStatus(HttpStatus.OK)
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Result handleValidationException(MethodArgumentNotValidException e) {
        log.error(ErrorStatus.ILLEGAL_DATA.getMessage() + ":" + e.getMessage());
        Map<String,Object> map=new HashMap<>();
        
        //拿到异常输出信息
        BindingResult bindingResult = e.getBindingResult();
        bindingResult.getFieldErrors().forEach(fieldError -> {
            String message = fieldError.getDefaultMessage();
            String field = fieldError.getField();
            map.put(field,message);
        });
        return Result.buildFailure(ErrorStatus.ILLEGAL_DATA.getCode(),String.valueOf(getFirstOrNull(map)),map);
    }

    //拿到map第一个值
    private static Object getFirstOrNull(Map<String, Object> map) {
        Object obj = null;
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            obj = entry.getValue();
            if (obj != null) {
                break;
            }
        }
        return  obj;
    }
}

加上异常处理后的方法代码如下所示，关于@ControllerAdvice全局异常处理请看这一篇博客
@PostMapping("/query")
public Result  getResult(@Valid @RequestBody ExceptionQuery query){
    return Result.buildSuccess(query);
}

是不是很简洁，下面看下输出结果


三、jsr303相关校验注解导图展示


注意:@Validated和@Valid注解都是开启注解校验功能的注解
下面举个例子说明一下
阐述基本用法可能不是那么适合，到实际应用改下就行



输出结果


四、@Valid和@Validated的区别
上述例子咱们用的是@Valid进行校验的，用@Validated注解也可以，那么他两的区别是什么呢？

所属不同：

该注解所属包为:javax.validation.Valid，而 @Validated是Spring基于@Valid进一步封装，并提供了一些高级功能，如分组，分组顺序等


使用位置不同：

@Validated：可以用在类型、方法和方法参数上。但是不能用在成员属性上

@Valid:可以用在方法、构造函数、方法参数和成员属性上

正是由于@Valid能用于成员属性(字段)上，因此@Valid可以提供级联校验，关于级联校验下面就要阐述
五、@Valid和@Validated高级使用
5.1Valid级联校验
级联校验也叫嵌套检测，嵌套即一个实体类包含另一个实体类
举个例子

下面有个People实体类



该类还有两个属性，一个是名字，一个头发，因为一个人有很多头发(暂不考虑光头哈哈)，Hair实体类如下



下面写一个方法检测下用户数据
在方法参数上用@Validated或者@Valid都可以
@PostMapping("/add")
public Result getPeople(@Validated @RequestBody People people){
    return Result.buildSuccess(people);
}

测试结果如下



暴露一个问题
没有输出Hair实体类对数据的校验结果，可以证明@Validated和@Valid加在方法参数前，都不会对嵌套的实体类Hair进行检测
实现检测
为了能够完成对嵌套实体类的检测，我们需要在属性上使用@Vaild注解


看下此时的输出结果


5.2@Validated分组校验
5.2.1什么是分组校验
分组校验是由@Validated的value方法提供的，用于开启指定的组校验，分别作用不同的业务场景中，下面举个例子说明下
5.2.2.引出jsr303校验注解的groups方法

假如使用Mybatis做持久化框架(其他也可以)，我们知道当向数据库插入一条数据时，这条数据id是自动生成，不用用户传入的，而当我们修改一条数据时，id需要用户传入，因此在修改操作时需要对id进行校验。像以上修改和插入对id不同的操作，这个时候就要使用groups方法对id进行分组，如下图所示



为了涵盖多种情况，加入了两个属性，personName属性在AddGroup.class,UpdateGroup.class时都会校验，personAge属性在不指定分组时校验
5.2.3.@Validated注解value方法开启指定分组校验

5.2.4.检验结果
下面使用一样的数据请求三个方法，得到的结果如下
模拟数据，该数据都不符合要求
{
    "personId":"",
    "personName":"",
    "personAge":0
}

getPerson方法不指定分组
校验了@Range(min=1,max=400,message="年龄提交有误")，该注解不含groups方法
{
    "success": false,
    "code": 10003,
    "msg": "年龄提交有误",
    "data": {
        "personAge": "年龄提交有误"
    }
}


addPerson方法指定AddGroup分组
校验了@NotBlank(message = "名字不能为空",groups = {AddGroup.class,UpdateGroup.class})
{
    "success": false,
    "code": 10003,
    "msg": "名字不能为空",
    "data": {
        "personName": "名字不能为空"
    }
}

updatePerson方法指定UpdateGroup分组
校验了@NotBlank(message = "id不能为空",groups = UpdateGroup.class)和
@NotBlank(message = "名字不能为空",groups = {AddGroup.class,UpdateGroup.class})
{
    "success": false,
    "code": 10003,
    "msg": "名字不能为空",
    "data": {
        "personName": "名字不能为空",
        "personId": "id不能为空"
    }
}

5.2.5.结论
如果校验注解添加上groups方法并指定分组，只有@Validated注解value方法指定该分组，才会开启校验注解的校验数据功能。
同样的如果校验注解没有groups指定分组，则@Validated注解value方法为默认分组时才会开启
5.3@Validated分组校验顺序
5.3.1为什么需要？

默认情况下，分组间的约束验证是无序的，然而某些情况下分组间的校验顺序却很重要，比如第二组约束验证依赖于第一组稳定状态来进行，这个时候需要分组按照顺序校验。

5.3.2如何实现?
分组校验顺序由@GroupSequence注解实现
举个例子
1.列出分组顺序
public interface First {}

public interface Second {}

//此时first、second顺序校验
@GroupSequence({First.class,Second.class})
public interface Group {}

2.实体类及请求方法
@Data
public class UserGroupSequence {

    @NotEmpty(message = "id不能为空",groups = First.class)
    private String userId;

    @NotEmpty(message = "姓名不能空",groups = First.class)
    @Size(min = 3,max = 8,message = "姓名长度在3到8之间",groups = Second.class)
    private String userName;
}


@RestController
@RequestMapping("/group")
public class UserGroupSequenceController {

    //此时用的是value方法指定的是Group接口
    @PostMapping("/add")
    public Result addGroup(@Validated(value = Group.class) @RequestBody UserGroupSequence sequence){
        return Result.buildSuccess(sequence);
    }
}

3.测试结果
模拟数据
{
    "userId":"",
    "userName":""
}

结果
{
    "success": false,
    "code": 10003,
    "msg": "姓名不能空",
    "data": {
        "userName": "姓名不能空",
        "userId": "id不能为空"
    }
}

4.结论

@GroupSequence注解指定分组顺序时，如果First标识的校验注解没有通过，则Second标识的注解不会生效。



读者可以测试下，如果把userName上两个校验注解groups去掉，输出结果是"姓名不能空"及"姓名长度在3到8之间"交替出现

5.4@Validated非实体类校验
上面校验都是对实体类的校验，下面来介绍下对非实体类的校验
5.4.1.使用@Validated注解
这里特别要注意一点就是@Validated注解对于非实体类的校验，在类上注解才会起效果
@Validated
public class AnnotationController {
    
    @GetMapping("/getage")
    public Result getAge(@Range(min = 3,max = 8,message = "年龄在3-8岁") @RequestParam String age){
        return Result.buildSuccess(age);
    }
}

5.4.2.GlobalExceptionHandler类添加异常处理方法
    @ExceptionHandler(ConstraintViolationException.class)
    @ResponseBody
    public Result resolveConstraintViolationException(ConstraintViolationException ex){

        Set<ConstraintViolation<?>> constraintViolations = ex.getConstraintViolations();
        
        //对异常信息进行处理
        if(!CollectionUtils.isEmpty(constraintViolations)){
            StringBuilder msgBuilder = new StringBuilder();
            for(ConstraintViolation constraintViolation :constraintViolations){
                msgBuilder.append(constraintViolation.getMessage()).append(",");
            }
            String errorMessage = msgBuilder.toString();
            if(errorMessage.length()>1){
                errorMessage = errorMessage.substring(0,errorMessage.length()-1);
            }
            return Result.buildFailure(ErrorStatus.ILLEGAL_DATA.getCode(),errorMessage);
        }
        return Result.buildFailure(ErrorStatus.ILLEGAL_DATA.getCode(),ex.getMessage());
    }

5.4.3测试结果
http://localhost:8082/annotation/getage?age=1

{
    "success": false,
    "code": 10003,
    "msg": "年龄在3-8岁",
    "data": null
}

六、自定义注解校验
提供一个场景，假如一个字段只能让用户传入特定的值，比如判断是否显示的属性isShow，只能取0和1，下面我们实现这一个功能
6.1自定义注解@ListValue
@Documented
//该注解由哪个类校验
@Constraint(validatedBy = {ListValue.ListValueConstraintValidator.class})
@Target({ ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE })
@Retention(RUNTIME)
public @interface ListValue {

    String message() default "{com.thinkcoder.annotation.ListValue.message}";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default { };

    int[] value();

    class ListValueConstraintValidator implements ConstraintValidator<ListValue,Integer> {
        private Set<Integer> set=new HashSet<>();

        //获取value属性指定的数字,存入set集合
        @Override
        public void initialize(ListValue constraintAnnotation) {
            int[] value = constraintAnnotation.value();
            for (int i : value) {
                set.add(i);
            }
        }

        //校验用户输入数据是否在set集合中
        //isValid第一个参数传入要校验属性的类型
        @Override
        public boolean isValid(Integer value, ConstraintValidatorContext context) {
            return  set.contains(value);
        }
    }
}

上面的代码需要说明以下几点

校验类要实现ConstraintValidator<ListValue,Integer>接口;第一个泛型参数是自定义注解，第二个泛型参数是要校验的属性类型
initalize方法:获取到用户使用自定义注解中的数据
isValid方法:实现校验逻辑，结果是返回boolean类型
@Constraint注解:将自定义注解和校验类联系起来

6.2使用自定义注解
@Data
public class AnnotationQuery {

    @ListValue(value = {0,1},message = "数值只能是0或者1")
    private Integer isShow;
}

6.3请求方法
@PostMapping("/add")
public Result addAnnotation(@Validated @RequestBody AnnotationQuery query){
    return Result.buildSuccess(query);
}

6.4测试结果
模拟数据
{
    "isShow":-1
}

测试结果
{
    "success": false,
    "code": 10003,
    "msg": "数值只能是0或者1",
    "data": {
        "isShow": "数值只能是0或者1"
    }
}

七、补充@PathVariable注解校验
7.1@PathVariable作用

用来对指定请求的URL路径里面的变量，比如@GetMapping("/get/{id}")，其中{id}就是这个请求的变量，可以通过@PathVariable来获取。



和@RequestParam的区别是，@RequestParam用来获得静态的URL请求入参。

7.2使用正则表达式校验路径变量
下面正则表达式表示id值只能是数字，如果不是数字报出404路径找不到的异常
@GetMapping("/get/{id:\\d+}")
public Result getId(@PathVariable(name="id") String userId){
    return Result.buildSuccess(userId);
}

7.3自定义类实现ErrorController接口
说下为什么要这么做？

@ControllerAdive注解只能处理进入控制器方法抛出的异常，ErrorController接口可以处理全局异常，而404路径找不到异常不是控制器方法抛出的，此时还没有进入控制器方法。ErrorController处理404异常时会跳转到/error路径，此时会返回错误的html页。为了让返回结果统一，重写下ErrorController接口的getErrorPath方法

@RestController
public class MyErrorController extends BasicErrorController {

    @Autowired
    public MyErrorController(ErrorAttributes errorAttributes,
                             ServerProperties serverProperties,
                             List<ErrorViewResolver> errorViewResolvers) {
        super(errorAttributes, serverProperties.getError(), errorViewResolvers);
    }

    //处理html请求
    @Override
    public ModelAndView errorHtml(HttpServletRequest request,
                                  HttpServletResponse response) {
        HttpStatus status = getStatus(request);
        Map<String, Object> model = getErrorAttributes(
                request, isIncludeStackTrace(request, MediaType.TEXT_HTML));
        ModelAndView modelAndView = new ModelAndView("myErrorPage", model, status);
        return modelAndView;
    }

    //处理json请求
    @Override
    public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
        Map<String, Object> body = getErrorAttributes(request,
                isIncludeStackTrace(request, MediaType.ALL));

        Map<String,Object> resultBody=new HashMap<>(16);
        resultBody.put("success",false);
        resultBody.put("code",body.get("status"));
        resultBody.put("msg",body.get("error"));

        return new ResponseEntity<>(resultBody, HttpStatus.OK);
    }
}

7.4测试结果
实例:
http://localhost:8082/get/aa

结果:
{
    "success": false,
    "code": 404,
    "msg": "请求接口不存在请检查路径",
}

八、导图总结
通过以上叙述基本包含了常用开发用到的校验注解，下面用导图总结下



参考博客
https://www.jb51.net/article/115431.htm
@Validated和@Valid区别
两个注解的区别
https://blog.csdn.net/gaojp008/article/details/80583301
创作不易，觉得有帮助，点个赞吧，您的支持是我最大的动力

今天在看hadoop源码时，想想自己最近在做的那个系统，发现很多异常处理的方式不对，还是按照传统的异常处理方式(即：采用返回值来标识程序出现的异常情况)。而hadoop中很多方法的声明是有异常抛出的，而我的系统中的很多方法的声明都没有抛出异常。只是判断了异常情况，并输出了错误提示，但是并没有抛出异常。
org.apache.hadoop.hdfs.protocol包下的Block类的readFields()方法：
public void readFields(DataInput in) throwsIOException {this.blockId =in.readLong();this.numBytes =in.readLong();this.generationStamp =in.readLong();if (numBytes < 0) {throw new IOException("Unexpected block size: " + numBytes);//抛出异常，要是的话就不会抛出，而只是System.out.println错误提示，
}
1.如果方法声明名里面有throws异常，那么方法体里面可以不抛出异常。因为可以在方法声明中包含异常说明，但实际上却不抛出！这样做的好处是，为异常先占个位置，以后就可以抛出这种异常而不用修改修改已有的代码。在定义抽象基类和接口时这种能力很重要，这样派生类或接口实现类就能够抛出这些预先声明的异常。
2.为什么有的方法声明里面没有throws，但方法体里面却抛出了异常？从RuntimeException继承的异常，可以在没有异常说明throws的情况下被抛出！对于Runtime异常(也称为非检查的异常unchecked exception)，编译器不需要异常说明。只能在代码中忽略RuntimeException(及其子类)类型的异常，其他类型的异常的处理都是由编译器强制实施的。究其原因，RuntimeException代表的是编程错误。
3.运行时异常会被Java虚拟机自动抛出！
1. 异常处理基础
1.1 System.out.println是高代价的。调用System.out.println会降低系统吞吐量。
1.2 在生产环境中别用异常的printStackTrace()方法。printStackTrace默认会把调用的堆栈打印到控制台上，在生产环境中访问控制台是不现实的。
2. 异常处理基本原则
2.1 如果你不能处理异常，不要捕获该异常。
2.2 如果要捕获，应在离异常源近的地方捕获它。
2.3 不要吞没你捕获的异常。
*(就是捕获的异常，但是什么也不做)
2.4 除非你要重新抛出异常，否则把它log起来。
2.5 当一个异常被重新包装，然后重新抛出的时候，不要打印statck trace。
2.6 用自定义的异常类，不要每次需要抛出异常的时候都抛出java.lang.Exception。方法的调用者可以通过throws知道有哪些异常需要处理--所以它是自我描述的。
2.7 如果你编写业务逻辑，对于终端用户无法修复的错误，系统应该抛出非检查的异常(unchecked exception)；如果你编写一个第三方的包给其他的开发人员用，对于不可修复的错误要用需要检查的异常(checked exception)。
2.8 绝对不要因为写throws语句会让你用起来不舒服，而不声明需要检查的异常。
2.9 应用级别的错误或不可修复的系统异常用非检查的异常(unchecked exception)抛出。
*(注意是错误，意味着不可修复，比如配置文件错误)
2.10 根据异常的粒度组织你的方法
其他参考文章：