如何用 scala 中的不可变 couterpart 替换 java 可变类？

Question

我试图了解如何在 scala 中使用不可变类来替代可变 java 类。

我的示例用例是在数据库中搜索联系人。 当命令式编程时，您将从数据库表中提取每个字段并将其设置在 java 对象上。

在 Scala 中，如何使用不可变类型和函数式风格来做到这一点？

我知道我可以使用构造函数并创建对象的新实例，将所有必需的数据传递给它，但对于大型复杂的数据结构，这似乎并不优雅。

完成此任务的“Scala”/“函数式”方法是什么？ 或者与构造复杂的不可变类型相关的一些最佳实践是什么？

public List<Contact> search(String firstName, String lastName) throws SQLException {
    List<Contact> contacts = new ArrayList<Contact>();

    Connection con = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
        con = dataSource.getConnection();

        ps = con.prepareStatement("select * from contacts where first_name like ? and last_name like ?");
        ps.setString(1, "%" + firstName + "%");
        ps.setString(1, "%" + lastName + "%");
        rs = ps.executeQuery();

        while (rs.next()) {
            Contact contact = new Contact();
            contact.setFirstName(rs.getString("first_name"));
            contact.setMiddleName(rs.getString("middle_name"));
            contact.setLastName(rs.getString("last_name"));
            Date birthday = rs.getDate("birthday");
            if (birthday != null) {
                contact.setBirthday(new Date(birthday.getTime()));
            }
            contacts.add(contact);
        }

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        rs.close();
        ps.close();
        con.close();
    }
    return contacts;
}

联系POJO

import java.util.Date;

public class Contact {
    private String firstName;
    private String middleName;
    private String lastName;
    private Date birthday;

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getMiddleName() {
        return middleName;
    }

    public void setMiddleName(String middleName) {
        this.middleName = middleName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}

Answer 1

快速的答案是您使用参数调用构造函数。在 Java 中：

public class Contact {
  private final String firstName;
  private final String middleName;
  private final String lastName;
  private final Date birthday;

  public Contact(
    String firstName,
    String middleName,
        String lastName,
    Date birthday
  ) {
    this.firstName = firstName;
    this.middleName = middleName;
    this.lastName = lastName;
    this.birthday = birthday;
  }
  … // getters
}

  … inside while loop:
  contacts.add(new Contact(
    rs.getString("first_name"),
    rs.getString("middle_name"),
    rs.getString("last_name"),
    new Date(birthday.getTime())
   );

我暂时省略了可选的生日，我们将在 Scala 版本中将其添加回来。

不过，我们仍然有一个可变的联系人列表，所以让我们看看如何使其正确地不可变。我们将使用 Scala 列表。首先，scala 数据对象：

case class Contact(
  first: String,
  middle: String,
  last: String,
  birthday: Option[Date])

我们有可选的生日作为 type-sig 的一部分作为奖励。

现在让我们定义一个简单的提取器方法，给定一个结果集：

def contacts(rs: ResultSet) = {
  @annotation.tailrec def loop(cs: List[Contact]): List[Contact] =
    if (!rs.next()) cs else loop(
      Contact(
        rs.getString("first_name"),
        rs.getString("middle_name"),
        rs.getString("last_name"),
        Option(rs.getLong("birthday"))
      ) :: cs)
  loop(Nil)
}

此版本递归地构建结果集中所有联系人的单链接列表。这是不可改变的。

Answer 2

您还可以拥有一个可变构建器，它可以生成您正在寻找的不可变对象。如果临时可变对象保留在其创建范围内并且不会传播到其他地方，那么拥有临时可变对象并没有什么问题。 Scala 标准库实现使用了大量这些库。

这是一个简单的例子（尽管当构造函数很大时这个解决方案更有用）：

// Here is the immutable class
case class Person( name: String, age: Int, married: Boolean )

// Here comes the mutable builder
class PersonBuilder {
  private var name: Option[String] = None
  private var age: Option[Int] = None
  private var married: Option[Boolean] = None

  def setName( n: String ) = { name = Some(n); this }
  def setAge( a: Int ) = { age = Some(a); this }
  def setMarried( m: Boolean ) = { married = Some(m); this }

  def build() = {
    val person = for( n <- name; a <- age; m <- married ) 
                   yield { Person( n, a, m ) }
    person getOrElse { throw new IllegalStateException( /*msg*/ ) }
  }
}

它可以用作：

val builder = new PersonBuilder
builder setName "Alex"
builder setAge 42
builder setMarried false
val person = builder build  // The immutable instance