Scala技术问询：如何在不重写父类字段时使用case类copy方法？

问题描述 #

当Scala的case类继承带有参数的抽象类时，自动生成的copy方法仅支持修改case类自身的构造参数，无法直接修改父类中的字段。由于实际场景中父类可能包含上百个字段，手动在case类中重写所有父类参数会导致代码极度冗余，因此需要一种无需重写父类参数即可实现全字段copy的方案。

示例代码 #

abstract class MyAbstractClass (val arg1: String = "bar 1")

case class MyCaseClass(arg2: String) extends MyAbstractClass

object MyMain {
  def main(args: Array[String]): Unit = {
    val myObj = MyCaseClass(arg2 = "bar 2")
    println("a.arg1: " + myObj.arg1) // 输出: a.arg1: bar 1
    println("a.arg2: " + myObj.arg2) // 输出: a.arg2: bar 2

    // 尝试修改父类字段arg1，编译报错
    val b = myObj.copy(arg1 = "try_1", arg2 = "try_2") 
    // 错误信息: too many arguments (2) for method copy: (arg2: String)com.MyCaseClass
    // Note that 'arg1' is not a parameter name of the invoked method.
  }
}

可行方案 #

1. 自定义扩展copy方法 #

手动实现一个包含父类字段的copy方法，无需重写所有父类参数。可以通过父类提供的字段修改方法，结合反射批量处理父类字段（适合字段较多的场景）：

abstract class MyAbstractClass(val arg1: String = "bar 1") {
  // 生成新的父类实例，携带修改后的字段
  def updateParent(newArg1: String): MyAbstractClass = new MyAbstractClass(newArg1) {}
}

case class MyCaseClass(arg2: String) extends MyAbstractClass {
  // 自定义copy方法，支持修改父类和子类字段
  def copy(arg1: String = this.arg1, arg2: String = this.arg2): MyCaseClass = {
    val updatedParent = updateParent(arg1)
    val newInstance = MyCaseClass(arg2)
    // 用反射将父类字段值复制到新实例
    val parentFields = classOf[MyAbstractClass].getDeclaredFields
    parentFields.foreach { field =>
      field.setAccessible(true)
      field.set(newInstance, field.get(updatedParent))
    }
    newInstance
  }
}

// 使用示例
object MyMain {
  def main(args: Array[String]): Unit = {
    val myObj = MyCaseClass(arg2 = "bar 2")
    val b = myObj.copy(arg1 = "try_1", arg2 = "try_2")
    println("b.arg1: " + b.arg1) // 输出: b.arg1: try_1
    println("b.arg2: " + b.arg2) // 输出: b.arg2: try_2
  }
}

2. 用Shapeless实现通用全字段copy #

对于存在大量父类字段的场景，Shapeless可以通过泛型编程自动遍历类的所有字段（包括父类继承的），生成通用的copy逻辑，完全避免手动处理每个字段：

首先添加Shapeless依赖到你的构建文件（比如sbt）：

libraryDependencies += "com.chuusai" %% "shapeless" % "2.3.10"

然后实现通用copy工具：

import shapeless._
import shapeless.labelled._

// 定义通用copy的类型类
trait FullCopy[T] {
  def apply(t: T)(updates: FieldType[Symbol, Any]*): T
}

object FullCopy {
  implicit def deriveFullCopy[T, L <: HList](implicit
    gen: LabelledGeneric.Aux[T, L],
    updater: Updater.Aux[L, L, L]
  ): FullCopy[T] = new FullCopy[T] {
    override def apply(t: T)(updates: FieldType[Symbol, Any]*): T = {
      val originalHList = gen.to(t)
      // 将更新字段合并到原HList
      val updatedHList = updates.foldLeft(originalHList)((acc, update) => updater(acc, update))
      gen.from(updatedHList.asInstanceOf[L])
    }
  }

  // 给所有类添加fullCopy扩展方法
  implicit class FullCopyOps[T](val t: T) extends AnyVal {
    def fullCopy(updates: FieldType[Symbol, Any]*)(implicit fc: FullCopy[T]): T = fc(t)(updates: _*)
  }
}

// 使用示例
object MyMain {
  import FullCopy._

  def main(args: Array[String]): Unit = {
    val myObj = MyCaseClass(arg2 = "bar 2")
    // 使用符号引用字段名，支持父类和子类字段
    val b = myObj.fullCopy('arg1 -> "try_1", 'arg2 -> "try_2")
    println("b.arg1: " + b.arg1) // 输出: b.arg1: try_1
    println("b.arg2: " + b.arg2) // 输出: b.arg2: try_2
  }
}

3. 调整类结构（可选） #

如果允许修改父类的定义，可以将父类改为特质，在case类中通过默认参数声明父类字段。虽然需要override，但可以避免手动维护大量字段：

trait MyAbstractTrait {
  val arg1: String = "bar 1"
}

// case类中声明override参数并设置默认值，自动生成包含arg1的copy方法
case class MyCaseClass(arg2: String, override val arg1: String = "bar 1") extends MyAbstractTrait

object MyMain {
  def main(args: Array[String]): Unit = {
    val myObj = MyCaseClass(arg2 = "bar 2")
    val b = myObj.copy(arg1 = "try_1", arg2 = "try_2")
    println("b.arg1: " + b.arg1) // 输出: b.arg1: try_1
    println("b.arg2: " + b.arg2) // 输出: b.arg2: try_2
  }
}

方案对比 #

• 自定义copy方法：无额外依赖，适合字段数量较少或无法引入第三方库的场景，但需要手动处理反射逻辑；
• Shapeless方案：自动化程度高，适合大量字段的场景，无需手动维护每个字段，但需要引入第三方库；
• 调整类结构：实现最简单，但需要修改父类定义，且仍需声明override参数。

内容的提问来源于stack exchange，提问作者Maor Aharon