Java异常框架中finally执行、及其他相关问题

最新推荐文章于 2023-04-22 23:55:33 发布
最新推荐文章于 2023-04-22 23:55:33 发布
阅读量5.3k 收藏 3
点赞数
分类专栏： JAVA java 文章标签： java 框架 exception null jdbc web框架
java 同时被 2 个专栏收录
116 篇文章 0 订阅
订阅专栏
JAVA
25 篇文章 0 订阅
订阅专栏


关键字: java 异常 finally 资源
     首先看一下异常处理的完整语法，如下：

Java代码
try{  
      //（尝试运行的）程序代码  
}catch(异常类型 异常的变量名){  
      //异常处理代码  
}finally{  
      //异常发生，方法返回之前，总是要执行的代码  
} 

try{
      //（尝试运行的）程序代码
}catch(异常类型 异常的变量名){
      //异常处理代码
}finally{
      //异常发生，方法返回之前，总是要执行的代码
}
        在Java中，应用try-catch-finally结构可以使我们在出现异常的时候能保证相关资源被按时正确的清理。

        我们都知道一个try-catch-finally结构，只要try块开始执行了，finally块里面的代码保证执行一次并且只执行一次。try-catch-finally给我们提供了在抛出异常时“保证执行某个动作”的机会，机会是提供了，但是finally一定会把握这次机会，完成某个动作的执行吗？或者说finally能完成它{...}里的相关操作吗？（当然这里除了system.exit()操作，因为在system.exit()时，finally是不会执行的）

       下面我们就通过一个例子来说明一下，一个最常见的实例应用就是jdbc的Connection, Statement, ResultSet的使用。

先看一个例子：

例1：

Java代码
void test(){   
   Connection conn = ...;   
   Statement stmt = ...;   
   ResultSet rset = ...;   
   rset.close();   
   stmt.close();  
   conn.close();   
   ...   
}  

void test(){
   Connection conn = ...;
   Statement stmt = ...;
   ResultSet rset = ...;
   rset.close();
   stmt.close();
   conn.close();
   ...
}
        乍一看，这个程序没有问题，按jdbc标准ResultSet, Statement, Connection都close()掉了，不用GC来帮忙回收资源了。但是如果在rset或者stmt关闭时，出现了异常，那么conn的close()就不能执行了，那么就会存在着浪费资源的问题。也就是说这个例子这样写是有问题的。

        这个时候我们就会想到用finally来执行ResultSet, Statement, Connection的close()操作，在finally中，肯定能执行这些close()操作。

例2：

Java代码
void test(){   
     Connection conn = null;   
     Statement stmt = null;   
     ResultSet rset = null;   
     try{   
          conn = ...;   
          stmt = ...;   
          rset = ...;   
          ...   
     } catch(Exception e){  
          e.printStackTrace();     
     } finally{   
          if(rset!=null)rset.close();   
          if(stmt!=null)stmt.close();   
          if(conn!=null)conn.close();   
     }   
}  

void test(){
     Connection conn = null;
     Statement stmt = null;
     ResultSet rset = null;
     try{
          conn = ...;
          stmt = ...;
          rset = ...;
          ...
     } catch(Exception e){
          e.printStackTrace();  
     } finally{
          if(rset!=null)rset.close();
          if(stmt!=null)stmt.close();
          if(conn!=null)conn.close();
     }
}
        有人认为这下终于安全了，不会存在资源浪费的情况了。

        其实很多人都是这么认为的，但是在finally里close的时候，也是会抛出异常的。如果在执行if(stmt!=null)stmt.close(); 出现了异常，那么conn.close()是不会执行的，finally{}不能完全执行结束。这样写还是有可能出现问题的。

所以就需要对上面的例2再进行改造：

例3：

Java代码
void test(){   
Connection conn = null;   
Statement stmt = null;   
ResultSet rset = null;   
try{   
conn = ...;   
stmt = ...;   
rset = ...;   
...   
}   
finally{   
try{   
   if(rset!=null)rset.close();   
}catch(Exception e){   
   e.printStackTrace();   
}   
 
try{   
   if(stmt!=null)stmt.close();  
}catch(Exception e){   
   e.printStackTrace();   
}   
 
try{   
   if(conn!=null)conn.close();  
}catch(Exception e){   
   e.printStackTrace();   
}   
}   
}  

void test(){
Connection conn = null;
Statement stmt = null;
ResultSet rset = null;
try{
conn = ...;
stmt = ...;
rset = ...;
...
}
finally{
try{
   if(rset!=null)rset.close();
}catch(Exception e){
   e.printStackTrace();
}

try{
   if(stmt!=null)stmt.close();
}catch(Exception e){
   e.printStackTrace();
}

try{
   if(conn!=null)conn.close();
}catch(Exception e){
   e.printStackTrace();
}
}
}

        这样就可以解决因为异常而存在浪费资源的问题了。一般的Exception通过例3都能解决这些问题。

        但是除了Exception，我们的程序还会碰到Error，那么上面这个例子是否也能处理Error呢？众所周知，Error代表不可恢复错误，是程序无法处理的错误，所以我们也处理不了这种Error。所以在finally里执行stmt.close()时，如果出现Error，那么conn.close()还是不会被执行的。finally还是不能执完全行结束。那我们遇到Error时，该怎么处理里？

        这里我们可以把Error转成Exception或者RuntimeException，然后抛出，再做处理。因为对于一个应用系统来说，系统所发生的任何异常或者错误对操作用户来说都是系统"运行时"异常，都是这个应用系统内部的异常。这也是将Error转成Exception或者RuntimeException的指导原则（当然也可以将Exception-->RuntimeException）。

        ①：Error到Exception：将错误转换为异常，并继续抛出。例如Spring WEB框架中，将org.springframework.web.servlet.DispatcherServlet的doDispatch()方法中，将捕获的错误转译为一个NestedServletException异常。这样做的目的是为了最大限度挽回因错误发生带来的负面影响。因为一个Error常常是很严重的错误，可能会引起系统挂起。

        ②：Exception到RuntimeException：将检查异常转换为RuntimeException可以让程序代码变得更优雅，让开发人员集中经理设计更合理的程序代码，反过来也增加了系统发生异常的可能性。

       ③：Error到RuntimeException：目的还是一样的。把所有的异常和错误转译为不检查异常，这样可以让代码更为简洁，还有利于对错误和异常信息的统一处理。

        所以例3总的来说,还是存在着一些问题,这样对于上面的例3我们又需要进行程序的修改（在例4中就不介绍Error与Exception或者RuntimeException的转换了）：

例4：

Java代码
void test(){   
 final Connection conn = ...;   
 try{   
  final Statement stmt = ...;   
  try{   
   final ResultSet rset = ...;   
   try{   
    ...   
   }catch(Exception e){  
      e.printStackTrace();  
   }finally{rset.close();}   
  }catch(Exception e){  
   ...  
  }finally{stmt.close();}   
 }catch(Exception e){  
  ...  
 }finally{conn.close();}   
}  

void test(){
 final Connection conn = ...;
 try{
  final Statement stmt = ...;
  try{
   final ResultSet rset = ...;
   try{
    ...
   }catch(Exception e){
      e.printStackTrace();
   }finally{rset.close();}
  }catch(Exception e){
   ...
  }finally{stmt.close();}
 }catch(Exception e){
  ...
 }finally{conn.close();}
}

       这样每建立一个需要清理的资源，就用一个try-catch-finally来保证它可以被清理掉。当然了，在执行close操作的时候，我们必须要注意close的次序。通过例4你会发现，close的次序问题好像已经被解决了，不用去考虑这个问题了。


=====================================================================================================

在Java里finally子句的处理还有其他诡异的地方。比如：它可以改写返回值。
如下所示：

Java代码
public class Test {  
    public static void main(String[] args) {  
        System.out.println(ret(-1));  
        System.out.println(ret(1));  
    }  
 
    private static boolean ret(int i) {  
        try {  
            if (i < 0) {  
                return false;  
            } else {  
                return true;  
            }  
        }catch (Exception e) {  
            // TODO: handle exception  
        }finally{  
            return false;  
        }  
    }  
} 

public class Test {
 public static void main(String[] args) {
  System.out.println(ret(-1));
  System.out.println(ret(1));
 }

 private static boolean ret(int i) {
  try {
   if (i < 0) {
    return false;
   } else {
    return true;
   }
  }catch (Exception e) {
   // TODO: handle exception
  }finally{
   return false;
  }
 }
}


        两次的返回结果都是:false。其实在调用ret(1)的时候，按道理应该返回true，但是就因为finally里的return操作改写了返回值。所以一般情况下，finally里不会return。


=====================================================================================================

     其实在例4中还是存在着一些小问题的：

  

Java代码
void test(){   
    final Connection conn = ...;   
    try{   
        final Statement stmt = ...;   
        try{   
            final ResultSet rset = ...;   
            try{④  
                ...③  
            }catch(Exception e){①  
                e.printStackTrace();②  
            }finally{  
                rset.close();⑤  
            }  
        }catch(Exception e){  
            ...  
        }finally{stmt.close();}   
    }catch(Exception e){  
        ...  
    }finally{conn.close();}   
} 

void test(){
 final Connection conn = ...;
 try{
  final Statement stmt = ...;
  try{
   final ResultSet rset = ...;
   try{④
    ...③
   }catch(Exception e){①
    e.printStackTrace();②
   }finally{
    rset.close();⑤
   }
  }catch(Exception e){
   ...
  }finally{stmt.close();}
 }catch(Exception e){
  ...
 }finally{conn.close();}
}

        ①: 这里应该指定具体的异常，而不提倡用一个catch(Exception e)语句捕获所有的异常。

     catch语句表示我们预期会出现某种异常，而且希望能够处理该异常。异常类的作用就是告诉Java编译器我们想要处理的是哪一种异常。

 

     在这段程序中，最明显的一个就是SQLException，这是JDBC操作中常见的异常。所以我们在捕获这个异常的时候最好能说明具体是那个异常。

 

     如果这try块中有多个异常产生，那么最好是通过多个catch来捕获不同的异常，而不是为了图省事，就用一个catch(Exception e)语句捕获所有的异常。

 

      ②:这里异常丢弃了，因为调用一下printStackTrace算不上“处理异常”，调用printStackTrace对调试程序有帮助，但程序调试阶段结束之后，printStackTrace就不应再在异常处理模块中担负主要责任了。

 

     所以在异常处理的时候针对具体异常采取具体行动，例如修正问题、提醒某个人或进行其他一些处理，要根据具体的情形确定应该采取的动作。 认为自己不能处理的一场，可以重新抛出异常也不失为一种选择，或者把该异常转换成另一种异常(可以把一个低级的异常转换成应用级的异常)。

 

       ③:如果在这个地方进行数据循环输出，而在循环输出时抛出了异常，那么循环的执行就会被打断的，这样就会导致用户将收到一份不完整的（或者错误的）数据，但却得不到任何有关这份数据是否完整的提示。对于有些系统来说，数据不完整可能比系统停止运行带来更大的损失。

 

       这个时候就要在处理异常的时候向输出设备写一些信息，声明数据的不完整性；另一种可能有效的办法是，先缓冲要输出的数据，准备好全部数据之后再一次性输出，如下所示：

 

Java代码
catch(SQLException sqlex)   
{   
　out.println("警告：数据不完整");   
　throw new SQLException("读取数据时出现SQL错误", sqlex);   
}  

catch(SQLException sqlex)
{
　out.println("警告：数据不完整");
　throw new SQLException("读取数据时出现SQL错误", sqlex);
} 

       ④:try块不要过于庞大

      把大量的语句装入单个巨大的try块就象是把所有东西就扔到一个大箱子，不能是吃的，还是用的，虽然东西是带上了，但要找出来却不容易。

 

       ⑤:其实应该跟例3一样

 

Java代码
finally{   
try{   
   if(rset!=null)rset.close();   
}catch(Exception e){   
   e.printStackTrace();   
}   
} 

zgmzyr
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
异常处理中关于finally的一些常见面试问题知识点解析整理
RMSTSYJ的博客
05-20 650
本篇博客主要为大家整理了关于java中面向对象中异常处理try-catch-finally格式中关于finally的一些常见的面试问题知识点的解析，是对这块内容的知识的一个汇总。 1.finally是什么？ 首先了解一下finally是什么？finally是异常处理try-catch-finally格式中必然执行的异常统一处理出口，无论是否发生异常，finally都必然执行。 2.finally不执行的情况 在面试的时候我们经常会被问到，当什么什么情况出现后，finally还会不会执行？注意..
Java异常中finally的执行
qiu__hui的博客
03-29 620
 package javatest; public class Test { public static void aMethod()throws Exception{  try{   throw new Exception();  }  catch(Exception e){   System.out.println("exception000");  }  finall
简单说说java异常处理中的finally
qq_36806434的博客
07-31 384
在try-catch-finally中,finally的做一些收尾性的工作，例如：关闭文件，关闭数据库，关闭网络连接等。 我们知道在try-catch-finally中无论try中的代码是否发生异常，finally总会执行，只有一种情况除外，那就是除非jvm关闭或崩溃（关闭jvm，System.exit;），否则finally总是会执行的 当finally遇上return的情况，代码执行顺序会如何： public class Test03 { public static int div(in..
Python异常处理中的Finally else的功能
Ta_ki
12-23 1193
Python异常处理中的Finally else的功能Python使用Try Exception来处理异常机制 若Exception中有Try对应的异常处理，则Try - exception之后的代码将被执行，但若Try - exception中没有对应的代码，则程序抛出Traceback停止运行 那么else finally就是针对这两种情况带来的后果分别相应的关键字else如果一个Try - e
java 异常框架CODE
09-30
Java异常框架是Java编程语言中处理程序运行时错误和异常的核心机制。在Java中，异常是一种特殊的对象，用于表示程序运行过程中的不正常状态。Java的异常处理模型基于\"异常处理块\"，包括try、catch、finally和throw...
Java异常框架设计
05-29
这篇博文“Java异常框架设计”可能探讨了如何有效地利用Java的异常处理机制来构建可靠的系统。在这个讨论中，我们将深入理解Java异常的基本概念、异常分类、以及如何通过良好的框架设计提升代码的可读性和可维护性。...
Java API中的异常类体系框架捕捉及详解.docx
07-02
Java异常处理的关键字包括`try`、`catch`、`finally`、`throw`和`throws`。`try`块用来包含可能会抛出异常的代码，当异常发生时，控制流会立即跳转到匹配的`catch`块。`catch`块用于处理特定类型的异常，可以有多个`...
简单谈谈java的异常处理(Try Catch Finally)
09-02
本文将深入探讨Java异常处理的关键元素——try、catch和finally，以及如何自定义异常类。 首先，Java中的异常处理基于五个关键字：`try`、`catch`、`finally`、`throw`和`throws`。`try`块用于包含可能会抛出异常的...
高效的java异常处理框架高效的java异常处理框架高效的java异常处理框架
08-03
本文将从 Java 异常的基本概念和语法开始，讲述 Java 异常处理的基本知识，分析 Java 异常体系结构，对比 Spring 的异常处理框架，阐述异常处理的基本原则，并提出了自己处理一个大型应用系统异常的思想，并通过设计...
java finally 抛出异常,在finally块中抛出异常
weixin_39554170的博客
03-19 1851
回答(14)2 years agotry {final Resource resource = acquire();try {use(resource);} finally {resource.release();}} catch (ResourceException exx) {... sensible code ...}任务完成 . 没有空测试 . 单一捕获，包括获取和释放异常 . 当然，您可...
关于finally代码块的抛出异常问题
璟矢
11-30 6998
之前面试被问道关于异常捕获的finally代码块作用，可能我们想到的会是在finally中进行一些资源关闭的操作。 常见的操作便是IO流这样的close操作： public static void throwException(){ File file = null; FileInputStream fis = null; try{ ...
finally块与抛异常
今天又是充满希望的一天
05-28 4603
复习一下finally块里有return和try抛异常的程序执行顺序问题.首先看一个测试例子：public class FinallyTryTest { public static void main(String[] args) { int a=testFinally(); System.out.println(a); } public s...
Java中的异常处理机制
十三阿哥的博客
04-22 710
** 自定义异常：* 在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。a. 如果希望写一个检查性异常类，则需要继承 Exception 类。b. 如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。} } /** 如果父类中的方法抛出多个异常, 则子类中的覆盖方法可以选择不抛出任何异常, 或者要么抛出相同的异常,* 要么抛出异常的子类, 但是不能抛出新的异常。
java的finally_深入浅析java中finally的用法
weixin_34828705的博客
02-12 1206
finally作为异常处理的一部分，它只能用在try/catch语句中，并且附带一个语句块，表示这段语句最终一定会被执行(不管有没有抛出异常)，经常被用在需要释放资源的情况下。之前在写爬虫的时候数据库连接的频率很高，有时候数据处理的不好，sql报错后，抛出异常但后边的数据库连接没有断开。导致最后数据库连接数过大，不让再连接了(因为是个人库，所以直接重启了一下)。这个释放数据库连接的操作就可以用fi...
解决try catch finally中close的问题
sutonline的博客
07-21 2977
解决try catch finally中close的问题一直觉得要在finally里关闭流，是很讨厌的，因为代码会非常糟糕。然后在SO中看到了一个JDK7+的方法: try (BufferedReader br = new BufferedReader(new FileReader(path))) { return br.readLine();
java finally close_[Java教程]Java的file.close()放在finally代码块报错_星空网
weixin_39676633的博客
02-16 412
Java的file.close()放在finally代码块报错2017-02-230在学习Java的IO部分时有如下代码：import java.io.*;public class InputFile { public static void main(String [] args){ int a = 0; FileInputStream file = null; try { ...
java在finally中关闭资源_Java try/catch/finally获取/关闭资源时的最佳实践
weixin_33195817的博客
03-08 503
如果你想捕获和报告所有的异常源，一个更好的解决方案是：ObjectOutputStream oos = null;try {oos = new ObjectOutputStream(new FileOutputStream(file));oos.writeObject(shapes);oos.flush();} catch (FileNotFoundException ex) {// compla...
java在finally中关闭资源_java7与java9中的try-finally关闭资源
weixin_30284125的博客
03-08 221
1.java7中的try在java7之前,对于一些需要使用finally关闭资源的操作,会显得很臃肿.try{//}catch(Exception e){//}finally{if(xxxx != null){xxxx.close();}}在java7中引入了可以在try中直接声明需要关闭的资源的功能,在try后的圆括号直接定义一个或多个资源即可.try(var xxx = new xxx();v...
java try catch finally finally 执行的插入会被事务回滚么
最新发布
09-07
在 Java 中，如果你使用了事务管理框架（如 Spring 的声明式事务），并且在 try 块中执行了数据库插入操作，如果在 catch 块中捕获了异常并且抛出了新的异常，或者在 finally 块中抛出了异常，那么事务管理框架通常...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值