hibernate总结

Hibernate总结

1.什么是Hibernate？

首先，hibernate是数据持久层的一个轻量级框架。数据持久层的框架有很多比如：iBATIS,myBatis,Nhibernate,Siena等等。

并且Hibernate是一个开源的orm（object relations mapping）框架，提供了查询获取数据的方法，用面向对象的思想来操作数据库，节省了我们开发处理数据的时间。

2.那使用Hibernate的优点呢？

1.使用简介的hql语句（Hibernate query language）。可以不使用传统的insert，update等sql语句。比如insert一个对象，原来的做法是：insert into 表名称 alue（值1，值2，值3，……），而现在的做法是：save（对象）。

2.使用or映射。对象到关系数据库之间的映射。是从对象的角度操作数据库，再次体现了面向对象思想。原来的实体抽取方法：首先有了表，然后表映射实体对象。而现在Hibernate做法是：直接由对象映射到表。

3.没有侵入性，移植性比较好。什么是没有侵入性？就是Hibernate采用了pojo对象。所谓的pojo对象就是没有继承Hibernate类或实现Hibernate接口。这样的话，此类就是一个普通的Java类，所以移植性比较好。

4.支持透明持久化。透明是针对上层而言的。三层架构的理念是上层对下层的依赖，只是依赖接口不依赖具体实现。而Hibernate中的透明是指对业务逻辑层提供了一个接口session，而其他的都封装隐藏。持久化是指把内存中的数据存放到磁盘上的文件中。

3.当然一个事物，不可能十全十美，即使如此优秀的Hibernate也有自己的弱点。比如：若是大量数据批量操作。则不适合使用Hibernate。并且一个持久化对象不能映射到多张表中。

4.Hibernate中核心5个接口

1.Configuration接口：负责配置及启动Hibernate，用来创建sessionFactory

2.SessionFactory接口：一个SessionFactory对应一个数据源存储，也就是一个数据库对应一个SessionFactory。SessionFactory用来创建Session对象。并且SessionFactory是线程安全的，可以由多个线程访问SessionFactory共享。

3.Session接口：这个接口是Hibernate中常用的接口，主要用于对数据的操作（增删改查）。而这个Session对象不是线程安全的。不能共享。

4.Query接口：用于数据库的查询对象。

5.Transaction接口：Hibernate事务接口。它封装了底层的事务操作，比如JTA（;Java transcation architecture）所有的数据操作，比如增删改查都写在事务中。

1.创建普通的Java项目。

因为hibernate是一个轻量级的框架，不像servlet，还必须需要tomcat的支持，Hibernate只要jdk支持即可。

2.引入jar包。

可以在项目中直接引入jar包，在：项目--->属性--->然后如下图：

另一种办法就是引入库，相当于一个文件夹，把所有的jar包放到自己新建的文件夹中。在：窗体-->选项-->然后如下图：

3.提供Hibernate的配置文件。hibernate.cfg.xml文件。完成相应的配置

<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>
<property name="hibernate.connection.username">root</property>
10.

11. <property name="hibernate.connection.password">bjpowernode</property>

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

15. </session-factory>

17. </hibernate-configuration>

在这里连接MySQL数据库，解释一下上面的标签。按照顺序来依次解释：第一个是连接mySql的驱动；第二个是连接的url；url后面的hibernate_first是数据库名字；第三个是和第四个分别是用户名和密码。第五个是方言。因为 hibernate对数据库封装，对不同的数据库翻译成不同的形式，比如drp中的分页，若是使用Oracle数据库，则翻译成sql语句三层嵌套。若是使用mySql数据库，则翻译成limit语句。

4.建立实体User类：

package com.bjpowernode.hibernate;
import java.util.Date;
public class User {
private String id;
private String name;
10.
11. private String password;
12.
13. private Date createTime;
14.
15. private Date expireTime;
16.
17. public String getId() {
18. return id;
19. }
20.
21. public void setId(String id) {
22. this.id = id;
23. }
24.
25. public String getName() {
26. return name;
27. }
28.
29. public void setName(String name) {
30. this.name = name;
31. }
32.
33. public String getPassword() {
34. return password;
35. }
36.
37. public void setPassword(String password) {
38. this.password = password;
39. }
40.
41. public Date getCreateTime() {
42. return createTime;
43. }
44.
45. public void setCreateTime(Date createTime) {
46. this.createTime = createTime;
47. }
48.
49. public Date getExpireTime() {
50. return expireTime;
51. }
52.
53. public void setExpireTime(Date expireTime) {
54. this.expireTime = expireTime;
55. }

56. }

5.建立User.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>
<class name="com.bjpowernode.hibernate.User">
<id name="id">
<generator class="uuid"/>
</id>
10. <property name="name"/>
11. <property name="password"/>
12. <property name="createTime"/>
13. <property name="expireTime"/>
14. </class>

15. </hibernate-mapping>

6.我们也映射完毕了，但是hibernate怎么知道我们映射完了呢，以及如何映射的呢？这就需要我们把我们自己的映射文件告诉hibernate,即：在hibernate.cfg.xml配置我们的映射文件。

<mapping resource="com/bjpowernode/hibernate/User.hbm.xml"/>

7.生成数据库表。大家也看到了我们上述还没有新建数据表呢，在第三步我们只是新建了数据库而已。按照我们普通的做法，我们应该新建数据表啊，否则实体存放何处啊。这个别急，数据库表这个肯定是需要有的，这个毋庸置疑，但是这个可不像我们原来需要自己亲自动手建立哦，现在hibernate需要帮我们实现哦，如何实现嗯，hibernate会根据配置文件hibernate.cfg.xml和我们的映射文件User.hbm.xml会自动给我们生成相应的表，并且这个表的名字也给我们取好：默认是User。那如何生成表呢？

//默认读取hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();
SchemaExport export = new SchemaExport(cfg);
export.create(true, true);

8.那我们就开始进行操作啦，我们添加一个用户对象，看看hibernate是如何添加的呢？跟我们以前的做法有什么不同呢？

public class Client {
public static void main(String[] args) {
//读取hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();
//建立SessionFactory
SessionFactory factory = cfg.buildSessionFactory();
10.
11. //取得session
12. Session session = null;
13. try {
14. session = factory.openSession();
15. //开启事务
16. session.beginTransaction();
17. User user = new User();
18. user.setName("张三");
19. user.setPassword("123");
20. user.setCreateTime(new Date());
21. user.setExpireTime(new Date());
22.
23. //保存User对象
24. session.save(user);
25.
26. //提交事务
27. session.getTransaction().commit();
28. }catch(Exception e) {
29. e.printStackTrace();
30. //回滚事务
31. session.getTransaction().rollback();
32. }finally {
33. if (session != null) {
34. if (session.isOpen()) {
35. //关闭session
36. session.close();
37. }
38. }
39. }
40. }

41. }

第八步，我们可以看到，没有我们熟悉的insert into表的sql语句了，那怎么添加进去的呢，到底添加了没？让我真实滴告诉你，确实添加进去了，不信的，可以自己尝试哦，这也是hibernate的优点，对jdbc封装的彻底，减少了我们对数据的操作时间哈。

那我们看一下hibernate中整体的内容：

hibernate框架中主键的生成策略有三种方式：

1，数据库负责生成主键（代理主键）

a,native:表示由设置的方言决定采用什么数据库生成主键方式，例如：在MySQL中会采用自增长的方式，主键字段必须都是整形类型；在Oracle数据库中，会采用序列的增长方式。

b,sequence:表示采用数据库的序列生成主键，适用于Oracle，DB2数据库中。

c,identity:表示采用自增长的主键生成方式，适用于MySQL,SQL Server中。

2，Hibernate框架负责生成主键值（代理主键）：

a,increment:表示由框架本身提供计数器，累加数据，获取主键。

b,uuid:由框架根据参数（IP地址，JVM虚拟机启动时间，系统时间，计数器等）生成32位16进制的数字字符串。

3，用户提供主键值（自然主键）：

Assigned:业务（自己）提供主键。

当然这里常用的是native,uuid和Assigned三值。在设置POJO类与表映射时，进行主键设置，标签为<id>，在其中的<generator>标签中进行设置，例如：

	瞬时状态	持久化状态	游离状态
增（Save）	可以	不可以（没必要）	不可以（没必要）
改（Update）	不可以	修改后会自动更新，不需手动	可以
删（delete）	不可以	可以	可以
查	不可以	可以	可以

	uuid	assigned	native
存在记录	发送upate语句	会查询判断，再更新	发送update语句
记录不存在	发送语句，剖异常	会查询判断，进行插入操作	发送语句，剖异常

标签	起作用到什么地方	取值解释
<class>	针对load方法	true : 延迟加载（默认） false : 禁用延迟加载
<set>	针对于一对多，多对多	true : 延迟加载 (默认) false : 禁用延迟加载 extra : 支持延迟加载,在访问集合自身信息时可以发送高效的查询语句。(推荐)
<many-to-one>	针对于多对一，一对一	false : 禁用延迟加载 proxy : 延迟加载 (默认) no-proxy : 支持延迟加载，不使用cglbi代理的方式完成延迟加载。通过第三方的字节码增强工具。
<one-to-one>	针对一对一	和<many-to-one>标签一样，这里需要注意：一对一的主键关联映射，根据主动方(不含外键)查询被动方(既是主键，又是外键)时不支持延迟加载的。

hibernate总结

hibernate框架中主键的生成策略有三种方式：

Hibernate，对三种状态下的POJO的增删改查操作：

一对一关系映射：

多对多的关系

Lazy（懒加载）

持久化对象的三种状态。

导航

公告