java - 传递了分离的实体以持久保留以在JPA中批量插入

对于以下批处理插入方法，我得到此异常“将分离的实体传递给持久化对象”。您能否看一下这种方法并给我一些提示？

非常感谢。

如果需要，我将在此处提供实体，目前我提供关键字实体：

public class Keyword implements Serializable {


    private static final long serialVersionUID = -1429681347817644570L;

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name="key_id")
    private long keyId;

    @Column(name="key_name")
    private String keyName;

    @ManyToOne
    @JoinColumn(name="tweet_id")
     private Tweet tweet;


    public long getKeyId() {
        return keyId;
    }


    public void setKeyId(long keyId) {
        this.keyId = keyId;
    }

    public String getKeyName() {
        return keyName;
    }

    public void setKeyName(String keyName) {
        this.keyName = keyName;
    }


    public Tweet getTweet() {
        return tweet;
    }

    public void setTweet(Tweet tweet) {
        this.tweet = tweet;
    }

}

这里Tweet实体：

@Entity
@Table(name="tweets")

public class Tweet implements Serializable{

    @Id
    @Column(name="tweet_id")
    private long tweetId;

    @Column(name="tweet_text")
    private String tweetText;

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "created_at")
    private Date createdAt;

    @Column(name="lang_code")
    private String languageCode;

    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user;


    @OneToMany(mappedBy="tweet")
    //@JoinColumn(name="hashtag_id")
    private List<Hashtag> hashtags;


    @OneToMany(mappedBy="tweet")
    //@JoinColumn(name="url_id")
    private List<Url> urls;


    public List<Keyword> getKeywords() {
        return keywords;
    }


    public void setKeywords(List<Keyword> keywords) {
        this.keywords = keywords;
    }


    @OneToMany(mappedBy="tweet")
    //@JoinColumn(name="url_id")
    private List<Keyword> keywords;




    public long getTweetId() {
        return tweetId;
    }


    public void setTweetId(long tweetId) {
        this.tweetId = tweetId;
    }


    public String getTweetText() {
        return tweetText;
    }


    public void setTweetText(String tweetText) {
        this.tweetText = tweetText;
    }


    public Date getCreatedAt() {
        return createdAt;
    }


    public void setCreatedAt(Date createdAt) {
        this.createdAt = createdAt;
    }


    public String getLanguageCode() {
        return languageCode;
    }


    public void setLanguageCode(String languageCode) {
        this.languageCode = languageCode;
    }


    public User getUser() {
        return user;
    }


    public void setUser(User user) {
        this.user = user;
    }


    public List<Hashtag> getHashtags() {
        return hashtags;
    }


    public void setHashtags(List<Hashtag> hashtags) {
        this.hashtags = hashtags;
    }


    public List<Url> getUrls() {
        return urls;
    }


    public void setUrls(List<Url> urls) {
        this.urls = urls;
    }


    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + (int) (tweetId ^ (tweetId >>> 32));
        return result;
    }


    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Tweet other = (Tweet) obj;
        if (tweetId != other.tweetId)
            return false;
        return true;
    }

这里的网址实体：

@Entity
@Table(name="tweet_url")
public class Url implements Serializable{


    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name="url_id")
    private int urlId;


    @Column(name="url")
    private String url;

    @ManyToOne
    @JoinColumn(name="tweet_id",referencedColumnName="tweet_id")
    private Tweet tweet;

    public int getUrlId() {
        return urlId;
    }

    public void setUrlId(int urlId) {
        this.urlId = urlId;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public Tweet getTweet() {
        return tweet;
    }

    public void setTweet(Tweet tweet) {
        this.tweet = tweet;
    }

这是标签实体：

@Entity
@Table(name="tweet_hashtag")
public class Hashtag implements Serializable{


    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name="hashtag_id")
    private int hashtagId;


    @Column(name="hashtag")
    private String hashtag;

    @ManyToOne
    @JoinColumn(name="tweet_id",referencedColumnName="tweet_id")
    private Tweet tweet;

    public int getHashtagId() {
        return hashtagId;
    }

    public void setHashtagId(int hashtagId) {
        this.hashtagId = hashtagId;
    }

    public String getHashtag() {
        return hashtag;
    }

    public void setHashtag(String hashtag) {
        this.hashtag = hashtag;
    }

    public Tweet getTweet() {
        return tweet;
    }

    public void setTweet(Tweet tweet) {
        this.tweet = tweet;
    }

和方法：

public  void batchInsert(List<Keyword> results) throws HibernateException {

    // chekeywordck if key exists

    //  try {
    em=RunQuery.emf.createEntityManager();
    em.getTransaction().begin();

    for(Keyword result:results)
    {

        try{
        em.persist(result.getTweet().getUser());
        }
        catch(ConstraintViolationException ce)
        {
            System.out.print("duplicated insert catched");

        }

        try{
        em.persist(result.getTweet());
        }
        catch(ConstraintViolationException ce)
        {
        System.out.print("duplicated insert catched");
        }

        if(result.getTweet().getHashtags()!=null)
            for(Hashtag hashtag:result.getTweet().getHashtags())
                   em.persist(hashtag);

        if(result.getTweet().getUrls()!=null)
            for(Url url:result.getTweet().getUrls())
                em.persist(url);

       em.persist(result);

        em.flush();
        em.clear();

      //when I put these two line out of this loop, it still is the same.
    }
    em.getTransaction().commit();


       // }


}

这是一个例外：

Exception in thread "Thread-3" javax.persistence.PersistenceException: org.hibernate.PersistentObjectException: detached entity passed to persist: model.twitter.entities.Url
    at org.hibernate.jpa.spi.AbstractEntityManagerImpl.convert(AbstractEntityManagerImpl.java:1763)
    at org.hibernate.jpa.spi.AbstractEntityManagerImpl.convert(AbstractEntityManagerImpl.java:1677)
    at org.hibernate.jpa.spi.AbstractEntityManagerImpl.convert(AbstractEntityManagerImpl.java:1683)
    at org.hibernate.jpa.spi.AbstractEntityManagerImpl.persist(AbstractEntityManagerImpl.java:1187)
    at model.service.QueryResultService.batchInsert(QueryResultService.java:74)
    at controller.ResultsController.save(ResultsController.java:125)
    at controller.ResultsController.parse(ResultsController.java:89)
    at main.TwitterStreamConsumer.run(TwitterStreamConsumer.java:41)
    at java.lang.Thread.run(Thread.java:745)
Caused by: org.hibernate.PersistentObjectException: detached entity passed to persist: model.twitter.entities.Url
    at org.hibernate.event.internal.DefaultPersistEventListener.onPersist(DefaultPersistEventListener.java:139)
    at org.hibernate.event.internal.DefaultPersistEventListener.onPersist(DefaultPersistEventListener.java:75)
    at org.hibernate.internal.SessionImpl.firePersist(SessionImpl.java:811)
    at org.hibernate.internal.SessionImpl.persist(SessionImpl.java:784)
    at org.hibernate.internal.SessionImpl.persist(SessionImpl.java:789)
    at org.hibernate.jpa.spi.AbstractEntityManagerImpl.persist(AbstractEntityManagerImpl.java:1181)
    ... 5 more

最佳答案

回答您的问题：您的模型在Tweet和U​​RL之间定义了一对多关系，而没有任何级联。当您传递Tweet实例进行持久化时，URL对象尚未保存，并且您的模型没有强制Tweet将持久化操作层叠到URL实例。因此，它无法与他们建立关系。
级联告诉休眠的，如何在相关实体上执行数据库操作。
您可以指示它将持久操作传递/层叠到相关实体，以级联所有操作或一系列操作。

话虽如此，如果您使用级联信息修改关系，则可以解决您的问题（其中1个）：

 @OneToMany(mappedBy="tweet", cascade={CascadeType.PERSIST})
 private List<Url> urls;

但是您的示例指出了其他可能的问题，我鼓励您花更多的时间阅读Hibernate ORM文档并在关系较少的示例模型上进行练习。

显而易见的问题之一似乎是缺乏对关系所有者概念的理解。
例如，在您的“推文到网址”关系中，URL是关系所有者（负责管理关系，例如，通过外键管理链接）
有关更多信息，请查阅hibernate docs或数百个类似问题here on SO之一。
根据您填充数据的方式，您可能会遇到约束问题，或者您的实体将不会链接在一起，因为您没有保存所有权。
另外，使用try / catch违反约束是检测重复条目的一种非常不好的方法。 ConstraintViolationException可能有很多原因，获得它们的原因与上述关系映射问题有关。
ORM是一个复杂的主题，从较小的示例开始，在转向更具挑战性的模型之前尝试了解框架机制，这确实有益。祝好运