Scala实现这种可重试调用的方式是什么？

Question

还是Scala的新手，我现在正在寻找一种在其上实现以下代码的方法：

@Override
public void store(InputStream source, String destination, long size) {

    ObjectMetadata metadata = new ObjectMetadata();
    metadata.setContentLength(size);
    final PutObjectRequest request = new PutObjectRequest(
            this.configuration.getBucket(), destination, source, metadata);

    new RetryableService(3) {

        @Override
        public void call() throws Exception {
            getClient().putObject(request);
        }
    };

}

在Scala中实现与RetryableService实现的功能相同的最佳方法是什么？

它基本上调用N次 调用
方法，如果所有方法均失败，则引发异常，如果所有方法均失败，则继续进行。这个不返回任何内容，但是我有另一个版本可以返回值（因此，我在Java中有两个类），我相信我可以在Scala中使用单个类/函数。

有任何想法吗？

编辑

Java当前的实现如下：

public abstract class RetryableService {

private static final JobsLogger log = JobsLogger
        .getLogger(RetryableService.class);

private int times;

public RetryableService() {
    this(3);
}

public RetryableService(int times) {
    this.times = times;
    this.run();
}

private void run() {

    RuntimeException lastExceptionParent = null;

    int x = 0;

    for (; x < this.times; x++) {

        try {
            this.call();
            lastExceptionParent = null;
            break;
        } catch (Exception e) {
            lastExceptionParent = new RuntimeException(e);
            log.errorWithoutNotice( e, "Try %d caused exception %s", x, e.getMessage() );

            try {
                Thread.sleep( 5000 );
            } catch (InterruptedException e1) {
                log.errorWithoutNotice( e1, "Sleep inside try %d caused exception %s", x, e1.getMessage() );
            }

        }

    }

    try {
        this.ensure();
    } catch (Exception e) {
        log.error(e, "Failed while ensure inside RetryableService");
    }

    if ( lastExceptionParent != null ) {
        throw new IllegalStateException( String.format( "Failed on try %d of %s", x, this ), lastExceptionParent);
    }

}

public void ensure() throws Exception {
    // blank implementation
}

public abstract void call() throws Exception;

}

Answer 1

递归+ 一流的功能 ，按名称参数==很棒。

def retry[T](n: Int)(fn: => T): T = {
  try {
    fn
  } catch {
    case e =>
      if (n > 1) retry(n - 1)(fn)
      else throw e
  }
}

用法是这样的：

retry(3) {
  // insert code that may fail here
}

编辑
：受@themel的答案启发而略有变化。少一行代码:-)

def retry[T](n: Int)(fn: => T): T = {
  try {
    fn
  } catch {
    case e if n > 1 =>
      retry(n - 1)(fn)
  }
}

再次编辑
：递归使我感到困扰，因为它向堆栈跟踪添加了多个调用。由于某些原因，编译器无法在catch处理程序中优化尾部递归。但是，尾部递归不在catch处理程序中，可以很好地优化:-)

@annotation.tailrec
def retry[T](n: Int)(fn: => T): T = {
  val r = try { Some(fn) } catch { case e: Exception if n > 1 => None }
  r match {
    case Some(x) => x
    case None => retry(n - 1)(fn)
  }
}

再次编辑
：显然，我将把它作为一种爱好，不断回来并为此答案添加替代方法。这是一个尾递归版本，它比使用更加简单Option，但是使用return短路功能并不是惯用的Scala。

@annotation.tailrec
def retry[T](n: Int)(fn: => T): T = {
  try {
    return fn
  } catch {
    case e if n > 1 => // ignore
  }
  retry(n - 1)(fn)
}

Scala 2.10更新 。作为我的业余爱好，我偶尔会重新审视此答案。Try引入的Scala 2.10
提供了一种以尾递归方式实现重试的干净方法。

// Returning T, throwing the exception on failure
@annotation.tailrec
def retry[T](n: Int)(fn: => T): T = {
  util.Try { fn } match {
    case util.Success(x) => x
    case _ if n > 1 => retry(n - 1)(fn)
    case util.Failure(e) => throw e
  }
}

// Returning a Try[T] wrapper
@annotation.tailrec
def retry[T](n: Int)(fn: => T): util.Try[T] = {
  util.Try { fn } match {
    case util.Failure(_) if n > 1 => retry(n - 1)(fn)
    case fn => fn
  }
}