首页 / JAVA / java7新特性之Try-with-resources (TWR)

java7新特性之Try-with-resources (TWR)

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了java7新特性之Try-with-resources (TWR)，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5335字，纯文字阅读大概需要8分钟。

内容图文

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 to allow
a resource (for example, a file or something a bit like one) to be scoped to a block in
such a way that the resource is automatically closed when control exits the block.
This is an important change, for the simple reason that virtually no one gets manual resource closing 100 percent right. Until recently, even the reference how-tos from Sun were wrong. The proposal submitted to Project Coin for this change
includes the astounding claim that two-thirds of the uses of close() in the JDK had
bugs in them!
Fortunately, compilers can be made to produce exactly the sort of pedantic, boilerplate code that humans so often get wrong, and that’s the approach taken by this change.
This is a big help in writing error-free code. To see just how helpful, consider how
you’d write a block of code that reads from a stream coming from a URL (url) and
writes to a file (out) with Java 6. Here’s one possible solution.
 技术分享


How close did you get? The key point here is that when handling external resources,
Murphy’s Law applies—anything can go wrong at any time:
■ The InputStream can fail to open from the URL, to read from it, or to close
properly.
■ The File corresponding to the OutputStream can fail to open, to write to it, or
to close properly.
■ A problem can arise from some combination of more than one factor.
This last possibility is where a lot of the headaches come from—a combination of
exceptions is very difficult to deal with well.
This is the main reason for preferring the new syntax—it’s much less error-prone.
The compiler isn’t susceptible to the mistakes that every developer will make when trying to write this type of code manually.


Let’s look at the Java 7 code for performing the same task as listing 1.3. As before, url
is a URL object that points at the entity you want to download, and file is a File object
where you want to save what you’re downloading. Here’s what this looks like in Java 7. 
try (OutputStream out = new FileOutputStream(file);
InputStream is = url.openStream() ) {
byte[] buf = new byte[4096];
int len;
while ((len = is.read(buf)) > 0) {
out.write(buf, 0, len);
}
}

This basic form shows the new syntax for a block with automatic management—the
try with the resource in round brackets. For C# programmers, this is probably a bit
reminiscent of a using clause, and that’s a good conceptual starting point when working with this new feature. The resources are used by the block, and they’re automatically disposed of when you’re done with them.
You still have to be careful with try-with-resources, as there are cases where a
resource might still not be closed. For example, the following code would not close its
FileInputStream properly if there was an error creating the ObjectInputStream
from the file (someFile.bin).

try ( ObjectInputStream in = new ObjectInputStream(new
FileInputStream("someFile.bin")) ) {
...
}


Let’s assume that the file (someFile.bin) exists, but it might not be an ObjectInput
file, so the file might not open correctly. Therefore, the ObjectInputStream wouldn’t
be constructed and the FileInputStream wouldn’t be closed!
The correct way to ensure that try-with-resources always works for you is to split the
resources into separate variables.

try ( FileInputStream fin = new FileInputStream("someFile.bin");
ObjectInputStream in = new ObjectInputStream(fin) ) {
...
}

One other aspect of TWR is the appearance of enhanced stack traces and suppressed
exceptions. Prior to Java 7, exception information could be swallowed when handling
resources. This possibility also exists with TWR, so the stack traces have been enhanced
to allow you to see the type information of exceptions that would otherwise be lost.
For example, consider this snippet, in which a null InputStream is returned from
a method:
try(InputStream i = getNullStream()) {
i.available();
}

This will give rise to an enhanced stack trace, in which the suppressed NullPointerException (NPE for short) can be seen:
Exception in thread "main" java.lang.NullPointerException
at wgjd.ch01.ScratchSuprExcep.run(ScratchSuprExcep.java:23)
at wgjd.ch01.ScratchSuprExcep.main(ScratchSuprExcep.java:39)
Suppressed: java.lang.NullPointerException
at wgjd.ch01.ScratchSuprExcep.run(ScratchSuprExcep.java:24)
1 more

We encourage you to use try-with-resources as soon as you’re able, to eliminate unnecessary bugs from your codebase.


TWR and AutoCloseable
Under the hood, the TWR feature is achieved by the introduction of a new interface,
called AutoCloseable, which a class must implement in order to be able to appear
as a resource in the new TWR try clause. Many of the Java 7 platform classes have
been converted to implement AutoCloseable (and it has been made a superinterface of Closeable), but you should be aware that not every aspect of the platform
has yet adopted this new technology. It’s included as part of JDBC 4.1, though.
For your own code, you should definitely use TWR whenever you need to work with
resources. It will help you avoid bugs in your exception handling.


读书笔记：The Well-Grounded Java Develope

原文：http://blog.csdn.net/doctor_who2004/article/details/50901195

内容总结

以上是互联网集市为您收集整理的java7新特性之Try-with-resources (TWR)全部内容，希望文章能够帮你解决java7新特性之Try-with-resources (TWR)所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1289958.html

来源：【匿名】