码迷，mamicode.com
首页 > Web开发 > 详细

hibernate学习笔记4---HQL、通用方法的抽取实现

时间：2015-05-11 23:30:50      阅读：138      评论：0      收藏：0      [点我收藏+]

标签：

一、通用方法的抽取实现
由于hibernate中对增删改查的一切操作都是面向对象的，所以将增删改查抽取成通用方法，以满足不同的表的增删改查操作，简化jdbc代码。
具体例子如下：
[java] view plaincopyprint?
 
  1. package cn.itcast.hibernate;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. import org.hibernate.Session;  
  6. import org.hibernate.SessionFactory;  
  7. import org.hibernate.Transaction;  
  8. import org.hibernate.cfg.Configuration;  
  9.   
  10. /* 
  11.  * 想让初始化创建只执行一次 
  12.  * 方式1：单例模式 
  13.  * 方式2: 静态语句块等 
  14.  *  
  15.  * 由于只想让初始化执行一次，不想让其他类继承所以此类用final修饰，不想被其他类初始化所以默认构造用private修饰,由于在静态语句块中所以加static 
  16.  *  
  17.  *  
  18.  */  
  19. public final class HIbernateUtil {  
  20.   
  21.   
  22.     private static SessionFactory sessionfactory;  
  23.     private HIbernateUtil(){  
  24.           
  25.     }  
  26.      /** 
  27.      * 细节1：Configuration:是一个配置类 
  28.      * Configuration的对象会找hibernate.cfg.xml，完成hibernate的初始化 
  29.      * 
  30.      * 细节2：hibernate的配置文件有两种hibernate.cfg.xml和hibernate.properties 
  31.      * 两种存在一种即可，当然如果都存在的话，hibernate.cfg.xml中的配置信息会覆盖hibernate.properties的配置信息 
  32.      *  
  33.      * 细节3：初始化工作只尽量只初始化一次，耗时 
  34.      */      
  35.     static {  
  36.         Configuration cfg = new Configuration();  
  37.         cfg.configure();  
  38.         //cfg.configure("filename"); 可以通过filename来指定配置文件的位置和配置文件名（如果不在默认classpath的位置下）  
  39.         //所用的src下的文件都会经行编译，最后字节码文件在classpath下，bin是classpath下的一部分  
  40.         sessionfactory = cfg.buildSessionFactory();  
  41.     }  
  42.     /* 
  43.      * 创建出对象，通过getter方法方便外接使用 
  44.      *  
  45.      */  
  46.     public static SessionFactory getSessionfactory() {  
  47.         return sessionfactory;  
  48.     }  
  49.       
  50.     /** 
  51.      * 此session包为org.hibernate.Session; 
  52.      * @return 
  53.      * 定义方法返回session,session你可以理解为jdbc的数据库连接 
  54.      */  
  55.     public static Session getSession(){  
  56.         return sessionfactory.openSession();  
  57.     }  
  58.     /** 
  59.      * 通用保存方法 
  60.      * @param entity 
  61.      */  
  62.     public static  void add(Object entity){  
  63.           
  64.         Session s = null;  
  65.         Transaction tx = null;  
  66.         try {  
  67.             s=HIbernateUtil.getSession();  
  68.             tx = s.beginTransaction();  
  69.             s.save(entity);  
  70.             tx.commit();  
  71.         } finally {  
  72.             if(s!=null){  
  73.                 s.close();  
  74.             }  
  75.         }  
  76.     }  
  77.       
  78.     /** 
  79.      * 通用更新方法 
  80.      * @param entity 
  81.      */  
  82.     public static  void update(Object entity){  
  83.           
  84.         Session s = null;  
  85.         Transaction tx = null;  
  86.         try {  
  87.             s=HIbernateUtil.getSession();  
  88.             tx = s.beginTransaction();  
  89.             s.update(entity);  
  90.             tx.commit();  
  91.         } finally {  
  92.             if(s!=null){  
  93.                 s.close();  
  94.             }  
  95.         }  
  96.     }  
  97.       
  98.     /** 
  99.      * 通用删除方法 
  100.      * @param entity 
  101.      */  
  102.     public static  void delete(Object entity){  
  103.           
  104.         Session s = null;  
  105.         Transaction tx = null;  
  106.         try {  
  107.             s=HIbernateUtil.getSession();  
  108.             tx = s.beginTransaction();  
  109.             s.delete(entity);  
  110.             tx.commit();  
  111.         } finally {  
  112.             if(s!=null){  
  113.                 s.close();  
  114.             }  
  115.         }  
  116.     }  
  117.       
  118.     /** 
  119.      * 通用根据ID查询方法 
  120.      * @param entity 
  121.      */  
  122.     public static  Object get(Class clazz,Serializable id){  
  123.           
  124.         Session s = null;  
  125.           
  126.         try {  
  127.             s=HIbernateUtil.getSession();  
  128.             Object obj = s.get(clazz, id);  
  129.             return obj;  
  130.         } finally {  
  131.             if(s!=null){  
  132.                 s.close();  
  133.             }  
  134.         }  
  135.     }  
  136. }  

二、HQL(Hibernate Query Language)
面向对象的查询语句，与sql不同，HQL中的对象名是区分大小写的（除了java类和属性其他部分不区分大小写）；HQL中查的是对象而不是和表，并且支持多态；
HQL主要通过Query来操作，QUery的创建方式：
Query q = session.createQuery(hql);
from Person
from User user where user.name = :name
from User user where user.name = :name and user.birthday <:birthday
 
 
sql查的是表，HQL查的是对象！
hibernate一切都是从对象出发,hql就是按照对象来查而不是表
[java] view plaincopyprint?
 
  1. package cn.itcast.hibernate;  
  2.   
  3. import java.util.Date;  
  4. import java.util.List;  
  5.   
  6. import org.hibernate.Query;  
  7. import org.hibernate.Session;  
  8.   
  9. import cn.itcast.hibernate.domain.User;  
  10.   
  11. public class QueryTest {  
  12.   
  13.       
  14.     /** 
  15.      * 使用HQL根据name查询方法 
  16.      * @param entity 
  17.      */  
  18.     public static void Query(String name){  
  19.           
  20.         Session s = null;  
  21.         try {  
  22.             s=HIbernateUtil.getSession();  
  23.             //HQL:  
  24.             //这里的from后面跟的不是表名，而是对象名（类名）  
  25.             String hql = "from User as user where user.name=?"; //from Object 支持多态度  
  26.             Query query = s.createQuery(hql);  
  27.             query.setString(0, name);  
  28.             List<User> list=query.list(); //executQuery();   
  29.             for(User user:list){  
  30.                 System.out.print(user.getName());  
  31.             }  
  32.               
  33.             //如果确定数据最多只有一条，可以使用一下的方法简化代码  
  34.             User u= (User)query.uniqueResult();  
  35.             System.out.print("只有一条数据"+u.getName());  
  36.         } finally {  
  37.             if(s!=null){  
  38.                 s.close();  
  39.             }  
  40.         }  
  41.     }  
  42.     /** 
  43.      * @param args 
  44.      */  
  45.     public static void main(String[] args) {  
  46.         User user = new User();  
  47.         user.setName("name");  
  48.         user.setBirthday(new Date());  
  49.         HIbernateUtil.add(user);  
  50.         Query(user.getName());  
  51.   
  52.     }  
  53.   
  54.       
  55. }  

String hql = "from Users as users where users.name = ?";切记用对象不要用表名

注意这句 users是Users的别名，

User是类名，不能直接使用User.name（不能通过类来访问，就好像你不能通过类名去访问实例变量一样。 
通常会用别名的方式解决，比如 
from Users as users where users.name = ?（别名就好像是test类的一个对象，通过对象就可以访问实例变量） 

当然，仅对一个类进行操作，也可以不借助于别名： 
from Users where name = ‘sdf‘

 

还可以用query.uniqueResult();用来返回单一的查询结果，务必确保查询结果唯一。

hibernate学习笔记4---HQL、通用方法的抽取实现

标签：

原文地址：http://www.cnblogs.com/tian830937/p/4495816.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！