JPA实体、servicelayer和存储库：我这样做对吗？

我不确定我在服务/持久性层是否做得对。 在我的例子中，我有四个实体：用户、类别、投资和投资重复：

用户： BaseEntityRepository实现实体的CRUD操作： 当我在创建实体后不更新用户时，当我通过em.find（…）刷新用户时，该用户不包含新类别，但新类别是在数据库中创建的

另一点是，当我使用investmentrepeat持久化一个新投资时，在db表investmentrepeat中，parentinvestment的id为everytime 0，或者当我删除@NotNull注释时，id为null。我如何向该类别添加投资是正确的吗？以下是我创建新投资的函数：

投资服务： 我希望有人能告诉我我犯了哪些错误，我对jpa的了解哪里是错的：）

---

谢谢

向用户添加类别的最简单方法是执行以下操作

确保您的用户拥有类别列表，否则它将仅用您最新的类别替换所有类别

将创建的新类别添加到列表中

更新用户实体，因为您对关系进行了级联，类别将被持久化，并且将与用户进行匹配

---

现在我们来看第二个问题。

谢谢您的回答！你的意思是我应该注释

newCategory=this.create（newCategory）

。但当我这样做时，用户的categorylist中新创建的类别的id=null。现在，当我向列表中添加第二个新类别并更新用户时，有两个类别的id=null，数据库类别表中的id发生更改。您应该这样做：

category newCategory=new category（categorytle，owner，deletable）；owner.AddCategory（新类别）；userService.update（所有者）执行此操作时，例如owner.getCategorList（）.get（0）.getId（）为空。因为将对类别执行合并操作。newCategory在数据库中，但在所有者列表中有一个空id，直到我重新定义所有者：/
public class User implements Identifiable, Serializable {

@OneToMany(mappedBy = "owner", cascade = CascadeType.ALL, fetch = FetchType.LAZY, 
orphanRemoval = true)
private List<Investment> investmentList;

@ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
@JoinTable(name = "user_investment", joinColumns = { @JoinColumn(name = "user") }, 
inverseJoinColumns = { @JoinColumn(name = "investment") })
private List<Investment> publicInvestmentList;

@OneToMany(mappedBy = "owner", cascade = CascadeType.ALL, 
fetch = FetchType.LAZY, orphanRemoval = true)
private List<Category> categoryList;

...
}

public class Category implements Identifiable, Serializable {

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "owner", columnDefinition = "BIGINT(20)")
@NotNull
private User owner;

@OneToMany(mappedBy = "category", fetch = FetchType.LAZY)
private List<Investment> investmentList;

...
}

public class Investment implements Identifiable, Serializable {

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "owner")
@NotNull
private User owner;

@ManyToMany(mappedBy = "publicInvestmentList")
private List<User> publicUserList;

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "category")
@NotNull
private Category category;

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "investmentrepeat")
@NotNull
private InvestmentRepeat investmentRepeat;

@OneToOne(cascade = { CascadeType.PERSIST, CascadeType.MERGE,
        CascadeType.REFRESH }, fetch = FetchType.LAZY)
@JoinColumn(name = "owninginvestmentrepeat", columnDefinition = "BIGINT(20)")
private InvestmentRepeat owningInvestmentRepeat;

...
}

public class InvestmentRepeat implements Identifiable, Serializable {
@OneToMany(mappedBy = "investmentRepeat", fetch = FetchType.LAZY)
private List<Investment> investmentList;

@OneToOne(mappedBy = "owningInvestmentRepeat", fetch = FetchType.LAZY)
@NotNull
private Investment parentInvestment;

...
}

 public Category createWithReferences(String categoryTitle, User owner,
        boolean deleteable) throws ServiceException,
        EntityPersistenceException {
    if (owner == null) {
        throw new ServiceException(getMessageService()
                .getMessageFromBundle("error.user_not_found_by_id"));
    }
    if (categoryTitle == null || categoryTitle.isEmpty()) {
        throw new ServiceException(getMessageService()
                .getMessageFromBundle("error.category.no_title"));
    }

    Category newCategory = new Category(categoryTitle, owner, deleteable);
    owner.addCategorie(newCategory);

    newCategory = this.repository.create(newCategory);
    userService.update(owner);

    return newCategory;
}

@Override
public T create(T obj) throws EntityPersistenceException {
    EntityTransaction tx = getEntityManager().getTransaction();
    tx.begin();
    try {
        getEntityManager().persist(obj);
        tx.commit();
    } catch (PersistenceException e) {
        if (tx.isActive()) {
            tx.rollback();
        }
        throw new EntityPersistenceException(
                "Could not create Object of Instance: "
                        + obj.getClass().getCanonicalName()
                        + "; ErrorMessage: " + e.getMessage());
    }

    return obj;
}

@Override
public T update(T obj) throws EntityPersistenceException {
    EntityTransaction tx = getEntityManager().getTransaction();
    tx.begin();
    try {
        obj = this.getEntityManager().merge(obj);
        tx.commit();
    } catch (PersistenceException e) {
        if (tx.isActive()) {
            tx.rollback();
        }
        throw new EntityPersistenceException(
                "Could not update Object of Instance: "
                        + obj.getClass().getCanonicalName()
                        + "; ErrorMessage: " + e.getMessage() + "; ID: "
                        + obj.getId());
    }
    return obj;
}

@Override
public void delete(T obj) throws EntityPersistenceException {
    EntityTransaction tx = getEntityManager().getTransaction();
    tx.begin();
    try {
        if (obj != null) {
            long id = 0;
            if (obj instanceof Identifiable) {
                id = ((Identifiable) obj).getId();
                T entity = getEntityManager().find(getType(), id);
                //entity = getEntityManager().merge(entity);
                getEntityManager().remove(entity);
                tx.commit();
            }
        }
    } catch (PersistenceException e) {
        if (tx.isActive()) {
            tx.rollback();
        }
        throw new EntityPersistenceException(
                "Could not delete Object of Instance: "
                        + obj.getClass().getCanonicalName()
                        + "; ErrorMessage: " + e.getMessage() + "; ID: "
                        + obj.getId());
    }
}

public Investment createWithReferences(User owner, String description,
        double amount, Date investDate, Category category,
        InvestmentRepeat investmentRepeat, boolean isParentInvestment)
        throws ServiceException, EntityPersistenceException {
    if (owner == null) {
        throw new ServiceException(getMessageService()
                .getMessageFromBundle("error.user_not_found_by_id"));
    }
    if (category == null) {
        throw new ServiceException(getMessageService()
                .getMessageFromBundle("error.category_is_null"));
    }
    if (investmentRepeat == null) {
        throw new ServiceException(getMessageService()
                .getMessageFromBundle("error.investmenterepeat_is_null"));
    }

    // Create investment
    Investment newInvestment = new Investment(investDate,
            new LocalDateTime(DateTimeZone.UTC), amount, description,
            owner, category, investmentRepeat);
    // add Investment to investmentRepeat and Category
    investmentRepeat.getInvestmentList().add(newInvestment);

    if (isParentInvestment) {
        investmentRepeat.setParentInvestment(newInvestment);
        newInvestment.setOwningInvestmentRepeat(investmentRepeat);
    }

    owner.findCategory(category).addInvestment(newInvestment);
    owner.addInvestment(newInvestment);

    // create investment
    newInvestment = this.create(newInvestment);

    // update Owner
    userService.update(owner);

    return newInvestment;
}