复习hiernate

 Configuration

Configuration 类负责管理 Hibernate 的配置信息

包括如下内容：1，Hibernate运行的底层信息：数据库的URL、用户名、密码、JDBC驱动类，数据库Dialect，数据库连接池等（对应 hibernate.cfg.xml 文件）。2，持久化类与数据表的映射关系（*.hbm.xml 文件）。

 

创建 Configuration 的两种方式

属性文件（hibernate.properties）
       Configuration cfg = new Configuration();

Xml文件（hibernate.cfg.xml）

加载默认名称的配置文件（hibernate.cfg.xml）
       Configuration cfg = new Configuration().configure();

或加载指定名称的配置文件：
       Configuration cfg = new Configuration().configure(“myhibernate.cfg.xml”);

 SessionFactory

Configuration对象根据当前的配置信息生成 SessionFactory 对象。SessionFactory 对象一旦构造完毕，即被赋予特定的配置信息（SessionFactory 对象中保存了当前的数据库配置信息和所有映射关系以及预定义的SQL语句。同时，SessionFactory还负责维护Hibernate的二级缓存）。 相关代码如下：

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

   SessionFactory sessionFactory = cfg.buildSessionFactory();

SessionFactory是线程安全的。

SessionFactory是生成Session的工厂：
       Session session = sessionFactory.openSession();

构造 SessionFactory 很消耗资源，一般情况下一个应用中只初始化一个 SessionFactory 对象。

 

Session(一次与数据库的会话)

Session 是应用程序与数据库之间交互操作的一个单线程对象，是 Hibernate 运作的中心，所有持久化对象必须在 session 的管理下才可以进行持久化操作。此对象的生命周期很短。Session 中有一个缓存，显式执行flush()方法之前，所有的持久层操作的数据都缓存在 session 对象处。（相当于 JDBC 中的 Connection）

持久化类与 Session 关联起来后就具有了持久化的能力。

Session是线程不安全的

Session 类的一些方法：

取得持久化对象的方法： get() load()

持久化对象都得保存，更新和删除：save(),update(),saveOrUpdate(),delete()

开启事务: beginTransaction().

管理 Session 的方法：isOpen(),flush(), clear(), evict(), close()等

 Transaction

代表一次原子操作，它具有数据库事务的概念。所有持久层都应该在事务管理下进行，即使是只读操作。

代表一次原子操作，它具有数据库事务的概念。所有持久层都应该在事务管理下进行，即使是只读操作。
Transaction tx = session.beginTransaction();

常用方法:

commit():提交相关联的session实例

rollback():撤销事务操作

wasCommitted():检查事务是否提交

Query和Criteria接口

都是查询接口，Query实例包装了HQL查询语句，hql是面向对象的，他引用类名及类的属性名，而不是表名和字段名。Criteria接口完全封装了基于字符串形式的查询语句，比Query接口更面向对象，他擅长执行动态查询。

Hibernate的运行过程

Hibernate的运行过程如下：

1、应用程序先调用Configuration类,该类读取Hibernate配置文件及映射文件中的信息，

2、并用这些信息生成一个SessionFactory对象，

3、然后从SessionFactory对象生成一个Session对象，

4、并用Session对象生成Transaction对象；

    A、可通过Session对象的get(),load(),save(),update(),delete()和saveOrUpdate()等方法对PO进行加载、保存、更新、删除、等操作；

    B、在查询的情况下，可通过Session对象生成一个Query对象，然后利用Query对象执行查询操作；如果没有异常，Transaction对象将提交这些操作到数据库中。

 

 动创建表：(hibernate.cfg.xml中配置)

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

create：先删除，再创建

update：如果表不存在就创建，不一样就更新，一样就什么都不做。在开发                   的时候使用较多。

create-drop：初始化时创建表，SessionFactory执行close()时删除 表。

validate：验证表结构是否一致，如果不一致，就抛异常。部署时可以使用

对持久化对象的要求

提供一个无参的构造器。使Hibernate可以使用Constructor.newInstance() 来实例化持久 化类。

提供一个标识属性（identifier property）。通常映射为数据库表的主键字段。如果没有该 属性，一些功能将不起作用，如：Session.saveOrUpdate()。

为类的持久化类的字段声明访问方法（get/set）。Hibernate对JavaBeans风格的属性实行        持久化。

使用非final类。在运行时生成代理是Hibernate的一个重要的功能。如果持久化类没有 实现任何接口，Hibnernate 使用 CGLIB 生成代理。如果使用的是 final 类，则无法生    成CGLIB代理。

重写eqauls()和hashCode()方法。如果需要把持久化类的实例放到Set中（当需要进行    关联映射时），则应该重写这两个方法。

OID

为了在系统中能够找到所需对象，需要为每一个对象分配一个唯一的标识号。在关系数据库中称之为主键，而在对象术语中，则叫做对象标识(Object identifier-OID)。

使用基本数据类型和包装类型的区别

基本数据类型和包装类型对应的hibernate映射类型相同（映射是一样的），例：

propertye （默认值）：

表明hibernate通过getXXX和setXXX来访问类属性。推荐使用。提高域模型透明性。

field

hibernate通过java反射机制直接访问类属性。对于没有get与set方法的属性可设置该访问策略。

noop

它映射Java持久化类中不存在的属性，即主要用于HQL（用query接口测试,使用hql语句）中，当数据库中有某列，而实体中不存在的情况。

 

OID，唯一性的标志

关系数据库用主键区分是否是同一条记录。

Hibernate使用OID来建立内存中的对象和数据库中记录的对应关系。对象的OID和数据库的表的主键对应。为保证OID的唯一性，应该让Hibernate来为OID赋值。

 

主键必备条件：

1，不能为null。

2，唯一，不能重复。

3，永远不会改变。

自然主键和代理主键

自然主键：把具有业务含义的字段作为主键叫做自然主键。

代理主键：不具备业务含义的字段，该字段一般取名为“id”。（推荐）

 

关系数据库按主键区分不同记录

 

把主键定义为自动增长类型

在my SQL中，把字段设为auto_increment类型，数据库会自动为主键赋值。

在ms SQL server中，把字段设为identity类型，数据库会自动为主键赋值。

 

oracle从序列(sequence)中获取自动增长的描述符

create sequence seq_customer increment by 2 start with 1

insert into customers  values(seq_customer.curval,’..’)

 

java与Hibernate如何区分对象

Java语言按内存地址（==）或equals()方法区分不同的对象

 

Hibernate中用对象表示符(OID)来区分对象

OID是关系数据库中的主键在java对象模型中的等价物。在运行时，hibernate根据OID来维持java对象和数据库记录的对应关系。

Hibernate使用OID来区分对象，不是equals()方法！所以不重写持久化类的hashCode()与equals()方法Hibernate也可以正确运行（但要放到HashSet等集合中时要注意需要重写这两个方法）。

iD和 generator元素配置说明

配置示例：

<id name=“id” type=“long” column=“ID”>

      <generator class=“increment” />

</id>

 

<id>元素说明：

设定持久化类的 OID 和表的主键的映射，可以有以下属性：

name: 标识持久化类 OID 的属性名 

column: 设置标识属性所映射的数据列的列名(主键字段的名字).

unsaved-value:若设定了该属性, Hibernate 会通过比较持久化类的 OID 值和该属性值来区分当前持久化类的对象是否为临时对象,在Hibernate3中几乎不再需要.

type:指定 Hibernate 映射类型. Hibernate 映射类型是 Java 类型与 SQL 类型的桥梁. 如果没有为某个属性显式设定映射类型, Hibernate 会运用反射机制先识别出持久化类的特定属性的 Java 类型, 然后自动使用与之对应的默认的 Hibernate 映射类型

Java 的基本数据类型和包装类型对应相同的 Hibernate 映射类型. 基本数据类型无法表达 null, 所以对于持久化类的 OID 推荐使用包装类型

 

<generator>元素说明

设定持久化类设定标识符生成器，可以有一个class属性：

class: 指定使用的标识符生成器全限定类名或其缩写名。

 

<generator>元素的class属性可以指定的值说明（主键生成策略）

主键生成器	描述
increment	适用于代理主键。由hibernate自动以递增的方式生成表识符，每次增量为1。
identity	适用于代理主键。由底层数据库生成表识符。条件是数据库支持自动增长数据类型。
sequence	适用于代理主键。Hibernate根据底层数据库序列生成标识符。条件是数据库支持序列。
hilo	适用于代理主键。Hibernate根据hign/low算法生成标识符。Hibernate把特定表的字段作为“hign”值。默认情况下，采用hibernate_unique_key表的next_hi字段。
native	适用于代理主键。根据底层数据库对自动生成表示符的能力来选择identity、sequence、hilo
uuid.hex	适用于代理主键。Hibernate采用128位的UUID算法来生成标识符。该算法能够在网络环境中生成唯一的字符串标识符，这种策略并不流行，因为字符串类型的主键比整数类型的主键占用更多的数据库空间。
assigned	适用于自然主键。由java程序负责生成标识符。不能把setID()方法声明为private的。尽量避免使用自然主键。

 

increment

 

increment 标识符生成器由 Hibernate 以递增的方式为代理主键赋值

Hibernate 会先读取表中的主键的最大值，向表中插入记录时, 就在 max(id) 的基础上递增，增量为1。

适用范围：

由于 increment生存标识符机制不依赖于底层数据库系统，因此它适合所有的数据库系统。

适用于只有单个 Hibernate 应用进程访问同一个数据库的场合，在多线程情况下会有问题（线程不安全）。

OID必须为long、int或 short 类型，如果把OID定义为byte类型，在运行时会抛出异常

identity

 

 

identity 标识符生成器由底层数据库来负责生成标识符, 它要求底层数据库把主键定义为自动增长字段类型。

适用范围:

由于 identity 生成标识符的机制依赖于底层数据库系统，因此，要求底层数据库系统必须支持自动增长字段类型。支持自动增长字段类型的数据库包括：DB2、 Mysql、MSSQLServer、Sybase等。

OID 必须为 long, int 或 short 类型, 如果把 OID 定义为 byte 类型, 在运行时会抛出异常。

sequence

 

 

sequence  标识符生成器利用底层数据库提供的序列来生成标识符.

Hibernate 在持久化一个 News 对象时, 先从底层数据库的 news_seq 序列中获得一个唯一的标识号, 再把它作为主键值

适用范围:

由于 sequence 生成标识符的机制依赖于底层数据库系统的序列，因此，要求底层数据库系统必须支持序列。支持序列的数据库包括：DB2 Oracle 等。

OID 必须为 long, int 或 short 类型, 如果把 OID 定义为 byte 类型, 在运行时会抛出异常。

hilo

(在hilo中这些关键字都不能修改)

hilo 标识符生成器由 Hibernate 按照一种 high/low 算法*生成标识符, 它从数据库的特定表的字段中获取 high 值.

Hibernate 在持久化一个 News 对象时, 由 Hibernate 负责生成主键值. hilo 标识符生成器在生成标识符时, 需要读取并修改 HI_TABLE 表中的 NEXT_VALUE 值.

适用范围：

由于 hilo 生存标识符机制不依赖于底层数据库系统, 因此它适合所有的数据库系统

OID 必须为 long, int 或 short 类型, 如果把 OID 定义为 byte 类型, 在运行时会抛出异常

native （在开发中用得最多）

 

native 标识符生成器依据底层数据库对自动生成标识符的支持能力, 来选择使用 identity, sequence 或 hilo 标识符生成器.

适用范围:

由于 native 能根据底层数据库系统的类型, 自动选择合适的标识符生成器, 因此很适合于跨数据库平台开发

OID 必须为 long, int 或 short 类型, 如果把 OID 定义为 byte 类型, 在运行时会抛出异常

  

 Hibernate映射类型

内置映射类型

Hibernate	java	sql	取值范围
integer int	int Integer	INTEGER	4
long	long Long	BIGINT	8
short	short Short	SMALLINT	2
byte	byte Byte	TINYINT	1
float	float Float	FLOAT	4
double	double Double	DOUBLE	8
big_decimal	java.math.BigDecinimal	NUMERIC	8位含2位小数部分
character	char Character String	CHAR(1)	定长字符
string	String	VARCHAR	变长串
boolean	boolean Boolean	BIT	布尔
yes_no	boolean Boolean	CHAR(1)	布尔
true_false	boolean Boolean	CHAR(1)	布尔

 

java时间和日期类性

Hibernate	java	sql	取值范围
date	util.Date sql.Date	DATE	YYYY-MM-DD
time	util.Date sql.Time	TIME	HH:MM:SS
timestamp	util.Date sql.timestamp	TIMESTAMP	YYYYMMDDHHMMSS
calendar	java.util.Calendar	TIMESTAMP	YYYYMMDDHHMMSS
calendar_date	java.util.Calendar	DATE	YYYY-MM-DD

 

大对象类型的映射

Hibernate	java	sql
binary	byte[]	VARBINARY(BLOB)
text	String	CLOB
serializable	实现类	BARBINARY(BLOB)
clob	sql.Clob	CLOB
blob	sql.Blob	BLOB

 

不允许以上类型来定义OID

 

 

（Hibernate Reference3.2.2中有）JDBC 类 java.sql.Clob 和 java.sql.Blob的映射。某些程序可能不适合使用这个类型，因为blob 和 clob 对象可能在一个事务之外是无法重用的。（而且, 驱动程序对这种类型的支持充满着补丁和前后矛盾。）

JDK自带的个别java类的映射类型

Hibernate	java	sql
class	java.lang.Class	VARCHAR
locale	java.util.Locale	VARCHAR
timezone	java.util.TimeZone	VARCHAR
currency	java.util.Currency	VARCHAR

 

集合属性大致有两种:

单纯的集合属性，如像List、Set或数组等集合属性

Map结构的集合属性，每个属性值都有对应的Key映射

 

集合映射的元素大致有如下几种：

list:        用于映射List集合属性

set:               用于映射Set集合属性

map:             用于映射Map集合性

array:             用于映射数组集合属性

bag:              用于映射无序集合

idbag:            用于映射无序集合，但为集合增加逻辑次序

使用集合属性时，一定要使用接口，而不能声明为具体的实现类。

因为经过Session操作后，集合就变成了Hibernate自己的集合实现类

Set

但Set是无序，不可重复的集合。

 

  <class name="Teacher" table="t_teacher">

        <id name="id" column="id" type="int">

        <generator class="native"/>

        </id>

        <property name="name" column="name" type="string" length="20"></property>

           <set name="course" table="t_teacher_course" order-by="caurse DESC">

                  <key column="teacherId"></key>

                  <element type="string" column="caurse" ></element>

           </set>

    </class>

order-by 影响是查询顺序（使用较多）

Sort可以影响插入顺序，但是必须是有序集合例如treeset list

测试程序

public class TeacherDao {

       private static SessionFactory  sf;

       static{

              Configuration cfg =  new Configuration();

              cfg.configure();

              cfg.addClass(Teacher.class);

              sf = cfg.buildSessionFactory();

       }

       @Test

       public void save() throws Exception{

              Set<String> set  = new HashSet<String>();

              set.add("java软件开发");

              set.add("C语言");

              set.add("MySql数据库");

             

              Teacher teacher =  new Teacher();

              teacher.setName("张三");

              teacher.setCourse(set);

             

              Session session =  sf.openSession();

              Transaction tc = null  ;

              try {

                     tc  = session.beginTransaction();

                     session.save(teacher);

                     tc.commit();

              } catch (Exception e) {

                     tc.rollback();

                     throw e;

              }finally{

                     session.close();

              }

             

             

       }

       @Test

       public void getById() throws Exception{

              Teacher teacher = null;

              Session session =  sf.openSession();

              Transaction tc = null  ;

              try {

                     tc  = session.beginTransaction();

                     teacher = (Teacher) session.get(Teacher.class, 1);

                     System.out.println(teacher.getId());

                     System.out.println(teacher.getName());

                     System.out.println(teacher.getCourse().toString());

                     tc.commit();

              } catch (Exception e) {

                     tc.rollback();

                     throw e;

              }finally{

                     session.close();

              }

             

             

       }

      

}

 

 

 

注：映射 Set 集合属性时，如果 element 元素包括 not-null = “true” 属性，则集合属性表以关联持久化类的外键和元素列作为联合主键，否则该表没有主键。但 List 集合属性不会，List 集合属性总是以外键列和元素此序列作为联合主键。

在实际应用中，我遇到要求没有顺序不重复的情况很多，所以一般set集合。

 

List是有序集合，可以重复

因此持久化到数据库时必须增加一列来表示集合元素的次序。

集合属性只能以接口声明(当持久化某个实例时, Hibernate 会自动把程序中的集合实现类替换成 Hibernate 自己的集合实现类)，因此下面代码中，schools的类型能是List，不能是ArrayList,

 

映射说明

list元素要求用list-index的子元素来映射有序集合的次序列。

集合的属性的值会存放有另外的表中，须以外键关联，用 Key 元素来映射外键列。

当集合元素是基本数据类型及其包装类, 字符串或日期类型时使用 element 来映射集合属性

 

<list name="course" table="t_teacher_course">

                  <key column="teacherId"></key>

                  <list-index column="indx"></list-index>不使用index关键字

                  <element type="string" column="caurse" length="100"></element>

           </list>

 

 

测试程序：

 

@Test

       public void save() throws Exception{

              List<String> list = new ArrayList<String>();

              list.add("java软件开发");

              list.add("C语言");

              list.add("MySql数据库");

              Teacher teacher =  new Teacher();

              teacher.setName("张三");

              teacher.setCourse(list);

             

              Session session =  sf.openSession();

              Transaction tc = null  ;

              try {

                     tc  = session.beginTransaction();

                     session.save(teacher);

                     tc.commit();

              } catch (Exception e) {

                     tc.rollback();

                     throw e;

              }finally{

                     session.close();

              }

             

             

       }

生成的表及插入的数据

 

 

数组

数组属性的映射和 List 的处理方式基本一致

数组使用 <array> 元素完成完成映射

<array name="course" table="t_teacher_course">

                  <key column="teacherId"></key>

                  <list-index column="indx"></list-index>

                  <element type="string" column="course" length="100"></element>

           </array>

代码：

@Test

       public void save() throws Exception{

             

              String[] array = new String[]{"java软件开发1","C语言","MySql数据库"};

              Teacher teacher =  new Teacher();

              teacher.setName("张三");

              teacher.setCourse(array);

             

              Session session =  sf.openSession();

              Transaction tc = null  ;

              try {

                     tc  = session.beginTransaction();

                     session.save(teacher);

                     tc.commit();

              } catch (Exception e) {

                     tc.rollback();

                     throw e;

              }finally{

                     session.close();

              }

             

             

       }

 

Bag的特性是：允许重复的元素，但无序。在Java的标准API中并没有提供Bag容器，Hibernate提供自己的Bag实现，允许您将List映射为Bag。

 

bag元素既可以为List集合属性映射，也可以为Collection集合属性映射。

不管是哪种集合属性，使用bag元素都将被映射成无序集合，而集合属性对应的表没有主键。

Bag 元素只需要 key 元素来映射外键列，使用 element 元素来映射集合属性的每个元素。

<bag name="course" table="t_teacher_course">

                  <key column="teacherId"></key>

                  <element type="string" column="caurse" ></element>

           </bag>

测试程序：

 

@Test

       public void save() throws Exception{

              List<String> list = new ArrayList<String>();

              list.add("java软件开发");

              list.add("C语言");

              list.add("MySql数据库");

              Teacher teacher =  new Teacher();

              teacher.setName("张三");

              teacher.setCourse(list);

             

              Session session =  sf.openSession();

              Transaction tc = null  ;

              try {

                     tc  = session.beginTransaction();

                     session.save(teacher);

                     tc.commit();

              } catch (Exception e) {

                     tc.rollback();

                     throw e;

              }finally{

                     session.close();

              }

       }

 

 

Map不仅需要映射属性值，还需要映射属性Key。

Hibnernate 将以外键列和Key列作为联合主键。

Map集合属性使用map元素映射，该元素需要key和map-key两个子元素

key子元素用于映射外键列，

map-key子元素则用于映射Map集合的Key。

map-key和element元素都必须确定type属性 

 

 

<map name="course" table="t_teacher_course">

                  <key column="teacherId"></key>

                  <map-key type="string" column="kemu" length="100"></map-key>

                  <element type="string" column="course" length="100"></element>

           </map>

代码实现：

public void save() throws Exception{

             

              Map<String, String> map = new HashMap<String, String>();

             

              map.put("科目1：", "java软件开发1");

              map.put("科目2：", "C语言");

              Teacher teacher =  new Teacher();

              teacher.setName("张三");

              teacher.setCourse(map);

             

              Session session =  sf.openSession();

              Transaction tc = null  ;

              try {

                     tc  = session.beginTransaction();

                     session.save(teacher);

                     tc.commit();

              } catch (Exception e) {

                     tc.rollback();

                     throw e;

              }finally{

                     session.close();

              }

       }

哦对了忘记说一个事情 我这里面的初始化方法是比较老的那种新的请参见 不同版本的 api