Java新特性-try-with-resource

最新推荐文章于 2024-08-25 10:25:19 发布
最新推荐文章于 2024-08-25 10:25:19 发布
阅读量1.7k 收藏 1
点赞数
分类专栏： Java新特性 文章标签： java7增强try 异常处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28988969/article/details/77364810
版权

在我们的项目中,所有被打开的系统资源，比如流、文件或者Socket连接等，都需要被开发者手动关闭，否则随着程序的不断运行，资源泄露将会累积成重大的生产事故。

传统的try

语法

try{
    //进行可能出现异常的操作
}catch(捕获的异常名称){
    //进行异常处理
}finally{
    //关闭资源操作
}

实例代码如下:

public static void try1() {
        BufferedInputStream bin = null;
        BufferedOutputStream bout = null;
        try {
            bin = new BufferedInputStream(new FileInputStream(new File("test.txt")));
            bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt")));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bin != null) {
                try {
                    bin.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bout != null) {// 确保即使BufferedInputStream在执行close()方法时发生异常,也执行BufferedOutputStream的close()方法
                try {
                    bout.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
  • 使用finally块来关闭物理资源，保证关闭操作总是会被执行。
  • 关闭每个资源之前首先保证引用该资源的引用变量不为null。
  • 为每一个物理资源使用单独的try…catch块来关闭资源，保证关闭资源时引发的异常不会影响其他资源的关闭。
  • 以上方式导致finally块代码十分臃肿,关闭资源的代码比业务代码还要多，程序的可读性降低。

java7增强try

为了解决以上传统方式的问题， Java7新增了自动关闭资源的try语句。它允许在try关键字后紧跟一对圆括号，里面可以声明、初始化一个或多个资源，此处的资源指的是那些必须在程序结束时显示关闭的资源（数据库连接、网络连接等），try语句会在该语句结束时自动关闭这些资源。

语法

try(初始化可能出现异常的操作){
    //进行操作
}ctach(捕获的异常名称){
    //进行异常操作
}

打开一个资源

try(
    打开一个资源的语句;//末尾可以加";",也可以不加
){
    //进行操作
}

打开多个资源

try(
    打开一个资源的语句;
    打开一个资源的语句;
    打开一个资源的语句;//多个表达式末尾加";",最后一个表达式末尾可以不加";"
){
    //进行操作
}

改写以上代码如下:

    //捕获异常
    public static void try2() {
        try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("test.txt")));
                BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt")));) {
            // 执行完try中的语句过后,资源自动关闭
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

或者

    //抛出异常
    public static void try2() throws FileNotFoundException, IOException {
        try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("test.txt")));
                BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt")));) {
            // 执行完try中的语句过后,资源自动关闭
        }
    }

自动关闭资源的try语句相当于包含了隐式的finally块（用于关闭资源），因此这个try语句可以既没有catch块，也没有finally块。

动手测试

为了能够配合try-with-resource，资源必须实现AutoCloseable接口。且该接口的实现类需要重写close方法：

package tryTest;

/**
 * 
 * @ClassName: Connection
 * @Description: 创建实例,实现AutoCloseable接口
 * @author cheng
 * @date 2017年8月18日 上午9:37:11
 */
public class Connection implements AutoCloseable {

    public void sendData() throws Exception {
        System.out.println("正在发送数据........");
    }

    /**
     * 重写close方法
     */
    @Override
    public void close() throws Exception {
        System.out.println("正在自动关闭连接........");
    }

}

测试

    public static void try3() {
        try (Connection conn = new Connection();) {
            conn.sendData();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

运行结果:

正在发送数据........
正在自动关闭连接........

通过结果我们可以看到，close方法被自动调用了。

异常屏蔽处理

修改Connection,模拟抛出异常

package tryTest;

/**
 * 
 * @ClassName: Connection
 * @Description: 创建实例,实现AutoCloseable接口
 * @author cheng
 * @date 2017年8月18日 上午9:37:11
 */
public class Connection implements AutoCloseable {

    public void sendData() throws Exception {
        System.out.println("正在发送数据........");
        throw new Exception("模拟发送时发生了异常.....");
    }

    /**
     * 重写close方法
     */
    @Override
    public void close() throws Exception {
        System.out.println("正在自动关闭连接........");
        throw new Exception("模拟关闭时发生了异常.....");
    }

}

使用传统的try,手动关闭异常

    public static void try5() throws Exception {
        Connection conn = null;
        try {
            conn = new Connection();
            conn.sendData();
        } finally {
            if (conn != null) {
                conn.close();
            }
        }
    }

调用:

    public static void main(String[] args) {
        try {
            try5();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

运行结果:

正在发送数据........
正在自动关闭连接........
java.lang.Exception: 模拟关闭时发生了异常.....
    at tryTest.Connection.close(Connection.java:23)
    at tryTest.TryTest.try5(TryTest.java:40)
    at tryTest.TryTest.main(TryTest.java:26)

好的，问题来了，由于我们一次只能抛出一个异常，所以在最上层看到的是最后一个抛出的异常——也就是close方法抛出的模拟异常，而sendData抛出的Exception被忽略了。这就是所谓的异常屏蔽。

由于异常信息的丢失，异常屏蔽可能会导致某些bug变得极其难以发现，程序员们不得不加班加点地找bug.

为了解决这个问题，从Java 1.7开始，大佬们为Throwable类新增了addSuppressed方法，支持将一个异常附加到另一个异常身上，从而避免异常屏蔽。那么被屏蔽的异常信息会通过怎样的格式输出呢？我们再运行一遍刚才用try-with-resource包裹的main方法：

    public static void try3() {
        try (Connection conn = new Connection();) {
            conn.sendData();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

运行结果:

正在发送数据........
正在自动关闭连接........
java.lang.Exception: 模拟发送时发生了异常.....
    at tryTest.Connection.sendData(Connection.java:14)
    at tryTest.TryTest.try3(TryTest.java:59)
    at tryTest.TryTest.main(TryTest.java:23)
    Suppressed: java.lang.Exception: 模拟关闭时发生了异常.....
        at tryTest.Connection.close(Connection.java:23)
        at tryTest.TryTest.try3(TryTest.java:60)
        ... 1 more

可以看到，异常信息中多了一个Suppressed的提示，告诉我们这个异常其实由两个异常组成.

打开多个资源时:单独声明每个资源

在使用try-with-resource的过程中，一定需要了解资源的close方法内部的实现逻辑。否则还是可能会导致资源泄露。

比如，在Java BIO中采用了大量的装饰器模式。当调用装饰器的close方法时，本质上是调用了装饰器内部包裹的流的close方法。比如：

public class TryWithResource {
    public static void main(String[] args) {
        try (FileInputStream fin = new FileInputStream(new File("input.txt"));
                GZIPOutputStream out = new GZIPOutputStream(new FileOutputStream(new File("out.txt")))) {
            byte[] buffer = new byte[4096];
            int read;
            while ((read = fin.read(buffer)) != -1) {
                out.write(buffer, 0, read);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，我们从FileInputStream中读取字节，并且写入到GZIPOutputStream中。GZIPOutputStream实际上是FileOutputStream的装饰器。由于try-with-resource的特性，实际编译之后的代码会在后面带上finally代码块，并且在里面调用fin.close()方法和out.close()方法。我们再来看GZIPOutputStream类的close方法：

public void close() throws IOException {
    if (!closed) {
        finish();
        if (usesDefaultDeflater)
            def.end();
        out.close();
        closed = true;
    }
}

我们可以看到，out变量实际上代表的是被装饰的FileOutputStream类。在调用out变量的close方法之前，GZIPOutputStream还做了finish操作，该操作还会继续往FileOutputStream中写压缩信息，此时如果出现异常，则会out.close()方法被略过，然而这个才是最底层的资源关闭方法。正确的做法是应该在try-with-resource中单独声明最底层的资源，保证对应的close方法一定能够被调用。在刚才的例子中，我们需要单独声明每个FileInputStream以及FileOutputStream：

public class TryWithResource {
    public static void main(String[] args) {
        try (FileInputStream fin = new FileInputStream(new File("input.txt"));
                FileOutputStream fout = new FileOutputStream(new File("out.txt"));
                GZIPOutputStream out = new GZIPOutputStream(fout)) {
            byte[] buffer = new byte[4096];
            int read;
            while ((read = fin.read(buffer)) != -1) {
                out.write(buffer, 0, read);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

由于编译器会自动生成fout.close()的代码，这样肯定能够保证真正的流被关闭。

总结:同时打开多个资源时,单独声明每个资源!

注意

  • 被自动关闭的资源必须实现Closeable或AutoCloseable接口。（Closeable是AutoCloseable的子接口，Closeable接口里的close()方法声明抛出了IOException,;AutoCloseable接口里的close()方法声明抛出了Exception）
  • 被关闭的资源必须放在try语句后的圆括号中声明、初始化。如果程序有需要自动关闭资源的try语句后可以带多个catch块和一个finally块。
  • Java7几乎把所有的“资源类”（包括文件IO的各种类，JDBC编程的Connection、Statement等接口……）进行了改写，改写后的资源类都实现了AutoCloseable或Closeable接口

AutoCloseable 源码:

package java.lang;

public interface AutoCloseable {

    void close() throws Exception;

}

Closeable源码:

package java.lang;

public interface Closeable implements AutoCloseable {

    void close() throws IOException;

}

若我们在try中打开的资源类没有实现AutoCloseable接口或者Closeable接口,则会报以下错误:

The resource type Connection does not implement java.lang.AutoCloseable

捕获多个异常

当我们操作一个对象的时候,它有时候会抛出多个异常,例如:

    public static void try6() {
        try {
            Thread.sleep(20000);
            FileInputStream fis = new FileInputStream("/a/b,txt");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

这样写起来很繁琐,java7优化后代码如下:

    public static void try7() {
        try {
            Thread.sleep(20000);
            FileInputStream fis = new FileInputStream("/a/b,txt");
        } catch (InterruptedException | FileNotFoundException e) {
            e.printStackTrace();
        }
    }

并且catch语句后面的异常参数是final的,不可以再修改

处理反射异常

java7之前使用反射时会有许多需要处理的异常,代码如下:

    public static void try7() {
        Object object = null;
        Class<?> clazz;
        try {
            clazz = Class.forName("tryTest.Connection");
            clazz.getMethods()[0].invoke(object);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
    }

尽管可以使用上面提到的捕获多个异常技术进行改良,

    public static void try7() {
        Object object = null;
        Class<?> clazz;
        try {
            clazz = Class.forName("tryTest.Connection");
            clazz.getMethods()[0].invoke(object);
        } catch (ClassNotFoundException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
                | SecurityException e) {
            e.printStackTrace();
        }
    }

但还是十分繁琐,java7引入了新的ReflectiveOperationException 异常类,帮助我们捕获反射异常

    public static void try7() {
        Object object = null;
        Class<?> clazz;
        try {
            clazz = Class.forName("tryTest.Connection");
            clazz.getMethods()[0].invoke(object);
        } catch (ReflectiveOperationException e) {
            e.printStackTrace();
        }
    }
写写代码AAA
关注
专栏目录
java 7新特性-TWR(Try-with-resources)
ty_laurel的博客
03-05 9010
在java 7之前，一般在进行文件IO操作时都需要显式的进行文件流的close操作，无论是操作到文件流末尾还是发生异常。往往很简单的一个逻辑都要好几行的代码进行修饰，使得代码结构变的复杂。 如下程序就使用了TWR，避免了java 7之前使用finally块时的繁琐，使得程序变得简洁 package javaFile.copyfile; import java.io.FileInputStre
java try with_Java使用try-with
weixin_33164837的博客
02-12 3075
在Java编程过程中，如果打开了外部资源(文件、数据库连接、网络连接等)，我们必须在这些外部资源使用完毕后，手动关闭它们。 (推荐学习：java课程)因为外部资源不由JVM管理，无法享用JVM的垃圾回收机制，如果我们不在编程时确保在正确的时机关闭外部资源，就会导致外部资源泄露，紧接着就会出现文件被异常占用，数据库连接过多导致连接池溢出等诸多很严重的问题。为了确保外部资源一定要被关闭，通常关闭...
Java7 新特性：try() 语句 即 try-with-resources
大树叶 技术专栏
01-13 1万+
Try-with-resources是java7中一个新的异常处理机制，它能够很容易地关闭在try-catch语句块中使用的资源。 利用Try-Catch-Finally管理资源（旧的代码风格） 在java7以前，程序中使用的资源需要被明确地关闭，这个体验有点繁琐。 下面的方法读取文件，然后用System.out打印： 01 private
java7新特性之Try-with-resources (TWR)
nobody
03-16 6058
java7新特性之Try-with-resources (TWR) This change is easy to explain, but it has proved to have hidden subtleties, which made it much less easy to implement than originally hoped. The basic idea is
为什么说 与try-finally相比，首选try-with-resources
最新发布
学Java，找哪吒
08-25 957
华为OD机试 2023B卷题库疯狂收录中，刷题。
java trywithresources_Java try…with…resources示例
weixin_39686192的博客
02-27 157
Java 7提供一个新的功能之一就是用于自动资源管理的try-with-resources语句。资源是一个在使用它完成程序后必须关闭的对象。例如，数据库连接的文件资源或JDBC资源或Socket连接资源。在Java 7之前，没有自动资源管理，程序员在完成工作后明确关闭资源。通常，它是在try-catch语句的finally块中完成的。当我们忘记关闭资源时，这种方法会导致内存泄漏和性能损失。下面来看...
深入理解Java基础之try-with-resource语法糖
08-26
Java try-with-resource 语法糖详解 Java try-with-resource 语法糖是 Java 1.7 中新增的一种语法糖，它主要用于简化资源的关闭操作。该语法糖可以自动关闭资源，无需开发者手动编写关闭代码，从而避免了资源泄露。...
Java如何优雅地关闭资源try-with-resource及其异常抑制
08-26
Java 如何优雅地关闭资源 try-with-resource 及其异常抑制 Java 中关闭资源的重要性不能被夸张，毕竟外部资源的泄露可能会导致文件被异常占用、数据库连接过多、连接池溢出等严重的问题。因此，了解如何优雅地关闭...
Java try-with-resource语法使用解析
08-19
public class TryWithResource { public static void main(String[] args) { try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("test.txt"))); BufferedOutputStream bout ...
try - with - resources详解
热门推荐
抽象的螺旋
07-14 2万+
概述 try-with-resources自JDK7引入，在JDK9中进行了改进，使得用户可以更加方便、简洁的使用try-with-resources。 JDK7之前资源需要手动关闭 下面是一个常见的文件资源关闭的示例： BufferedWriter writer = null; try { writer = Files.newBufferedWriter(file, charset); writer.write(s, 0, s.length()); } catch (IOException
JAVA JDK1.7 try-with-resources 特性理解分析
qrn196789910的博客
07-15 285
我们都知道，在执行 io 操作时都需要在执行finally 里面进行 colse 方法进行 关闭流，这样可以出现 资源出现占用等一系列问题，在jdk1.7中出现了try-with-resources 特性帮助我们做了这些事情，我们先来看看 api文档对特性的描述 jdk文档try-with-resources特性描述 文档中给出了几个实例，我们先来看看前面2个实例就可以很好的看出了try-with-resources 特性 ： static String readFirstLineFromFile(Stri
java try with_Java Try with Resources
weixin_39815345的博客
02-24 54
资源是一个程序利用后必须关闭的对象。 例如，用于数据库连接的文件资源或JDBC资源或套接字连接资源。 在Java7之前，没有自动资源管理，我们应该在我们的工作完成后明确地关闭资源。 通常，它是在try-catch语句的finally块中完成的。 当我们忘记关闭资源时，这种方法会导致内存泄漏和性能问题。before Java 7：try{//open resources like File, Dat...
java try with_Java try-with-resource
weixin_32672201的博客
02-12 314
背景众所周知，所有被打开的系统资源，比如流、文件或者Socket连接等，都需要被开发者手动关闭，否则随着程序的不断运行，资源泄露将会累积成重大的生产事故。在Java的江湖中，存在着一种名为finally的功夫，它可以保证当你习武走火入魔之时，还可以做一些自救的操作。在远古时代，处理资源关闭的代码通常写在finally块中。然而，如果你同时打开了多个资源，那么将会出现噩梦般的场景：public cl...
java try with_Java 7中的Try-with-resources
weixin_42298164的博客
02-12 138
原文链接 作者：Jakob Jenkov 译者：fangqiang08(fangqiang08@gmail.com)Try-with-resources是java7中一个新的异常处理机制，它能够很容易地关闭在try-catch语句块中使用的资源。利用Try-Catch-Finally管理资源(旧的代码风格)在java7以前，程序中使用的资源需要被明确地关闭，这个体验有点繁琐。下面的方法读取文件，然...
Java try-with-resources 特性详解
leileiluoluo的博客
04-15 1129
本文首先介绍了在 try-with-resources 特性引入前，资源的关闭如何做的；然后介绍了 try-with-resources 特性如何使用，以及其带来的好处；最后介绍了 Java 9 对 try-with-resources 特性的增强以及自定义 AutoClosable 资源的实现。
try_with_resource关闭流
智障少年木易
10-08 2072
try_with_resource转载自背景众所周知，所有被打开的系统资源，比如流、文件或者Socket连接等，都需要被开发者手动关闭，否则随着程序的不断运行，资源泄露将会累积成重大的生产事故。在Java的江湖中，存在着一种名为finally的功夫，它可以保证当你习武走火入魔之时，还可以做一些自救的操作。在远古时代，处理资源关闭的代码通常写在finally块中。然而，如果你同时打开了多个资源，那么将
【Java】JAVA使用字节流读写文件操作及try-with-resourse自动资源管理操作
Veni的博客
03-30 1997
java import java.io.*; public class ShowFile { public static void main(String[] args) { int i; String filename = "1.txt"; //要打开文件的名称 FileInputStream fin=null; //fin初始化为空 ...
java8 try resource_java try with resource
weixin_34274163的博客
02-27 222
你可以在块中使用多个资源而且这些资源都能被自动地关闭。下面是例子：private static void printFileJava7() throws IOException {try( FileInputStream input = new FileInputStream("file.txt");BufferedInputStream bufferedInput = ...
Java 异常处理
Charge8的博客
07-28 553
1、java 异常 异常指不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。 异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程。 Java通过API中 Throwable 类的众多子类描述各种不同的异常。因而，Java异常都是对象，是Throwable子类的实例，描述了出现在一段编码中的 错误条件。当条件生成时，错误将引发异常。 Java异常类层次结...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值