hibernate11--Criteria查询

public class EmpTest {
    Session session =null;
    Transaction transaction=null;

    @Before
    public  void  before(){
         session = HibernateSessionUtil.getCurrentSession();
         transaction= session.beginTransaction();
    }

    /**
     * Criteria 查询接口:完全是面向对象的思想来 操作数据库！
     * 看不到sql看不到hql！
     * 01.查询所有的部门信息
     */
    @Test
    public  void  test01(){
    Criteria criteria=session.createCriteria(Dept.class);   //createQuery("from Dept");
        List<Dept>list = criteria.list();
        for (Dept dept : list) {
            System.out.println(dept);
        }
    }
    /**
     * 02.查询指定的部门信息     eq(属性名，属性值)
     * Restrictions：给我们的查询增加条件
     *      001.Restrictions中的方法都是静态的
     *      002.方法的返回是都是    Criterion或者其实现类
     */
    @Test
    public  void  test02(){
        Criteria criteria=session.createCriteria(Dept.class);   //createQuery("from Dept");
        criteria.add(Restrictions.eq("deptName", "研发部")); //给查询增加条件
        Dept dept = (Dept) criteria.uniqueResult();
        System.out.println(dept);
    }
    /**
     * 03.查询员工薪水大于10k的    gt(属性名，属性值)
     */
    @Test
    public  void  test03(){
        Criteria criteria=session.createCriteria(Emp.class);
        criteria.add(Restrictions.gt("salary", 10000d)); //给查询增加条件
         List<Emp> list = criteria.list();
         for (Emp emp : list) {
            System.out.println(emp);
        }
    }
    /**
     * 04.查询员工薪水大于5k的  小于100k   bw(属性名，属性值1,属性值2)
     */
    @Test
    public  void  test04(){
        Criteria criteria=session.createCriteria(Emp.class);
        criteria.add(Restrictions.between("salary", 5000d, 100000d)); //给查询增加条件
        List<Emp> list = criteria.list();
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }    

    /**
     * 05.查询没有部门的员工     dept是我们Emp类中的一个域属性  对象为null  使用 isNull
     */
    @Test
    public  void  test05(){
        Criteria criteria=session.createCriteria(Emp.class);
        criteria.add(Restrictions.isNull("dept")); //给查询增加条件
        List<Emp> list = criteria.list();
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }
    /**
     * 06.查询没有员工的 部门    emps是我们Dept类中的一个集合    集合的size=0   使用 isEmpty
     */
    @Test
    public  void  test06(){
        Criteria criteria=session.createCriteria(Dept.class);
        criteria.add(Restrictions.isEmpty("emps")); //给查询增加条件
        List<Dept> list = criteria.list();
        for (Dept dept : list) {
            System.out.println(dept);
        }
    }    

    /**
     * 07.查询 员工姓名是  员工1  或者 员工2的信息
     *   两种情况  使用or
     */
    @Test
    public  void  test07(){
        Criteria criteria=session.createCriteria(Emp.class);
        //给查询增加条件
        criteria.add(Restrictions.or
                (Restrictions.eq("empName", "员工1"),
                Restrictions.eq("empName", "员工2")));
        List<Emp> list = criteria.list();
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }    

    /**
     * 08.查询 员工姓名是  员工1  或者 员工2的信息
     *   两种情况  使用in(属性名，集合)
     */
    @Test
    public  void  test08(){
        Criteria criteria=session.createCriteria(Emp.class);
        List<String> names=new ArrayList<>();
        names.add("员工1");
        names.add("员工2");
        //给查询增加条件
        criteria.add(Restrictions.in("empName", names));
        List<Emp> list = criteria.list();
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }
    /**
     * 09.查询 员工姓名是  员工1  或者 员工2 ，员工3  员工4 的信息
     *   两种情况  使用in(属性名，集合)
     */
    @Test
    public  void  test09(){
        Criteria criteria=session.createCriteria(Emp.class);
        List<String> names=new ArrayList<>();
        names.add("员工1");
        names.add("员工2");
        names.add("员工3");
        names.add("员工4");
        //给查询增加条件
        criteria.add(Restrictions.in("empName", names));
        List<Emp> list = criteria.list();
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }    

    /**
     * 10.查询 员工姓名是  员工1  或者 员工2 ，员工3  员工4 的信息
     *
     *  Restrictions.disjunction()返回一个Disjunction对象
     *  Disjunction 继承了Junction
     *  Junction中有一个add（）
     *   底层代码
     *  public Junction add(Criterion criterion) {
        criteria.add(criterion);
        return this;
       }
     */
    @Test
    public  void  test10(){
        Criteria criteria=session.createCriteria(Emp.class);
        //给查询增加条件
        criteria.add(Restrictions.disjunction()
                .add(Restrictions.eq("empName", "员工1"))
                .add(Restrictions.eq("empName", "员工2"))
                .add(Restrictions.eq("empName", "员工3"))
                .add(Restrictions.eq("empName", "员工4"))
                );
        List<Emp> list = criteria.list();
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }
    /**
     * 11.查询 员工姓名包含 A 的员工信息
     *    like  模糊查询
     */
    @Test
    public  void  test11(){
        Criteria criteria=session.createCriteria(Emp.class);
        //给查询增加条件
        criteria.add(Restrictions.like("empName", "%A%"));
        List<Emp> list = criteria.list();
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }
    /**
     * 12.查询 员工姓名包含 A/a 的员工信息
     *    ilike  模糊查询    忽略大小写
     */
    @Test
    public  void  test12(){
        Criteria criteria=session.createCriteria(Emp.class);
        //给查询增加条件
        criteria.add(Restrictions.ilike("empName", "%A%"));
        List<Emp> list = criteria.list();
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }    

    /**
     * 13.查询 员工姓名包含 A 的员工信息
     *    like  模糊查询
     *    MatchMode:  我们value值出现的位置    可以替换%
     *    MatchMode.ANYWHERE:前后
     *    MatchMode.END:后
     *    MatchMode.START:前
     */
    @Test
    public  void  test13(){
        Criteria criteria=session.createCriteria(Emp.class);
        //给查询增加条件
        criteria.add(Restrictions.like("empName", "A",MatchMode.ANYWHERE));
        List<Emp> list = criteria.list();
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }    

    /**
     * 14.聚合函数   和 投影查询    Projections
     *
     * 查询 薪水的最大值 最小值   总薪水 和平均薪水
     * criteria.setProjection   是赋值操作
     * 如果不清空Projection
     * 之前给的值   会带入下次的查询
     */
    @Test
    public  void   test14(){
        Criteria criteria = session.createCriteria(Emp.class);
        criteria.setProjection(
                Projections.projectionList()
                .add(Projections.max("salary"))
                .add(Projections.min("salary"))
                .add(Projections.sum("salary"))
                .add(Projections.avg("salary"))
                );
        //criteria.setProjection(null);   清空所有的约束
        List<Object[]> list = criteria.list();
        for (Object[] objects : list) {
            System.out.println("最大薪水："+objects[0]);
            System.out.println("最小薪水："+objects[1]);
            System.out.println("总薪水："+objects[2]);
            System.out.println("平均薪水："+objects[3]);
        }
    }
    /**
     * 15. 分页查询
     *   查询姓名中 包含 "员工" 的  并且 按照 薪水 降序排列
     */
    @Test
    public  void   test15(){
        //查询总记录数
        int count=((Long)session.createCriteria(Emp.class)
                .add(Restrictions.like("empName", "员工",MatchMode.ANYWHERE))
                .setProjection(Projections.count("empName")).uniqueResult()).intValue();
        System.out.println("总记录数是："+count);
        //当前页
        int  pageIndex=1;
        //页大小
        int  pageSize=4;
        //总页数
        int  totalPageSize=(count%pageSize==0)?(count/pageSize):(count/pageSize+1);
        //进行薪水的降序排列
       Criteria criteria=    session.createCriteria(Emp.class)
        .add(Restrictions.like("empName", "员工",MatchMode.ANYWHERE))
        .addOrder(Order.desc("salary"));
       //设置 当前页 以及页大小
       List<Emp> list = criteria.setFirstResult((pageIndex-1)*pageSize).setMaxResults(pageSize).list();
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }

    /**
     * 16:面试题
     * DetachedCriteria和 Criteria的区别
     * 相同点：都能用来 做查询操作
     * 不同点：
     *    01.DetachedCriteria在创建的时候 不需要session！
     *    02.真正执行查询的时候getExecutableCriteria(session)才使用session
     *    03.DetachedCriteria自身可以作为一个参数
     *
     *  薪水  大于    平均值的员工信息
     */
    @Test
    public  void   test16(){
        //得到DetachedCriteria对象
        DetachedCriteria criteria= DetachedCriteria.forClass(Emp.class)
         .setProjection(Projections.avg("salary"));
        //执行查询
        double  avg=(double) criteria.getExecutableCriteria(session).uniqueResult();
        System.out.println("薪水的平均值是："+avg);

        //薪水 大于    平均值的员工信息
        List<Emp> list = session.createCriteria(Emp.class).add(
                Property.forName("salary").gt(criteria)).list();
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }

}

public class EmpTest { Session session =null; Transaction transaction=null; @Before public  void before(){ session = HibernateSessionUtil.getCurrentSession(); transaction= session.beginTransaction(); } /** * Criteria 查询接口:完全是面向对象的思想来 操作数据库！ * 看不到sql看不到hql！ * 01.查询所有的部门信息 */ @Test public  void test01(){ Criteria criteria=session.createCriteria(Dept.class);   //createQuery("from Dept");
        List<Dept>list = criteria.list();
for (Dept dept : list) {
System.out.println(dept);
}
}
/**
* 02.查询指定的部门信息 eq(属性名，属性值)
* Restrictions：给我们的查询增加条件
* 001.Restrictions中的方法都是静态的
* 002.方法的返回是都是 Criterion或者其实现类
*/
@Test
public  void test02(){
Criteria criteria=session.createCriteria(Dept.class);   //createQuery("from Dept");
        criteria.add(Restrictions.eq("deptName", "研发部")); //给查询增加条件
        Dept dept = (Dept) criteria.uniqueResult();
System.out.println(dept);
}
/**
* 03.查询员工薪水大于10k的 gt(属性名，属性值)
*/
@Test
public  void test03(){
Criteria criteria=session.createCriteria(Emp.class);
criteria.add(Restrictions.gt("salary", 10000d)); //给查询增加条件
         List<Emp> list = criteria.list();
for (Emp emp : list) {
System.out.println(emp);
}
}
/**
* 04.查询员工薪水大于5k的 小于100k bw(属性名，属性值1,属性值2)
*/
@Test
public  void test04(){
Criteria criteria=session.createCriteria(Emp.class);
criteria.add(Restrictions.between("salary", 5000d, 100000d)); //给查询增加条件
        List<Emp> list = criteria.list();
for (Emp emp : list) {
System.out.println(emp);
}
}

/**
* 05.查询没有部门的员工 dept是我们Emp类中的一个域属性 对象为null 使用 isNull
*/
@Test
public  void test05(){
Criteria criteria=session.createCriteria(Emp.class);
criteria.add(Restrictions.isNull("dept")); //给查询增加条件
        List<Emp> list = criteria.list();
for (Emp emp : list) {
System.out.println(emp);
}
}
/**
* 06.查询没有员工的 部门 emps是我们Dept类中的一个集合 集合的size=0 使用 isEmpty
*/
@Test
public  void test06(){
Criteria criteria=session.createCriteria(Dept.class);
criteria.add(Restrictions.isEmpty("emps")); //给查询增加条件
        List<Dept> list = criteria.list();
for (Dept dept : list) {
System.out.println(dept);
}
}

/**
* 07.查询 员工姓名是 员工1 或者 员工2的信息
* 两种情况 使用or
*/
@Test
public  void test07(){
Criteria criteria=session.createCriteria(Emp.class);
//给查询增加条件
criteria.add(Restrictions.or
(Restrictions.eq("empName", "员工1"),
Restrictions.eq("empName", "员工2")));
List<Emp> list = criteria.list();
for (Emp emp : list) {
System.out.println(emp);
}
}

/**
* 08.查询 员工姓名是 员工1 或者 员工2的信息
* 两种情况 使用in(属性名，集合)
*/
@Test
public  void test08(){
Criteria criteria=session.createCriteria(Emp.class);
List<String> names=new ArrayList<>();
names.add("员工1");
names.add("员工2");
//给查询增加条件
        criteria.add(Restrictions.in("empName", names));
List<Emp> list = criteria.list();
for (Emp emp : list) {
System.out.println(emp);
}
}
/**
* 09.查询 员工姓名是 员工1 或者 员工2 ，员工3 员工4 的信息
* 两种情况 使用in(属性名，集合)
*/
@Test
public  void test09(){
Criteria criteria=session.createCriteria(Emp.class);
List<String> names=new ArrayList<>();
names.add("员工1");
names.add("员工2");
names.add("员工3");
names.add("员工4");
//给查询增加条件
        criteria.add(Restrictions.in("empName", names));
List<Emp> list = criteria.list();
for (Emp emp : list) {
System.out.println(emp);
}
}

/**
* 10.查询 员工姓名是 员工1 或者 员工2 ，员工3 员工4 的信息
*
* Restrictions.disjunction()返回一个Disjunction对象
* Disjunction 继承了Junction
* Junction中有一个add（）
* 底层代码
* public Junction add(Criterion criterion) {
criteria.add(criterion);
return this;
}
*/
@Test
public  void test10(){
Criteria criteria=session.createCriteria(Emp.class);
//给查询增加条件
criteria.add(Restrictions.disjunction()
.add(Restrictions.eq("empName", "员工1"))
.add(Restrictions.eq("empName", "员工2"))
.add(Restrictions.eq("empName", "员工3"))
.add(Restrictions.eq("empName", "员工4"))
);
List<Emp> list = criteria.list();
for (Emp emp : list) {
System.out.println(emp);
}
}
/**
* 11.查询 员工姓名包含 A 的员工信息
* like 模糊查询
*/
@Test
public  void test11(){
Criteria criteria=session.createCriteria(Emp.class);
//给查询增加条件
        criteria.add(Restrictions.like("empName", "%A%"));
List<Emp> list = criteria.list();
for (Emp emp : list) {
System.out.println(emp);
}
}
/**
* 12.查询 员工姓名包含 A/a 的员工信息
* ilike 模糊查询 忽略大小写
*/
@Test
public  void test12(){
Criteria criteria=session.createCriteria(Emp.class);
//给查询增加条件
        criteria.add(Restrictions.ilike("empName", "%A%"));
List<Emp> list = criteria.list();
for (Emp emp : list) {
System.out.println(emp);
}
}

/**
* 13.查询 员工姓名包含 A 的员工信息
* like 模糊查询
* MatchMode: 我们value值出现的位置 可以替换%
* MatchMode.ANYWHERE:前后
* MatchMode.END:后
* MatchMode.START:前
*/
@Test
public  void test13(){
Criteria criteria=session.createCriteria(Emp.class);
//给查询增加条件
        criteria.add(Restrictions.like("empName", "A",MatchMode.ANYWHERE));
List<Emp> list = criteria.list();
for (Emp emp : list) {
System.out.println(emp);
}
}

/**
* 14.聚合函数 和 投影查询 Projections
*
* 查询 薪水的最大值 最小值 总薪水 和平均薪水
* criteria.setProjection 是赋值操作
* 如果不清空Projection
* 之前给的值 会带入下次的查询
*/
@Test
public  void test14(){
Criteria criteria = session.createCriteria(Emp.class);
criteria.setProjection(
Projections.projectionList()
.add(Projections.max("salary"))
.add(Projections.min("salary"))
.add(Projections.sum("salary"))
.add(Projections.avg("salary"))
);
//criteria.setProjection(null); 清空所有的约束
        List<Object[]> list = criteria.list();
for (Object[] objects : list) {
System.out.println("最大薪水："+objects[0]);
System.out.println("最小薪水："+objects[1]);
System.out.println("总薪水："+objects[2]);
System.out.println("平均薪水："+objects[3]);
}
}
/**
* 15. 分页查询
* 查询姓名中 包含 "员工" 的 并且 按照 薪水 降序排列
*/
@Test
public  void test15(){
//查询总记录数
        int count=((Long)session.createCriteria(Emp.class)
.add(Restrictions.like("empName", "员工",MatchMode.ANYWHERE))
.setProjection(Projections.count("empName")).uniqueResult()).intValue();
System.out.println("总记录数是："+count);
//当前页
        int  pageIndex=1;
//页大小
        int  pageSize=4;
//总页数
        int  totalPageSize=(count%pageSize==0)?(count/pageSize):(count/pageSize+1);
//进行薪水的降序排列
       Criteria criteria=    session.createCriteria(Emp.class)
.add(Restrictions.like("empName", "员工",MatchMode.ANYWHERE))
.addOrder(Order.desc("salary"));
//设置 当前页 以及页大小
       List<Emp> list = criteria.setFirstResult((pageIndex-1)*pageSize).setMaxResults(pageSize).list();
for (Emp emp : list) {
System.out.println(emp);
}
}

/**
* 16:面试题
* DetachedCriteria和 Criteria的区别
* 相同点：都能用来 做查询操作
* 不同点：
* 01.DetachedCriteria在创建的时候 不需要session！
* 02.真正执行查询的时候getExecutableCriteria(session)才使用session
* 03.DetachedCriteria自身可以作为一个参数
*
* 薪水 大于 平均值的员工信息
*/
@Test
public  void test16(){
//得到DetachedCriteria对象
        DetachedCriteria criteria= DetachedCriteria.forClass(Emp.class)
.setProjection(Projections.avg("salary"));
//执行查询
        double  avg=(double) criteria.getExecutableCriteria(session).uniqueResult();
System.out.println("薪水的平均值是："+avg);

//薪水 大于 平均值的员工信息
        List<Emp> list = session.createCriteria(Emp.class).add(
Property.forName("salary").gt(criteria)).list();
for (Emp emp : list) {
System.out.println(emp);
}
}

}

时间： 2024-10-09 05:40:59

hibernate11--Criteria查询的相关文章

Criteria查询初学者的采纳点哦

一.Hibernate提供了5种检索对象的方式 1.导航对象图检索方式:根据已经加载的对象导航到其他对象    from  Emp e group by e.dept.deptName 2.OID检索方式:按照对象的OID来检索对象  get/load 3.HQL检索方式:使用面向对象的HQL查询语言 4.QBC检索方式:使用QBC(Query By Criteria)API来检索对象,这种API封装了基于字符串形式的查询语句,提供了更加面向对象的查询接口 5.本地SQL检索方式:使用本地数据库

Hibernate(十二)Criteria查询

一.简述 Criteria是一种比hql更面向对象的查询方式.Criteria 可使用 Criterion 和 Projection 设置查询条件.可以设置 FetchMode(联合查询抓取的模式 ) ,设置排序方式,Criteria 还可以设置 FlushModel (冲刷 Session 的方式)和 LockMode (数据库锁模式). Criteria本身只是查询的容器.Criteria查询又称对象查询 Criteria查询采用面向对象的方式封装查询条件.由Hibernater自动生成SQ

hibernate条件查询 Criteria查询

criteria查询 的方法详解 1.获取 criteria对象 Criteria criteria = this.getSession().createCriteria(Record.class); 红色部分为实体类,此处的Record代表信息记录类 2.追加条件 criteria = criteria.add(Expression.eq("level", 1)); 红色部分 Expression.eq("",""),两个参数第一个是 实体类中

Nhibernate系列学习之（三） Criteria查询表达式增删改查

Criteria查询表达式: 正如我们所见,Expression对查询语句的表达式进行了封装和限制,下表列出了Expression所有的方法,以及每个方法所对应的查询表达式及其限制. Restrictions的用法: 方法 说明 Restrictions.eq ＝ Restrictions.allEq 利用Map来进行多个等于的限制 Restrictions.gt > Restrictions.ge >＝ Restrictions.lt < Restrictions.le <＝ R

Hibernate框架之HQL查询与Criteria 查询的区别

Hibernate框架提供了HQL查询和Criteria 查询.下面对这两种查询分别做个例子.也好对这两种查询方法有个大概的了解.就用房屋信息表做例子,查询所有房屋信息. HQL语句查询所有房屋信息: /* * 查询所有房屋 * * (non-Javadoc) * @see Dao.HouseDao#selecthouse() */ public List<House> selecthouse() { // TODO Auto-generated method stub //获取连接 Sess

Hibernate检索方式和Criteria查询的讲解

Hibernate框架5种检索方式 1.导航对象图检索方式:根据已经加载的对象导航到其他对象 2.OID检索方式:按照对象的OID来检索对象 3.HQL检索方式:使用面向对象的HQL查询语言 4.QBC检索方式:使用QBC(Query By Criteria)API来检索对象,这种API封装了基于字符串形式的查询语句,提供了更加面向对象的查询接口 5.本地SQL检索方式:使用本地数据库的SQL查询语句 这次重点讲解Criteria查询,首先我们先了解一下它.  Criteria 查询采用面向对象

Criteria查询数据

Criteria介绍: Criteria查询是Hibernate提供的一种查询方式,与HQL基于字符串的查询形式完全不同.Hibernate提供了org.hiberanee.Criteria 接口.orghibernate.criterionCriterion 接口和org.hibernate.criterion.Restrictions类等CriteriaAPI,用于支持在运行时动态生成查询语句. 简单使用Criteria: 先面是有一个简单的例子来介绍一下Criteria: Session

hibernate框架学习笔记7：HQL查询、Criteria查询

HQL查询:hibernate独有的查询语言 适用于不复杂的多表查询 示例: 实体类: package domain; public class Customer { private Long cust_id; private String cust_name; private String cust_source; private String cust_industry; private String cust_level; private String cust_linkman; priv

JPA criteria 查询:类型安全与面向对象

参考:https://my.oschina.net/zhaoqian/blog/133500 一.JPA元模型概念,及使用 在JPA中,标准查询是以元模型的概念为基础的.元模型是为具体持久化单元的受管实体定义的.这些实体可以是实体类,嵌入类或者映射的父类.提供受管实体元信息的类就是元模型类. 描述受管类的状态和他们之间的关系的静态元模型类可以 1.从注解处理器产生 2.从程序产生 3.用EntityManager访问. 如下code,一个简单的实体类package com.demo.entiti

Criteria查询及注解

HQL和Criteria支持的比较运算 HQL运算符 Criteria运算方法 说明 = SimpleExpression Restrictions.eq(String propertyName,Object value) 等于 <> SimpleExpression Restrictions.ne(String propertyName,Object value) 不等于 > SimpleExpression Restrictions.gt(String propertyName,Ob