Java 带异常和泛型的DAO的JPA和spring处理

javax.transaction.TransactionRequiredException

”从未在相应的try块中抛出

参考：

注意：我不想在我的方法签名中声明

抛出新异常

如何
处理异常

我认为
.save.merge
用于所有
dao
。因此，用不同的对象（但相同的模式）为每个DAO编写相同的代码不是明智的
OOP.

如何正确地使
通用。合并。保存
或所有重复的内容

不过，我在谷歌上找不到多少稳定的例子

有样本代码吗

private EntityManager entityManager;

    public Boards save(Boards board) {
          Boards boardToBeReturned = null;
          try{
              boardToBeReturned = entityManager.merge(board);
          }catch (IllegalArgumentException e){
              e.printStackTrace();
          }catch (TransactionRequiredException e){
              e.printStackTrace();
          }

          return boardToBeReturned;
    } 

类的完整示例代码：

package web.dao.impl.jpa;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.PersistenceContextType;
import javax.transaction.TransactionRequiredException;

import org.hibernate.Session;
import org.springframework.stereotype.Repository;
import web.dao.BoardsDAO;
import web.entity.Boards;
import web.entity.Users;


@Repository
public class BoardsDAOImpl implements BoardsDAO {

    /**
     * The JPA entity manager
     */
//  @Autowired
    @PersistenceContext(type = PersistenceContextType.EXTENDED)
    private EntityManager entityManager;

    public Boards save(Boards board) {
        Boards boardToBeReturned = null;
        try{
            boardToBeReturned = entityManager.merge(board);
        }catch (IllegalArgumentException e){
             e.printStackTrace();
//        }catch (TransactionRequiredException e){
//            e.printStackTrace();
        }
        return boardToBeReturned;
    }


    public Boards getBoardById(Long id){
        Boards boardToBeReturned = null;
        System.out.println("board id entered for lookup was : "+id);
        try {
            boardToBeReturned=entityManager.find(Boards.class, id);
        }catch (IllegalArgumentException e){
               e.printStackTrace();
        }
        return boardToBeReturned;
    }


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

    /**
     * Helper method to return the hibernate session from the JPA
     * entity manager implementation.
     * 
     * @return the hibernate {#link Session}
     */
    protected Session getHibernateSession() {
        return entityManager.unwrap(Session.class);
    }


        public List<Boards> getBoardListByUser(Users user){

            return null;
        }


}

package web.dao.impl.jpa；
导入java.util.List；
导入javax.persistence.EntityManager；
导入javax.persistence.PersistenceContext；
导入javax.persistence.PersistenceContextType；
导入javax.transaction.TransactionRequiredException；
导入org.hibernate.Session；
导入org.springframework.stereotype.Repository；
导入web.dao.BoardsDAO；
导入web.entity.Boards；
导入web.entity.Users；
@存储库
公共类BoardsDAOImpl实现BoardsDAO{
/**
*JPA实体管理器
*/
//@自动连线
@PersistenceContext（类型=PersistenceContextType.EXTENDED）
私人实体管理者实体管理者；
公共董事会保存（董事会）{
boardToBeReturned=null；
试一试{
boardToBeReturned=entityManager.merge（板）；
}捕获（IllegalArgumentException e）{
e、 printStackTrace（）；
//}catch（TransactionRequiredException e）{
//e.printStackTrace（）；
}
返回董事会，以备查阅；
}
公共板getBoardById（长id）{
boardToBeReturned=null；
System.out.println（“为查找而输入的板id为：“+id”）；
试一试{
boardToBeReturned=entityManager.find（Boards.class，id）；
}捕获（IllegalArgumentException e）{
e、 printStackTrace（）；
}
返回董事会，以备查阅；
}
@持久上下文
公共无效设置EntityManager（EntityManager EntityManager）{
this.entityManager=entityManager；
}
/**
*从JPA返回hibernate会话的Helper方法
*实体管理器实现。
* 
*@返回休眠{#链接会话}
*/
受保护会话getHibernateSession（）{
返回entityManager.unwrap（Session.class）；
}
公共列表getBoardListByUser（用户）{
返回null；
}
}
以下是一个示例界面：

public interface GenericDao<T, PK extends Serializable> {
    T create(T t);
    T read(PK id);
    T update(T t);
    void delete(T t);
}

公共接口GenericDao{
T创建（T）；
T读取（pkid）；
T更新（T）；
无效删除（T）；
}

以及一项实施：

public class GenericDaoJpaImpl<T, PK extends Serializable> 
    implements GenericDao<T, PK> {

    protected Class<T> entityClass;

    @PersistenceContext
    protected EntityManager entityManager;

    public GenericDaoJpaImpl() {
        ParameterizedType genericSuperclass = (ParameterizedType) getClass()
             .getGenericSuperclass();
        this.entityClass = (Class<T>) genericSuperclass
             .getActualTypeArguments()[0];
    }

    @Override
    public T create(T t) {
        this.entityManager.persist(t);
        return t;
    }

    @Override
    public T read(PK id) {
        return this.entityManager.find(entityClass, id);
    }

    @Override
    public T update(T t) {
        return this.entityManager.merge(t);
    }

    @Override
    public void delete(T t) {
        t = this.entityManager.merge(t);
        this.entityManager.remove(t);
    }
}

公共类GenericDaoJpaImpl
实现GenericDao{
保护类实体类；
@持久上下文
受保护的实体管理器实体管理器；
公共通用DAOJPAIMPL（）{
ParameteredType genericSuperclass=（ParameteredType）getClass（）
.getGenericSuperclass（）；
this.entityClass=（类）genericSuperclass
.getActualTypeArguments（）[0]；
}
@凌驾
公共T创建（T）{
this.entityManager.persist（t）；
返回t；
}
@凌驾
公共T读（主键id）{
返回此.entityManager.find（entityClass，id）；
}
@凌驾
公共T更新（T）{
返回此.entityManager.merge（t）；
}
@凌驾
公共作废删除（T）{
t=this.entityManager.merge（t）；
此.entityManager.remove（t）；
}
}

记录异常并将它们作为调用方的
RuntimeException
重新抛出

记录异常：-在catch块中打印/记录堆栈跟踪，这样，如果方法的调用方忘记将其记录到日志中，那么您已经在
genericdao中完成了它

重新抛出异常：-以便调用方可以捕获该异常并回滚等他想做的任何事情
下面是一个示例界面：

public interface GenericDao<T, PK extends Serializable> {
    T create(T t);
    T read(PK id);
    T update(T t);
    void delete(T t);
}

公共接口GenericDao{
T创建（T）；
T读取（pkid）；
T更新（T）；
无效删除（T）；
}

以及一项实施：

public class GenericDaoJpaImpl<T, PK extends Serializable> 
    implements GenericDao<T, PK> {

    protected Class<T> entityClass;

    @PersistenceContext
    protected EntityManager entityManager;

    public GenericDaoJpaImpl() {
        ParameterizedType genericSuperclass = (ParameterizedType) getClass()
             .getGenericSuperclass();
        this.entityClass = (Class<T>) genericSuperclass
             .getActualTypeArguments()[0];
    }

    @Override
    public T create(T t) {
        this.entityManager.persist(t);
        return t;
    }

    @Override
    public T read(PK id) {
        return this.entityManager.find(entityClass, id);
    }

    @Override
    public T update(T t) {
        return this.entityManager.merge(t);
    }

    @Override
    public void delete(T t) {
        t = this.entityManager.merge(t);
        this.entityManager.remove(t);
    }
}

公共类GenericDaoJpaImpl
实现GenericDao{
保护类实体类；
@持久上下文
受保护的实体管理器实体管理器；
公共通用DAOJPAIMPL（）{
ParameteredType genericSuperclass=（ParameteredType）getClass（）
.getGenericSuperclass（）；
this.entityClass=（类）genericSuperclass
.getActualTypeArguments（）[0]；
}
@凌驾
公共T创建（T）{
this.entityManager.persist（t）；
返回t；
}
@凌驾
公共T读（主键id）{
返回此.entityManager.find（entityClass，id）；
}
@凌驾
公共T更新（T）{
返回此.entityManager.merge（t）；
}
@凌驾
公共作废删除（T）{
t=this.entityManager.merge（t）；
此.entityManager.remove（t）；
}
}

记录异常并将它们作为调用方的
RuntimeException
重新抛出

记录异常：-在catch块中打印/记录堆栈跟踪，这样，如果方法的调用方忘记将其记录到日志中，那么您已经在
genericdao中完成了它

重新引发异常：-以便调用方可以捕获该异常并回滚等他想执行的任何操作
IllegalArgumentException和TransactionRequiredException是运行时异常，表示存在编程错误。你不应该抓住他们。如果你抓住了他们，更糟糕的事情是像你正在做的那样忽视他们，假装什么都没发生。您的方法应该如下所示：

public Boards save(Boards board) {
    return entityManager.merge(board);
}

既然您正在使用Spring并寻找通用DAO，那么请看看这个项目，它只提供了这些，还有更多