1

我有以下具有 1 对 N 关系的 Persistable 类。

@PersistenceCapable
public class Pet {

  @Persistent(primaryKey = "true", valueStrategy = IdGeneratorStrategy.IDENTITY)
  Long id;

  @Persistent
  String name;

  @Element(column = "PET_ID")
  List<Photo> photos;

  // getters and setters

和

@PersistenceCapable
public class Photo {

  @Persistent(primaryKey = "true", valueStrategy = IdGeneratorStrategy.IDENTITY)
  Long id;

  @Persistent
  String desc;

  @Persistent(serialized="true")
  Object image;

  // getters and setters

  // hash and equal using field id

Field List photos使用 FK 在 Pet (1) 和 Photo (N) 之间建立 1-N 关系。Photo中的Field Object图像是一个序列化的来保存图像对象。

对于数据存储操作，我使用 PetDao，它有以下方法

public final static PersistenceManagerFactory pmf = JDOHelper
            .getPersistenceManagerFactory("datastore");

public void storePet(Pet pet) {
    // get PM and current tx
    try {
       tx.begin();
       pm.makePersistent(pet);
       tx.commit();
    } catch (Exception e) {
       // rollback and close pm
    }           
}

public void storePhoto(Long petId, Photo photo) {
    // get PM and current tx
    try {
       tx.begin();
       Pet pet = pm.getObjectById(Pet.class,petId);
       pet.addPhoto(photo);
       tx.commit();
    } catch (Exception e) {
       // rollback and close pm
    }
}

我创建并持久化对象为

Pet pet = new Pet();
pet.setName("Nicky");

Photo photo = new Photo();
photo.setDesc("Photo 1");
photo.setImage(new Image("image 1"));
pet.addPhoto(photo);

.... add photo 2 and photo 3

PetDao petDao = new PetDao();       
petDao.storePet(pet);

// i have one more photo so add it directly
photo = new Photo();
photo.setDesc("Photo 4");
photo.setImage(new Image ("image 4"));      

petDao.storePhoto((long)0, photo);

一切都按要求保留，数据存储最终在 PET 表中包含 1 只宠物，在 PHOTO 表中包含 4 张照片。

但是当我分析petDao.storePhoto((long)0, photo)代码的 DataNucleus 日志时，我看到 DataNucleus 从数据存储中检索所有图像对象。

Native          [DEBUG] INSERT INTO PHOTO ("DESC",IMAGE,PET_ID,PHOTOS_INTEGER_IDX) VALUES (<'Photo 4'>,<UNPRINTABLE>,<0>,<3>)
Persist         [DEBUG] Execution Time = 70 ms (number of rows = 1) on PreparedStatement "org.datanucleus.store.rdbms.ParamLoggingPreparedStatement@190a0d6"
Persist         [DEBUG] Object "in.m.pet.Photo@10deb5f" was inserted in the datastore and was given strategy value of "3"
Native          [DEBUG] SELECT A0.IMAGE FROM PHOTO A0 WHERE A0.ID = <1>
Retrieve        [DEBUG] Execution Time = 1 ms
Native          [DEBUG] SELECT A0.IMAGE FROM PHOTO A0 WHERE A0.ID = <0>
Retrieve        [DEBUG] Execution Time = 0 ms
Native          [DEBUG] SELECT A0.IMAGE FROM PHOTO A0 WHERE A0.ID = <2>
Retrieve        [DEBUG] Execution Time = 0 ms

使用 INSERT INTO PHOTO... 语句添加“照片 4”后，DataNucleus 通过触发 3 SELECT IMAGE FROM PHOTO 语句检索前面的三个图像对象。随着图像对象数量的增加，这些检索可能会非常大，从而导致数据存储上出现不必要的负载，从而影响性能。

如果我使用 pm.getObjectById() 选择宠物并分离 Pet 对象并将照片添加到分离的对象，然后使用 pm.makePersistent(pet) 将其附加回对象图，也会发生同样的事情。FetchGroup 如下

@PersistenceCapable(detachable="true")
@FetchGroup(name="detachPhotos", members={@Persistent(name="photos")})
public class Pet {
   ....
}

并使用 fetchgroup 分离宠物

public Pet getPet(Long id){
    PersistenceManager pm = pmf.getPersistenceManager();
    pm.getFetchPlan().addGroup("detachPhotos");
    Pet pet = pm.getObjectById(Pet.class, id);      
    return pm.detachCopy(pet);  
}

我的问题是如何避免对数据存储中的对象图像进行这些不必要的重试。

还有一个观察：如果我从另一个应用程序调用 petDao.storePhoto((long)0, photo) 或在 PetDao.storePhoto 方法中使用单独的 PMF 实例，那么 DataNucleus将不会触发 SELECT 来检索图像对象。

4

2 回答 2

1

如果 1-N 关系会变得很大，您可能需要考虑以关系方式映射它，即映射 Photo.pet，而不是映射 Pet.photos。这将阻止您在没有查询的情况下以 OO 方式从 Pet 导航到 Photo，但会阻止您关注的 SQL 语句。

然后，您的 storePhoto 将如下所示，并且不会获取 1-N。

public void storePhoto(Photo photo) {
    // get PM and current tx
    try {
       tx.begin();
       pm.makePersistent(photo); // assuming pet was already set
       tx.commit();
    } catch (Exception e) {
       // rollback and close pm
    }
}
于 2013-09-30T23:43:17.187 回答
0

在DataNucleus Performance Tuning中得到答案，如果应用程序不需要可达性，建议设置datanucleus.persistenceByReachabilityAtCommit=false 。将此设置为 false，可以解决图像检索问题，而不会对宠物/照片产生任何其他副作用。

引用 DN doc

DataNucleus 验证新持久化的对象在提交时是否可访问内存，如果不是，则将它们从数据库中删除。此过程反映了垃圾收集，其中未引用的对象被垃圾收集或从内存中删除。可达性很昂贵，因为它遍历整个对象树并且可能需要从数据库重新加载数据。如果您的应用程序不需要可达性，您应该禁用它。

在将其设置为 false 之前，请检查您的应用是否需要可达性。

于 2013-10-07T07:31:53.380 回答