Hibernate查询方式

　　Hibernate主要提供了三种查询方式

　　　　·HQL

　　　　·Criteria

　　　　·Native SQL Queries

 

HQL

　　HQL是Hibernate Query Language的简称。是Hibernate自己搞的一套面向对象的查询方式。最大的好处就是移植性。在更改数据库的时候，会根据数据库生成对应的SQL文。

　　HQL的查询主要是通过org.hibernate.query.Query,可以通过Session来获得一个Query。如果HQL是一个命名的Query这可以通过Sesson的getNamedQuery方法，否则的话可以通过creatQuery方法。

　　我们可以看看Query接口。

　　·首先它时候一个接口，支持泛型操作 public interface Query<R> extends TypedQuery<R>,COmmonQueryContract.

　　·List<R> list():返回一个集合

　　·R uniqueResult():返回一个实例，如果没查询到则返回null

　　·Query<R> setFetchSize(int fetchSize):设置查询的记录数的提示

　　·Query<R> setFirstResult(int startPosition):设置查询开始记录的位置

　　·Query<R> setMaxResults(int maxResult):设置查询的最大记录数

　　　　setFirstResult(int startPosition)+setMaxResults(int maxResult)配合设置，可以实现分页查询。

　　·Query<R> setParameter(xx,xx,xx？)：设置参数

查询语句：

　　查询语句的基本结构

select_statement :: =
    [select_clause]
    from_clause
    [where_clause]
    [groupby_clause]
    [having_clause]
    [orderby_clause]

最简单的查询与语句如下：

List<Person> persons=session.createQuery("from Person").list();

更新语句

　　更新的基本结构

update_statement ::=
    update_clause [where_clause]

update_clause ::=
    UPDATE entity_name [[AS] identification_variable]
    SET update_item {, update_item}*

update_item ::=
    [identification_variable.]{state_field | single_valued_object_field} = new_value

new_value ::=
    scalar_expression | simple_entity_expression | NULL

删除语句

　　删除语句的基本结构

delete_statement ::=
    delete_clause [where_clause]

delete_clause ::=
    DELETE FROM entity_name [[AS] identification_variable]

插入语句

　　插入语句的基本结构

insert_statement ::=
    insert_clause select_statement

insert_clause ::=
    INSERT INTO entity_name (attribute_list)

attribute_list ::=
    state_field[, state_field ]*

 

实例：

有如下表：

package com.fuwh.service;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.query.Query;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.fuwh.model.Person;
import com.fuwh.model.Phone;

public class DoTest {
    
    //标准的sessionFactory取得方式
    private SessionFactory sessionFactory;
    
    @Before
    public void setUp() throws Exception {
        final StandardServiceRegistry registry=new StandardServiceRegistryBuilder().configure().build();
        try {
            sessionFactory=new MetadataSources(registry).buildMetadata().buildSessionFactory();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
            StandardServiceRegistryBuilder.destroy(registry);
        }
    }

    @After
    public void tearDown() throws Exception {
        if(sessionFactory != null){
            sessionFactory.close();
        }
    }

    @Test
    public void testHQL() {
        Session session=sessionFactory.openSession();
        session.beginTransaction();
        
        Query query=session.createQuery("select p  from Person p join p.phones ph where ph.number like :number order by p.age desc");
        query.setParameter("number", "11%");
        List ls=query.getResultList();
        Iterator it=ls.iterator();
        while(it.hasNext()){
            Person phone=(Person)it.next();
            System.out.println(phone);
        }
        
        session.getTransaction().commit();
        session.close();
        
    }
}

 

Criteria Queries

　　Criteria Queries提供了一种替代HQL，Native SQL Queries的类型安全的查询方式。

package com.fuwh.service;

import java.util.Iterator;
import java.util.List;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.criterion.Restrictions;
import org.hibernate.query.Query;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.fuwh.model.Person;
import com.fuwh.model.Phone;

public class DoTest {
    
    //标准的sessionFactory取得方式
    private SessionFactory sessionFactory;
    
    @Before
    public void setUp() throws Exception {
        final StandardServiceRegistry registry=new StandardServiceRegistryBuilder().configure().build();
        try {
            sessionFactory=new MetadataSources(registry).buildMetadata().buildSessionFactory();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
            StandardServiceRegistryBuilder.destroy(registry);
        }
    }

    @After
    public void tearDown() throws Exception {
        if(sessionFactory != null){
            sessionFactory.close();
        }
    }

    
    @Test
    public void testCriteria() {
        Session session=sessionFactory.openSession();
        session.beginTransaction();
        
        CriteriaBuilder builder=session.getCriteriaBuilder();    //创建一个Criteria生成器
        CriteriaQuery<Person> criteria = builder.createQuery(Person.class);    //创建一个CriteriaQuery对象，指定至返回值类型为Person对象
        Root<Person> root=criteria.from(Person.class);//指定查询的root类型
        criteria.select(root);//指定返回的结果集中的类型
        criteria.where(builder.equal(root.get("name"), "北京人"));//指定查询条件
        List<Person> ls=session.createQuery(criteria).getResultList();//通过CriteriaQuery创建查询语句，并查询
        
        Iterator<Person> it=ls.iterator();
        while(it.hasNext()){
            Person phone=(Person)it.next();
            System.out.println(phone);
        }
        
        session.getTransaction().commit();
        session.close();
        
    }
}

 

 

Native SQL Queries

　　Native SQL Queries允许用户直接使用本地数据库的SQL语句来执行操作。

 

package com.fuwh.service;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.query.Query;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.fuwh.model.Person;
import com.fuwh.model.Phone;

public class DoTest {
    
    //标准的sessionFactory取得方式
    private SessionFactory sessionFactory;
    
    @Before
    public void setUp() throws Exception {
        final StandardServiceRegistry registry=new StandardServiceRegistryBuilder().configure().build();
        try {
            sessionFactory=new MetadataSources(registry).buildMetadata().buildSessionFactory();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
            StandardServiceRegistryBuilder.destroy(registry);
        }
    }

    @After
    public void tearDown() throws Exception {
        if(sessionFactory != null){
            sessionFactory.close();
        }
    }

    @Test
    public void testHQL() {
        Session session=sessionFactory.openSession();
        session.beginTransaction();
        
        Query query=session.createSQLQuery("select * from person where age > 20").addEntity(Person.class);
        
        List<Person> ls=query.list();
        Iterator<Person> it=ls.iterator();
        while(it.hasNext()){
            Person phone=(Person)it.next();
            System.out.println(phone);
        }
        
        session.getTransaction().commit();
        session.close();
        
    }
}

 

　　当然还有许多其他的更复杂的查询，可以参考官方文档。