java - 允许 Scala/Java 中的参数化类/类型

Question

我想将域实体中的属性(如域驱动设计中)定义为具有最大长度的字符串类型。不同的属性将具有不同的最大长度(以便能够匹配数据库列数据类型)。例如描述将为 VARCHAR2(50)，而长描述将为 VARCHAR2(200)。

是否可以定义一个以整数作为参数的类型，如 VARCHAR2(50)？那么我只需要为所有此类类型定义一个类并将其用于不同的属性？val 描述:TextValue(50)val longDescription: TextValue(200)

Answer 1

我认为你不能使用 Java 类型系统做这样的事情(除了代码后处理，请参阅最后一个想法)。 Scala 类型系统的功能要强大得多，因此您可以尝试遵循以下几种方法。

无形Nat

一个明显的方向是尝试使用 Nat provided by shapeless粗略地说，这是自然数的一种类型编码。您可以像这样使用它来定义给定最大长度的 TextValue:

import shapeless._
import shapeless.ops.nat._
import shapeless.syntax.nat._


case class TextValue[N <: Nat] private(string: String)

object TextValue {
  // override to make the one generated by case class private
  private def apply[N <: Nat](s: String) = ???

  def unsafe[N <: Nat](s: String)(implicit toIntN: ToInt[N]): TextValue[N] = {
    if (s.length < Nat.toInt[N]) new TextValue[N](s)
    else throw new IllegalArgumentException(s"length of string is ${s.length} while max is ${Nat.toInt[N]}")
  }

  implicit def convert[N <: Nat, M <: Nat](tv: TextValue[N])(implicit less: NatLess[N, M]): TextValue[M] = new TextValue[M](tv.string)
}


// N < M
trait NatLess[N <: Nat, M <: Nat]

object NatLess {
  implicit def less[N <: Nat]: NatLess[N, Succ[N]] = new NatLess[N, Succ[N]] {}

  implicit def lessSucc[N <: Nat, M <: Nat](implicit prev: NatLess[N, M]): NatLess[N, Succ[M]] = new NatLess[N, Succ[M]] {}
}

然后你可以像这样使用它:

def test(): Unit = {
  val Twenty = Nat(20)
  type Twenty = Twenty.N
  val Thirty = Nat(30)
  type Thirty = Thirty.N

  val tv20: TextValue[Twenty] = TextValue.unsafe[Twenty]("Something short")
  val tv30: TextValue[Thirty] = TextValue.unsafe[Thirty]("Something short")

  val tv30assigned: TextValue[Thirty] = tv20
  //val tv20assigned: TextValue[Twenty] = tv30 // compilation error
}

这种方法的问题是 Nat 显着延长了编译时间。如果您尝试编译数百个 Nat，则需要几分钟，而且我不确定您是否可以通过这种方式编译数千个。您还可以在 Limits of Nat type in Shapeless 找到一些详细信息

手工制作Nat

Nat 的编译时间非常糟糕，因为数字是使用一种 Church encoding 进行编码的。带有多对 Succ[_] 包装器。实际上，您很可能不需要 1 到最大长度之间的所有值，因此仅明确列出您需要的值的手工制作版本可能更适合您:

sealed trait Nat {
  type N <: Nat
}

// N < M
trait NatLess[N <: Nat, M <: Nat]

object NatLess {

  implicit def transitive[N <: Nat, M <: Nat, K <: Nat](implicit nm: NatLess[N, M], mk: NatLess[M, K]): NatLess[N, K] = new NatLess[N, K] {}
}

trait ToInt[N <: Nat] {
  val intValue: Int
}

object Nat {

  def toInt[N <: Nat](implicit toInt: ToInt[N]): Int = toInt.intValue

  sealed abstract class NatImpl[N <: Nat](val value: Int) extends Nat {
    implicit def toInt: ToInt[N] = new ToInt[N] {
      override val intValue = value
    }
  }

  /////////////////////////////////////////////
  sealed trait Nat50 extends Nat {
    type N = Nat50
  }

  object Nat50 extends NatImpl(50) with Nat50 {
  }

  /////////////////////////////////////////////
  sealed trait Nat100 extends Nat {
    type N = Nat100
  }

  object Nat100 extends NatImpl(100) with Nat100 {
  }

  implicit val less50_100: NatLess[Nat50, Nat100] = new NatLess[Nat50, Nat100] {}

  /////////////////////////////////////////////
  sealed trait Nat200 extends Nat {
    type N = Nat200
  }

  object Nat200 extends NatImpl(200) with Nat200 {
  }

  implicit val less100_200: NatLess[Nat100, Nat200] = new NatLess[Nat100, Nat200] {}
  /////////////////////////////////////////////

}

使用这样的自定义Nat和非常相似的TextValue

case class TextValue[N <: Nat] private(string: String)

object TextValue {
  // override to make the one generated by case class private
  private def apply[N <: Nat](s: String) = ???

  def unsafe[N <: Nat](s: String)(implicit toIntN: ToInt[N]): TextValue[N] = {
    if (s.length < Nat.toInt[N]) new TextValue[N](s)
    else throw new IllegalArgumentException(s"length of string is ${s.length} while max is ${Nat.toInt[N]}")
  }

  implicit def convert[N <: Nat, M <: Nat](tv: TextValue[N])(implicit less: NatLess[N, M]): TextValue[M] = new TextValue[M](tv.string)
}

你可以轻松编译这样的东西

def test(): Unit = {

  val tv50: TextValue[Nat.Nat50] = TextValue.unsafe[Nat.Nat50]("Something short")
  val tv200: TextValue[Nat.Nat200] = TextValue.unsafe[Nat.Nat200]("Something short")


  val tv200assigned: TextValue[Nat.Nat200] = tv50
  // val tv50assigned: TextValue[Nat.Nat50] = tv200 // compilation error
}

请注意，这次最大长度 200 不会以任何显着方式影响编译时间。

使用隐式进行运行时检查

如果您同意所有检查仅在运行时进行，您可以使用完全不同的方法。然后您可以定义trait Validator和class ValidatedValue，例如:

trait Validator[T] {
  def validate(value: T): Boolean
}

case class ValidatedValue[T, V <: Validator[T]](value: T)(implicit validator: V) {
  if (!validator.validate(value))
    throw new IllegalArgumentException(s"value `$value` does not pass validator")
}

object ValidatedValue {
  implicit def apply[T, VOld <: Validator[T], VNew <: Validator[T]](value: ValidatedValue[T, VOld])(implicit validator: VNew): ValidatedValue[T, VNew] = ValidatedValue(value.value)
}

并将 MaxLength 检查定义为

abstract class MaxLength(val maxLen: Int) extends Validator[String] {
  override def validate(value: String): Boolean = value.length < maxLen
}

object MaxLength {

  implicit object MaxLength50 extends MaxLength(50)

  type MaxLength50 = MaxLength50.type
  type String50 = ValidatedValue[String, MaxLength50]

  implicit object MaxLength100 extends MaxLength(100)

  type MaxLength100 = MaxLength100.type
  type String100 = ValidatedValue[String, MaxLength100]
}

然后你可以像这样使用它:

def test(): Unit = {
  import MaxLength._

  val tv50: String50 = ValidatedValue("Something short")
  val tv100: String100 = ValidatedValue("Something very very very long more than 50 chars in length")
  val tv100assigned: String100 = tv50
  val tv50assigned: String50 = tv100 // only runtime error
}

请注意，这次最后一行将编译并且只会在运行时失败。

这种方法的一个好处可能是您可以对任意类进行检查，而不仅仅是String。例如，您可以创建类似 NonNegativeInt 的内容。此外，通过这种方法，理论上您可以将多项检查合并为一个(但将 MaxLength 转换为特征并创建扩展多个特征的类型)。在这种情况下，您可能希望 validate 返回类似 cats.data.Validated 的内容。或者至少 List[String] 来积累多个由于不同原因而导致的错误。

使用宏进行运行时检查

我没有这种方法的现成代码，但想法是您定义 an annotation that is processed by a macro 。您可以使用它来注释类的字段。然后您编写一个宏，它将重写类的代码，以便验证字段 setter 中的最大长度(或取决于注释的其他条件)。

这是您可能相对容易的唯一解决方案 implement in Java也是如此。