Hibernate 知识梳理

Angel_Y_

于 2013-07-21 18:23:48 发布

阅读量451

点赞数 1

分类专栏： Java 文章标签： Hibernate

本文链接：https://blog.csdn.net/yang283561852/article/details/9399645

版权

Java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、Hibernate核心API

Configuration类:

Configuration对象用于配置和启动Hibernate。Hibernate应用通过Configuration实例来指定对象-关系映射文件的位置或者动态配置Hibernate的属性，然后创建SessionFactory实例。

SessionFactory接口：

一个SessionFactory实例对应一个数据存储源。应用从SessionFactory中获取Session实例。

1)它是线程安全的，这意味着它的一个实例能够被应用的多个线程共享。

2)它是重量级的，这意味着不能随意创建或者销毁，一个数据库只对应一个SessionFactory。

通常构建SessionFactory是在某对象Bean的静态初始化代码块中进行。

如果应用只是访问一个数据库，只需创建一个SessionFactory实例，并且在应用初始化的时候创建该实例。

如果应用有同时访问多个数据库，则需为每个数据库创建一个单独的SessionFactory。

Session接口：

是Hibernate应用最广泛的接口。它提供了和持久化相关的操作，如添加，删除，更改，加载和查询对象。

1)它是线程不安全的，因此在设计软件架构时，应尽量避免多个线程共享一个Session实例。

2)Session实例是轻量级的，这意味着在程序可以经常创建和销毁Session对象，

例如为每个客户请求分配单独的Session实例。

原则：一个线程一个Session；一个事务一个Session

二，Hibernate开发步骤:

开始：(设置环境变量和配置)

在myeclipse里导入Hibernate的文件包(包括各数据库的驱动和其他的jar包，对版本敏感，注意各版本的兼容)

按hibernate规范编写名字为hibernate.cfg.xml文件(默认放在工程文件夹下)

步骤一：设计和建立数据库表

可以用Hibernate直接生成映射表。

Oracle里建表： create table t_ad (oid number(15) primary key,

ACTNO varchar(20) not null unique,BALANCE number(20));

步骤二：持久化类的设计

POJO----

POJO 在Hibernate 语义中理解为数据库表所对应的Domain Object。(此类中只含有属性、构造方法、get/set方法)

这里的POJO就是所谓的“Plain Ordinary Java Object”，字面上来讲就是无格式普通Java 对象，

简单的可以理解为一个不包含逻辑代码的值对象(Value Object 简称VO)。

步骤三：持久化类和关系数据库的映射

编写*.hbm.xml文件

---该文件配置持久化类和数据库表之间的映射关系

<class name=“POJO的类全路径” table=“对应的库表名” //这两项一定要配置，其它的都可以不配置

discriminator-value=“discriminator_value” //区分不同子类的值，多态时使用。默认与类名一样

dynamic-update=“true | false” //是否动态更新SQL。false:每次都更新所有属性;true:只更新修改的

dynamic-insert=“true | false” //是否动态插入SQL。false:每次都插入所有属性;true:只插入非空的

select-before-update=“true | false” //是否在update前查询对象是否被修改过，修改过才update

polymorphism=“implicit | explicit” //设置多态是显性（explicit）的还是隐性（implicit）的

where=“查询时使用的SQL的条件子句” //查询时使用的SQL的条件子句

lazy=“true | false” //设置延迟加载策略

一个实体对应一个xml文件，组件用id，非组件用property。

*.hbm.xml文件样板：

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.tarena.ebank.biz.entity">

</generator></id>

</class>

</hibernate-mapping>

步骤四：Hibernate配置文件

hibernate.cfg.xml或hibernate.properties

1.需要配置那些信息：持久化映射，方言，特性，登陆信息

多数使用默认的设置。

A、dialect：方言，就是拼驱动程序和SQL语句。每种数据库对应一种方言。其实就是指定了用那一种数据库。

Oracle数据库方言：org.hibernate.dialect.OracleDialect

MySql数据库方言：org.hibernate.dialect.MySQLDialect

B、Object Persistence：对象持久化。把内存中的数据保存到一个永久的介质中，比如说数据库。

C、ORM：对象关系映射，是一个自动的过程

注：持久对象与临时对象最大的区别是有没有数据库id标识。

2.hibernate.cfg.xml的样板：

<?xml version='1.0' encoding='UTF-8'?>

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/Hibernate Configuration DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<property name="connection.url">jdbc:mysql://localhost:3306/test</property>

<property name="connection.driver_class">com.mysql.jdbc.Driver</property>

<property name="connection.password">password</property>

<property name="hbm2ddl.auto">update</property>

<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

<property name="cache.use_query_cache">false</property>

<property name="cache.use_second_level_cache">false</property>

<property name="dialect">org.hibernate.dialect.MySQLDialect</property>

<property name="myeclipse.connection.profile">mysql</property>

<property name="current_session_context_class">thread</property>

</session-factory>

</hibernate-configuration>

步骤五：使用Hibernate API

//读取Hibernate.cfg.xml配置文件，并读到内存中为后续操作作准备

Configuration config = new Configuration().configure();

//SessionFactory缓存了生成的SQL语句和Hibernate在运行时使用的映射元数据。

SessionFactory sessionFactory = config.buildSessionFactory();

//Session是持久层操作的基础，相当于JDBC中的Connection。

Session session = sessionFactory.openSession();

try{ //为保持事务的原子性，必须捕捉异常。所有事务都放在这一代码块里。

//操作事务时(增、删、改)必须显式的调用Transaction(默认：autoCommit=false)。

Transaction tx = session.beginTransaction();

for(int i=0; i<=1000; i++){

Student stu = new Student(...);

session.save(stu);//set value to stu

//批量更新：为防止内存不足，分成每20个一批发送过去。

if(i%20==0){session.flush();session.clear();}//不是大批量更新，则不需要写这一行

//默认时，会自动flush：查询之前、提交时。

} tx.commit();//提交事务，Hibernate不喜欢抛异常，如有需要，自己捕捉。

//查询方法。如果有必要，也可以用事务(调用Transaction)

String hql = "from Student s where s.stuNo like ? and s.Sal > ?";//Student是类而不是表

List list = session.createQuery(hql)

.setString(0, "a00_").setDouble(1, 3000.0)//设置HQL的第一二个问号取值

.list();//Hibernate里面，没有返回值的都默认返回List

StringBuffer sb = new StringBuffer();

for(Student st :(List<Student>)list){//(List<Student>)强制类型转换

sb.append(st.getOid()+" "+st.getName()+"\n");//拿到Student类里的属性

}System.out.print(sb.toString());//直接打印sb也可以，它也是调用toString，但这样写效率更高

} catch (HibernateException e) {

e.printStackTrace();

session.getTransaction().rollback();//如果事务不成功，则rollback

} finally {

session.close();//注意关闭顺序，session先关，Factory最后关(因为它可以启动多个session)

sessionFactory.close();//关闭SessionFactory，虽然这里没看到它，但在HbnUtil里开启了。

}

三、 Hibernate的查询方案(应该熟悉各种查询的使用方法)

1、利用Session接口提供的load方法或者get方法

2、Hibernate提供的主要查询方法

1)Criteria Query(条件查询)的步骤：

(1)通过Session来创建条件查询对象Criteria

Criteria criteria = session.createCriteria(Course.class);

(2)构建条件---创建查询条件对象Criterion

Criterion criterion1 = Property.forName("id").ge(39);//通过Property来创建

Criterion criterion2 = Restrictions.le("cycle", 5); //通过Restrictions来创建

(3)查询对象关联条件

criteria.add(criterion1);

(4)执行条件查询

List<Course> courses = criteria.list();

2)HQL(Hibernate Qurey Language)

特点：语法上与SQL类似；完全面向对象的查询；支持继承、多态、关联

(1) FROM子句

例如：查询所有的学生实例

Query query=session.createQuery("from Student"); query.list();

(2) SELECT子句

选择哪些对象和属性返回到结果集

A、SELECT语句后可以跟多个任意类型的属性，返回结果保存在Object类型的数组中

//A、B、C、都是查询学生的姓名和年龄

Query query=session.createQuery("select stu.name,stu.age from Student as stu");

List<Object[]> os=query.list();//返回的Object数组中有两个元素，第一个是姓名，第二个是年龄

B、SELECT语句后可以跟多个任意类型的属性，返回结果也可以保存在List中

Query query=session.createQuery

("select new List(stu.name,stu.age) from Student as stu");

List<List> lists=query.list();

C、SELECT语句后可以跟多个任意类型的属性，返回结果也可以是一个类型安全的POJO对象

Query query=session.createQuery

("select new Student(stu.name,stu.age) from Student as stu");

List<Student> stuList=query.list();//注意：Student类必须有Student(String,int)的构造方法

D、SELECT子句中可以使用聚集函数、数学操作符、连接

支持的聚集函数：avg、sum、min、max、count ….

(3) WHERE子句，限制返回结果集的范围

(4) ORDER BY子句，对返回结果集进行排序

四、 Hibernate对象的状态

实体对象的三种状态：

1) 暂态(瞬时态)(Transient)---实体在内存中的自由存在，它与数据库的记录无关。

po在DB中无记录(无副本)，po和session无关(手工管理同步)

如：Customer customer = new Customer(); customer.setName("eric");

这里的customer对象与数据库中的数据没有任何关联

2) 持久态(Persistent)---实体对象处于Hibernate框架的管理中。

po在DB中有记录，和session有关(session自动管理同步)

3)游离态(脱管态)(Detached)

处于Persistent状态的实体对象，其对应的Session实例关闭之后，那么，此对象处于Detached状态。

po在DB中有记录，和session无关(手工管理同步)

无名态：po处于游离态时被垃圾回收了。没有正本，只有DB中的副本。

po处于暂态时被垃圾回收了，则死亡。(唯一可以死亡的状态)

实质上，这三个状态是：持久对象的正副本与同步的关系

原则：尽量使用持久态。

暂态--->持久态

A.调用Session接口上的get()、load()方法

B.调用Session接口上的save()、saveOrUpdate()方法

持久态--->暂态

delete();

游离态--->持久态

update()、saveOrUpdate()、lock();

(lock不建议用，危险；肯定没变化时用，有则用updata)

持久态--->游离态

evict()、close()、clear()

(一般用evict，只关闭一个实体的连接；close关闭整个连接，动作太大)

五、Hibernate的关联映射
         Hibernate的关联关系有两种：单向、双向。
         其中单向关联分为：1-1、1-N、N-1、N-N。
         双向关联分为：1-1、1-N、N-N。

         5.1、单向N-1关联
          对于单向N-1关联，只需要在在N的一端的持久化类增加一个属性，该属性引用1的一端的关联实体。
         1、无连接表的N-1关联(基于外键)
         Hibernate使用<many-to-one.../>元素映射N-1的关联实体。N的一端采用<many-to-one.../>元素来映射关联关系，同时需要增加一个外键列，用来参照主表记录。1的一端保存不变。
[html]
<many-to-one name="address" class="Address" column="address_id" />

         注意：对于所有的基于外键约束关联关系中，都必须这样：要么总是持久化主表对应的实体，要么设置级联操作(cascade="all")。

         2、基于连接表的N-1关联
         对于基于有连接表的关联关系，需要使用<join.../>元素来映射。<join.../>元素用于强制将一个类的属性映射到多张表中。
在这里映射文件中这样：N的一端使用<join.../>元素来映射关联关系，同时还需要增加<key.../>子元素来映射外键，并且为<join.../>元素增加<many-to-one.../>子元素，用来映射N-1的关联实体。同样1的一端不变。
[html]
<join table="person_address">
    
    <key column="person_id"/>
    
    <many-to-one name="address" class="Address" column="address_id"/>
</join>

         5.2、单向1-1关联
         对于1-1关联而言，它有三种关联映射策略：基于外键、基于连接表、基于主键。
         1、基于外键的单向1-1关联
          基于外键的1-1关联映射与基于外键的N-1的映射文件几乎没有什么区别，只需要在<many-to-one../>元素中指定unique="true"即可实现。
[html]
<many-to-one name="address" class="Address" column="address_id" unique="true"/>

2、基于连接表的单向1-1关联
         基于连接表的1-1关联映射与基于连接表的N-1的映射也没有什么区别，同样只需要在<many-to-one../>元素中指定unique="true"即可实现。
[html]
<join table="person_address">
      
      <key column="person_id"/>
      
      <many-to-one name="address" class="Address" column="address_id" unique="true"/>
  </join>

3、基于主键的单向1-1关联
         对于基于主键的1-1关联映射，它的持久化类不能有自己的主键生成器策略，它的主键应该有关联实体来负责生成。
         采用<one-to-one.../>元素来映射基于主键的1-1关联。同时应该给该元素指定一个name属性，该属性的值指定关联实体属性的属性名。
[html]
<id name="id" column="person_id">
    <generator class="foreign">
        
        <param name="property">address</param>
    </generator>
</id>

<one-to-one name="address"/>

5.3、单向1-N关联
         对于单向1-N关联关系的持久化类，1的一端需要访问N的一端，而N的一端应该以集合的形式表现。
         1、基于无连接表的单向1-N
         在N的一端需要映射集合属性，还要使用<one-to-many.../>来映射关联实体。
[html]
<set name="address">
      
      <key column="person_id"/>
      
      <one-to-many class="Address"/>
  </set>

2、基于有连接表的单向1-N
         对于有连接表的1-N关联映射，映射文件使用<many-to-many.../>元素来映射关联实体，但为了保证当前实体是1的一端，需要增加unique="true"属性来指定。
[html]
<set name="address" table="person_address">
       <key column="person_id"/>
       
       <many-to-many class="Address" column="address_id" unique="true"/>
   </set>

5.4、单向N-N关联
         单向的N-N关联与1-N关联的持久化类完全相同，控制关系的一端需要增加一个Set类型的属性，被关联的持久化类实体以集合形式存在。
         映射文件也相同，只需要去掉unique="true"即可。
[html]
<set name="address" table="person_address">
       <key column="person_id"/>
       
       <many-to-many class="Address" column="address_id"/>
   </set>

         5.5、双向1-N关联
         双向的1-N关联的持久化类，N的一端增加引用到关联实体的属性，1的一端增加集合属性，集合元素为关联实体。
         1、基于无连接表的双向1-N关联
         对于基于无连接表的双向1-N关联的映射文件，需要在N的一端增加<many-to-one.../>元素来映射关联属性。而1的一端则需要使用<set.../>或者<bag.../>元素来映射关联属性，同时还需要增加<key.../>子元素映射外键列，并使用<one-to-many.../>子元素映射关联属性。此外由于对于1-N关联关系中，我们一般都是有N的一端来控制关联关系，所以我们需要在<set.../>元素中指定inverse="true"，用来指定1的一端不控制关联关系。
         1的一端的映射文件
[html]
<set name="name" inverse="true">
    <key column="person_id"/>
    <one-to-many class="Address"/>
</set>

         N的一端的映射文件
[html]
<many-to-one name="person" class="Person" column="person_id"/>

         2、基于连接表的双向1-N关联
         1的一端使用集合元素映射，然后在集合元素里增加<many-to-many.../>子元素，该子元素映射到关联类，同时在该子元素中增加unique="true"属性以保证该实体是1的一端。N的一端则使用<join.../>元素来强制使用连接表。
         1的一端映射文件
[html]
<set name="address" inverse="true" table="person_address">
    <key column="person_id"/>
    <many-to-many class="Address" column="address_id" unique="true"/>
</set>
       N的一端映射文件
[html]
<join table="person_address">
     <key column="address_id"/>
     <many-to-one name="person" column="person_id"/>
</join>

         这里必须要保证以下三队相等：两个table的值要相等、<set.../>元素里的<key../>的column属性的值与<join.../>元素里的<many-to-one../>的column属性的值相等、<set.../>元素里的<many-to-many.../>的column属性的值与<join.../>元素里的<key.../>的column属性的值相等。

         5.6、双向N-N关联
         双向N-N关联需要两端都使用Set集合属性，两端都增加对集合属性的访问。
[html]
<set name="address" table="person_address">
      <key column="person_id"/>
      <many-to-many class="Address" column="address_id"/>
  </set>
[html]
<set name="person" table="person_address">
      <key column="address_id"/>
      <many-to-many class="Address" column="person_id"/>
  </set>

         5.7、双向1-1关联
         双向的1-1关联同样有这样三种映射方式：基于外键、基于连接表、基于主键
         1、基于外键的双向1-1关联
         基于外键的1-1关联，外键可以存放在任意一边。需要存放外键的一端，需要增加<many-to-many.../>元素，这里需要为<many-to-many.../>元素增加unique="true"属性来表示该实体实际上是1的一端。
         另一端需要使用<one-to-one.../>元素，该<one-to-one.../>元素需要使用name属性指定关联属性名，同时使用property-ref属性指定引用关联类的属性。
[html]
<one-to-one name="address" property-ref="person"/>

[html]
<many-to-one name="person" unique="true" column="person_id"/>

         2、基于连接表的双向关联
     双向1-1关联两端都需要使用<join../>元素强制使用连接表，还需要在两端增加<many-to-one.../>元素映射关联属性，两个<many-to-many.../>元素都应该增加unique="true"
[html]
<join table="person_address">
     <key column="person_id"/>
     <many-to-one name="address" class="Address" column="address_id" unique="true"/>
</join>
[html]
<join table="person_address">
      <key column="address_id"/>
      <many-to-one name="person" class="Person" column="person_id" unique="true"/>
  </join>

         3、基于主键的双向关联
      在任意一端采用foreign主键生成器策略。两端同时使用<one-to-one.../>元素映射关联实体。
[html]
<id name="address_id">
       <generator class="foreign">
           <param name="property">person</param>
       </generator>
   </id>
   <one-to-one name="person"/>
[html] view plaincopyprint?
<one-to-one name="address"/>

这里关于关联映射要注意以下几点：
            1、对于所有的基于外键约束的关联关系中，要么选择先持久化主表记录对应的实体，要么是有级联操作
            2、对于1-N关联关系而言，我们一般都采用N的一端控制关联关系
            3、N-N的关联关系都需要使用连接表策略来进行映射
            4、单向关联更加难于查询。在大型应用中，几乎所有的关联必须在查询中可以双向导航。

         7.8、组件属性包含的关联实体
         对于组件属性的关联实体的映射文件使用<component.../>元素来映射该组件属性，然后在<component.../>元素里使用<set../>元素1-N关联实体。
[html]
<component name="address" class="Address">
   
    <parent name="person"/>
    <property name="addressDetail"/>
    
    <set name="schools">
        <key column="address_id"/>
        <one-to-many class="School"/>
    </set>
</component>

Angel_Y_

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
Hibernate 知识梳理

一、Hibernate核心API Configuration类: Configuration对象用于配置和启动Hibernate。Hibernate应用通过Configuration实例来指定对象-关系映射文件的位置或者动态配置Hibernate的属性，然后创建SessionFactory实例。 SessionFactory接口：一个Ses
复制链接

扫一扫