[SPRING] 최대 절전 모드 컨텍스트 세션을 사용하여 일반 DAO 클래스를 만드는 방법

최대 절전 모드 컨텍스트 세션을 사용하여 일반 DAO 클래스를 만드는 방법

최대 절전 모드 컨텍스트 세션을 사용하여 일반 DAO를 구현하려고합니다. 다음은 나의 탄이었다 : |

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>

우리는 Spring 3.0.3과 Hibernate 3.5.5를 사용하여 구현하고자하는 새로운 애플리케이션이다.

Q1. 내가 그것을 구현하고 일하고 있지만 올바른 방법으로 했는가?

Q2. 제네릭을 사용하여 find () 연산을 구현하려면 어떻게해야합니까?

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

이 행은 컴파일 오류를 발생시킵니다.

업데이트 : 첫 번째 매개 변수가 클래스 형식이기 때문에 오류입니다.

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

Q3. T를 T.class로 변환하는 방법?

해결법

1. ==============================

   1.다음 트릭은 실제 DAO 클래스에서 종종 실제 서브 클래스의 유형 매개 변수에 액세스하는 데 사용됩니다.

   다음 트릭은 실제 DAO 클래스에서 종종 실제 서브 클래스의 유형 매개 변수에 액세스하는 데 사용됩니다.

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

   그리고 실제 DAO 하위 클래스 :

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

2. ==============================

   2.제네릭은 그런 식으로 사용할 수 없습니다. GenericDAOImpl을 변경하여 클래스를 가져 와서 해당 클래스를 session.get 호출에서 사용하도록하십시오. 아래 예제를 보라 (Hibernate 특정 클래스 대신에 JPA를 사용한다).

   제네릭은 그런 식으로 사용할 수 없습니다. GenericDAOImpl을 변경하여 클래스를 가져 와서 해당 클래스를 session.get 호출에서 사용하도록하십시오. 아래 예제를 보라 (Hibernate 특정 클래스 대신에 JPA를 사용한다).

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

   또한 @Transactional 어노테이션을 DAO가 아닌 비즈니스 또는 데이터 서비스에 배치하는 것이 더 좋습니다.

from https://stackoverflow.com/questions/3573479/how-to-create-a-generic-dao-class-using-hibernate-context-sessions by cc-by-sa and MIT license