Comment créer un Générique de la classe DAO de l'utilisation d'Hibernate Contexte sessions

Je suis en train de mettre en œuvre un Générique DAO à l'aide de la mise en veille prolongée Contexte Sessions. Suite a mon coup:|

import java.io.Serializable;
public interface GenericDao<T, ID extends Serializable> {
/** Persist the newInstance object into database */
ID create(T newInstance);
/**
* Retrieve an object that was previously persisted to the database using
* the indicated id as primary key
*/
T read(ID primaryKey);
/** Save changes made to a persistent object. */
void update(T transientObject);
/** Remove an object from persistent storage in the database */
void delete(T persistentObject);
}
import java.io.Serializable;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.springframework.transaction.annotation.Transactional;
@Transactional
@SuppressWarnings("unchecked")
public class GenericDaoImpl<T, ID extends Serializable> implements
GenericDao<T, ID> {
private SessionFactory sessionFactory;
public void setSessionFactory(final SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
@Override
public ID create(final T newInstance) {
ID id = null;
final Session session = sessionFactory.openSession();
final Transaction tx = session.beginTransaction();
try {
id = (ID) session.save(newInstance);
tx.commit();
session.close();
} catch (final Exception e) {
if (tx != null) {
tx.rollback();
}
e.printStackTrace();
} finally {
if (session.isOpen()) {
session.close();
}
}
return id;
}
@Override
public T read(final ID primaryKey) {
T id = null;
final Session session = sessionFactory.openSession();
final Transaction tx = session.beginTransaction();
try {
id = (T) session.get(T, primaryKey);
tx.commit();
session.close();
} catch (final Exception e) {
if (tx != null) {
tx.rollback();
}
e.printStackTrace();
} finally {
if (session.isOpen()) {
session.close();
}
}
return id;
}
@Override
public void update(final T transientObject) {
final Session session = sessionFactory.openSession();
final Transaction tx = session.beginTransaction();
try {
session.saveOrUpdate(transientObject);
tx.commit();
session.close();
} catch (final Exception e) {
if (tx != null) {
tx.rollback();
}
e.printStackTrace();
} finally {
if (session.isOpen()) {
session.close();
}
}
}
@Override
public void delete(final T persistentObject) {
final Session session = sessionFactory.openSession();
final Transaction tx = session.beginTransaction();
try {
session.delete(persistentObject);
tx.commit();
session.close();
} catch (final Exception e) {
if (tx != null) {
tx.rollback();
}
e.printStackTrace();
} finally {
if (session.isOpen()) {
session.close();
}
}
}
}

applicationContext:

<bean id="domainDao" class="com.foo.dao.DomainDao">
<property name="sessionFactory">
<ref bean="sessionFactory"></ref>
</property>
</bean>
<bean id="domainDao2" class="com.foo.dao.GenericDaoImpl">
<property name="sessionFactory">
<ref bean="sessionFactory"></ref>
</property>
</bean>
<tx:annotation-driven transaction-manager="txManager" />
<bean id="txManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>

La nôtre est une nouvelle application qui nous tentent de mettre en œuvre à l'aide de Printemps 3.0.3 et Hibernate 3.5.5.

T1. Bien que je ne la mettre en œuvre et de travail, je n'ai pu le faire dans le bon sens?

T2. Comment puis-je mettre en œuvre find() opération à l'aide de médicaments génériques?

id = (T) session.get(T, primaryKey);

Cette ligne est de donner une erreur de compilation.

Mise à JOUR: L'erreur est parce que le premier paramètre est de type Class.

public Object get(Class clazz, Serializable id)
throws HibernateException

T3. Comment convertir T à T.class?

Merci de ne pas nous dire ce que l'erreur de compilation est, c'est beaucoup plus amusant à deviner.
Désolé de ne pas l'obtenir. Vous êtes sérieux ou était-ce un sarcastique :S
C'était du sarcasme. Et concernant T3, les Génériques type d'information est effacée au moment de la compilation et n'est donc pas disponible au moment de l'exécution. Vous devez passer à la classe réelle et la mémoriser où vous en avez besoin.

InformationsquelleAutor jai | 2010-08-26

L'astuce suivante est souvent utilisée dans les classes DAO pour accéder aux paramètres de type réel de sous-classes:

public abstract class GenericDAO<T, ID extends Serializable> {  
private Class<T> persistentClass;  
...
@SuppressWarnings("unchecked")
public GenericDAO() {
this.persistentClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
}
public T get(ID id) {
return (T) session.get(persistentClass, id);
}
...
}

Et le réel DAO sous-classe:

public class FooDAO extends GenericDAO<Foo, Long> {}

InformationsquelleAutor axtavt

Les génériques ne peuvent pas être utilisés de cette façon. Changer votre GenericDAOImpl d'avoir un constrctor qui prend de la classe et de l'utilisation de cette classe dans le session.get appel. Voir l'exemple ci-dessous (il utilise JPA au lieu de Hibernate classes spécifiques).

public class GenericDao<T> {
@PersistenceContext
private EntityManager em;
public EntityManager em() {
return em;
}
public void create(final T entity) {
em.persist(entity);
}
public void update(final T entity) {
em.merge(entity);
}
protected T get(final Class<T> type, final String id) {
return em.find(type, id);
}
public void delete(final T entity) {
em.remove(entity);
}
}
public class PersonDao extends GenericDao<Person>{
public Person get(final String id) {
return get(Person.class, id);
}
}

Aussi, il est préférable de mettre @Transactional annotations sur les affaires ou les services de données, pas sur les DAOs.

InformationsquelleAutor Abhinav Sarkar

Vous devez vous connecter pour publier un commentaire.