浅谈Hibernate入门

前言

最近打算做一个自己的个人网站，经过仔细思考，打算使用hibernate作为开发的ORM框架，因此各种找资料，由于本人是刚刚接触这技术的，所以就找了比较基础的知识来分享下

基本概述

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。

hibernate是轻量级的ORM框架，ORM全称object/relationmapping[对象/关系映射]。

PS：JAR包及其文档可以在官网网站下载：http://www.hibernate.org

ORM基本概念

对象关系映射（ObjectRelationMapping，简称ORM）是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，将java程序中的对象自动持久化到关系数据库中。本质上就是将数据从一种形式转换到另外一种形式。

PS：通过ORM这种技术可以在JAVA程序以类和对象的形式去操控数据库的表和记录。

ORM框架

1、ApacheOJB

2、Hibernate

3、iBatis

4、SMYLE

5、TopLink

使用Hibernate的好处

1、引入hibernate可以使工作人员角色细化，让程序员更关心业务流程。让数据库人员关注数据库相关的各种操作。

2、分层更清晰，耦合性更小。

3、通用性强：可以更轻松的从一个数据库平台转移到别的平台。

4、对象化：把关系数据库变成了Java的对象，更加方便操作。

5、性能保证：hibernate可能按不同的数据库，处理不同的操作是用最优化的SQL语句。

6、增加了程序的鲁棒性。

基本原理图

PS：Hibernate的基本原理是通过反射机制，将DB中的表与Java类进行映射。

Hibernate框架与JDBC的区别

PS：使用JDBC的时候如果有结果需要处理还需要进行二次封装，而Hibernate这样的ORM框架已经在内部就已经封装好了，故其功能更强大，也更便捷。

MVC框架图(加上Hibernate框架)

PS：这可以和前段时间写的Struts入门、WebMVC模式实现 这两篇博客里的MVC模式进行比较。

Hibernate开发的三种方式

1、由Domain对象->mapping->database(官方推荐)

2、由Database->Domain对象->mapping

3、由映射文件开始

PS：其实通过MyEclipse可以自动生成大部分代码，但是为了理解的更深刻，还是要学习手工开发。

Hibernate手工开发

采用上述第二种方式，实现一个员工管理系统。

1、Database设计(Oracle)

--创建employee表

1. createtableemployee
2. (
3. idnumberprimarykey,--编号
4. namevarchar2(50)notnull,--姓名
5. emailvarchar2(50)notnull,--电子邮件
6. hiredatedatenotnull--入职时间
7. );
8. --创建employee自增序列
9. createsequenceemp_seq
10. startwith1
11. incrementby1
12. minvalue1
13. nomaxvalue
14. nocycle
15. nocache
16. ;

2、引入hibernate包

这个可以到官方网站上下载，然后引入。

3、编写POJO类(Employee类)

packagecom.pc.domain;

1. importjava.io.Serializable;
2. importjava.util.Date;
3. /**
4. *
5. *@authorSwitch
6. *@functionemployee表的映射Domain对象
7. *@description可以视为Domain对象、Javabean、POJO，该POJO按照规范应当序列化，目的是唯一的标识该对象,同时可以在网络和文件传输
8. *
9. */
10. publicclassEmployeeimplementsSerializable{
11. /**
12. *
13. */
14. privatestaticfinallongserialVersionUID=1L;
15. privateIntegerid;
16. privateStringname;
17. privateStringemail;
18. privateDatehiredate;
19. publicIntegergetId(){
20. returnid;
21. }
22. publicvoidsetId(Integerid){
23. this.id=id;
24. }
25. publicStringgetName(){
26. returnname;
27. }
28. publicvoidsetName(Stringname){
29. this.name=name;
30. }
31. publicStringgetEmail(){
32. returnemail;
33. }
34. publicvoidsetEmail(Stringemail){
35. this.email=email;
36. }
37. publicDategetHiredate(){
38. returnhiredate;
39. }
40. publicvoidsetHiredate(Datehiredate){
41. this.hiredate=hiredate;
42. }
43. }

4、编写对象映射文件(Employee.hbm.xml)

<?xmlversion="1.0"encoding="UTF-8"?>

1. <!--映射文件需要DTD来指定格式-->
2. <!DOCTYPEhibernate-mappingPUBLIC
3. "-//Hibernate/HibernateMappingDTD3.0//EN"
4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
5. <!--该文件用于配置domain对象和表的映射关系-->
6. <!--package指定是哪个包下面的映射-->
7. <hibernate-mappingpackage="com.pc.domain">
8. <!--name指domain对象的名字-->
9. <!--table指表的名字-->
10. <classname="Employee"table="employee">
11. <!--ID元素用户指定主键属性-->
12. <!--name指定domain对象中的主键属性-->
13. <!--column指定表中的主键列-->
14. <!--type指定属性类型-->
15. <idname="id"column="id"type="java.lang.Integer">
16. <!--该元素用户指定主键值生成策略-->
17. <!--class指生成策略类型-->
18. <!--hilonativeincrementsequenceuuid等-->
19. <generatorclass="sequence">
20. <!--name指定生成策略参数名-->
21. <!--其中的值表示对应的东西，这里是一个自增序列-->
22. <paramname="sequence">emp_seq</param>
23. </generator>
24. </id>
25. <!--对其它属性的配置-->
26. <!--name表示属性名-->
27. <!--type表示属性类型-->
28. <propertyname="name"type="java.lang.String">
29. <!--配置对应列属性-->
30. <!--name对应于表中相应列-->
31. <!--not-null之类的属性可以表示该列的限制-->
32. <columnname="name"not-null="false"/>
33. </property>
34. <propertyname="email"type="java.lang.String">
35. <columnname="email"not-null="false"/>
36. </property>
37. <propertyname="hiredate"type="java.util.Date">
38. <columnname="hiredate"not-null="false"/>
39. </property>
40. </class>
41. </hibernate-mapping>

5、配置hibernate.cfg.xml

<?xmlversion="1.0"encoding="UTF-8"?>

1. <!DOCTYPEhibernate-configurationPUBLIC
2. "-//Hibernate/HibernateConfigurationDTD3.0//EN"
3. "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
4. <hibernate-configuration>
5. <!--配置oracle连接-->
6. <session-factory>
7. <!--常用配置可以参考hibernate集合包主目录projectetc、hibernate.properties文件-->
8. <!--配置driver-->
9. <!--name表示参数类型-->
10. <!--元素值表示参数内容-->
11. <propertyname="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
12. <!--配置url-->
13. <propertyname="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:SWITCH</property>
14. <!--配置用户名-->
15. <propertyname="connection.username">scott</property>
16. <!--配置密码-->
17. <propertyname="connection.password">123456</property>
18. <!--配置显示hibernate生成的sql,特别说明，在开发阶段设为true利于调试，在使用项目则设为false-->
19. <propertyname="show_sql">true</property>
20. <!--配置dialect，明确的告知Hibernate连接的是哪种数据库-->
21. <propertyname="dialect">org.hibernate.dialect.OracleDialect</property>
22. <!--指定管理的对象映射文件-->
23. <!--resource指定单个domain对象的配置文件-->
24. <mappingresource="com/pc/domain/Employee.hbm.xml"/>
25. </session-factory>
26. </hibernate-configuration>

6、编写测试类测试

为了简单这里不写EmployeeService类提供服务了，直接调用持久层。但是实际开发，必须要通过EmployeeService调用持久层提供服务。

packagecom.pc.view;

1. importjava.util.Date;
2. importorg.hibernate.SessionFactory;
3. importorg.hibernate.Transaction;
4. importorg.hibernate.cfg.Configuration;
5. importorg.hibernate.classic.Session;
6. importcom.pc.domain.Employee;
7. importcom.pc.util.MySessionFactory;
8. publicclassTestMain{
9. publicstaticvoidmain(String[]args){
10. //使用hibernate完成crud操作(只见对象，不见表)
11. //不使用service，直接测试
12. //1.创建Configuration对象，该对象用于读取hibernate.cfg.xml，并完成初始化
13. //configure默认载入hibernate.cfg.xml文件，可以指定需要载入的xml
14. Configurationconfiguration=newConfiguration().configure();
15. //2.创建SessionFactory对象(这是一个会话工厂，是一个重量级的对象)
16. SessionFactorysessionFactory=configuration.buildSessionFactory();
17. //3.创建Session(用于与数据库的对话，相当于JDBC中的Connection)
18. Sessionsession=sessionFactory.openSession();
19. //4.对Hibernate而言，要求程序员，在进行增加、删除、修改的时候使用事务提交，否则不生效
20. Transactiontransaction=session.beginTransaction();
21. //添加一个雇员
22. Employeeemployee=newEmployee();
23. employee.setName("zs");
24. employee.setEmail("[e-mail]");
25. employee.setHiredate(newDate());
26. //保存
27. //--->insertinto...[被hibernate封装]
28. session.save(employee);
29. //提交
30. transaction.commit();
31. session.close();
32. }
33. }

补充内容

1、Hibernate依赖的其它库

Jar包	说明
CommonsCollections	Commons的集合类库
antlr	Java开源的语法分析生成器
dom4j	进行XML解析的类库
javassist	开源的分析、编辑和创建Java字节码的类库
slf4j-api	SimpleLoggingFacadeforJava，日志处理API
slf4j-simple	SLF4JAPI的实现，实现了简单日志处理
JTA	JavaTransactionAPI，Java中的事务处理API

PS：Hibernate框架是由许多技术组成的，比如解析XML的dom4j等等。

2、POJO(PlainOrdinaryJavaObjects简单的Java对象)

在使用hibernate时，要求和数据库的某张表相互映射的那个java类，是一个POJO类，一般放在com.xxx.domain包下,POJO类翻译过来就是:简单的Java对象（PlainOrdinaryJavaObjects）实际就是普通JavaBeans,使用POJO名称是为了避免和EJB混淆起来。一个POJO类应当具有:

1、有一个主键属性,用于唯一标识该对象。(这就是hibernate设计者建议要映射的表需要一个主键的原因)

2、有其它的属性

3、有对各个属性操作的get/set方法

4、属性一般是private修饰.

5、一定有一个无参的构造函数(用于hibernate框架反射用)

3、使用第一种方式实现Hibernate

第一种方式是先写Domain对象，再由mapping生成数据库中数据。

1、重新配置hibernate.cfg.xml文件

<?xmlversion="1.0"encoding="UTF-8"?>

1. <!DOCTYPEhibernate-configurationPUBLIC
2. "-//Hibernate/HibernateConfigurationDTD3.0//EN"
3. "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
4. <hibernate-configuration>
5. <!--配置oracle连接-->
6. <session-factory>
7. <!--常用配置可以参考hibernate集合包主目录projectetc、hibernate.properties文件-->
8. <!--配置driver-->
9. <!--name表示参数类型-->
10. <!--元素值表示参数内容-->
11. <propertyname="connection.driver_class">com.mysql.jdbc.Driver</property>
12. <!--配置url-->
13. <propertyname="connection.url">jdbc:mysql://127.0.0.1:3306/mydb1</property>
14. <!--配置用户名-->
15. <propertyname="connection.username">root</property>
16. <!--配置密码-->
17. <propertyname="connection.password">123456</property>
18. <!--配置显示hibernate生成的sql,特别说明，在开发阶段设为true利于调试，在使用项目则设为false-->
19. <propertyname="show_sql">true</property>
20. <!--配置dialect，明确的告知Hibernate连接的是哪种数据库-->
21. <propertyname="dialect">org.hibernate.dialect.MySQLDialect</property>
22. <!--让hibernate自动创建表-->
23. <!--create创建该表，如果有表，删除后再创建-->
24. <!--update如果没有表则创建新表，如果有表，表结构有没有变化，如果有变化，则创建新表-->
25. <propertyname="hbm2ddl.auto">update</property>
26. <!--指定管理的对象映射文件-->
27. <!--resource指定单个domain对象的配置文件-->
28. <mappingresource="com/pc/domain/Employee.hbm.xml"/>
29. </session-factory>
30. </hibernate-configuration>

2、对对象映射文件(Employee.hbm.xml)，做相应的修改

<idname="id"column="id"type="java.lang.Integer">

1. <!--该元素用户指定主键值生成策略-->
2. <!--class指生成策略类型-->
3. <!--hilonativeincrementsequenceuuid等-->
4. <generatorclass="increment"/>
5. </id>

PS：因为是从Oracle转到MySQL，所以Sequence不能使用了，这是就修改成increment。

对员工系统的优化

1、将SessionFactory做成工具类

因为SessionFactory是重量级类，故一个数据库最好只对应一个SessionFactory，这就要采用单例模式了。

packagecom.pc.util;

1. importorg.hibernate.SessionFactory;
2. importorg.hibernate.cfg.Configuration;
3. /**
4. *
5. *@authorSwitch
6. *@function实现SessionFactory单例化
7. *@description在使用Hibernate开发项目的时候，保证一个数据库只对应一个SessionFactory
8. *
9. */
10. publicclassMySessionFactory{
11. privatestaticSessionFactorysessionFactory=null;
12. //单例
13. privateMySessionFactory(){
14. }
15. static{
16. sessionFactory=newConfiguration().configure().buildSessionFactory();
17. }
18. publicstaticSessionFactorygetSessionFactory(){
19. returnsessionFactory;
20. }
21. }

2、将CRUD操作抽出成相应方法

原理上应该讲业务逻辑放在EmployeeService类中，但是这里为了方便就放在测试类中。

packagecom.pc.view;

 

1. importjava.util.Date;
2. importorg.hibernate.SessionFactory;
3. importorg.hibernate.Transaction;
4. importorg.hibernate.cfg.Configuration;
5. importorg.hibernate.classic.Session;
6. importcom.pc.domain.Employee;
7. importcom.pc.util.MySessionFactory;
8. publicclassTestMain{
9. publicstaticvoidmain(String[]args){
10. //使用hibernate完成crud操作(只见对象，不见表)
11. //不使用service，直接测试
12. addEmployee();
13. //updateEmployee();
14. //deleteEmployee();
15. }
16. //删除员工信息
17. publicstaticvoiddeleteEmployee(){
18. //获取一个会话
19. Sessionsession=MySessionFactory.getSessionFactory().openSession();
20. //创建一个事务
21. Transactiontransaction=null;
22. try{
23. transaction=session.beginTransaction();
24. //1.获取该雇员
25. Employeeemployee=(Employee)session.load(Employee.class,3);
26. //2.删除该雇员
27. session.delete(employee);
28. //提交
29. transaction.commit();
30. }catch(Exceptione){
31. //TODO:handleexception
32. if(transaction!=null){
33. transaction.rollback();
34. }
35. thrownewRuntimeException(e.getMessage());
36. }finally{
37. if(session!=null&&session.isOpen()){
38. session.close();
39. }
40. }
41. }
42. //修改员工信息
43. publicstaticvoidupdateEmployee(){
44. //获取一个会话
45. Sessionsession=MySessionFactory.getSessionFactory().openSession();
46. //创建事务对象
47. Transactiontransaction=null;
48. try{
49. transaction=session.beginTransaction();
50. //1.获取要修改的雇员
51. //load是通过主键属性，获取该对象实例(表的记录)
52. Employeeemployee=(Employee)session.load(Employee.class,2);
53. //2.修改该雇员
54. employee.setName("ls");
55. //提交
56. transaction.commit();
57. }catch(Exceptione){
58. //TODO:handleexception
59. if(transaction!=null){
60. transaction.rollback();
61. }
62. thrownewRuntimeException(e.getMessage());
63. }finally{
64. if(session!=null&&session.isOpen()){
65. session.close();
66. }
67. }
68. }
69. //添加员工
70. publicstaticvoidaddEmployee(){
71. //1.创建Configuration对象，该对象用于读取hibernate.cfg.xml，并完成初始化
72. //configure默认载入hibernate.cfg.xml文件，可以指定需要载入的xml
73. Configurationconfiguration=newConfiguration().configure();
74. //2.创建SessionFactory对象(这是一个会话工厂，是一个重量级的对象)
75. SessionFactorysessionFactory=configuration.buildSessionFactory();
76. //3.创建Session(用于与数据库的对话，相当于JDBC中的Connection)
77. Sessionsession=sessionFactory.openSession();
78. //4.对Hibernate而言，要求程序员，在进行增加、删除、修改的时候使用事务提交，否则不生效
79. Transactiontransaction=session.beginTransaction();
80. //添加一个雇员
81. Employeeemployee=newEmployee();
82. employee.setName("zs");
83. employee.setEmail("[e-mail]");
84. employee.setHiredate(newDate());
85. //保存
86. //--->insertinto...[被hibernate封装]
87. session.save(employee);
88. //提交
89. transaction.commit();
90. session.close();
91. }
92. }