blocks|key|508112|text|将其封装在如下的接口中如何：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|508113|class+ManagedExceptionEnvironment+{
++++public+static+void+safeExecution(Wrapper+w)+{
++++++++try+{
++++++++++++w.codeThatThrows();
++++++++}+catch+(Exception+e)+{
++++++++++++//+your+error+handling
++++++++}
++++}


++++public+static+void+example()+{
++++++++safeExecution(()+->+{+throw+new+Exception();+});
++++++++//+Or+the+old-fashioned+way:
++++++++safeExecution(new+Wrapper()+{
++++++++++++@Override
++++++++++++public+void+codeThatThrows()+throws+Exception+{
++++++++++++++++throw+new+Exception();
++++++++++++}
++++++++});
++++}

++++interface+Wrapper+{
++++++++public+void+codeThatThrows()+throws+Exception;
++++}
}|code-block|syntax|javascript|508114|诀窍是类似于Runnable.run()的方法指定它可能抛出异常，而run()不抛出异常。|offset|length|style|CODE|508115|entityMap^0|0|0|6|E|Y|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

How about wrapping it in an interface like this:

<pre><code>class ManagedExceptionEnvironment {
 public static void safeExecution(Wrapper w) {
 try {
 w.codeThatThrows();
 } catch (Exception e) {
 // your error handling
 }
 }


 public static void example() {
 safeExecution(() -&gt; { throw new Exception(); });
 // Or the old-fashioned way:
 safeExecution(new Wrapper() {
 @Override
 public void codeThatThrows() throws Exception {
 throw new Exception();
 }
 });
 }

 interface Wrapper {
 public void codeThatThrows() throws Exception;
 }
}
</code></pre>

The trick is that the method that is analogous to <code>Runnable.run()</code> specifies that it may throw an Exception whereas <code>run()</code> does not.

blocks|key|204146|text|您可以将异常作为接口/类/方法的(泛型)签名的一部分。请参见我的问题(+How+to+not+throw+a+generically+specified+exception?+)作为示例。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|204147|例如，您可以将其命名为"newInstance()“，而不是调用该方法"process()”。然后围绕它创建一个类型安全处理程序。客户端只需传递lambda表达式即可。|204148|基本上定义您自己的包装器(如另一个答案所示:-)|204149|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/51612250/how-to-not-throw-a-generically-specified-exception^0|10|1F|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

You can make exceptions part of the (generic) signature of your interface / class / method. See my question ( <a href="https://stackoverflow.com/questions/51612250/how-to-not-throw-a-generically-specified-exception">How to not throw a generically specified exception?</a> ) as example. 

Instead of calling the method "newInstance()" you could name it "process()" for example. And then create a type safe handler around that. And clients simply pass lambda expressions around.

Basically defining your own wrapper (as shown in the other answer :-)

blocks|key|204138|text|除非ManagedExceptionEnvironment打算扩展一些现有的类，否则在这里使用Java类而不是static方法是没有价值的。所以，你可以这样写：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|204139|public+static+<T>+T+boomProtector(Callable<T>+thingThatMightGoBoom)+{
++try+{
++++return+thingThatMightGoBoom.call();
++}
++catch(Exception+e)+{
++++//+TODO:+your+standard+catch+logic
++}

++return+null;
}|code-block|syntax|javascript|204140|然后，在您需要它的地方，您可以调用：|204141|Whatever+result+=+boomProtector(()+->+earthShatteringKaboom());|204142|其中Whatever是earthShatteringKaboom()返回的类型。如果earthShatteringKaboom()返回一个对象，您将在result中获取它。如果抛出异常，则执行您的标准捕获逻辑，并且result为null。|204143|(注意:我展示了示例boomProtector()调用的Java8语法，您需要在项目中启用它，例如通过Android+Studio中的文件>项目设置>应用程序-或者使用Callable<T>的匿名内部类实现)|204144|entityMap^0|2|R|1J|6|0|0|0|0|2|8|B|N|16|N|23|6|2Z|6|36|4|0|A|F|2C|B|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1F|8|@$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|T|$]]

Unless <code>ManagedExceptionEnvironment</code> was going to extend some existing class, there is no value in using a Java class here as opposed to a <code>static</code> method. So, you could write:

<pre><code>public static &lt;T&gt; T boomProtector(Callable&lt;T&gt; thingThatMightGoBoom) {
 try {
 return thingThatMightGoBoom.call();
 }
 catch(Exception e) {
 // TODO: your standard catch logic
 }

 return null;
}
</code></pre>

Then, where you need it, you can call:

<pre><code>Whatever result = boomProtector(() -&gt; earthShatteringKaboom());
</code></pre>

where <code>Whatever</code> is the type that <code>earthShatteringKaboom()</code> returns. If <code>earthShatteringKaboom()</code> returns an object, you get it in <code>result</code>. If it throws an exception, your standard catch logic is executed and <code>result</code> is <code>null</code>.

(note: I am showing Java 8 syntax for the sample <code>boomProtector()</code> call, which you will need to enable in your project, such as via File > Project Settings > app in Android Studio &mdash; or, use an anonymous inner class implementation of <code>Callable&lt;T&gt;</code>)

I have a lot of code with <code>try</code>/<code>catch</code> and in almost all cases I take the same action. What I want to do is simplify my error handling by creating something where I can just say

<pre><code>ManagedExceptionEnvironment() {
 // The code that might throw exceptions
}
</code></pre>

And then inside of <code>ManagedExceptionEnvironment</code> it has the shared error handling logic.

My initial thought on this was to have <code>ManagedExceptionEnvironment</code>'s constructor take a <code>Runnable</code>, but if you put logic that might throw an exception inside an anonymous <code>Runnable</code>'s <code>run</code> method then it still complains about not implementing <code>try</code>/<code>catch</code> even if the container you're passing it to would have taken care of it. 

I suppose another option is to only handle the errors at the highest level and have them keep getting thrown up another level, though that seems rather risky. 

Edit: I guess one option here (and I don't know if this is a thing in Java) is some kind of macro?

Edit 2: Just did some cursory reading on using the C pre-processor to inject macros into Java src and that is really horrifying. So macros are out as a solution.

Create exception safe execution wrapper in Java

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我用try/catch编写了很多代码，几乎在所有情况下我都会采取相同的操作。我想要做的是通过创建一些东西来简化我的错误处理，我可以这样说ManagedExceptionEnvironment() {    // The code that might throw exceptions}然后在ManagedExcepti...

问在Java中创建异常安全执行包装器
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中创建异常安全执行包装器EN