2

使用流时，我编写了以下将 an 的内容复制InputStream到 an 的函数OutputStream：

def copy(input: InputStream, output: OutputStream, chunk: Int = 2048) {
  val buffer = Array.ofDim[Byte](chunk)
  var count  = -1

  while({count = input.read(buffer); count > 0})
    output.write(buffer, 0, count)
}

编写相同的函数将 a 的内容复制Reader到 a 会Writer产生极其相似的代码——唯一的区别是Array.

我正在尝试，但到目前为止还无法概括我的copy方法。

我想我记得在某处读过，我可以通过它支持的方法来描述一个类型——比如接受任何支持的类型read(buffer: Array[Byte])。我可能已经弥补了，因为我再也找不到了。

我也想过传递一个隐式的辅助对象，有点像Ordering各种集合的sorted方法，但我的大脑正在碰壁。

任何正确方向的帮助或指示将不胜感激。

4

2 回答 2

3

是的，你想要一个结构化类型。请注意，这将利用运行时反射。这应该不会对性能造成明显影响，因为您可能会在此函数中执行 I/O，但仅供参考。

def copy(input: { def read(buffer: Array[Byte]):Int }, ...
于 2013-09-26T15:06:29.833 回答
2

您可以获得结构化类型的许多好处，而不会使用类型类导致运行时损失。类型类是一个概念。这是多态性的一种方法。特别是，它是ad-hoc polymorphism。它是我们可以获得编译时、静态检查的鸭子类型的方式！

让我们制作Reader[I]和Writer[O]特征，其中I和O分别是输入和输出流类型。

trait Reader[I] {
  def read(input: I, buffer: Array[Byte]): Int
}

trait Writer[O] {
  def write(output: O, buffer: Array[Byte], startAt: Int, nBytesToWrite: Int): Unit
}

我们现在可以创建一个通用的复制方法，该方法可以对订阅这些接口的事物进行操作。

object CopyStreams {

  type Bytes = Int

  def apply[I, O](input: I, output: O, chunkSize: Bytes = 1024)(implicit r: Reader[I], w: Writer[O]): Unit = {
    val buffer = Array.ofDim[Byte](chunkSize)
    var count = -1

    while ({count = r.read(input, buffer); count > 0})
      w.write(output, buffer, 0, count)
  }
}

注意这里的隐式r和w参数。本质上，我们是说如果存在且范围内的值，CopyStreams[I,O].apply它将起作用。这将使我们能够无缝地调用 CopyStreams(input, output)。Reader[I]Writer[O]

我们可以使用上下文边界apply并将签名重写为

def apply[I: Reader, O: Writer](input: I, output: O, chunkSize: Bytes = 1024): Unit

然后，我们将分别使用和访问我们的Reader[I]和Writer[O]实例。请注意，这种形式等同于第一种形式。Scala 编译器实际上会将这个上下文绑定版本重写为我们提供的第一个版本。implicitly[Reader[I]]implicitly[Writer[O]]

然而，重要的是，请注意此实现是通用的。它对独立于实际流实现的类型进行操作。

在我的特定用例中，我需要将 S3 对象复制到本地文件。所以我做了以下隐含值。

object Reader {

  implicit val s3ObjectISReader = new Reader[S3ObjectInputStream] {
    @inline override def read(input: S3ObjectInputStream, buffer: Array[Byte]): Int =
      input.read(buffer)
  }
}


object Writer {

  implicit val fileOSWriter = new Writer[FileOutputStream] {
    @inline override def write(output: FileOutputStream,
                               buffer: Array[Byte],
                               startAt: Int,
                               nBytesToWrite: Int): Unit =
      output.write(buffer, startAt, nBytesToWrite)
  }
}

所以现在我可以执行以下操作：

val input:S3ObjectStream = ...
val output = new FileOutputStream(new File(...))
import Reader._
import Writer._
CopyStreams(input, output)
// close and such...

如果我们需要复制不同的流类型，我们只需要写入一个新的Reader或Writer隐含的值。我们可以在CopyStreams不更改代码的情况下使用它！

于 2015-04-10T21:09:53.130 回答