Hibernate学习---第十节：Hibernate之hql

一、Hql 入门

1、实体类：

package learn.hibernate.bean;import java.util.Date;import java.util.HashSet;import java.util.Set;/** * 持久化类设计 * 注意： *         持久化类通常建议要有一个持久化标识符(ID) *         持久化标识符通常建议使用封装类(例如：Integer  因为基本类型存在默认值) *         持久化类通常建议手动添加一个无参构造函数 (因为有些操作是通过放射机制进行的) *         属性通常建议提供  getter/setter 方法 *         持久化类不能使用 final 修饰 *         持久化类中如果使用了集合类型数据，只能使用集合所对应的接口类型来声明(List/Map/Set) *              如下：ArrayList list = new ArrayList();  不行 *                 List list = new ArrayList(); 可行 */public class Person {    private Integer id;    private String name;    private int age;    private int passwork;    private Date birthday;        private Set<Address> addres = new HashSet<Address>();        public Person() {            }        public Person(String name, int age, int passwork, Date birthday) {        super();        this.name = name;        this.age = age;        this.passwork = passwork;        this.birthday = birthday;    }        @Override    public String toString() {        return "Person [id=" + id + ", name=" + name + ", age=" + age                + ", passwork=" + passwork + ", birthday=" + birthday + "]";    }        public Integer getId() {        return id;    }    public void setId(Integer id) {        this.id = id;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public int getPasswork() {        return passwork;    }    public void setPasswork(int passwork) {        this.passwork = passwork;    }    public Date getBirthday() {        return birthday;    }    public void setBirthday(Date birthday) {        this.birthday = birthday;    }    public Set<Address> getAddres() {        return addres;    }    public void setAddres(Set<Address> addres) {        this.addres = addres;    }}

package learn.hibernate.bean;public class Address {    private Integer id;    private String zipCode;    private String address;    private Person person;        public Address() {            }        public Address(String zipCode, String address) {        super();        this.zipCode = zipCode;        this.address = address;    }    @Override    public String toString() {        return "Address [zipCode=" + zipCode + ", address=" + address + "]";    }    public Integer getId() {        return id;    }    public void setId(Integer id) {        this.id = id;    }    public String getZipCode() {        return zipCode;    }    public void setZipCode(String zipCode) {        this.zipCode = zipCode;    }    public String getAddress() {        return address;    }    public void setAddress(String address) {        this.address = address;    }    public Person getPerson() {        return person;    }    public void setPerson(Person person) {        this.person = person;    }}

2、映射配置文件：

<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping package="learn.hibernate.bean">    <class name="Person" table="t_person">        <id name="id" column="person_id">            <generator class="native"/>        </id>        <property name="name" column="t_name"/>        <property name="age"/>            <property name="passwork"/>        <property name="birthday"/>        <!--             通过Set配置一个人对应的多个地址的关联关系            inverse=true 表示在Person端不维护关系;因为多的一端有外键,管理关联关系更高效         -->        <set name="addres" cascade="all" inverse="true">            <!-- 指定 addres 集合中的数据对应t_person的的一个外键 -->            <key column="p_id"/>            <!-- 指定Person 关联的实例类型 -->            <one-to-many class="Address"/>        </set>                <!-- inverse="false" 一定要为 false 因为要控制顺序 -->        <!-- <list name="addres" inverse="false" cascade="all">            <key column="p_id"/>            <index column="indexs" type="integer"/>            <one-to-many class="Address"/>        </list> -->        <!-- inverse="false" 一定要为 false 因为要控制顺序 -->        <!-- <map name="addres" inverse="false" cascade="all">            <key column="p_id"/>            <index column="map_key" type="string"/>            <one-to-many class="Address"/>        </map> -->    </class>    <class name="Address" table="t_address">        <id name="id">            <generator class="native"/>        </id>        <property name="zipCode"/>        <property name="address"/>        <!--             多的一端使用 many-to-one 进行配置         -->        <many-to-one name="person" column="p_id"/>    </class></hibernate-mapping>

3、hibernate 配置文件：

<!DOCTYPE hibernate-configuration PUBLIC    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"><!--声明Hibernate配置文件的开始--><hibernate-configuration>    <!--表明以下的配置是针对session-factory配置的，SessionFactory是Hibernate中的一个类，这个类主要负责保存HIbernate的配置信息，以及对Session的操作-->    <session-factory>        <!--hibernate.dialect 只是Hibernate使用的数据库方言,就是要用Hibernate连接那种类型的数据库服务器-->         <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>        <!--配置数据库的驱动程序，Hibernate 在连接数据库时，需要用到数据库的驱动程序-->         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>        <!--设置数据库的连接url:jdbc:mysql://localhost/hibernate,其中localhost表示mysql服务器名称，此处为本机，    hibernate是数据库名-->         <!--             jdbc:mysql://192.168.1.112:3305/hibernate    联网络数据库            jdbc:mysql:///hibernate    联本机         -->        <property name="hibernate.connection.url">jdbc:mysql:///hibernate</property>        <!--连接数据库是用户名-->         <property name="hibernate.connection.username">root</property>        <!--连接数据库是密码-->        <property name="hibernate.connection.password">123456</property>        <!-- 是否自动创建数据库表  他主要有一下几个值：              validate:当sessionFactory创建时，自动验证或者schema定义导入数据库。                      create:每次启动都drop掉原来的schema，创建新的。                      create-drop:当sessionFactory明确关闭时，drop掉schema。                      update(常用):如果没有schema就创建，有就更新。                    -->          <property name="hibernate.hbm2ddl.auto">update</property>         <!--是否在后台显示Hibernate用到的SQL语句，开发时设置为true，便于差错，程序运行时可以在Eclipse的控制台显示Hibernate的执行Sql语句。项目部署后可以设置为false，提高运行效率-->         <property name="hibernate.show_sql">true</property>        <!--指定映射文件 -->        <mapping resource="learn\hibernate\bean\Person.hbm.xml"/>    </session-factory></hibernate-configuration>

4、测试类：

package learn.hibernate.test;import static org.junit.Assert.*;import java.util.Arrays;import java.util.Date;import java.util.HashSet;import java.util.Iterator;import java.util.List;import java.util.Set;import learn.hibernate.bean.Person;import org.hibernate.Query;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;import org.hibernate.service.ServiceRegistry;import org.hibernate.service.ServiceRegistryBuilder;import org.junit.After;import org.junit.Before;import org.junit.Test;public class TestHibernate {    SessionFactory factory = null;    Session session = null;    Transaction tx = null;        /**     * 测试之前初始化数据     * @throws Exception     */    @SuppressWarnings("deprecation")    @Before    public void setUp() throws Exception {        System.out.println("---------初始化数据----------");                Configuration config = new Configuration().configure();        ServiceRegistry sr = new ServiceRegistryBuilder()        .applySettings(config.getProperties()).buildServiceRegistry();        factory = config.buildSessionFactory(sr);        session = factory.openSession();    }    /**     * 测试之后释放(销毁)数据     * @throws Exception     */    @After    public void tearDown() throws Exception {        System.out.println("---------释放数据----------");        if(session.isOpen()){            session.close();        }    }        /**     * 批量写入数据     */    @Test    public void testAdd(){        tx = session.beginTransaction();        for(int i = 0; i < 100; i++){            Person person = new Person("ldh_"+i, 22+i, 123456+i, new Date());            session.persist(person);            if(i % 10 == 0){                session.flush();                session.clear();            }        }        tx.commit();    }        /**     * 批量查询数据     */    @Test    public void testQuery(){        // 查询表中的所有字段不需要写 select 关键字，如下：        String queryString = "from Person";        Query query = session.createQuery(queryString);        List<Person> list = query.list();        int count = 0;        for(Person person : list){            System.out.println((++count)+"---------"+person);        }    }}

另一种查询方式:

/** * N + 1 查询 * 首先获取表的 id，当需要用到实体对象的时候，在根据 id 值获取每一条记录(延迟查询) * 每获得一条记录前都会发起一次查询，效率比较慢 * 通过下面的例子知道 iterator 支持一级缓存的读和写 */@Testpublic void testQuery2(){        /*Person person = (Person)session.get(Person.class, 99);    System.out.println(person);    System.out.println("----------------------");*/    // 查询表中的所有字段不需要写 select 关键字，如下：    String queryString = "from Person";    Query query = session.createQuery(queryString);    Iterator<Person> it = query.iterate();    while(it.hasNext()){        Person p = it.next();        System.out.println(p);    }        // 没有发起查询，说明 person 对象是从缓存中拿到的    System.out.println("----------------------");    Person person = (Person)session.get(Person.class, 99);    System.out.println(person);}

详解：list() 和 iterate() 方法的区别：

1、查询数据的不同形式：

(1)、Hibernate Iterator的查询本身是分为两步的：存在N+1问题
  ==> select id from cat //一条
  ==> select * from cat where id = ?  //n条
  解析：第一步，去数据库中取主键列表，第二步，按照主键一个一个取数据。假如不用JCS的话，那么从数据库中取出n条记录就需要n+1次sql查询，假如使用了JCS，他会先到JCS里面去看看，按照主键去找持久对象，假如有了，直接拿出来用，假如没有，那么只好去数据库中取得，然后再把它填到JCS里面去。

(2)、而Hibernate List方式：
  ==> select * from cat
  它是JDBC的简单封装，一次sql就把所有的数据都取出来了，它不会像Iterator那样先取主键，然后再取数据，因此List无法利用JCS。不过List也可以把从数据库中取出的数据填充到JCS里面去。当再次使用list查询数据的时候，仍然要发送sql去数据库中读取数据，证明list()方法不使用缓存。

2、list和iterate对缓存的使用情况

(1)、iterate会查询session缓存、2级缓存， list只会使用查询缓存（如果查询缓存开启的话）

(2)、当查询缓存开启时，对iterate和list查询语句的影响
  查询缓存：将query 的cache打开的话,缓存的是query本身,以hql 生成的 sql ，再加上参数，分页等信息做为key值, 而不是query的结果.query的结果是放在session的cache中和二    级cache中,和query的cache是有区别的。

以上文字来自：http://blog.csdn.net/javaloveiphone/article/details/8200691

二、HQL进阶

1、查询表的部分字段

/** * 查询单个字段 */@Testpublic void testSelect(){    String hql = "select name from Person";    Query query = session.createQuery(hql);    List<String> list = query.list();    for(String name : list){        System.out.println(name);    }    }/** * 查询多个字段 */@Testpublic void testSelect2(){    String hql = "select name，age, passwork from Person";    Query query = session.createQuery(hql);    // 如果查询的是多个字段，返回的是一个 Object[] 数组    List<Object[]> list = query.list();    for(Object[] objs : list){        System.out.println(Arrays.toString(objs));    }}/** * 查询多个字段 */@Testpublic void testSelect3(){    // 可以在 hql 语句上使用构造器的方式来绑定查询数据(前提：这个构造器必须是已定义的)    String hql = "select new Person(name，age, passwork, birthday) from Person";    Query query = session.createQuery(hql);    List<Person> list = query.list();    for(Person p : list){        System.out.println(p);    }}/** * 查询多个字段 */@Testpublic void testSelect4(){    // 可以在 hql 语句上使用List的方式来绑定查询数据,并将匹配条件的数据返回成对应的List集合    String hql = "select new List(name，age, passwork, birthday) from Person";    Query query = session.createQuery(hql);    List<List> list = query.list();    for(List l : list){        for(int i = 0, size = l.size(); i < size; i++){            System.out.println(l.get(i));        }        System.out.println("------------------");    }}/** * 查询多个字段 */@Testpublic void testSelect5(){    // 可以在 hql 语句上使用 Map 的方式来绑定查询数据,并将匹配条件的数据返回成对应的 Map 集合    String hql = "select new Map(name，age, passwork, birthday) from Person";    Query query = session.createQuery(hql);    List<Map> list = query.list();    for(Map m : list){        Iterator<Map.Entry> it = m.entrySet().iterator();        while(it.hasNext()){            Map.Entry map = it.next();            System.out.println(map.getKey()+"----------------"+map.getValue());        }        System.out.println("------------------");    }}/** * 查询多个字段 */@Testpublic void testSelect6(){    // 可以在 hql 语句上使用 Map 的方式来绑定查询数据,并将匹配条件的数据返回成对应的 Map 集合    String hql = "select new Map(name as n，age as a, passwork as p, birthday as b) from Person";    Query query = session.createQuery(hql);    List<Map> list = query.list();    for(Map m : list){        Iterator<Map.Entry> it = m.entrySet().iterator();        while(it.hasNext()){            Map.Entry map = it.next();            System.out.println(map.getKey()+"----------------"+map.getValue());        }        System.out.println("------------------");    }}

2、查询某几条数据

/** * 查询某几条数据 */@Testpublic void testSelect7(){    // 可以在 hql 语句上使用构造器的方式来绑定查询数据(前提：这个构造器必须是已定义的)    String hql = "select new Person(name，age, passwork, birthday) from Person";    Query query = session.createQuery(hql);    List<Person> list = query.list();    // 获取集合中的指定下标位置的数据，但是其他满足条件的数据已经查询出来，并写入的缓存中了    Person p = list.get(0);    System.out.println(p);}/** * 查询满足条件的唯一记录 */@Testpublic void testSelect8(){    // 可以在 hql 语句上使用构造器的方式来绑定查询数据(前提：这个构造器必须是已定义的)    String hql = "select new Person(name，age, passwork, birthday) from Person";    Query query = session.createQuery(hql);    // 如果知道获取的数据时唯一的一条记录可以调用uniqueResult()方法，如果有多条记录则报异常    Person p = (Person)query.uniqueResult();    System.out.println(p);}

3、分页查询

/** * 分页查询 */@Testpublic void testSelect9(){    String hql = "from Person";    Query query = session.createQuery(hql);    // 分页的起始位置(会从指定位置的下一个位置开始)    query.setFirstResult(0);    // 分页的大小    query.setMaxResults(10);    List<Person> list = query.list();    for(Person p : list){        System.out.println(p);    }}

4、绑定变量

/** * 绑定变量 */@Testpublic void testSelect10(){    String hql = "from Person where id= ?";    Query query = session.createQuery(hql);    // 通过 ？号占位符绑定变量，JDBC是从 1 开始，hibernate 是从 0 开始    query.setInteger(0, 99);    List<Person> list = query.list();    for(Person p : list){        System.out.println(p);    }}/** * 多条件绑定变量查询 */@Testpublic void testSelect11(){    String hql = "from Person where id= ?1 and name = ?2";    Query query = session.createQuery(hql);    // 参数的位置通过 ？后面的数字来确定，不管查询条件的位置如何变化都不会改变一下查询结果    query.setInteger("1", 99);    query.setString("2", "admin-98");    List<Person> list = query.list();    for(Person p : list){        System.out.println(p);    }}/** * 命名参数绑定查询 */@Testpublic void testSelect12(){    // 命名参数绑定    String hql = "from Person where id= :id and name = :name";    Query query = session.createQuery(hql);    query.setInteger("id", 99);    query.setString("name", "admin-98");    List<Person> list = query.list();    for(Person p : list){        System.out.println(p);    }}/** * 命名参数绑定多值查询 */@Testpublic void testSelect13(){    // 命名参数绑定    String hql = "from Person where id in(:ids)";    Query query = session.createQuery(hql);    // 批量参数绑定可以使用数组    //query.setParameterList("ids", new Object[]{3,6,9});    // 批量参数绑定可以使用集合    List<Integer> lists = new ArrayList<Integer>();    lists.add(3);    lists.add(6);    lists.add(9);    query.setParameterList("ids", lists);    List<Person> list = query.list();    for(Person p : list){        System.out.println(p);    }}

5、模糊查询

/** * 模糊查询 */@Testpublic void testSelect14(){    // 命名参数绑定    String hql = "from Person where name like :name";    Query query = session.createQuery(hql);    query.setString("name", "%-99%");    List<Person> list = query.list();    for(Person p : list){        System.out.println(p);    }}

6、连接查询

/** * 为了方便连接查询，往 Address 表中写入数据 */@Testpublic void testSave2(){    Person p = (Person)session.get(Person.class, 1);        Address a1 = new Address("420000", "湖南桂阳");    Address a2 = new Address("422300", "湖南郴州");        Set<Address> set = new HashSet<Address>();    set.add(a1);    set.add(a2);    // Person 与  Address 关联    p.setAddres(set);    // Address 与  Person 关联    a1.setPerson(p);    a1.setPerson(p);        tx = session.beginTransaction();    session.update(p);    tx.commit();}/** * 连接查询 */@Testpublic void testSelect15(){    //String sql ="select *　from t_person p, t_address a where p.id = a.p_id and p.name = 'admin-0'";    String hql = "select p,a　from t_person p, t_address a where p.id = a.person and p.name = :name";    Query query = session.createQuery(hql);    query.setString("name", "admin-0");    List<Object[]> list = query.list();    for(Object [] obj : list){        System.out.println(Arrays.toString(obj));    }}/** * 连接查询 */@Testpublic void testSelect16(){    // addres 对应 映射文件中 set元素的 name 属性值    String hql = "select p,a　from t_person p left join p.addres a where p.name = :name";    Query query = session.createQuery(hql);    query.setString("name", "admin-0");    List<Object[]> list = query.list();    for(Object [] obj : list){        System.out.println(Arrays.toString(obj));    }}

7、批量更新

/** * 批量更新 */@Testpublic void testUpdate(){    String  hql = "update Person set passwork = 1234543";    tx = session.beginTransaction();    int count = session.createQuery(hql).executeUpdate();    tx.commit();    String flag = count > 0?"成功":"失败";    System.out.println(flag);}/** * 批量更新 */@Testpublic void testUpdate2(){    System.out.println("--------1------");    Person p = (Person)session.get(Person.class, 2);    System.out.println(p);    // 批量更新和批量删除，是不会影响缓存中的数据的    String  hql = "update Person set passwork = 0 where id = 2";    tx = session.beginTransaction();    int count = session.createQuery(hql).executeUpdate();    tx.commit();    String flag = count > 0?"成功":"失败";    System.out.println(flag);    // 清空缓存，以保证数据库表的数据和缓存中的数据是一致的    session.clear();    System.out.println("--------2------");    Person p2 = (Person)session.get(Person.class, 2);    System.out.println(p2);}

8、删除

/** * 批量删除 */@Testpublic void testDelete(){    String  hql = "delete from Person where id > 1";    tx = session.beginTransaction();    // 映射文件中允许级联操作，但是 executeUpdate() 方法不支持级联操作，如果要想使用这个方法批量修改，那么需要加条件将不符合的数据排除    int count = session.createQuery(hql).executeUpdate();    tx.commit();    String flag = count > 0?"成功":"失败";    System.out.println(flag);}/** * 级联删除 */@Testpublic void testCascadeDelete(){    Person p = (Person)session.get(Person.class, 1);    tx = session.beginTransaction();    session.delete(p);    tx.commit();}

三、在持久化配置文件中配置HQL或SQL

第一种方式：

配置文件代码如下：

<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping package="learn.hibernate.bean">    <class name="Person" table="t_person">        <id name="id" column="person_id">            <generator class="native"/>        </id>        <property name="name" column="t_name"/>        <property name="age"/>            <property name="passwork"/>        <property name="birthday"/>        <set name="addres" cascade="all" inverse="true">            <!-- 指定 addres 集合中的数据对应t_person的的一个外键 -->            <key column="p_id"/>            <!-- 指定Person 关联的实例类型 -->            <one-to-many class="Address"/>        </set>    </class>    <class name="Address" table="t_address">        <id name="id">            <generator class="native"/>        </id>        <property name="zipCode"/>        <property name="address"/>        <many-to-one name="person" column="p_id"/>    </class>        <query name="myQuery">        from Person    </query></hibernate-mapping>

查询代码如下：

/** * 在 hibernate 开发中最好是将HQL 和标准的 SQL 查询语句尽量配置到持久化映射文件中(*.hbm.xml) *  */@Testpublic void testQuery(){    Query query = session.getNamedQuery("myQuery");    List<Person> list = query.list();    for(Person person : list){        System.out.println(person);    }}

第二种方式：

单独写一个配置文件，代码如下：

<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping package="learn.hibernate.bean">    <query name="myQuery2">        from Person    </query>        <query name="myQuery3">        <!-- 直接写小于符合是不行的，这里用到小于符号的转义 -->        from Person where id &lt; 5    </query>        <!-- 如果有特殊的字符与 xml中的起到冲突可以用以下方式解决 -->    <query name="myQuery3">        <![CDDATE[from Person where id < :id]]>    </query>    </hibernate-mapping>

将配置文件引入到 *.cfg.xml 文件中，代码如下：

<!DOCTYPE hibernate-configuration PUBLIC    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"><!--声明Hibernate配置文件的开始--><hibernate-configuration>    <!--表明以下的配置是针对session-factory配置的，SessionFactory是Hibernate中的一个类，这个类主要负责保存HIbernate的配置信息，以及对Session的操作-->    <session-factory>        <!--hibernate.dialect 只是Hibernate使用的数据库方言,就是要用Hibernate连接那种类型的数据库服务器-->         <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>        <!--配置数据库的驱动程序，Hibernate 在连接数据库时，需要用到数据库的驱动程序-->         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>        <!--设置数据库的连接url:jdbc:mysql://localhost/hibernate,其中localhost表示mysql服务器名称，此处为本机，    hibernate是数据库名-->         <!--             jdbc:mysql://192.168.1.112:3305/hibernate    联网络数据库            jdbc:mysql:///hibernate    联本机         -->        <property name="hibernate.connection.url">jdbc:mysql:///hibernate</property>        <!--连接数据库是用户名-->         <property name="hibernate.connection.username">root</property>        <!--连接数据库是密码-->        <property name="hibernate.connection.password">123456</property>        <!-- 是否自动创建数据库表  他主要有一下几个值：              validate:当sessionFactory创建时，自动验证或者schema定义导入数据库。                      create:每次启动都drop掉原来的schema，创建新的。                      create-drop:当sessionFactory明确关闭时，drop掉schema。                      update(常用):如果没有schema就创建，有就更新。                    -->          <property name="hibernate.hbm2ddl.auto">update</property>         <!--是否在后台显示Hibernate用到的SQL语句，开发时设置为true，便于差错，程序运行时可以在Eclipse的控制台显示Hibernate的执行Sql语句。项目部署后可以设置为false，提高运行效率-->         <property name="hibernate.show_sql">true</property>        <!--指定映射文件 -->        <mapping resource="learn\hibernate\bean\Person.hbm.xml"/>        <mapping resource="learn\hibernate\bean\query.xml"/>    </session-factory></hibernate-configuration>

Java 代码如下：

@Testpublic void testQuery2(){    Query query = session.getNamedQuery("myQuery4");    query.setInteger("id", 5);    List<Person> list = query.list();    for(Person person : list){        System.out.println(person);    }}

hibernate 的hql 知识可以查看一下网址：

http://blog.csdn.net/aaronuu/article/details/7034815

http://developer.51cto.com/art/200906/130045.htm

http://www.wyjava.com/html/2012/hibernate_0219/293.html