hibernate封装

最新推荐文章于 2023-01-31 22:39:32 发布
最新推荐文章于 2023-01-31 22:39:32 发布
阅读量224 收藏
点赞数
文章标签： java
原文链接：https://my.oschina.net/u/2484672/blog/523689
版权

有幸和一个技术比较厉害的同事做项目，本来快要失败的项目被死死的整活了，以下是他对hibernate的封装，可以放在线程里使用的哦(以前不知道呢，-_-!，hibernate的功能真大啊 )

package com.eclink.editp.dao;

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

import org.apache.log4j.Logger;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.ScrollableResults;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.cn.hibernate.SessionFactory;

/**
 * @author xiongying
 * @Date 2006-02-25
 * @declare 关于HIBERNATE的相关方法的封装
 */
public class HibernateDao {
 private static final Logger logger = Logger.getLogger(HibernateDao.class);
 List list = new ArrayList();
 
    /**
     * @param entityName
     * @param id
     * @return
     */
 public Object get(Class entityName, Serializable id) {
  logger.info("get(Class entityName, int id) - start");
  Session session = null;
  Transaction tx = null;
  try {
   session = SessionFactory.currentSession();//最好是工具生成的SessionFactory，自己写比较麻烦，想我这种菜鸟还会出错
   tx = session.beginTransaction();
   Object object = session.get(entityName, id);
   tx.commit();
   SessionFactory.closeSession();
   logger.info("get(Class entityName, int id) - end");
   return object;
  } catch (HibernateException e) {
   logger.error("get(Class entityName, int id) throw exception = ", e);
   try {
    if (tx != null) tx.rollback();
   } catch (HibernateException ex) {
    throw new RuntimeException("tx.rollbacd() throw exception = " + ex.toString());
   }
   throw new RuntimeException("get(Class entityName, int id) throw exception = " + e.toString());
  } finally {
   try {
    if (session != null) SessionFactory.closeSession(); 
   } catch (HibernateException e) {
    throw new RuntimeException("SessionFactory.closeSession() throw exception = " + e.toString());
   }
  }
 } 

 /**
  * @param object
  * @return
  */
 public boolean delete(Object object) {
  Session session = null;
  Transaction tx = null;
  logger.info("delete(Object object) - start");
  try {
   session = SessionFactory.currentSession();
   tx = session.beginTransaction();
   session.delete(object);
   tx.commit();
   SessionFactory.closeSession();
   logger.info("delete(Object object) - end");
   return true;
  } catch (HibernateException e) {
   logger.error("delete(Object object) throw exception = ", e);
   try {
    if (tx != null) tx.rollback();
   } catch (HibernateException ex) {
    throw new RuntimeException("tx.rollbacd() throw exception = " + ex.toString());
   }
   throw new RuntimeException("delete(Object object) throw exception = " + e.toString());
  } finally {
   try {
    if (session != null) SessionFactory.closeSession(); 
   } catch (HibernateException e) {
    throw new RuntimeException("SessionFactory.closeSession() throw exception = " + e.toString());
   }
  }
 }

 /**
  * @param object
  * @return
  * @throws HibernateException
  */
 public boolean save(Object object) {
  Session session = null;
  Transaction tx = null;
  logger.info("save(Object object) - start");
  try {
   session = SessionFactory.currentSession();
   tx = session.beginTransaction();
   session.save(object);
   tx.commit();
   SessionFactory.closeSession();
   logger.info("save(Object object) - end");
   return true;
  } catch (HibernateException e) {
   logger.error("save(Object object) throw exception = ", e);
   try {
    if (tx != null) tx.rollback();
   } catch (HibernateException ex) {
    throw new RuntimeException("tx.rollbacd() throw exception = " + ex.toString());
   }
   throw new RuntimeException("save(Object object) throw exception = " + e.toString());
  } finally {
   try {
    if (session != null) SessionFactory.closeSession(); 
   } catch (HibernateException e) {
    throw new RuntimeException("SessionFactory.closeSession() throw exception = " + e.toString());
   }
  }
 }

 /**
  * @param object
  * @return
  * @throws HibernateException
  */
 public boolean update(Object object) {
  Session session = null;
  Transaction tx = null;
  logger.info("update(Object object) - start");
  try {
   session = SessionFactory.currentSession();
   tx = session.beginTransaction();
   session.update(object);
   tx.commit();
   SessionFactory.closeSession();
   logger.info("update(Object object) - end");
   return true;
  } catch (HibernateException e) {
   logger.error("update(Object object) throw exception = ", e);
   try {
    if (tx != null) tx.rollback();
   } catch (HibernateException ex) {
    throw new RuntimeException("tx.rollbacd() throw exception = " + ex.toString());
   }
   throw new RuntimeException("update(Object object) throw exception = " + e.toString());
  } finally {
   try {
    if (session != null) SessionFactory.closeSession(); 
   } catch (HibernateException e) {
    throw new RuntimeException("SessionFactory.closeSession() throw exception = " + e.toString());
   }
  }
 }

 /**
  * @param object
  * @return
  * @throws HibernateException
  */
 public boolean saveOrUpdate(Object object) {
  System.out.println("=============== saveOrUpdate() start =================");
  Session session = null;
  Transaction tx = null;
  logger.info("saveOrUpdate(Object) - start");
  try {
   session = SessionFactory.currentSession();
   tx = session.beginTransaction();
   session.saveOrUpdate(object);
   tx.commit();
   SessionFactory.closeSession();
   logger.info("saveOrUpdate(Object) - end");
   System.out.println("============== saveOrUpdate() end =================");
   return true;
  } catch (HibernateException e) {
   logger.error("saveOrUpdate(Object object) throw exception = ", e);
   try {
    if (tx != null) tx.rollback();
   } catch (HibernateException ex) {
    throw new RuntimeException("tx.rollbacd() throw exception = " + ex.toString());
   }
   throw new RuntimeException("saveOrUpdate(Object) throw exception = " + e.toString());
  } finally {
   try {
    if (session != null) SessionFactory.closeSession(); 
   } catch (HibernateException e) {
    throw new RuntimeException("SessionFactory.closeSession() throw exception = " + e.toString());
   }
  }
 }

 /**
  * @param sql
  * @param parameter
  * @return
  * @throws HibernateException
  */
 public boolean update(String sql, Object[] parameter) {
  Session session = null;
  Transaction tx = null;
  logger.info("update(String sql, Object[] parameter) - start");
  try {
   session = SessionFactory.currentSession();
   tx = session.beginTransaction();
   Query query = session.createQuery(sql);
   setQueryParameterValues(query, parameter);
   query.executeUpdate();
   tx.commit();
   SessionFactory.closeSession();
   logger.info("update(String sql, Object[] parameter) - end");
   return true;
  } catch (HibernateException e) {
   logger.error("update(String sql, Object[] parameter) throw exception = ", e);
   try {
    if (tx != null) tx.rollback();
   } catch (HibernateException ex) {
    throw new RuntimeException("tx.rollbacd() throw exception = " + ex.toString());
   }
   throw new RuntimeException("update(String sql, Object[] parameter) throw exception = " + e.toString());
  } finally {
   try {
    if (session != null) SessionFactory.closeSession(); 
   } catch (HibernateException e) {
    throw new RuntimeException("SessionFactory.closeSession() throw exception = " + e.toString());
   }
  }
 }

 /** 
  * @param sql
  * @return
  */
 public List find(String sql) {
  logger.info("find(String, String, int) - start");
  Session session = null;
  Transaction tx = null;
  try {
   session = SessionFactory.currentSession();
   tx = session.beginTransaction();
   Query query = session.createQuery(sql);
   list = query.list();
   tx.commit();
   SessionFactory.closeSession();
   logger.info("find(String, String, int) - end");
   return list;
  } catch (HibernateException e) {
   logger.error("find(String, String, int) throw exception = ", e);
   try {
    if (tx != null) tx.rollback();
   } catch (HibernateException ex) {
    throw new RuntimeException("tx.rollbacd() throw exception = " + ex.toString());
   }
   throw new RuntimeException("find(String, String, int) throw exception = " + e.toString());
  } finally {
   try {
    if (session != null) SessionFactory.closeSession(); 
   } catch (HibernateException e) {
    throw new RuntimeException("SessionFactory.closeSession() throw exception = " + e.toString());
   }
  }
 }

 /**
  * 位置参数查询
  * @param sql
  * @param parameter
  * @return
  */
 public List find(String sql, Object[] parameter) {
  Session session = null;
  Transaction tx = null;
  logger.info("find(String sql, Object[] object) - start");
  try {
   session = SessionFactory.currentSession();
   tx = session.beginTransaction();
   Query query = session.createQuery(sql);
   setQueryParameterValues(query, parameter);
   list = query.list();
   tx.commit();
   SessionFactory.closeSession();
   logger.info("find(String sql, Object[] object) - end");
   return list;
  } catch (HibernateException e) {
   logger.error("find(String sql, Object[] object) throw exception = ", e);
   try {
    if (tx != null) tx.rollback();
   } catch (HibernateException ex) {
    throw new RuntimeException("tx.rollbacd() throw exception = " + ex.toString());
   }
   throw new RuntimeException("find(String sql, Object[] object) throw exception = " + e.toString());
  } finally {
   try {
    if (session != null) SessionFactory.closeSession(); 
   } catch (HibernateException e) {
    throw new RuntimeException("SessionFactory.closeSession() throw exception = " + e.toString());
   }
  }
 }
 
 /**
  * 命名参数查询
  * @param sql
  * @param name
  * @param parameter
  * @return
  */
 public List find(String sql, String[] name, Object[] parameter) {
  Session session = null;
  Transaction tx = null;
  logger.info("find(String sql, String[] name, Object[] object)  - start");
  try {
   session = SessionFactory.currentSession();
   tx = session.beginTransaction();
   Query query = session.createQuery(sql);
   setQueryParameterValues(query, name, parameter);
   list = query.list();
   tx.commit();
   SessionFactory.closeSession();
   logger.info("find(String sql, String[] name, Object[] object)  - end");
   return list;
  } catch (HibernateException e) {
   logger.error("find(String sql, String[] name, Object[] object)  throw exception = ", e);
   try {
    if (tx != null) tx.rollback();
   } catch (HibernateException ex) {
    throw new RuntimeException("tx.rollbacd() throw exception = " + ex.toString());
   }
   throw new RuntimeException("find(String sql, String[] name, Object[] object)  object) throw exception = " + e.toString());
  } finally {
   try {
    if (session != null) SessionFactory.closeSession(); 
   } catch (HibernateException e) {
    throw new RuntimeException("SessionFactory.closeSession() throw exception = " + e.toString());
   }
  }
 } 
 
 /**
  * @param sql
  * @param firstSize
  * @param pageSize
  * @return
  */
 public List findPage(String sql, int firstSize, int pageSize) {
  Session session = null;
  Transaction tx = null;
  try {
   logger.info("findPage(String sql, int firstSize, int pageSize) - start");
   session = SessionFactory.currentSession();
   tx = session.beginTransaction();
   Query query = session.createQuery(sql);
   query.setFirstResult(firstSize);
   query.setMaxResults(pageSize);
   list = query.list();
   tx.commit();
   SessionFactory.closeSession();
   logger.info("findPage(String sql, int firstSize, int pageSize)) - end");
   return list;
  } catch (HibernateException e) {
   logger.error("findPage(String sql, int firstSize, int pageSize) throw exception = ", e);
   try {
    if (tx != null) tx.rollback();
   } catch (HibernateException ex) {
    throw new RuntimeException("tx.rollbacd() throw exception = " + ex.toString());
   }
   throw new RuntimeException("findPage(String sql, int firstSize, int pageSize) throw exception = " + e.toString());
  } finally {
   try {
    if (session != null) SessionFactory.closeSession(); 
   } catch (HibernateException e) {
    throw new RuntimeException("SessionFactory.closeSession() throw exception = " + e.toString());
   }
  }
 }

 /**
  * 位置参数 分页查询
  * @param sql
  * @param parameter
  * @param firstSize
  * @param pageSize
  * @return
  */
 public List findPage(String sql, Object[] parameter, int firstSize, int pageSize) {
  Session session = null;
  Transaction tx = null;
  logger.info("findPage(String sql, Object[] object, int firstSize, int maxSize) - start");
  try {
   session = SessionFactory.currentSession();
   tx = session.beginTransaction();
   Query query = session.createQuery(sql);
   setQueryParameterValues(query, parameter);
   query.setFirstResult(firstSize);
   query.setMaxResults(pageSize);
   list = query.list();
   tx.commit();
   SessionFactory.closeSession();
   logger.info("findPage(String sql, Object[] object, int firstSize, int maxSize) - end");
   return list;
  } catch (HibernateException e) {
   logger.error("findPage(String sql, Object[] object, int firstSize, int maxSize) throw exception = ", e);
   try {
    if (tx != null) tx.rollback();
   } catch (HibernateException ex) {
    throw new RuntimeException("tx.rollbacd() throw exception = " + ex.toString());
   }
   throw new RuntimeException("findPage(String sql, Object[] object, int firstSize, int maxSize) throw exception = " + e.toString());
  } finally {
   try {
    if (session != null) SessionFactory.closeSession(); 
   } catch (HibernateException e) {
    throw new RuntimeException("SessionFactory.closeSession() throw exception = " + e.toString());
   }
  }
 }
 
 /**
  * 命名参数 分页查询
  * @param sql
  * @param name
  * @param parameter
  * @param firstSize
  * @param pageSize
  * @return
  */
 public List findPage(String sql, String[] name , Object[] parameter, int firstSize, int pageSize) {
  Session session = null;
  Transaction tx = null;
  logger.info("findPage(String sql, String[] name , Object[] object, int firstSize, int maxSize) - start");
  try {
   session = SessionFactory.currentSession();
   tx = session.beginTransaction();
   Query query = session.createQuery(sql);
   setQueryParameterValues(query, name ,parameter);
   query.setFirstResult(firstSize);
   query.setMaxResults(pageSize);
   list = query.list();
   tx.commit();
   SessionFactory.closeSession();
   logger.info("findPage(String sql, String[] name , Object[] object, int firstSize, int maxSize) - end");
   return list;
  } catch (HibernateException e) {
   logger.error("findPage(String sql, String[] name , Object[] object, int firstSize, int maxSize) throw exception = ", e);
   try {
    if (tx != null) tx.rollback();
   } catch (HibernateException ex) {
    throw new RuntimeException("tx.rollbacd() throw exception = " + ex.toString());
   }
   throw new RuntimeException("findPage(String sql, String[] name , Object[] object, int firstSize, int maxSize) throw exception = " + e.toString());
  } finally {
   try {
    if (session != null) SessionFactory.closeSession(); 
   } catch (HibernateException e) {
    throw new RuntimeException("SessionFactory.closeSession() throw exception = " + e.toString());
   }
  }
 }

 /**
  * 滚动查询
  * @param sql
  * @param parameter
  * @return
  */
 public List findScrollable(String sql, Object[] parameter) {
  Session session = null;
  Transaction tx = null;
  logger.info("findScrollable(String sql, Object[] object) - start");
  ScrollableResults srs = null;
  List list = new ArrayList();
  int j;
  try {
   session = SessionFactory.currentSession();
   tx = session.beginTransaction();
   Query query = session.createQuery(sql);
   System.out.println("query before");
   setQueryParameterValues(query, parameter);
   srs = query.scroll();// ===有滚动；
   while (srs.next()) {
    Vector vec = new Vector();
    j = 0;
    // ===将查询的字段值循环放入到集合中；
    while (true) {
     try {
      vec.add(srs.get(j)); // ===当没有字段值时，此处自动会抛出一个异常终止；
      j++;
     } catch (Exception e) {
      logger.error("findScrollable(String sql, Object[] object)", e);
      break;
     }
    }
    list.add(vec);
   }
   tx.commit();
   SessionFactory.closeSession();
   logger.info("findScrollable(String sql, Object[] object) - end");
   return list;
  } catch (HibernateException e) {
   logger.error("findScrollable(String sql, Object[] object) throw exception = ", e);
   try {
    if (tx != null) tx.rollback();
   } catch (HibernateException ex) {
    throw new RuntimeException("tx.rollbacd() throw exception = " + ex.toString());
   }
   throw new RuntimeException("findScrollable(String sql, Object[] object) throw exception = " + e.toString());
  } finally {
   try {
    if (session != null) SessionFactory.closeSession(); 
   } catch (HibernateException e) {
    throw new RuntimeException("SessionFactory.closeSession() throw exception = " + e.toString());
   }
  }
 }
 
 /**
  * 位置参数设置
  * @param query
  * @param parameter
  */
 public void setQueryParameterValues(Query query, Object[] parameter){
  logger.info("setQueryParameterValues(Query query, Object[] object) - start");
  try {
   if(parameter!=null){
    for(int i=0;i<parameter.length;i++)  query.setParameter(i,parameter[i]); 
   } 
   logger.info("setQueryParameterValues(Query query, Object[] object) - end");
  } catch (HibernateException e) {
   logger.error("setQueryParameterValues(Query query, Object[] object) throw exception = ", e);   
   throw new RuntimeException("setQueryParameterValues(Query query, Object[] object) throw exception = " + e.toString());
  }    
 }
 
 /**
  * 命名参数设置
  * @param query
  * @param name
  * @param parameter
  */
 public void setQueryParameterValues(Query query, String[] name , Object[] parameter){  
  logger.info("setQueryParameterValues(Query query, String[] str , Object[] object) - start");
  try {
   if (name.length != parameter.length) {
    throw new IllegalArgumentException("setQueryParameterValues(Query query, String[] name , Object[] parameter) = Length of paramNames array must match length of values array");
   }
   if(name!=null && parameter!=null){
    for(int i=0;i<name.length;i++) query.setParameter(name[i],parameter[i]);
   }
   logger.info("setQueryParameterValues(Query query, String[] str , Object[] object) - end");
  } catch (HibernateException e) {
   logger.error("setQueryParameterValues(Query query, String[] str , Object[] object) throw exception = ", e);   
   throw new RuntimeException("setQueryParameterValues(Query query, String[] str , Object[] object) throw exception = " + e.toString());
  } 
 }

 /**
  * @param parameter
  * @param query
  * @throws HibernateException
  */
 public void setQueryParameter(Query query, Object[] parameter){
  logger.info("setQueryParameter(Query query, Object[] object) - start");
  Object pValue = null;
  try {
   if (parameter != null) {
    for (int i = 0; i < parameter.length; i++) {
     pValue = parameter[i];
     if (pValue instanceof String) {
      query.setString(i, (String) pValue);
     } else if (pValue instanceof Integer) {
      query.setInteger(i, ((Integer) pValue).intValue());
     } else if (pValue instanceof Boolean) {
      query.setBoolean(i, ((Boolean) pValue).booleanValue());
     } else if (pValue instanceof Short) {
      query.setShort(i, ((Short) pValue).shortValue());
     } else if (pValue instanceof Long) {
      query.setLong(i, ((Long) pValue).longValue());
     } else if (pValue instanceof Float) {
      query.setFloat(i, ((Float) pValue).floatValue());
     } else if (pValue instanceof Double) {
      query.setDouble(i, ((Double) pValue).doubleValue());
     } else if (pValue instanceof BigDecimal) {
      query.setBigDecimal(i, (BigDecimal) pValue);
     } else if (pValue instanceof Byte) {
      query.setByte(i, ((Byte) pValue).byteValue());
     } else if (pValue instanceof java.sql.Date) {
      query.setDate(i, java.sql.Date.valueOf(pValue.toString()));
     } else if (pValue instanceof java.sql.Time) {
      query.setTime(i, java.sql.Time.valueOf(pValue.toString()));
     } else if (pValue instanceof java.sql.Timestamp) {
      query.setTimestamp(i, java.sql.Timestamp.valueOf(pValue.toString()));
     } else if (pValue instanceof java.util.Date) {
      query.setDate(i, java.sql.Date.valueOf(pValue.toString()));
     } else {
      // query.setObject(i, pValue);
     }
    }
   }
   logger.info("setQueryParameter(Query query, Object[] object) - end");
  } catch (HibernateException e) {
   logger.error("setQueryParameter(Query query, Object[] object)", e);  
   throw new RuntimeException("setQueryParameter(Query query, Object[] object) throw exception = " + e.toString());
  }
 }
}

转自我的校内：

http://blog.renren.com/blog/223579197/336228947?frommyblog

版权声明：本文为博主原创文章，未经博主允许不得转载。

转载于:https://my.oschina.net/u/2484672/blog/523689

chitangya6507
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HBM显存技术与市场前景
吴建明wujianming_110117
01-14 6964
HBM显存技术与市场前景 HBM(High Bandwidth Memory)作为一种GPU显存存在时，现在似乎已经不算罕见了。很多人可能都知道HBM成本高昂，所以即便不罕见，也只能在高端产品上见到。部分游戏玩家应该知道，HBM是一种带宽远超DDR/GDDR的高速内存，而且内部结构还用上了3D堆叠的SRAM，听起来就十分高级，虽然成本高，但这行业有钱的主也不少，况且GPU不是就在用HBM。未来HBM会替代DDR，成为计算机内存吗？ 本文围绕HBM内存和CPU搭配会发生什么、HBM的三个缺点以及HBM是否适用
Hibernate 框架（五）（hibernate的封装工具）
qq_42421212的博客
04-17 258
package dc.com; import java.io.Serializable; import java.util.List; import java.util.Map; import org.hibernate.Hibernate; import org.hibernate.Session; import org.hibernate.SessionFactory; import ...
Hibernate（对JDBC的轻量级封装）
weixin_44030848的博客
02-13 1271
目录认识Hibernatehibernate部署测试步骤程序文件0.导入hibernate所依赖的的包1.product.java2.类和表的配置文件3.数据库连接配置文件4.TestHibernate.java 认识Hibernate 使用JDBC做数据库相关功能开发会做很多重复性的工作，比如创建连接，关闭连接，把字段逐一映射到属性中。 Hibernate把这一切都封装起来了，使得数据库访问变得...
Hibernate 自动进行数据封装
最新发布
很酷的站长的博客
01-31 249
Hibernate 可以构建各种复杂的 SQL 语句，但其本质都是反射机制结合映射关系完成的。框架也仅是一款程序产品，人为编写的产物。要相信，只要你愿意，你完全可以实现自己的 JDBC 框架。本节课和大家继续聊聊 Hibernate 是如何自动封装数据的。
HBM学习总结
热门推荐
weixin_51613968的博客
09-05 1万+
简介 HBM ：High Bandwidth Memory 高带宽存储器 主要作为GPU显存芯片（一般在高端产品中，比如nv面向数据中心的GPU，A100），也作为部分CPU的内存芯片（目前HPC芯片中有应用到，富岳中的A64FX） HBM将多个DDR芯片堆叠在一起，所以也是个3D结构；每个die之间通过TVS和microbump方式连接；除了堆叠的DRAM die以外，下层会有个HBM控制器逻辑die。然后最下层通过base die(比如说硅中介silicon interposer)，来与CPU/GPU等
hibernate dao 封装
cq1995的博客
04-03 245
整体结构：com.it.beanStudent.java中字段     private String stu_id;     private String stu_pwd;     private String stu_name;     private String stu_sex;     private String stu_age;     private String stu_addr;...
使用hibernate封装方法
12-02
标题“使用Hibernate封装方法”暗示我们将讨论如何在项目中通过封装Hibernate操作，以提高代码的复用性和可读性。通常，我们会在DAO（数据访问对象）层进行这些封装，将数据库的CRUD（创建、读取、更新、删除）操作...
hibernate封装.pdf
09-27
在提供的代码片段中，我们可以看到一个`HibernateDao`类，它是对Hibernate的一些基本操作进行了封装，包括获取、删除等方法。下面将详细解释这些知识点。 1. **SessionFactory**: `SessionFactory`是Hibernate的...
小码哥Hibernate封装的查询方法的皮毛介绍共4页.p
10-29
【标题】：“小码哥Hibernate封装的查询方法的皮毛介绍共4页.p” 【描述】：“小码哥Hibernate封装的查询方法的皮毛介绍共4页.pdf.zip”这个压缩包文件内包含了一份关于Hibernate封装查询方法的初步介绍，由知名...
SpringSide的Hibernate封装
03-20
SpringSide的Hibernate封装是针对Spring和Hibernate整合时的一种优化实践，旨在提高开发效率和代码的可维护性。它通过三层封装来实现对Hibernate操作的便捷和类型安全。 第一层是HibernateGenericDao，它是基于...
hibernate环境搭建基本操作封装
10-25
hibernate环境搭建基本操作封装，使用mysql开源数据库
封装了一个Hibernate增删改查的工具类
01-07
一个工具类实现了增删改查 util comm.util beanutils 方便了获取session和sessionFactory
基于hibernate封装的BaseDao
01-02
基于hibernate封装的BaseDao，有完整的增删改查，分页，执行hql sql 方法 约 20个方法，详情地址 https://blog.csdn.net/qq_41861261/article/details/85595872
对hibernate的封装 HibernateTemplate
03-21
NULL 博文链接：https://vincent1003.iteye.com/blog/945052
hibernate入门实例封装了HibernateUtil
07-06
hibernate入门实例封装了HibernateUtil,完成数据库的添加操作，和查询操作。 Session的save方法和get方法。
hibernate 简单封装
weixin_30578677的博客
11-12 101
package com.wode.util; import org.hibernate.HibernateException;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.cfg.Configuration; public class HibernateUtil { p...
hibernate工具类的封装
Java修炼者的博客
02-17 250
hibernate封装工具类 封装HibernateUtils.java package utils; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.boot.registry.StandardServiceRegist...
类似hibernate的jdbc封装
05-24
类似hibernate的jdbc简单封装，说不定大家用的上。。
hibernate的封装
悲欢离合
03-25 349
创建Configuration对象 获取sessionfactory对象 获取session 开启事务transaction public class HibernateUtil { private static final SessionFactory FACTORY=buildSessionFactory(); //建一个session工厂 p...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值