Hibernate-generic-DAO, allgemeiner Dienst, und Generische View-Schicht?

Ich habe versucht, Sie zu verstehen und zu implementieren, die eine GenericDAO Schicht im Ruhezustand. Ich bin neu in das Konzept und wurden dabei ein wenig Lesen und studieren. Ich fand zahlreiche Beispiele, Beispiel-Implementierungen von einem GenericDAO Ebene, und das ist, was ich endete mit. 

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;
    }       
}

Scheint es, als ob diese Arbeit sollte in der Theorie (möglicherweise müssen einige Optimierungen)

Meine Frage ist kann ich verwenden einen generischen service und view layer zu "pass-through" der geschichteten Architektur-Ansatz? Ich verstehe nicht ganz, hibernate Transaktionen genug, um zu wissen, ob es sicher ist, dies zu tun, mit seiner Handhabung der Transaktionen etc...

Vielleicht so etwas wie dies für die service-Schicht zum Beispiel

public class GenericServiceImpl<T, ID extends Serializable> implements GenericService<T, ID>{

    private GenericDAO<T, ID> genericDao;

    @Override
    public T findById(long id, Class<T> objectClass) {
        return this.getGenericDao().findById(id, objectClass);
    }

    @Override
    public boolean create(T newInstance) {
        return this.getGenericDao().create(newInstance);
    }

    @Override
    public boolean updpate(T updateInstance) {
        return this.getGenericDao().updpate(updateInstance);
    }

    @Override
    public boolean delete(T entity) {
        return this.getGenericDao().delete(entity);
    }

    @SuppressWarnings({ "unchecked", "rawtypes" })
    @Override
    public List findByExample(T exampleInstance, Class<T> objectClass) {
        return this.getGenericDao().findByExample(exampleInstance, objectClass);
    }


    public GenericDAO<T, ID> getGenericDao() {
        return genericDao;
    }

    public void setGenericDao(GenericDAO<T, ID> genericDao) {
        this.genericDao = genericDao;
    }


}

Dann könnte ich gehen und tun, eine generische view-Schicht?

Bitte lassen Sie mich wissen, ob diese Vorgehensweise akzeptabel ist oder wenn es irgendwelche Bedenken bei diesem Ansatz.

Vielen Dank im Voraus für Eure Gedanken und Antworten!

InformationsquelleAutor Curt | 2012-08-23

  1. 3

    Ihren Dienst, so wie es da steht, ist einfach delegieren alles an den zugrunde liegenden DAO. Dies kann gewünscht sein, manchmal, aber in der Regel lege ich "business-Logik" in die service-Schicht. Putting Logik in die service-Ebene wird dazu beitragen, halten Sie Ihre controller-Schicht ziemlich leicht zu.

    Dienst kann eine oder mehrere DAOs, die Aufgabe zu erfüllen, die es braucht. So erwägen, eine einfache bank-system, wo ich einen AccountDao

    public class AccountDao implements GenericDao<Account, Long> {
  //your save, insert, delete, find, etc
}

    Dann in meinem Dienst, ich würde "makePayment" oder etwas

    @Service
public class AccountService {

   @Autowired
   private AccountDao dao;

   @Transactional
   public void makePayment(Long fromId, Long toId, double amount) {
      Account from = dao.find(fromId);
      from.withdrawl(amount);

      Account to = dao.find(toId);
      to.deposit(amount);

      dao.save(from);
      dao.save(to);
   }
}

    Transaktionen verwenden, die auf Ihrem service-layer, um Ihnen mehr Kontrolle über die Vorgänge müssen in der gleichen Transaktion.

    Danke für die schnelle Antwort! Also nur um zu klären, würden Sie immer noch, erstellen Sie eine separate DAO für jede hibernate-domain-Objekt, das würde einfach zu implementieren oder erweitern Sie die GenericDAO? Der ganze Zweck von mir erstellen der genericDAO war die Reduzierung der Anzahl der redundanten hibernate-DAO-Klassen ?
    Wenn Ihre Datenbank-Operationen sind diese einfach (nur update, insert, delete) und keine spezielle Abfragen, dann kann man nur noch instanziieren mehrere generische daos, eine für jeden Typ.

    InformationsquelleAutor jeff

  2. 4

    Ich habe implementiert eine Generische Entität, Dao und Service für Hibernate

    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;
    }

}

    GenericDao

    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();
}

    GenericJpaDao

    @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();
    }

}

    GenericService

    public class GenericService<T, ID extends Serializable> {
    @Autowired
    private GenericDao<T, ID> genericDao;

    public T find(long id) {
        return this.getGenericDao().findById(id);
    }

    public List<T> all() {
        return this.getGenericDao().findAll();
    }

    @Transactional
    public T create(T newInstance) {
        return (T) this.getGenericDao().save(newInstance);
    }

    @Transactional
    public T updpate(T updateInstance) {
        return (T) this.getGenericDao().update(updateInstance);
    }

    @Transactional
    public void delete(T entity) {
         this.getGenericDao().delete(entity);
    }

    public GenericDao<T, ID> getGenericDao() {
        return genericDao;
    }

    public void setGenericDao(GenericDao<T, ID> genericDao) {
        this.genericDao = genericDao;
    }


}

    Für Den Einsatz :

    Benutzer 

    @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;
    }
}

    UserDAO 

    public interface UserDAO extends GenericDao<User, Long> {


}

    UserDAOImpl 

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

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

    @PersistenceContext
    private EntityManager entityManager;

}

    Und Schließlich die Magie Service mein Service Mysv

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

}

    InformationsquelleAutor EraMaX

  3. 1

    Nur zu deiner information, es gibt ein separates code-Bibliothek für GenericDAO hibernate-generic-dao! Es ist immer gut zu schreiben Ihren eigenen code für den Zweck des Lernens, aber ich glaube, es ist auch wichtig zu Las-code der standard-Bibliothek und frameworks zu erlernen-Normen, die angenommen wurde es von Experten. So, es wird empfohlen, besuchen Sie diese Bibliothek.

    InformationsquelleAutor Neo182

Schreibe einen Kommentar