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

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

案例演示：

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

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

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

 package com.bie.po;
 /**
 * @author BieHongLi
 * @version 创建时间：2017年3月8日 下午5:17:23
 *
 */
 public class User {

     private int id;
     private String name;
     private String password;
     private String email;
     private String phone;
     public int getId() {
         return id;
     }
     public void setId(int id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getEmail() {
         return email;
     }
     public void setEmail(String email) {
         this.email = email;
     }
     public String getPhone() {
         return phone;
     }
     public void setPhone(String phone) {
         this.phone = phone;
     }
     public String getPassword() {
         return password;
     }
     public void setPassword(String password) {
         this.password = password;
     }
     @Override
     public String toString() {
         return "User [id=" + id + ", name=" + name + ", password=" + password + ", email=" + email + ", phone=" + phone
                 + "]";
     }

 }

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

 <?xml version="1.0"?>
 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

 <hibernate-mapping package="com.bie.po">
     <!-- 操作条件：
         1：对象与表
         2：属性与字段的对应
         3：类型的对应,类型默认采用属性的类型，type不写的话
      -->
     <class name="User" table="user">
         <!-- 主键，映射 -->
         <id name="id" column="id">
             <generator class="native"></generator>
         </id>

         <!-- 非主键，映射 -->
         <property name="name" column="name"></property>
         <property name="password" column="password"></property>
         <property name="email" column="email"></property>
         <property name="phone" column="phone"></property>

     </class>

 </hibernate-mapping>

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

 <!DOCTYPE hibernate-configuration PUBLIC
     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

 <hibernate-configuration>
     <session-factory>
         <!--
             1:数据连接配置
             2:加载所有的映射（*.hbm.xml）
          -->

          <!-- 1:数据连接配置 -->
          <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
          <property name="hibernate.connection.url">jdbc:mysql:///test</property>
          <property name="hibernate.connection.username">root</property>
          <property name="hibernate.connection.password">123456</property>
          <!-- mysql数据库的方言 -->
          <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

          <property name="hibernate.show_sql">true</property>

          <!-- 2:加载所有的映射（*.hbm.xml） -->
          <mapping resource="com/bie/po/User.hbm.xml"/>

     </session-factory>
 </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();

---

源码如下所示：

 package com.bie.test;

 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.cfg.Configuration;
 import org.junit.Test;

 import com.bie.po.User;

 /**
 * @author BieHongLi
 * @version 创建时间：2017年3月8日 下午5:28:35
 *
 */
 public class HelloTest {

     @Test
     public void testHello(){
         //对象
         User user=new User();
         user.setName("张三");
         user.setPassword("123456");
         user.setEmail("1748741329@qq.com");
         user.setPhone("15236083005");

         //获取加载配置文件的管理类对象
         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();

     }
 }

演示效果如下所示：

---

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

　　     session.saveOrUpdate(user);

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

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

源码如下所示：

 package com.bie.test;

 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.cfg.Configuration;
 import org.junit.Test;

 import com.bie.po.User;

 /**
 * @author BieHongLi
 * @version 创建时间：2017年3月8日 下午5:28:35
 *
 */
 public class HelloTest2 {

     //SessionFactory代表整个配置文件，所以没必要加载多次，放到全局即可
     private static SessionFactory sf;
     static{
         //1:创建配置管理类对象
         Configuration config=new Configuration();
         //加载配置文件，(默认加载/src/hibernate.cfg.xml)
         config.configure();

         //2：根据加载的配置管理类对象，创建SessionFactory对象
         sf=config.buildSessionFactory();

         //简介写法，写到一行里面
         //sf=new Configuration().configure().buildSessionFactory();
     }
     @Test
     public void testHello(){
         //对象
         User user=new User();
         user.setId(1);
         user.setName("李四22222");
         user.setPassword("222222");
         user.setEmail("22222222@qq.com");
         user.setPhone("15236083005");

         //3:根据sesson的工厂创建session对象
         Session session = sf.openSession();

         //开启事务
         Transaction tx = session.beginTransaction();
         //执行操作
         //session.save(user);
         session.saveOrUpdate(user);

         //提交事务
         tx.commit();
         //关闭事务
         session.close();
         sf.close();
     }

 }

演示结果如下所示：

---

　　6.3：实现Hibernate的查询操作：

　　　　6.3.1：主键查询的方法

　　　　　　两种方法：

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

源码如下所示：

 package com.bie.test;

 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.cfg.Configuration;
 import org.junit.Test;

 import com.bie.po.User;

 /**
 * @author BieHongLi
 * @version 创建时间：2017年3月9日 下午8:47:46
 * Hibernate查询的几种方式：
 *
 */
 public class SelectTest {

     //全局静态session工厂
     private static SessionFactory sf;
     static{
         //1：创建sesson工厂
         sf=new Configuration().configure().buildSessionFactory();
     }

     @Test
     public void select(){
         User user=new User();

         //2：根据session工厂创建session
         Session session=sf.openSession();
         //3：开启事务
         Transaction tx=session.beginTransaction();
         //4：主键查询，执行查询操作，方法一：get方法，方法2：load方法
         //User u=(User)session.get(User.class, 1);
         User u=(User)session.load(User.class, 1);

         //主键查询测试结果
         System.out.println(u);
         //5：提交事务
         tx.commit();
         //6：关闭事务和session
         session.close();
         sf.close();

     }

 }

演示效果如下所示：

---

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

　　　　HQL查询和sql查询的区别：

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

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

源码如下所示：

 package com.bie.test;

 import java.util.List;

 import org.hibernate.Query;
 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.cfg.Configuration;
 import org.junit.Test;

 import com.bie.po.User;

 /**
 * @author BieHongLi
 * @version 创建时间：2017年3月9日 下午8:47:46
 * Hibernate查询的几种方式：
 *
 */
 public class SelectTest2 {

     //全局静态session工厂
     private static SessionFactory sf;
     static{
         //1：创建sesson工厂
         sf=new Configuration().configure().buildSessionFactory();
     }

     @Test
     public void select(){
         User user=new User();

         //2：根据session工厂创建session
         Session session=sf.openSession();
         //3：开启事务
         Transaction tx=session.beginTransaction();

         //HRL查询，查询全部信息，注意HRL查询的是实体类的名称，不是数据表的名称，特别注意这一点
         //Query q=session.createQuery("from User");
         Query q=session.createQuery("from User user where user.id=1 or user.id=2 ");

         List<User> list=q.list();
         System.out.println(list);

         //5：提交事务
         tx.commit();
         //6：关闭事务和session
         session.close();
         sf.close();

     }

 }

效果如下所示：

---

　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);

源码如下所示：

 package com.bie.test;

 import java.util.List;

 import org.hibernate.Criteria;
 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.cfg.Configuration;
 import org.hibernate.criterion.Restrictions;
 import org.junit.Test;

 import com.bie.po.User;

 /**
 * @author BieHongLi
 * @version 创建时间：2017年3月9日 下午8:47:46
 * Hibernate查询的几种方式：
 *
 */
 public class SelectTest3 {

     //全局静态session工厂
     private static SessionFactory sf;
     static{
         //1：创建sesson工厂
         sf=new Configuration().configure().buildSessionFactory();
     }

     @Test
     public void select(){
         User user=new User();

         //2：根据session工厂创建session
         Session session=sf.openSession();
         //3：开启事务
         Transaction tx=session.beginTransaction();

         //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);

         //5：提交事务
         tx.commit();
         //6：关闭事务和session
         session.close();
         sf.close();

     }

 }

演示效果如下所示：

　　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);源码如下所示：

 package com.bie.test;

 import java.util.List;

 import org.hibernate.SQLQuery;
 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.cfg.Configuration;
 import org.junit.Test;

 import com.bie.po.User;

 /**
 * @author BieHongLi
 * @version 创建时间：2017年3月9日 下午8:47:46
 * Hibernate查询的几种方式：
 *
 */
 public class SelectTest4 {

     //全局静态session工厂
     private static SessionFactory sf;
     static{
         //1：创建sesson工厂
         sf=new Configuration().configure().buildSessionFactory();
     }

     @Test
     public void select(){
         User user=new User();

         //2：根据session工厂创建session
         Session session=sf.openSession();
         //3：开启事务
         Transaction tx=session.beginTransaction();

         //sql语句
         //把每一行记录封装为对象数组，再添加到list集合中
         //SQLQuery sql= session.createSQLQuery("select * from user ");
         //把每一行记录封装为指定的对象类型
         SQLQuery sql=session.createSQLQuery("select * from user where id=1 ").addEntity(User.class);
         List<User> list=sql.list();
         System.out.println(list);

         //5：提交事务
         tx.commit();
         //6：关闭事务和session
         session.close();
         sf.close();

     }

 }

演示如下所示：

---

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