Design patterns DAO模式-使用静态还是非静态方法？

我的应用程序使用的是DAO模式。 我是否应该使实现方法“静态”呢

我说的是这个具体的实现：

• findByIdentifier（字符串标识符）

但是关于一般实现：

• E getByID（K ID）
• 列出findAll（）
• 保存（电子实体）
• 更新（电子实体）
• 删除（E）实体

谢谢你的建议

public interface DaoBase<K, E> {
    E getByID(K ID);
    List<E> findAll();
    void save(E entity);
    void update(E entity);
    void delete(E entity);
}



public interface DaoLanguage extends DaoBase<Long, LanguageEntity> {    
    LanguageEntity findByIdentifier(String identifier);
}

公共接口数据库{
E getByID（K ID）；
列出findAll（）；
作废保存（E实体）；
无效更新（E实体）；
作废删除（E实体）；
}
公共接口DAO语言扩展了DaoBase{
LanguageEntity findByIdentifier（字符串标识符）；
}

我使用JPA来持久化所有实体类

public class JpaDaoLanguage extends JpaDaoBase<Long, LanguageEntity> implements DaoLanguage {
    public LanguageEntity findByIdentifier(String identifier) {
        LanguageEntity language = (LanguageEntity) entityManager.createQuery(
                "select lan from LanguageEntity as lan where lan.identifier = ?1")
                .setParameter(1, identifier)
                .getSingleResult();
        return language;
    }
}

public类JpaDaoLanguage扩展了JpaDaoBase语言{
公共语言实体findByIdentifier（字符串标识符）{
LanguageEntity language=（LanguageEntity）entityManager.createQuery(
“从LanguageEntity中选择lan作为lan，其中lan.identifier=？1”）
.setParameter（1，标识符）
.getSingleResult（）；
返回语言；
}
}

通用基实现

public abstract class JpaDaoBase<K, E> implements DaoBase<K, E> {
    protected EntityManager entityManager;
    protected Class<E> entityClass;

    @SuppressWarnings("unchecked")
    public JpaDaoBase() {
        ParameterizedType genericSuperclass = (ParameterizedType) getClass()
                .getGenericSuperclass();
        this.entityClass = (Class<E>) genericSuperclass
                .getActualTypeArguments()[1];

        EntityManagerFactory factory = Persistence
                .createEntityManagerFactory("CyberLabPersistenceUnit");
        entityManager = factory.createEntityManager();
    }

    @Override
    public E getByID(K ID) {
        return entityManager.find(entityClass, ID);
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<E> findAll() {
        Query q = entityManager.createQuery("SELECT e FROM "
                + entityClass.getName() + " e ");
        return (List<E>) q.getResultList();
    }

    @Override
    public void save(E entity) {
        entityManager.persist(entity);
    }

    @Override
    public void update(E entity) {
        entityManager.merge(entity);
    }

    @Override
    public void delete(E entity) {
        entityManager.remove(entity);
    }
}

公共抽象类JpaDaoBase实现DaoBase{
受保护的实体管理器实体管理器；
保护类实体类；
@抑制警告（“未选中”）
公共JPADobase（）{
ParameteredType genericSuperclass=（ParameteredType）getClass（）
.getGenericSuperclass（）；
this.entityClass=（类）genericSuperclass
.getActualTypeArguments（）[1]；
EntityManagerFactory工厂=持久性
.createEntityManagerFactory（“CyberLabPersistenceUnit”）；
entityManager=factory.createEntityManager（）；
}
@凌驾
公共E getByID（K ID）{
返回entityManager.find（entityClass，ID）；
}
@抑制警告（“未选中”）
@凌驾
公共列表findAll（）{
Query q=entityManager.createQuery（“从中选择e”
+entityClass.getName（）+“e”）；
返回（列表）q.getResultList（）；
}
@凌驾
公共作废保存（E实体）{
entityManager.persist（实体）；
}
@凌驾
公共作废更新（E实体）{
entityManager.merge（实体）；
}
@凌驾
公共作废删除（E实体）{
entityManager.remove（实体）；
}
}

试试这个：为使用此DAO的代码编写一个单元测试

您的目标之一应该是快速通过的测试，并且不依赖于外部资源（一个好的单元测试应该不需要实际的数据库）。因此，与其让您的测试调用真正的DAO，不如创建一个返回固定语言实体的模拟DAO，让您的测试代码使用模拟而不是真正的DAO。那还能用吗？如果真实DAO具有这些方法的静态实现，那么您能否成功地用模拟DAO替换真实DAO

尽可能避免它们