zoukankan html css js c++ java

Hibernate的四种查询方式（主键查询，HQL查询，Criteria查询，本地sql查询）和修改和添加

Hibernate的添加，修改，查询（三种查询方式）的方法：

案例演示：

1：第一步，导包，老生常谈了都是，省略；

2：第二步，创建数据库和数据表,表结构如下所示：

3：第三步创建实体类User.java

 1 package com.bie.po;
 2 /** 
 3 * @author BieHongLi 
 4 * @version 创建时间：2017年3月8日 下午5:17:23 
 5 * 
 6 */
 7 public class User {
 8 
 9     private int id;
10     private String name;
11     private String password;
12     private String email;
13     private String phone;
14     public int getId() {
15         return id;
16     }
17     public void setId(int id) {
18         this.id = id;
19     }
20     public String getName() {
21         return name;
22     }
23     public void setName(String name) {
24         this.name = name;
25     }
26     public String getEmail() {
27         return email;
28     }
29     public void setEmail(String email) {
30         this.email = email;
31     }
32     public String getPhone() {
33         return phone;
34     }
35     public void setPhone(String phone) {
36         this.phone = phone;
37     }
38     public String getPassword() {
39         return password;
40     }
41     public void setPassword(String password) {
42         this.password = password;
43     }
44     @Override
45     public String toString() {
46         return "User [id=" + id + ", name=" + name + ", password=" + password + ", email=" + email + ", phone=" + phone
47                 + "]";
48     }
49     
50     
51 }

4：第四步，完成实体类的属性和数据表字段的映射，映射的.xml如下所示，前面的博客已经介绍如何写这个映射，这里略过；

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC 
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5     
 6 <hibernate-mapping package="com.bie.po"> 
 7     <!-- 操作条件：
 8         1：对象与表
 9         2：属性与字段的对应
10         3：类型的对应,类型默认采用属性的类型，type不写的话
11      -->
12     <class name="User" table="user">
13         <!-- 主键，映射 -->
14         <id name="id" column="id">
15             <generator class="native"></generator>
16         </id>
17         
18         <!-- 非主键，映射 -->
19         <property name="name" column="name"></property>
20         <property name="password" column="password"></property>
21         <property name="email" column="email"></property>
22         <property name="phone" column="phone"></property>
23         
24         
25     </class>
26 
27 </hibernate-mapping>

5：映射之后写Hibernate的配置文件，配置文件如下所示：

 1 <!DOCTYPE hibernate-configuration PUBLIC
 2     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 3     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 4 
 5 <hibernate-configuration>
 6     <session-factory>
 7         <!-- 
 8             1:数据连接配置
 9             2:加载所有的映射（*.hbm.xml）
10          -->
11          
12          <!-- 1:数据连接配置 -->
13          <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
14          <property name="hibernate.connection.url">jdbc:mysql:///test</property>
15          <property name="hibernate.connection.username">root</property>
16          <property name="hibernate.connection.password">123456</property>
17          <!-- mysql数据库的方言 -->
18          <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
19          
20          <property name="hibernate.show_sql">true</property>
21          
22          <!-- 2:加载所有的映射（*.hbm.xml） -->
23          <mapping resource="com/bie/po/User.hbm.xml"/>
24          
25     </session-factory>
26 </hibernate-configuration>

6：完成上面的之后写测试的类即可；

　　6.1：首先实现Hibernate的插入操作《session.save(user)》：

　　　　核心代码：

　　　        //获取加载配置文件的管理类对象
                  Configuration config=new Configuration();
                  //默认加载src/hibernate.cfg.xml文件
                  config.configure();
                 //创建session的工厂文件
                 SessionFactory sf=config.buildSessionFactory();
                //创建session（代表一个会话，与数据库连接的会话）
          Session session=sf.openSession();
                //开启事务
                Transaction tx=session.beginTransaction();
                //保存到数据库
                session.save(user);
                //提交事务
                tx.commit();
                //关闭
                session.close();
                //sessionFactory关闭
               sf.close();

源码如下所示：

 1 package com.bie.test;
 2 
 3 import org.hibernate.Session;
 4 import org.hibernate.SessionFactory;
 5 import org.hibernate.Transaction;
 6 import org.hibernate.cfg.Configuration;
 7 import org.junit.Test;
 8 
 9 import com.bie.po.User;
10 
11 /** 
12 * @author BieHongLi 
13 * @version 创建时间：2017年3月8日 下午5:28:35 
14 * 
15 */
16 public class HelloTest {
17 
18     @Test
19     public void testHello(){
20         //对象
21         User user=new User();
22         user.setName("张三");
23         user.setPassword("123456");
24         user.setEmail("1748741329@qq.com");
25         user.setPhone("15236083005");
26         
27         //获取加载配置文件的管理类对象
28         Configuration config=new Configuration();
29         //默认加载src/hibernate.cfg.xml文件
30         config.configure();
31         //创建session的工厂文件
32         SessionFactory sf=config.buildSessionFactory();
33         //创建session（代表一个会话，与数据库连接的会话）
34         Session session=sf.openSession();
35         //开启事务
36         Transaction tx=session.beginTransaction();
37         //保存到数据库
38         session.save(user);
39         //提交事务
40         tx.commit();
41         //关闭
42         session.close();
43         //sessionFactory关闭
44         sf.close();
45     
46         
47     }
48 }

演示效果如下所示：

　　6.2：实现Hibernate的修改操作，核心代码《session.saveOrUpdate(user); session.update(user);这个就不演示了，用法一样，将他们替换一下即可，只是saveOrUpdate更加强大的说》：

　　 session.saveOrUpdate(user);

　　　　　这个实现的是如果没有实体类的编号就执行保存操作，如果有实体类的编号就执行修改操作；

　　　　设计Hibernate框架的人太TMD有才了，当然这是夸赞，大大简化了我们对数据库的操作，必须赞一个；

源码如下所示：

 1 package com.bie.test;
 2 
 3 import org.hibernate.Session;
 4 import org.hibernate.SessionFactory;
 5 import org.hibernate.Transaction;
 6 import org.hibernate.cfg.Configuration;
 7 import org.junit.Test;
 8 
 9 import com.bie.po.User;
10 
11 /** 
12 * @author BieHongLi 
13 * @version 创建时间：2017年3月8日 下午5:28:35 
14 * 
15 */
16 public class HelloTest2 {
17 
18     //SessionFactory代表整个配置文件，所以没必要加载多次，放到全局即可
19     private static SessionFactory sf;
20     static{
21         //1:创建配置管理类对象
22         Configuration config=new Configuration();
23         //加载配置文件，(默认加载/src/hibernate.cfg.xml)
24         config.configure();
25         
26         //2：根据加载的配置管理类对象，创建SessionFactory对象
27         sf=config.buildSessionFactory();
28         
29         //简介写法，写到一行里面
30         //sf=new Configuration().configure().buildSessionFactory();
31     }
32     @Test
33     public void testHello(){
34         //对象
35         User user=new User();
36         user.setId(1);
37         user.setName("李四22222");
38         user.setPassword("222222");
39         user.setEmail("22222222@qq.com");
40         user.setPhone("15236083005");
41         
42         //3:根据sesson的工厂创建session对象
43         Session session = sf.openSession();
44         
45         //开启事务
46         Transaction tx = session.beginTransaction();
47         //执行操作
48         //session.save(user);
49         session.saveOrUpdate(user);
50         
51         //提交事务
52         tx.commit();
53         //关闭事务
54         session.close();
55         sf.close();
56     }
57     
58 }

演示结果如下所示：

　　6.3：实现Hibernate的查询操作：

　　　　6.3.1：主键查询的方法

　　　　　　两种方法：

　　　　　　　User u=(User)session.get(User.class, 1);
　　　　User u=(User)session.load(User.class, 1);支持懒加载

源码如下所示：

 1 package com.bie.test;
 2 
 3 import org.hibernate.Session;
 4 import org.hibernate.SessionFactory;
 5 import org.hibernate.Transaction;
 6 import org.hibernate.cfg.Configuration;
 7 import org.junit.Test;
 8 
 9 import com.bie.po.User;
10 
11 /** 
12 * @author BieHongLi 
13 * @version 创建时间：2017年3月9日 下午8:47:46 
14 * Hibernate查询的几种方式：
15 *     
16 */
17 public class SelectTest {
18 
19     //全局静态session工厂
20     private static SessionFactory sf;
21     static{
22         //1：创建sesson工厂
23         sf=new Configuration().configure().buildSessionFactory();
24     }
25     
26     @Test
27     public void select(){
28         User user=new User();
29         
30         //2：根据session工厂创建session
31         Session session=sf.openSession();
32         //3：开启事务
33         Transaction tx=session.beginTransaction();
34         //4：主键查询，执行查询操作，方法一：get方法，方法2：load方法
35         //User u=(User)session.get(User.class, 1);
36         User u=(User)session.load(User.class, 1);
37         
38         //主键查询测试结果
39         System.out.println(u);
40         //5：提交事务
41         tx.commit();
42         //6：关闭事务和session
43         session.close();
44         sf.close();
45         
46     }
47     
48 }

演示效果如下所示：

　　6.3.2：HQL查询，特别注意的是查询语句必须是实体类的方法名，不能是表名称，必须和sql语句查询区别：

　　　　HQL查询和sql查询的区别：

　　　　　　（1）：sql查询是表以及字段，不区分大小写，也叫做结构化的查询语句；

　　　　　　（2）：HQL查询是Hibernate提供的面向对象的查询语句，查询的是对象以及对象的属性，区分大小写的。

源码如下所示：

 1 package com.bie.test;
 2 
 3 
 4 
 5 import java.util.List;
 6 
 7 import org.hibernate.Query;
 8 import org.hibernate.Session;
 9 import org.hibernate.SessionFactory;
10 import org.hibernate.Transaction;
11 import org.hibernate.cfg.Configuration;
12 import org.junit.Test;
13 
14 import com.bie.po.User;
15 
16 /** 
17 * @author BieHongLi 
18 * @version 创建时间：2017年3月9日 下午8:47:46 
19 * Hibernate查询的几种方式：
20 *     
21 */
22 public class SelectTest2 {
23 
24     //全局静态session工厂
25     private static SessionFactory sf;
26     static{
27         //1：创建sesson工厂
28         sf=new Configuration().configure().buildSessionFactory();
29     }
30     
31     @Test
32     public void select(){
33         User user=new User();
34         
35         //2：根据session工厂创建session
36         Session session=sf.openSession();
37         //3：开启事务
38         Transaction tx=session.beginTransaction();
39         
40         //HRL查询，查询全部信息，注意HRL查询的是实体类的名称，不是数据表的名称，特别注意这一点
41         //Query q=session.createQuery("from User");
42         Query q=session.createQuery("from User user where user.id=1 or user.id=2 ");
43         
44         List<User> list=q.list();
45         System.out.println(list);
46         
47         //5：提交事务
48         tx.commit();
49         //6：关闭事务和session
50         session.close();
51         sf.close();
52         
53     }
54     
55 }

效果如下所示：

　6.3.3：完全面向对象的查询，Criteria查询也叫做 QBC查询 query by criteria

　　　核心代码：　　　

　　　　　 //Criteria查询也叫做 QBC查询   query by criteria
       　　　//完全的面向对象的查询
       　　    Criteria criteria = session.createCriteria(User.class);
       　　    //添加条件
       　　   criteria.add(Restrictions.eq("id", 1));
       　　   //查询全部，没有sql语句
       　　   List<User> list = criteria.list();
       　　    System.out.println(list);

源码如下所示：

 1 package com.bie.test;
 2 
 3 
 4 
 5 import java.util.List;
 6 
 7 import org.hibernate.Criteria;
 8 import org.hibernate.Session;
 9 import org.hibernate.SessionFactory;
10 import org.hibernate.Transaction;
11 import org.hibernate.cfg.Configuration;
12 import org.hibernate.criterion.Restrictions;
13 import org.junit.Test;
14 
15 import com.bie.po.User;
16 
17 /** 
18 * @author BieHongLi 
19 * @version 创建时间：2017年3月9日 下午8:47:46 
20 * Hibernate查询的几种方式：
21 *     
22 */
23 public class SelectTest3 {
24 
25     //全局静态session工厂
26     private static SessionFactory sf;
27     static{
28         //1：创建sesson工厂
29         sf=new Configuration().configure().buildSessionFactory();
30     }
31     
32     @Test
33     public void select(){
34         User user=new User();
35         
36         //2：根据session工厂创建session
37         Session session=sf.openSession();
38         //3：开启事务
39         Transaction tx=session.beginTransaction();
40         
41         //Criteria查询也叫做 QBC查询   query by criteria 
42         //完全的面向对象的查询
43         Criteria criteria = session.createCriteria(User.class);    
44         //添加条件
45         criteria.add(Restrictions.eq("id", 1));
46         
47         //查询全部，没有sql语句
48         List<User> list = criteria.list();
49     
50         
51         System.out.println(list);
52         
53         //5：提交事务
54         tx.commit();
55         //6：关闭事务和session
56         session.close();
57         sf.close();
58         
59     }
60     
61 }

演示效果如下所示：

　　6.3.4：本地查询sql语句，适合使用复杂的查询，或者不想使用HQL或者criteria查询，可以使用本地sql查询，缺点，不能跨越数据库，一般不适用，除非遇到复杂的sql语句才使用：

　　　　核心代码：

　　　　　 //sql语句
       　　   //SQLQuery sql= session.createSQLQuery("select * from user ");
       　　 SQLQuery sql=session.createSQLQuery("select * from user where id=1 ");
       　　 sql.addEntity(User.class);
       　　 List<User> list=sql.list();
       　　 System.out.println(list);源码如下所示：

 1 package com.bie.test;
 2 
 3 
 4 
 5 import java.util.List;
 6 
 7 import org.hibernate.SQLQuery;
 8 import org.hibernate.Session;
 9 import org.hibernate.SessionFactory;
10 import org.hibernate.Transaction;
11 import org.hibernate.cfg.Configuration;
12 import org.junit.Test;
13 
14 import com.bie.po.User;
15 
16 /** 
17 * @author BieHongLi 
18 * @version 创建时间：2017年3月9日 下午8:47:46 
19 * Hibernate查询的几种方式：
20 *     
21 */
22 public class SelectTest4 {
23 
24     //全局静态session工厂
25     private static SessionFactory sf;
26     static{
27         //1：创建sesson工厂
28         sf=new Configuration().configure().buildSessionFactory();
29     }
30     
31     @Test
32     public void select(){
33         User user=new User();
34         
35         //2：根据session工厂创建session
36         Session session=sf.openSession();
37         //3：开启事务
38         Transaction tx=session.beginTransaction();
39         
40         //sql语句
41         //把每一行记录封装为对象数组，再添加到list集合中
42         //SQLQuery sql= session.createSQLQuery("select * from user ");
43         //把每一行记录封装为指定的对象类型
44         SQLQuery sql=session.createSQLQuery("select * from user where id=1 ").addEntity(User.class);
45         List<User> list=sql.list();
46         System.out.println(list);
47         
48         //5：提交事务
49         tx.commit();
50         //6：关闭事务和session
51         session.close();
52         sf.close();
53         
54     }
55     
56 }

演示如下所示：

为了美好明天，加油！！！

查看全文

相关阅读:
解决Servlet无法换行
 Servlet页面解析中文乱码问题
 IDEA2020版创建Servlet(Web项目)完整教程
 SPFA算法
 最短路算法Dijkstra
搜索与图论总结
 Kruskal算法
 第10章嵌入式Linux 的调试技术
 第9章硬件抽象层：HAL
第八章让开发板发出声音：蜂鸣器驱动

原文地址：https://www.cnblogs.com/biehongli/p/6528001.html