精华内容
下载资源
问答
  • 在编写异常处理的java程序中
    2021-06-17 22:50:26

    目录

    统一异常处理的原因

    如果进行统一异常处理

    1、编写统一异常处理类与方法

    2、编写自定义异常类

    3、定义异常枚举类

    4、抛出指定异常

    小提醒


    统一异常处理的原因

    在我们写代码的时候,因为各种场景需要进行各种校验,我们就可能会进行多种响应,多种异常返回,会出现的情况就是,满屏幕的try cache,可读性不高,所以需要进行一个统一异常处理

    如果进行统一异常处理

    个人觉得,进行统一异常处理的步骤,分为这么几部分

    1、编写统一异常处理类与方法

    @ControllerAdvice
    public class ExceptionAdvice {
    
        @ExceptionHandler(MyException.class)
        public ResponseEntity<MyRsp> doRsp (MyException e) {
            return ResponseEntity.status(200).body(new MyRsp(e.getStatus(), e.getMessage()));
        }
    
    }
    
    
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class MyRsp {
    
        private String statusCode;
        private String statusDesc;
    
    }
    

    这里出现了两个注解,@ControllerAdvice和@ExceptionHandler

    第一个注解的作用就是,只要你加了@Controller的类,抛出了异常,就会走这个添加了@ControllerAdvice的类

    第二个注解的作用,就是当前类发生了异常,就会走加了@ExceptionHandler的注解的方法

    2、编写自定义异常类

    @Data
    @AllArgsConstructor
    public class MyException extends RuntimeException{
    
        private String status;
        private String message;
    
        public MyException(ExceptionEnu e) {
            this.status = e.getCode();
            this.message = e.getMessage();
        }
    
    }
    

    3、定义异常枚举类

    @Getter
    public enum  ExceptionEnu {
    
        SUCCESS("1", "成功"),
        FAILD("2", "失败");
    
    
    
        private String code;
        private String message;
    
        ExceptionEnu(String code, String message) {
            this.code = code;
            this.message = message;
        }
    }
    

    4、抛出指定异常

    @RestController
    public class OneController {
    
        @GetMapping("/doCheck")
        public String doCheck (int age) {
            if (age > 1) {
            throw new MyException(ExceptionEnu.SUCCESS);
            } else {
                throw new MyException(ExceptionEnu.FAILD);
            }
        }
    
    }
    

    小提醒

    当然,不是所有的情况都要进行统一异常处理,本人遇到过的好些个场景,都是不可以进行统一异常处理的,必须try cache

    比如:调用一个别的服务,如果调用成功了,那就走这个流程,如果调用失败了,那就走那个流程,这个就必须用 try cache了,不能做统一异常处理,你要是做了统一异常处理,好家伙,直接这个流程结束了,这不就没得玩了

    要不要做统一异常处理,这个需要结合实际业务来判断,这里不过多讨论

     

    更多相关内容
  • 主要介绍了Java编程10个最佳的异常处理技巧,本文,将讨论Java异常处理最佳实践,这些Java最佳实践遵循标准的JDK库,和几个处理错误和异常的开源代码,这还是一个提供给java程序员编写健壮代码的便利手册,需要的...
  • java异常处理

    千次阅读 2021-12-15 09:36:17
    文章目录异常概述与异常体系结构异常在java语言,将程序执行发生的不正常情况称为异常。编译时异常:运行时异常:常见异常异常处理处理机制一:try---catch---finallytry---catch---finally处理机制二:throws...

    异常概述与异常体系结构

    异常:在java语言中,将程序执行中发生的不正常情况称为异常。

    在这里插入图片描述

    异常可以分为如下两类:

    • Erroy:虚拟机无法解决的问题。 主要问题为JVM系统内部的错误。堆栈溢出等。

    • Exception:因编程错误,或者外在因素导致的问题。比如:空指针异常,数组越界等。

    对于 Exception来说又可分为编译时异常,和运行行异常。

    对于这两个异常大家应该不陌生

    编译时异常:

    • 是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。编译器要求Java程序必须捕获或声明所有编译时异常。

    • 对于这类异常,如果程序不处理,可能会带来意想不到的结果。

    运行时异常:

    • 是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误,是程序员应该积极避免其出现的异常。java.lang.RuntimeException类及它的子
      类都是运行时异常。
    • 对于这类异常,可以不作处理,因为这类异常很普遍,若全处理可能会对程序的可读性和运行效率产生影响。

    对于这些错误,一般有两种解决方法:一是遇到错误就终止程序的运行。另一种方法是由程序员在编写程序时,就考虑到错误的检测、错误消息的提示,以及错误的处理。

    常见异常

    Exception子类

    异常解释
    DataFormatException发出数据格式错误的信号
    IOException表示发生某种类型的I / O异常。 此类是由失败或中断的I / O操作产生的一般异常类。
    ParseException表示解析时意外出现错误。
    RuntimeException在Java虚拟机的正常操作期间可以抛出的那些异常的超类。

    RuntimeException直接子类
    这里就是我们经常遇见的一些异常

    异常名解释
    ArithmeticException抛出异常算术条件时抛出。 例如,“除以零”的整数会抛出此类的一个实例。
    EmptyStackExceptionStack类中的方法抛出,表示堆栈为空
    IllegalArgumentException抛出表示一种方法已经通过了非法或不正确的参数。
    IndexOutOfBoundsException抛出以表示某种索引(例如数组,字符串或向量)的索引超出范围。
    NullPointerException当应用程序尝试在需要对象的情况下使用null时抛出
    ArrayIndexOutOfBoundsException抛出以表示使用非法索引访问数组。 索引为负数或大于或等于数组的大小。

    异常处理

    处理机制一:try—catch—finally

    我们在编写程序的时候,经常会在会出现错误的地方加上if-else判断经行保护,但过多的if-else会导致代码的臃肿。因此我们可以使用异常处理机制。

    • Java提供的是异常处理的抓抛模型。 Java程序的执行过程中如出现异常会生成一个异常类对象,
    • 该异常对象将被提交给Java运行时系统,这个过程称为抛出(throw)异常

    异常的产生:由虚拟机产生、由开发人员手动创建。

    • 如果一个方法内抛出异常,该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理,它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去,直到异常被处理。这一过程称为捕获(catch)异常。
    • 如果一个异常回到main()方法,并且main()也不处理,则程序运行终止。
    • 程序员通常只能处理Exception,而对Error无能为力。

    异常处理通常是通过try—catch—finally来处理的。

    try—catch—finally

    • try
      捕获异常的第一步是用try{…}语句块选定捕获异常的范围,将可能出现异常的代码放在try语句块中。
    • catch (Exceptiontype e)
      在catch语句块中是对异常对象进行处理的代码。每个try语句块可以伴随一个或多个catch语句,用于处理可能产生的不同类型的异常对象。
    • finally
      捕获异常的最后一步是通过finally语句为异常处理提供一个统一的出口,不论是否捕获到了异常,finally块中的语句都会被执行。

    关于异常的两个常用方法

    方法名
    getMessage返回此throwable的详细消息字符串。
    printStackTrace将此throwable和其追溯打印到标准错误流。

    示例:

    public class Catch {
    
    	public static void main(String[] args) {
    		int[] arr = new int[] {1,2,3};
    		
    		try {
    			for (int i = 0; i < 3; i++) {//注意数组的大小为3
    				System.out.println(arr[i]);
    			}
    			
    		} catch (Exception e) {
    			//发生异常 时执行
    			System.out.println("越界异常");
    		}finally {
    			//都会执行
    			System.out.println("运行结束");
    		}
    
    	}
    
    }
    

    结果:
    在这里插入图片描述
    有异常时:
    代码:

    public class Catch {
    
    	public static void main(String[] args) {
    		int[] arr = new int[] {1,2,3};
    		
    		try {
    			for (int i = 0; i < 4; i++) {//注意数组的大小为3
    				System.out.println(arr[i]);
    			}
    			
    		} catch (Exception e) {
    			//发生异常 时执行
    			System.out.println("越界异常");
    		}finally {
    			//都会执行
    			System.out.println("运行结束");
    		}
    
    	}
    
    }
    
    

    结果:
    不作处理:
    在这里插入图片描述
    使用try catch
    在这里插入图片描述

    处理机制二:throws

    如果一个方法(中的语句执行时)可能生成某种异常,但是并不能确定如何处理这种异常,则此方法应显示地声明抛出异常,表明该方法将不对这些异常进行处理,而由该方法的调用者负责处理。

    在类的后面声明即可。

    在这里插入图片描述
    此时本类不对异常做处理,将其将给调用者进行处理,如果都不做处理,在到达main,如果main方法也没有做处理,则程序终止。

    public class Catch {
    
    	public static void main(String[] args) throws Exception {
    		int[] arr = new int[] {1,2,3};
    		
    		
    			for (int i = 0; i < 4; i++) {//注意数组的大小为3
    				System.out.println(arr[i]);
    			}
    	}
    }
    

    在这里插入图片描述
    无人处理时,到达main函数时,程序结束。

    手动抛出异常

    首先产生异常对象,然后手动抛出。

    Exception exp = new RuntimeErrorException(null);
    			throw exp;
    
    

    可以抛出的异常必须时throwable的子类。否则会发生编译时异常。

    自定义异常

    • 一般地,用户自定义异常类都是RuntimeException的子类。
    • 自定义异常类通常需要编写几个重载的构造器。
    • 自定义异常需要提供serialVersionUID
    • 自定义的异常通过throw抛出。
    • 自定义异常最重要的是异常类的名字,当异常出现时,可以根据名字判断异常类型。

    示例:

    public class PetExpception extends RuntimeException{
    	
    	public PetExpception(String str) {
    		super(str);
    	}
    
    }
    
    展开全文
  • 在java中,提供一个throw关键字,它成为抛出一个指定的异常对象。那么,一个抛出异常具体如何操作呢? 创建一个异常对象。封装一些提示信息(信息内容可以自己编写)。 需要将这个异常对象告知给调用者。怎么知道呢...
  • Java提供了几个异常处理特性,以try,catch和finally关键字的形式内建于语言自身之Java编程语言也允许你创建新的异常,并通过使用throw和throws关键字抛出它们。事实上,异常处理不仅仅是知道语法。书写一个强健...
  • 主要介绍了Java中异常处理机制,结合实例形式详细分析了Java异常处理机制的相关概念、原理、用法及操作注意事项,需要的朋友可以参考下
  • 主要介绍了Java抛出异常与自定义异常类,结合实例形式分析了Java针对错误与异常处理的try、catch、throw等语句相关使用技巧,需要的朋友可以参考下
  • 本篇文章是对Java编程中异常处理的优劣进行了详细的分析介绍,需要的朋友参考下
  • 本篇文章主要介绍了java异常处理机制及应用,异常处理机制是Java语言的一大特色。从异常处理的机制、异常处理的方法、异常处理的原则等方面介绍Java语言的异常处理技术,有兴趣的可以了解一下。
  • 主要给大家介绍了关于Java异常处理中的各种细节的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 前言:本文主要讨论Java中异常,因为java是一种强类型语言,其中的异常处理和Python语言异常处理还是有些许区别!!!目 录一、异常异常:就是程序出现不正常的情况案例如下:packageitheima2;public ...

    前言:

    本文主要讨论Java中的异常,因为java是一种强类型语言,其中的异常处理和Python语言中的异常处理还是有些许区别!!!

    目  录

    一、异常

    异常:就是程序出现不正常的情况

    207480144e8af308b8d9caad5e1e3960.png

    案例如下:

    packageitheima2;public classExceptionDemo {public static voidmain(String[] args) {//调用方法

    test();

    }//定义方法 -- 注意:自定义方法必须有static修饰,但是自定义类中的方法不需要static 修饰

    public static voidtest() {int[] arr = {1, 2, 3};

    System.out.println(arr[3]); //超出数组索引范围,

    }/*报错信息:

    Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3

    at itheima2.ExceptionDemo.test(ExceptionDemo.java:14)

    at itheima2.ExceptionDemo.main(ExceptionDemo.java:7)*/}

    二、JVM 默认的异常处理

    //如果程序出现了问题,我们没有解决。那么Java虚拟机JVM就会做默认处理//处理包括两个步骤:

    /*1、将异常的名称、异常的原因和异常的位置输出在控制台

    2、停止程序的运行

    /*

    三、异常处理之 Try...catch...

    异常处理通常有两种方法:

    Try ... catch..  和   Throws

    Try .. catch .. 格式及执行流程:

    //try ...catch...异常处理/*格式:

    try {

    可能出现异常部分的代码;

    } catch(异常类名 变量名) {

    异常的处理代码;

    }

    执行流程:

    从try里面的代码开始执行,出现异常后会生成一个异常类对象,并且将这个异常类对象交给java运行时系统;

    java运行时系统会去catch中找匹配的异常类对象进行异常处理;

    执行完异常处理的代码后程序会向下继续执行!!!*/

    案例:

    packageitheima2;//try ...catch...异常处理/*格式:

    try {

    可能出现异常部分的代码;

    } catch(异常类名 变量名) {

    异常的处理代码;

    }

    执行流程:

    从try里面的代码开始执行,出现异常后会生成一个异常类对象,并且将这个异常类对象交给java运行时系统;

    java运行时系统会去catch中找匹配的异常类对象进行异常处理;

    执行完异常处理的代码后程序会向下继续执行!!!*/

    public classExceptionDemo1 {public static voidmain(String[] args) {//TODO 方法调用

    test();

    }public static voidtest() {try{int[] arr = {1, 2, 3};

    System.out.println(arr[3]); //超出数组索引范围,

    } catch(ArrayIndexOutOfBoundsException e) {

    System.out.println("索引错误,索引值超出数组的索引范围");

    }

    }

    }

    四、Throwable 的成员方法

    Throwable 类是所有异常类的父类!如下图所示:

    0bfeae2597a1fbb610485c4a100491c3.png

    Throwable类成员方法及案例如下:

    packageitheima2;/** Throwable 的成员方法, Throwable 类是 所有异常类的父类

    * public String getMessage() 返回throwable的详细信息字符串

    * public String toString() 返回可抛出的简短描述(原因)

    * public void printStackTrace() 将异常信息输出在控制台

    **/

    public classExceptionDemo2 {public static voidmain(String[] args) {//TODO

    System.out.println("开始:");

    test();

    System.out.println("结束:");

    }public static voidtest() {try{int[] arr = {1, 2, 3};

    System.out.println(arr[3]); //超出数组索引范围,

    } catch(ArrayIndexOutOfBoundsException e) {//System.out.println("索引错误,索引值超出数组的索引范围");//public String getMessage() 返回throwable的详细信息字符串

    System.out.println(e.getMessage());//public String toString()

    System.out.println(e.toString());//public void printStackTrace() 将异常信息输出在控制台----最常用方法

    e.printStackTrace();//注意:调用printStackTrace方法时会直接打印出字符串,没有返回值;因此可以直接调用

    /** e.printStackTrace() 执行结果如下,可以看出和jvm默认的异常处理一样,但是程序不会终止,可以继续向下执行;

    * java.lang.ArrayIndexOutOfBoundsException: 3

    at itheima2.ExceptionDemo2.test(ExceptionDemo2.java:22)

    at itheima2.ExceptionDemo2.main(ExceptionDemo2.java:15)*/}

    }

    }

    五、编译型异常和运行时异常

    异常通常分为编译时异常和运行时异常//编译时异常通常都是 Exception类及其子类,需要显示处理,不然无法编译无法执行//运行时异常通常都是 RuntimeException类,不需要显示处理

    编译时异常可以理解为:在代码编写过程中代码飘红,出现错误导致代码无法执行;

    运行时异常可以理解为:代码在编写过程中没有出现错误,但是执行结果显示错误。

    具体案例如下:

    packageitheima2;importjava.text.ParseException;importjava.text.SimpleDateFormat;importjava.util.Date;//编译时异常和运行时异常

    public classExceptionDemo3 {public static voidmain(String[] args) {//method();

    method2();

    }//自定义方法

    public static voidmethod() {int[] arr = {1, 2, 3};

    System.out.println(arr[3]); //运行时错误: 编译通过,结果报错,可以直接在代码中修改

    }public static voidmethod2() {try{

    String ss= "2020-10-09";

    SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd");

    Date a= sdf.parse(ss); //编译时错误:代码飘红--

    System.out.println(a);

    }catch(ParseException e) {

    e.printStackTrace();

    }

    }/** sdf.parse() 报错信息:包括错误原因和错误位置

    * java.lang.Error: Unresolved compilation problem:

    Unhandled exception type ParseException

    at itheima2.ExceptionDemo3.method2(ExceptionDemo3.java:25)

    at itheima2.ExceptionDemo3.main(ExceptionDemo3.java:12)*/}

    六、异常处理之Throws

    一般的异常使用try catch来处理,但是当遇到一些超出权限的异常时我们需要将异常抛出,比如说将异常抛给方法的调用者,由方法的调用者进行异常处理!!!

    /*throws 异常处理格式如下:

    public void 方法名() throws 异常类名{

    }

    注意: 该格式放在方法()的后面*/

    案例如下:

    packageitheima2;/*throws 异常处理方法

    格式:

    throws 异常类名

    注意: 该格式放在 方法()的后面。案例如下:*/

    importjava.text.ParseException;importjava.text.SimpleDateFormat;importjava.util.Date;public classExceptionDemo4 {public static voidmain(String[] args) {//method();//在方法调用的时候进行try catch 异常处理, 在方法编写的时候用throws 异常类名 ,将异常抛出

    try{

    method2();

    }catch(ParseException e) {

    e.printStackTrace();

    }

    }//运行时异常

    public static voidmethod() {int[] arr = {1, 2, 3};

    System.out.println(arr[3]); //运行时错误: 编译通过,结果报错,可以直接在代码中修改

    }//编译时异常

    public static void method2() throwsParseException{

    String ss= "2020-10-09";

    SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd");

    Date a= sdf.parse(ss); //编译时错误:代码飘红--

    System.out.println(a);

    }

    }

    七、自定义异常类

    自定义异常类就是继承Exception类,并给出无参和带参构造方法!

    案例如下:

    自定义异常类:

    packageitheima2;//自定义分数异常类,继承Exception类

    public class ScoreException extendsException{//有参无参构造方法

    publicScoreException(){}publicScoreException(String message) {super(message);

    }

    }

    教师类:

    packageitheima2;//自定义教师类

    public classTeacher {//成员方法

    public void checkScore(int score) throws ScoreException { //利用throws来抛出异常,给方法调用者进行处理//执行判断过程

    if(score < 0 || score > 100) {//抛出异常信息,可以无参方法也可以是带参方法//throw new ScoreException();

    throw new ScoreException("给出的数值不在范围内");

    }else{

    System.out.println("成绩正常!");

    }

    }

    }

    测试类:

    packageitheima2;importjava.util.Scanner;public classTestDemo {public static voidmain(String[] args) {//TODO Auto-generated method stub

    Scanner sc = newScanner(System.in);

    System.out.println("请输入分数:");int score =sc.nextInt();//异常处理

    try{

    Teacher tt= newTeacher();

    tt.checkScore(score);

    }catch(ScoreException e) {

    e.printStackTrace();

    }

    }

    }/*执行结果如下:

    请输入分数:

    111

    itheima2.ScoreException: 给出的数值不在范围内

    at itheima2.Teacher.checkScore(Teacher.java:12)

    at itheima2.TestDemo.main(TestDemo.java:17)*/

    展开全文
  • 两数计算+异常处理

    2018-05-29 19:22:39
    Java异常可以是函数的语句执行时引发的,也可以是程序员通过throw 语句手动抛出的,只要在Java程序中产生了异常,就会用一个对应类型的异常对象来封装异常,JRE就会试图寻找异常处理程序来处理异常
  • 深入介绍java异常基本概念及异常处理流程配有导图总结哦~

    代码已上传gitee:https://gitee.com/shang_jun_shu/springboot-exception-jsr303.git
    其他系列博客
    java异常处理(二)—从字节码层面看throw关键字及try…catch…finally的实现
    java异常处理(三)—Springboot全局异常处理(@ControllerAdvice和ErrorController)
    java异常处理(四)—还在用if判断校验参数?试试SpringBoot全局异常+JSR303校验吧!

    一、Java异常基本概念

    1.1、异常是什么

    程序执行过程发生了不正常的情况,这种情况叫做异常

    java提供一套发现并处理异常的机制,使程序员更容易发现错误
    异常信息是由JVM打印在控制台

    1.2异常以什么方式存在

    类的方式,每一个异常类都可以创建对象

    对应现实生活
    火灾(异常类):

    • 2008年8月8日,小明加着火了(异常对象)
    • 2008年8月9日,小方加着火了(异常对象)
    • 2008年8月10日,小红加着火了(异常对象)

    1.3异常继承结构图

    在这里插入图片描述
    所有错误执行执行的结果就是终止程序,不管错误还是异常皆可抛出,因为都是Throwable类的子类

    1.4异常分类

    从上图中可以看出,异常主要分为两类

    • 编译时异常:该异常类直接继承了Exception,程序员在编写程序时要处理这种异常,要不然编译不通过
    • 运行时异常:该异常类继承了RuntimeException,程序员可以不用处理这种异常,如果不处理会直接交给jvm处理,打印堆栈信息

    两者区别:

    • 编译时异常发生概率高,要进行预处理
    • 运行时异常发生概率低,没有必要预处理

    举例子:
    在这里插入图片描述
    如上图所示,
    method1抛出了IOException,该异常直接继承了Exception,该异常为编译时异常,所以编辑器工具会报出红线,提示程序员进行处理。

    而method2抛出了RuntimeException,为运行时异常,此时程序员不需要进行处理。

    二、处理异常方式

    在java中处理异常一共有两种方式

    • 1.在方法声明位置,使用throws关键字,抛给上一级

      谁调用我,就抛给谁,上一级也有这两种处理方式,如果接着向上抛,抛给main方法,main方法抛给jvm,就会终止程序

    • 2.使用try…catch…finally进行异常处理,此时处理完的异常就不用抛出去了,当然如果catch或者finally语块中包含throw关键字,也是抛出异常,这个后面讨论。

    总结如下图
    在这里插入图片描述

    三、java异常在程序中的几个表现

    下面按照导图顺序说下在实际开发中对异常的处理方式以及适用情况

    3.1自动抛出异常

    public class ExceptionTest1 {
    
        public static void main(String[] args) throws Exception {
            method1(0);
        }
    
        //不管异常
        public static void method1(int b){
            int a= 6;
            //除数为0发生异常
            int c=a/b;
            System.out.println(c);
        }
    }
    
    
    //输出结果
    Exception in thread "main" java.lang.ArithmeticException: / by zero
    	at com.thinkcoder.ExceptionTest1.method1(ExceptionTest1.java:14)
    	at com.thinkcoder.ExceptionTest1.main(ExceptionTest1.java:8)
    
    Process finished with exit code 1
    

    从输出结果可以看出可以得出两点

    1.该异常交给了jvm去处理,最后调用printStrace方法打印出堆栈日志

    2.异常发生在主线程(main方法)直接终止程序,后面的代码不执行

    但是一般情况下,不希望这种情况发生,因为用户的数据导致整个程序不能用,现在使用springboot后会终止线程,但是需要给用户友好提示,所以实际生产情况下要避免这种情况发生,因此要处理异常

    3.2catch语块处理异常

    catch语块处理异常分为三种情况

    只打印日志

    return方法结束

    throw抛出异常

    3.2.1只打印日志

    对于只打印日志的情况就是,即使异常发生,后续代码也会执行即程序也会正常执行,那么什么情况下适用只打印日志呢?

    1.该方法代码不是核心功能

    比如统计用户点击量,如果此代码出现异常导致后面代码不能执行,核心功能不能用,那就得不偿失了,此时就可以只打印日志

    public Object run() {
    
        log.info("用户点击统计模块开始过滤");
    
        RequestContext ctx = RequestContext.getCurrentContext();
        String requestURI = ctx.getRequest().getRequestURI();
    
        try{
            //是否在uri在模块中
            if(AppUserHitEnum.compareUri(requestURI)){
                DataModuleHits hits = new DataModuleHits();
                AppUserHitEnum userHit = AppUserHitEnum.getUserHit(requestURI);
                hits.setModuleCode(userHit.getModuleCode());
                hits.setModuleName(userHit.getModuleName());
                log.info("用户请求的模块,{},在统计列表中",userHit.getModuleName());
                this.dataAppUserDistClient.add(hits);
            }else{
                log.info("App用户请求的uri不在统计列表中"+requestURI);
            }
        }catch (Exception e){
            log.error(e.getMessage());
        }finally {
            return null;
        }
    }
    

    如上代码所示,即使try块中的代码出现异常,也不会导致程序结束运行

    2.不使用try块中变量值,但是像这种情况很少见

    3.2.2return语句结束方法

    在catch块中使用return语句表明方法有能力处理异常,一般分为两种情况

    一种方法是没有返回值即void,可以直接结束用户请求

    另一种方法是有返回值的,此时return出去的是一个默认值

    总结来说,return在实际生产中不常用,因为此时用户并不知道异常存在,以为自己的数据没有问题,而导致数据错误。

    3.2.3throw抛出异常

    使用throw抛出异常即可以终止程序,又可以提示用户发生异常,所以在实际编程中使用throw自定义异常,一般是运行时异常,因为编译已经通过了,将异常抛出去

    public UserToken getUserToken(){
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token = request.getHeader(JwtConstans.CONTEXT_TOKEN);
        UserToken userInfo=new UserToken();
        try{
            userInfo = (UserToken)redisUtil.get(token);
        }catch (Exception e){
            //抛出去没有权限的异常
            throw new UnAuthException(401,"token获得用户为空");
        }
        return userInfo;
    }
    
    //自定义异常
    public class UnAuthException extends RuntimeException {
    
        private Integer code;
    
        public UnAuthException(Integer code,String message) {
            super(message);
            this.code = code;
        }
    
    }
    

    在上述的例子中在redis中取出token对应的用户信息可能会发生异常,比如redis环境突然变了,redis突然down了等等,所以加了catch语块处理,而实际编程中一般是使用throw加自定义异常,代替return的做法

    3.3 throw关键字与throws关键字

    先说下两者的区别,严格意义来说,这两者不是同一性质的东西,因为throw是抛出异常,而throws是处理异常的方式。有那么一点共同点是都是抛出异常

    接下来要补充下对throw关键字的认识

    • 1.throw关键字可以用在代码可能出现异常的任何地方

    • 2.throw关键字是throw的Exception的一个实例,throw new RuntimeException是可以不处理的,而throw new Exception是需要处理异常的

    下面举例子说明一下

    throw 编译时异常
    在这里插入图片描述
    可以看出来throw编译时异常需要让程序员处理异常,要用到处理异常的两种方式,throws出去或者try…catch

    throw 运行时异常在这里插入图片描述如果是运行时异常则不是必须让程序员处理

    四、方法执行过程

    从上面可以看出来,异常是在方法执行中产生的,要总结异常处理的流程,首先要先了解下方法在JVM中是怎样执行的,如下图所示
    在这里插入图片描述

    虚拟机栈是描述java方法的执行过程的内存模型,它在当前栈帧(Stack Frame)中存储了局部变量表、操作数栈,动态链接,方法出口等信息。

    同时栈帧用来存储部分运行时数据及其数据结构,处理动态链接(Dynamic Linking)方法的返回值和异常分派(Dispatch Exception).

    栈帧用来记录方法的执行过程,在方法被执行时虚拟机会为其创建一个与之对应的栈帧,方法的执行和返回对应栈帧在虚拟机栈中的入栈和出栈。

    注意:无论方法是正常运行完成还是异常完成(抛出了在方法内未被捕获的异常),都视为方法运行结束

    当一个方法执行完毕,Java虚拟机会从调用栈中弹出该方法的栈结构,然后继续处理前一个方法。

    五、异常处理流程

    下面以比较熟悉的Controller、Service、Mapper举个例子,说明一下方法调用及其异常处理的流程,如下图所示:
    在这里插入图片描述
    下面用文字描述下

    如果在执行方法的过程中抛出异常,则Java虚拟机必须找到能捕获该异常的catch代码块。它首先查看当前方法是否存在这样的catch代码块,如果存在,那么就执行该catch代码块;否则,Java虚拟机会从调用栈中弹出该方法的栈结构,继续到前一个方法中查找合适的catch代码块。在回溯过程中,如果Java虚拟机在某个方法中找到了处理该异常的代码块,则该方法的栈结构将成为栈顶元素,程序流程将转到该方法的异常处理代码部分继续执行。

    当Java虚拟机追溯到调用栈的底部的方法时,如果仍然没有找到处理该异常的代码块,按以下步骤处理。

    (1)调用异常对象的printStackTrace()方法,打印来自方法调用栈的异常信息。

    (2)如果该线程不是主线程,那么终止这个线程,其他线程继续正常运行。如果该线程是主线程(即方法调用栈的底部为main()方法),那么整个应用程序被终止。

    六、总结精华

    • 1.异常分为编译时异常和运行时异常,编译时异常必须程序员处理,运行时异常不一定

    • 2.异常情况和throw都会终止程序进行,并抛出异常

    创作不易,觉得有帮助的,来个三连吧
    在这里插入图片描述

    展开全文
  • 异常处理机制能让程序在异常发生时,按照代码的预先设定的异常处理逻辑,针对性地处理异常,让程序尽最大可能恢复正常并继续执行,且保持代码的清晰
  • 本文主要对 JAVA编程过程的问题进行分解,首先应尽量避免出现错误和异常,针对无法避免和预测的情况要考虑发生异常的时 候怎样处理。从JAVA语言的概念和特点等方面,对JAVA语言的异常进行了分析,阐述了JAVA语言...
  • Java异常处理代码编写

    千次阅读 2019-08-19 10:12:38
    Java异常处理代码编写 java中异常 计算机程序运行的过程,总是会出现各种各样的错误。 有一些错误是用户造成的,比如,希望用户输入一个int类型的年龄,但是用户的输入是abc: // 假设用户输入了abc: ...
  • 返回本章节 返回作业目录 需求说明: 从控制输入计算机磁盘后缀名为“....创建类Read,该类导入java.io.FileInputStream类,Read类定义静态方法readFile(),该方法有一个String类型的参数,该参数表示从
  • Java异常处理的几种方式

    千次阅读 2021-07-29 15:42:24
    异常处理 文章目录异常处理异常概述与异常体系结构异常...异常在Java语言,将程序执行发生的不正常情况称为“异常” 。 (开发过程的语法错误和逻辑错误不是异常) Java 程序在执行过程所发生的异常事件可分为
  • Java程序在执行过程所发生的异常事件可分为两类: Error: Java虚拟机无法解决的严重问题。 如: JVM系统内部错误、 资源耗尽等严重情况。 比如: StackOverflowError和OOM。 一般不编写针对性的代码进行处理。 ...
  • 主要简单介绍了Java编程异常处理的运用,是Java入门学习的基础知识,需要的朋友可以参考下
  • java异常 — — 异常处理

    千次阅读 2021-08-31 12:21:02
    二、异常处理 Java异常处理的五个关键字: try、catch、finally、throw、throws ...在java中,提供了一个throw关键字,它用来抛出一个指定的异常对象。 抛出异常后: ① 创建一个异常对象。封装一些提示
  • 实验六 Java 异常处理程序设计; Java 自定 义异常程序设计 一、实验目的 1、理解系统异常处理的机制。 2、创建自定义的异常类型。 二、实验学时 2 学时 三、实验类型 验证性实验 四、实验需求 1、硬件 每位学生...
  • package 异常处理上机; import java.util.Scanner; public class ExceptionABCD extends Exception { public static void TestABCD(String str) throws ExceptionABCD { System.out.print("this is ...
  • 最全最详细的Java异常处理机制

    千次阅读 多人点赞 2022-01-27 11:21:36
    一、异常概述与异常体系结构 异常概述 使用计算机语言进行项目开发的过程,即使程序员把代码写得尽善尽美,系统的运行过程仍然会遇到一些问题,因为...Java程序在执行过程所发生的异常事件可分为两类: ...
  • JAVA 异常处理小技巧

    千次阅读 2021-03-01 06:33:12
    1、异常:就是程序运行时出现不正常情况异常由来:问题也是现实生活中一个具体的事物,也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。对于问题的划分(两种):一...
  • (开发过程的语法错误和逻辑错误不是异常)2、Java程序在执行过程所发生对异常事件可分为两类:Error:Java虚拟机无法解决的严重问题。如:JVM系统内部错误、资源耗尽等严重情况。比如:StackOverflowError和OOM。...
  • Java论文异常处理论文:JAVA异常处理的分析与研究.doc
  • 【单选题】设有如下类的定义: pubic class parent{ int change(){} } class Child extends Parent{} 则下面哪些方法可加入Child类? ( )【单选题】对于如下程序的执行,说法错误的是( )。 class MultiCatch { public...
  • 今天,总结一下最近编程使用的python异常处理和日志处理的感受,其实异常处理程序编写时非常重要的一块,但是我一开始学的语言是C++,这门语言没有强制要求使用try…catch语句,因此我通常编写代码的时候忽略了...
  • Java面向对象程序设计 实验四 异常处理

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 306,870
精华内容 122,748
关键字:

在编写异常处理的java程序中