Hiberante框架学习(二)

Hibernate的查询的方式

OID查询

      OID检索 Hibernate根据对象的OID(主键)进行检索

      使用get方法 Customer customer = session.get(Customer.class,1l);

      使用load方法 Customer customer = session.load(Customer.class,1l);

对象导航检索

       对象导航检索 Hibernate根据一个已经查询到的对象,获得其关联的对象的一种查询方式。

       LinkMan linkMan = session.get(LinkMan.class,1l);

       Customer customer  = linkMan.getCustomer();

       Customer customer = session.get(Customer.class,2l);

      Set<LinkMan> linkMans = customer.getLinkMans();

HQL检索

      HQL查询:Hibernate Query Language,Hibernate的查询语言,是一种面向对象的方式的查询语言,语法类似SQL。通过session.createQuery(),用于接收一个HQL进行查询方式。

 简单查询

 

Session session = HibernateUtil.getCurrentSession();
Transaction transaction = session.beginTransaction();
Query query = session.createQuery("from Customer");
List<Customer> list = query.list();
//SQL支持*号的写法 select * from cst_customer;HQL不支持
//Query query = session.createQuery("select * from Customer");//报错
//List<Customer> list = query.list();
for (Customer customer : list) {
    System.out.println(customer);
}
transaction.commit();

别名查询

Session session = HibernateUtil.getCurrentSession();
Transaction transaction = session.beginTransaction();
Query query = session.createQuery("select c from Customer c");
List<Customer> list = query.list();

for (Customer customer : list) {
    System.out.println(customer);
}
transaction.commit();

排序查询

Session session = HibernateUtil.getCurrentSession();
Transaction transaction = session.beginTransaction();
//默认情况
//List<Customer> list = session.createQuery("from Customer order by cust_id").list();
//设置降序排序 升序使用asc 降序使用desc
List<Customer> list = session.createQuery("from Customer order by cust_id desc").list();

for (Customer customer : list) {
    System.out.println(customer);
}
transaction.commit();

条件查询

Session session = HibernateUtil.getCurrentSession();
Transaction transaction = session.beginTransaction();
//按位置绑定
//一个条件
/*
Query query = session.createQuery("from Customer where cust_name = ?");
query.setParameter(0,"张飞");
List<Customer> list = query.list();
*/
//多个条件
/*
Query query = session.createQuery("from Customer where cust_source = ? and cust_name like ?");
query.setParameter(0, "小广告");
query.setParameter(1,"张%");
List<Customer> list = query.list();
*/
//按名称绑定
Query query = session.createQuery("from Customer where cust_source = :aaa and cust_name like :bbb");
query.setParameter("aaa", "网络推广");
query.setParameter("bbb","张%");
List<Customer> list = query.list();
for (Customer customer : list) {
    System.out.println(customer);
}
transaction.commit();

投影查询

投影查询 查询对象的某个或某些属性。

Session session = HibernateUtil.getCurrentSession();
Transaction transaction = session.beginTransaction();
//单个属性
/*
List<Object> list = session.createQuery("select c.cust_name from Customer c").list();
for (Object object : list){
    System.out.println(object);
}
*/
//多个属性
/*
List<Object[]> list = session.createQuery("select c.cust_name, c.cust_source from Customer c").list();
for (Object[] objects : list){
    System.out.println(Arrays.toString(objects));
}
*/
//多个属性封装到对象中,需提供无参和有参构造方法
List<Customer> list = session.createQuery("select new Customer(c.cust_name, c.cust_source) from Customer c").list();
for (Customer customer : list) {
    System.out.println(customer);
}
transaction.commit();

分页查询

Session session = HibernateUtil.getCurrentSession();
Transaction transaction = session.beginTransaction();
Query query = session.createQuery("from LinkMan");
query.setFirstResult(10);
query.setMaxResults(10);
List<LinkMan> list = query.list();
for (LinkMan linkMan : list) {
    System.out.println(linkMan);
}
transaction.commit();

分组统计查询

Session session = HibernateUtil.getCurrentSession();
Transaction transaction = session.beginTransaction();
//count(),max(),min(),avg(),sum()
/*
Query query = session.createQuery("select count(*) from Customer");
Long sum = (Long)query.uniqueResult();
System.out.println(sum);
*/
Query query = session.createQuery("select cust_source, count(*) from Customer group by cust_source having count(*) > 1");
List<Object[]> list = query.list();
for (Object[] objects : list){
    System.out.println(Arrays.toString(objects));
}

transaction.commit();

多表查询

       SQL的多表查询

       连接查询

       交叉连接 笛卡尔积

       select * from A,B;

       内连接    :inner join (inner 可以省略)

       隐式内连接

       select * from A,B where A.id = B.aid;

      显示内连接

      select * from A inner join B on A.id = B.aid;

      外连接

      左外连接:left outer join(outer 可以省略)

      select * from A left outer join B on A.id= B.aid;

     右外连接:right outer join(outer 可以省略)

     select * from A right outer join B on A.id = B.aid;

     子查询

    HQL的多表查询

    连接查询

    交叉连接

    内连接

           显示内连接

           隐式内连接

           迫切内连接

   外连接

          左外连接

          右外连接

         迫切左外连接

QBC检索

QBC查询 Query By Criteria,条件查询。是一种更加面向对象化的查询的方式。

简单查询

 

排序查询

 

分页查询

 条件查询

 

统计查询

 离线条件查询(SSH)---DetachedCriteria

 

SQL检索

SQL查询

SQL查询:通过使用sql语句进行查询

 Hibernate的抓取策略(优化)

延迟加载

延迟加载:lazy(懒加载)。执行到该行代码的时候,不会发送语句去进行查询,在真正使用这个对象的属性的时候才会发送SQL语句进行

类级别的延迟加载

       指的是通过load方法查询某个对象的时候,是否采用延迟。session.load(Customer.class,1l);

       

       类级别延迟加载通过<class>上的lazy进行配置,如果让lazy失效

              将lazy设置为false

              将持久化类使用final修饰

              Hibernate. Initialize()

关联级别的延迟加载

       指的是在查询到某个对象的时候,查询其关联的对象的时候,是否采用延迟加载。

       Customer customer = session.get(Customer.class,1l);

       customer.getLinkMans();----通过客户获得联系人的时候,联系人对象是否采用了延迟加载,称为是关联级别的延迟

       抓取策略往往会和关联级别的延迟加载一起使用,优化语句。

抓取策略

       通过一个对象抓取到关联对象需要发送SQL语句,SQL语句如何发送,发送成什么样格式通过策略进行配置。

       通过<set>或者<many-to-one>上通过fetch属性进行设置

       fetch和这些标签上的lazy如何设置优化发送的SQL语句

<set>上的fetch和lazy

      fetch:抓取策略,控制SQL语句格式

      select               :默认值,发送普通的select语句,查询关联对象

      join                    :发送一条迫切左外连接查询关联对象

     subselect         :发送一条子查询查询其关联对象

     lazy:延迟加载,控制查询关联对象的时候是否采用延迟

     true                  :默认值,查询关联对象的时候,采用延迟加载

     false                 :查询关联对象的时候,不采用延迟加载

     extra                 :及其懒惰

在实际开发中,一般都采用默认值。如果有特殊的需求,可能需要配置join

<many-to-one>上的fetch和lazy

       fetch        :抓取策略,控制SQL语句格式

       select       :默认值,发送普通的select语句,查询关联对象

        join          :发送一条迫切左外连接

        lazy  :延迟加载,控制查询关联对象的时候是否采用延迟

        proxy       :默认值,proxy具体的取值,取决于另一端的<class>上的lazy的值

        false         :查询关联对象,不采用延迟

        no-proxy  :(不会使用)

在实际开发中,一般都采用默认值。如果有特殊的需求,可能需要配置join

批量抓取

 

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值