深入理解 Java try-with-resource 语法糖

最新推荐文章于 2024-05-10 14:28:28 发布
最新推荐文章于 2024-05-10 14:28:28 发布
阅读量1.4k 收藏 4
点赞数 2
分类专栏： java

原文：https://juejin.im/entry/57f73e81bf22ec00647dacd0


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

在Java的江湖中，存在着一种名为finally的功夫，它可以保证当你习武走火入魔之时，还可以做一些自救的操作。在远古时代，处理资源关闭的代码通常写在finally块中。然而，如果你同时打开了多个资源，那么将会出现噩梦般的场景：

public class Demo {
    public static void main(String[] args) {
        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")));
            int b;
            while ((b = bin.read()) != -1) {
                bout.write(b);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            if (bin != null) {
                try {
                    bin.close();
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
                finally {
                    if (bout != null) {
                        try {
                            bout.close();
                        }
                        catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

Oh My God！！！关闭资源的代码竟然比业务代码还要多！！！这是因为，我们不仅需要关闭BufferedInputStream，还需要保证如果关闭BufferedInputStream时出现了异常， BufferedOutputStream也要能被正确地关闭。所以我们不得不借助finally中嵌套finally大法。可以想到，打开的资源越多，finally中嵌套的将会越深！！！

更为可恶的是，Python程序员面对这个问题，竟然微微一笑很倾城地说：“这个我们一点都不用考虑的嘞~”：

但是兄弟莫慌！我们可以利用Java 1.7中新增的try-with-resource语法糖来打开资源，而无需码农们自己书写资源来关闭代码。妈妈再也不用担心我把手写断掉了！我们用try-with-resource来改写刚才的例子：

public class TryWithResource {
    public static void main(String[] args) {
        try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("test.txt")));
             BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt")))) {
            int b;
            while ((b = bin.read()) != -1) {
                bout.write(b);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

是不是很简单？是不是很刺激？再也不用被Python程序员鄙视了！好了，下面将会详细讲解其实现原理以及内部机制。

动手实践

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

public class Connection implements AutoCloseable {
    public void sendData() {
        System.out.println("正在发送数据");
    }
    @Override
    public void close() throws Exception {
        System.out.println("正在关闭连接");
    }
}

调用类：

public class TryWithResource {
    public static void main(String[] args) {
        try (Connection conn = new Connection()) {
            conn.sendData();
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行后输出结果：

正在发送数据
正在关闭连接

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

原理

那么这个是怎么做到的呢？我相信聪明的你们一定已经猜到了，其实，这一切都是编译器大神搞的鬼。我们反编译刚才例子的class文件：

public class TryWithResource {
    public TryWithResource() {
    }
    public static void main(String[] args) {
        try {
            Connection e = new Connection();
            Throwable var2 = null;
            try {
                e.sendData();
            } catch (Throwable var12) {
                var2 = var12;
                throw var12;
            } finally {
                if(e != null) {
                    if(var2 != null) {
                        try {
                            e.close();
                        } catch (Throwable var11) {
                            var2.addSuppressed(var11);
                        }
                    } else {
                        e.close();
                    }
                }
            }
        } catch (Exception var14) {
            var14.printStackTrace();
        }
    }
}

看到没，在第15~27行，编译器自动帮我们生成了finally块，并且在里面调用了资源的close方法，所以例子中的close方法会在运行的时候被执行。

异常屏蔽

我相信，细心的你们肯定又发现了，刚才反编译的代码（第21行）比远古时代写的代码多了一个addSuppressed。为了了解这段代码的用意，我们稍微修改一下刚才的例子：我们将刚才的代码改回远古时代手动关闭异常的方式，并且在sendData和close方法中抛出异常：

public class Connection implements AutoCloseable {
    public void sendData() throws Exception {
        throw new Exception("send data");
    }
    @Override
    public void close() throws Exception {
        throw new MyException("close");
    }
}

修改main方法：

public class TryWithResource {
    public static void main(String[] args) {
        try {
            test();
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }
    private static void test() throws Exception {
        Connection conn = null;
        try {
            conn = new Connection();
            conn.sendData();
        }
        finally {
            if (conn != null) {
                conn.close();
            }
        }
    }
}

运行之后我们发现：

basic.exception.MyException: close
	at basic.exception.Connection.close(Connection.java:10)
	at basic.exception.TryWithResource.test(TryWithResource.java:82)
	at basic.exception.TryWithResource.main(TryWithResource.java:7)
	......

好的，问题来了，由于我们一次只能抛出一个异常，所以在最上层看到的是最后一个抛出的异常——也就是close方法抛出的MyException，而sendData抛出的Exception被忽略了。这就是所谓的异常屏蔽。由于异常信息的丢失，异常屏蔽可能会导致某些bug变得极其难以发现，程序员们不得不加班加点地找bug，如此毒瘤，怎能不除！幸好，为了解决这个问题，从Java 1.7开始，大佬们为Throwable类新增了addSuppressed方法，支持将一个异常附加到另一个异常身上，从而避免异常屏蔽。那么被屏蔽的异常信息会通过怎样的格式输出呢？我们再运行一遍刚才用try-with-resource包裹的main方法：

java.lang.Exception: send data

	at basic.exception.Connection.sendData(Connection.java:5)
	at basic.exception.TryWithResource.main(TryWithResource.java:14)
	......
	Suppressed: basic.exception.MyException: close
		at basic.exception.Connection.close(Connection.java:10)
		at basic.exception.TryWithResource.main(TryWithResource.java:15)
		... 5 more

可以看到，异常信息中多了一个Suppressed的提示，告诉我们这个异常其实由两个异常组成，MyException是被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()的代码，这样肯定能够保证真正的流被关闭。


还不够
关注
专栏目录
try-with-resource语法糖优化
Jk_zhangjm的博客
09-24 297
//实际方法 //现在是一个嵌套try，并且还是未进行优化的关流 public void saveMessage(String keycde,String xmlStr,String type,String fromStr) throws PublicException{ Connection conn = null; PreparedStatement state = null; try { try { conn = this.commonDao.getNewConnection(); } catch (
来尝尝try-with-resouces语法糖(JDK版本17)
LINchuana的博客
07-17 1083
语法糖与常用try-catch的抉择与割舍
深入理解Java try-with-resource
switch513的博客
10-10 972
背景 众所周知，所有被打开的系统资源，比如流、文件或者Socket连接等，都需要被开发者手动关闭，否则随着程序的不断运行，资源泄露将会累积成重大的生产事故。 在Java的江湖中，存在着一种名为finally的功夫，它可以保证当你习武走火入魔之时，还可以做一些自救的操作。在远古时代，处理资源关闭的代码通常写在finally块中。然而，如果你同时打开了多个资源，那么将会出现噩梦般的场景：
深入理解 Java 中的 try-with-resource
火龙王Z
12-14 287
文章结茧自：深入理解 Java 中的 try-with-resource 在java1.7之后，新增try-with-resource 方式方法，解决了原始的finally收到释放资源可能出现多层嵌套等弊端。 try-with-resource的实现 首先必须在其资源类上实现AutoClosable接口public class Connection implements AutoCloseab
try...with...resource语法糖
QQ156881887的专栏
12-04 534
这是为减少程序员的工作量，而设计的语法。对于执行器而言，要做的功能并没有变化，只是在编写程序时代码量减少了。 3、简化写法 4、说明 这种简化写法，仅对需要在 finally 结构中关闭资源的代码适用，且该资源类需要继承 Closeable 接口。 在编写程序时起到少写代码的作用，但是编译后的class文件中，其实是由编译器对 finally 语句进行了填充。 在关闭资源时，如果打开资源较多，人为判断容易遗漏，可借由编译器代为完成。 5、代码示例 编译后的class文件
try_with_resource语法糖
杨杨杨~~的博客
03-21 424
文章目录前言try_with_resource语法糖01 目的02 语法03 实例 前言   如果您觉得有用的话，记得给博主点个赞，评论，收藏一键三连啊，写作不易啊^ _ ^。   而且听说点赞的人每天的运气都不会太差，实在白嫖的话，那欢迎常来啊!!! try_with_resource语法糖 01 目的 try-with-resource是JDK7引入的语法糖，可以简化Autocloseable资源类的关闭过程,方便了我们资源的代码编写。 02 语法 不使用try-with-resource，一般采用f
深入理解Java基础之try-with-resource语法糖
08-26
Java try-with-resource 语法糖详解 Java try-with-resource 语法糖是 Java 1.7 中新增的一种语法糖，它主要用于简化资源的关闭操作。该语法糖可以自动关闭资源，无需开发者手动编写关闭代码，从而避免了资源泄露。...
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 ...
Java如何优雅地关闭资源try-with-resource及其异常抑制
08-26
本文将着重介绍 Java 中的 try-with-resource 语法和异常抑制机制，并探讨其实现原理。 背景 在 Java 编程过程中，如果打开了外部资源（文件、数据库连接、网络连接等），我们必须在这些外部资源使用完毕后，手动...
Java深度解析：try-with-resource语法糖
"深入理解Java基础之try-with-resource语法糖，该文旨在解析Java中的try-with-resource特性，帮助开发者更高效、安全地管理资源关闭。此特性旨在解决传统使用finally块进行资源清理时代码繁琐的问题。" 在Java编程...
Java基础之try-with-resource语法糖
热门推荐
江湖人称黑哥的博客
12-22 1万+
背景 在java开发中，一些网络链接或者是文件资源都需要程序员去手动调用close方法关闭，比如InputStream、OutputStream和java.sql.Connection。 如果忘关了就可能造成严重的性能后果。而关闭的方法有很多种。比如finalizer、try-catch-finally、try-with-resources等等。 try-with-resources try-with-resources是jdk1.7引入的语法糖，使得关闭资源操作无需层层嵌套在finally。 finali
try-with-resources 语法详解
qq_45110186的博客
02-05 1856
在Java 7中，引入了一项重要的语法糖——try-with-resources，这项特性的目的是为了更有效地处理资源的管理。资源指的是需要在代码执行完毕后手动关闭的对象，比如文件流、网络连接等。try-with-resources语法糖提供了一种更为简便、方便且安全的方式来确保这些资源在使用完成后得到适当的关闭。使用try-with-resources可以使得代码更加简洁，不再需要显式地编写finally块来手动关闭资源。
JAVA之语法糖
辛聪明的博客
09-04 1100
一、概念 编译器是一种计算机程序, 它主要的目的是将便于人编写、阅读、维护的高级计算机语言所写的源代码程序, 翻译为计算机能解读、运行的低阶机器语言的程序, 即可执行文件。而 javac 就是java语言中的编译器, 它用于将 .java 文件转换成JVM能识别的 .class 字节码文件, 反编译则是将 .class 文件转换成 .java 文件。 语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·兰丁发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能
Java语法糖 : try-with-resources
微信公众号：一颗向上的草莓
08-26 251
先了解几个背景知识 什么是语法糖 语法糖是在语言中增加的某种语法，在不影响功能的情况下为程序员提供更方便的使用方式。 什么是资源 使用之后需要释放或者回收的都可以称为资源，比如JDBC的connection连接，文件IO的各种类。 在这里我们可以简单理解为实现了 java.lang.AutoCloseable/java.io.Closeable接口的类对象。 回到正题，tr...
每日一学--Java语法糖 try-with-resources
qq_39273039的博客
07-23 495
文章目录语法糖资源try-with-resources使用对象使用示例内部实现 参考博客 语法糖 在语言中增加的某种语法，在不影响功能的情况下为程序员提供更方便的使用方式。 资源 使用之后需要释放或者回收的都可以称为资源，比如JDBC的connection连接，文件IO的各种类。 try-with-resources java的一个语法糖，在try语句中声明一个或者多个资源。 使用对象 实现了 java.lang.AutoCloseable/java.io.Closeable 的类对象 使用示例 try-c
try ...catch语法糖
weixin_42731977的博客
02-20 493
Java里try …catch语法糖的学习。
Java中的语法糖:让代码更加“甜美“ 什么是语法糖?
最新发布
赵KK的博客
05-10 642
首先,让我们来通俗地解释一下什么是"语法糖"。"语法糖"这个概念最初是由Peter J. Landin在1964年提出的。它指的是编程语言中为了更好地编写代码而添加的一些语法,这些语法并不影响程序的底层逻辑,但能够大大提高代码的可读性和编写效率。简单地说,“语法糖"就是一种语法上的"语法糖”。它让代码变得更加"甜美"、更加易于编写和阅读。但是,这些"语法糖"最终会被编译器或解释器转换成更加底层的代码,因此它们并不会改变程序的本质行为。比如在Java中,我们经常会使用诸如for-each循环、等语法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值