java - 创建一个可以处理所有类型的 CRUD 操作的类。每次我需要执行 CRUD 时，无需创建 SessionFactory 或 Session 对象

Question

我想让java中的一个类有一个可以与Hibernate配置交互并执行某些操作的方法，该方法被标识为ENUM(例如:读取，更新，添加，删除等)

方法参数应为(枚举操作、类 DTO、NamedQuery 命名查询、DTOObject Object_to_persist、param(任何额外参数))。

方法应该很方便，我可以在需要时通过传递实际参数(Operation.read、USERDTO.class、namedquery、USERDTO obj_UserDTO、HashMap hmapData)来调用它。

  /* Enum Defined Operation done to the database.
   */ 
     public enum Operations {READ,UPDATE,ADD,DELETE};

      /*Centralized Method Defination for Basic CRUD Operation */
public T<?> DatabaseCRUDOperations((Operation.READ,USERDTO.class , namedquery , USERDTO obj_UserDTO , HashMap<String, String> hmapid){
     switch(Operation opts){
             case Operation.Read : //Call Read Method
               break;

             case Operation.UPDATE: //call Update Method
               break;
                ......
                ......
              default://call any Error Method or set error
        }
   }

基本上我想定义一个自定义类(项目的一种内部框架)，它具有所有基本的 CRUD 操作只能通过这个类完成。无需创建 SessionFactory 或 Session 对象，在我需要的每个地方创建。 请通过一些代码片段提出建议。

Answer 1

Java 泛型来救援!准备好感到惊讶吧。

您的抽象实体(如果您想定义在通用 Controller 类等中使用的方法，则很有用):

public abstract class AbstractEntity<ID extends Serializable> implements Serializable {

    public abstract ID getPrimaryKey();//I simply put this here as an example
}

创建通用 DAO 接口(interface):

public interface IGenericDAO<T extends AbstractEntity<ID>, ID extends Serializable> {
    T findByPrimaryKey(ID id);

    T save(T entity);

    void delete(T entity);

    List<T> saveAll(List<T> entities);
    .
    .
    .
}

然后，定义您的抽象通用 DAO:

public abstract class AbstractHibernateDAO<T extends AbstractEntity<ID>, ID extends Serializable> implements IGenericDAO<T, ID> {
    protected Class<T> persistentClass;

    protected AbstractHibernateDAO(){}
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public AbstractHibernateDAO(Class c) {
        persistentClass = c;
    }

    @Override
    @SuppressWarnings("unchecked")
    public T findByPrimaryKey(ID id){
        return (T) HibernateUtil.getSession().get(persistentClass, id);
    }


    @Override
    public T save(T entity){
        HibernateUtil.getSession().saveOrUpdate(entity);
        return entity;
    }

    @Override
    public List<T> saveAll(List<T> entities){
        for(int i = 0; i < entities.size(); i++){
            HibernateUtil.getSession().saveOrUpdate(entities.get(i));
        }
        return entities;
    }

    @Override
    public void delete(T entity){
        HibernateUtil.getSession().delete(entity);
    }
    .
    .
    .
}

实体的 DAO 接口(interface)(在本例中，我使用 Integer 作为主键):

public interface IMyEntityDAO extends IGenericDAO<MyEntity, Integer> {
}

现在(击鼓)，您已准备好铺设一些具体的(类)...

DAO:

public class MyEntityDAO extends AbstractHibernateDAO<MyEntity, Integer> implements IMyEntityDAO {
    public MyEntityDAO() {
        super(MyEntity.class);
    }
}

我的实体:

@Entity
@Table(name = "my_entity_table")
public class MyEntity extends AbstractEntity<Integer>{

    @Id
    @Column(name = "index")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

 public Integer getPrimaryKey (){
       return id;
 }
    .
    .
    .
}

繁荣。 (麦克风掉落)

如果您需要进一步解释，请告诉我!

如果不感谢卡梅伦·麦肯齐和他令人惊叹的book here，我就不能正确地发布此内容。 。这让我看到了一个全新的世界，认识到了泛型的力量。