Hibernate（三）

1.1Hibernate的检索方式

1.1.1Hibernate的检索方式概述

Hibernate提供了以下几种检索对象的方式：

导航对象图检索方式：根据已经家就在的对象导航到其他对象。
- Customer customer = session.get(Customer.class,1);customer.getOrders();获取客户的订单。　　
OID检索方式：按照对象的OID来检索对象。
- get()/load()方法来进行检索。　　
HQL检索方式：使用面向对象的HQL查询语言。
QBC检索方式：使用QBC API来检索对象。这种API封装了基于字符串形式的查询语句，提供了更加面向对象的查询接口。
本地SQL检索方式：使用本地数据库的SQL查询语句。

1.1.2HQL

HQL（HIbernate Query Language）是面向对象的查询语言，它和SQL查询语言有些相似，在HIbernate提供的各种检索方式中，HQL是使用最广的一种检索方式。它有如下功能：
- 在查询语句中设定各种查询条件。
- 支持投影查询，即仅查询出对象的部分属性。
- 支持分页查询。
- 支持连接查询。
- 支持分组查询，允许使用having和group by关键字。
- 提供内置聚集函数（分组函数），如sum()，min()和max()等。
- 能够调用用户定义的SQL函数或标准的SQL函数。
- 支持子查询。
- 支持动态绑定参数。
HQL检索方式包括以下的步骤：
- 通过session的createQuery()方法创建一个Query对象，它包括一个HQL查询语句。HQL查询语句中可以包含命名参数。
- 动态绑定参数。
- 调用Query的ist()方法执行查询语句，该方法返回java.util.List类型的查询结果，在List集合中存放了符合查询条件的持久化对象。
Query接口支持方法链编程风格，它的setXXX()方法返回自身实例，而不是void类型。
HQL vs SQL：
- HQL查询语句是面向对象的，HIbernate负责解析HQL查询语句，然后根据对象-关系映射文件中的映射信息，把HQL查询语句翻译成相应的SQL语句，HQL查询语句中的主体是域模型中的类或类的属性。
- SQL查询语句是与关系数据库绑定在一起的。SQL查询语句中的主体是数据库表及表的字段。

1.1.3搭建环境、具体的实体类和映射文件以及核心配置文件

实体类
- Customer.java类

package cn.hibernate3.demo4;

import java.io.Serializable;
import java.util.HashSet;
/**
 * 客户实体
 */
import java.util.Set;
public class Customer implements Serializable{
    private Integer cid;
    private String cname;
    //一个客户有多个订单
    private Set<Order> orders = new HashSet<Order>();
    public Integer getCid() {
        return cid;
    }
    public void setCid(Integer cid) {
        this.cid = cid;
    }
    public String getCname() {
        return cname;
    }
    public void setCname(String cname) {
        this.cname = cname;
    }
    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }

}

- Order.java类

package cn.hibernate3.demo4;

import java.io.Serializable;
/**
 * 订单实体
 */
public class Order implements Serializable{
    private Integer oid;
    private String addr;
    //订单属于某一个客户
    private Customer customer ;

    public Integer getOid() {
        return oid;
    }
    public void setOid(Integer oid) {
        this.oid = oid;
    }
    public String getAddr() {
        return addr;
    }
    public void setAddr(String addr) {
        this.addr = addr;
    }
    public Customer getCustomer() {
        return customer;
    }
    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

}

映射文件
- Customer.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 引入约束 -->
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="cn.hibernate3.demo4.Customer" table="customer">
        <!-- 配置唯一标识 -->
        <id name="cid" column="cid">
            <generator class="native"/>
        </id>
        <!-- 配置普通属性 -->
        <property name="cname" column="cname" type="java.lang.String"/>
        <!-- 建立映射 -->
        <!-- 配置集合 -->
        <!--
            set标签中的name表示关联对象的属性名称

         -->
        <set name="orders">
            <!-- key标签中的column用来一对多的多的一方的外键 -->
            <key column="cno"/>
            <!-- 配置一个one-to-many -->
            <one-to-many class="cn.hibernate3.demo4.Order" />
        </set>
    </class>
</hibernate-mapping>

- Order.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 引入约束 -->
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="cn.hibernate3.demo4.Order" table="orders">
        <!-- 配置唯一标识 -->
        <id name="oid" column="oid">
            <generator class="native"/>
        </id>
        <!-- 配置普通属性 -->
        <property name="addr" column="addr" type="java.lang.String"/>
        <!-- 建立映射 -->
        <!--
            many-to-one标签
                属性：
                    name:关联对象的属性名称。
                    column:表中外键的名称。
                    class:关联对象的全路径。
         -->
        <many-to-one name="customer" column="cno" class="cn.hibernate3.demo4.Customer"></many-to-one>
    </class>
</hibernate-mapping>

核心配置文件hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
    <!-- 配置数据库的基本信息 -->
    <!-- 驱动的名称 -->
    <property name="hibernate.connection.driver_class">
        com.mysql.jdbc.Driver
    </property>
    <!-- 访问数据库的url -->
    <property name="hibernate.connection.url">
        jdbc:mysql:///hibernate_day03
    </property>
    <!-- 用户名 -->
    <property name="hibernate.connection.username">root</property>
    <!-- 密码 -->
    <property name="hibernate.connection.password">root</property>
    <!-- 方言 -->
    <property name="hibernate.dialect">
        org.hibernate.dialect.MySQLDialect
    </property>
    <!-- C3P0连接池设定-->
    <!-- 使用c3po连接池  配置连接池提供的供应商-->
    <property name="connection.provider_class">
        org.hibernate.connection.C3P0ConnectionProvider
    </property>
    <!--在连接池中可用的数据库连接的最少数目 -->
    <property name="c3p0.min_size">5</property>
    <!--在连接池中所有数据库连接的最大数目  -->
    <property name="c3p0.max_size">20</property>
    <!--设定数据库连接的过期时间,以秒为单位,
        如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->
    <property name="c3p0.timeout">120</property>
    <!--每3000秒检查所有连接池中的空闲连接 以秒为单位-->
    <property name="c3p0.idle_test_period">3000</property>
    <!-- 可选配置 -->
    <!-- 显示SQL -->
    <property name="hibernate.show_sql">true</property>
    <!-- 格式化SQL -->
    <property name="hibernate.format_sql">true</property>
    <!-- hbm:映射 2:to ddl:create drop alter -->
    <property name="hibernate.hbm2ddl.auto">update</property>
    <mapping resource="cn/hibernate3/demo4/Customer.hbm.xml" />
    <mapping resource="cn/hibernate3/demo4/Order.hbm.xml" />

</session-factory>
</hibernate-configuration>

工具类HibernateUtils.java

package cn.utils;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * Hibernate抽取工具类
 */
public class HibernateUtils {
    private static Configuration configuration;
    private static SessionFactory sessionFactory;
    static{
        configuration = new Configuration().configure();
        sessionFactory = configuration.buildSessionFactory();
    }

    public static Session openSession(){
        return sessionFactory.openSession();
    }

    public static void main(String[] args) {
        openSession();
    }
}

初始化数据

　　@Test
    //初始化数据
    public void demo1(){
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();

        Customer customer = new Customer();
        customer.setCname("小金");

        for (int i = 0; i < 10; i++) {
            Order order = new Order();
            order.setAddr("江苏"+i);
            order.setCustomer(customer);
            customer.getOrders().add(order);
        }

        session.save(customer);

        tx.commit();
        session.close();
    }

　　@Test
    //初始化数据
    public void demo1(){
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();

        Customer customer = new Customer();
        customer.setCname("小名");

        for (int i = 0; i < 10; i++) {
            Order order = new Order();
            order.setAddr("北京"+i);
            order.setCustomer(customer);
            customer.getOrders().add(order);
        }

        session.save(customer);

        tx.commit();
        session.close();
    }

- 需要配置级联关系Customer.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 引入约束 -->
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="cn.hibernate3.demo4.Customer" table="customer">
        <!-- 配置唯一标识 -->
        <id name="cid" column="cid">
            <generator class="native"/>
        </id>
        <!-- 配置普通属性 -->
        <property name="cname" column="cname" type="java.lang.String"/>
        <!-- 建立映射 -->
        <!-- 配置集合 -->
        <!--
            set标签中的name表示关联对象的属性名称

         -->
        <set name="orders" cascade="save-update">
            <!-- key标签中的column用来一对多的多的一方的外键 -->
            <key column="cno"/>
            <!-- 配置一个one-to-many -->
            <one-to-many class="cn.hibernate3.demo4.Order" />
        </set>
    </class>
</hibernate-mapping>

1.1.4简单查询及别名查询

HQL：简单查询

　　@Test
    //查询所有数据
    public void demo2(){
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();

        Query query = session.createQuery("from Customer");
        List<Customer> list = query.list();
        for (Customer customer : list) {
            System.out.println(customer.getCname());
        }

        tx.commit();
        session.close();
    }

QBC：简单查询

    @Test
    //查询所有数据
    public void demo2(){
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();

        Criteria criteria = session.createCriteria(Customer.class);
        List<Customer> list = criteria.list();
        for (Customer customer : list) {
            System.out.println(customer.getCname());
        }

        tx.commit();
        session.close();
    }

SQL：简单查询

　　@Test
    //查询所有数据
    public void demo2(){
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();

        SQLQuery query = session.createSQLQuery("select * from customer");
        List<Customer> list = query.addEntity(Customer.class).list();
        for (Customer customer : list) {
            System.out.println(customer.getCname());
        }

        tx.commit();
        session.close();
    }

　　@Test
    //查询所有数据
    public void demo2(){
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();

        SQLQuery query = session.createSQLQuery("select * from customer");
        List<Object[]> list = query.list();
        for (Object[] obj : list) {
            System.out.println(Arrays.toString(obj));
        }

        tx.commit();
        session.close();
    }

HQL：使用别名

时间： 2024-10-12 22:56:25

Hibernate（三）的相关文章

简单理解Hibernate三种状态的概念及互相转化

本文描述了Hibernate三种状态的概念及互相转化.Java对象的生命周期中有三种状态,而且互相转化.它们分别是临时状态,持久化状态,以及游离状态. AD:WOT2015 互联网运维与开发者大会热销抢票在Hibernate中有三种状态,对它的深入理解,才能更好的理解hibernate的运行机理,刚开始不太注意这些概念,后来发现它是重要的.对于理解hibernate,JVM和sql的关系有更好的理解.对于需要持久化的JAVA对象,在它的生命周期中有三种状态,而且互相转化. Hibernate

Hibernate三种状态的区分，以及save,update,saveOrUpdate,merge等的使用 ----转----

Hibernate三种状态的区分,以及save,update,saveOrUpdate,merge等的使用 Hibernate的对象有3种状态,分别为:瞬时态(Transient). 持久态(Persistent).脱管态(Detached).处于持久态的对象也称为PO(Persistence Object),瞬时对象和脱管对象也称为VO(Value Object). 瞬时态由new命令开辟内存空间的java对象, eg. Person person = new Person(

Hibernate三种状态的区分，以及save,update,saveOrUpdate,merge等的使用

Hibernate——三种状态的实例persistent演示

上篇博客介绍了自己对Hibernate三种状态的理解,这一篇主要是通过实例演示去进一步的理解三种状态. persistent状态: 此时的状态持久化对象纳入的session的管理,当提交事物时,数据会和数据库同步,如果有更新的数据将产生更新语句. session=HibernateUtils.getSession(); tx=session.beginTransaction(); //transient状态,此时的对象没有纳入session管理 user=new User(); user.set

Hibernate 三种状态理解及转换

首先先说下hibernate中的三个状态,只有完全理解了这三个状态,才能在项目中充分利用hibernate这个工具来完成项目进度. 1.瞬时态,也叫临时态等,不受hibernate session管制的状态,即某个实例跟session没有任何关联,比如new产生的实例. 2.持久态,session中持久化了的实例,相当于数据库中的记录,修改实例的任何属性都会导致数据库记录的变更. 3.托管态,也叫游离态等,持久化对象脱离了Session的对象.如Session缓存被清空的对象.特点:已经持久化,

Hibernate三种状态,缓存,以及update更新问题

一. Hibernate中对象的三种状态 1. 瞬时状态(transient) 当我们通过Java的new关键字来生成一个实体对象时,这时这个实体对象就处于自由状态,此时该对象只是通过JVM获得了一块内存空间,还并没有通过Session对象的save()方法保存进数据库,因此也就还没有纳入Hibernate的缓存管理中,也就是说该对象现在还自由的游荡于Hibernate缓存管理之外.所以我们可以看出自由对象最大的特点就是,在数据库中不存在一条与它对应的记录. 瞬时状态特点: I: 不和 Sess

hibernate三种状态

学过hibernate的人都可能都知道hibernate有三种状态,transient(瞬时状态),persistent(持久化状态)以及detached(离线状态),大家伙也许也知道这三者之间的区别,比如瞬时状态就是刚new出来一个对象,还没有被保存到数据库中,持久化状态就是已经被保存到数据库中,离线状态就是数据库中有,但是session中不存在该对象.但是大家又是否对hibernate的session的那几个特殊方法一清二楚呢?或者说大家是否能够一眼就快速看出一个测试用例在反复的调用sess

Hibernate(三)——框架中的关系映射

在设计数据库时我们会考虑,表与表之间的关系,例如我们前边经常提到的一对一,一对多,多对多关系,在数据库中我们通过外键,第三张表等来实现这些关系.而Hibernate时间实体类和数据库中的表进行的映射,这些关系如何映射呢?这里简单总结一下: 一,一对多,多对一关系映射,这里拿学生和班级进行简单演示: 1,学生的类和对应的映射文件的编写: private int sid ; private String sname ; private Classes classes ; //,引入班级对象,多对一

Hibernate(三)结构-配置文件-实体映射及配置文件

一.体系结构 SessionFactory:属于单一数据库的编译过的映射文件的一个线程安全的,不可变的缓存快照.Session的工厂.有可能持有一个可选的数据缓存可以进程级别或者群级别保存可以在事务中重用数据. 会话,Session:单线程,生命期短促的对象,代表应用程序和持久化层之间的一次对话.封装了一个JDDBC连接,它也是Transaction的工厂,保存有必须持久化对象的缓存,用于遍历对象,或者通过标识符查找对象. 持久化对象(Persistent Object)及其集合(Collect