java - ORM 支持不可变类

Question

哪种 ORM 支持不可变类型的域模型？

我想编写如下类(或等效的 Scala):

class A {
  private final C c; //not mutable

  A(B b) {
     //init c
  }

  A doSomething(B b) {
     // build a new A
  }
}

ORM 必须使用构造函数初始化对象。因此可以在构造函数中检查不变量。对初始化的默认构造函数和字段/ setter 访问是不够的，并且会使类的实现复杂化。

应该支持使用集合。如果集合被更改，它应该从用户的角度创建一个副本。 (使旧的集合状态过时。但用户代码仍然可以处理(或至少读取)它。)很像 persistent data structures工作。

关于动机的一些话。假设您有一个 FP 风格的域对象模型。现在您想将其保存到数据库中。你是谁做的？您希望以纯函数式风格尽可能多地做，直到邪恶的副作用出现。如果您的域对象模型不是不可变的，您可以例如不在线程之间共享对象。你必须复制、缓存或使用锁。因此，除非您的 ORM 支持不可变类型，否则您在选择解决方案时会受到限制。

Answer 1

更新:我创建了一个名为 JIRM 的项目专注于解决这个问题。 : https://github.com/agentgt/jirm

我在使用 Spring JDBC 实现我自己的之后才发现这个问题和 Jackson对象映射器。基本上我只需要一些最低限度的 SQL <-> 不可变对象(immutable对象)映射。

简而言之，我只使用 Springs RowMapper 和 Jackson's ObjectMapper 从数据库中来回映射对象。我仅将 JPA 注释用于元数据(如列名等)。 如果人们有兴趣，我会将其清理并放在 github 上(目前它仅在我的初创公司的私有(private)仓库中)。

这是一个粗略的想法，这里是一个示例 bean(注意所有字段都是最终的):

//skip imports for brevity
public class TestBean {

    @Id
    private final String stringProp;
    private final long longProp;
    @Column(name="timets")
    private final Calendar timeTS;

    @JsonCreator
    public TestBean(
            @JsonProperty("stringProp") String stringProp, 
            @JsonProperty("longProp") long longProp,
            @JsonProperty("timeTS") Calendar timeTS ) {
        super();
        this.stringProp = stringProp;
        this.longProp = longProp;
        this.timeTS = timeTS;
    }

    public String getStringProp() {
        return stringProp;
    }
    public long getLongProp() {
        return longProp;
    }

    public Calendar getTimeTS() {
        return timeTS;
    }

}

这里有什么 RowMapper看起来像(注意它主要委托(delegate)给 Springs ColumnMapRowMapper，然后使用 Jackson 的 objectmapper):

public class SqlObjectRowMapper<T> implements RowMapper<T> {

    private final SqlObjectDefinition<T> definition;
    private final ColumnMapRowMapper mapRowMapper;
    private final ObjectMapper objectMapper;


    public SqlObjectRowMapper(SqlObjectDefinition<T> definition, ObjectMapper objectMapper) {
        super();
        this.definition = definition;
        this.mapRowMapper = new SqlObjectMapRowMapper(definition);
        this.objectMapper = objectMapper;
    }

    public SqlObjectRowMapper(Class<T> k) {
        this(SqlObjectDefinition.fromClass(k), new ObjectMapper());
    }


    @Override
    public T mapRow(ResultSet rs, int rowNum) throws SQLException {
        Map<String, Object> m = mapRowMapper.mapRow(rs, rowNum);
        return objectMapper.convertValue(m, definition.getObjectType());
    }

}

现在我刚刚使用 Spring JDBCTemplate 并给它一个 fluent 包装器。以下是一些示例:

@Before
public void setUp() throws Exception {
    dao = new SqlObjectDao<TestBean>(new JdbcTemplate(ds), TestBean.class);

}

@Test
public void testAll() throws Exception {
    TestBean t = new TestBean(IdUtils.generateRandomUUIDString(), 2L, Calendar.getInstance());
    dao.insert(t);
    List<TestBean> list = dao.queryForListByFilter("stringProp", "hello");
    List<TestBean> otherList = dao.select().where("stringProp", "hello").forList();
    assertEquals(list, otherList);
    long count = dao.select().forCount();
    assertTrue(count > 0);

    TestBean newT = new TestBean(t.getStringProp(), 50, Calendar.getInstance());
    dao.update(newT);
    TestBean reloaded = dao.reload(newT);
    assertTrue(reloaded != newT);
    assertTrue(reloaded.getStringProp().equals(newT.getStringProp()));
    assertNotNull(list);

}

@Test
public void testAdding() throws Exception {
    //This will do a UPDATE test_bean SET longProp = longProp + 100
    int i = dao.update().add("longProp", 100).update();
    assertTrue(i > 0);

}

@Test
public void testRowMapper() throws Exception {
    List<Crap> craps = dao.query("select string_prop as name from test_bean limit ?", Crap.class, 2);
    System.out.println(craps.get(0).getName());

    craps = dao.query("select string_prop as name from test_bean limit ?")
                .with(2)
                .forList(Crap.class);

    Crap c = dao.query("select string_prop as name from test_bean limit ?")
                .with(1)
                .forObject(Crap.class);

    Optional<Crap> absent 
        = dao.query("select string_prop as name from test_bean where string_prop = ? limit ?")
            .with("never")
            .with(1)
            .forOptional(Crap.class);

    assertTrue(! absent.isPresent());

}

public static class Crap {

    private final String name;

    @JsonCreator
    public Crap(@JsonProperty ("name") String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

}

请注意，将任何查询映射到不可变 POJO 是多么容易。也就是说，您不需要将实体一对一地放到表格中。还要注意 Guava's optionals 的使用。 (最后一个查询..向下滚动)。我真的很讨厌 ORM 如何抛出异常或返回 null。

如果你喜欢它，请告诉我，我会花时间把它放在 github 上(仅使用 postgresql 进行测试)。否则，通过上面的信息，您可以使用 Spring JDBC 轻松实现自己的。我开始真正深入研究它，因为不可变对象(immutable对象)更容易理解和思考。