Obtendo o modelo de hibernato correto em uma primavera genérica Crud Dao

Question

Ainda sou muito novo na primavera e achei irritante fazer todos esses crus daos, então fiz uma "classe pública genérica e estende a hibernatedaosupport implementa Cruddao". Nos meus objetos de serviço, simplesmente digo algo como

private GenericCRUDDAO<User, Integer> userDAO = new GenericCRUDDAO<User, Integer>();

E não tenho mais que escrever Daos simples e conectá -los. Yay! Exceto por uma coisa, tenho certeza de que todos os seus desenvolvedores de primavera experimentaram imediatamente: não consigo obter o modelo de hibernato dentro do genéricocruddao, então fazendo

HibernateTemplate ht = getHibernateTemplate();

me dá um HT que é nulo. Não tão bom. Pensei em conectá -lo, significando fazer um Bean GenericCruddao e depois definir uma anotações estática, mas isso ainda não me daria um hibernateTemplate. Alguma sugestão sobre como eu contorno isso para que eu possa ter meu modelo de hibernação?

Mais algum problema em fazer um crud dao genérico em que eu deveria estar pensando?

Felicidades

Nik

Answer 1

Para muitos, HibernateTemplate e HibernateDaoSupport estão de fora e injetando um SessionFactory é preferível. Nem todo mundo, lembre -se, mas é uma tendência, que eu adotei há pouco tempo, removendo HibernateTemplate Do meu próprio Dao genérico.

Este blog tem um resumo muito bom.

Os exemplos do autor devem poder ajudá -lo a chegar onde você deseja estar.

Answer 2

Genericdao

Bem, para mim, Se o seu genérico for 'genérico', você pode precisar apenas de uma instância, e faça tudo com essa única instância.

Tenho certeza de que não incomoda você a conectar na instância, é a repetição que você fica bravo (e eu concordo com você).

Por exemplo, você pode passar a classe de entidade para um método genérico.

• Public void Save (classe, e ...): permite salvar uma ou mais instâncias do tipo E, sendo uma de suas entidades.
• Public E Load (classe, ID longo): carrega uma entidade.

• ...

  /** Assuming the entities have a superclass SuperEntity with getIdent(). */
  public class GenericDaoImpl implements GenericDao {
  
     /** Save a bunch of entities */
     public void save(SuperEntity... entities) {
       for(SuperEntity entity : entities) {
         getSession().save(entity);
       }
     }
  
     /** Load any entity. */
     public <E extends SuperEntity> E load(Class<E> entityClass, Long ident) {
       return (E)getSession().load(entityClass, ident);
     }
  
     // other generic methods
  }
  

---

Variante

Em nossas aplicações, na verdade temos uma variante para isso. Como temos muitas solicitações específicas para cada DAO, precisamos das classes DAO específicas de qualquer maneira (crie a classe e conecte -a); portanto, para evitar o caso especial de um DAO que não seria definido, fazemos as classes específicas do DAO imediatamente.

Codificação

Mas de forma alguma repetimos o código. Todos os nossos DAOs estendem o Genericdao, fornecendo no construtor o parâmetro de classe necessário. Código de exemplo (não completo, simples para obter a ideia básica):

    public abstract class GenericDaoImpl<E extends SuperEntity> 
        implements GenericDao<E> {

       /** Available for generic methods, so it is not a parameter 
        * for the generic methods. */
       private final Class<E> entityClass;

       protected GenericDaoImpl(Class<E> entityClass) {
         this.entityClass = entityClass;
       }

       // generic implementation ; can be made efficient, as it may 
       // send the orders as a batch
       public void save(E... entities) {
         for(SuperEntity entity : entities) {
           getSession().save(entityClass, entity.getIdent());
         }
         // possibly add flushing, clearing them from the Session ...
       }

       // other generic methods
    }

    public class PersonDaoImpl extends GenericDaoImpl<Person> 
        implements PersonDao {

      /** Constructor, instanciating the superclass with the class parameter. */
      public PersonDaoImpl() {
        super(Person.class);
      }

      /** Specific method. */
      public List<Person> findByAge(int minAge, int maxAge) {
        //....
      }
    }

Fiação

A fiação de todo o feijão não é uma fatalidade. Atualmente, existem muitas políticas de arremessos automáticos, você não precisa se preocupar com isso. Veja -os na primavera
http://static.springsource.org/spring/docs/2.5.x/reference/beans.html#beans-annotation-config