hibernate的数据库访问例子收集

Hibernate 是一种强大，高性能的以对象到关系型数据库的持久化服务．开发人员可以基础语言
（包括关联，继承，多态，组合及java的集合框架），开发持久层．
====================================需要导入的Hibernate类包======================================
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.ProjectionList;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;

==================================创建启动配置文件对象和会话工厂对象===============================
 private static Configuration configuration;
 private static SessionFactory sessionFactory;
 static {
  try
  {
   configuration=new Configuration();//创建启动配置文件对象
   configuration.configure("firsthibernate/hibernate.cfg.xml");//对应配置文件路径
   sessionFactory=configuration.buildSessionFactory();//创建会话实例
  }catch(Exception ex)
  {
   ex.printStackTrace();
  }
 }

==================================将持久化对象保存到数据库========================================
首先实例化一个持久化对象，然后设置持久化对象setXXX方法，最后调用事务处理方法
 public void saveStudents(Students students) throws Exception
 {
  Session session =sessionFactory.openSession();//启动一个会话对象用来保存用户会话信息
  Transaction transaction=null;//定义事务对象
  try
  {
   transaction=session.beginTransaction();//使用会话对象的方法，创建事务
   session.save(students);//save方法用来将持久化对象信息保存到数据库
   transaction.commit(); //提交事务，执行查询语句
  }catch(Exception ex)
  {
   if (transaction!=null)
   {
    transaction.rollback();//回滚事务，撤消查询语句
   }
   throw ex;
  }
  finally
  {
   session.close();//关闭会话状态，清空资源
  }
 }
==================================查询数据对象类的条件查询语句====================================
 public List findAllStudents() throws Exception
 {
  Session session =sessionFactory.openSession();//启动一个会话对象用来保存用户会话信息
  Transaction transaction=null;//定义事务对象
  Query qu=null;  //Hibernate 查询接口，能够执行复杂的HQL查询语句
  List studentsList=null; //用来保存所有的持久化类对象，数据的集合
  try
  {
   transaction =session.beginTransaction();//使用会话对象的方法，创建事务
   qu=session.createQuery("from Students where Age=?");//使用会话对象的方法，创建查询接口对象
   //注意:这里Students是持久化类对象，而非数据库表名，Age对应持久化对象的属性
   qu.setInteger(0, new Integer(12));//设置一个Integer类型的查询条件参数
   studentsList=qu.list();//获取持久化对象信息,以List集合的方式返回信息
   transaction.commit();//提交事务，执行查询语句
  }
  catch(Exception ex)
  {
   if (transaction!=null)
   {
    transaction.rollback();//回滚事务，撤消查询语句
   }
   throw ex;
  }
  finally
  {
   session.close();//关闭会话状态，清空资源
  }
  return studentsList;
 }

===================================删除持久化对象信息===============================================
删除时需要先查询出持久化对象的所有信息，最后调用事务处理方法
 public void deleteInfo(Students student) throws Exception
 {
  Session session =sessionFactory.openSession();//启动一个会话对象用来保存用户会话信息
  Transaction transaction=null;//定义事务对象
  try
  {
   transaction=session.beginTransaction();//使用会话对象的方法，创建事务
   session.delete(student);//delete用来删除持久对象所对应的数据库中的记录
   transaction.commit(); //提交事务，执行查询语句    
  }
  catch(Exception ex)
  {
   if (transaction!=null)
   {
    transaction.rollback();//回滚事务，撤消查询语句
   }
   throw ex;
  }
  finally
  {
   session.close();//关闭会话状态，清空资源
  }
 }
===================================更新持久化对象信息===================================================
修改时需要先查询出持久化对象的所有信息，然后再修改持久化对象的setXXX方法，最后调用事务处理方法
 public void updateInfo(Students student) throws Exception
 {
  Session session =sessionFactory.openSession();//启动一个会话对象用来保存用户会话信息
  Transaction transaction=null;//定义事务对象
  try
  {
   transaction=session.beginTransaction();//使用会话对象的方法，创建事务
   session.update(student);//udpate方法根据持久化对象的标实符来更新持久化对象所对应的数据库数据
   transaction.commit();//提交事务，执行查询语句
  }catch(Exception ex)
  {
   if (transaction!=null)
   {
    transaction.rollback();
   }
   throw ex;
  }
  finally
  {
   session.close();//回滚事务，撤消查询语句
  }
 }

=======================================查询持久化对象的所有信息===============================================
   transaction=session.beginTransaction();//创建事务,获取开始会话的事务对象
   query=session.createQuery("from Students");//查询出所有的持久化对象信息,方案1
   
   /*query=session.createQuery("from Students s where s.name=? and s.age=?");//按姓名和年龄查询持久化对象，方案2
   query.setString(0, "XiaoHong");  //对应HQL语句中条件值？，根据属性类型，从0参数开始
   query.setInteger(1, new Integer(20));//对应HQL语句中条件值？，根据属性类型,参数1*/
   
   /*query=session.createQuery("from Students s where s.name=:setName and s.age=:setAge");//以:号定义查询参数,方案3
   query.setString("setName", "Tom");  //对应HQL语句中条件参数setName，对应属性类型
   query.setInteger("setAge", new Integer(18));//对应HQL语句中条件参数setAge，对应属性类型*/
   
   //对查询结果进行排序
   //query=session.createQuery("from Students s order by s.name asc");//按姓名对查询结果排序，方案4
   
   //query=session.createQuery("from Students s order by s.name desc");//按姓名对查询结果进行降序，方案5
   
   //对查询结果进行混合排序
   //该混合查询只能以名称按升序的方式进行排序，按年龄降序的查询无效
   //query=session.createQuery("from Students s order by s.name asc,s.age desc");//按姓名升序年龄降序的方式进行排序，方案6
   
   //对查询对果进行分页
   /*query=session.createQuery("from Students");//从起始结果开始，查询出５个满足条件的结果，方案7
   query.setFirstResult(0); //查询结果的起绐位置
   query.setMaxResults(5);  //查询出最多５个满足条件的结果*/
   
   /*query=session.createQuery("from Students");//从起始结果开始，查询出５个满足条件的结果，方案8
   query.setFirstResult(5); //查询结果的位置6开始
   query.setMaxResults(5);  //查询出最多５个满足条件的结果*/
      
   //查询年龄在20岁到30岁之间的学生,方案13
   //query=session.createQuery("from Students s where s.age between 17 and 30");
   
   //查询名称为Andy或Tom或Jian名称的学生，方案14
   //query=session.createQuery("from Students s where s.name in ('Andy','Tom','Jian'))");
   
   //字符串区配运算符（like)
   //查询A开头y结尾的学生信息,方案15
   //query=session.createQuery("from Students s where s.name like 'A%y'");
   
   //查询名称为An开头，长度为４的学生信息,方案16
   //query=session.createQuery("from Students s where s.name like 'An__'");
   
   //对查询结果去掉重复项，方案17
   //query=session.createQuery("select distinct s.name from Students s");

   //分组查询
   //分组查询年龄相同的学生
   //query=session.createQuery("select s.age,count(s.id) from Students s group by s.age");
   
   //加上条件的分组查询年龄相同的学生
   query=session.createQuery("select s.age,count(s.id) from Students s group by s.age having(s.age<20)");
   
   objectList=query.list();//获取查询的持久化对象信息，以集合的方式返回
   Iterator iterator=objectList.iterator();
   while (iterator.hasNext())    
   {
    Object[] obj=(Object[])iterator.next();
    Integer age=(Integer)obj[0];
    Integer count=(Integer)obj[1];
    System.out.println("年龄:"+age+"/t数量:"+count);
   }
   
   //objectList=query.list();//获取查询的持久化对象信息，以集合的方式返回
   transaction.commit();//提交事务，执行数据库操作

===========================================查询持久化对象的单个信息===============================================
   transaction=session.beginTransaction();//创建事务,获取开始会话的事务对象
   //查询持久化对象的单个信息,方案10
   /*query=session.createQuery("from Students");
   query.setMaxResults(1); //查询出最多一个满足条件的结果
   student=(Students)query.uniqueResult();//查询出单个持久化对象信息*/
   
   //查询名称为tom的学生，名称不区分大小,方案11
   /*query=session.createQuery("from Students s where lower(s.name)='tom'");
   query.setMaxResults(1); //查询出最多一个满足条件的结果
   student=(Students)query.uniqueResult();//查询出单个持久化对象信息*/
   
   //查询名称为tom的学生，名称不区分大小,方案12
   query=session.createQuery("from Students s where upper(s.name)='tom'");
   query.setMaxResults(1); //查询出最多一个满足条件的结果
   student=(Students)query.uniqueResult();//查询出单个持久化对象信息

   //设置结果集为１,返回一满足条件的对象
   Criteria criteria=session.createCriteria(Students.class);
   criteria.setMaxResults(1);
   student=(Students)criteria.uniqueResult();//查询出单个持久化对象信息
   
   
   transaction.commit();//提交事务，执行数据库操作

============================================QBC查询方式======================================================
 public List qbcInfo()
 {
  Session session=sessionFactory.openSession();//创建会话对象，用来保存持久化对象的信息
  Transaction transaction=null;
  Query query=null;//查询接口对象
  List objectList=null;
  try
  {
   transaction=session.beginTransaction();//创建事务,获取开始会话的事务对象
   //QBC查询方式，以持久类为对象查询
   //Criteria criteria=session.createCriteria(Students.class);
   
   //以学生名升序年龄降序的方式进行排序  
   //criteria.addOrder(Order.asc("name"));
   //criteria.addOrder(Order.desc("age"));
   
   //分页查询结果,从第６个查询结果开始，查询满足条件的最多５个参数
   //criteria.setFirstResult(5);
   //criteria.setMaxResults(5);
   
   //查询学生名为Andy的持久化对象   
   //criteria.add(Restrictions.eq("name", "Andy"));
   
   //查询年龄在17岁到20岁之间的持久化对象信息
   //criteria.add(Restrictions.gt("age", new Integer(17)));
   //criteria.add(Restrictions.lt("age", new Integer(20)));
   
   //查询年龄等于２0或者为Null的持久化对象
   //criteria.add(Restrictions.or(Restrictions.eq("age", new Integer(20)),
   //   Restrictions.isNull("age")));
   
   //查询学生的平均年龄
   /*criteria.setProjection(Projections.avg("age"));        
   objectList=criteria.list(); 
   Iterator iterator=objectList.iterator();
   Object obj=(Object)iterator.next();    
   System.out.println("平均年龄为:"+obj);*/
   
   //对年龄进行分组查询
   ProjectionList projectionList=Projections.projectionList();
   projectionList.add(Projections.groupProperty("age"));//以年龄进行分组
   projectionList.add(Projections.rowCount()); //统计人数
   Criteria criteria=session.createCriteria(Students.class);
   criteria.setProjection(projectionList);//查询每个年龄各有多少人      
   objectList=criteria.list(); 
   Iterator iterator=objectList.iterator();
   while (iterator.hasNext())
   {
    Object[] obj=(Object[])iterator.next();
    System.out.println("分组年龄:"+obj[0]+"/t人数:"+obj[1]);
   }
   
   transaction.commit();//提交事务，执行数据库操作 
  }

============================================（关联映射）内连接查询==================================================
 public static List selectInfo(){
  Session session=getSession();
  Transaction transaction=null;
  Query query=null;
  List studentsList=null;
  try{
   transaction=session.beginTransaction();
   query=session.createQuery("from Booklist b inner join b.students s where b.booklistIndex<3");
   studentsList=query.list();
   Iterator iterator=studentsList.iterator();
   while (iterator.hasNext()){
    Object[] objList=(Object[])iterator.next();   
    Booklist booklists=(Booklist)objList[0];
    Students student=(Students)objList[1];
    System.out.print("借书ID:"+booklists.getId()+"/t借书数量:"+booklists.getBooklistIndex());
    System.out.println("学员Id:"+student.getId()+"/t学员姓名:"+student.getName()+"/t学员年龄:"+student.getAge());
   }
   transaction.commit();   
  }catch(Exception ex){
   if (transaction!=null){
    transaction.rollback();
   }
   ex.printStackTrace();
  }finally{
   closeSession();
  }
  return studentsList;
 }
=========================================hibernate中执行SQL====================================
import org.hibernate.SQLQuery;
import org.hibernate.Session;

SQLQuery query1=session.createSQLQuery(sql1); //执行第1个SQL
int sun1=query1.executeUpdate();