Hibernate框架查询方式

2021-06-10 22:05

阅读：532

标签：构造方法 mit sum 参数转化为什么简单的 _id ble

1. 唯一标识OID的检索方式
    * session.get(对象.class,OID)
2. 对象的导航的方式

public class Demo {

    /**
     * 演示对象导航的方式
     */
    @Test
    public void run1() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        //先查询1号客户通过OID查询
        Customer customer = session.get(Customer.class, 1L);
        //查询该客户下联系人集合大小
        System.out.println(customer.getLinkmans().size());
        tx.commit();
    }
    
    /**
     * 查询联系人所属的客户
     */
    @Test
    public void run2() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        //查询2号联系人通过OID查询
        Linkman linkman = session.get(Linkman.class, 2L);
        System.out.println(linkman.getCustomer().getCust_name());
        tx.commit();
    }
}

HQL方式的基本查询

/**
 * HQL方式的基本查询
 * 
 * @author bamaw
 */
public class Demo2 {
    /**
     * 基本查询
     */
    @Test
    public void run1() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        // 创建HQL的查询接口
        Query query = session.createQuery("from Customer");
        // 查询 //泛型写上，因为数据就封装进去了
        List list = query.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }

    /**
     * 支持方法链编程 以及设置条件的查询
     */
    @Test
    public void run2() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        // 创建HQL的查询接口
        /**
         * 如果设置条件
         * session.createQuery("from Customer").setParameter(index,参数).list()
         * index表示参数第几位(从0开始) 
         * 如：session.createQuery("from User where id = ? and name = ?")
         * id就是第0位 name第一位 
         */
        List list = session.createQuery("from Customer").list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
    
    /**
     * 使用别名方式查询
     * 注意：如果在HQL语句中这样写
     * select * from Customer 语法错误 不能出现*号
     * 这样我们可以通过起别名的方式
     * 如：from Customer c
     *       select c from Customer c;
     * 
     */
    @Test
    public void run3() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        List list = session.createQuery("select c from Customer c ").list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
    
    /**
     * 排序查询
     * SQL语句中  order by 字段  asc升序（默认）/desc降序
     * HQL语句中关键字是一样的
     */
    @Test
    public void run4() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        //我给起了个别名 还可以from Customer order by cust_id desc
        List list = session.createQuery("from Customer c order by c.cust_id desc").list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
    
    /**
     * 分页查询  mysql中 limit ?,?  ---第一个?号  （当前页-1）*pageSize
     *                                   第二个?号  pageSize
     * setFirstResult(0);     值 = （当前页-1）*pageSize
     * setMaxResults(2);    每页查询的最大条数
     */
    @Test
    public void run5() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        Query query = session.createQuery("from Customer");
        query.setFirstResult(0);//从哪条记录开始,如果查询是从第一条开始,那么是0
        /**
         * 查询第二页query.setFirstResult(3);
         * 值 = （当前页-1）*pageSize
         */
        query.setMaxResults(3);//每页显示多少条
        List list = query.list();
        //这里可以写成方法链的形式
        //List list = session.createQuery("from Customer").setFirstResult(0).setMaxResults(3).list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
    
    /**
     * 按条件查询
     */
    @Test
    public void run6() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        Query query = session.createQuery("from Customer where cust_id > ? and cust_level = ?");
        
        /**
         * 我们以前用过
         * Query query = session.createQuery("from Customer where cust_level = ?");
         * 传入值
         * query.setString(0,"高级");
         * 还有一种方式
         *  Query query = session.createQuery("from Customer where cust_level = :cust_level");
         *  query.setString("cust_level","高级");
         */
        
        /**
         * setParameter("?号的位置，默认从0开始","参数的值"); 不用考虑参数的具体类型
         * 按位置绑定参数的条件查询（指定下标值，默认从0开始）
         * 按名称绑定参数的条件查询（HQL语句中的 ? 号换成 :名称 的方式）
         */
        query.setParameter(0, 2L);
        query.setParameter(1, "高级");
        List list = query.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
}

投影查询

/**
     * 我不想查所有字段，只查指定的几个字段，
     * 那么这个查询结果出来不能封装到对象当中的，这个时候就采用投影去查询
     * 先演示为什么不能
     * 返回的是对象数组
     * 打印的结果
     * Hibernate: 
     *    select
     *    customer0_.cust_name as col_0_0_,
     *    customer0_.cust_level as col_1_0_ 
     *    from
     *   cst_customer customer0_
     *    [bamaw, 高级]
     *    [巴莫, 初级]
     *    如果我就想把这些数据放到一个对象中，那么就new ,很麻烦
     *    那么如果我就想返回对象，我们可以采用投影查询,它支持我们返回一个对象
     */
    @Test
    public void run7() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        Query query = session.createQuery("select cust_name,cust_level from Customer");
        List

QBC查询方式：

/**
 * QBC查询 按条件查询(推荐)
 * @author bamaw
 *
 */
public class Demo3 {
    
    //简单的查询
    @Test
    public void run1() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        Criteria criteria = session.createCriteria(Customer.class);
        List list = criteria.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
    /**
     * QBC排序,调用方法
     */
    @Test
    public void run2() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        Criteria criteria = session.createCriteria(Customer.class);
        //调用排序方法addOrder()   
        criteria.addOrder(Order.desc("cust_id"));//降序
        List list = criteria.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
    
    /**
     * QBC分页 完全的面向对象
     */
    @Test
    public void run3() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        Criteria criteria = session.createCriteria(Customer.class);
        criteria.setFirstResult(0);//(当前页-1)*pageSize
        criteria.setMaxResults(3);//pageSize
        List list = criteria.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
    
    /**
     * 条件查询（Criterion是查询条件的接口,Restrictions可不是criteria的实现类 ,而是
     * Restrictions类是Hibernate框架提供的工具类，使用该工具类来设置查询条件）
     * 条件查询使用Criteria接口的add方法，用来传入条件。
     * 使用Restrictions的添加条件的方法，来添加条件，例如：
     * Restrictions.eq           -- 相等
     * Restrictions.gt           -- 大于号
     * Restrictions.ge           -- 大于等于
     * Restrictions.lt           -- 小于
     * Restrictions.le           -- 小于等于
     * Restrictions.between      -- 在之间
     * Restrictions.like         -- 模糊查询
     * Restrictions.in           -- 范围
     * Restrictions.and          -- 并且
     * Restrictions.or           -- 或者
     */
    @Test
    public void run4() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        Criteria criteria = session.createCriteria(Customer.class);
        criteria.add(Restrictions.eq("cust_level", "高级"));
        /**
         * 加入继续想加条件，可以继续在后面写
         * criteria.add(Restrictions.gt("cust_id", 1L));
         */
        List list = criteria.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
    
    /**
     * in查询
     */
    @Test
    public void run5() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        Criteria criteria = session.createCriteria(Customer.class);
        //SQL:select * from cst_customer where cust_id in(1,2,6); 注意：：：6不包含
        List params = new ArrayList();
        params.add(1L);
        params.add(2L);
        params.add(6L);
        //使用in查询
        criteria.add(Restrictions.in("cust_id", params));
        List list = criteria.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
    }
}

    /**
     * or查询 
     */
    @Test
    public void run6() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        Criteria criteria = session.createCriteria(Customer.class);
        criteria.add(Restrictions.or(Restrictions.gt("cust_id", 1L), Restrictions.eq("cust_level", "初级")));
        List list = criteria.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
    
    /**
     * 判断某个字段为空的所有数据
     * Restrictions.isNull("cust_phone")
     */
    @Test
    public void run7() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        Criteria criteria = session.createCriteria(Customer.class);
        //查看在cust_phone为空的数据
        criteria.add(Restrictions.isNull("cust_phone"));
        List list = criteria.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
    
    /**
     * QBC聚合函数的查询
     */
    @Test
    public void run8() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        Criteria criteria = session.createCriteria(Customer.class);
        criteria.setProjection(Projections.count("cust_id"));
        List list = criteria.list();
        long count = list.get(0).longValue();
        System.out.println(count);
        tx.commit();
    }
    
    /**
     * 强调问题：聚合函数的查询
     * select count(lkm_id) from cst_linkman
     * 然后我们又想继续查select * from cst_linkman
     */
    @Test
    public void run9() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        Criteria criteria = session.createCriteria(Customer.class);
        criteria.setProjection(Projections.count("cust_id"));
        List list = criteria.list();
        long value = list.get(0).longValue();
        System.out.println(value);
        
        //又想继续查select * from cst_linkman
        criteria.setProjection(null);
        List list2 = criteria.list();
        for (Customer customer : list2) {
            System.out.println(customer);
        }
    }
    
    /**
     * 统计查询
     */
    @Test
    public void run10() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        Criteria criteria = session.createCriteria(Customer.class);
        criteria.setProjection(Projections.rowCount());
        Long value = (Long) criteria.uniqueResult();
        System.out.println(value);
        tx.commit();
    }

public class Demo4 {
    
    /**
     *     QBC离线条件查询
     *  离线条件查询使用的是DetachedCriteria接口进行查询，
     *  离线条件查询对象在创建的时候，不需要使用Session对象，
     *  只是在查询的时候使用Session对象即可。
     */
    @Test
    public void run() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        // 获得一个离线条件查询的对象
        DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
        detachedCriteria.add(Restrictions.eq("cust_level", "高级"));
        // 离线条件查询对象与session绑定.
        List list = detachedCriteria.getExecutableCriteria(session).list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        tx.commit();
    }
    
    /**
     * 测试SQL语句的查询
     */
    @Test
    public void run2() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        //创建SQL查询接口
        SQLQuery query = session.createSQLQuery("select * from cst_customer");
        List

Hibernate框架查询方式

标签：构造方法 mit sum 参数转化为什么简单的 _id ble

原文地址：http://www.cnblogs.com/bamaw/p/7287318.html

上一篇：thinkphp 点击某个class提交post值，返回回来用一个弹窗插件，提示返回来要说的话

下一篇：CSS3实现投影效果

文章来自：搜素材网的编程语言模块，转载请注明文章出处。
文章标题：Hibernate框架查询方式
文章链接：http://soscw.com/index.php/essay/93337.html

亲，登录后才可以留言！

Hibernate框架查询方式

评论

热门文章

推荐文章

最新文章

置顶文章