对象导航查询

• 根据id查询某个订单，再查询订单里商品

package com.td.dao;

import java.util.Set;

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

import com.td.domain.Goods;
import com.td.domain.Order;
import com.td.utils.HibernateUtils;

public class TestHibernate {
    @Test
    public void add() {
        SessionFactory factory = null;
        Session session = null;
        Transaction transaction = null;
        try {
            factory = HibernateUtils.getSessionFatory();
            session = factory.openSession();
//          开启事务
            transaction = session.beginTransaction();
//          对象导航查询，首先查询到订单，
            Order order = session.get(Order.class, 1);
//          再找到订单里的商品
            Set<Goods> setGoods = order.getSetGoods();
            for (Goods goods : setGoods) {
                System.out.println(goods);
            }
            transaction.commit();
        } catch (Exception e) {
//          如果发生异常那么回滚
            transaction.rollback();
        }finally {
//          释放资源
            if(session != null) {
                session.close();
            }
            if(factory != null) {
                factory.close();
            }
        }
    }
}   

OID查询

• 根据id查询某一条记录，返回对象

hql查询

• hql ：hibernate query language,hibernate提供了一中查询语言，hql语言和普通的sql语言很相似
  
  • hql语言操作实体类和属性
  • sql语言操作数据库表和字段
• 常用的hql语句

• 使用hql查询的时候，使用Query对象

  • Query对象，写hql语句实现查询
  • 调用query对象里面的方法得到结果
    
    1. ==查询所有==
  • 查询所有的hql语句：from + 实体类名称

  • 通过Session获取Query对象

    import java.util.List;
    
    import org.hibernate.Query;
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.junit.Test;
    
    import com.td.domain.Order;
    import com.td.utils.HibernateUtils;
    
    public class TestHibernate {
            
        @Test
        public void add() {
            SessionFactory factory = null;
            Session session = null;
            Transaction transaction = null;
            try {
                factory = HibernateUtils.getSessionFatory();
                session = factory.openSession();
    //          开启事务
                transaction = session.beginTransaction();
    //          获取Query对象
                Query query = session.createQuery("from Order");
    //          执行query的 方法，获得结果的集合
                List<Order> list = query.list();
                for (Order order : list) {
                    System.out.println(order);
                }
    
                transaction.commit();
            } catch (Exception e) {
    //          如果发生异常那么回滚
                transaction.rollback();
            }finally {
    //          释放资源
                if(session != null) {
                    session.close();
                }
                if(factory != null) {
                    factory.close();
                }
            }
        }

  • 查询结果：

    1. ==条件查询==
  • hql语句：from + 实体类对象 + where+条件
  • 通过Session获取Query对象

  • 调用query的setParameter方法给hql语句的？设置参数

    • 参数使用？替代
    • 参数从0开始计数
      

      @Test
          public void add() {
              SessionFactory factory = null;
              Session session = null;
              Transaction transaction = null;
              try {
                  factory = HibernateUtils.getSessionFatory();
                  session = factory.openSession();
      //          开启事务
                  transaction = session.beginTransaction();
      //          获取Query对象，条件查询的hql语句from + 实体类名字 + where + 条件
      //from Order where oaddress like ?
      // query.setParameter(1, "%西%");百分号匹配任意个字符，_匹配一个字符
                  Query query = session.createQuery("from Order where oaddress=? and phone=?");
                  /**
                   * 使用setParameter方法给hql语句设置参数，
                   * 方法的第一参数指定位置，从0开始
                   * 方法的第二个参数指定参数值
                   * */
                  query.setParameter(0, "山西");
                  query.setParameter(1, "223");
      //          执行query的 方法，获得结果的集合
                  List<Order> list = query.list();
                  for (Order order : list) {
                      System.out.println(order);
                  }
      
                  transaction.commit();
              } catch (Exception e) {
      //          如果发生异常那么回滚
                  transaction.rollback();
              }finally {
      //          释放资源
                  if(session != null) {
                      session.close();
                  }
                  if(factory != null) {
                      factory.close();
                  }
              }
          }

  • 数据库查询结果：

    1. ==排序查询==
  • hql语句：from + 实体类名字 + [条件] + order by +实体类 属性名+ asc/desc
  • 通过Session获取Query对象

  • 执行query的list方法

    @Test
        public void test() {
            SessionFactory factory = null;
            Session session = null;
            Transaction transaction = null;
            try {
                factory = HibernateUtils.getSessionFatory();
                session = factory.openSession();
    //          开启事务
                transaction = session.beginTransaction();
    //          获取Query对象，排序查询的hql语句from + 实体类名字 + order by + 实体类属性名+ desc/asc
                Query query = session.createQuery("from Order order by oid desc");
    
    //          执行query的 方法，获得结果的集合
                List<Order> list = query.list();
                for (Order order : list) {
                    System.out.println(order);
                }
                transaction.commit();
            } catch (Exception e) {
    //          如果发生异常那么回滚
                transaction.rollback();
            }finally {
    //          释放资源
                if(session != null) {
                    session.close();
                }
                if(factory != null) {
                    factory.close();
                }
            }
        }

  • 查询结果：

    1. ==分页查询==
  • mysql实现分页：使用limit

  • 使用hql实现，hql语句中不能写limit,但是hibernate中的Query对象封装好了两个方法来实现分页操作

    • 查询所有

    • 使用query的方法设置分页的起始位置，和显示的数据数量

      @Test
          public void test() {
              SessionFactory factory = null;
              Session session = null;
              Transaction transaction = null;
              try {
                  factory = HibernateUtils.getSessionFatory();
                  session = factory.openSession();
      //          开启事务
                  transaction = session.beginTransaction();
      //          第一步查询所有
                  Query query = session.createQuery("from Order");
      //          设置分页的起始位置
                  query.setFirstResult(0);
      //          设置每页的显示的数量
                  query.setMaxResults(2);
      
                  List<Order> list = query.list();
                  for (Order order : list) {
                      System.out.println(order);
                  }
                  transaction.commit();
              } catch (Exception e) {
      //          如果发生异常那么回滚
                  transaction.rollback();
              }finally {
      //          释放资源
                  if(session != null) {
                      session.close();
                  }
                  if(factory != null) {
                      factory.close();
                  }
              }
          }

    • 查询结果：

      1. ==投影查询==
  • 投影查询：查询的不是所有的字段的值，而是部分的字段的值

  • hql语句：select + 实体类属性名.. + from 实体类名字

    @Test
        public void test() {
            SessionFactory factory = null;
            Session session = null;
            Transaction transaction = null;
            try {
                factory = HibernateUtils.getSessionFatory();
                session = factory.openSession();
    //          开启事务
                transaction = session.beginTransaction();
    //          查询部分字段
                Query query = session.createQuery("select oaddress from Order");
    //          由于查询的只是部分的字段，不能封装成对象了
                List list = query.list();
                for (Object a : list) {
                    System.out.println(a);
                }
                transaction.commit();
            } catch (Exception e) {
    //          如果发生异常那么回滚
                transaction.rollback();
            }finally {
    //          释放资源
                if(session != null) {
                    session.close();
                }
                if(factory != null) {
                    factory.close();
                }
            }
        }

  • 查询结果：

  • ==这种方式查询不建议使用，完全可以查询出全部的字段封装成对象，调用对象的方法获取需要的属性==

    1. ==聚合函数查询==
  • 常用的聚合函数
    
    • count 、sum、avg、max、min
  • hql聚合函数语句写法
    
    • 查询表的记录数:select count(*) from 实体类名称
    • 获取query对象，调用uniqueResult()方法获取结果
    • 使用聚合函数count查询数量，方法的返回值是 一个long类型的，向上转型成为了一个Object类型，如果需要int类型的值，需要先强转为Long类型，在 使用Long类型的方法intValue()将Long类型转换成int类型
      
@Test
public void test() {
SessionFactory factory = null;
Session session = null;
Transaction transaction = null;
try {
factory = HibernateUtils.getSessionFatory();
session = factory.openSession();
// 开启事务
transaction = session.beginTransaction();
// 获取query对象，hql;select count(*) from Order
Query query = session.createQuery("select count(*) from Order");
// 使用Query的方法获取结果，这个结果是 Long类型的，向上转型成为了Object
Object result = query.uniqueResult();
System.out.println(result);
// 如果想要获取int类型的，那么需要先强转化为long类型，在调用Long类型的intValue
// 方法转换为int类型
Long re = (Long)result;
int mum = re.intValue();
System.out.println(mum);
transaction.commit();
} catch (Exception e) {
// 如果发生异常那么回滚
transaction.rollback();
}finally {
// 释放资源
if(session != null) {
session.close();
}
if(factory != null) {
factory.close();
}
}
}

    • 结果：