hibernate学习笔记6--Criteria查询方式、完整小练习（开发步骤）

一、Criteria查询方式
没有sql语了，因此更加面向对象一些。
Criteria是一种比HQL更面向对象的查询方式；Criteria的创建方式：
 Criteria c = s.createCriteria(DomainClass.class);
 简单属性条件如：c.add(Restrictions.eq(propertyName, name));
 c.add(Restrictions.eqProperty(propertyName, otherpropertyName));

[java] view plaincopyprint?
 
  1. package cn.itcast.hibernate;  
  2.   
  3. import java.util.Date;  
  4. import java.util.List;  
  5.   
  6. import org.hibernate.Criteria;  
  7. import org.hibernate.Session;  
  8. import org.hibernate.criterion.Restrictions;  
  9.   
  10. import cn.itcast.hibernate.domain.User;  
  11.   
  12. public class Cri {  
  13.   
  14.     /** 
  15.      * 使用Criteria根据name查询方法 
  16.      * @param entity 
  17.      */  
  18.     public static void Cri(String name){  
  19.           
  20.         Session s = null;  
  21.         try {  
  22.             s=HIbernateUtil.getSession();  
  23.             //使用Criteria接口  
  24.             Criteria c = s.createCriteria(User.class);  
  25.             //对查询添加限制条件，相当于where子句。"name"必须是类中具有的属性  
  26.             //Criteria相当于一个容器，约束可以一直加  
  27.             c.add(Restrictions.eq("name", name)); //等于  
  28. //          c.add(Restrictions.gt("birthday",new Date())); // 大于  
  29.             c.add(Restrictions.lt("birthday",new Date())); // 小于  
  30.             //以上条件之间是and的连接方式，当然也可以用一下的or连接方式  
  31. //          c.add(Restrictions.or(lhs, rhs));or 两个条件  
  32.               
  33.             //Criteria实现分页，hql的方法名基本相同  
  34.             c.setFirstResult(0);// 从哪条开始取  
  35.             c.setMaxResults(10);// 共取多少条  
  36.             List<User> list=c.list(); //executQuery();   
  37.             for(User user:list){  
  38.                 System.out.print(user.getName());  
  39.             }  
  40.               
  41.             //如果确定数据最多只有一条，可以使用一下的方法简化代码  
  42.             User u= (User)c.uniqueResult();  
  43.             System.out.print("只有一条数据"+u.getName());  
  44.         } finally {  
  45.             if(s!=null){  
  46.                 s.close();  
  47.             }  
  48.         }  
  49.     }  
  50.     /** 
  51.      * @param args 
  52.      */  
  53.     public static void main(String[] args) {  
  54.         Cri("你妹");  
  55.   
  56.     }  
  57.   
  58. }  


 

二、小练习（一个各层的完整开发步骤）

1.完整开发步骤

2.实现功能（实现接口方法）

下面具体例子代码：

接口类：

[java] view plaincopyprint?
 
  1. package cn.itcast.dao;  
  2.   
  3. import cn.itcast.domain.User;  
  4.   
  5. public interface UserDao {  
  6.     public void saveUser(User user);  
  7.     public User findUserByName(String name);  
  8.     public User findUserById(int id);  
  9.     public void updateUser(User user);  
  10.     public void remove(User user);  
  11. }  

工具类：获取session

[java] view plaincopyprint?
 
  1. package cn.itcast.dao;  
  2.   
  3. import org.hibernate.Session;  
  4. import org.hibernate.SessionFactory;  
  5. import org.hibernate.cfg.Configuration;  
  6. /** 
  7.  *（1）不想让其他类继承工具类 
  8.  *（2）不能让它创建对象，所以属性全部private，还得有个private的无参数构造 
  9.  * @author Mars 
  10.  * 
  11.  */  
  12. public final class HibernateUtil {  
  13.     private static SessionFactory sessionFactory;  
  14.       
  15.     private HibernateUtil(){  
  16.           
  17.     }  
  18.     /** 
  19.      * 细节1：Configuration:是一个配置类 
  20.      * Configuration的对象会找hibernate.cfg.xml，完成hibernate的初始化 
  21.      * 
  22.      * 细节2：hibernate的配置文件有两种hibernate.cfg.xml和hibernate.properties 
  23.      * 两种存在一种即可，当然如果都存在的话，hibernate.cfg.xml中的配置信息会覆盖hibernate.properties的配置信息 
  24.      */  
  25.     static{  
  26.         //1。读取并解析配置文件  
  27.         Configuration cfg = new Configuration();  
  28.         //如果hibernate.cfg.xml不是放在类路径下，就需要此时指定路径  
  29.         //cfg.configure("filename");  
  30.         cfg.configure();  
  31.         //可以使用代码来设置配置信息，但是不便于管理，不建议使用  
  32.         //cfg.setProperty("hibernate.connection.driver_class", "oracle.jdbc.driver.OracleDriver");  
  33.         //2。读取并解析映射信息，创建SessionFactory  
  34.         //所有的配置信息都可以在SessionFactory中找到，映射文件的信息都能找到  
  35.         sessionFactory = cfg.buildSessionFactory();  
  36.     }  
  37.     /** 
  38.      * 获取session 
  39.      * @return 
  40.      */  
  41.     public static Session getSession(){  
  42.         //  3。打开Session  
  43.         return sessionFactory.openSession();  
  44.     }  
  45.       
  46.     /** 
  47.      * 获取SessionFactory对象 
  48.      * @return 
  49.      */  
  50.     public static SessionFactory getSessionFactory(){  
  51.         return sessionFactory;  
  52.     }  
  53. }  

接口的实现类：

[java] view plaincopyprint?
 
  1. package cn.itcast.dao.imp;  
  2.   
  3.   
  4.   
  5. import org.hibernate.Criteria;  
  6. import org.hibernate.Query;  
  7. import org.hibernate.Session;  
  8. import org.hibernate.Transaction;  
  9. import org.hibernate.criterion.Restrictions;  
  10.   
  11. import cn.itcast.dao.HibernateUtil;  
  12. import cn.itcast.dao.UserDao;  
  13. import cn.itcast.domain.User;  
  14.   
  15. public class UserDaoHibernateImpl implements UserDao {  
  16.   
  17.     /** 
  18.      * 根据id查询user 
  19.      */  
  20.     public User findUserById(int id) {  
  21.         //因为是查询所以可以不用开启事务  
  22.         Session s = null;  
  23.         try {  
  24.             s = HibernateUtil.getSession();  
  25.             //User.class不可随便放，必须靠这个指定来找相应的映射文件  
  26.             //此处不能使用懒加载s.load(arg0, arg1),会报错，详见后续文章  
  27.             User user = (User)s.get(User.class, id);  
  28.             return user;  
  29.         } finally {  
  30.             if(s!=null){  
  31.                 s.close();  
  32.             }  
  33.         }  
  34.     }  
  35.   
  36.     /** 
  37.      * 根据姓名获取user 
  38.      */  
  39.     public User findUserByName(String name) {  
  40.         Session s = null;  
  41.         try {  
  42.             s=HibernateUtil.getSession();  
  43.             Criteria c =  s.createCriteria(User.class);  
  44.             c.add(Restrictions.eq("name", name));  
  45.             User user = (User)c.uniqueResult();  
  46.             return user;  
  47.         } finally{  
  48.             if(s!=null){  
  49.                 s.close();  
  50.             }  
  51.         }  
  52.           
  53.           
  54.     }  
  55.     /** 
  56.      * 通过hql根据姓名获取user 
  57.      */  
  58.     public User findUserByNamehql(String name) {  
  59.         Session s = null;  
  60.         try {  
  61.             s=HibernateUtil.getSession();  
  62.             String hql = "from User as user where user.name=:n";  
  63.             Query q =  s.createQuery(hql);  
  64.             q.setString("n",name);  
  65.             User user = (User)q.uniqueResult();  
  66.             return user;  
  67.         } finally{  
  68.             if(s!=null){  
  69.                 s.close();  
  70.             }  
  71.         }  
  72.           
  73.           
  74.     }  
  75.       
  76.     /** 
  77.      * 删除方法：必须开启事务 
  78.      */  
  79.     public void remove(User user) {  
  80.         Session s = null;  
  81.         Transaction tx =null;  
  82.           
  83.         try {  
  84.             s=HibernateUtil.getSession();  
  85.             tx=s.beginTransaction();  
  86.             s.delete(user);  
  87.             tx.commit();  
  88.         } finally{  
  89.             if(s!=null){  
  90.                 s.close();  
  91.             }  
  92.         }  
  93.     }  
  94.   
  95.     /** 
  96.      * 删除方法测试：只穿id的话能否成功删除 
  97.      */  
  98.     public void remove(int id) {  
  99.         Session s = null;  
  100.         Transaction tx =null;  
  101.         User user = new User();  
  102.         user.setId(id);  
  103.         try {  
  104.             s=HibernateUtil.getSession();  
  105.             tx=s.beginTransaction();  
  106.             s.delete(user);  
  107.             tx.commit();  
  108.         } finally{  
  109.             if(s!=null){  
  110.                 s.close();  
  111.             }  
  112.         }  
  113.     }  
  114.       
  115.     /** 
  116.      * 保存对象 
  117.      */  
  118.     public void saveUser(User user) {  
  119.         Session s = null;  
  120.         Transaction tx =null;  
  121.           
  122.         try {  
  123.             s=HibernateUtil.getSession();  
  124.             tx=s.beginTransaction();  
  125.             s.save(user);  
  126.             tx.commit();  
  127.         } finally{  
  128.             if(s!=null){  
  129.                 s.close();  
  130.             }  
  131.         }  
  132.     }  
  133.   
  134.     /** 
  135.      * 更新对象 
  136.      */  
  137.     public void updateUser(User user) {  
  138.         Session s = null;  
  139.         Transaction tx =null;  
  140.           
  141.         try {  
  142.             s=HibernateUtil.getSession();  
  143.             tx=s.beginTransaction();  
  144.             s.update(user);  
  145.             tx.commit();  
  146.         } finally{  
  147.             if(s!=null){  
  148.                 s.close();  
  149.             }  
  150.         }  
  151.   
  152.     }  
  153.   
  154.     /** 
  155.      * @param args 
  156.      */  
  157.     public static void main(String[] args) {  
  158.         // TODO Auto-generated method stub  
  159.   
  160.     }  
  161.   
  162. }  


dimain：

[java] view plaincopyprint?
 
  1. package cn.itcast.domain;  
  2.   
  3. import java.util.Date;  
  4.   
  5. public class User {  
  6.     private int id;  
  7.     private String name;  
  8.     private Date birthday;  
  9.     public int getId() {  
  10.         return id;  
  11.     }  
  12.     public void setId(int id) {  
  13.         this.id = id;  
  14.     }  
  15.     public String getName() {  
  16.         return name;  
  17.     }  
  18.     public void setName(String name) {  
  19.         this.name = name;  
  20.     }  
  21.     public Date getBirthday() {  
  22.         return birthday;  
  23.     }  
  24.     public void setBirthday(Date birthday) {  
  25.         this.birthday = birthday;  
  26.     }  
  27.       
  28. }  

映射文件：

[html] view plaincopyprint?
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC  
  3.         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.         "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="cn.itcast.domain">  
  6.     <class name="User" table="tb_user">  
  7.         <!-- 对象标示符，类型可以不写，hibernate自己识别 -->  
  8.         <id name="id" column="id">  
  9.             <!-- 指定主键生成方式。  
  10.         native根据方言判定生成主键的方式  
  11.          -->  
  12.              <generator class="native"/>   
  13.         </id>  
  14.           
  15.         <property name="name" column="name" unique="true" not-null="true"/><!--标示name唯一性,非空的限制 -->  
  16.         <property name="birthday"  />  
  17.     </class>  
  18.   
  19.   
  20. </hibernate-mapping>  


下面就是简单粗暴的测试类：

[java] view plaincopyprint?
 
  1. package cn.itcast;  
  2.   
  3. import java.util.Date;  
  4.   
  5. import cn.itcast.dao.UserDao;  
  6. import cn.itcast.dao.imp.UserDaoHibernateImpl;  
  7. import cn.itcast.domain.User;  
  8.   
  9. public class DaoText {  
  10.   
  11.     /** 
  12.      * 模拟业务逻辑层在使用数据访问层的东西 
  13.      */  
  14.     public static void main(String[] args) {  
  15.         UserDao dao = new UserDaoHibernateImpl();  
  16.         UserDaoHibernateImpl daoimp = new UserDaoHibernateImpl();  
  17.         User user = new User();  
  18.         user.setName("nimei");  
  19.         user.setBirthday(new Date());  
  20.         System.out.println("1111");  
  21.         dao.saveUser(user);  
  22.           
  23.         int id = dao.findUserByName("nimei").getId();  
  24.         System.out.println("id: "+id);  
  25.         user.setName("new name");  
  26.         System.out.println("2222");  
  27.         dao.updateUser(user);  
  28.           
  29.         //User u = dao.findUserByName(user.getName());  
  30.           
  31.         System.out.println("3333");  
  32.         //dao.remove(user);  
  33.         //封装的对象只封装如id和非空字段，实施删除测试  
  34.         //daoimp.remove(id);  
  35.           
  36.         //封装的对象只封装如id和非空字段，实施更新测试  
  37.         User user2 = new User();  
  38.         user2.setId(id);  
  39.         user2.setName("涅米");  
  40.         dao.updateUser(user2);  
  41.     }  
  42.   
  43. }  

 

备注：

备注1：对于方言可以不添加，hibernate在启动时会自行进行测试匹配，一般都能识别出相应的数据库，但是最好还是加上。
<property>节点中的name属性中不要有在结尾处有空格

备注2：hibernante:不再是更新单列，完全面对的是对象，更新就是更新对象状态，删除就删除对象。
所以对于删除来说删除是根据id，只要将id和映射文件中不为空的字段封装入user即可，之后就可以轻松的调用remove();
例如：不满足映射文件
<property name="name" column="name" unique="true" not-null="true"/><!--标示name唯一性 ，非空的限制-->
则运行时报错。
以上有关于删除的规则，更新同样适用

备注3.hibernate对domain Object限制
（1）默认构造方法(必须的)
（2）有无意义的标示符id（主键）（可选）
（3）非fianl的，对懒加载有影响（可选）

posted @ 2015-05-11 22:04  tian830937  阅读(325)  评论(0)  编辑  收藏  举报