1. 查询基础理论
2. 创建查询 - Query 和 TypedQuery
3. 创建查询 - CriteriaQuery
4. 创建查询 - Hibernate的查询接口
5. 准备查询
6. 执行查询
7. 命名查询
8. 查询提示 - hints

查询基础理论

1. 创建查询
2. 准备该查询, 包括传递参数, 设置提示和分页选项等
3. 运行查询获取结果

创建查询 - Query 和 TypedQuery

Query query = em.createQuery("SELECT m FROM MessageVersion m");

TypedQuery<MessageVersion> query = em.createQuery("SELECT m FROM MessageVersion m", MessageVersion.class);
List<MessageVersion> messageVersionList = query.getResultList();

TypedQuery<MessageVersion> query = em.createQuery("SELECT m FROM MessageVersion m WHERE m.id = :id", MessageVersion.class).setParameter("id", 4L);

MessageVersion messageVersion = query.getSingleResult();

创建查询 - CriteriaQuery

public class BasicSearchInterfaces {

    public static EntityManager getEM() {
        EntityManagerFactory emf =
                CaveatEmptorUtil.getEntityManagerFactory();
        return emf.createEntityManager();
    }

    public static EntityManagerFactory getEMF() {
        return CaveatEmptorUtil.getEntityManagerFactory();
    }

    @Test
    public void testBasicInterfaces() {
        EntityManager em = getEM();
        em.getTransaction().begin();

        CriteriaBuilder cb = em.getCriteriaBuilder();

        //也可以从EMF中获取
        //CriteriaBuilder cb2 = getEMF().getCriteriaBuilder();

        //创建一个CriteriaQuery对象
        CriteriaQuery criteriaQuery = cb.createQuery();

        //.select表示查询, 然后传入.from()函数的结果, 这行语句从左向右念, 就很像SQL语句的 SELECT FROM 顺序
        criteriaQuery.select(criteriaQuery.from(MessageVersion.class));

        //依然使用em.createQuery重载方法来创建查询
        Query query = em.createQuery(criteriaQuery);

        //使用查询获取结果
        List<MessageVersion> messageVersionList = query.getResultList();

        System.out.println(messageVersionList);

        em.getTransaction().commit();
    }
}

CriteriaQuery<MessageVersion> criteriaQuery = cb.createQuery(MessageVersion.class);
criteriaQuery.select(criteriaQuery.from(MessageVersion.class));

//查看源码可以知道, 这个重载方法是: <T> TypedQuery<T> createQuery(CriteriaQuery<T> var1);
TypedQuery<MessageVersion> query = em.createQuery(criteriaQuery);

List<MessageVersion> messageVersionList = query.getResultList();

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<MessageVersion> criteriaQuery = cb.createQuery(MessageVersion.class);

//相当于单独抽出了.from()函数的结果, 可以将其认为是查到的那个结果
Root<MessageVersion> m = criteriaQuery.from(MessageVersion.class);

//这里要注意的是, 使用CriteriaBuilder创建一个WHERE条件, 这里用的是equal()方法, 第一个参数是属性名称, 第二个是值
//这行语句念起来也很像 SELECT ... FROM ... WHERE id = 4
criteriaQuery.select(m).where(cb.equal(m.get("id"), 4L));

TypedQuery<MessageVersion> query = em.createQuery(criteriaQuery);

MessageVersion messageVersion = query.getSingleResult();

System.out.println(messageVersion);

创建查询 - Hibernate的查询接口

1. org.hibernate.Query, 已过时, 被org.hibernate.query.Query替代
2. org.hibernate.SQLQuery, 已过时, 被org.hibernate.query.NativeQuery替代
3. org.hibernate.Criteria

Query<MessageVersion> query = session.createQuery("SELECT m FROM MessageVersion m", MessageVersion.class);
Query<MessageVersion> query1 = session.createQuery("SELECT m FROM MessageVersion m WHERE m.id = :id", MessageVersion.class).setParameter("id", 4L);

NativeQuery query = session.createSQLQuery("SELECT {m.*} FROM messageversion {m}").addEntity("m", MessageVersion.class);
System.out.println(query.getResultList());

准备查询 - 绑定命名参数 和 绑定顺序参数

1. 绑定命名参数
2. 绑定顺序参数
3. 分页
4. Hibernate特有的游标查询

Query<Sender> senderQuery = em.createQuery("SELECT s FROM Sender s WHERE s.messageVersion = :mv order by s.id", Sender.class);
MessageVersion messageVersion = em.find(MessageVersion.class, 4L);
senderQuery.setParameter("mv", messageVersion);
System.out.println(senderQuery.getResultList());

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<MessageVersion> criteriaQuery = cb.createQuery(MessageVersion.class);
Root<MessageVersion> m = criteriaQuery.from(MessageVersion.class);

//注意红色部分, 实际上相当于将原来equal方法第二个参数, 从一个具体值替换成了一个 cb.parameter() 方法的结果, 这个方法第一个参数是参数类型, 第二个参数是参数的名称
criteriaQuery.select(m).where(cb.equal(m.get("id"), cb.parameter(Long.class, "number")));

//在准备查询的时候, 设置参数的名称时, 就需要使用cb.parameter()中指定的方法
TypedQuery<MessageVersion> query = em.createQuery(criteriaQuery).setParameter("number", 4L);

Query query = em.createQuery("SELECT m FROM MessageVersion m WHERE m.id> ?1 and m.id < ?2 order by m.id", MessageVersion.class);

query.setParameter(1, 4L);
query.setParameter(2, 6L);

System.out.println(query.getResultList());

Query query = em.createQuery("SELECT s FROM Sender s ORDER BY s.id", Sender.class);

query.setFirstResult(10).setMaxResults(5);

System.out.println(query.getResultList());

@Test
public void testCursor() {
    SessionFactory sessionFactory = getSessionFactory();
    Session session = sessionFactory.getCurrentSession();

    session.getTransaction().begin();

    org.hibernate.query.Query<Sender> query = session.createQuery("SELECT s FROM Sender s order by s.id", Sender.class);

    //指定某种游标模式, 然后从Query中创建一个游标对象
    org.hibernate.ScrollableResults resultsWithCursor = query.scroll(ScrollMode.SCROLL_INSENSITIVE);

    //游标移动到最后
    resultsWithCursor.last();

    //当前的总数就是游标的位置+1, 可见游标是从位置0开始移动的, 这个索引像数组的索引.
    int total = resultsWithCursor.getRowNumber() + 1;
    System.out.println("总数量是: " + total);

    //可以关闭游标了, 其实此时所有数据都已经被查询出来
    resultsWithCursor.close();

    //可以反复多次执行查询
    query.setFirstResult(10).setMaxResults(5);
    System.out.println(query.getResultList());
    System.out.println("改变查询的分页");

    query.setFirstResult(5).setMaxResults(10);
    System.out.println(query.getResultList());

    session.getTransaction().commit();
    session.close();
    sessionFactory.close();

}

执行查询

TypedQuery<String> query = em.createQuery("SELECT s.name FROM Sender s ORDER BY s.id", String.class);

List<String> names = query.getResultList();

System.out.println(names);

TypedQuery<Long> query = em.createQuery("SELECT count(s) FROM Sender s", Long.class);

Long numbers = query.getSingleResult();

org.hibernate.query.Query<Sender> query = session.createQuery("SELECT s FROM Sender s order by s.id", Sender.class);

org.hibernate.ScrollableResults resultsWithCursor = query.scroll(ScrollMode.SCROLL_INSENSITIVE);

//移动到第六行
resultsWithCursor.setRowNumber(5);

//取出第六行的数据, 这里需要强制转换类型, 这是固定写法, 只能get(0), 不能get(1)
Sender sender = (Sender) resultsWithCursor.get(0);

resultsWithCursor.close();

1. ScrollMode.SCROLL_INSENSITIVE, 游标对于数据库的变化不敏感, 即查出来的结果集不会再变动(没关闭游标的情况下), 这样就没有脏读也没有不可重复读, 幻读的问题.
2. ScrollMode.SCROLL_SENSITIVE, 没关闭游标的情况下, 如果有新提交数据, 结果集也会有变化. 不过由于Hibernate的一级缓存本身就提供了不可重复读的隔离, 即不会加载新数据, 所以这个情况仅仅会影响查询结果是标量集的情况.
3. ScrollMode.FORWARD_ONLY, 不能像上边的例子一样自由的在不同的行号间跳跃.

org.hibernate.query.Query<Sender> query = session.createQuery("SELECT s FROM Sender s", Sender.class);

Iterator<Sender> senderIterator = query.iterate();

while (senderIterator.hasNext()) {
    System.out.print(senderIterator.next());
}

//必须要手工关闭
Hibernate.close(senderIterator);

命名查询

@NamedQueries(
        {

                @NamedQuery(
                        name = "query1",
                        query = "SELECT s FROM Sender s order by s.id"
                ),
                @NamedQuery(
                        name = "query2",
                        query = "SELECT s FROM Sender s order by s.id desc"
                )

        }
)

@Entity
public class Sender {

}

TypedQuery<Sender> firstQuery = em.createNamedQuery("query1", Sender.class);
TypedQuery<Sender> secondQuery = em.createNamedQuery("query2", Sender.class);

查询提示 - hints

1. AUTO, 在每次执行查询前, 都会刷新持久化上下文. 比如查出一个结果集, 修改结果集, 再进行查询. 第二次查询之前, 会先刷新持久化上下文, 也就是写入. 默认就是AUTO.
2. COMMIT, 将某一个查询设置为COMMIT的时候, 在执行这个查询之前, 就不会刷新上下文.
3. ALWAYS, 这个一般不用, 即每次都会更新.

@Test
public void testNamedQuery() {
    EntityManager em = getEM();
    em.getTransaction().begin();

    //设置query2查询的FlushMode为COMMIT
    TypedQuery<Sender> query = em.createNamedQuery("query2", Sender.class);

    query.setHint("org.hibernate.flushMode", FlushMode.COMMIT);


    System.out.println("开始第一次查询");
    List<Sender> senders = em.createQuery("SELECT s FROM Sender s ORDER BY s.id", Sender.class).getResultList();

    System.out.println("修改一个结果");
    senders.get(0).setName(String.valueOf(System.currentTimeMillis()));

    System.out.println("第二次查询");
    System.out.println(query.getResultList());


    em.getTransaction().commit();
    em.close();
}