EclipseLink 没有使用嵌套的 Lazy OneToMany 关系填充 Lazy OneToOne
EclipseLink not populating Lazy OneToOne with nested Lazy OneToMany Relation
我从 Hibernate 迁移到 EclipseLink，因为我们需要复合主键，EclipseLink 可以很好地处理而 Hibernate 不能（真的不能！）。现在我正在修复我们的 JUnit 测试，我遇到了未加载大量 OneToMany 关系的问题。
我有以下 类:
DatabaseSession.java
package platform.data;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.stream.Collectors;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import javax.persistence.metamodel.Attribute;
import javax.persistence.metamodel.EntityType;
import javax.persistence.metamodel.Metamodel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import platform.accesscontrol.UserContext;
import pm.data.IndicatorSet;
/**
* Provides easy to use database sessions and transactions.
* <p>
* The session and transaction is automatically opened in the constructor.
* <p>
* The session must be closed using close(), which should be done with a try(...) { ...} block. If data is modified,
* the transaction must be committed explicitly using commit(), usually as the last statement in the
* try(...) { ...} block. Uncommitted transactions are automatically rolled back when the session is closed.
*/
public final class DatabaseSession implements AutoCloseable {
/**
* Maximum latency in milliseconds for a JPA operation, after which a warning shall be logged.
*/
private static final double MAX_LATENCY = 100.0;
/**
* Maximum duration in milliseconds for a session, after which a warning shall be logged.
*/
private static final double MAX_LATENCY_TOT = 1000.0;
/**
* Our logger, never null.
*/
private static final Logger log = LoggerFactory.getLogger(DatabaseSession.class);
/**
* The factory for creating EntityManager instances, created in initEntityManagerFactory() or in the constructor.
*/
private static EntityManagerFactory factory;
/**
* The EntityManager instance to access the database, created from the factory in the constructor.
*/
private EntityManager em;
/**
* The time when the instance was created, useful for measure total time of the session.
*/
private final long ttot = System.nanoTime();
/**
* Indicates whether commit() as been called.
*/
private boolean committed;
/**
* Initializes the EntityManagerFactory (optional, useful for testing).
* <p>
* If this method is not called, the EntityManagerFactory is initialized
* automatically with persistence unit "default" when the first instance is created.
* <p>
* Persistence units are defined in conf/META-INF/persistence.xml.
*
* @param persistenceUnitName the name of the persistence unit to be used,
* must match the XML attribute /persistence/persistence-unit/@name.
*/
public static void initEntityManagerFactory(String persistenceUnitName) {
synchronized(DatabaseSession.class) {
factory = Persistence.createEntityManagerFactory(persistenceUnitName);
}
}
public void shutdownDB(){
em.close();
em = null;
DatabaseSession.factory.close();
DatabaseSession.factory = null;
}
/**
* Opens a new session and begins a new transaction.
*/
public DatabaseSession() {
synchronized(DatabaseSession.class) {
if(factory == null) {
factory = Persistence.createEntityManagerFactory("default");
}
}
createEntityManager();
}
public void createEntityManager(){
em = factory.createEntityManager();
em.getTransaction().begin();
EntityType<IndicatorSet> entity = factory.getMetamodel().entity(IndicatorSet.class);
Set<Attribute<IndicatorSet, ?>> attrs = entity.getDeclaredAttributes();
attrs.toString();
}
@Override
public void close() {
try {
if (!committed) {
if(em != null){
em.getTransaction().rollback();
}
}
} finally {
if (committed) {
if(em != null){
em.close();
}
}
double latency = (System.nanoTime() - ttot)/1000000.0;
if(latency > MAX_LATENCY_TOT) {
log.warn("Duration of session was " + latency + "ms.");
} else {
log.debug("Duration of session was " + latency + "ms.");
}
}
}
/**
* Commits the transaction, must explicitly be done before the session is closed.
*/
public void commit()
{
long t = System.nanoTime();
em.flush();
em.getTransaction().commit();
committed = true;
double latency = (System.nanoTime() - t)/1000000.0;
if(latency > MAX_LATENCY) {
warn("Latency of commit() was %sms.", latency);
}
}
public <T extends PersistentRecord> List<T> loadAll(Class<T> clazz, String mandt) {
return loadAll(clazz, mandt, true);
}
public <T extends PersistentRecord> List<T> loadAll(Class<T> clazz, String mandt, boolean filterDeleted) {
log("loadAll(%s)", clazz.getSimpleName());
long t = System.nanoTime();
CriteriaBuilder b = em.getCriteriaBuilder();
CriteriaQuery<T> q = b.createQuery(clazz);
Metamodel m = em.getMetamodel();
EntityType<T> et = m.entity(clazz);
Root<T> r = q.from(clazz);
q.select(r);
if (mandt != null) {
q.where(b.equal(r.get(et.getAttribute("mandt").getName()), mandt));
}
if (filterDeleted) {
q.where(b.equal(r.get(et.getAttribute("deleted").getName()), 0));
}
List<T> result = em.createQuery(q).getResultList();
double latency = (System.nanoTime() - t)/1000000.0;
if(latency > MAX_LATENCY) {
warn("Latency of loadAll(%s) was %sms.", clazz.getSimpleName(), latency);
}
return result;
}
public <T extends PersistentRecord> int count(Class<T> clazz, String mandt) {
return count(clazz, mandt, true);
}
public <T extends PersistentRecord> int count(Class<T> clazz, String mandt, boolean filterDeleted) {
log("count(%s)", clazz.getSimpleName());
long t = System.nanoTime();
CriteriaBuilder b = em.getCriteriaBuilder();
CriteriaQuery<T> q = b.createQuery(clazz);
Metamodel m = em.getMetamodel();
EntityType<T> et = m.entity(clazz);
Root<T> r = q.from(clazz);
q.select(r);
if (mandt != null) {
q.where(b.equal(r.get(et.getAttribute("mandt").getName()), mandt));
}
if (filterDeleted) {
q.where(b.equal(r.get(et.getAttribute("deleted").getName()), 0));
}
List<T> result = em.createQuery(q).getResultList();
double latency = (System.nanoTime() - t)/1000000.0;
if(latency > MAX_LATENCY) {
warn("Latency of count(%s) was %sms.", clazz.getSimpleName(), latency);
}
return result.size();
}
public <T extends PersistentRecord> T load(Class<T> clazz, String mandt, String id) {
return load(clazz, mandt, id, true);
}
public <T extends PersistentRecord> T load(Class<T> clazz, String mandt, String id, boolean filterDeleted) {
log("load(%s, %s)", clazz.getSimpleName(), id);
long t = System.nanoTime();
T result = em.find(clazz, mandt != null ? new MandtId(mandt, id) : id);
if(result != null){
em.refresh(result); // TODO: This always results in a database hit, but relationship syncing is not meant to be done that way. Reduction of db hits can be achieved trough custom annotation or flag.
//JPA does not maintain relationships for you, the application is required to set both sides to stay in sync ("
}
if(filterDeleted) {
result = filterDeleted(result);
}
double latency = (System.nanoTime() - t)/1000000.0;
if(latency > MAX_LATENCY) {
warn("Latency of load(%s, %s) was %sms.", clazz.getSimpleName(), id, latency);
}
return result;
}
public <T extends PersistentRecord> List<T> loadByQuery(Class<T> clazz, String mandt, String query, Object... params) {
log("loadByQuery(%s, '%s', %s)", clazz.getSimpleName(), query, format(params));
long t = System.nanoTime();
TypedQuery<T> q = em.createQuery(query, clazz);
for(int i = 0; i < params.length; i++) {
q.setParameter(i+1, params[i]);
}
List<T> result = q.getResultList();
if (mandt != null) { // mandt can be null to allow queries without mandt
result = filterMandt(result, mandt); // as a safety measure we ensure mandt separation in db and application layer
}
result = filterDeleted(result);
double latency = (System.nanoTime() - t)/1000000.0;
if(latency > MAX_LATENCY) {
warn("Latency of loadByQuery(%s, '%s', %s) was %sms.", clazz.getSimpleName(), query, format(params), latency);
}
return result;
}
public <T extends PersistentRecord> T loadSingleByQuery(Class<T> clazz, String mandt, String query, Object... params) {
log("loadSingleByQuery(%s, '%s', %s)", clazz.getSimpleName(), query, format(params));
long t = System.nanoTime();
TypedQuery<T> q = em.createQuery(query, clazz);
for(int i = 0; i < params.length; i++) {
q.setParameter(i+1, params[i]);
}
List<T> result = q.getResultList();
if (mandt != null) { // mandt can be null to allow queries without mandt
result = filterMandt(result, mandt); // as a safety measure we ensure mandt separation in db and application layer
}
result = filterDeleted(result);
double latency = (System.nanoTime() - t)/1000000.0;
if(latency > MAX_LATENCY) {
warn("Latency of loadSingleByQuery(%s, '%s', %s) was %sms.", clazz.getSimpleName(), query, format(params), latency);
}
return result.size() > 0 ? result.get(0) : null;
}
/**
* Stores a new or updated record (resulting in an INSERT or UPDATE statement)
* @param record the record to be stored, must not be null.
* @param uc the user that initiated the operation, can be null.
* @return the given record, or another instance with the same ID if EntityManager.merge() was called.
*/
public <T extends PersistentRecord> T store(T record, UserContext uc) {
if(record == null) {
return null;
}
log("update(%s, %s)", record.getClass().getSimpleName(), record.getId());
if(record instanceof ReadWriteRecord) {
((ReadWriteRecord)record).touch(uc);
}
return add(record);
}
/**
* Deletes a record or marks a record as deleted (resulting in an UPDATE or maybe an INSERT statement if T is a subclass of ReadWriteRecord, or resulting in a DELETE statement otherwise).
* @param record the record to be deleted, must not be null.
* @param uc the user that initiated the operation, can be null.
* @return the given record, or another instance with the same ID if EntityManager.merge() was called.
*/
public <T extends PersistentRecord> T delete(T record, UserContext uc) {
if(record == null) {
return null;
}
log("delete(%s, %s)", record.getClass().getSimpleName(), record.getId());
if(record instanceof ReadWriteRecord) {
((ReadWriteRecord)record).setDeleted(true);
((ReadWriteRecord)record).touch(uc);
return add(record); // same as store(), we _dont_ physically delete the record
} else {
em.remove(record);
return null;
}
}
/**
* Physically deletes all records of a table, intended for JUnit tests only (unless you really want to get rid of your data).
* @param clazz the DTO class of the table.
*/
public <T extends PersistentRecord> void deleteAll(Class<T> clazz, String mandt) {
log("deleteAll(%s)", clazz.getSimpleName());
for(T rec : loadAll(clazz, mandt, false)) {
em.remove(rec);
}
}
/**
* Forces lazy initialization of an entity.
* @param record a record loaded from the database, can be null.
* @return the record passed to this method.
*/
public <T extends PersistentRecord> T fetch(T record) {
if(record != null) {
em.refresh(record);// TODO: This always results in a database hit, but relationship syncing is not meant to be done that way. Reduction of db hits can be achieved trough custom annotation or flag.
//JPA does not maintain relationships for you, the application is required to set both sides to stay in sync (
record.fetch();
}
return record;
}
/**
* Forces lazy initialization of an entity.
* @param record a record loaded from the database, can be null.
* @param fetcher a method to be invoked on the record to lazy initialize nested fields.
* @return the record passed to this method.
*/
public <T extends PersistentRecord> T fetch(T record, BiConsumer<DatabaseSession, T> fetcher) {
if(record != null) {
em.refresh(record); // TODO: This always results in a database hit, but relationship syncing is not meant to be done that way. Reduction of db hits can be achieved trough custom annotation or flag.
//JPA does not maintain relationships for you, the application is required to set both sides to stay in sync (
record.fetch();
fetcher.accept(this, record);
}
return record;
}
/**
* Forces lazy initialization of multiple entities.
* @param records a list of records loaded from the database, can be null.
* @param fetcher a method to be invoked on the records to lazy initialize nested fields.
* @return the list of records passed to this method.
*/
public <T extends PersistentRecord> List<T> fetch(List<T> records, BiConsumer<DatabaseSession, T> fetcher) {
if(records != null) {
for(T record : records) {
em.refresh(record); // TODO: This always results in a database hit, but relationship syncing is not meant to be done that way. Reduction of db hits can be achieved trough custom annotation or flag.
//JPA does not maintain relationships for you, the application is required to set both sides to stay in sync (
record.fetch();
fetcher.accept(this, record);
}
}
return records;
}
/**
* Forces lazy initialization of a one-to-many relationship.
* @param records a list representing a one-to-many relationship, can be null.
* @return the relationship passed to this method.
*/
public <T extends PersistentRecord> List<T> fetchCollection(List<T> records) {
if(records != null) {
records.size();
}
return records;
}
/**
* Adds the given record to the EntityManager, called by store() and delete().
* <p>
* This method attempts to do something like Hibernate's saveOrUpdate(), which is not available in JPA:
* <ul>
* <li> For newly created records, EntityManager.persist() has to be called in order so insert the record.
* This case will be assumed when markNew() has been called on the record.
* <li> For records that have been read from the database by _another_ session (so-called detached entities),
* EntityManager.merge() has to be called in order to update the record.
* This case will be assumed when markNew() has NOT been called on the record.
* <li> For records that have been read from the database by this session, nothing has to be done because the
* EntityManager takes care of the entities it loaded. This case can be detected easily using contains().
* </ul>
* Note: EntityManager.merge() does not add the entity to the session.
* Instead, a new entity is created and all properties are copied from the given record to the new entity.
*
* @param record the record to be added, can be null.
* @return the given record, or another instance with the same ID if EntityManager.merge() was called.
*/
private <T extends PersistentRecord> T add(T record) {
long t = System.nanoTime();
try {
if (record == null || em.contains(record)) {
return record;
} else if(record.mustInsert) {
em.persist(record); // will result in INSERT
record.mustInsert = false;
return record;
} else {
record = em.merge(record);
return record;
}
} finally {
double latency = (System.nanoTime() - t)/1000000.0;
if(latency > MAX_LATENCY) {
warn("Latency of add(%s, %s) was %sms.", record.getClass().getSimpleName(), record.getId(), latency);
}
}
}
private static <T extends PersistentRecord> List<T> filterDeleted(List<T> records) {
if(records != null) {
records = records.stream().
filter(record -> (record instanceof ReadWriteRecord) == false || ((ReadWriteRecord) record).getDeleted() == false).
collect(Collectors.toList());
}
return records;
}
private static <T extends PersistentRecord> List<T> filterMandt(List<T> records, String mandt) {
if(records != null) {
records = records.stream().
filter(record -> Objects.equals(record.getMandt(), mandt)).
collect(Collectors.toList());
}
return records;
}
private static <T extends PersistentRecord> T filterDeleted(T record) {
if(record != null && record instanceof ReadWriteRecord) {
if(((ReadWriteRecord) record).getDeleted()) {
record = null;
}
}
return record;
}
private void log(String format, Object... args) {
if(log.isDebugEnabled()) {
log.debug(String.format(format, args));
}
}
private void warn(String format, Object... args) {
if(log.isWarnEnabled()) {
log.warn(String.format(format, args));
}
}
private static String format(Object... args) {
StringBuilder sb = new StringBuilder();
sb.append("[");
for(Object arg: args) {
if(sb.length() > 1)
sb.append(", ");
sb.append(arg);
}
sb.append("]");
return sb.toString();
}
// For debugging
public Query createQuery(String string) {
return em.createQuery(string);
}
}
Project.java
package pm.data;
...common imports...
import platform.data.DatabaseBindingIds;
import platform.data.MandtId;
import platform.data.PropertySet;
import platform.data.ReadWriteRecord;
import resource.data.Resource;
@Entity
@IdClass(MandtId.class)
public class Project extends ReadWriteRecord {
@Id
@Column(name=DatabaseBindingIds.PROJECT_TENANT)
private String mandt;
@Id
@Column(name=DatabaseBindingIds.PROJECT_ID)
private String entityId;
@OneToOne(fetch=FetchType.LAZY, cascade= CascadeType.ALL) // one to one mappings are directly mapped using the project primary keys
@JoinColumns( {
@JoinColumn(name=DatabaseBindingIds.PROJECT_TENANT, referencedColumnName=DatabaseBindingIds.PROPERTYSET_TENANT, insertable=false, updatable=false),
@JoinColumn(name=DatabaseBindingIds.PROJECT_ID, referencedColumnName=DatabaseBindingIds.PROPERTYSET_ID, insertable=false, updatable=false)
} )
private PropertySet propertySet;
@OneToOne(fetch=FetchType.LAZY, cascade = CascadeType.ALL) // one to one mappings are directly mapped using the project report primary keys
@JoinColumns( {
@JoinColumn(name=DatabaseBindingIds.PROJECTREPORT_TENANT, referencedColumnName=DatabaseBindingIds.INDICATORSET_TENANT, insertable=false, updatable=false),
@JoinColumn(name=DatabaseBindingIds.PROJECTREPORT_ID, referencedColumnName=DatabaseBindingIds.INDICATORSET_ID, insertable=false, updatable=false)
} )
private IndicatorSet indicatorSet; // SAMPLE NOTE: The indicator set is essentially the same thing as the property set.
...other member variables...
@Override
public String getMandt() {
return mandt;
}
@Override
public String getId() {
return entityId;
}
@Override
public void setId(MandtId x) {
markNew();
mandt = x != null ? x.getMandt() : null;
entityId = x != null ? x.getId() : null;
propertySet = new PropertySet();
propertySet.setId(x);
}
public PropertySet getPropertySet() {
return propertySet;
}
...getters and setters for other member variables...
}
PropertySet.java
package platform.data;
import java.util.ArrayList;
import java.util.List;
...common imports...
@Entity
@IdClass(MandtId.class)
public class PropertySet extends ReadWriteRecord {
@Id
@Column(name=DatabaseBindingIds.PROPERTYSET_TENANT)
private String mandt;
@Id
@Column(name=DatabaseBindingIds.PROPERTYSET_ID)
private String entityId;
@OneToMany(mappedBy="propertySet", fetch=FetchType.EAGER)
@OrderBy("sortIndex")
private List<Property> properties;
@Override
public String getMandt() {
return mandt;
}
@Override
public String getId() {
return entityId;
}
@Override
public void setId(MandtId x) {
markNew();
mandt = x != null ? x.getMandt() : null;
entityId = x != null ? x.getId() : null;
}
public List<Property> getProperties() {
if(properties == null) {
properties = new ArrayList<>();
}
return properties;
}
}
Property.java
package platform.data;
...common imports...
@Entity
@IdClass(MandtId.class)
public class Property extends ReadWriteRecord {
@Id
@Column(name=DatabaseBindingIds.PROPERTY_TENANT)
private String mandt;
@Id
@Column(name=DatabaseBindingIds.PROPERTY_ID)
private String entityId;
@ManyToOne(fetch=FetchType.EAGER, optional=false)
@JoinColumns( {
@JoinColumn(name=DatabaseBindingIds.PROPERTY_TENANT, referencedColumnName=DatabaseBindingIds.PROPERTYSET_TENANT, insertable=false, updatable=false),
@JoinColumn(name=DatabaseBindingIds.PROPERTY_PROPERTYSET_ID, referencedColumnName=DatabaseBindingIds.PROPERTYSET_ID, insertable=true, updatable=true)
} )
private PropertySet propertySet;
@Column
private Integer sortIndex;
@Column
private String key;
@Column
@Convert(converter = IntlStringConverter.class)
private IntlString label;
@Column
private String type;
@Column
private String value;
@Override
public String getMandt() {
return mandt;
}
@Override
public String getId() {
return entityId;
}
@Override
public void setId(MandtId x) {
markNew();
mandt = x != null ? x.getMandt() : null;
entityId = x != null ? x.getId() : null;
}
public void setPropertySet(PropertySet x) {
propertySet = x;
}
public PropertySet getPropertySet() {
return propertySet;
}
public int getSortIndex() {
return sortIndex == null ? 0 : sortIndex;
}
public void setSortIndex(int x) {
sortIndex = x;
}
public String getKey() {
return key;
}
public void setKey(String x) {
key = x;
}
public IntlString getLabel() {
return label;
}
public void setLabel(IntlString x) {
label = x;
}
public String getType() {
return type;
}
public void setType(String x) {
type = x;
}
public String getValue() {
return value;
}
public void setValue(String x) {
value = x;
}
}
MandtId.java
复合主键 IDClass.
package platform.data;
import java.io.Serializable;
import java.util.Objects;
/**
* @author sm
* Class to map MANDT and *ID field as composite key
*/
@SuppressWarnings("serial")
public class MandtId implements Serializable {
private String mandt;
private String entityId;
...setters and getters...
@Override
public int hashCode()
...
@Override
public boolean equals(Object other)
...
@Override
public String toString()
...
}
我们像这样在每个单元测试之前插入条目：
try(DatabaseSession db = new DatabaseSession()) {
Project prjT = createProject(db, UUID_PROJECT_NEW, "<New Project>");
createProperty(db, prjT.getPropertySet(), "prj-prop1", "Property 1", "string", "<New Value 1>", 2);
createProperty(db, prjT.getPropertySet(), "prj-prop2", "Property 2", "string", "<New Value 2>", 1);
db.commit();
}
public static Project createProject(DatabaseSession db, String id, String name) {
Project prj = new Project();
prj.setId(new MandtId(MANDT, id));
prj.setName(name);
prj.setStatus(UUID_PROJECT_STATUS_ACTIVE);
db.store(prj.getPropertySet(), null); // workaround: persist child first (otherwise PropertySet will stay marked as new)
db.store(prj, null);
return prj;
}
public static Property createProperty(DatabaseSession db, PropertySet ps, String key, String label, String type, String value, int sortIndex) {
Property rec = new Property();
rec.setId(new MandtId(MANDT, UuidString.generateNew()));
rec.setPropertySet(ps);
rec.setKey(key);
rec.setLabel(IntlStrings.wrap(label));
rec.setType(type);
rec.setValue(value);
rec.setSortIndex(sortIndex);
ps.getProperties().add(rec);
db.store(rec.getPropertySet(), null);
db.store(rec, null);
// rec.properties.add(p);
return rec;
}
如果我稍后尝试获取该项目，我会：
@Override
public Project loadProject(String projectId) throws DataAccessException {
try(DatabaseSession session = new DatabaseSession()) {
return session.fetch(session.load(Project.class, mandt, projectId), (s, r) -> {
s.fetch(r.getPropertySet());
s.fetch(r.getOwner());
s.fetch(r.getResponsibility());
s.fetch(r.getProjectGuideline());
});
} catch(RuntimeException e) {
throw new DataAccessException(e);
}
}
但是 属性set 在这种情况下保持为空。它甚至没有初始化。当我初始化它时，它保持为空。我可以通过在其上使用 em.refresh 来修复其他提取，但我已经添加了一个 TODO，因为刷新总是会导致数据库命中。 属性 实体在数据库中，我可以通过单独的特定 SELECT 查询找到它。
这个数据库设置的主要需求是我们支持数据库内容的高并发编辑。由于数据库通过原子化提交解决了并发问题，我想我在这里是安全的。
我看到的一个问题是，在添加具有双向关系的实体时，我没有将它们添加到两侧，但是当我稍后再次加载它们时是否应该再次修复这个问题（可能不是因为它们被缓存）？此外，它也没有解决我在直接 OneToMany 关系中遇到的任何其他问题（与此处嵌套 OneToMany 的 OneToOne 相比），我仍然需要 em.refresh(...)。如果 em 在服务器环境中，它们是否以无竞争的方式维护实体？
如果您需要更多信息，请告诉我。
编辑：
问题似乎与我在这里进行的单元测试设置有关，内存中的 H2 数据库似乎与 eclipselink 混淆，但是以下注释在生产系统（MsSQL 上的 eclipselink）中运行良好:
Project.java
package pm.data;
...common imports...
import platform.data.DatabaseBindingIds;
import platform.data.MandtId;
import platform.data.PropertySet;
import platform.data.ReadWriteRecord;
import resource.data.Resource;
@Entity
@IdClass(MandtId.class)
public class Project extends ReadWriteRecord {
@Id
@Column(name=DatabaseBindingIds.PROJECT_TENANT)
private String mandt;
@Id
@Column(name=DatabaseBindingIds.PROJECT_ID)
private String entityId;
@OneToOne(fetch=FetchType.LAZY, cascade= CascadeType.ALL) // one to one mappings are directly mapped using the project primary keys
@JoinColumns( {
@JoinColumn(name=DatabaseBindingIds.PROJECT_TENANT, referencedColumnName=DatabaseBindingIds.PROPERTYSET_TENANT, insertable=false, updatable=true),
@JoinColumn(name=DatabaseBindingIds.PROJECT_ID, referencedColumnName=DatabaseBindingIds.PROPERTYSET_ID, insertable=false, updatable=true)
} )
private PropertySet propertySet;
@OneToOne(fetch=FetchType.LAZY, cascade = CascadeType.ALL) // one to one mappings are directly mapped using the project report primary keys
@JoinColumns( {
@JoinColumn(name=DatabaseBindingIds.PROJECTREPORT_TENANT, referencedColumnName=DatabaseBindingIds.INDICATORSET_TENANT, insertable=false, updatable=false),
@JoinColumn(name=DatabaseBindingIds.PROJECTREPORT_ID, referencedColumnName=DatabaseBindingIds.INDICATORSET_ID, insertable=false, updatable=false)
} )
private IndicatorSet indicatorSet; // NOTE: Yes, the updatable are false here and are only true in one set.
...other member variables...
...same as above...
...getters and setters for other member variables...
}
PropertySet.java
package platform.data;
import java.util.ArrayList;
import java.util.List;
...common imports...
@Entity
@IdClass(MandtId.class)
@Cache(isolation=CacheIsolationType.ISOLATED) // Fix turns off EclipseLink cache for PropertySet
public class PropertySet extends ReadWriteRecord {
...same as above...
我接受了 Chris 的回答，因为它帮助我理解了发生的问题以及缓存的工作原理。对于 PropertySet，我必须关闭缓存。修复问题的选项列表也很有帮助。
I get issues with tons of OneToMany relations not loaded
它们可能无法加载的原因是因为默认行为是延迟加载这些关系，这意味着相关实体不会在加载父实体时加载。
在这个例子中，当你加载 Project 时，PropertySet 及其子项不会被加载，因为下面一行：
@OneToOne(fetch=FetchType.LAZY, cascade= CascadeType.ALL)
在这里，您告诉持久性提供程序它应该延迟加载相关的 PropertySet。所以你得到了预期的行为。如果您希望在加载 Project 实例时加载相关实体，则必须从 @OneToOne 注释中删除 fetch 属性。
I could fix other fetches by using em.refresh on it ...
我不明白为什么您首先使用 find() 调用加载实体，然后在下一行中使用 refresh()。 refresh() 的目的是如果您的实体长时间处于持久性上下文中，并且您预计数据库中可能会有新的更改，而您的示例代码中并非如此。
您提到的问题与 Project->PropertySet 关系有关，这是一个严格的 OneToOne 映射，显示的实体没有显示 OneToMany 涉及该问题。由于不是双向的，所以和传统的不设置后向指针没有关系，但是有点关系
问题是因为这个 OneToOne 映射的外键也是项目 ID 字段，它们被映射为可写的基本映射。为了解决多重可写映射异常，您已将 Project.propertySet 映射的连接列标记为 insertable=false、updatable=false，实质上告诉 EclipseLink 此映射是只读的。所以当你设置或更改关系时，这个 'change' 会被忽略，不会合并到缓存中。这会导致您创建的实体在从缓存中读取时始终对此引用具有空值，除非它是来自数据库的refreshed/reloaded。这只会影响二级缓存，因此不会显示在创建它的 EntityManager 中，除非它被清除。
有几种方法可以解决这个问题，最好的方法取决于您的应用程序的使用情况。
禁用共享缓存。
这可以为每个实体或特定实体完成。看
有关详细信息，请访问 eclipseLink faq。这是最简单的选择
会给你类似于 Hibernate 的结果，它不启用
默认二级缓存，但除非有
是不使用二级缓存的其他考虑因素，因为它
以性能为代价。
更改Project中的基本ID映射字段以使用
可插入=假，可更新=假。然后你删除
insertable=false, updatable=false 来自连接列，允许
OneToOne 映射来控制您的主键。功能上这个
不应以任何方式更改您的应用程序。如果你得到相同的
基本映射问题，本机 EclipseLink postClone
方法可用于设置引用映射中的字段，或者
您的实体 get 方法可以快速检查是否有 PropertySet
并在返回 null 之前使用该值。
使用 JPA 2.0 的派生 ID。 JPA 允许将关系标记为 ID，从而无需为相同的值设置这两个基本映射。或者您可以使用关系上的 @MapsId 来告诉 JPA 关系控制值，JPA 将为您设置这些字段。使用@MapsId 需要使用您的 pk class 作为嵌入式 ID，并且看起来像：
@Entity
public class Project extends ReadWriteRecord {
@EmbeddedId
private MandtId mandtId;
@MapsId("mandtId")
@OneToOne(fetch=FetchType.LAZY, cascade= CascadeType.ALL) // one to one mappings are directly mapped using the project primary keys
@JoinColumns( {
@JoinColumn(name=DatabaseBindingIds.PROJECT_TENANT, referencedColumnName=DatabaseBindingIds.PROPERTYSET_TENANT, insertable=false, updatable=false),
@JoinColumn(name=DatabaseBindingIds.PROJECT_ID, referencedColumnName=DatabaseBindingIds.PROPERTYSET_ID, insertable=false, updatable=false)
} )
private PropertySet propertySet;
我从 Hibernate 迁移到 EclipseLink，因为我们需要复合主键，EclipseLink 可以很好地处理而 Hibernate 不能（真的不能！）。现在我正在修复我们的 JUnit 测试，我遇到了未加载大量 OneToMany 关系的问题。
我有以下 类:
DatabaseSession.java
package platform.data;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.stream.Collectors;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import javax.persistence.metamodel.Attribute;
import javax.persistence.metamodel.EntityType;
import javax.persistence.metamodel.Metamodel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import platform.accesscontrol.UserContext;
import pm.data.IndicatorSet;
/**
* Provides easy to use database sessions and transactions.
* <p>
* The session and transaction is automatically opened in the constructor.
* <p>
* The session must be closed using close(), which should be done with a try(...) { ...} block. If data is modified,
* the transaction must be committed explicitly using commit(), usually as the last statement in the
* try(...) { ...} block. Uncommitted transactions are automatically rolled back when the session is closed.
*/
public final class DatabaseSession implements AutoCloseable {
/**
* Maximum latency in milliseconds for a JPA operation, after which a warning shall be logged.
*/
private static final double MAX_LATENCY = 100.0;
/**
* Maximum duration in milliseconds for a session, after which a warning shall be logged.
*/
private static final double MAX_LATENCY_TOT = 1000.0;
/**
* Our logger, never null.
*/
private static final Logger log = LoggerFactory.getLogger(DatabaseSession.class);
/**
* The factory for creating EntityManager instances, created in initEntityManagerFactory() or in the constructor.
*/
private static EntityManagerFactory factory;
/**
* The EntityManager instance to access the database, created from the factory in the constructor.
*/
private EntityManager em;
/**
* The time when the instance was created, useful for measure total time of the session.
*/
private final long ttot = System.nanoTime();
/**
* Indicates whether commit() as been called.
*/
private boolean committed;
/**
* Initializes the EntityManagerFactory (optional, useful for testing).
* <p>
* If this method is not called, the EntityManagerFactory is initialized
* automatically with persistence unit "default" when the first instance is created.
* <p>
* Persistence units are defined in conf/META-INF/persistence.xml.
*
* @param persistenceUnitName the name of the persistence unit to be used,
* must match the XML attribute /persistence/persistence-unit/@name.
*/
public static void initEntityManagerFactory(String persistenceUnitName) {
synchronized(DatabaseSession.class) {
factory = Persistence.createEntityManagerFactory(persistenceUnitName);
}
}
public void shutdownDB(){
em.close();
em = null;
DatabaseSession.factory.close();
DatabaseSession.factory = null;
}
/**
* Opens a new session and begins a new transaction.
*/
public DatabaseSession() {
synchronized(DatabaseSession.class) {
if(factory == null) {
factory = Persistence.createEntityManagerFactory("default");
}
}
createEntityManager();
}
public void createEntityManager(){
em = factory.createEntityManager();
em.getTransaction().begin();
EntityType<IndicatorSet> entity = factory.getMetamodel().entity(IndicatorSet.class);
Set<Attribute<IndicatorSet, ?>> attrs = entity.getDeclaredAttributes();
attrs.toString();
}
@Override
public void close() {
try {
if (!committed) {
if(em != null){
em.getTransaction().rollback();
}
}
} finally {
if (committed) {
if(em != null){
em.close();
}
}
double latency = (System.nanoTime() - ttot)/1000000.0;
if(latency > MAX_LATENCY_TOT) {
log.warn("Duration of session was " + latency + "ms.");
} else {
log.debug("Duration of session was " + latency + "ms.");
}
}
}
/**
* Commits the transaction, must explicitly be done before the session is closed.
*/
public void commit()
{
long t = System.nanoTime();
em.flush();
em.getTransaction().commit();
committed = true;
double latency = (System.nanoTime() - t)/1000000.0;
if(latency > MAX_LATENCY) {
warn("Latency of commit() was %sms.", latency);
}
}
public <T extends PersistentRecord> List<T> loadAll(Class<T> clazz, String mandt) {
return loadAll(clazz, mandt, true);
}
public <T extends PersistentRecord> List<T> loadAll(Class<T> clazz, String mandt, boolean filterDeleted) {
log("loadAll(%s)", clazz.getSimpleName());
long t = System.nanoTime();
CriteriaBuilder b = em.getCriteriaBuilder();
CriteriaQuery<T> q = b.createQuery(clazz);
Metamodel m = em.getMetamodel();
EntityType<T> et = m.entity(clazz);
Root<T> r = q.from(clazz);
q.select(r);
if (mandt != null) {
q.where(b.equal(r.get(et.getAttribute("mandt").getName()), mandt));
}
if (filterDeleted) {
q.where(b.equal(r.get(et.getAttribute("deleted").getName()), 0));
}
List<T> result = em.createQuery(q).getResultList();
double latency = (System.nanoTime() - t)/1000000.0;
if(latency > MAX_LATENCY) {
warn("Latency of loadAll(%s) was %sms.", clazz.getSimpleName(), latency);
}
return result;
}
public <T extends PersistentRecord> int count(Class<T> clazz, String mandt) {
return count(clazz, mandt, true);
}
public <T extends PersistentRecord> int count(Class<T> clazz, String mandt, boolean filterDeleted) {
log("count(%s)", clazz.getSimpleName());
long t = System.nanoTime();
CriteriaBuilder b = em.getCriteriaBuilder();
CriteriaQuery<T> q = b.createQuery(clazz);
Metamodel m = em.getMetamodel();
EntityType<T> et = m.entity(clazz);
Root<T> r = q.from(clazz);
q.select(r);
if (mandt != null) {
q.where(b.equal(r.get(et.getAttribute("mandt").getName()), mandt));
}
if (filterDeleted) {
q.where(b.equal(r.get(et.getAttribute("deleted").getName()), 0));
}
List<T> result = em.createQuery(q).getResultList();
double latency = (System.nanoTime() - t)/1000000.0;
if(latency > MAX_LATENCY) {
warn("Latency of count(%s) was %sms.", clazz.getSimpleName(), latency);
}
return result.size();
}
public <T extends PersistentRecord> T load(Class<T> clazz, String mandt, String id) {
return load(clazz, mandt, id, true);
}
public <T extends PersistentRecord> T load(Class<T> clazz, String mandt, String id, boolean filterDeleted) {
log("load(%s, %s)", clazz.getSimpleName(), id);
long t = System.nanoTime();
T result = em.find(clazz, mandt != null ? new MandtId(mandt, id) : id);
if(result != null){
em.refresh(result); // TODO: This always results in a database hit, but relationship syncing is not meant to be done that way. Reduction of db hits can be achieved trough custom annotation or flag.
//JPA does not maintain relationships for you, the application is required to set both sides to stay in sync ("
}
if(filterDeleted) {
result = filterDeleted(result);
}
double latency = (System.nanoTime() - t)/1000000.0;
if(latency > MAX_LATENCY) {
warn("Latency of load(%s, %s) was %sms.", clazz.getSimpleName(), id, latency);
}
return result;
}
public <T extends PersistentRecord> List<T> loadByQuery(Class<T> clazz, String mandt, String query, Object... params) {
log("loadByQuery(%s, '%s', %s)", clazz.getSimpleName(), query, format(params));
long t = System.nanoTime();
TypedQuery<T> q = em.createQuery(query, clazz);
for(int i = 0; i < params.length; i++) {
q.setParameter(i+1, params[i]);
}
List<T> result = q.getResultList();
if (mandt != null) { // mandt can be null to allow queries without mandt
result = filterMandt(result, mandt); // as a safety measure we ensure mandt separation in db and application layer
}
result = filterDeleted(result);
double latency = (System.nanoTime() - t)/1000000.0;
if(latency > MAX_LATENCY) {
warn("Latency of loadByQuery(%s, '%s', %s) was %sms.", clazz.getSimpleName(), query, format(params), latency);
}
return result;
}
public <T extends PersistentRecord> T loadSingleByQuery(Class<T> clazz, String mandt, String query, Object... params) {
log("loadSingleByQuery(%s, '%s', %s)", clazz.getSimpleName(), query, format(params));
long t = System.nanoTime();
TypedQuery<T> q = em.createQuery(query, clazz);
for(int i = 0; i < params.length; i++) {
q.setParameter(i+1, params[i]);
}
List<T> result = q.getResultList();
if (mandt != null) { // mandt can be null to allow queries without mandt
result = filterMandt(result, mandt); // as a safety measure we ensure mandt separation in db and application layer
}
result = filterDeleted(result);
double latency = (System.nanoTime() - t)/1000000.0;
if(latency > MAX_LATENCY) {
warn("Latency of loadSingleByQuery(%s, '%s', %s) was %sms.", clazz.getSimpleName(), query, format(params), latency);
}
return result.size() > 0 ? result.get(0) : null;
}
/**
* Stores a new or updated record (resulting in an INSERT or UPDATE statement)
* @param record the record to be stored, must not be null.
* @param uc the user that initiated the operation, can be null.
* @return the given record, or another instance with the same ID if EntityManager.merge() was called.
*/
public <T extends PersistentRecord> T store(T record, UserContext uc) {
if(record == null) {
return null;
}
log("update(%s, %s)", record.getClass().getSimpleName(), record.getId());
if(record instanceof ReadWriteRecord) {
((ReadWriteRecord)record).touch(uc);
}
return add(record);
}
/**
* Deletes a record or marks a record as deleted (resulting in an UPDATE or maybe an INSERT statement if T is a subclass of ReadWriteRecord, or resulting in a DELETE statement otherwise).
* @param record the record to be deleted, must not be null.
* @param uc the user that initiated the operation, can be null.
* @return the given record, or another instance with the same ID if EntityManager.merge() was called.
*/
public <T extends PersistentRecord> T delete(T record, UserContext uc) {
if(record == null) {
return null;
}
log("delete(%s, %s)", record.getClass().getSimpleName(), record.getId());
if(record instanceof ReadWriteRecord) {
((ReadWriteRecord)record).setDeleted(true);
((ReadWriteRecord)record).touch(uc);
return add(record); // same as store(), we _dont_ physically delete the record
} else {
em.remove(record);
return null;
}
}
/**
* Physically deletes all records of a table, intended for JUnit tests only (unless you really want to get rid of your data).
* @param clazz the DTO class of the table.
*/
public <T extends PersistentRecord> void deleteAll(Class<T> clazz, String mandt) {
log("deleteAll(%s)", clazz.getSimpleName());
for(T rec : loadAll(clazz, mandt, false)) {
em.remove(rec);
}
}
/**
* Forces lazy initialization of an entity.
* @param record a record loaded from the database, can be null.
* @return the record passed to this method.
*/
public <T extends PersistentRecord> T fetch(T record) {
if(record != null) {
em.refresh(record);// TODO: This always results in a database hit, but relationship syncing is not meant to be done that way. Reduction of db hits can be achieved trough custom annotation or flag.
//JPA does not maintain relationships for you, the application is required to set both sides to stay in sync (
record.fetch();
}
return record;
}
/**
* Forces lazy initialization of an entity.
* @param record a record loaded from the database, can be null.
* @param fetcher a method to be invoked on the record to lazy initialize nested fields.
* @return the record passed to this method.
*/
public <T extends PersistentRecord> T fetch(T record, BiConsumer<DatabaseSession, T> fetcher) {
if(record != null) {
em.refresh(record); // TODO: This always results in a database hit, but relationship syncing is not meant to be done that way. Reduction of db hits can be achieved trough custom annotation or flag.
//JPA does not maintain relationships for you, the application is required to set both sides to stay in sync (
record.fetch();
fetcher.accept(this, record);
}
return record;
}
/**
* Forces lazy initialization of multiple entities.
* @param records a list of records loaded from the database, can be null.
* @param fetcher a method to be invoked on the records to lazy initialize nested fields.
* @return the list of records passed to this method.
*/
public <T extends PersistentRecord> List<T> fetch(List<T> records, BiConsumer<DatabaseSession, T> fetcher) {
if(records != null) {
for(T record : records) {
em.refresh(record); // TODO: This always results in a database hit, but relationship syncing is not meant to be done that way. Reduction of db hits can be achieved trough custom annotation or flag.
//JPA does not maintain relationships for you, the application is required to set both sides to stay in sync (
record.fetch();
fetcher.accept(this, record);
}
}
return records;
}
/**
* Forces lazy initialization of a one-to-many relationship.
* @param records a list representing a one-to-many relationship, can be null.
* @return the relationship passed to this method.
*/
public <T extends PersistentRecord> List<T> fetchCollection(List<T> records) {
if(records != null) {
records.size();
}
return records;
}
/**
* Adds the given record to the EntityManager, called by store() and delete().
* <p>
* This method attempts to do something like Hibernate's saveOrUpdate(), which is not available in JPA:
* <ul>
* <li> For newly created records, EntityManager.persist() has to be called in order so insert the record.
* This case will be assumed when markNew() has been called on the record.
* <li> For records that have been read from the database by _another_ session (so-called detached entities),
* EntityManager.merge() has to be called in order to update the record.
* This case will be assumed when markNew() has NOT been called on the record.
* <li> For records that have been read from the database by this session, nothing has to be done because the
* EntityManager takes care of the entities it loaded. This case can be detected easily using contains().
* </ul>
* Note: EntityManager.merge() does not add the entity to the session.
* Instead, a new entity is created and all properties are copied from the given record to the new entity.
*
* @param record the record to be added, can be null.
* @return the given record, or another instance with the same ID if EntityManager.merge() was called.
*/
private <T extends PersistentRecord> T add(T record) {
long t = System.nanoTime();
try {
if (record == null || em.contains(record)) {
return record;
} else if(record.mustInsert) {
em.persist(record); // will result in INSERT
record.mustInsert = false;
return record;
} else {
record = em.merge(record);
return record;
}
} finally {
double latency = (System.nanoTime() - t)/1000000.0;
if(latency > MAX_LATENCY) {
warn("Latency of add(%s, %s) was %sms.", record.getClass().getSimpleName(), record.getId(), latency);
}
}
}
private static <T extends PersistentRecord> List<T> filterDeleted(List<T> records) {
if(records != null) {
records = records.stream().
filter(record -> (record instanceof ReadWriteRecord) == false || ((ReadWriteRecord) record).getDeleted() == false).
collect(Collectors.toList());
}
return records;
}
private static <T extends PersistentRecord> List<T> filterMandt(List<T> records, String mandt) {
if(records != null) {
records = records.stream().
filter(record -> Objects.equals(record.getMandt(), mandt)).
collect(Collectors.toList());
}
return records;
}
private static <T extends PersistentRecord> T filterDeleted(T record) {
if(record != null && record instanceof ReadWriteRecord) {
if(((ReadWriteRecord) record).getDeleted()) {
record = null;
}
}
return record;
}
private void log(String format, Object... args) {
if(log.isDebugEnabled()) {
log.debug(String.format(format, args));
}
}
private void warn(String format, Object... args) {
if(log.isWarnEnabled()) {
log.warn(String.format(format, args));
}
}
private static String format(Object... args) {
StringBuilder sb = new StringBuilder();
sb.append("[");
for(Object arg: args) {
if(sb.length() > 1)
sb.append(", ");
sb.append(arg);
}
sb.append("]");
return sb.toString();
}
// For debugging
public Query createQuery(String string) {
return em.createQuery(string);
}
}
Project.java
package pm.data;
...common imports...
import platform.data.DatabaseBindingIds;
import platform.data.MandtId;
import platform.data.PropertySet;
import platform.data.ReadWriteRecord;
import resource.data.Resource;
@Entity
@IdClass(MandtId.class)
public class Project extends ReadWriteRecord {
@Id
@Column(name=DatabaseBindingIds.PROJECT_TENANT)
private String mandt;
@Id
@Column(name=DatabaseBindingIds.PROJECT_ID)
private String entityId;
@OneToOne(fetch=FetchType.LAZY, cascade= CascadeType.ALL) // one to one mappings are directly mapped using the project primary keys
@JoinColumns( {
@JoinColumn(name=DatabaseBindingIds.PROJECT_TENANT, referencedColumnName=DatabaseBindingIds.PROPERTYSET_TENANT, insertable=false, updatable=false),
@JoinColumn(name=DatabaseBindingIds.PROJECT_ID, referencedColumnName=DatabaseBindingIds.PROPERTYSET_ID, insertable=false, updatable=false)
} )
private PropertySet propertySet;
@OneToOne(fetch=FetchType.LAZY, cascade = CascadeType.ALL) // one to one mappings are directly mapped using the project report primary keys
@JoinColumns( {
@JoinColumn(name=DatabaseBindingIds.PROJECTREPORT_TENANT, referencedColumnName=DatabaseBindingIds.INDICATORSET_TENANT, insertable=false, updatable=false),
@JoinColumn(name=DatabaseBindingIds.PROJECTREPORT_ID, referencedColumnName=DatabaseBindingIds.INDICATORSET_ID, insertable=false, updatable=false)
} )
private IndicatorSet indicatorSet; // SAMPLE NOTE: The indicator set is essentially the same thing as the property set.
...other member variables...
@Override
public String getMandt() {
return mandt;
}
@Override
public String getId() {
return entityId;
}
@Override
public void setId(MandtId x) {
markNew();
mandt = x != null ? x.getMandt() : null;
entityId = x != null ? x.getId() : null;
propertySet = new PropertySet();
propertySet.setId(x);
}
public PropertySet getPropertySet() {
return propertySet;
}
...getters and setters for other member variables...
}
PropertySet.java
package platform.data;
import java.util.ArrayList;
import java.util.List;
...common imports...
@Entity
@IdClass(MandtId.class)
public class PropertySet extends ReadWriteRecord {
@Id
@Column(name=DatabaseBindingIds.PROPERTYSET_TENANT)
private String mandt;
@Id
@Column(name=DatabaseBindingIds.PROPERTYSET_ID)
private String entityId;
@OneToMany(mappedBy="propertySet", fetch=FetchType.EAGER)
@OrderBy("sortIndex")
private List<Property> properties;
@Override
public String getMandt() {
return mandt;
}
@Override
public String getId() {
return entityId;
}
@Override
public void setId(MandtId x) {
markNew();
mandt = x != null ? x.getMandt() : null;
entityId = x != null ? x.getId() : null;
}
public List<Property> getProperties() {
if(properties == null) {
properties = new ArrayList<>();
}
return properties;
}
}
Property.java
package platform.data;
...common imports...
@Entity
@IdClass(MandtId.class)
public class Property extends ReadWriteRecord {
@Id
@Column(name=DatabaseBindingIds.PROPERTY_TENANT)
private String mandt;
@Id
@Column(name=DatabaseBindingIds.PROPERTY_ID)
private String entityId;
@ManyToOne(fetch=FetchType.EAGER, optional=false)
@JoinColumns( {
@JoinColumn(name=DatabaseBindingIds.PROPERTY_TENANT, referencedColumnName=DatabaseBindingIds.PROPERTYSET_TENANT, insertable=false, updatable=false),
@JoinColumn(name=DatabaseBindingIds.PROPERTY_PROPERTYSET_ID, referencedColumnName=DatabaseBindingIds.PROPERTYSET_ID, insertable=true, updatable=true)
} )
private PropertySet propertySet;
@Column
private Integer sortIndex;
@Column
private String key;
@Column
@Convert(converter = IntlStringConverter.class)
private IntlString label;
@Column
private String type;
@Column
private String value;
@Override
public String getMandt() {
return mandt;
}
@Override
public String getId() {
return entityId;
}
@Override
public void setId(MandtId x) {
markNew();
mandt = x != null ? x.getMandt() : null;
entityId = x != null ? x.getId() : null;
}
public void setPropertySet(PropertySet x) {
propertySet = x;
}
public PropertySet getPropertySet() {
return propertySet;
}
public int getSortIndex() {
return sortIndex == null ? 0 : sortIndex;
}
public void setSortIndex(int x) {
sortIndex = x;
}
public String getKey() {
return key;
}
public void setKey(String x) {
key = x;
}
public IntlString getLabel() {
return label;
}
public void setLabel(IntlString x) {
label = x;
}
public String getType() {
return type;
}
public void setType(String x) {
type = x;
}
public String getValue() {
return value;
}
public void setValue(String x) {
value = x;
}
}
MandtId.java 复合主键 IDClass.
package platform.data;
import java.io.Serializable;
import java.util.Objects;
/**
* @author sm
* Class to map MANDT and *ID field as composite key
*/
@SuppressWarnings("serial")
public class MandtId implements Serializable {
private String mandt;
private String entityId;
...setters and getters...
@Override
public int hashCode()
...
@Override
public boolean equals(Object other)
...
@Override
public String toString()
...
}
我们像这样在每个单元测试之前插入条目：
try(DatabaseSession db = new DatabaseSession()) {
Project prjT = createProject(db, UUID_PROJECT_NEW, "<New Project>");
createProperty(db, prjT.getPropertySet(), "prj-prop1", "Property 1", "string", "<New Value 1>", 2);
createProperty(db, prjT.getPropertySet(), "prj-prop2", "Property 2", "string", "<New Value 2>", 1);
db.commit();
}
public static Project createProject(DatabaseSession db, String id, String name) {
Project prj = new Project();
prj.setId(new MandtId(MANDT, id));
prj.setName(name);
prj.setStatus(UUID_PROJECT_STATUS_ACTIVE);
db.store(prj.getPropertySet(), null); // workaround: persist child first (otherwise PropertySet will stay marked as new)
db.store(prj, null);
return prj;
}
public static Property createProperty(DatabaseSession db, PropertySet ps, String key, String label, String type, String value, int sortIndex) {
Property rec = new Property();
rec.setId(new MandtId(MANDT, UuidString.generateNew()));
rec.setPropertySet(ps);
rec.setKey(key);
rec.setLabel(IntlStrings.wrap(label));
rec.setType(type);
rec.setValue(value);
rec.setSortIndex(sortIndex);
ps.getProperties().add(rec);
db.store(rec.getPropertySet(), null);
db.store(rec, null);
// rec.properties.add(p);
return rec;
}
如果我稍后尝试获取该项目，我会：
@Override
public Project loadProject(String projectId) throws DataAccessException {
try(DatabaseSession session = new DatabaseSession()) {
return session.fetch(session.load(Project.class, mandt, projectId), (s, r) -> {
s.fetch(r.getPropertySet());
s.fetch(r.getOwner());
s.fetch(r.getResponsibility());
s.fetch(r.getProjectGuideline());
});
} catch(RuntimeException e) {
throw new DataAccessException(e);
}
}
但是 属性set 在这种情况下保持为空。它甚至没有初始化。当我初始化它时，它保持为空。我可以通过在其上使用 em.refresh 来修复其他提取，但我已经添加了一个 TODO，因为刷新总是会导致数据库命中。 属性 实体在数据库中，我可以通过单独的特定 SELECT 查询找到它。
这个数据库设置的主要需求是我们支持数据库内容的高并发编辑。由于数据库通过原子化提交解决了并发问题，我想我在这里是安全的。
我看到的一个问题是，在添加具有双向关系的实体时，我没有将它们添加到两侧，但是当我稍后再次加载它们时是否应该再次修复这个问题（可能不是因为它们被缓存）？此外，它也没有解决我在直接 OneToMany 关系中遇到的任何其他问题（与此处嵌套 OneToMany 的 OneToOne 相比），我仍然需要 em.refresh(...)。如果 em 在服务器环境中，它们是否以无竞争的方式维护实体？
如果您需要更多信息，请告诉我。
编辑：
问题似乎与我在这里进行的单元测试设置有关，内存中的 H2 数据库似乎与 eclipselink 混淆，但是以下注释在生产系统（MsSQL 上的 eclipselink）中运行良好:
Project.java
package pm.data;
...common imports...
import platform.data.DatabaseBindingIds;
import platform.data.MandtId;
import platform.data.PropertySet;
import platform.data.ReadWriteRecord;
import resource.data.Resource;
@Entity
@IdClass(MandtId.class)
public class Project extends ReadWriteRecord {
@Id
@Column(name=DatabaseBindingIds.PROJECT_TENANT)
private String mandt;
@Id
@Column(name=DatabaseBindingIds.PROJECT_ID)
private String entityId;
@OneToOne(fetch=FetchType.LAZY, cascade= CascadeType.ALL) // one to one mappings are directly mapped using the project primary keys
@JoinColumns( {
@JoinColumn(name=DatabaseBindingIds.PROJECT_TENANT, referencedColumnName=DatabaseBindingIds.PROPERTYSET_TENANT, insertable=false, updatable=true),
@JoinColumn(name=DatabaseBindingIds.PROJECT_ID, referencedColumnName=DatabaseBindingIds.PROPERTYSET_ID, insertable=false, updatable=true)
} )
private PropertySet propertySet;
@OneToOne(fetch=FetchType.LAZY, cascade = CascadeType.ALL) // one to one mappings are directly mapped using the project report primary keys
@JoinColumns( {
@JoinColumn(name=DatabaseBindingIds.PROJECTREPORT_TENANT, referencedColumnName=DatabaseBindingIds.INDICATORSET_TENANT, insertable=false, updatable=false),
@JoinColumn(name=DatabaseBindingIds.PROJECTREPORT_ID, referencedColumnName=DatabaseBindingIds.INDICATORSET_ID, insertable=false, updatable=false)
} )
private IndicatorSet indicatorSet; // NOTE: Yes, the updatable are false here and are only true in one set.
...other member variables...
...same as above...
...getters and setters for other member variables...
}
PropertySet.java
package platform.data;
import java.util.ArrayList;
import java.util.List;
...common imports...
@Entity
@IdClass(MandtId.class)
@Cache(isolation=CacheIsolationType.ISOLATED) // Fix turns off EclipseLink cache for PropertySet
public class PropertySet extends ReadWriteRecord {
...same as above...
我接受了 Chris 的回答，因为它帮助我理解了发生的问题以及缓存的工作原理。对于 PropertySet，我必须关闭缓存。修复问题的选项列表也很有帮助。
I get issues with tons of OneToMany relations not loaded
它们可能无法加载的原因是因为默认行为是延迟加载这些关系，这意味着相关实体不会在加载父实体时加载。
在这个例子中，当你加载 Project 时，PropertySet 及其子项不会被加载，因为下面一行：
@OneToOne(fetch=FetchType.LAZY, cascade= CascadeType.ALL)
在这里，您告诉持久性提供程序它应该延迟加载相关的 PropertySet。所以你得到了预期的行为。如果您希望在加载 Project 实例时加载相关实体，则必须从 @OneToOne 注释中删除 fetch 属性。
I could fix other fetches by using em.refresh on it ...
我不明白为什么您首先使用 find() 调用加载实体，然后在下一行中使用 refresh()。 refresh() 的目的是如果您的实体长时间处于持久性上下文中，并且您预计数据库中可能会有新的更改，而您的示例代码中并非如此。
您提到的问题与 Project->PropertySet 关系有关，这是一个严格的 OneToOne 映射，显示的实体没有显示 OneToMany 涉及该问题。由于不是双向的，所以和传统的不设置后向指针没有关系，但是有点关系
问题是因为这个 OneToOne 映射的外键也是项目 ID 字段，它们被映射为可写的基本映射。为了解决多重可写映射异常，您已将 Project.propertySet 映射的连接列标记为 insertable=false、updatable=false，实质上告诉 EclipseLink 此映射是只读的。所以当你设置或更改关系时，这个 'change' 会被忽略，不会合并到缓存中。这会导致您创建的实体在从缓存中读取时始终对此引用具有空值，除非它是来自数据库的refreshed/reloaded。这只会影响二级缓存，因此不会显示在创建它的 EntityManager 中，除非它被清除。
有几种方法可以解决这个问题，最好的方法取决于您的应用程序的使用情况。
禁用共享缓存。 这可以为每个实体或特定实体完成。看 有关详细信息，请访问 eclipseLink faq。这是最简单的选择 会给你类似于 Hibernate 的结果，它不启用 默认二级缓存，但除非有 是不使用二级缓存的其他考虑因素，因为它 以性能为代价。
更改Project中的基本ID映射字段以使用 可插入=假，可更新=假。然后你删除 insertable=false, updatable=false 来自连接列，允许 OneToOne 映射来控制您的主键。功能上这个 不应以任何方式更改您的应用程序。如果你得到相同的 基本映射问题，本机 EclipseLink postClone 方法可用于设置引用映射中的字段，或者 您的实体 get 方法可以快速检查是否有 PropertySet 并在返回 null 之前使用该值。
使用 JPA 2.0 的派生 ID。 JPA 允许将关系标记为 ID，从而无需为相同的值设置这两个基本映射。或者您可以使用关系上的 @MapsId 来告诉 JPA 关系控制值，JPA 将为您设置这些字段。使用@MapsId 需要使用您的 pk class 作为嵌入式 ID，并且看起来像：
@Entity public class Project extends ReadWriteRecord { @EmbeddedId private MandtId mandtId; @MapsId("mandtId") @OneToOne(fetch=FetchType.LAZY, cascade= CascadeType.ALL) // one to one mappings are directly mapped using the project primary keys @JoinColumns( { @JoinColumn(name=DatabaseBindingIds.PROJECT_TENANT, referencedColumnName=DatabaseBindingIds.PROPERTYSET_TENANT, insertable=false, updatable=false), @JoinColumn(name=DatabaseBindingIds.PROJECT_ID, referencedColumnName=DatabaseBindingIds.PROPERTYSET_ID, insertable=false, updatable=false) } ) private PropertySet propertySet;