二、框架学习 （一）Hibernate框架学习 （4）Hibernate查询操作

Hibernate的查询方式

         1 对象导航查询

                   (1)根据id查询某个客户,再查询这个客户里面所有的联系人

         2 OID查询

                   (1)根据id查询某一条记录,返回对象

         3 hql查询。

                   (1) Query对象,写hql语句实现查询

         4 QBC查询。

                   (1) Criteria对象

         5 本地sql查询

                   (1) SQLQuery对象,使用普通sql实现查询

测试数据库如下

t_customer表：

 t_linkman表：

一、 对象导航查询

　　1 查询某个客户里面所有联系人过程，使用对象导航实现

　　客户类：

package cn.itcast.entity;

import java.util.HashSet;
import java.util.Set;

public class Customer {
    private Integer cid;
    private String custName;
    private String custLevel;
    private String custSource;
    private String custPhone;
    private String custMobile;
    
    private Set<LinkMan> setLinkMan=new HashSet<LinkMan>();

    public Integer getCid() {
        return cid;
    }

    public void setCid(Integer cid) {
        this.cid = cid;
    }

    public String getCustName() {
        return custName;
    }

    public void setCustName(String custName) {
        this.custName = custName;
    }

    public String getCustLevel() {
        return custLevel;
    }

    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }

    public String getCustSource() {
        return custSource;
    }

    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }

    public String getCustPhone() {
        return custPhone;
    }

    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }

    public String getCustMobile() {
        return custMobile;
    }

    public void setCustMobile(String custMobile) {
        this.custMobile = custMobile;
    }

    public Set<LinkMan> getSetLinkMan() {
        return setLinkMan;
    }

    public void setSetLinkMan(Set<LinkMan> setLinkMan) {
        this.setLinkMan = setLinkMan;
    }

    @Override
    public String toString() {
        return "Customer [cid=" + cid + ", custName=" + custName + ", custLevel=" + custLevel + ", custSource="
                + custSource + ", custPhone=" + custPhone + ", custMobile=" + custMobile 
                + "]";
    }
    
    
    
}

　　　　客户类对应的xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <!-- 1配置类和表对应
        c1ass标签
        name属性:实体类全路径
        tab1e属性:数据库表名称 
    -->
    <class name="cn.itcast.entity.Customer" table="t_Customer">
        <!-- 2配置实体类id和表id对应
            hibernate要求实体类有一个属性唯一值
            hibernate要求表有字段作为唯一值
        -->
        <!-- id标签
            name属性:实体类里面主d属性名称
            co1umn属性:生成的表字段名称
        -->
        <id name="cid" column="cid">
            <!-- 设置数据库表id增长策略
                native:生成表id值就是主键自动增长 
            -->
            <generator class="native"></generator>
        </id>
        <!-- 
            配置其他属性和表字段对应
            name属性:实体类属性名称
            column属性:生成表字段名称
         -->
        <property name="custName" column="custName"></property>
        <property name="custLevel" column="custLevel"></property>
        <property name="custSource" column=" custSource"></property>
        <property name="custPhone" column=" custPhone"></property>
        <property name="custMobile" column=" custMobile"></property>
        <!-- 一对多设置 -->
        <set name="setLinkMan" cascade="save-update,delete" inverse="true">
            <key column="clid"></key>
            <one-to-many class="cn.itcast.entity.LinkMan"/>
        </set>
    </class>
</hibernate-mapping>

　　　　 联系人类：

package cn.itcast.entity;

public class LinkMan {
    private Integer lkm_id;
    private String lkm_name;
    private String lkm_gender;
    private String lkm_phone;
    private Customer customer;
    
    
    
    
    
    
    public Customer getCustomer() {
        return customer;
    }
    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
    public Integer getLkm_id() {
        return lkm_id;
    }
    public void setLkm_id(Integer lkm_id) {
        this.lkm_id = lkm_id;
    }
    public String getLkm_name() {
        return lkm_name;
    }
    public void setLkm_name(String lkm_name) {
        this.lkm_name = lkm_name;
    }
    public String getLkm_gender() {
        return lkm_gender;
    }
    public void setLkm_gender(String lkm_gender) {
        this.lkm_gender = lkm_gender;
    }
    public String getLkm_phone() {
        return lkm_phone;
    }
    public void setLkm_phone(String lkm_phone) {
        this.lkm_phone = lkm_phone;
    }
    @Override
    public String toString() {
        return "LinkMan [lkm_id=" + lkm_id + ", lkm_name=" + lkm_name + ", lkm_gender=" + lkm_gender + ", lkm_phone="
                + lkm_phone + ", customer=" + customer + "]";
    }
    
    
    
    
    
}

　　　　　　联系人类对应的xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <!-- 1配置类和表对应
        c1ass标签
        name属性:实体类全路径
        tab1e属性:数据库表名称 
    -->
    <class name="cn.itcast.entity.LinkMan" table="t_LinkMan">
        <!-- 2配置实体类id和表id对应
            hibernate要求实体类有一个属性唯一值
            hibernate要求表有字段作为唯一值
        -->
        <!-- id标签
            name属性:实体类里面主d属性名称
            co1umn属性:生成的表字段名称
        -->
        <id name="lkm_id" column="lkm_id">
            <!-- 设置数据库表id增长策略
                native:生成表id值就是主键自动增长 
            -->
            <generator class="native"></generator>
        </id>
        <!-- 
            配置其他属性和表字段对应
            name属性:实体类属性名称
            column属性:生成表字段名称
         -->
        <property name="lkm_name" column="lkm_name"></property>
        <property name="lkm_gender" column="lkm_gender"></property>
        <property name="lkm_phone" column="lkm_phone"></property>
        <!-- 一对多设置 -->
        <many-to-one name="customer" class="cn.itcast.entity.Customer" column="clid"></many-to-one>
    </class>
</hibernate-mapping>

　　　　　　代码：

package cn.itcast.hibernatetest;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

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

import cn.itcast.entity.Customer;
import cn.itcast.entity.LinkMan;
import cn.itcast.utils.HibernateUtils;

public class test {
    @Test
    public void test1(){
        //获取sessionFactory对象，HibernateUtils是自己编写的工具类
        SessionFactory sessionFactory=HibernateUtils.getSessionFactory();
        //通过sessionFactory获取session对象
        Session session=sessionFactory.openSession();
        //开启事务
        Transaction tx=session.beginTransaction();
        
        
        Customer customer=session.get(Customer.class,10);
        
        Set<LinkMan> set=customer.getSetLinkMan();
        for (LinkMan linkMan : set) {
            System.out.println(linkMan);
        }
        
        //提交事务
        tx.commit();
        //关闭session和sessionFactory
        session.close();
        sessionFactory.close();
        
    }
}

结果：

Hibernate:

    select

        customer0_.cid as cid1_0_0_,

        customer0_.custName as custName2_0_0_,

        customer0_.custLevel as custLeve3_0_0_,

        customer0_.custSource as custSour4_0_0_,

        customer0_.custPhone as custPhon5_0_0_,

        customer0_.custMobile as custMobi6_0_0_

    from

        t_Customer customer0_

    where

        customer0_.cid=?

Hibernate:

    select

        setlinkman0_.clid as clid5_1_0_,

        setlinkman0_.lkm_id as lkm_id1_1_0_,

        setlinkman0_.lkm_id as lkm_id1_1_1_,

        setlinkman0_.lkm_name as lkm_name2_1_1_,

        setlinkman0_.lkm_gender as lkm_gend3_1_1_,

        setlinkman0_.lkm_phone as lkm_phon4_1_1_,

        setlinkman0_.clid as clid5_1_1_

    from

        t_LinkMan setlinkman0_

    where

        setlinkman0_.clid=?

LinkMan [lkm_id=53, lkm_name=1, lkm_gender=222, lkm_phone=123456789, customer=Customer [cid=10, custName=苹果苹果, custLevel=1, custSource=null, custPhone=18763897307, custMobile=3434492]]

LinkMan [lkm_id=51, lkm_name=3, lkm_gender=222, lkm_phone=123456789, customer=Customer [cid=10, custName=苹果苹果, custLevel=1, custSource=null, custPhone=18763897307, custMobile=3434492]]

LinkMan [lkm_id=54, lkm_name=4, lkm_gender=222, lkm_phone=123456789, customer=Customer [cid=10, custName=苹果苹果, custLevel=1, custSource=null, custPhone=18763897307, custMobile=3434492]]

LinkMan [lkm_id=52, lkm_name=2, lkm_gender=222, lkm_phone=123456789, customer=Customer [cid=10, custName=苹果苹果, custLevel=1, custSource=null, custPhone=18763897307, custMobile=3434492]]

二、 OID查询

　　　　test代码：

package cn.itcast.hibernatetest;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

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

import cn.itcast.entity.Customer;
import cn.itcast.entity.LinkMan;
import cn.itcast.utils.HibernateUtils;

public class test {
    @Test
    public void test2(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();

            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            //OID查询就是使用get方法查询出一条记录
            LinkMan linkMan=session.get(LinkMan.class, 52);
            System.out.println(linkMan);
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }
}

三、 HQL查询。

　　　　　　HQL查询是使用Hibernate Query Language进行的一种查询方式，在这种查询方式中必须要写HQL语句才能查询

1 查询所有

　　查询所有的hql语句格式为：from 实体类名称（以查询所有商品为例）

　　　　　　代码：

　　　　

    @Test
    public void test3(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();

            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            // 1、得到Query对象，并写入hql语句
            Query query = session.createQuery("from LinkMan");
            //2、使用Query对象的list方法得到数据集合
            List<LinkMan> list = query.list();
            //3、遍历集合获取数据
            for (LinkMan linkMan : list) {
                System.out.println(linkMan);
            }
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

2、条件查询

　　条件查询有准确查询和模糊查询，使用hql语句完成。

　　（1）准确查询hql语句：from 实体类名 where 实体属性名 = ？ and 实体类属性名 = ？。

　　准确查询代码：

    @Test
    public void test4(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            
            
            // 1、得到Query对象，并写入hql语句
            Query query = session.createQuery("from LinkMan where lkm_gender = ?");
            //2、填写上一步中占位符的内容
            query.setParameter(0, "男");
            //3、使用Query对象的list方法得到数据集合
            List<LinkMan> list = query.list();
            //3、遍历集合获取数据
            for (LinkMan linkMan : list) {
                System.out.println(linkMan);
            }
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

　　（2）模糊查询hql语句：from 实体类名 where 实体类属性名 like  ？。

　　模糊查询代码：

    @Test
    public void test5(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            
            
            // 1、得到Query对象，并写入hql语句
            Query query = session.createQuery("from LinkMan where lkm_phone like ?");
            //2、填写上一步中占位符的内容
            query.setParameter(0, "%1025%");
            //3、使用Query对象的list方法得到数据集合
            List<LinkMan> list = query.list();
            //3、遍历集合获取数据
            for (LinkMan linkMan : list) {
                System.out.println(linkMan);
            }
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

3、排序查询

　　排序查询hql语句：正序: form 实体类名称 order by 实体类属性名 asc

　　　　　　　　　　 倒序：from 实体类名称 order by 实体类属性名 desc

　　（1）正序查询代码

    @Test
    public void test6(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            
            
            // 1、得到Query对象，并写入hql语句
            Query query = session.createQuery("from LinkMan order by lkm_name asc");
            //2、使用Query对象的list方法得到数据集合
            List<LinkMan> list = query.list();
            //3、遍历集合获取数据
            for (LinkMan linkMan : list) {
                System.out.println(linkMan);
            }
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

　　　　（2）倒序查询代码：

    @Test
    public void test7(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            
            
            // 1、得到Query对象，并写入hql语句
            Query query = session.createQuery("from LinkMan order by lkm_name desc");
            //2、使用Query对象的list方法得到数据集合
            List<LinkMan> list = query.list();
            //3、遍历集合获取数据
            for (LinkMan linkMan : list) {
                System.out.println(linkMan);
            }
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

4、分页查询

　　在mysql数据库中分页使用limit实现，在Hibernate中使用Query对象的两个方法实现。

　　分页查询代码：

    @Test
    public void test8(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            
            
            // 1、得到Query对象，并写入hql语句
            Query query = session.createQuery("from LinkMan");
            //2、使用Query的方法实现分页
            //2.1设置第一个要查询的位置（计算公式：（当前页数-1）*每页的记录数）
            query.setFirstResult(0);
            //2.2设置每页显示的最大记录数
            query.setMaxResults(2);
            // 2、使用Query对象的list方法得到数据集合
            List<LinkMan> list = query.list();
            // 3、遍历集合获取数据
            for (LinkMan linkMan : list) {
                System.out.println(linkMan);
            }
            
            
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

5、投影查询

　　投影查询概念：查询的不是表中的所有字段，而是一部分字段

　　代码：

    @Test
    public void test9(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            
            
            // 1、得到Query对象，并写入hql语句
            Query query = session.createQuery("select lkm_name from LinkMan");
            // 2、使用Query对象的list方法得到数据集合
            List<Object> list = query.list();
            // 3、遍历集合获取数据
            for (Object object: list) {
                System.out.println(object);
            }
            
            
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

6、聚集函数查询

　　常用聚集函数：count  avg  max  min  sum

　　以count为例进行说明

　　hql语句：select count(*) from 实体类名称

　　　　代码：

    @Test
    public void test10(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            
            
            // 1、得到Query对象，并写入hql语句
            Query query = session.createQuery("select count(*) from LinkMan");
            //2、获取结果（结果为long类型）
            Object obj = query.uniqueResult();
            //3、转化为long(类型为long，转为int会报错)
            
            Long long1 = (Long) obj;
            int count = long1.intValue();
            System.out.println(count);
            
            
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

四、 QBC查询。

　　　　使用QBC不在需要写hql语句，而是使用criteria对象的各种方法来实现

1、查询所有

    @Test
    public void test11(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            
            
            //1、创建criteria对象，指定要查询的实体类的名称
            Criteria criteria = session.createCriteria(LinkMan.class);
            //2、调用方法得到数据
            List<LinkMan> list = criteria.list();
            for (LinkMan linkMan : list) {
                System.out.println(linkMan);
            }
            
            
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

2、条件查询

　　（1）准确查询

    @Test
    public void test12(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            
            
            //1、创建criteria对象，指定要查询的实体类的名称
            Criteria criteria = session.createCriteria(LinkMan.class);
            
            /**
             * 使用方法设置查询条件
             * 使用criteria的add方法添加条件
             * 使用Restrictios的静态方法设置条件
             */
            criteria.add(Restrictions.eq("lkm_id", 1));
            
            //2、调用方法得到数据
            List<LinkMan> list = criteria.list();
            for (LinkMan linkMan : list) {
                System.out.println(linkMan);
            }
            
            
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

　　　　（2）模糊查询

    @Test
    public void test13(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            
            
            //1、创建criteria对象，指定要查询的实体类的名称
            Criteria criteria = session.createCriteria(LinkMan.class);
            
            /**
             * 使用方法设置查询条件
             * 使用criteria的add方法添加条件
             * 使用Restrictios的静态方法设置条件
             */
            criteria.add(Restrictions.like("lkm_phone", "%1025%"));
            
            //2、调用方法得到数据
            List<LinkMan> list = criteria.list();
            for (LinkMan linkMan : list) {
                System.out.println(linkMan);
            }
            
            
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

3、排序查询

　　（1）正序查询

    @Test
    public void test14(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            
            
            //1、创建criteria对象，指定要查询的实体类的名称
            Criteria criteria = session.createCriteria(LinkMan.class);
            
             /**
             * 使用方法设置查询条件 
             * 使用criteria的addOrder方法添加排序
             *  使用Order的静态方法设置排属性
             */
            criteria.addOrder(Order.asc("lkm_name"));
            
            //2、调用方法得到数据
            List<LinkMan> list = criteria.list();
            for (LinkMan linkMan : list) {
                System.out.println(linkMan);
            }
            
            
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

　　　　（2）降序查询：

    @Test
    public void test15(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            
            
            //1、创建criteria对象，指定要查询的实体类的名称
            Criteria criteria = session.createCriteria(LinkMan.class);
            
            /**
             * 使用方法设置查询条件 
             * 使用criteria的addOrder方法添加排序
             *  使用Order的静态方法设置排属性
             */
            criteria.addOrder(Order.desc("lkm_name"));
            
            //2、调用方法得到数据
            List<LinkMan> list = criteria.list();
            for (LinkMan linkMan : list) {
                System.out.println(linkMan);
            }
            
            
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

4、分页查询

    @Test
    public void test16(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            
            
            //1、创建criteria对象，指定要查询的实体类的名称
            Criteria criteria = session.createCriteria(LinkMan.class);
            
             //设置第一个要查询记录的位置
            criteria.setFirstResult(0);
            //2、设置每页最大的记录是
            criteria.setMaxResults(2);
            
            //2、调用方法得到数据
            List<LinkMan> list = criteria.list();
            for (LinkMan linkMan : list) {
                System.out.println(linkMan);
            }
            
            
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

5、统计查询

    @Test
    public void test17(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            //1、创建criteria对象，指定要查询的实体类的名称
            Criteria criteria = session.createCriteria(LinkMan.class);
            criteria.setProjection(Projections.rowCount());
            // 2、调用方法得到数据
            Object object = criteria.uniqueResult();
            Long long1 = (Long) object;
            int count = long1.intValue();
            System.out.println(count);
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

6、离线查询

    @Test
    public void test18(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            // 1、创建DetachedCriteria对象，指定要查询的实体类的名称
            DetachedCriteria cDetachedCriteria = DetachedCriteria.forClass(LinkMan.class);
            //2、得到criteria对象（最终执行时才用到session）
            Criteria criteria = cDetachedCriteria.getExecutableCriteria(session);
            criteria.setProjection(Projections.rowCount());
            // 3、调用方法得到数据
            Object object = criteria.uniqueResult();
            Long long1 = (Long) object;
            int count = long1.intValue();
            System.out.println(count);
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }

7、QBC查询条件

五、 本地SQL查询

 本地SQL查询是使用SQLQuery类，使用的是原生态的sql

    @Test
    public void test19(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        
        try {
            //获取sessionFactory对象，HibernateUtils是自己编写的工具类
            sessionFactory=HibernateUtils.getSessionFactory();
            
            //通过sessionFactory获取session对象
            session=sessionFactory.openSession();
            
            //开启事务
            tx=session.beginTransaction();
            
            // 1、创建SQLQuery对象，指定要查询的实体类的名称
            SQLQuery SqlQuery=session.createSQLQuery("select * from t_linkman");
            // 2、设置用来接收结果的实体类
            SqlQuery.addEntity(LinkMan.class);
            // 3、用list接收结果
            List<LinkMan> list=SqlQuery.list();
            for (LinkMan linkMan : list) {
                System.out.println(linkMan);
            }
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            //异常回滚
            tx.rollback();
        }finally{
            //关闭session和sessionFactory
            session.close();
            sessionFactory.close();
        }
    }