相关疑难解决方法(0)

我需要创建一个库,在其中我将有同步和异步方法.

• executeSynchronous() - 等到我有结果,返回结果.
• executeAsynchronous() - 立即返回Future,如果需要,可在其他事情完成后处理.

我的图书馆的核心逻辑

客户将使用我们的库,他们将通过传递DataKey构建器对象来调用它.然后我们将使用该DataKey对象构造一个URL,并通过执行它来对该URL进行HTTP客户端调用,然后在我们将响应作为JSON字符串返回之后,我们将通过创建DataResponse对象将该JSON字符串发送回我们的客户.有些客户会打电话executeSynchronous(),有些人可能会打电话executeAsynchronous(),这就是为什么我需要在我的库中单独提供两种方法.

接口:

public interface Client {

    // for synchronous
    public DataResponse executeSynchronous(DataKey key);

    // for asynchronous
    public Future<DataResponse> executeAsynchronous(DataKey key);
}

然后我有我DataClient实现上面的Client接口:

public class DataClient implements Client {

    private RestTemplate restTemplate = new RestTemplate();
    // do I need to have all threads as non-daemon or I can have daemon thread for my use case?
    private ExecutorService executor = …

我偶然发现代码看起来像这样：

void run() {
    try {
        doSomething();
    } catch (Exception ex) {
        System.out.println("Error: " + ex);
        throw ex;
    }
}

void doSomething() {
    throw new RuntimeException();
}

这段代码使我感到惊讶，因为它看起来像run()-method能够抛出an Exception，因为它可以捕获Exception然后重新抛出它，但是该方法未声明为throw Exception，显然不需要。这段代码可以很好地编译（至少在Java 11中）。

我的期望是我必须throws Exception在run()-method中声明。

额外的信息

以类似的方式，如果doSomething被声明为throw，IOException那么即使被捕获并重新抛出，也只IOException需要在run()-method中声明Exception。

void run() throws IOException {
    try {
        doSomething();
    } catch (Exception ex) {
        System.out.println("Error: " + ex);
        throw ex;
    }
}

void doSomething() throws …

我有以下coffeescript代码:

try
   do something
catch error
   log something
   throw error

我应该用throw new Error(error)而不是throw error吗？

有什么不同？

要使用多种方法，我必须多次使用相同的检查异常catch（请参阅Java：checked vs uncheckedexception解释）。结果是重复的代码行。我想要某种减少重复异常的方法，catch以减少代码行数。

什么是减少重复catch节的数量并减少代码行的好方法？有什么方法可以catch在另一个文件中写入该操作并明确使用它？

基本上，我想减少行数，并使代码更简洁，更易于阅读。

这是我的代码示例：

@RequestMapping(value="")
public @ResponseBody Response addMultiple(){
if() {
    try {
        data = new weight();

    } 
    catch( AmazonServiceException se ){
        response = x;
    }
    catch (AmazonClientException ce) {
        response = y;
    }
    catch(JsonProcessingException je) {
        response = z;
    }
}


@RequestMapping(value="")
public @ResponseBody Response addMultiple2(){
if() {
    try {
        data = new height();

    } 
    catch( AmazonServiceException se ){
        response = x;
    }
    catch (AmazonClientException ce) { …

通常,有两种方法可以处理Java中的异常.

1. 在方法签名中添加throws声明
2. 使用try/catch块进行环绕.

但是,我注意到一些异常,特别是那些继承的异常,RuntimeException不需要这样的显式异常处理.

例如,我创建了一个如下所示的示例方法,并为不需要显式异常处理的方法标记为"Not required".

public void textException(){
    int i = (new Random()).nextInt(100);

    switch (i){
    case 1:
        throw new NullPointerException();   //Not required
    case 2:
        throw new NumberFormatException();  //Not required
    case 3:
        throw new RuntimeException();       //Not required
    case 4:         
        throw new ClassNotFoundException(); //Required
    case 5:
        throw new IOException();            //Required
    case 6:
        throw new Exception();              //Required
    default:
        return;
    }
}

我注意到了RuntimeException继承自Exception.

为什么RuntimeException不需要明确地捕获它而不是其他Exceptions呢？

我看到一个定义可以是这样的:

通常,RuntimeExceptions是可以通过编程方式阻止的异常.

但这仍然不是已检查异常的定义.我认为已检查的异常是"可在编译时处理的异常".这是正确的和/或你能告诉我更多吗？

我也在网站上看过这个,你能解释一下这个引用吗？

许多人说不应该使用经过检查的异常(即你应该明确地捕获或重新抛出的异常).

Java:已检查vs未经检查的异常说明

我可以直接了解定义是什么吗？我也有些意外地读到了:

NumberFormatException未选中

但我认为这NumberFormatException是检查,因为我会在编译时处理它.你能帮我理解一下吗？我已经完成了一些Java编程,但我从未编写过自己的异常类,为什么我需要它呢？

更新

给出的定义是Sierra/Bates的SCJP书:

理念

我正在考虑使用回调而不是在C#/ .NET中抛出异常.

优点和缺点

优点是

• 没有隐藏的goto像未经检查的异常的控制流
• 更清晰的代码,特别是如果涉及多个例外
• 抛出的异常记录在方法签名中,并且调用者被迫考虑处理异常,但可以轻松地传递应用程序范围的异常处理程序,"UnhandledExceptionHandler"或null.因此它们有点像"软"检查异常但更易于维护,因为异常可以通过重载方法抛出,或者异常可以通过不再在异常处理程序上调用"句柄"来消除.
• 适用于异步调用
• 异常处理程序可以处理在不同位置抛出的几个异常
• 明确应该处理哪些例外.普通方式抛出异常仍可用于您不希望像"NotImplementedException"那样处理的异常.

缺点是

• 不是C#和.NET的惯用语
• throw方法必须通过立即返回一个返回值来中断控制流程.如果返回类型是值类型,则这很困难.
• ？(见下面的问题)

题

我可能错过了一些关键的缺点,因为我想知道为什么不使用它.我错过了什么缺点？

例:

代替

void ThrowingMethod() {
    throw new Exception();
}

和

void CatchingMethod() {
    try {
         ThrowingMethod();
    } catch(Exception e) {
         //handle exception
    }
}

我会做

void ThrowingMethod(ExceptionHandler exceptionHandler) {
    exceptionHandler.handle(new Exception());
}

void CatchingMethod() {
     ThrowingMethod(exception => */ handle exception */ );
}

同

delegate void ExceptionHandler(Exception exception);

在某处定义并且"handle(...)"是一个检查null的扩展方法,检索堆栈跟踪,如果在抛出异常时根本没有异常处理程序,则可能抛出"UnhandledException".

在之前未抛出异常的方法中抛出异常的示例

void UsedToNotThrowButNowThrowing() {
   UsedToNotThrowButNowThrowing(null);
}

//overloads existing method that did not throw to …

class Y {
    public static void main(String[] args) throws RuntimeException{//Line 1
        try {
            doSomething();
        }
        catch (RuntimeException e) {
            System.out.println(e);
        }
    }
    static void doSomething() throws RuntimeException{ //Line 2
        if (Math.random() > 0.5) throw new RuntimeException(); //Line 3
        throw new IOException();//Line 4
    }
}

当我抛出两种类型的异常(Line4中的IOException和Line3中的RunTimeException)时,我发现我的程序在我在第1行和第2行的throws子句中指示"IOException"之前不会编译.

而如果我反向"抛出"以指示抛出IOException,则程序会成功编译,如下所示.

class Y {
    public static void main(String[] args) throws IOException {//Line1
        try {
            doSomething();
        }
        catch (RuntimeException e) {
            System.out.println(e);
        }
    }
    static void doSomething() throws IOException {//Line 2
        if (Math.random() > 0.5) throw …

我不知道为什么IllegalArgumentException不类需要被逮住或声明，而其他的异常有（例如java.net.MalformedURLException）。

public void foo() {
    throw new IllegalArgumentException("spam");
}

public void bar() throws MalformedURLException { // required
    throw new MalformedURLException("ham");
}

我知道Errors 不必声明，因为它们不打算被捕获。

我想声明一个新的异常，它也不需要被捕获。

是否可以通过查看代码来判断异常类是经过检查还是未经检查？我一直认为,如果它扩展了Exception,则会进行检查,但是RuntimeException会扩展Exception并且取消选中.RuntimeException可能是弯曲该经验法则的唯一类,其他未经检查的异常如果不扩展RuntimeException则必须扩展Throwable.但是,我没有看到RuntimeException与Exception的区别.我想知道是否在解释器本身内部定义了差异？