包装器 scala API 优于 Java API

Question

我是 Scala 的新手，我正在为我的 Java API

构建一个 Scala 包装器

我有四个 Java 接口

public interface Client<T> {
 <T> Handle<T> execute(App<T> app);
}

public interface App<T> extends Serializable{
  T process(AppContext context) throws Exception;
}

public interface AppContext {
  File getDirectory();
  void deleteDirectory();
  File createDirectory(String path);
}

public interface Handle<T> extends Future<T> {
   static interface Listener<T> {          
       void onSuccess(Handle<T> handle)
       void onFailure(Handle<T> handle, Throwable e)
   }

   void addListener(Listener<T> listener);
}

这是我的 Scala 等价物

trait Process[T] extends Future[T] { 
  // Few abstract methods
}


class ProcessImpl[T](handle: Handle[T]) extends Process[T] {

val promise = Promise[T]

override def isCompleted: Boolean = ???

override def onComplete[U](func: (Try[T]) => U)(implicit executor: ExecutionContext)  = {
  case Success(t) => promise.success(handle.get())
  case Failure(e) => promise.failure(e)
   }

override def value: Option[Try[T]] = ???

@throws(classOf[Exception])
override def result(atMost: Duration)(implicit permit: CanAwait): T = ???

@throws(classOf[InterruptedException])
@throws(classOf[TimeoutException])
override def ready(atMost: Duration)(implicit permit: CanAwait) = ???

 } 


class ScalaClient(javaClient: Client) {
   def execute[T](func: AppContext => T): ScalaHandle[T] = {
     val app = new App[T]
     @throws(classOf[Exception])
     override def process(AppContext context): T = func(context)

     val handle = javaClient.execute(app) // This returns a Handle obj. I want to convert it to ScalaHandle

    //My approach

     val scalahandle = new ProcessImpl(handle)       
     scalahandle
  }
}

我收到以下错误

必须完全知道匿名函数的参数类型。 (SLS 8.5)

预期类型为：单位 override def onComplete[U](func: (Try[T]) => U)(implicit executor: ExecutionContext) = {

另外，我想知道我这里的做法对不对

Answer 1

您的问题不在于 onComplete 本身——而是在于您实施它的方式。

override def onComplete[U](func: (Try[T]) => U)(implicit executor: ExecutionContext)  = {
  case Success(t) => promise.success(test.get())
  case Failure(e) => promise.failure(e)
}

在这里，您将 onComplete 定义为某个函数 Try[_] => U 的部分函数——类型未知，并且它绝对不会覆盖原始方法 abstract def onComplete[U](f: (Try[T]) ⇒ U)(implicit executor: ExecutionContext): Unit。请注意，case 不匹配此处的任何内容：func 不是此处的 Try[T]。

附带说明一下，我不能不提一下，您永远不应该扩展 Future。一个非常有用的格言是，不惜一切代价避免继承。在你的情况下，我认为继承不会为你赢得任何东西——相反，它会增加混乱。

您可能正在寻找的是，

def asFuture[T](handle: Handle[T]): Future[T] = {
  val promise = Promise[T]()
  handle.addListener(new Handle.Listener[T] {
    def onSuccess(handle: Handle[T]) {
      promise.trySuccess(handle.get())
    }
    def onFailure(handle: Handle[T], e: Throwable) {
      promise.tryFailure(e)
    }
  })
  promise.future
}

包装器 scala API 优于 Java API

Wrapper scala API over Java API

java

scala

interface

future