使用泛型检查@Unique的@Entity

Question

有没有可能在genericPersist和isUniqueEntity中使用泛型？persist方法看起来相当简单：

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

嗯，我不太确定--你是想用isUniqueEntity取代isUniqueArticle和isUniqueNewsgroup吗？你能在文章/新闻组中添加一些东西吗？如果您可以为它们添加一个接口和一个方法，那么可以。如果您不能这样做，那么您可能也可以这样做，但我不能这样想:)

不管怎样，你可以试试这个。向两个类添加一个接口：

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 other) (现在只需复制粘贴两个isXUnique中的“in”中的条件)。

如果这就是你要找的东西并且还行得通的话(我还没有编译它！)持久化方法对您来说应该不成问题:)