Hibernate常见概念以及关键技术
hibernate简介
one to one
<one-to-one name = “propertyName” class=“className” cascade=“all|none|save-update|delete” constrained=“true|false” outer-join=“true|false|auto” />
改
当前会话期
获取session
Student s = session.load(Student.class, new long(“123”)); s.setName(“yinhongbinTest”); s.flush();
关闭session
不同会话期
获取session Student s = session.load(Student.class,new Long(“123”)); 关闭session s.setName(“yinhongbinTest”); 获取session session.update(s); 关闭session
id
<id name = “propertyName” tyep=“typeName” column=“columnName” unSaved-value=“any|none|null|id_value”> <generator class =“generatorClass”> /id>
property
Hibernate技术
Hibernate 技术Hibernate 是一个开放源代码的对象关系映射框架，它对JDBC 进行了非常轻量级的对象封装，把开发者从数据库编程中隔离开来,Java程序中所有进出数据库的操作都交给 Hibernate 来处理 ,它会为我们自动生成SQL 语句操作数据库 . 有了 Hibernate 后 ,程序员不再要写繁琐的SQL 语句 ,也不再要把实体对象一个个字段拆开又组装 .Hibernate 不仅负责从Java类到数据库表的映射（还包括从Java 数据类型到 SQL数据类型的映射），还提供了面向对象的数据查询检索机制，从而极大地缩短的手动处理 SQL 和 JDBC 上的开发时间。
一、 Hibernate 架构的概要图Hibernate 的核心接口一共有 5 个，分别为 :Session、 SessionFactory、Transaction、Query 和 Configuration 。
这 5 个核心接口在任何开发中都会用到。
通过这些接口，不仅可以对持久化对象进行存取，还能够进行事务控制。
下面对这五个核心接口分别加以介绍。
Session接口Session接口负责执行被持久化对象的CRUD 操作(CRUD 的任务是完成与数据库的交流，包含了很多常见的SQL 语句。
)。
但需要注意的是Session对象是非线程安全的。
同时，Hibernate 的session不同于JSP 应用中的HttpSession。
这里当使用session这个术语时，其实指的是 Hibernate 中的 session，而以后会将 HttpSesion 对象称为用户 session。
SessionFactory接口SessionFactory接口负责初始化Hibernate。
它充当数据存储源的代理，并负责创建Session对象。
这里用到了工厂模式。
需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个 SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个 SessionFactory。
Hibernate知识点
1 什么是HibernateHibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任2 Hibernate的核心类和接口：<1>Configuration负责管理Hibernate的配置信息，这些配置信息都是从配置文件hibernate.cfg.xml或者Hibernate.properties读取的，当然也可以自定义文件名称，只要在实例化Configuration的时候指定具体的路径就可以了<2>SessionFactoryConfiguration的实例会根据当前的配置信息，构造SessionFactory实例。
SessionFactory是线程安全的，一般情况下一个应用中一个数据库共享一个SessionFactory实例。
<3>Session一般的持久化方法（CRUD）都是通过Session来调用的，Session是非线程安全的<4>Transaction事务管理<5>Query查询的接口3 Hibernate的原理及步骤1. 读取并解析配置文件//采用默认的hibernate.cfg.xml来启动一个Configuration的实例例：Configuration configuration=new Configuration().configure();//如要修改默认配置文件名当然你可以选择不修改Configuration configuration=new Configuration().configure(new File("src/xxx.xml"));2. 读取并解析映射信息，创建SessionFactory例：SessionFactory sessionFactory =configuration.buildSessionFactory();3. 打开Session实例(它是线程不安全的，是共享同一个session，所以要ThreadLocal模式来控制)例：Session session = sessionFactory.openSession();4. 创建事务Transaction例：Transaction transaction = (Transaction)session.beginTransaction();5. CRUD操作(执行数据操作 CRUD 增删查改)例：增加session.save(pojo对象);增加或者修改session.saveOrOpdate(pojo对象)//当修改时候,id不存在将被抛出异常删除session.delete(pojo对象)//根据主键加载p1=(Person)session.load(pojo类.class, 主键值);6. 提交事务例：mit();7. 关闭Session实例及SessionFactory例： session.close();sessionFactory.close();4.Session的管理Session是Hibernate运作的中心，对象的生命周期、事务的管理、数据库的存取，都与 Session息息相关，就如同在编写JDBC时需关心Connection的管理，以有效的方法创建、利用与回收Connection，以减少资源的消耗，增加系统执行效能一样，有效的Session管理，也是Hibernate应用时需关注的焦点。
hibernate框架的工作原理
hibernate框架的工作原理Hibernate框架的工作原理Hibernate是一个开源的ORM(Object-Relational Mapping)框架，它将Java对象映射到关系型数据库中。
它提供了一种简单的方式来处理数据持久化，同时也提供了一些高级特性来优化性能和可维护性。
1. Hibernate框架的基本概念在开始讲解Hibernate框架的工作原理之前，需要先了解一些基本概念：Session：Session是Hibernate与数据库交互的核心接口，它代表了一个会话，可以用来执行各种数据库操作。
SessionFactory：SessionFactory是一个线程安全的对象，它用于创建Session对象。
通常情况下，应用程序只需要创建一个SessionFactory对象。
Transaction：Transaction是对数据库操作进行事务管理的接口。
在Hibernate中，所有对数据库的操作都应该在事务中进行。
Mapping文件：Mapping文件用于描述Java类与数据库表之间的映射关系。
它定义了Java类属性与数据库表字段之间的对应关系。
2. Hibernate框架的工作流程Hibernate框架主要分为两个部分：持久化层和业务逻辑层。
其中，持久化层负责将Java对象映射到数据库中，并提供数据访问接口；业务逻辑层则负责处理业务逻辑，并调用持久化层进行数据访问。
Hibernate框架的工作流程如下：2.1 创建SessionFactory对象在应用程序启动时，需要创建一个SessionFactory对象。
SessionFactory是一个线程安全的对象，通常情况下只需要创建一个即可。
2.2 创建Session对象在业务逻辑层需要进行数据访问时，需要先创建一个Session对象。
Session是Hibernate与数据库交互的核心接口，它代表了一个会话，可以用来执行各种数据库操作。
2.3 执行数据库操作在获取了Session对象之后，就可以执行各种数据库操作了。
hibernate原理
hibernate原理Hibernate是目前为止最流行的ORM（Object-Relational Mapping，面向对象关系映射）框架之一。
它是一个基于Java的开源框架，可以自动映射Java对象和关系型数据库的表格。
下面将为大家介绍Hibernate原理。
1. Hibernate的架构Hibernate的架构包含三层，分别是持久层、业务逻辑层和展示层。
其中，持久层是Hibernate的重点，它用于处理数据存储和检索。
在Hibernate中，持久层将Java类和关系型数据库之间建立一对一或一对多的映射关系，实现了Java类与数据库表的交互。
2. Hibernate的持久化过程Hibernate的持久化过程主要包括对象创建、连接数据库、执行SQL语句、提交事务和回滚事务等五个步骤。
具体流程如下：（1）对象创建：首先，创建一个Hibernate的SessionFactory对象，该对象是Hibernate的核心对象，用于创建会话；接着，获取一个会话（Session）对象，会话对象负责将Java对象和数据库之间建立映射关系。
（2）连接数据库：创建数据库连接的过程，Hibernate使用hibernate.cfg.xml文件配置数据库连接信息，包括数据库URL、数据库名称、用户名、密码等。
（3）执行SQL语句：Hibernate框架可以自动生成SQL语句，执行完SQL语句后，将结果存储到Java对象的属性中。
（4）提交事务：一旦操作完成，Hibernate会将所有未提交的事务进行提交，向数据库中写入数据。
（5）回滚事务：如果操作失败，Hibernate会将未提交的事务进行回滚，保证数据的完整性。
3. Hibernate的核心概念Hibernate中的核心概念包括持久类、映射文件、关联关系、事务、缓存等。
（1）持久类：持久化类是Java类，表示与数据库表相对应的实体类。
Hibernate会自动将该实体类与数据库表相映射。
Hibernet上手指南
核心提示：Hibernate，很久以前我就听说过这个名词，但是似乎没什么动力让我去接近它，感觉它是一个很复杂的东西，一直没搞明白它到底是用来做什么的。
Hibernate上手Hibernate，很久以前我就听说过这个名词，但是似乎没什么动力让我去接近它，感觉它是一个很复杂的东西，一直没搞明白它到底是用来做什么的。
直到接手了一个项目在技术选型的时候我再一次的看到了Hibernate。
我尝试着去使用它，发现它并不是我想像中的那么深奥，它很易用。
你并不需要了解它的内部结构，它一样能为你工作的很好，如果你理解了它到底能为你做什么的话本文着重讲述了为什么要使用Hibernate，此外也简单的介绍了如何使用Hibernate，以及Hibernate中的一些基本概念。
我想借这篇文章来向还没有接触过Hibernate的开发者推荐款优秀的开源ORM产品，如果你已经实践过Hibernate，那么我想你没有必要再看下去。
一、Why Hibernate？现在流行“测试驱动开发”，相似的我觉得“目的驱动学习”是一种比较好的接受新技术，新知识的途径。
在学习一样新的技术之前，首先得明确到底有没有必要学习，已有的技术是否已经工作的很好，学习这个新的技术是为了解决什么问题。
如果你明确了以上问题，那么寻找并学习新的技术将会事半功倍，并且能快速应用到实际的开发当中来提高效益。
要说Hibernate，就得先介绍一下Object/Relation Mapper（ORM），中文翻译为对象关系映射。
之所以会产生这样的概念是源于目前软件开发中的一些不协调的思想。
目前流行的编程模型是OOP（Object Oriented Programming），面向对象的编程，而目前流行的数据库模型是Relational Database，这两者思考的方式不一样，这必然产生了开发过程中的不协调。
ORM 框架（也称为持久层框架，）的出现就是为了解决这样的问题，屏蔽底层数据库的操作，以面向对象的方式提供给开发者操作数据库中数据的接口。
Hibernate知识点总结
Hibernate是目前最流行的开源对象关系映射(ORM)框架。
Hibernate采用低侵入式的设计，也即完全采用普通的Java对象（POJO），而不必继承Hibernate的某个基类，或实现Hibernate的某个接口。
Hibernate是面向对象的程序设计语言和关系数据库之间的桥梁，Hibernate允许程序开发者采用面向对象的方式来操作关系数据库。
因为我们知道hibernate它能支持透明持久化从这个角度来看它没有侵入性所谓侵入性它没有侵入hibernate任何的API所以它叫轻量级框架，轻量级框架的好处是没有侵入性另外的一个好处是为测试带来了好处，测试非常简单测试就行我们写普通的java应用程序一样不需要什么环境只需要几个jar包就可以了写个main函数一侧就可以了它没有侵入性和测试非常简单这是它流行的一个原因。
hibernate的优缺点优点：1、程序更加面向对象；2、提高了生产率；3、方便移植（修改配置文件）；4、无侵入性。
缺点：1、效率比JDBC略差；2、不适合批量操作。
3、只能配置一种关联关系Hibernate有四种查询方案1、get,load方法，根据id查找对象2、HQL--hibernate query language（查询对象：Query)3、Criteria--标准查询语言（查询对象：Criteria，查询条件：Criterion）4、通过sql来查（查询对象：SQLQuery）具体Query/Criteria:1.Query接口封装了Hibernate强大的对象查询能力，同时也支持数据库的更新操作2.提供了动态查询的参数绑定功能3.提供list(),iterator(),scroll()等对象导航方法4.提供uiqueResult()方法获取单独的对象5.提供executeUpdate()方法来执行DML语句6.提供了可移植的分页查询方法Session：1、save，presist保存数据，persist在事务外不会产生insert语句。
有关hibernate相关知识点
关于Hibernate一、什么是Hibernate？Hibernate是一个轻量级的ORMapping框架ORMapping原理（Object Relational Mapping）ORMapping基本对应规则：1：类跟表相对应2：类的属性跟表的字段相对应3：类的实例与表中具体的一条记录相对应4：一个类可以对应多个表，一个表也可以对应对个类5：DB中的表可以没有主键，但是Object中必须设置主键字段6：DB中表与表之间的关系（如：外键）映射成为Object之间的关系7：Object中属性的个数和名称可以和表中定义的字段个数和名称不一样ORMapping的基本实现方式：使用JDBC，用SQL来操作数据库，只是看动态生成还是人工写代码来实现。
大家想想，我们实现过ORMapping吗？二、Hibernate能干什么：Hibernate主要用来实现Java对象和表之间的映射，除此之外还提供还提供数据查询和获取数据的方法，可以大幅度减少开发时人工使用SQL和JDBC处理数据的时间。
Hibernate的目标是对于开发者通常的数据持久化相关的编程任务，解放其中的95%。
对于以数据为中心的程序来说,它们往往只在数据库中使用存储过程来实现商业逻辑,Hibernate 可能不是最好的解决方案;对于那些在基于Java的中间层应用中，它们实现面向对象的业务模型和商业逻辑的应用，Hibernate是最有用的。
Hibernate可以帮助你消除或者包装那些针对特定厂商的SQL代码，并且帮你把结果集从表格式的表示形式转换到一系列的对象去。
一个非常简要的Hibernate体系结构的高层概要图Hibernate运行时体系结构“最小”的体系结构方案，要求应用程序提供自己的JDBC 连接并管理自己的事务。
这种方案使用了Hibernate API 的最小子集.“全面解决”的体系结构方案，将应用层从底层的JDBC/JTA API中抽象出来，而让Hibernate 来处理这些细节。
Java框架Hibernate基础知识
Java框架Hibernate基础知识Hibernate是一款开源的Java ORM框架，它的基本功能是将Java 程序中的对象映射到数据库中的关系表，实现了Java对象和数据库表格之间的互相转换。
Hibernate的特点主要包括以下几个方面：1.高效的数据访问Hibernate使用缓存技术来提高数据库的访问效率，它可以通过缓存对象和结果来减少频繁的数据库查询，提高性能；同时，在数据库设计时，可以使用Hibernate内置的注解或XML文件映射数据表，大大减少了手动编写SQL语句的工作量。
2.简化的数据访问Hibernate可以把Java对象映射到和数据库表相似的对象，而不需要在编写复杂的SQL语句时独立处理每个Java属性；这使得Hibernate的使用更加简单，代码更加紧凑。
3.独立性Hibernate是一个独立的框架，不依赖于任何特定的技术或平台，可以与不同的数据库平台和不同的Java框架一起使用，为开发者提供了更大的灵活性。
以上是Hibernate的基本特点，接下来将介绍Hibernate的一些常见使用方法和技术。
1.Session管理在Hibernate中，Session是处理一级缓存的入口，也是与数据库交互的唯一途径。
Session可以通过SessionFactory来获取，而SessionFactory则可以通过Hibernate配置信息初始化。
2.映射文件在使用Hibernate时，需要将Java对象和数据库表之间建立映射关系。
Hibernate采用XML文件或注解方式来描述Java对象和数据库表之间的映射关系，其优点是抽象了数据库表的细节和差异，简化了代码开发。
3.HQL查询Hibernate中的HQL是Hibernate Query Language的缩写，是一种类似于SQL语法的查询语言，支持面向对象的查询和复杂查询。
使用HQL可以通过编写查询语句来获取所需的Java对象，而不需要手动创建数据库查询语句。
Hibernate(1)——基本概念
Hibernate(1)----基本概念一、JDBCJava程序要访问关系数据库需要通过JDBC (Java Database Connectivity：Java数据库连接器)驱动程序，进而使用SQL语言，JDBC驱动程序是连接Java程序和关系数据库的桥梁，通过它Java程序才能与关系数据库通信。
从MySQL的官方网站( )上就可以下载到MySQL的JDBC驱动程序类库，如“mysql-connector-java-5.0.8-bin.jar”。
通过JDBD API访问数据库：从图中可以看出，有了JDBC驱动程序，Java程序就只需和JDBC驱动程序的API交互了。
JDBC API使用的是面向对象的Java语言，它为Java程序提供了用于访问数据库的接口和类，主要包括:●DriverManager：代表驱动程序管理器，负责创建数据库连接。
●Connection：代表数据库连接。
●Statement：负责执行SQL语句。
●PreparedStatement：负责执行SQL语句，具有预定义SQL语句的功能。
●ResultSet：代表SQL查询语句的查询结果集。
通常，在Java程序中使用JDBC API的顺序为：(1) Class.forName("com.mysql.jdbc.Driver"); //加载MySQL驱动程序(2) Connection conn=DriverManager.getConnection(url, username, password); //连接数据库其中：String url = "jdbc:mysql://127.0.0.1:3306/数据库名";String username = "root";String password = "root";(3) Statement stmt=conn.createStatement(); //创建SQL语句对象(4) ResultSet rs = stmt.executeQuery("SQL语句"); //执行SQL语句(5) rs.close(); //关闭结果集对象(6) stmt.close(); //关闭语句对象(7) conn.close(); //关闭连接(1)、(2)两句与SQL2005的对比：SQL2005：(1)Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");(2)Connectionconn=DriverManager.getConnection("jdbc:sqlserver://127.0.0.1:1433;D atabaseName=数据库名", "用户名", "密码");一段典型的MySql的JDBC应用语句：private Connection conn;private Statement stmt;private ResultSet result;try{Class.forName("com.mysql.jdbc.Driver");conn=(Connection)DriverManager.getConnection("jdbc:mysql://127.0 .0.1:3306/airticket_db","root","root");} catch (SQLException e) {e.printStackTrace();} catch (ClassNotFoundException e) {e.printStackTrace();}List<Message> list = new ArrayList<Message>();message = new Message();stmt = (Statement) conn().createStatement();result = (ResultSet)stmt.executeQuery("select * from airticket"); while(result.next()){message.setNumber(result.getString(1));message.setStartEnd(result.getString(2));message.setStartTime(result.getString(3));message.setEndTime(result.getString(4));list.add(message) ;}if(this.conn!=null){this.conn.close();}return list ;在JDBD API中必须编写SQL语句，导致Java程序不是纯面向对象的。
Hibernate 知识点小结
Hibernate 知识点小结Hibernate一, Hibernate 介绍:Hibernate 只是一个将持久化类与数据库表相映射的工具，每个持久化类实例均对应于数据库表中的一个数据行而已。
用户只需直接使用面向对象的方法操作此持久化类实例，即可完成对数据库表数据的插入、删除、修改、读取等操作。
当然实际的Hibernate 框架非常复杂，用分层的概念划分的话，它相当于在业务逻辑处理层和数据库底层JDBC驱动之间的一层，即通常说的持久化层，而用户通过XML 配置文件将具体的持久化类与数据库表映射起来。
Hibernate 的实际过程还需依赖SQL 语言和JDBC 编程接口，但是Hibernate 将原本分散的JDBC 和SQL 配合产生的接口变成了对象化的接口，定义了自己的基于面向对象设计的HQL（Hibernate Query Language）查询语言，通过它生成实际的SQL 语句传递到数据库执行的。
1) ConfigurationConfiguration 类负责管理Hibernate 运行时需要获取一些底层实现的基本配置信息，如：数据库URL、数据库用户、数据库用户密码、数据库JDBC 驱动类、数据库适配器（dialect，用于对特定数据库支持）等。
Hibernate 的配置文件为hibernate.cfg.xml 或者hibernate.properties，缺省在CLASSPATH 路径下，可调用如下进行初始化：Configuration config = new Configuration().configure();2) SessionFactorySessionFactory 负责创建Session 实例，通过Configuation 实例创建它：SessionFactory sessionFactory =config.buildSessionFactory();如果需要访问多个数据库，要分别为其创建对应的SessionFactory 实例。
Hibernate技术
5、Hibernate和JDBC在性能上的对比
（1）用hibernate开发的系统能提高开发效率和系统的可 重用性等方面
因为任何封装在JDBC之上的东西都不可能有直接去写 JDBC快(不考虑cache)。
（2）提高了数据库访问性能
开发人员可以不再需要考虑与数据库交互的性能问题，如 连接池、数据缓存等等----因为Hibernate提供了对这些方面 的功能实现：数据读取和更新、事务管理、数据连接池、查询 和实体关系管理等。
（3）Hibernate使设计和开发人员达到下面的效果
对设计人员达到持久层设计上的解耦 对开发人员达到简化持久层的编程实现
这是一种比较合理的
（3）JDBC+Hibernate相互结合 设计!
所以我们应该在性能影响太大的地方采用面向对象和关系相 结合的方式
但在更多的地方仍然只能采用对象关联的方式。
我们家中购买了汽车后，也应该 还要保留我们原来的自行车!
6、如何为应用系统提供统一的一致的数据库访问操作 （1）JDBC技术：它是一套API而不是一个框架。
希望您能够明确这点!
（4）Hibernate的一些弱点
主要体现在比如对象关系的映射配置过多，控制复杂；事 务处理也面临各种兼容问题；
一个持久性类不能映射到多个表
Hibernat e内置映射 类型复杂 化
ID规定化生成：Hibernate中内置标识符生成器给表单ID自动
生成提供了方便，但却不能自定义各种ID形式。
（3）Hibernate与JDBC的主要区别（续）
Hibernate是一个和JDBC密切关联的框架，所以 Hibernate的兼容性和JDBC驱动，和数据库都有一定的关 系，但是和使用它的Java程序、应用服务器没有任何关系， 也不存在兼容性问题。
Hibernate的工作原理
Hibernate的工作原理Hibernate是一个流行的Java持久化框架，它的工作原理是通过对象关系映射（ORM）将Java对象映射到关系数据库中。
本文将详细介绍Hibernate的工作原理，包括其引言概述和正文内容。
正文内容分为五个部分，分别是：Hibernate的概述、SessionFactory的创建、Session的管理、持久化操作和查询、事务管理。
引言概述：Hibernate是一个开源的对象关系映射框架，它简化了Java应用程序与关系数据库之间的交互。
通过Hibernate，开发人员可以使用面向对象的方式进行数据库操作，而不必直接编写SQL语句。
Hibernate的工作原理是将Java对象映射到数据库表中，使得开发人员可以更加专注于业务逻辑的实现，而不必关心底层的数据库操作细节。
一、Hibernate的概述：1.1 Hibernate的核心组件：Hibernate由多个核心组件组成，包括SessionFactory、Session、Transaction等。
SessionFactory是Hibernate的核心接口，用于创建Session 对象。
Session是Hibernate与数据库交互的主要接口，开发人员通过Session进行数据的增删改查等操作。
Transaction用于管理事务的提交和回滚。
1.2 Hibernate的配置文件：Hibernate的配置文件是一个XML文件，用于配置Hibernate的各种属性和参数。
配置文件中包含数据库连接信息、映射文件的路径、缓存配置等。
通过配置文件，Hibernate可以正确地连接到数据库，并根据映射文件将Java对象映射到数据库表中。
1.3 Hibernate的映射文件：映射文件是Hibernate的另一个重要组成部分，它用于定义Java对象与数据库表之间的映射关系。
映射文件中包含了Java对象的属性与数据库表的字段之间的映射关系，以及对象之间的关联关系。
Hibernete基本概念
认识Hibernate一、Hibernate是一个优秀的持久化框架，了解持久化之前，先了解两种状态：1.瞬时状态：保存在内存中的程序数据，程序退出了，数据就消失了。
2.持久状态：保存在磁盘中的程序数据，程序退出了，数据依然存在。
持久化就是程序数据在瞬时状态和持久状态之间转换的一种机制。
二、hibernate是JDBC的轻量级封装，是一个独立的对象持久层框架；Hibernate可以用在任何JDBC可以使用的场合；Hibernate是一个和JDBC密切关联的框架，所以Hibernate的兼容性和JDBC驱动，和数据库都有一定的关系。
但是和使用它的Java程序，和App Server没有任何关系，也不存在兼容性问题；由于两者读取方式不一样，hibernate采用uuid.hex构造主键，性能稍慢与jdbc；特别是jdbc使用批处理的时候，显得jdbc更快，但是JVM(java虚拟机)内存也就要求大；总而言之，所有的ORM比如CMP、JDO、Hibernate都是对jdbc的封装，理论上讲ORM的性能不会高于jdbc，就像所有的高级语言性能不会高于汇编语言是一个道理。
所以，JDBC占着灵活效率高的优势，而hibernate占着易学易使用的优势。
那么hibernate与JDBC有什么区别呢：相同点：1.都是java数据库操作的中间件；2.两者对数据库对象的操作都不是线程安全的，都需要及时关闭；3.两者都可以对数据库的更新操作进行显式的事务处理；不同点：1.hibernate先检索缓存中的映射对象( 即hibernate操作的是对象)，而jdbc则是直接操作数据库，将数据直接通过SQl传送到数据库......(操作的对象不同)2.JDBC使用基于关系数据库的标准SQL(Structured Query Language)语言，hibernate使用HQL(Hibernate Query Language)语言....(使用的语言不同)3.Hibernate操作的数据是可持久化的，也就是持久化的对象属性的值，可以和数据库中保持一致，而jdbc操作数据的状态是瞬时的，变量的值无法和数据库中一致....(数据状态不同)三、ORM(Object Relational Mapping)对象关系映射完成对象数据到关系型数据映射的机制，称为：对象·关系映射，简ORM总结：Hibernate是一个优秀的对象关系映射机制，通过映射文件保存这种关系信息；在业务层以面向对象的方式编程，不需要考虑数据的保存形式。
hibernate基本原理
hibernate基本原理Hibernate是一个开源的关系数据库映射框架，主要用于将对象映射到数据库表上。
它可以将Java类与数据库表格之间进行转换，并提供对象关系映射（ORM）的支持，从而使得Java开发人员可以脱离SQL语句进行开发。
使用Hibernate可以大大降低开发人员在实现持久化存储时的工作量，使开发人员能够专注于业务逻辑的实现，提高开发效率。
1. Hibernate的基本概念在学习Hibernate的基本原理之前，需要先掌握一些用于描述Hibernate系统的基本概念。
这些概念包括：• Hibernate Session：在Hibernate中，所有的操作都必须经过Session来操作，即Session是Hibernate与数据库之间交流的一个管道。
Session对象是线程不安全的，一个线程应该只使用一个Session对象。
• Hibernate Transaction：事务是数据库操作的基本单元，所有数据库操作都应该在事务里面完成。
Hibernate 中的事务对象通过SessionFactory创建，使用完之后应该关闭。
• Hibernate Configuration：该对象封装了Hibernate的配置信息，如连接数据库的URL、数据库用户名、密码等。
• Hibernate SessionFactory：对于一个Hibernate 应用来说，SessionFactory是其运行的核心。
SessionFactory是一个线程安全的对象，用于创建Session，每个应用应该只有一个SessionFactory对象。
• Hibernate Mapping：Hibernate通过Java对象和数据库表格进行交互，其中的映射信息就是Hibernate Mapping。
• Hibern ate Query：Hibernate查询是面向对象的，它使用Hibernate QBC（Criteria）和HQL（Hibernate Query Language）两种方式来生成查询语句。
Hibernate常见概念以及关键技术
软件开发的分层思想:三层架构：数据表现层业务逻辑层数据持久层SUN的桌面应用Swing AWT 普通Java类JDBCSUN的WEB基本应用JSP 普通Servlet JDBCSUN的WEB高级应用JSF SessionBean PersistenceWEB国内流行开源Struts Spring Hibernate一、对象持久化的理论1.对象持久化：内存中的对象转存到外部持久设备上，在需要的时候还可以恢复。
2。
对象持久化的原因(目标)：// 是基础工作！是信息共享的主要原因物理：1) 内存不能持久，需要在硬盘上持久保存//（物理上，物理的都不是根本原因）2）内存容量有限，需要在容量更大的硬盘上保存应用：3）共享(Internet的本质：信息的收集、整理、发布）//最重要的原因4）检索(大规模）//也很重要5）管理(备份、安全）3。
怎样进行对象持久化？(仅从JA V A方面讲）物理：1) 对象序列化2）DB技术(JDBC 数据库）4。
怎样利用数据库做对象持久化？优点:功能完备、理论上效率高缺点：复杂（难)、代码量大、面向R（过程;二维表关系）2) EJB 仅讲Entity Bean优点：封装JDBC缺点:更复杂的API、重量级（侵入式)、功能不完备、难共享缺点的后果：开发周期长、测试困难、面向过程以上是2。
0之前的版本，但3。
0跟Hibernate基本一样3）ORM 轻量级框架（Hibernate）现阶段最佳的持久化工具：文档齐全、服务很好、工业标准、大量应用、易学优点：封装JBDC、简单的API、轻量级(只做持久化)(用类库)、PO（持久对象)-〉POJO（纯JA V A)、开源缺点：不够JDBC灵活5。
结论：1）对象持久化是必须的2)必须使用DB来实现3)Hibernate必须的（现阶段最佳选择)开源工具的通常问题：1.文档不全；2。
服务不全；3.标准化不够而Hibernate避免了所有这些问题二、ORM和Hibernate的相关知识（理解)1) ORM：Object Relational Mapping对象—关系映射实现了面向对象世界中对象到关系数据库中的表的自动的(和透明的）持久化，使用元数据（meta data）描述对象与数据库间的映射。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
软件开发的分层思想：三层架构：数据表现层业务逻辑层数据持久层SUN的桌面应用Swing AWT 普通Java类JDBCSUN的WEB基本应用JSP 普通Servlet JDBCSUN的WEB高级应用JSF SessionBean PersistenceWEB国内流行开源Struts Spring Hibernate一、对象持久化的理论1.对象持久化：内存中的对象转存到外部持久设备上，在需要的时候还可以恢复。
2.对象持久化的原因(目标)：// 是基础工作！是信息共享的主要原因物理：1) 内存不能持久，需要在硬盘上持久保存//(物理上，物理的都不是根本原因)2) 内存容量有限，需要在容量更大的硬盘上保存应用：3) 共享(Internet的本质：信息的收集、整理、发布) //最重要的原因4) 检索(大规模) //也很重要5) 管理(备份、安全)3.怎样进行对象持久化？(仅从JA V A方面讲)物理：1) 对象序列化2) DB技术(JDBC 数据库)4.怎样利用数据库做对象持久化？优点：功能完备、理论上效率高缺点：复杂(难)、代码量大、面向R(过程；二维表关系)2) EJB 仅讲Entity Bean优点：封装JDBC缺点：更复杂的API、重量级(侵入式)、功能不完备、难共享缺点的后果：开发周期长、测试困难、面向过程以上是2.0之前的版本，但3.0跟Hibernate基本一样3) ORM 轻量级框架(Hibernate)现阶段最佳的持久化工具：文档齐全、服务很好、工业标准、大量应用、易学优点：封装JBDC、简单的API、轻量级(只做持久化)(用类库)、PO(持久对象)->POJO(纯JA V A)、开源缺点：不够JDBC灵活5.结论：1)对象持久化是必须的2)必须使用DB来实现3)Hibernate必须的(现阶段最佳选择)开源工具的通常问题：1.文档不全；2.服务不全；3.标准化不够而Hibernate避免了所有这些问题二、ORM和Hibernate的相关知识(理解)1) ORM:Object Relational Mapping对象-关系映射实现了面向对象世界中对象到关系数据库中的表的自动的(和透明的)持久化，使用元数据(meta data)描述对象与数据库间的映射。
2) Hibernate是非常优秀、成熟的O/R Mapping框架。
它提供了强大的对象和关系数据库映射以及查询功能。
规范：1.一个映射文件对应一个持久类(一一对应)2.映射文件的名字和它所描述的持久类的名字保持一致3.映射文件应该与它所描述的类在同一包中po -> (pojo)-> oid(唯一，中性)-> getters/setters-> 构造方法三、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。
Transaction接口：是Hibernate的事务处理接口，它对底层的事务接口进行封装。
Query和Criteria接口：这两个是Hibernate的查询接口，用于向数据库查询对象，以及控制执行查询的过程。
Query实例包装了一个HQL查询语句。
Criteria接口完全封装了基于字符串形式的查询语句，比Query接口更面向对象。
Criteria更擅长于执行动态查询。
补充：find方法也提供数据查询功能，但只是执行一些简单的HQL查询语句的快捷方式(已过时)，远没有Query接口强大！四、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前查询对象是否被修改过，修改过才updatepolymorphism=“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"""><hibernate-mapping package=".entity"><!--package指文件所在的包名--><class name="Account" table="student"><!-- name:POJO类的名; table数据库里对应的表名--><id name="oid" column="OID"><!-- OID:(唯一，中性)表自动生成的(需要另外添加hilo表) --><generator class="hilo"><param name="table">t_hi</param><param name="column">hi</param></generator></id><property name="actNo" column="ACTNO" unique="true" not-null="true"/><property name="bal" column="BALANCE" not-null="true"/></class></hibernate-mapping>步骤四：Hibernate配置文件hibernate.cfg.xml或hibernate.properties1.需要配置那些信息：持久化映射，方言，特性，登陆信息多数使用默认的设置。
A、dialect：方言，就是拼驱动程序和SQL语句。
每种数据库对应一种方言。
其实就是指定了用那一种数据库。
Oracle数据库方言：org.hibernate.dialect.OracleDialectMySql数据库方言：org.hibernate.dialect.MySQLDialectB、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"""><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="ername">root</property><property name="connection.password">password</property><!-- 自动建表语句：create覆盖旧表，update自动更新，none不理会--> <property name="hbm2ddl.auto">update</property><!-- 是否在控制台上打印SQL(Hibernate把语句转化为SQL语句)，默认false--><property name="show_sql">true</property><!-- 缓存策略，数据量不大可不写--><propertyname="cache.provider_class">org.hibernate.cache.EhCacheProvider</property><property name="e_query_cache">false</property><property name="e_second_level_cache">false</property><!-- 不同数据库使用的SQL选择--><property name="dialect">org.hibernate.dialect.MySQLDialect</property><property name="myeclipse.connection.profile">mysql</property><!-- 连接池配置，练习时不写，使用默认的--><property name="connection.pool_size">1</property><!--决定是采用thread或jta或自定义的方式来产生session，练习时不写，使用默认的--><property name="current_session_context_class">thread</property><!-- *.hbm.xml文件路径，各关联表要一同写上--><mapping resource="many_to_one/vo/Customer.hbm.xml" /><mapping resource="com/tarena/ebank/biz/entity/Order.hbm.xml" /></session-factory></hibernate-configuration>步骤五：使用Hibernate API//读取Hibernate.cfg.xml配置文件，并读到内存中为后续操作作准备Configuration config = new Configuration().configure();//SessionFactory缓存了生成的SQL语句和Hibernate在运行时使用的映射元数据。