Hibernate查询方式、对象导航查询、OID查询、HQL查询、QBC、元素SQL

-》对象导航查询
        通过企业Id，查询到企业，然后根据这个企业查询所有的员工

测试类:

package test;
 
import java.util.Iterator;
import java.util.List;
 
import junit.framework.TestCase;
 
import org.hibernate.Session;
 
import com.java.hibernate.HibernateUtils;
import com.java.hibernate.Student;
 
public class ObjectNavQueryTest extends TestCase {
 
	public void testQuery() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
 
			List students = session.createQuery("from Student s where s.classes.name like '%2%'").list();
			for (Iterator iter=students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
 
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
	}
 

 -》OID查询
        就是通过Id查询记录，调用session的get方法

 @Test
    public void testSelectOID(){
        Session session = null;
        Transaction transaction = null;
        try {
            //1.使用SessionFactory创建Session对象
            //理解：类似于jdbc的连接数据库
            session = HibernateUtils.getSessionObject();
            //2.开启事务
            transaction = session.beginTransaction();
            //3.写具体的crud操作
            //查询cid=3的客户
            Customer customer = session.get(Customer.class, 3);
            //4.提交事务
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //5.回滚事务
            transaction.rollback();
        } finally {
            //6.关闭资源     在使用了与本地线程绑定的session对象之后，就不需要手动关闭session了
            session.close();
        }
    }

 -》HQL查询（不写表名是实体名称，不写字段名写属性名称）
        -》查询所有
        -》条件查询
            where
            like 
            设置参数，0开始
        -》分页查询
        -》排序
            from 实体名称 order by 实体属性名称  asc|desc
        -》聚合函数
            常用的聚合函数：
                count、sum、avg、max、min
            hql聚合函数语句写法
                select count(*) from 实体类名称
    -》QBC

QBC查询所有

  @Test
    public void testSelectQBC01(){
        Session session = null;
        Transaction transaction = null;
        try {
            //1.使用SessionFactory创建Session对象
            //理解：类似于jdbc的连接数据库
            session = HibernateUtils.getSessionObject();
            //2.开启事务
            transaction = session.beginTransaction();
            //3.写具体的crud操作
            //查询所有的客户
            //3-1.创建Criteria对象
            Criteria criteria = session.createCriteria(Customer.class);
            //3-2.调用方法得到结果
            List<Customer> list = criteria.list();
            for (Customer customer : list) {
                System.out.println("cid = " + customer.getCid() + "    custName = " + customer.getCustName());
            }
            //4.提交事务
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //5.回滚事务
            transaction.rollback();
        } finally {
            //6.关闭资源     在使用了与本地线程绑定的session对象之后，就不需要手动关闭session了
            session.close();
        }
    }

QBC条件查询

 @Test
    public void testSelectQBC02(){
        Session session = null;
        Transaction transaction = null;
        try {
            //1.使用SessionFactory创建Session对象
            //理解：类似于jdbc的连接数据库
            session = HibernateUtils.getSessionObject();
            //2.开启事务
            transaction = session.beginTransaction();
            //3.写具体的crud操作
            //条件查询
            //3-1.创建Criteria对象
            Criteria criteria = session.createCriteria(Customer.class);
            //3-2.使用Criteria对象里面的方法设置条件值
            //使用add方法设置条件值，在add方法里面使用Restrictions类的方法实现条件设置
            //静态方法中，参数1：实体类属性名    属性2：实体类属性名对应的条件值
            criteria.add(Restrictions.eq("cid", 3));
            criteria.add(Restrictions.eq("custName", "三点连线"));
            //3-3.调用方法得到结果
            List<Customer> list = criteria.list();
            for (Customer customer : list) {
                System.out.println("cid = " + customer.getCid() + "    custName = " + customer.getCustName());
            }
            //4.提交事务
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //5.回滚事务
            transaction.rollback();
        } finally {
            //6.关闭资源     在使用了与本地线程绑定的session对象之后，就不需要手动关闭session了
            session.close();
        }
    }

QBC模糊查询

 @Test
    public void testSelectQBC03(){
        Session session = null;
        Transaction transaction = null;
        try {
            //1.使用SessionFactory创建Session对象
            //理解：类似于jdbc的连接数据库
            session = HibernateUtils.getSessionObject();
            //2.开启事务
            transaction = session.beginTransaction();
            //3.写具体的crud操作
            //模糊查询
            //3-1.创建Criteria对象
            Criteria criteria = session.createCriteria(Customer.class);
            //3-2.使用Criteria对象里面的方法设置条件值
            //使用add方法设置条件值，在add方法里面使用Restrictions类的方法实现条件设置
            //静态方法中，参数1：实体类属性名    属性2：实体类属性名对应的条件值
            criteria.add(Restrictions.like("custName", "%点%"));
            //3-3.调用方法得到结果
            List<Customer> list = criteria.list();
            for (Customer customer : list) {
                System.out.println("cid = " + customer.getCid() + "    custName = " + customer.getCustName());
            }
            //4.提交事务
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //5.回滚事务
            transaction.rollback();
        } finally {
            //6.关闭资源     在使用了与本地线程绑定的session对象之后，就不需要手动关闭session了
            session.close();
        }
    }

QBC排序查询

 @Test
    public void testSelectQBC04(){
        Session session = null;
        Transaction transaction = null;
        try {
            //1.使用SessionFactory创建Session对象
            //理解：类似于jdbc的连接数据库
            session = HibernateUtils.getSessionObject();
            //2.开启事务
            transaction = session.beginTransaction();
            //3.写具体的crud操作
            //排序查询
            //3-1.创建Criteria对象
            Criteria criteria = session.createCriteria(Customer.class);
            //3-2.使用Criteria对象里面的方法设置条件值
            //使用add方法设置条件值，在add方法里面使用Restrictions类的方法实现条件设置
            //静态方法决定排序规则，参数：设置根据那个属性进行排序
            criteria.addOrder(Order.asc("cid"));
            //3-3.调用方法得到结果
            List<Customer> list = criteria.list();
            for (Customer customer : list) {
                System.out.println("cid = " + customer.getCid() + "    custName = " + customer.getCustName());
            }
            //4.提交事务
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //5.回滚事务
            transaction.rollback();
        } finally {
            //6.关闭资源     在使用了与本地线程绑定的session对象之后，就不需要手动关闭session了
            session.close();
        }
    }

QBC离线查询

 @Test
    public void testSelectQBC07(){
        Session session = null;
        Transaction transaction = null;
        try {
            //1.使用SessionFactory创建Session对象
            //理解：类似于jdbc的连接数据库
            session = HibernateUtils.getSessionObject();
            //2.开启事务
            transaction = session.beginTransaction();
            //3.写具体的crud操作
            //离线查询
            //使用场景，servlet调用service，service调用dao（对数据库crud操作--使用hibernate框架时，最终使用session里面的方法实现数据操作）
            //3-1.创建对象
            DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
            //3-2.最终执行时才用到session
            Criteria criteria = detachedCriteria.getExecutableCriteria(session);
            //3-3.调用方法得到结果
            List<Customer> list = criteria.list();
            for (Customer customer : list) {
                System.out.println("cid = " + customer.getCid() + "    custName = " + customer.getCustName());
            }
            //4.提交事务
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //5.回滚事务
            transaction.rollback();
        } finally {
            //6.关闭资源     在使用了与本地线程绑定的session对象之后，就不需要手动关闭session了
            session.close();
        }
    }

QBC统计查询

  @Test
    public void testSelectQBC06(){
        Session session = null;
        Transaction transaction = null;
        try {
            //1.使用SessionFactory创建Session对象
            //理解：类似于jdbc的连接数据库
            session = HibernateUtils.getSessionObject();
            //2.开启事务
            transaction = session.beginTransaction();
            //3.写具体的crud操作
            //3-1.统计查询
            Criteria criteria = session.createCriteria(Customer.class);
            //3-2.设置所要做的操作
            criteria.setProjection(Projections.rowCount());
            //3-3.调用方法得到结果
            Object object = criteria.uniqueResult();
            Long count = (Long)object;
            int a = count.intValue();
            System.out.println("object = " + a);
            //4.提交事务
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //5.回滚事务
            transaction.rollback();
        } finally {
            //6.关闭资源     在使用了与本地线程绑定的session对象之后，就不需要手动关闭session了
            session.close();
        }
    }

        使用hibernate api查询，本质是使用Criteria对象实现
    -》元素SQL
        使用nativeQuery查询