Scala服务优化：统一3个相似用户查询端点的实现方案

针对你遇到的多端点逻辑重复问题，推荐两种高效的实现模式，其中类型类（Type Class）方案更符合Scala函数式风格，且兼具类型安全性与扩展性。

方案一：类型类（Type Class）实现 #

核心思路是将「根据特定字段查询用户」的行为抽象为类型类，通过隐式实例绑定不同ID类型与对应的查询规则，编译期即可确定逻辑，无运行时额外开销。

1. 定义类型类 #

抽象查询所需的核心信息：数据库字段对应的WHERE子句，以及ID到UUID的转换（如果ID是包装UUID的自定义类型）：

trait UserLookup[ID] {
  // 返回对应字段的WHERE子句模板
  def whereClause: String
  // 将自定义ID转换为UUID（若ID直接是UUID可省略）
  def toUUID(id: ID): UUID
}

2. 为各ID类型实现类型类实例 #

针对每个ID类型，提供具体的查询规则：

object UserLookup {
  // UserID对应的查询规则
  implicit val byUserId: UserLookup[UserID] = new UserLookup[UserID] {
    override def whereClause: String = "user_id IN (?)"
    override def toUUID(id: UserID): UUID = id.value // 假设UserID是case class UserID(value: UUID)
  }

  // EmployeeID对应的查询规则
  implicit val byEmployeeId: UserLookup[EmployeeID] = new UserLookup[EmployeeID] {
    override def whereClause: String = "employee_id IN (?)"
    override def toUUID(id: EmployeeID): UUID = id.value
  }

  // DepartmentID对应的查询规则
  implicit val byDepartmentId: UserLookup[DepartmentID] = new UserLookup[DepartmentID] {
    override def whereClause: String = "department_id IN (?)"
    override def toUUID(id: DepartmentID): UUID = id.value
  }
}

3. 编写通用查询方法 #

利用隐式参数自动获取对应ID类型的查询规则，实现通用逻辑：

import UserLookup._

def getUsersByID[ID](ids: List[ID])(implicit lookup: UserLookup[ID]): List[User] = {
  // 拼接通用SQL
  val baseSql = "SELECT user_id, employee_id, department_id FROM users WHERE "
  val sql = baseSql + lookup.whereClause

  // 转换ID为UUID参数
  val uuidParams = ids.map(lookup.toUUID)

  // 执行数据库查询并映射为User实例（这里替换为你的实际DB操作逻辑）
  db.query(sql, uuidParams).map { row =>
    User(
      userId = UserID(row.getUUID("user_id")),
      employeeID = EmployeeID(row.getUUID("employee_id")),
      departmentID = DepartmentID(row.getUUID("department_id"))
    )
  }
}

4. 简化端点实现 #

原有的三个端点只需调用通用方法即可，无需重复编写查询逻辑：

def getUserByUserID(userIds: List[UserID]): List[User] = getUsersByID(userIds)
def getUserByEmployeeID(employeeIDs: List[EmployeeID]): List[User] = getUsersByID(employeeIDs)
def getUserByDepartmentID(departmentIDs: List[DepartmentID]): List[User] = getUsersByID(departmentIDs)

方案二：枚举+模式匹配（轻量替代方案） #

如果场景简单，也可以用枚举标记查询类型，配合模式匹配实现通用逻辑，适合快速迭代的小型项目：

1. 定义查询类型枚举 #

sealed trait QueryType
case object UserIdQuery extends QueryType
case object EmployeeIdQuery extends QueryType
case object DepartmentIdQuery extends QueryType

2. 编写通用查询方法 #

def getUsersByType(ids: List[UUID], queryType: QueryType): List[User] = {
  val whereClause = queryType match {
    case UserIdQuery => "user_id IN (?)"
    case EmployeeIdQuery => "employee_id IN (?)"
    case DepartmentIdQuery => "department_id IN (?)"
  }

  val sql = s"SELECT user_id, employee_id, department_id FROM users WHERE $whereClause"
  // 执行查询并映射User（逻辑同方案一）
  db.query(sql, ids).map(row => User(UserID(row.getUUID(0)), EmployeeID(row.getUUID(1)), DepartmentID(row.getUUID(2))))
}

3. 端点调用 #

def getUserByUserID(userIds: List[UserID]): List[User] = getUsersByType(userIds.map(_.value), UserIdQuery)
def getUserByEmployeeID(employeeIDs: List[EmployeeID]): List[User] = getUsersByType(employeeIDs.map(_.value), EmployeeIdQuery)
def getUserByDepartmentID(departmentIDs: List[DepartmentID]): List[User] = getUsersByType(departmentIDs.map(_.value), DepartmentIdQuery)

方案对比 #

• 类型类方案：编译期绑定逻辑，无运行时开销，类型安全，新增ID类型只需添加对应隐式实例，无需修改通用代码，符合开闭原则，推荐用于中大型项目。
• 枚举+模式匹配：实现简单，但需要手动传递查询类型，扩展时需修改模式匹配分支，适合小型快速迭代场景。

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