Scala 的方法是什么来实现像这样的可重试调用？

仍然是 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 中实现可重试服务实现的相同功能的最佳方法是什么？

它基本上称为call方法 N 次，如果全部失败，则引发异常，如果成功，则继续。这个不返回任何内容，但我有另一个版本允许返回一个值（所以，我在 Java 中有两个类），我相信我可以在 Scala 中使用单个类/函数。

有任何想法吗？

EDIT

目前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;

}

递归 + 一流函数 按名称参数 == 很棒。

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
}

Edit：略有变化的灵感来自@themel https://stackoverflow.com/users/334485/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)
}

斯卡拉 2.10 更新。由于我的爱好，我偶尔会重新审视这个答案。 Scala 2.10 介绍Try http://www.scala-lang.org/api/current/index.html#scala.util.Try%24，它提供了一种以尾递归方式实现重试的干净方法。

// 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
  }
}