使用泛型检查@Unique的@Entity

Question

是否可以使用泛型与genericPersist和isUniqueEntity？该坚持的方法看起来相当简单：

package net.bounceme.dur.usenet.driver; 

import java.util.ArrayList; 
import java.util.List; 
import java.util.logging.Level; 
import java.util.logging.Logger; 
import javax.mail.Folder; 
import javax.mail.Message; 
import javax.persistence.EntityManager; 
import javax.persistence.EntityManagerFactory; 
import javax.persistence.Persistence; 
import javax.persistence.TypedQuery; 
import net.bounceme.dur.usenet.model.Article; 
import net.bounceme.dur.usenet.model.Newsgroup; 
import net.bounceme.dur.usenet.model.Usenet; 

public class Main { 

    private static final Logger LOG = Logger.getLogger(Main.class.getName()); 
    private Usenet u = Usenet.INSTANCE; 

    public static void main(String[] args) { 
     try { 
      Main main = new Main(); 
     } catch (Exception ex) { 
      Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex); 
     } 
    } 

    public Main() throws Exception { 
     EntityManagerFactory emf; 
     EntityManager em; 
     emf = Persistence.createEntityManagerFactory("USENETPU"); 
     List<Newsgroup> subscribed = getFolders(); 
     em = emf.createEntityManager(); 
     for (Newsgroup newsgroup : subscribed) { 
      persistNewsgroups(em, newsgroup); 
      List<Message> messages = u.getMessages(newsgroup.getNewsgroup()); 
      LOG.fine(newsgroup + " " + messages.size() + " messages"); 
      for (Message message : messages) { 
       LOG.fine("message " + message.getMessageNumber()); 
       Article article = new Article(message); 
       persistArticle(em, article); 
      } 
     } 
     em.close(); 
    } 

    private boolean isUniqueArticle(Article article, List<Article> articles) { 
     LOG.fine(articles.toString()); 
     for (Article a : articles) { 
      if (a.getSubject().equalsIgnoreCase(article.getSubject())) { 
       return false; 
      } 
     } 
     LOG.fine("new\t\t" + article); 
     return true; 
    } 

    private void persistArticle(EntityManager em, Article article) { 
     LOG.fine(article.toString()); 
     TypedQuery<Article> query = em.createQuery("SELECT a FROM Article a", Article.class); 
     List<Article> results = query.getResultList(); 
     if (isUniqueArticle(article, results)) { 
      em.getTransaction().begin(); 
      em.persist(article); 
      em.getTransaction().commit(); 
     } 
    } 

    private <T> void genericPersist(EntityManager em, Class<T> entity, String queryString) { 
     TypedQuery<T> query = em.createQuery(queryString, entity); 
     List<T> results = query.getResultList(); 
     if (isUniqueEntity(entity, results)) { 
      em.getTransaction().begin(); 
      em.persist(entity); 
      em.getTransaction().commit(); 
     } 
    } 

    private <T> boolean isUniqueEntity(Class<T> entity,List<T> results) { 
     return false; 
    } 

    private void persistNewsgroups(EntityManager em, Newsgroup newNewsgroup) { 
     LOG.fine(newNewsgroup.toString()); 
     TypedQuery<Newsgroup> query = em.createQuery("SELECT n FROM Newsgroup n", Newsgroup.class); 
     List<Newsgroup> results = query.getResultList(); 
     if (isUniqueNewsgroup(newNewsgroup, results)) { 
      em.getTransaction().begin(); 
      em.persist(newNewsgroup); 
      em.getTransaction().commit(); 
     } 
    } 

    private boolean isUniqueNewsgroup(Newsgroup newNewsgroup, Iterable<Newsgroup> results) { 
     LOG.fine(results.toString()); 
     for (Newsgroup existingNewsgroup : results) { 
      if ((existingNewsgroup.getNewsgroup().equals(newNewsgroup.getNewsgroup()))) { 
       return false; 
      } 
     } 
     LOG.fine(newNewsgroup + "\tnew"); 
     return true; 
    } 

    private List<Newsgroup> getFolders() { 
     List<Folder> folders = u.getFolders(); 
     List<Newsgroup> newsgroups = new ArrayList<>(); 
     for (Folder folder : folders) { 
      Newsgroup newsgroup = new Newsgroup(folder); 
      newsgroups.add(newsgroup); 
     } 
     LOG.fine(newsgroups.toString()); 
     return newsgroups; 
    } 
} 

对于isUniqueEntity所有我能想到的是确定物体的类型，然后使用交换机，但这似乎并没有太大的积蓄。如何才能做到这一点？

假设实体有一个@Unique字段，请确定该字段，然后相应地查询数据库？

Answer 1

嗯我不太确定 - 你是否试图用和isUniqueNewsgroup替换isUniqueEntity？你能添加一些文章/ NewsGroup？如果你可以给它们添加一个接口，并且每个接口都有一个方法是的。如果你不能那么大概你也可以做到这一点，但我不能这么想:)

无论如何，你可以试试这个。接口添加到这两个类：

public interface Equalable<T> { 
    boolean isEqual(T other); 
} 

private <T extends Equalable> boolean isUniqueEntity(T entity, Iterable<T> results) { 
    LOG.fine(results.toString()); 
    for (T resultEntity : results) { 
     if (resultEntity.isEqual(entity))) { 
      return false; 
     } 
    } 
    LOG.fine(newNewsgroup + "\tnew"); 
    return true; 
} 

然后在这两个类的isEqual实现（T等）（只需复制粘贴现在在两个isXUnique你的“如果”你的条件）。

如果这是你要找的人及工程（没有编译它！）的persist方法应该是你没问题:)