哪个 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 访问初始化是不够的，并且使类的实现复杂化。
应支持使用集合。如果更改了集合，则应从用户角度创建副本。（使旧集合状态过时。但用户代码仍然可以处理（或至少读取）它。就像持久数据结构的工作方式一样。
关于动机的一些话。假设您有一个 FP 样式的域对象模型。现在，您希望将其保存到数据库中。你是谁做的？你想以纯粹的功能风格做尽可能多的事情，直到邪恶的一面进来。例如，如果域对象模型不是不可变的，则可以不在线程之间共享对象。您必须复制，缓存或使用锁。因此，除非您的ORM支持不可变类型，否则您在选择解决方案时会受到限制。
更新：我创建了一个专注于解决这个问题的项目，称为JIRM：https://github.com/agentgt/jirm
我只是在使用Spring JDBC和Jackson Object Mapper实现我自己的问题后发现了这个问题。基本上，我只需要一些最低限度的SQL<>不可变对象映射。
简而言之，我只使用Spring RowMapper和Jackson的ObjectMapper从数据库中来回映射对象。我只对元数据使用JPA注释（如列名等）。如果人们感兴趣，我会清理它并将其放在github上（现在它只在我的创业公司的私人存储库中）。
这里有一个粗略的想法，它是如何工作的，这里有一个示例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的样子（请注意，它主要委托给Springs ColumnMapRowMapper，然后使用Jackson的对象映射器）：
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，并给了它一个流畅的包装器。以下是一些示例：
@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是多么容易。也就是说，您不需要它 1 对 1 的实体到表。另请注意番石榴的可选选项的使用（最后一个查询..向下滚动）。我真的很讨厌ORM如何抛出异常或返回。null
如果你喜欢它，请告诉我，我会花时间把它放在github上（只有teste与postgresql）。否则，有了上面的信息，您就可以使用Spring JDBC轻松实现自己的信息。我开始真正挖掘它，因为不可变对象更容易理解和思考。
