下载文档原格式
Hibernate4.1实现单表CRUD 学习JavaWeb的人，我想对Hibernate都不陌生，是一个比较流行的ORM框架，ORM 简称对象关系映射，那你用此框架实现过单表的CRUD吗；我们来试试利用hibernate实现单表的CRUD，也就是我们所说的增删改查；·打开我们熟悉常用的开发工具myeclipse；·新建项目Hibernate4Project·添加Hibernate开发支持，很多人使用的手动配置，其实也是可以自动配置的，右键项目Myeclipse→Project Facets→Install Hibernate Facet 表示添加Hibernate开发支持，不用你在很多JAR包中寻找了；·然后选择4.1版本，下面默认然后下一步Next；·下面按照如图配置即可，在java package那一个文本框之中，如果你没有建立包的话，就点击后面的New，然后继续NEXT;·下面我们要选择我们要操作的数据源，前提你一定要配置好数据源，如果选择，如果你没配置DB Driver的话，是没有其他选项的，点击Next·下面就是选择插件的了，如果你不需要什么插件，就选择核心包即可，core包；·点击finish即可，现在hibernate的开发支持就OK了；·如果你没有配置数据源可以看下此项选择Window→Other·下面选择要打开的视图DB Browser·你会看到下面的一个视图被打开了，应该在右下角显示的；·新建一个你要连接的数据库，空白出点击右键→new·在下面这个界面中配置就OK了；Driver template 选择你要连接的数据库类型；Driver name 自定义一个名称即可；Connection URL 数据库连接地址；User name 数据库用户名；Password 密码Drive JAR 数据库驱动包；Driver classname 选择一个常用的驱动Save password 勾选此项，然后点击Test Driver最后保存即可；·然后我们继续我们的单表CRUD实现；当我们添加好hibernate支持的时候，myeclipse会自动生成一个HibernateSessionFactory.java的类，这个类就是我们在用的数据库连接类，在hibernate之中，一个数据库连接叫做一个session，可以看下下面的这个类，我添加了一些注释；package cn.oracle.dbc;import org.hibernate.HibernateException;import org.hibernate.Session;import org.hibernate.cfg.Configuration;import org.hibernate.service.ServiceRegistry;import org.hibernate.service.ServiceRegistryBuilder;/*** 数据库连接类* @author congz_000**/public class HibernateSessionFactory {/*** ThreadLocal 保存数据库连接；*/private static final ThreadLocal<Session> threadLocal = newThreadLocal<Session>();/*** 连接工厂*/private static org.hibernate.SessionFactory sessionFactory;private static Configuration configuration = new Configuration();private static ServiceRegistry serviceRegistry;static {try {configuration.configure();serviceRegistry = newServiceRegistryBuilder().applySettings(configuration.getProperties()).buildS erviceRegistry();sessionFactory =configuration.buildSessionFactory(serviceRegistry);} catch (Exception e) {System.err.println("%%%% Error Creating SessionFactory %%%%");e.printStackTrace();}}/*** 无参构造方法*/private HibernateSessionFactory() {}/*** 静态方法，我们用来得到数据库的连接；* @return返回一个数据库连接；* @throws HibernateException*/public static Session getSession() throws HibernateException {Session session = (Session) threadLocal.get();if (session == null || !session.isOpen()) {if (sessionFactory == null) {rebuildSessionFactory();}session = (sessionFactory != null) ? sessionFactory.openSession(): null;threadLocal.set(session);}return session;}/*** 从名称可以看到重建连接工厂；*/public static void rebuildSessionFactory() {try {configuration.configure();serviceRegistry = newServiceRegistryBuilder().applySettings(configuration.getProperties()).buildS erviceRegistry();sessionFactory =configuration.buildSessionFactory(serviceRegistry);} catch (Exception e) {System.err.println("%%%% Error Creating SessionFactory %%%%");e.printStackTrace();}}/*** 关闭数据库连接，静态方法，可以类名称直接调用；* @throws HibernateException*/public static void closeSession() throws HibernateException {Session session = (Session) threadLocal.get();threadLocal.set(null);if (session != null) {session.close();}}/*** 建立数据库连接工厂；* @return*/public static org.hibernate.SessionFactory getSessionFactory() { return sessionFactory;}public static Configuration getConfiguration() {return configuration;}}·我们还需要映射表，我们拿emp表来做，打开你创建的数据源，然后我们找到要操作的表，右键Hibernate Reverse Engineering·选择创建的pojo的位置，和一些自动生成配置，选择NEXT；·下面选择主键的生成类型ID Generator，选择assigned 表示指派，也就是自定义；·下一步同样，选择assigned ，其他不做修改，点击Finish;·等一会就会生成一个简单java 类和一个Emp.hbm.xml文件,如果此表中有关系字段的话，删除即可；Emp.javapackage cn.oracle.pojo;import java.util.Date;@SuppressWarnings("serial")public class Emp implements java.io.Serializable {private Short empno;private String ename;private String job;private Short mgr;private Date hiredate;private Double sal;private Double comm;}Emp.hbm.xml<?xml version="1.0"encoding="utf-8"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN" "/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping><class name="cn.oracle.pojo.Emp"table="EMP"schema="SCOTT">→对应的数据表和用户<id name="empno"type="ng.Short">→字段empno的数据类型及对应的列名称和允许的大小，及主键的指派类型；<column name="EMPNO"precision="4"scale="0"/><generator class="assigned"></generator></id><property name="ename"type="ng.String">→对应的列名称和精度<column name="ENAME"length="10"/></property><property name="job"type="ng.String">→job字段对象的列和精度<column name="JOB"length="9"/></property><property name="mgr"type="ng.Short"><column name="MGR"precision="4"scale="0"/></property><property name="hiredate"type="java.util.Date"><column name="HIREDATE"length="7"/></property><property name="sal"type="ng.Double"><column name="SAL"precision="7"/></property><property name="comm"type="ng.Double"><column name="COMM"precision="7"/></property></class></hibernate-mapping>·以上就是自动生成，需要简单修改的一部分，下面的就需要自己编写了，不过和从头到尾不用工具实现的CRUD相对简单多了；·编写DAO接口，首先我们可以编写一个公共的接口IDAO.javaIDAO.javapackage cn.oracle.dao;import java.util.List;/*** 一个公共接口，实现单表的CRUD加分页的操作；* @author congz_000** @param<K>主键类型* @param<V>简单java类*/public interface IDAO<K,V> {/*** 实现数据的增加* @param vo 简单java类对象；* @return返回boolean值，返回true表示增加成功，false表示添加失败！* @throws Exception*/public boolean doCreat(V vo)throws Exception;/*** 删除一条数据；* @param id 参数是删除数据的主键类型；* @return返回boolean数据类型,true表示删除成功，false表示删除失败；* @throws Exception*/public boolean doRemove(K id)throws Exception;/*** 修改一条数据；* @param vo 参数为简单java类对象；* @return返回boolean 类型，true表示修改成功，false表示修改失败；* @throws Exception*/public boolean doUpdate(V vo)throws Exception;/*** 查询一条数据* @param id 根据参数id查询数据；* @return返回一个简单java类对象；* @throws Exception*/public V findById(K id)throws Exception;/*** 查询表中所有数据；* @return返回一个List集合，里面是每条数据对应的简单java类对象；* @throws Exception*/public List<V> list()throws Exception;/*** 模糊查询* @param column 要模糊查询的列；* @param keyWord 模糊查询的关键字；* @param currentPage 当前页数；* @param lineSize 每页显示数据条目数；* @return返回一个list集合；* @throws Exception*/public List<V> list(String column,String keyWord,IntegercurrentPage,Integer lineSize)throws Exception;/*** 统计模糊查询的条目数；* @param column 要模糊查询的列；* @param keyWord 要模糊查询的关键字；* @return* @throws Exception*/public Integer getAllCount(String column,String keyWord)throws Exception; }IEmpDAO.java 直接继承IDAO即可；package cn.oracle.dao;import cn.oracle.pojo.Emp;public interface IEmpDAO extends IDAO<Short, Emp> {}·IEmpDAO接口的实现类，EmpDAOImpl.javapackage cn.oracle.dao.impl;import java.util.List;import org.hibernate.Query;import cn.oracle.dao.IEmpDAO;import cn.oracle.dbc.HibernateSessionFactory;import cn.oracle.pojo.Emp;public class EmpDAOImpl implements IEmpDAO {@Overridepublic boolean doCreat(Emp vo) throws Exception {String hql="INSERT INTOemp(empno,ename,job,hiredate,sal,comm)VALUES(?,?,?,?,?,?)";Query query=HibernateSessionFactory.getSession().createQuery(hql);query.setShort(0, vo.getEmpno());query.setString(1,vo.getEname());query.setString(2, vo.getJob());query.setDate(3, vo.getHiredate());query.setDouble(4,vo.getSal());query.setDouble(5, vo.getComm());return query.executeUpdate()==1;}@Overridepublic boolean doRemove(Short id) throws Exception {String hql="DELETE FROM emp AS n WHERE n.empno=?";Query query=HibernateSessionFactory.getSession().createQuery(hql);query.setShort(0, id);return query.executeUpdate()>0;}@Overridepublic boolean doUpdate(Emp vo) throws Exception {String hql="UPDATE emp AS n SETn.ename=?,n.job=?,n.hiredate=?,n.sal=?,m=? WHERE n.empno=?";Query query=HibernateSessionFactory.getSession().createQuery(hql);query.setShort(1, vo.getEmpno());query.setString(2,vo.getEname());query.setString(3, vo.getJob());query.setDate(4, vo.getHiredate());query.setDouble(5,vo.getSal());query.setDouble(0, vo.getComm());return query.executeUpdate()>0;}@Overridepublic Emp findById(Short id) throws Exception {return (Emp) HibernateSessionFactory.getSession().get(Emp.class,id);}@SuppressWarnings("unchecked")@Overridepublic List<Emp> list() throws Exception {String hql="FROM emp AS n";Query query=HibernateSessionFactory.getSession().createQuery(hql);List<Emp> all=query.list();return all;}@Overridepublic List<Emp> list(String column, String keyWord, Integer currentPage, Integer lineSize) throws Exception {String hql=" SELECT empno,ename,job,hiredate,sal,comm "+ " FROM "+ " (SELECT empno,ename,job,hiredate,sal,comm,ROWNUM rn WHERE "+column+" LIKE ? ROWNUM<?)temp "+ " WHERE temp.rn>? ";Query query=HibernateSessionFactory.getSession().createQuery(hql);query.setString(0, "%"+keyWord+"%");query.setInteger(1, currentPage*lineSize);query.setInteger(2,(currentPage-1)*lineSize);@SuppressWarnings("unchecked")List<Emp> all=query.list();return all;}@Overridepublic Integer getAllCount(String column, String keyWord) throws Exception {String hql="SELCT COUNT(empno) FROM emp WHERE "+column+" LIKE ?";Query query=HibernateSessionFactory.getSession().createQuery(hql);query.setString(0, "%"+keyWord+"%");return query.executeUpdate();}}·建立工厂类DAOFactory.javapackage cn.oracle.factory;import cn.oracle.dao.IEmpDAO;import cn.oracle.dao.impl.EmpDAOImpl;public class DAOFactory {public static IEmpDAO getIEmpDAOInstance(){return new EmpDAOImpl();}}建立IEmpService.java接口；package cn.oracle.service;import java.util.List;import java.util.Map;import cn.oracle.pojo.Emp;public interface IEmpService {public boolean insert(Emp vo)throws Exception;public boolean update(Emp vo)throws Exception;public boolean delete(int id)throws Exception;public Emp get(int id)throws Exception;public List<Emp> list()throws Exception;public Map<String,Object> list(String column,String keyWord,Integer currentPage,Integer lineSize)throws Exception;}·建立接口IEmpService.java的实现类，EmpServiceImpl.javapackage cn.oracle.service.impl;import java.util.HashMap;import java.util.List;import java.util.Map;import cn.oracle.dbc.HibernateSessionFactory;import cn.oracle.factory.DAOFactory;import cn.oracle.pojo.Emp;import cn.oracle.service.IEmpService;public class EmpServiceImpl implements IEmpService {@Overridepublic boolean insert(Emp vo) throws Exception {try{return DAOFactory.getIEmpDAOInstance().doCreat(vo);}catch(Exception e){throw e;}finally{HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();}}@Overridepublic boolean update(Emp vo) throws Exception {try{return DAOFactory.getIEmpDAOInstance().doUpdate(vo);}catch(Exception e){throw e;}finally{HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();}}@Overridepublic boolean delete(Short id) throws Exception {try{return DAOFactory.getIEmpDAOInstance().doRemove(id);}catch(Exception e){throw e;}finally{HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();}}@Overridepublic Emp get(Short id) throws Exception {try{return DAOFactory.getIEmpDAOInstance().findById(id);}catch(Exception e){throw e;}finally{HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();}}@Overridepublic List<Emp> list() throws Exception {try{return DAOFactory.getIEmpDAOInstance().list();}catch(Exception e){throw e;}finally{HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();}}@Overridepublic Map<String, Object> list(String column, String keyWord,Integer currentPage, Integer lineSize) throws Exception { Map<String,Object> map=new HashMap<String,Object>();try{map.put("allEmps", DAOFactory.getIEmpDAOInstance().list(column, keyWord, currentPage, lineSize));map.put("allCount",DAOFactory.getIEmpDAOInstance().getAllCount(column, keyWord));return map;}catch(Exception e){throw e;}finally{HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();}}}·最后的工厂类，ServiceFactory.javapackage cn.oracle.factory;import cn.oracle.service.IEmpService;import cn.oracle.service.impl.EmpServiceImpl;public class ServiceFactory {public static IEmpService getIEmpServiceInstance(){ return new EmpServiceImpl();}}OK 到此完成；。
Hibernate 中的HQL查询的总结一．Spring+Hibernate 中1.保存一个实体getHibernateTemplate().save(user);2.根据id号从数据库中查询到一个实体Useruser=(User)getHibernateTemplate().load(User.class,fromUse rId));3.删除一个实体方法一：直接删除getHibernateTemplate().delete((Message)；方法二：嵌套一个根据id号查询到一个实体，再删除getHibernateTemplate().delete((Message)getHibernateTempla te().load(Message.class, msgId));4.查询符合添加的记录的个数，函数count(*)Object obj = getSession().createQuery("select count(*)from Message where recepUser.id="+recepUserId+" and msgType=1").uniqueResult();//表示只返回一个结果5.修改一个实体getHibernateTemplate().update(message);6.设定查询记录的起始位置和得到的记录数List<Message> list = getSession().createQuery("from Message where (fromUser.id="+userId+" or recepUser.id="+userId+") and msgType=2 order by id desc").setMaxResults(想要得到的记录数).setFirstResult(取得记录的起点).list();7. intValue()返回的结果是整数int msgCount=((Long)getSession().createQuery("select count(*) from Message where from User.id="+userId+" or recepUser.id="+userId).uniqueResult()).intValue();二．只有Hibernate 中1.保存数据/*** 保存数据** @param t传入的泛型* @return*/public boolean save(T t) {session = HibernateUtil.getSession();try {session.beginTransaction();session.save(t);session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();return false;} finally {HibernateUtil.closeSession(session);}return true;}2.删除数据/*** 删除数据** @param t传入的泛型* @return*/public boolean delete(T t) {session = HibernateUtil.getSession();try {session.beginTransaction();session.delete(t);session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();return false;} finally {HibernateUtil.closeSession(session);}return true;}3.修改数据/*** 修改数据** @param t传入的泛型* @return*/public boolean update(T t) {session = HibernateUtil.getSession();try {session.beginTransaction();session.update(t);session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();return false;} finally {HibernateUtil.closeSession(session);}return true;}4.查询单条数据，返回查询得到的唯一的结果实体对象/*** 查询单条数据** @param hql* @return返回查询得到的唯一的结果实体对象*/public T queryFrom(String hql) {// T表示泛型对象,T泛型定义T t = null;// 引用实体对象session = HibernateUtil.getSession();try {session.beginTransaction();Query query = session.createQuery(hql);// 执行传递来的hql查询語句t = (T) query.uniqueResult();// 将查询结果转换为实体对象session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();} finally {HibernateUtil.closeSession(session);}return t;// 返回查询得到的实体对象}5.通过泛型定义的查询多条语句方法/*** 通过泛型定义的查询多条语句方法** @param hql** @return 查询得到的结果集List*/public List<T> queryList(String hql) {session = HibernateUtil.getSession();List<T> list = null;try {session.beginTransaction();Query query = session.createQuery(hql);// 执行传递来的hql查询语句list = query.list();// 将查询返回的结果集转换成List集合session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();} finally {HibernateUtil.closeSession(session);}return list;// 返回查询得到的集合对象}6. 返回指定条数的查询结果的方法/*** 返回指定条数的查询结果的方法** @param hql* @param showNumber所要查询的数据的结果的条数* @return返回查询得到的集合对象*/public List<T> queryTypeListNumber(String hql, int showNumber,Type type) {session = HibernateUtil.getSession();List<T> list = null;try {session.beginTransaction();Query query = session.createQuery(hql);// 执行传递来的hql查询语句// for(int i=0;i<params.length;i++){//把传递过来的参数数组遍历出来，遍历赋值给hql语句中的未知待定数据// query=query.setParameter(i, params[i]);// }query=query.setParameter(0, type);query.setMaxResults(showNumber);// 设这所要查询的数据的结果的条数list = query.list();// 将查询返回的结果集转换成List集合session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();} finally {HibernateUtil.closeSession(session);}return list;// 返回查询得到的集合集合对象}7.查询所有用户信息String hql = "from User";list = session.createQuery(hql) //创建Query对象 .list();8.保存用户session.save(user);9.通过用户名和密码查询用户（参数不一定，用动态赋值）//HQL查询语句String hql = "from User u where ername=? and u.password=?";Query query = session.createQuery(hql) //创建Query对象.setParameter(0, username)//动态赋值.setParameter(1, password);//动态赋值10.判断指定用户名的用户是否存在//HQL查询语句String hql = "from User u where ername=?";Query query = session.createQuery(hql) //创建Query对象.setParameter(0, username);//动态赋值Object user = query.uniqueResult();//返回User对象//如果用户存在exist为trueif(user != null){exist = true;}11.根据id删除一条留言信息//加载指定id的留言信息Message message = (Message)session.get(Message.class, id);session.delete(message); //删除留言12.查询所有文章中都有哪些作者（Group By）hql = "select author from ArticleInfo group by author";//查询文章详细信息的hql语句List authorList = objectDao.queryListObject(hql);//执行查询request.setAttribute("authorList", authorList);13.分组查询，各部门名称和各部门的人数（Group By）hql="select u.dept,count(*) from User u group by u.dept";Query query=session.creatQuery(hql);List<Object[]> list=query.list();//object[]是数组，可以同时多个属性查询obj[o],obj[1],obj[2],,,,//for循环输出信息For(object[] obj;list){Sysout.("部门"+obj[0]);Sysout.("人数"+obj[1])}14.查询文章的回复// 文章回复内容的详细查询hql = "from ReArticleInfo where re_id=" + id + " order by id desc";//查询文章详细内容的hql语句ObjectDao<ReArticleInfo> re_objectDao = new ObjectDao<ReArticleInfo>();//实例化持久化类List<ReArticleInfo> list = null;//定义List集合15.In的条件嵌套查询（双重条件，条件在其他表中）跨表hql_article_commend = "from ArticleInfo where commend='是' and author in (select account from UserInfo where freeze='解冻')";hql_article_vistor = "from ArticleInfo where author in (select account from UserInfo where freeze='解冻') order by visit desc";16.多对一映射在user表中，通过Author对象查询userString hql="from Category c wherec.typeName='"+category.getTypeName()+"'andc.author='"+category.getAuthor().getId()+"'";。
hibernate executeupdate的返回值在Hibernate 中，executeUpdate 方法用于执行更新操作（如插入、修改和删除），并返回受影响的行数。
返回值类型为int，表示更新操作执行后受影响的行数。
具体的返回值含义如下：-如果返回值大于0，则表示更新操作成功，并返回受影响的行数；-如果返回值等于0，则表示更新操作执行但没有影响任何行；-如果返回值小于0，则表示更新操作执行失败。
示例代码如下：```javaString hql = "UPDATE User SET name = :newName WHERE id = :userId"; Query query = session.createQuery(hql);query.setParameter("newName", "John");query.setParameter("userId", 123);Transaction transaction = session.beginTransaction();int rowsAffected = query.executeUpdate();mit();System.out.println("受影响的行数：" + rowsAffected);```在上面的示例中，首先构造一个HQL（Hibernate Query Language）更新语句，然后创建Query 对象，并设置参数。
接着开启事务，执行更新操作，并通过executeUpdate 方法获取受影响的行数。
最后提交事务并输出受影响的行数。
需要注意的是，executeUpdate 方法返回的是受影响的行数，而不是实际更新的对象。
如果需要获取更新后的对象，可以在执行更新操作后，再通过查询获取更新后的数据。
hibernate框架用法
Hibernate框架是一个开源的对象关系映射（ORM）框架，它可以
将Java对象映射到关系数据库中的表中，从而使得开发人员可以使用Java编程语言来访问和操作数据库。
Hibernate的使用流程如下：
1. 在Java类中定义实体对象及其属性和关系；
2. 在Hibernate中配置映射文件，将实体类映射为数据库表；
3. 通过Session API实现数据的增删改查操作。
Hibernate框架的优点有：
1. 开发效率高：Hibernate自动处理对象与数据库表之间的映射，使得开发人员可以将精力集中在业务逻辑上。
2. 数据库平台无关性好：Hibernate提供了一套底层数据库操作
接口，在数据操作层面上实现了面向对象与关系数据库的交互。
3. 透明性强：Hibernate框架屏蔽了大部分JDBC的细节，对于开发人员而言可以专注于业务需求的实现。
4. 高性能：Hibernate框架缓存机制、懒加载等一些优化措施，
可以改善数据库访问的性能。
同时，Hibernate还提供了一些高级特性，如事务管理、二级缓存、查询缓存、延迟加载等，可以更好地满足复杂应用的需要。
一、实验目的1. 理解数据访问的基本概念和原理。
2. 掌握常见的数据访问技术及其应用场景。
3. 通过实验加深对数据访问方法的理解和实际操作能力。
二、实验原理数据访问是指从数据库或其他数据源中获取、检索、更新和删除数据的过程。
在数据访问过程中，需要了解数据的存储结构、查询语言、连接技术等。
本实验主要涉及以下内容：1. 数据库访问技术：JDBC、、ORM等。
2. 数据查询语言：SQL、NoSQL等。
3. 数据连接技术：TCP/IP、HTTP等。
三、实验内容1. 数据库访问技术（1）JDBCJDBC（Java Database Connectivity）是Java语言中用于访问关系型数据库的API。
本实验使用JDBC连接MySQL数据库，实现数据的增删改查操作。
（2）是.NET框架中用于访问数据库的组件。
本实验使用C#语言通过连接SQL Server数据库，实现数据的增删改查操作。
（3）ORMORM（Object-Relational Mapping）是一种将对象模型和关系模型相互映射的技术。
本实验使用Hibernate框架，通过ORM技术实现数据的增删改查操作。
2. 数据查询语言（1）SQLSQL（Structured Query Language）是一种用于数据库查询、更新和管理的标准语言。
本实验使用SQL语句对数据库进行查询、更新和删除操作。
（2）NoSQLNoSQL是一种非关系型数据库技术，适用于处理大规模、分布式、非结构化数据。
本实验使用MongoDB数据库，通过NoSQL语言进行数据操作。
3. 数据连接技术（1）TCP/IPTCP/IP是一种网络协议，用于实现数据在网络中的传输。
本实验通过TCP/IP协议连接数据库服务器，实现数据访问。
（2）HTTPHTTP（HyperText Transfer Protocol）是一种应用层协议，用于在Web服务器和客户端之间传输数据。
本实验通过HTTP协议访问Web服务，实现数据访问。
数据访问技术实验报告实验目的：本实验旨在通过实践操作，加深对数据访问技术的理解，掌握不同数据访问方法的实现原理和应用场景，提高解决实际数据访问问题的能力。
实验环境：- 操作系统：Windows 10- 数据库管理系统：MySQL 8.0- 开发工具：Eclipse IDE 2021-09实验内容：1. SQL查询语句的编写与执行。
2. JDBC（Java Database Connectivity）的使用。
3. ORM（Object-Relational Mapping）框架Hibernate的使用。
实验步骤：1. 准备实验环境，安装并配置好MySQL数据库和Eclipse开发环境。
2. 创建数据库和数据表，为实验提供数据支持。
3. 编写SQL查询语句，实现数据的增删改查操作。
4. 利用JDBC连接数据库，执行SQL语句，并处理结果。
5. 配置Hibernate框架，通过ORM方式进行数据访问。
实验过程：1. 在MySQL中创建名为`ExperimentDB`的数据库，并在其中创建`Students`表，包含字段`id`, `name`, `age`, `major`。
2. 编写SQL语句，插入几条学生记录，并查询所有学生信息。
3. 在Eclipse中创建Java项目，添加MySQL驱动依赖。
4. 编写Java程序，使用JDBC连接到`ExperimentDB`数据库，执行SQL查询语句，并打印查询结果。
5. 配置Hibernate，定义实体类`Student`与`Students`表映射，并使用Hibernate的Session进行数据访问。
实验结果：1. SQL查询语句成功执行，能够正确插入和查询数据。
2. JDBC程序能够连接数据库，执行SQL语句，并正确处理查询结果。
3. Hibernate配置成功，通过ORM方式能够进行数据的增删改查操作。
实验分析：通过本次实验，我们了解到SQL是直接与数据库进行交互的基本语言，适用于简单的数据操作。
java项目中的增删改查方法在Java项目中，增删改查（CRUD）操作是非常常见的需求。
无论是开发Web应用、移动应用还是后台系统，都会涉及到对数据的增加、删除、修改和查询操作。
在Java中，我们通常使用数据库来存储数据，而针对数据库的增删改查操作，我们通常会使用SQL语句来实现。
下面我们来看看在Java项目中，如何实现增删改查方法。
1. 增加（Create），在Java项目中，要实现数据的增加操作，通常需要先连接数据库，然后使用SQL语句向数据库中插入新的数据。
在Java中，我们可以使用JDBC（Java Database Connectivity）来连接数据库，使用PreparedStatement或者Statement来执行插入操作。
另外，如果我们使用了ORM框架（如Hibernate或MyBatis），我们也可以通过框架提供的API来实现数据的插入操作。
2. 删除（Delete），删除数据操作通常是根据某个条件从数据库中删除符合条件的数据。
在Java项目中，我们可以使用SQL的DELETE语句来实现数据的删除操作。
同样地，我们可以使用JDBC或者ORM框架提供的API来执行删除操作。
3. 修改（Update），修改数据操作通常是根据某个条件更新数据库中的数据。
在Java项目中，我们可以使用SQL的UPDATE语句来实现数据的更新操作。
同样地，我们可以使用JDBC或者ORM框架提供的API来执行更新操作。
4. 查询（Retrieve），查询数据操作是从数据库中检索数据。
在Java项目中，我们可以使用SQL的SELECT语句来实现数据的查询操作。
同样地，我们可以使用JDBC或者ORM框架提供的API来执行查询操作，并将查询结果返回给Java应用程序。
总的来说，在Java项目中实现增删改查方法，我们通常会使用JDBC来连接数据库并执行SQL语句，或者使用ORM框架来简化数据库操作。
无论是使用JDBC还是ORM框架，都需要对数据库操作有一定的了解，以便能够编写出高效、安全的增删改查方法。
hibernatetemplate 语法摘要：一、介绍HibernateTemplate 语法二、HibernateTemplate 的优势三、HibernateTemplate 的使用方法四、HibernateTemplate 的常见方法五、HibernateTemplate 的注意事项六、总结正文：HibernateTemplate 是Hibernate 框架中的一个核心类，它提供了一种简化Hibernate 操作的语法。
HibernateTemplate 可以帮助我们简化Hibernate 的增删改查操作，使开发者无需手动编写SQL 语句，只需使用HibernateTemplate 类的方法即可完成相应的操作。
HibernateTemplate 的优势在于它提供了一种更符合面向对象编程思想的操作方式。
通过HibernateTemplate，我们可以将业务逻辑与数据访问逻辑分离，使代码结构更加清晰。
同时，HibernateTemplate 还具有自动事务管理功能，可以有效地管理事务，避免出现因事务处理不当而引发的问题。
使用HibernateTemplate 非常简单，首先需要创建一个HibernateTemplate 对象，然后通过这个对象调用相应的方法进行操作。
下面是一个简单的示例：```java// 获取HibernateTemplate 对象Session session = HibernateUtil.getSessionFactory().openSession();HibernateTemplate hibernateTemplate = new HibernateTemplate(session);// 使用HibernateTemplate 插入数据User user = new User();user.setName("张三");user.setAge(25);hibernateTemplate.insert(user);// 使用HibernateTemplate 更新数据User user2 = (User) hibernateTemplate.load(User.class, 1);user2.setName("李四");hibernateTemplate.update(user2);// 使用HibernateTemplate 删除数据hibernateTemplate.delete(user);// 使用HibernateTemplate 查询数据List<User> users = hibernateTemplate.loadAll(User.class);```HibernateTemplate 提供了许多常用的方法，如insert、update、delete、load、loadAll 等，可以满足我们日常开发中的大部分需求。
java项目中的增删改查方法在Java项目中，增删改查（CRUD）方法是非常常见和重要的。
这些方法用于对数据库中的数据进行操作，是任何应用程序的核心功能之一。
在本文中，我们将讨论Java项目中的增删改查方法的实现和最佳实践。
1. 增加（Create）数据。
在Java项目中，创建数据通常涉及将用户输入或其他来源的数据插入到数据库中。
为了实现这一点，我们通常会使用SQL INSERT语句或ORM（对象关系映射）框架（如Hibernate）来执行插入操作。
在使用ORM框架的情况下，我们可以通过创建实体对象并将其持久化到数据库中来实现数据的创建操作。
2. 删除（Delete）数据。
删除数据是指从数据库中移除特定记录或数据集。
在Java项目中，我们可以使用SQL DELETE语句或ORM框架提供的方法来执行删除操作。
在使用ORM框架时，通常会调用实体对象的删除方法来删除数据库中的记录。
3. 修改（Update）数据。
修改数据是指更新数据库中现有记录的内容。
在Java项目中，我们可以使用SQL UPDATE语句或ORM框架提供的方法来执行更新操作。
如果使用ORM框架，我们可以通过修改实体对象的属性并将其持久化到数据库中来实现数据的修改操作。
4. 查询（Retrieve）数据。
查询数据是指从数据库中检索特定记录或数据集。
在Java项目中，我们可以使用SQL SELECT语句或ORM框架提供的方法来执行查询操作。
如果使用ORM框架，我们通常会调用相应的查询方法来检索数据库中的数据。
在实现增删改查方法时，我们应该注意以下最佳实践：使用预编译语句或参数化查询来防止SQL注入攻击。
对数据库操作进行事务管理，以确保数据的一致性和完整性。
使用适当的索引和优化数据库查询，以提高性能。
对于ORM框架，应该了解并遵循框架的最佳实践和性能优化建议。
总之，增删改查方法是任何Java项目中不可或缺的部分。
通过遵循最佳实践和使用合适的工具和技术，我们可以有效地实现这些方法并确保应用程序的数据操作功能的稳健性和性能。
Hibernate中的replace函数1. 定义Hibernate是一个开源的Java持久化框架，用于将Java对象映射到关系数据库中。
它提供了一种简单且高效的方法来处理数据库操作，包括增删改查等。
Hibernate中的replace函数是其中一个用于更新数据的方法。
2. 用途replace函数用于将数据库中的记录替换为新的记录。
它可以用于更新已存在的记录，也可以用于插入新的记录。
相对于update函数，replace函数更加灵活，可以自动判断是插入新记录还是更新已存在的记录。
3. 工作方式replace函数的工作方式如下：1.首先，Hibernate会检查数据库中是否存在与要替换的记录具有相同主键的记录。
如果存在，则会删除该记录。
2.然后，Hibernate会插入新的记录。
可以看出，replace函数实际上是先删除已存在的记录，然后再插入新的记录。
它会自动判断是插入新记录还是更新已存在的记录，这取决于主键是否存在于数据库中。
4. 代码示例下面是一个使用Hibernate的replace函数的示例：Session session = sessionFactory.openSession();Transaction transaction = session.beginTransaction();// 创建一个新的实体对象Entity entity = new Entity();entity.setId(1);entity.setName("New Name");// 使用replace函数替换数据库中的记录session.saveOrUpdate(entity);mit();session.close();在上面的示例中，我们首先创建了一个新的实体对象entity，并设置了其属性值。
然后，我们使用session的saveOrUpdate方法来保存或更新该实体对象。
Hibernate会自动判断是插入新记录还是更新已存在的记录，并执行相应的操作。
1）拷贝下面所说的.java文件，9个java文件和相应的包名，这些都是大果任封装好的文件，可以直接用。
dao包里面有：还有一个impl包：manager包里面有：还有一个impl包：struts包里面有：还有一个action包：utils包里面有：再把log4j.properties贴到src包下面。
2）把spring-struts-struts-struts-struts-struts-struts-validator-这些以前写过的都可以贴过来，你可以直接把这个项目里的都贴过去，以后就直接在这里该代码就行了。
以上两个步骤样就是为了完成手写SSH代码3）新建一个pojo包：创建一个实体：先让这个类实现序列接口如：然后写相应的字段：利用get和set方法生成每个字段的get()和set()。
例如：4)为了更够生成所以为每一个字段写出相应的元数据：1.生成相应的表：说明：利用hibernate生成UserLogin表。
2.字段id的映射，元数据要写在get（）方法前面：3.字段username的映射，元数据要写在get（）方法前面：4.字段password的映射，元数据要写在get（）方法前面：这样这个就完成了。
5）右键项目名称找到“属性”选项：找到：XDoclet点击这个出来相应的界面：单击按钮，出现：选中：并单击确定按钮。
出现：点击“确定”按钮。
6）右键项目名称：执行RunXDocle后只要出现：就说明你的UserLogin类的创建成功了！！7）新建一个的页面(带Form的那种页面)：生成相应的页面后把属性名称，改成：给相应的action后面添加一个名字，指明提交表单后走哪个.do如：8）找到双击：在代码标签中手写action(就是上面表单提交后的那个/***.do)：在找到标签，写上form-bean的代码：说明：根据jsp页面提交的/找到struts-里面的path属性，根据name属性找到form-bean标签里的name属性，以及它对应的type属性，type 属性写的就是pojo类中UserLogin的全名(包括包名和类名)，Parameter属性是说明表单提交后要执行check方法，Validate=”false”属性说明不使用表单验证框架,Scope=”request”说明作用域是request，Type=””属性写得就是你一会要创建的UserLoginAction的全名(包括包名和类名)，Forword标签就是说明要是check成功后跳转，失败就跳转页面。
hibernate的flush方法Hibernate是一个开源的对象关系映射工具，提供了数据库操作的抽象层，使开发者可以使用面向对象的方式进行数据库操作。
Hibernate的flush方法是用于将Hibernate会话中的变化同步到数据库的操作。
在Hibernate中，会话（Session）是表示开发者与数据库之间的一次连接。
开发者可以通过向会话中添加、修改和删除对象来操作数据库。
而flush方法则是将这些变化同步到数据库。
在什么情况下需要使用flush方法呢？1. 当开发者需要保证数据的完整性时，可以使用flush方法。
当开发者添加、修改或删除了对象之后，调用flush方法会立即将这些变化同步到数据库。
2. 当开发者需要检查数据是否已经被持久化时，可以使用flush方法。
在调用flush方法之后，数据将被立即同步到数据库，可以通过查询数据库来验证数据是否已经被保存。
3. 当开发者需要在事务之外使用最新的数据时，可以使用flush方法。
在Hibernate中，默认情况下，事务提交之前，所有的数据变化只是在会话缓存中进行维护，而不会立即同步到数据库。
但是，如果开发者需要在事务之外查询到最新的数据，可以在查询之前调用flush方法，确保数据已经更新到数据库中。
4. 当开发者需要将数据库操作的异常抛出时，可以使用flush方法。
在执行数据库操作过程中，如果发生了异常，Hibernate会自动回滚事务，但不会抛出异常。
如果开发者希望在发生异常时得到通知，可以在执行数据库操作之前调用flush方法，如果操作失败，会抛出异常。
实际上，flush方法执行的操作如下：1.将会话中的持久化对象的状态同步到数据库。
持久化对象的状态包括新增、修改和删除。
2.将会话中的变化同步到数据库的操作也会级联到关联对象。
如果一些持久化对象发生了变化，与之关联的其他对象也会受到影响。
3. 执行flush操作不会结束当前事务，会话仍然处于打开状态，可以继续进行操作。
搭建第⼀个web项⽬：实现⽤户的增删改查 好久没写这个web的代码了，再不写估计以前的也忘记的差不多了，赶紧复习下，顺便把⾃⼰的想法慢慢实现了。
最近在公司发现以前的项⽬有⽤easyUI搭建的。
赶紧copy回来学习下。
感觉写⽇志真的很有必要，⾃⼰总结的肯定要⽐每次从⽹上查阅来的靠谱。
每次搭建⼀个基本的web项⽬都都要查ssh的配置真的很忧伤啊，有⽊有 把jar包的截图截了⼀下，要不总是记不清该⽤到的基本jar有啥。
其中Struts中⽤到的jar有：commons-fileupload.jar commons-io.jar freemarker.jar ognl.jar struts2-core.jar xwork-core.jar 因为⽤到的是Struts的注解形式，所以加⼊了Struts的插件jar：struts2-convention-plugin.jar hibernate中⽤到的jar有：hibernate核⼼包：hibernate.jar hibernate必须包：antlr.jar commons-collection.jar dom4j.jar javassist.jar jta.jar slf-4j.jar 数据库连接池:c3p0 数据库驱动jdbc:mysql-connector.jar spring中⽤到的jar有：核⼼包：spring.jar AOP:aspectjrt.jar aspectjweaver.jar 动态代理（和aop也有关）cglib.jar ⽇志有关commons-logging.jar 其他的插件包需要的时候⼀个⼀个添加，上⾯的是最基本的。
好了，这回基本jar包也记录下来了。
下⾯开始好好研究下公司项⽬，实现最基本的⽤户增删改查了。
现在最⿇烦的就是项⽬⾥的基础通⽤类不知道该怎么部署，啊啊啊啊啊 马丹，把项⽬拷到公司电脑上之后包了个这个错误，我也是醉了好不，明明都是⼀样的MySQL和Eclipse，为啥就不⾏了呢。
hibernate createnativequery 使用摘要：一、Hibernate 简介1.Hibernate 介绍2.Hibernate 的作用二、Hibernate 的NativeQuery 使用1.NativeQuery 概述2.NativeQuery 的使用场景3.NativeQuery 的优点和缺点三、Hibernate CreateNativeQuery 方法1.CreateNativeQuery 方法定义2.方法参数说明3.方法使用示例四、Hibernate CreateNativeQuery 应用实例1.实例一：使用CreateNativeQuery 查询数据2.实例二：使用CreateNativeQuery 更新数据3.实例三：使用CreateNativeQuery 删除数据正文：Hibernate 是一个开源的持久化框架，主要用于将Java 对象映射到关系型数据库中，从而实现数据持久化。
它将Java 对象与数据库表之间的映射关系以及数据库操作进行了抽象，简化了开发者在数据库操作方面的复杂性。
在Hibernate 中，有一个非常重要的功能就是NativeQuery 的使用。
NativeQuery 允许开发者使用JDBC 语句直接操作数据库，这在某些特定场景下非常有用。
例如，当需要执行复杂查询、存储过程或事务处理时，使用NativeQuery 可以提供更大的灵活性。
Hibernate 提供了CreateNativeQuery 方法，用于创建一个NativeQuery 对象。
CreateNativeQuery 方法接收一个字符串参数，即SQL 语句或命名查询，根据这个参数创建一个NativeQuery 对象。
然后，可以通过这个NativeQuery 对象执行查询、更新、删除等数据库操作。
Hibernate批处理操作优化（批量插入、更新与删除）在项目的开发过程之中，由于项目需求，我们常常需要把大批量的数据插入到数据库。
数量级有万级、十万级、百万级、甚至千万级别的。
如此数量级别的数据用Hibernate做插入操作，就可能会发生异常，常见的异常是OutOfMemoryError（内存溢出异常）。
首先，我们简单来回顾一下Hibernate插入操作的机制。
Hibernate要对它内部缓存进行维护，当我们执行插入操作时，就会把要操作的对象全部放到自身的内部缓存来进行管理。
谈到Hibernate的缓存，Hibernate有内部缓存与二级缓存之说。
由于Hibernate对这两种缓存有着不同的管理机制，对于二级缓存，我们可以对它的大小进行相关配置,而对于内部缓存，Hibernate就采取了“放任自流”的态度了，对它的容量并没有限制。
现在症结找到了，我们做海量数据插入的时候，生成这么多的对象就会被纳入内部缓存（内部缓存是在内存中做缓存的），这样你的系统内存就会一点一点的被蚕食，如果最后系统被挤“炸”了，也就在情理之中了。
我们想想如何较好的处理这个问题呢？有的开发条件又必须使用Hibernate来处理，当然有的项目比较灵活，可以去寻求其他的方法。
笔者在这里推荐两种方法：(1)：优化Hibernate,程序上采用分段插入及时清除缓存的方法。
(2)：绕过Hibernate API ，直接通过 JDBC API 来做批量插入，这个方法性能上是最好的，也是最快的。
对于上述中的方法1，其基本是思路为：优化Hibernate，在配置文件中设置hibernate.jdbc.batch_size参数，来指定每次提交SQL的数量；程序上采用分段插入及时清除缓存的方法(Session实现了异步write-behind，它允许Hibernate显式地写操作的批处理),也就是每插入一定量的数据后及时的把它们从内部缓存中清除掉，释放占用的内存。
java项目中实现增删改查基本流程
在Java项目中实现增删改查的基本流程如下：
1. 增加（Create）：创建一个新的实体对象，并将其存储到数据库中。
- 创建实体对象的类，并进行必要的字段设置。
- 使用数据库连接或ORM框架，将实体对象插入到数据库表中。
2. 删除（Delete）：从数据库中删除指定的实体对象。
- 根据需要删除的实体对象的唯一标识（如ID），准备删除操作。
- 使用数据库连接或ORM框架，执行删除操作。
3. 修改（Update）：更新数据库中的指定实体对象。
- 获取需要修改的实体对象，并对其进行必要的字段修改。
- 使用数据库连接或ORM框架，执行更新操作。
4. 查询（Retrieve）：从数据库中查询实体对象。
- 根据需要查询的条件（如关键字、字段值等），准备查询操作。
- 使用SQL语句或ORM框架提供的查询方法，执行查询操作，并将结果返回。
以上是增删改查的基本流程，在实际项目中可能会有更多复杂的逻辑和操作，例如条件查询、分页查询、排序等，但基本的增删改查流程是不变的。
请根据具体项目的需求和技术栈，选
择合适的数据库处理方式（原生JDBC、JPA、MyBatis等）来实现。
1./**2. *3. * @author fly.zhou4. */5.public interface IBaseDao {6.7.//增加对应实体的一条记录8.public boolean save(Object o);9.10.//更新对应实体的一条记录11.public boolean update(Object o);12.13.//增加或者更新对应实体的一条记录14.public boolean saveOrUpdate(Object o);15.16.//保存一系列对象集合17.public boolean saveOrUpdateAll(Collection l);18.19.//删除对应实体的一条记录20.public boolean delete(Object o);21.22.//根据id删除对应实体的一条记录23.public boolean delete(Class c, Serializable id);24.25.//执行hql语句删除一条记录26.public Integer delete(String hql, Object... values);27.28.//删除一系列数据29.public boolean deleteAll(Collection l);30.31.//执行hql语句查找32.public List find(String hql);33.34.//分页查询，多参数条件35.public List find(String hql, DataGridReq dgr, List values);36.37.//分页查询，多参数条件38.public List find(String hql, DataGridReq dgr, Object... values);39.40.//不带分页查询，多参数条件41.public List find(String hql, Object... values);42.43.//不带分页查询，多参数条件44.public boolean update(String hql, Object... values);45.46.//根据主键ID查询对应实体的一条记录47.public Object get(Class clazz, Serializable id);48.49.//获取某实体对象50.public Object load(Class c, Serializable id);51.52.//获取总记录数53.public Long total(String hql, List values);54.55.//获取总记录数56.public Long total(String hql, Object... values);57.58.//更新对应实体的某一条记录59.public boolean updateOneByProperty(Class clazz, Serializable id, String pName, Object pValue);60.61.//更新对应实体的某几条记录62.public boolean updateOneByPropertys(Class clazz, Serializable id, List<String> pName, List<Object> pValue);63.64.//更新对应实体的某几条记录(封装成map)65.public boolean updateOneByPropertys(Class clazz, Serializable id, Map<String, Object> map);66.67.//根据属性名以及对应的属性值查找一条记录68.public Object getSingleByProperty(Class clazz, String pName, Object pValue);69.70.//判断是否有对应的属性名和属性值存在，存在返回true71.public boolean ifHasOneByProperty(Class clazz, String pName, Object pValue);72.73.//根据一系列属性以及对应的属性值查询一条记录74.public Object getSingleByPropertys(Class clazz, List<String> pName, List<Object> pValue);75.76.//判断是否有一系列对应的属性名和属性值存在，存在返回true77.public boolean ifHasOneByPropertys(Class clazz, List<String> pName, List<Object> pValue);78.79.//根据一系列属性以及对应的属性值(封装成Map)查询一条记录80.public Object getSingleByPropertys(Class clazz, Map<String, Object> map);81.82.//判断是否有一系列对应的属性名和属性值(封装成Map)存在，存在返回true83.public boolean ifHasOneByPropertys(Class clazz, Map<String, Object> map);84.85.//通过某一对应的属性名和属性值，查询某一个属性的值86.public Object getValueByPropertys(Class clazz, Map<String, Object> map, String selectName);87.88.//通过一系列对应的属性名和属性值，查询某一个属性的值89.public Object getValueByProperty(Class clazz, String pName, Object pValue, String selectName);90.91.//通过一系列对应的属性名和属性值，查询某一个属性的值92.public Object getValueByPropertys(Class clazz, List<String> pNames, List<Object> pValues, String selectName);93.94.//查询对应实体的所有记录95.public List<Object> getObjects(Class clazz);96.97.//查询符合属性名以及对应的属性值的一系列记录98.public List<Object> getObjectsByProperty(Class clazz, String pName, Object pValue);99.100.//根据任意属性查询名以及对应的属性值的一系列记录101.public List<Object> getObjectsByAnyProperty(Class clazz, List<String > pName, List<Object> pValue);102.103.//查询符合一系列属性名以及对应的属性值的一系列记录104.public List<Object> getObjectsByPropertys(Class clazz, List<String> pName, List<Object> pValue);105.106.//根据某属性对应的属性值在某一范围内的一系列记录107.public List<Object> getObjectsByProperty(Class clazz, String pName, String operator, Object pValue);108.109.//根据某属性对应的属性值在某一范围内的一系列记录110.public List<Object> getObjectsByPropertys(Class clazz, List<String> pName, List<String> operator, List<Object> pValue);111.}2》接口的实现 BaseDaoImpl.java[java]view plaincopy1.public class BaseDaoImpl implements IBaseDao {2.3.private static final Logger logger = Logger.getLogger(BaseDaoImpl.class);4.private HibernateTemplate hibernateTemplate;5.6.public HibernateTemplate getHibernateTemplate() {7. hibernateTemplate.setCacheQueries(true);// 开启二级查询缓存8.return hibernateTemplate;9. }10.11.@Autowired12.public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {13.this.hibernateTemplate = hibernateTemplate;14. }15.16.@Override17.public boolean delete(Object o) {18.// ("删除");19.try {20.this.getHibernateTemplate().delete(o);21.return true;22. } catch (Exception e) {23.return false;24. }25. }26.27.@Override28.public boolean delete(Class c, Serializable id) {29.// ("删除");30.try {31.this.getHibernateTemplate().delete(get(c, id));32.return true;33. } catch (Exception e) {34.return false;35. }36. }37.38.@Override39.public Integer delete(final String hql, final Object... values) {40.return this.getHibernateTemplate().execute(new HibernateCallback<Integer>() {41.42.@Override43.public Integer doInHibernate(Session session) throws HibernateException, SQLException {44. Query q = session.createQuery(hql);45.if (values != null && values.length > 0) {46.for (int i = 0; i < values.length; i++) {47. q.setParameter(i, values[i]);48. }49. }50.return q.executeUpdate();51. }52. });53. }54.55.@Override56.public boolean deleteAll(Collection l) {57.// ("删除");58.try {59.this.getHibernateTemplate().deleteAll(l);60.return true;61. } catch (Exception e) {62.return false;63. }64. }65.66.@Override67.public boolean update(Object o) {68.// ("更新");69.try {70.this.getHibernateTemplate().update(o);71.return true;72. } catch (Exception e) {73. e.printStackTrace();74.return false;75. }76. }77.78.@Override79.public boolean save(Object o) {80.// ("保存");81.try {82.this.getHibernateTemplate().save(o);83.return true;84. } catch (Exception e) {85.return false;86. }87. }88.89.@Override90.public boolean saveOrUpdate(Object o) {91.try {92.this.getHibernateTemplate().saveOrUpdate(o);93.return true;94. } catch (Exception e) {95.return false;96. }97. }98.99.@Override100.public boolean saveOrUpdateAll(Collection l) { 101.// ("编辑");102.try {103.this.getHibernateTemplate().saveOrUpdateAll(l);104.return true;105. } catch (Exception e) {106.return false;107. }108. }109.110.@Override111.public List find(String hql) {112.// ("查询");113.return this.getHibernateTemplate().find(hql);114. }115.116.@Override117.public List find(final String hql, final DataGridReq dgr, final List values) {118.return this.getHibernateTemplate().execute(new HibernateCallback <List>() {119.120.@Override121.public List doInHibernate(Session session) throws HibernateE xception, SQLException {122. Query q = session.createQuery(hql);123.if (values != null && values.size() > 0) {124.for (int i = 0; i < values.size(); i++) {125. q.setParameter(i, values.get(i));126. }127. }128.if (dgr == null) {129.return q.list();130. }131.return q.setFirstResult(dgr.getStart()).setMaxResults(dg r.getLimit() * dgr.getPage()).list();132. }133. });134. }135.136.@Override137.public List find(final String hql, final DataGridReq dgr, final Obje ct... values) {138.return this.getHibernateTemplate().execute(new HibernateCallback <List>() {139.140.@Override141.public List doInHibernate(Session session) throws HibernateE xception, SQLException {142. Query q = session.createQuery(hql);143.if (values != null && values.length > 0) {145. q.setParameter(i, values[i]);146. }147. }148.if (dgr == null) {149.return q.list();150. }151.return q.setFirstResult(dgr.getStart()).setMaxResults(dg r.getLimit() * dgr.getPage()).list();152. }153. });154. }155.156.@Override157.public List find(String hql, Object... values) {158.return this.getHibernateTemplate().find(hql, values);159. }160.161.@Override162.public boolean update(final String hql, final Object... values) { 163.try {164.this.getHibernateTemplate().bulkUpdate(hql, values);165.return true;166. } catch (Exception e) {167.return false;168. }169. }170.171.@Override172.public Object get(Class c, Serializable id) {173.return this.getHibernateTemplate().get(c, id);174. }175.176.@Override177.public Object load(Class c, Serializable id) {178.return this.getHibernateTemplate().load(c, id);179. }180.181.@Override182.public Long total(final String hql, final List values) {183.return this.getHibernateTemplate().execute(new HibernateCallback <Long>() {184.185.@Override186.public Long doInHibernate(Session session) throws HibernateE xception, SQLException {187. Query q = session.createQuery(hql);188.if (values != null && values.size() > 0) {190. q.setParameter(i, values.get(i));191. }192. }193.return (Long) q.uniqueResult();194. }195. });196. }197.198.@Override199.public Long total(final String hql, final Object... values) { 200.return this.getHibernateTemplate().execute(new HibernateCallback <Long>() {201.202.@Override203.public Long doInHibernate(Session session) throws HibernateE xception, SQLException {204. Query q = session.createQuery(hql);205.if (values != null && values.length > 0) {206.for (int i = 0; i < values.length; i++) {207. q.setParameter(i, values[i]);208. }209. }210.return (Long) q.uniqueResult();211. }212. });213. }214.215.@Override216.public boolean updateOneByProperty(Class clazz, Serializable id, Str ing pName, Object pValue) {217. String hql = "update " + clazz.getName() + " entity set entity."+ pName + " = '" + pValue + "' where entity.id = " + id;218. getHibernateTemplate().bulkUpdate(hql);219.return true;220. }221.222.@Override223.public boolean updateOneByPropertys(Class clazz, Serializable id, Li st<String> pName, List<Object> pValue) {224. String hql = "update " + clazz.getName() + " entity set entity.";225.int maxIndex = pName.size() - 1;226.for (int i = 0; i < maxIndex; i++) {227. hql += pName.get(i) + " = '" + pValue.get(i) + "', entity."; 228. }229. hql += pName.get(maxIndex) + " = '" + pValue.get(maxIndex) + "'w here entity.id = " + id;230. System.out.println(hql);231. getHibernateTemplate().bulkUpdate(hql);232.return true;233. }234.235.@Override236.public boolean updateOneByPropertys(Class clazz, Serializable id, Ma p<String, Object> map) {237. String hql = "update " + clazz.getName() + " entity set entity.";238. Set set = map.entrySet();239.if (set != null) {240. Iterator iterator = set.iterator();241.while (iterator.hasNext()) {242. Entry entry = (Entry) iterator.next();243. Object key = entry.getKey();244. Object value = entry.getValue();245. hql += key + " = '" + value + "' and entity.";246. }247. }248. hql = hql.substring(0, hql.length() - 12);249. hql += "'where entity.id = " + id;250. System.out.println(hql);251. getHibernateTemplate().bulkUpdate(hql);252.return true;253. }254.255./**256. * 根据属性查询257. *258. * @param clazz259. * @param pName260. * @param pValue261. * @return262. */263.@Override264.public Object getSingleByProperty(Class clazz, String pName, Object pValue) {265.266. String hql = "from " + clazz.getName() + " entity where entity."+ pName + " = '" + pValue + "'";267. List<Object> os = getHibernateTemplate().find(hql);268.if (os != null && !os.isEmpty()) {269.return os.get(0);270. } else {271.return null;272. }273. }274.275./**276. * 根据属性查询277. *278. * @param clazz279. * @param pName280. * @param pValue281. * @return282. */283.@Override284.public boolean ifHasOneByProperty(Class clazz, String pName, Object pValue) {285. String hql = "from " + clazz.getName() + " entity where entity."+ pName + " = '" + pValue + "'";286. List<Object> os = getHibernateTemplate().find(hql);287.if (os != null && !os.isEmpty()) {288.return true;289. } else {290.return false;291. }292. }293.294./**295. * 根据属性查询296. *297. * @param clazz298. * @param pName299. * @param pValue300. * @return301. */302.@Override303.public List<Object> getObjectsByAnyProperty(Class clazz, List<String > pName, List<Object> pValue) {304. String hql = "from " + clazz.getName() + " entity where entity.";305.int maxIndex = pName.size() - 1;306.for (int i = 0; i < maxIndex; i++) {307. hql += pName.get(i) + " = '" + pValue.get(i) + "' or entity.";308. }309. hql += pName.get(maxIndex) + " = '" + pValue.get(maxIndex) + "'";310. System.out.println(hql);311. List<Object> os = getHibernateTemplate().find(hql);312.if (os != null && !os.isEmpty()) {313.return os;314. } else {315.return null;316. }317. }318.319.@Override320.public boolean ifHasOneByPropertys(Class clazz, List<String> pName, List<Object> pValue) {321. String hql = "from " + clazz.getName() + " entity where entity.";322.int maxIndex = pName.size() - 1;323.for (int i = 0; i < maxIndex; i++) {324. hql += pName.get(i) + " = '" + pValue.get(i) + "' and entity .";325. }326. hql += pName.get(maxIndex) + " = '" + pValue.get(maxIndex) + "'";327. System.out.println(hql);328. List<Object> os = getHibernateTemplate().find(hql);329.if (os != null && !os.isEmpty()) {330.return true;331. } else {332.return false;333. }334. }335.336.@Override337.public Object getSingleByPropertys(Class clazz, List<String> pName, List<Object> pValue) {338.339. String hql = "from " + clazz.getName() + " entity where entity.";340.int maxIndex = pName.size() - 1;341.for (int i = 0; i < maxIndex; i++) {342. hql += pName.get(i) + " = '" + pValue.get(i) + "' and entity .";343. }344. hql += pName.get(maxIndex) + " = '" + pValue.get(maxIndex) + "'";345. System.out.println(hql);346. List<Object> os = getHibernateTemplate().find(hql);347.if (os != null && !os.isEmpty()) {348.return os.get(0);349. } else {350.return null;351. }352. }353.354.@Override355.public Object getSingleByPropertys(Class clazz, Map<String, Object> map) {356. String hql = "from " + clazz.getName() + " entity where entity.";357. Set set = map.entrySet();358.if (set != null) {359. Iterator iterator = set.iterator();360.while (iterator.hasNext()) {361. Entry entry = (Entry) iterator.next();362. Object key = entry.getKey();363. Object value = entry.getValue();364. hql += key + " = '" + value + "' and entity.";365. }366. }367. hql = hql.substring(0, hql.length() - 12);368. System.out.println("hql = " + hql);369. List<Object> os = getHibernateTemplate().find(hql);370.if (os != null && !os.isEmpty()) {371.return os.get(0);372. } else {373.return null;374. }375. }376.377.@Override378.public boolean ifHasOneByPropertys(Class clazz, Map<String, Object> map) {379.380. String hql = "from " + clazz.getName() + " entity where entity.";381. Set set = map.entrySet();382.if (set != null) {383. Iterator iterator = set.iterator();384.while (iterator.hasNext()) {385. Entry entry = (Entry) iterator.next();386. Object key = entry.getKey();387. Object value = entry.getValue();388. hql += key + " = '" + value + "' and entity.";389. }390. }391. hql = hql.substring(0, hql.length() - 12);392. List<Object> os = getHibernateTemplate().find(hql);393.if (os != null && !os.isEmpty()) {394.return true;395. } else {396.return false;397. }398. }399.400./**401. * 查询所有402. */403.@Override404.public List<Object> getObjects(Class clazz) {405. String hql = "from " + clazz.getName();406. List list = getHibernateTemplate().find(hql);407.return list;408. }409.410./**411. * 根据属性查询全部412. *413. * @param clazz414. * @param pName415. * @param pValue416. * @return417. */418.@Override419.public List<Object> getObjectsByProperty(Class clazz, String pName, Object pValue) {420. String hql = "from " + clazz.getName() + " entity where entity."+ pName + " = '" + pValue + "'";421.return getHibernateTemplate().find(hql);422. }423.424.@Override425.public List<Object> getObjectsByPropertys(Class clazz, List<String> pName, List<Object> pValue) {426. String hql = "from " + clazz.getName() + " entity where entity.";427.int maxIndex = pName.size() - 1;428.for (int i = 0; i < maxIndex; i++) {429. hql += pName.get(i) + " = '" + pValue.get(i) + "' and "; 430. }431. hql += pName.get(maxIndex) + " = '" + pValue.get(maxIndex) + "'";432.return getHibernateTemplate().find(hql);433. }434.435./**436. * 根据属性查询全部437. *438. * @param clazz439. * @param pName440. * @param pValue441. * @return442. */443.@Override444.public List<Object> getObjectsByProperty(Class clazz, String pName, String operator, Object pValue) {445. String hql = "from " + clazz.getName() + " entity where entity."+ pName + " " + operator + pValue;446.return getHibernateTemplate().find(hql);447. }448.449.@Override450.public List<Object> getObjectsByPropertys(Class clazz, List<String> pName, List<String> operator, List<Object> pValue) {451. String hql = "from " + clazz.getName() + " entity where entity.";452.int maxIndex = pName.size() - 1;453.for (int i = 0; i < maxIndex; i++) {454. hql += pName.get(i) + " " + operator.get(i) + " '" + pValue.get(i) + "' and ";455. }456. hql += pName.get(maxIndex) + " " + operator.get(maxIndex) + " '"+ pValue.get(maxIndex) + "'";457. System.out.println("hql = " + hql);458.return getHibernateTemplate().find(hql);459. }460.461.@Override462.public Object getValueByPropertys(Class clazz, Map<String, Object> m ap, String selectName) {463. String hql = "select entity." + selectName + "from " + clazz.get Name() + " entity where entity.";464. Set set = map.entrySet();465.if (set != null) {466. Iterator iterator = set.iterator();467.while (iterator.hasNext()) {468. Entry entry = (Entry) iterator.next();469. Object key = entry.getKey();470. Object value = entry.getValue();471. hql += key + " = '" + value + "' and entity.";472. }473. }474. hql = hql.substring(0, hql.length() - 12);475. System.out.println("hql = " + hql);476.return getHibernateTemplate().find(hql);477. }478.479.@Override480.public Object getValueByProperty(Class clazz, String pName, Object p Value, String selectName) {481. String hql = "select entity." + selectName + " from " + clazz.ge tName() + " entity where entity." + pName + " = '" + pValue + "'";482. System.out.println("hql = " + hql);483.return getHibernateTemplate().find(hql);484. }485.486.@Override487.public Object getValueByPropertys(Class clazz, List<String> pNames, List<Object> pValues, String selectName) {488. String hql = "select entity." + selectName + "from " + clazz.get Name() + " entity where entity.";489.int maxIndex = pNames.size() - 1;490.for (int i = 0; i < maxIndex; i++) {491. hql += pNames.get(i) + " = '" + pValues.get(i) + "' and ";492. }493. hql += pNames.get(maxIndex) + " = '" + pValues.get(maxIndex) + "'";494. System.out.println("hql = " + hql);495.return getHibernateTemplate().find(hql);496. }497.}3》值得注意的地方Map如何获取key[java]view plaincopy1.Set set = map.entrySet();2.if (set != null) {3. Iterator iterator = set.iterator();4.while (iterator.hasNext()) {5. Entry entry = (Entry) iterator.next();6. Object key = entry.getKey();7. Object value = entry.getValue();8. hql += key + " = '" + value + "' and entity.";9. }10.}4》这样写的话会对项目省去大量的重复代码，在对具体的实体操作时，我们只需要把对应实体的实现继承BaseDaoImpl。
