Fatal编程技术网
  • java/
  • Java Hibernate通用DAO、通用服务和通用视图层？

Java Hibernate通用DAO、通用服务和通用视图层？

java spring hibernate

Java Hibernate通用DAO、通用服务和通用视图层？,java,spring,hibernate,Java,Spring,Hibernate,我一直在努力完全理解和实现hibernate中的GenericDAO层。我对这个概念很陌生，一直在做一些阅读和研究。我在GenericDAO层的示例实现中找到了大量的示例，这就是我最终得到的结果 public class GenericDAOImpl<T, ID extends Serializable> implements GenericDAO<T, ID> { private static Logger log = Logger.getLogger(Gen

我一直在努力完全理解和实现hibernate中的GenericDAO层。我对这个概念很陌生，一直在做一些阅读和研究。我在GenericDAO层的示例实现中找到了大量的示例，这就是我最终得到的结果

public class GenericDAOImpl<T, ID extends Serializable> implements GenericDAO<T, ID> {

    private static Logger log = Logger.getLogger(GenericDAOImpl.class.getName());


    private SessionFactory sessionFactory;


    @SuppressWarnings("unchecked")
    public T findById(long id, Class<T> objectClass) {
        log.info("Entered GenericDAOImpl findById(" + id +")");
        T result = (T) getSessionFactory().getCurrentSession().load(objectClass, id);
        if(result != null){
            Hibernate.initialize(result);
            return result;
        }else{ 
            return null;
        }
    }

    public boolean create(T newInstance) {
        log.info("Entered GenericDAOImpl create()");
        if(newInstance == null){
            return false;
        }
        getSessionFactory().getCurrentSession().saveOrUpdate(newInstance);
        return true;        
    }


    public boolean updpate(T updateInstance) {
        log.info("Entered GenericDAOImpl updpate()");
        if(updateInstance == null){
            return false;
        }
        getSessionFactory().getCurrentSession().update(updateInstance); 
        return true;
    }

    public boolean delete(T entity) {
        log.info("Entered GenericDAOImpl delete()");
        if(entity == null){
            return false;
        }
        getSessionFactory().getCurrentSession().delete(entity);
        return true;
    }

    @SuppressWarnings("unchecked")
    public List<T> findByExample(T exampleInstance, Class<T> objectClass){
        log.info("Entered GenericDAOImpl findByExample()");
        Criteria searchCriteria = getSessionFactory().getCurrentSession().createCriteria(objectClass);

        searchCriteria.add(Example.create(exampleInstance));

        return (List<T>)searchCriteria.list();          

    }

    public SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }       
}
那么我可以继续做一个通用的视图层吗

请让我知道这种方法是否可以接受，或者这种方法是否存在任何问题

提前感谢您的想法和回复

目前，您的服务只是将所有内容委托给底层DAO。有时可能需要这样做，但通常我会将“业务逻辑”放在服务层中。将逻辑放在服务层也将有助于保持控制器层的轻巧

服务可以使用一个或多个DAO来完成它需要的任务。因此，考虑一个简单的银行系统，在那里我有一个帐号

public class AccountDao implements GenericDao<Account, Long> {
  // your save, insert, delete, find, etc
}
在您的服务层上使用事务，使您能够更好地控制哪些操作需要在同一事务中。

您的服务目前只是将所有内容委托给底层DAO。有时可能需要这样做，但通常我会将“业务逻辑”放在服务层中。将逻辑放在服务层也将有助于保持控制器层的轻巧

服务可以使用一个或多个DAO来完成它需要的任务。因此，考虑一个简单的银行系统，在那里我有一个帐号

public class AccountDao implements GenericDao<Account, Long> {
  // your save, insert, delete, find, etc
}
在服务层上使用事务，使您能够更好地控制哪些操作需要在同一事务中。

我为Hibernate实现了一个通用实体、Dao和服务

BaseEntity

@MappedSuperclass
public class BaseEntity implements Serializable {

    private static final long serialVersionUID = -932093556089251203L;

    @Id
    @GeneratedValue
    private Long id;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

}

@Entity
@Table(name="USER")
public class User extends BaseEntity {

    private static final long serialVersionUID = -6189512849157712745L;

    @Column(name="username", nullable = false)
    private String username;

    @Column(name="name", nullable = false)
    private String name;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public interface UserDAO extends GenericDao<User, Long> {


}

@Repository
public class UserDAOImpl extends GenericJpaDao<User, Long>  implements UserDAO {

    public UserDAOImpl() {
        super(User.class);
    }

    @PersistenceContext
    private EntityManager entityManager;

}
通用DAO

public interface GenericDao<T, ID extends Serializable> {

    T save(T entity);
    T update(T entity);
    void delete(T entity);
    T findById(long id);
    List<T> findAll();
    void flush();
}

@Transactional
public abstract class GenericJpaDao<T, ID extends Serializable> implements GenericDao<T, ID> {

    private Class<T> persistentClass;

    @PersistenceContext
    private EntityManager entityManager;

    public GenericJpaDao(Class<T> persistentClass) {
        this.persistentClass = persistentClass;
    }

    protected EntityManager getEntityManager() {
        return entityManager;
    }

    @PersistenceContext
    public void setEntityManager(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    public Class<T> getPersistentClass() {
        return persistentClass;
    }

    @Transactional(readOnly=true)
    public T findById(long id) {
        T entity = (T) getEntityManager().find(getPersistentClass(), id);
        return entity;
    }

    @SuppressWarnings("unchecked")
    @Transactional(readOnly=true)
    public List<T> findAll() {
        return getEntityManager()
            .createQuery("select x from " + getPersistentClass().getSimpleName() + " x")
            .getResultList();
    }

    public T save(T entity) {
        getEntityManager().persist(entity);
        return entity;
    }

    public T update(T entity) {
        T mergedEntity = getEntityManager().merge(entity);
        return mergedEntity;
    }

    public void delete(T entity) {
        if (BaseEntity.class.isAssignableFrom(persistentClass)) {
            getEntityManager().remove(
                    getEntityManager().getReference(entity.getClass(), 
                            ((BaseEntity)entity).getId()));
        } else {
            entity = getEntityManager().merge(entity);
            getEntityManager().remove(entity);
        }
    }

    public void flush() {
        getEntityManager().flush();
    }

}
UserDAO

@MappedSuperclass
public class BaseEntity implements Serializable {

    private static final long serialVersionUID = -932093556089251203L;

    @Id
    @GeneratedValue
    private Long id;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

}

@Entity
@Table(name="USER")
public class User extends BaseEntity {

    private static final long serialVersionUID = -6189512849157712745L;

    @Column(name="username", nullable = false)
    private String username;

    @Column(name="name", nullable = false)
    private String name;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public interface UserDAO extends GenericDao<User, Long> {


}

@Repository
public class UserDAOImpl extends GenericJpaDao<User, Long>  implements UserDAO {

    public UserDAOImpl() {
        super(User.class);
    }

    @PersistenceContext
    private EntityManager entityManager;

}

公共接口UserDAO扩展了GenericDao{
}
UserDAOImpl

@MappedSuperclass
public class BaseEntity implements Serializable {

    private static final long serialVersionUID = -932093556089251203L;

    @Id
    @GeneratedValue
    private Long id;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

}

@Entity
@Table(name="USER")
public class User extends BaseEntity {

    private static final long serialVersionUID = -6189512849157712745L;

    @Column(name="username", nullable = false)
    private String username;

    @Column(name="name", nullable = false)
    private String name;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public interface UserDAO extends GenericDao<User, Long> {


}

@Repository
public class UserDAOImpl extends GenericJpaDao<User, Long>  implements UserDAO {

    public UserDAOImpl() {
        super(User.class);
    }

    @PersistenceContext
    private EntityManager entityManager;

}

@存储库
公共类UserDAOImpl扩展了GenericJpaDao实现了UserDAO{
公共UserDAOImpl（）{
super（User.class）；
}
@持久上下文
私人实体管理者实体管理者；
}
最后是神奇服务我的服务Mysv

@Service
public class Mysv extends GenericService<User, Long> {

}

@服务
公共类Mysv扩展了GenericService{
}
我已经为Hibernate实现了一个通用实体、Dao和服务

BaseEntity

@MappedSuperclass
public class BaseEntity implements Serializable {

    private static final long serialVersionUID = -932093556089251203L;

    @Id
    @GeneratedValue
    private Long id;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

}

@Entity
@Table(name="USER")
public class User extends BaseEntity {

    private static final long serialVersionUID = -6189512849157712745L;

    @Column(name="username", nullable = false)
    private String username;

    @Column(name="name", nullable = false)
    private String name;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public interface UserDAO extends GenericDao<User, Long> {


}

@Repository
public class UserDAOImpl extends GenericJpaDao<User, Long>  implements UserDAO {

    public UserDAOImpl() {
        super(User.class);
    }

    @PersistenceContext
    private EntityManager entityManager;

}
通用DAO

public interface GenericDao<T, ID extends Serializable> {

    T save(T entity);
    T update(T entity);
    void delete(T entity);
    T findById(long id);
    List<T> findAll();
    void flush();
}

@Transactional
public abstract class GenericJpaDao<T, ID extends Serializable> implements GenericDao<T, ID> {

    private Class<T> persistentClass;

    @PersistenceContext
    private EntityManager entityManager;

    public GenericJpaDao(Class<T> persistentClass) {
        this.persistentClass = persistentClass;
    }

    protected EntityManager getEntityManager() {
        return entityManager;
    }

    @PersistenceContext
    public void setEntityManager(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    public Class<T> getPersistentClass() {
        return persistentClass;
    }

    @Transactional(readOnly=true)
    public T findById(long id) {
        T entity = (T) getEntityManager().find(getPersistentClass(), id);
        return entity;
    }

    @SuppressWarnings("unchecked")
    @Transactional(readOnly=true)
    public List<T> findAll() {
        return getEntityManager()
            .createQuery("select x from " + getPersistentClass().getSimpleName() + " x")
            .getResultList();
    }

    public T save(T entity) {
        getEntityManager().persist(entity);
        return entity;
    }

    public T update(T entity) {
        T mergedEntity = getEntityManager().merge(entity);
        return mergedEntity;
    }

    public void delete(T entity) {
        if (BaseEntity.class.isAssignableFrom(persistentClass)) {
            getEntityManager().remove(
                    getEntityManager().getReference(entity.getClass(), 
                            ((BaseEntity)entity).getId()));
        } else {
            entity = getEntityManager().merge(entity);
            getEntityManager().remove(entity);
        }
    }

    public void flush() {
        getEntityManager().flush();
    }

}
UserDAO

@MappedSuperclass
public class BaseEntity implements Serializable {

    private static final long serialVersionUID = -932093556089251203L;

    @Id
    @GeneratedValue
    private Long id;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

}

@Entity
@Table(name="USER")
public class User extends BaseEntity {

    private static final long serialVersionUID = -6189512849157712745L;

    @Column(name="username", nullable = false)
    private String username;

    @Column(name="name", nullable = false)
    private String name;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public interface UserDAO extends GenericDao<User, Long> {


}

@Repository
public class UserDAOImpl extends GenericJpaDao<User, Long>  implements UserDAO {

    public UserDAOImpl() {
        super(User.class);
    }

    @PersistenceContext
    private EntityManager entityManager;

}

公共接口UserDAO扩展了GenericDao{
}
UserDAOImpl

@MappedSuperclass
public class BaseEntity implements Serializable {

    private static final long serialVersionUID = -932093556089251203L;

    @Id
    @GeneratedValue
    private Long id;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

}

@Entity
@Table(name="USER")
public class User extends BaseEntity {

    private static final long serialVersionUID = -6189512849157712745L;

    @Column(name="username", nullable = false)
    private String username;

    @Column(name="name", nullable = false)
    private String name;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public interface UserDAO extends GenericDao<User, Long> {


}

@Repository
public class UserDAOImpl extends GenericJpaDao<User, Long>  implements UserDAO {

    public UserDAOImpl() {
        super(User.class);
    }

    @PersistenceContext
    private EntityManager entityManager;

}

@存储库
公共类UserDAOImpl扩展了GenericJpaDao实现了UserDAO{
公共UserDAOImpl（）{
super（User.class）；
}
@持久上下文
私人实体管理者实体管理者；
}
最后是神奇服务我的服务Mysv

@Service
public class Mysv extends GenericService<User, Long> {

}

@服务
公共类Mysv扩展了GenericService{
}
仅供参考，GenericDAO有一个单独的代码库！为了学习的目的编写自己的代码总是很好的，但我相信阅读标准库和框架的代码也很重要，以学习专家在那里采用的标准。因此，建议访问此库。

仅供参考，GenericDAO有一个单独的代码库！为了学习的目的编写自己的代码总是很好的，但我相信阅读标准库和框架的代码也很重要，以学习专家在那里采用的标准。因此，建议访问此库。

感谢您的快速响应！因此，为了澄清这一点，您仍然会为每个hibernate域对象创建一个单独的DAO，该对象将简单地实现或扩展GenericDAO？我创建genericDAO的全部目的是减少冗余的hibernate DAO类的数量？如果您的数据库操作如此简单（只需更新、插入、删除），并且没有专门的查询，那么您可以只实例化几个通用DAO，每种类型一个。感谢您的快速响应！因此，为了澄清这一点，您仍然会为每个hibernate域对象创建一个单独的DAO，该对象将简单地实现或扩展GenericDAO？我创建genericDAO的全部目的是减少冗余hibernate DAO类的数量？如果您的数据库操作如此简单（只需更新、插入、删除），并且没有专门的查询，那么您可以只实例化几个通用DAO，每种类型一个。