Hibernate学习笔记
Hibernate 笔记
1
/xiaolincc26/home CrazyCabbage
一 、第一个应用实例 1．搭建环境：新建一个名为 HibernateDemo 的 java 工程，并导入 Hibernate 的 jar 包， 特别要注意除了导入 lib 下的 jar 包还需导入 hibernate3.jar 核心 jar 包。 由于涉及数 据库操作，还应导入 mysql 驱动包。 说 明 ， 如 果 使 用 最 新 的 hibernate ， hibernate 开 发 的 基 本 jar 包 (7 个 ) 来 源 ：
return name; } public void setБайду номын сангаасame(String name) {
= name; } public Date getDate() {
return date; } public void setDate(Date date) {
this.date = date;
name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property
name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property> <property name="ername">root</property> <property name="hibernate.connection.password">123456</property>
private int id; private String name; private Date date;
public int getId() { return id;
} public void setId(int id) {
this.id = id; } public String getName() {
<id>子标签实际就是用来映射主键，<id>下的name就是用来指java类中的id属性，而 它可以有一个column属性用来指定表中的主键。同时注意在此标签下有一个 <generator class="native"/>标签，它是用来指定主键的生成方式。 <property>子标签，就是用来指定 java 类的属性映射到表中的一个字段，默认下此标 签没有指定 column 属性，即是说它会把 name 所关联的属性名作为字段名。 如果不想 java 类中的某些属性映射到表中，只要不用这个标签来关联这些属性即可。 总结：上面的<class><id><property>的 name 属性都分别指定了 java 类，java 类的 属性。而 table，column 是用来指定表，字段名 配置文件：hibernate.cfg.xml。它放在当前的项目的根目录下。内容如下： <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
<class name="User"> <id name="id"> <generator class="native"/> </id> <property name="name"></property> <property name="date"></property>
</class> </hibernate-mapping> 此配置文件，是用来为 User.java 进行配置的，我们以后称这种文件为实体配置文件（或 是持久化类映射文件） <class>用来关联一个 java 类，注意在前面的根元素下有一个 package 属性，这样结合这个 package 和 class 标签下所指定的类名，就共同关联映射了 一个 java 类。 其实可以这样理解，每一个包下都有实体配置文件，而这个配置文件开始 的根元素 package 指定了此文件所处的位置（或是说它所关联的包），根元素下可以有多 个<class>标签（查阅 dtd 文件），它们可以分别来关联包下的 java 类文件。 <class>标签，一般建议至少有两个属性：name 属性用来关联一个 java 类，比如这里关联 了 User 类；table 属性用来指定这个类所对应的表文件，如果不指定，系统会自动 name 指定的类文件进行关联（比如上面实际是：<class name="User" table="user">） <class>标签下的子标签：
public class UserTest { public static void main(String []args){ Configuration cf=new Configuration(); cf.configure(); SessionFactory sf=cf.buildSessionFactory();
import java.util.Date; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.cfg.Configuration; import er;
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.hbm2ddl.auto">create</property> <mapping resource="com/asm/hibernate/domain/User.hbm.xml"/> </session-factory> </hibernate-configuration> 主配置文件，完成了驱动注册，数据库连接，并关联了相应的java对象配置文件。 说明：<mapping>具体指定了关联的所有实体配置文件，关于它的作用可以注释掉此属 性看效果。另通过<property name="hibernate.hbm2ddl.auto">create</property>指定 了根据实体配置文件来自动生成表，其中包括：create/create-drop/update/validate四 种可选方式。 5．编写测试类：UserTest.java 内容如下： package com.asm.hibernate.test;
"-//Hibernate/Hibernate Mapping DTD 3.0//EN" "/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com.asm.hibernate.domain">
hibernate-distribution-3.3.2.GA.zip hibernate3.jar lib\required 下的所有 jar 包
2．简述 Hibernate 的作用：ORM：Object Relational Mapping，对象关系映射。将 java 程序中的对象自动持久化到关系数据库中。而 Hibernate 的作用好比就是在 java 对象与 关系数据库之间的一座桥梁，它主要负责两者之间的映射。在 Hibernate 内部封装了 JDBC 技术（但只是一个轻量级的封装，因而可以让程序设计人员更方便的以面向对象的思想操 纵数据库），并向外提供 API 接口。 3．建新一个名为 User.java 的类，即是上面所说的 java 对象。我们以后称这种类为实体 类（或是持久化类），它的对象为实体对象（或是持久化对象）。User.java 内容如下： package com.asm.hibernate.domain; import java.util.Date; public class User {
2
/xiaolincc26/home CrazyCabbage
} } 4．编写配置文件：User.hbm.xml。它和 User.java 放在同一个包下。内容如下： <?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC
3
/xiaolincc26/home CrazyCabbage
"/hibernate-configuration-3.0.dtd">
<hibernate-configuration> <session-factory name="foo"> <property
Session s=sf.openSession();
4
/xiaolincc26/home CrazyCabbage
Transaction ts=s.beginTransaction(); //事务
hibernate 学习笔记精要
使用hibernate编程，继承了面向对象编程的特点，使我们屏蔽了直接的拼sql语句对数据库表进行操作。
JDBC操作数据库很繁琐，sql语句编写并不是面向对象的，可以在对象和关系表间建立关联来简化编程，跨数据库平台，只需改写方言Dialect学习建立user library->hibernate，并加入相应的jar包：可以在项目右键build path->configure build path->add library选择user library，在其中新建library，命名为hibernate，加入所需的包（hibernate core、required、slf4j jar、log4j.jar）配置文件hibernate.cfg.xml一般放在src根目录下面，这样当读取这个配置文件时，就可以直接使用configuration.configure()方法,而不需设置这个配置文件所在路径所有的POJO最好都放到一个package下面，这样与之对应的映射文件*.hbm.xml也都放在了那下面在hibernate3以后开始支持annotation，目标是建立符合JPA标准的annotation，可以下载与hibernate版本对应的annotation包，引入三个jar包：hibernate-commons-annotations.jar，ejb3-persistence.jar，hibernate-annotations.jar。
new Configuration时，要使用AnnocationConfiguration使用注解时，如果想要当自己一键入@就给提示，content-assist的activation中加上@符号就可以了。
目前比较流行的ORM框架有hibernate，toplink，jdo，ibatis(“半自动化”的ORM实现，而非“一站式”)，jpa；jpa(意愿一统天下)slf是一个日志框架，针对不同的实现，我们只需引入相关的jar包，比如slf4j nop,log4j, jdk logging, commons-logging，这种方式很像JPA，JDBC我们可以常常看看project->etc下面的一些文件，主要是些配置文件，我们用的时候可以参考，比如log4j.properties注解有的是写给javac编译器看的，有的是写给java运行环境看的。
Hibernate学习笔记
Hibernate项目的构建与配置1.在项目里倒入Hibernate所必须的Jar包(1)Hibernate框架可以使用在任何的Java项目里，并不一定是Web项目。
只需要在项目里倒入Hibernate所必须要使用的jar包就可以了。
(2)在Hibernate的官网下载hibernate-release-4.2.2.Final.zip解压，要使用Hibernate必须导入的jar包就在目录“hibernate-release-4.2.2.Final\lib\required”下。
倒入此路径下的所有jar包就可以了。
2.配置hibernate.cfg.xml文件(1)配置hibernate.cfg.xml文件可以参考“\project\etc”目录下的hibernate.cfg.xml文件与hibernate.properties文件。
(2)使用Hibernate连接MySQL的hibernate.cfg.xml配置文件如下：<hibernate-configuration><session-factory>（设置显示Hibernate产生的SQL语句）<property name="show_sql">true</property>（设置MySQL的SQL语法的方言）<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>（设置MySQL的驱动程序）<property name="hibernate.connection.driver_class">org.gjt.mm.mysql.Driver</property>（设置MySQL的数据库路径、用户名、密码）<property name="hibernate.connection.url">jdbc:mysql:///java</property><property name="ername">root</property><property name="hibernate.connection.password">lizhiwei</property>（设置当数据库要保存的表不存在时，就新建表）<property name="hibernate.hbm2ddl.auto">update</property>（设置对象与数据库表的关系映射文件）<mapping resource="vo/User.hbm.xml"/></session-factory></hibernate-configuration>(3)此配置文件一般放在项目的src目录下。
Hibernate学笔记
Hibernate学习笔记Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。
支持各种主流数据库。
核心APIHibernate的API一共有6个，分别为:Session、SessionFactory、Transaction、Query、Criteria和Configuration。
通过这些接口，可以对持久化对象进行存取、事务控制。
SessionSession接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句)。
但需要注意的是Session对象是非线程安全的。
同时，Hibernate的session不同于JSP应用中的HttpSession。
这里当使用session这个术语时，其实指的是Hibernate中的session，而以后会将HttpSession对象称为用户session。
SessionFactorySessionFactory接口负责初始化Hibernate。
它充当数据存储源的代理，并负责创建Session对象。
这里用到了工厂模式。
需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。
TransactionTransaction 接口是一个可选的API，可以选择不使用这个接口，取而代之的是Hibernate 的设计者自己写的底层事务处理代码。
Hibernate笔记完整版
day1一. hibernate数据持久化组件对象持久化(Object Persistence):把数据保存在永久存储介质中（数据库）1.为什么要持久化:a.内存是暂时存储设备,断电后数据易丢失b.网络传输无法传输内存中的对象，需要将对象外化c.内存中数据查询,组织不方便d.内存只能存储少量数据2.怎样持久化a.对象序列化 --> 二进制流合并存储,粒度大,无规律不支持检索只适合少数个别对象的序列化b.用JDBC/EJB/ORM 将数据存入数据库用JDBC:(Java DB Connection)优点:底层开发,控制力强(细); 效率最高; 标准的(SQL)JDBC,有可移植性缺点:过于复杂; 代码量大; 可维护性差(代码重用性低);用EJB:(Entity Java Bean)优点:直接自动生成JDBC代码; 持久对象(PO)的状态由服务器管理; 声明式的事务缺点:功能不全(特殊的组件,不能做继承关系); EJB容器是侵入性容器,失去OO的优点; 调试更复杂用ORM:（object relation mapping）对象关系映射优点:自动生成JDBC(代码量下降); 使用(plain oldest java object---pojo),非侵入型; 提供状态管理; 难度下降,不需要容器缺点:由于开源, 文档少; bug多; 技术支持差结论: 用java开发-->必须将数据持久化-->用数据库持久化-->须用ORM-->需要用Hibernate二. Hibernate1.POJO类plain oldest java object,就是标准的Java Bean。
2.HibernateHibernate -->一个可以自动的根据xml完成对象关系映射，并持久化到数据库的开源组件。
其底层也是由JDBC实现的。
hibernate是通过xml文件的配置，对数据库的底层的方言，以及数据库连接所需的信息，以及连接数据库的驱动。
Hibernate学习笔记
主讲：刘涛(Robin)第一天：第一章Hibernate入门1、持久化：狭义：将数据持久地保存(将处于临时状态的数据持久的保存到文件或数据库中)；广义：对数据进行CRUD操作；employee(idnameagedeptidaddressid)2、ORM：将内存中的对象映射到关系型数据库中；面向对象的java 关系型数据库-----------------------------------类表属性字段(列)关系表OID PK注意：派生属性不需要映射派生属性，即可以由其他属性计算出来的属性3、公用持久化模板的要求：1）提供API供客户使用，执行CRUD操作；2）提供一种语言访问数据库（面向对象的）；如HQL：Hibernate Query Language 3）允许客户制定表和类之间的映射关系，一般写在xml中；4）提供一些优化机制，来提高性能，如：缓存、延迟加载等；4、什么是Hibernate?1）中间件，介于应用程序和数据库之间的软件；2）持久化工具，封装了和数据库访问的细节，可以让程序开发人员更加关注于业务逻辑的处理；3）ORM工具，将面向对象的java同关系型数据库进行映射，可以实现内存中的数据和数据库中数据的双向同步更新；5、Hibernate涉及的文件：1）pojo：封装数据；2）配置文件：hibernate.properties 或hibernate.cfg.xml，用来配置和数据库连接相关的信息；3）映射文件：xx.hbm.xml(hbm：hibernate mapping)，用来映射表和类之间的对应关系；4）hibernate API：1.核心接口：CRUD操作，事务处理等；2.回调接口：当特定时间触发时，回调客户端程序；3.类型：hibernate有自己定义的类型；4.可扩展接口：可以以hibernate为基础进行扩展；6、核心接口：1）org.hibernate.cfg.Configuration：1.对hibernate进行配置，根启动hibernate;2.创建SessionFactory;2）org.hibernate.SessionFactory: 1.重量级的(非常的占用资源)，不要频繁的创建，删除，一般一个数据库对应一个SessionFactory；2.线程安全的；3.缓存sql语句；如：student(idnameage)缓存的四条sql语句：select id,name,age from student where id=?delete from student where id=? update student set name=?,age=? where id=?insert into student values(?,?,?)4.维护着hibernate的二级缓存（可选的）；5.创建Session；3）org.hibernate.Session:1.轻量级的，可以频繁的创建和删除，一般一个事务中的操作对应一个Session;2.线程不安全的(多线程访问需要进行线程控制)；3.维护着hibernate的一级缓存（必用的）；4.可以执行CRUD操作；session.save(...);session.delete(...);session.update(...);session.get(...);session.load(...);4）org.hibernate.Transaction：hibernate中的事务控制，包括：jdbc 事务、JTA事务、CORBA事务；5）org.hibernate.Query：通过HQL执行查询操作； ---> "Hibernate Query Language" session.createQuery(String queryString)sql：select id,name,age from studenthql：from Student6）org.hibernate.Criteria：擅长于做动态查询7、Hibernate编程步骤：1）创建pojo类；2）创建配置文件（包含数据库连接的相关信息，以及连接的映射文件）；3）创建映射文件；4）调用hibernate的API；1.创建Configuration;2.创建SessionFactory;3.创建Session;4.启动事务，session.beginTransaction();5.执行CRUD操作；6.提交或回滚事务；mit()，transaction.rollback()create table xuxiang_student(id number(7) primary key,name varchar2(25),age number,gendar varchar2(10),address varchar2(50));添加Hibernate驱动：项目名--->右键--->Properties--->Java Build Path--->Libraries--->Add Library...--->MyEclipselibraries--->Hibernate 3.0 Core Librariessrc--com.briup.first--StudentTestDTD，XML，Schema第二章对象/关系映射基础1、映射文件：xx.hbm.xml在同一个映射文件中，可以映射多个pojo类，但建议只映射一个；2、常用标签介绍：1）<class>：用来映射表2）<id>：用来映射主键3）name：类中set/get方法后的名字4）column：表中的列名5）type： hibernate数据类型6）<generator>：用来制定主键的生成方式1. increment：由hibernate按照自增长方式产生唯一主键，注意在多线程访问时不要使用；对应的java类：org.hibernate.id.IncrementGenera tor2. identity：由支持identity的数据库产生主键；--org.hibernate.id.IdentityGener atorid number primary key identity 3. sequence：由数据库sequence来产生唯一主键；--org.hibernate.id.SequenceGener atorcreate sequence xuxiang_sequence start with 100;4. hilo：由数据库按高低值算法产生唯一主键（主键高值存在于表中）；--org.hibernate.id.TableHiLoGene rator算法：id=hi*(max_lo+1)+lo如下，则有：id=100*(100+1)+0=10100 create table xuxiang_hi(nextval number);insert into xuxiang_hivalues(100);commit;5. seqhilo：由数据库按高低值算法产生唯一主键（主键高值存在于sequence中）；--org.hibernate.id.SequenceHiLoG enerator6. assign：手动指定主键值；7）<property>：用来映射普通的列；8）<discriminator>：识别器，整个类层次映射成一张表时使用；9）<one-to-one>：用来映射一对一关系；10）<many-to-one>：用来映射多对一关系；11）<many-to-many>：用来映射多对多关系；12）<composite-id>：用来映射联合主键；positecreate table xuxiang_student2(id1 number,id2 number, name varchar2(25),age number,primary key(id1,id2));13）<component>：用来映射组合关系；ponent--User,Addresscreate table xuxiang_user(id number primary key,name varchar2(25),age number,city varchar2(20),street varchar2(50));14）<subclass>：用来映射子类；15）<formula>：计算表达式，映射派生属性时经常使用；User--Date bornDate3、作业：建一个表product，对其进行CRUD操作，要求主键由sequence生成，映射派生属性totalPrice;create table xuxiang_product(id number primary key,name varchar2(25),price number,count number);第二天：4、Hibernate中的类型：1）值类型：没有映射文件，不能直接映射到数据库中；基本数据类型，对象类型(如Address) 2）实体类型：有映射文件，可以直接映射到数据库中；第三章关联关系映射1、一对一映射：1）唯一外键关联；表上：table user table addressid<PK> idname city... ...addressid<FK>类上：class User class Addressid idname city... ...Address address User user对应的映射文件：User.hbm.xml<many-to-one name="address" class="Address"column="addressid"unique="true" />注意：由于<one-to-one>已被主键关联占用，为了与其区别，故引入了<many-to-one>!Address.hbm.xml<one-to-one name="user"class="User" />com.briup.third.one2one.fk create table xuxiang_address( id number primary key,city varchar2(20),street varchar2(50));create table xuxiang_user(id number primary key,name varchar2(25),age number,addressid number references xuxiang_address(id));2）主键关联；表上：table user table addressid<PK> id<PK,FK>name city... ...类上：class User class Addressid idname city ... ...Address address User user映射文件：User.hbm.xml<one-to-one name="address"class="Address" />Address.hbm.xml<one-to-one name="user"class="User" /><generator class="foreign"><paramname="property">user</param></generator>com.briup.third.one2one.pk create table xuxiang_user2(id number primary key,name varchar2(25),age number);create table xuxiang_address2( id number referencesxuxiang_user2(id),city varchar2(20),street varchar2(50),primary key(id));2、一对多映射：1）单向：只能在类上体现，表上是不能体现的，故单向和双向的表是完全相同的；表上：table user table addressid<PK> idname city... ...addressid<FK>类上：class User class Addressid idname city... ...Address address映射文件：User.hbm.xml<many-to-one name="address" class="Address"column="addressid" notnull=" true"/>Address.hbm.xml不需要作任何配置；com.briup.third.many2one.unidire ctcreate table xuxiang_address3( id number primary key,city varchar2(20),street varchar2(50));create table xuxiang_user3(id number primary key,name varchar2(25),age number,addressid number references xuxiang_address3(id));2）双向：表上：table user table addressid<PK> idname city... ...addressid<FK>类上：class User class Addressid idname city... ...Address address List users映射文件：User.hbm.xml<many-to-one name="address" class="Address"/>Address.hbm.xml<set name="users"><key column="addressid"/><one-to-many class="User"/></set>注意：cascade：设置级联sava-update：级联保存、更新delete：级联删除none：不级联，默认值all：级联保存、更新、删除inverse：在映射一对多关系时，一般将该属性设置为true，表示表间的关联关系由一方设置，减少update语句，提高性能。
Hibernate课堂笔记
Hibernate部分学习笔记讲师:梁建全liangjq@目录Hibernate部分学习笔记 (1)Day01 (5)一、Hibernate基本概念 (5)1、Hibernate是什么，有什么作用和好处 (5)2、Hibernate实现原理 (5)3、Hibernate框架主要结构 (5)二、Hibernate基本应用 (6)1、Hibernate使用步骤 (6)三、映射类型 (9)1、Hibernate映射类型主要有以下几种： (9)四、主键生成 (10)Day02 (11)一、Hibernate框架的基本特性 (11)1、Hibernate一级缓存 (11)A.一级缓存的特点 (11)B.一级缓存的好处 (11)C.使用建议 (11)2、Hibernate对象持久性 (13)3、Hibernate延迟加载 (14)A.针对于以下方法，Hibernate默认使用延迟加载机制： (14)B.Session的get和load方法区别： (14)C.延迟实现原理 (15)D.Hibernate框架如何动态生成一个代理类 (15)E.使用建议 (15)二、Hibernate综合练习 (15)前期案例：任务列表示例重构（采用Struts2+Hibernate） (15)A.Hibernate前期准备 (15)B.为了更好使用一级缓存，采用ThreadLocal封装Session (16)C.采用Hibernate重构ProjectDAO (17)D.为了支持延迟加载API，采用拦截器实现OpenSessionInView模式 (18)Day03 (20)一、什么是关联映射，有什么好处 (20)二、一对多关联映射 (20)示例：d_order和d_item存在一对多的业务关系 (20)一对多关系映射的实现步骤： (20)三、多对一关联映射 (21)多对一关系映射实现步骤： (21)四、关联操作 (22)1、关联查询 (22)2、利用lazy属性控制延迟加载 (22)3、级联操作（采用关系级联方式进行添加、删除、更新操作） (22)A.在关联属性映射部分添加cascade属性，可以指定以下属性 (22)B.Inverse属性的作用 (22)C.级联添加 (23)D.级联删除 (23)Day04 (24)一、如何使用Myeclipse生成映射文件和实体类? (24)1、如何根据DB生成实体类和映射文件 (24)A.利用Myeclipse追加Hibernate框架步骤: (24)B.利用Myeclipse根据表生成实体类和映射文件 (26)二、多对多关系映射 (29)三、继承关系映射 (30)1、继承关系映射（1） (30)A.首先将Book继承自Product类 (30)B.修改Book.hbm.xml描述信息 (30)2、继承关系映射(2)---理解 (31)Day05 (33)一、其他映射 (33)1、List集合映射 (33)2、formula子查询映射 (33)3、Component组件映射 (34)4、联合主键映射 (35)案例：采用联合主键映射+组件映射对t_person表进行操作。
Hibernate学习笔记4---Transient、Persistent、Detached三个状态
Transient、Persistent、Detached是Hibernate三个核心的状态：---------------------------------------------------------------------------Transient状态最大的特征是：* 在数据库中没有与之匹配的数据* 没有纳入session的管理Persistent状态最大的特征是：* 在数据库中有与之匹配的数据* 纳入了session的管理* 在清理缓存(脏数据检查)的时候，会和数据库同步Detached状态最大的特征是：* 在数据库中有与之匹配的数据* 没有纳入session的管理---------------------------------------------------------------------------如下面的两个图（中英文对照）以下是一段用于说明这三个状态的代码：package com.ahuzl.hibernate;import java.util.Date;import org.hibernate.Session;import org.hibernate.Transaction;import junit.framework.TestCase;public class SessionTest extends TestCase {public void testSession(){Session session = null;Transaction tx = null;User user = null;try {session = HibernateUtils.getSession();tx = session.beginTransaction();//Transient状态，临时状态，一经save就会转变到Persistent状态user = new User();user.setName("中田");user.setPassword("nakada");user.setCreateTime(new Date());user.setExpireTime(new Date());//Persistent状态，持久化状态(数据库中有相同的值与之对应)，当属性发生改变时，hibernate会自动与数据库同步，不需要updatesession.save(user);user.setName("幸島");mit();}catch (Exception e){e.printStackTrace();tx.rollback();}finally {HibernateUtils.closeSession(session);}//Detached状态，游离状态，session关闭之后，便由persistent状态变为Detached状态try{session = HibernateUtils.getSession();session.beginTransaction();user.setName("幸島");//在Detached状态下，更新对象的属性，需要update才能反映到数据库session.update(user);session.getTransaction().commit();}catch(Exception e){e.printStackTrace();session.getTransaction().rollback(); }finally{HibernateUtils.closeSession(session);}}}。
Hibernate笔记
Main.java
package com.it315.main; import java.util.Date; import org.hibernate.Session; import org.hibernate.Transaction; import er; import ls;
批注 [z3]: 连接数据库的 URL 地址。 批注 [z4]: 用户名。 批注 [z5]: 密码。 批注 [z6]: 每次加载 hibernate，重 新创建数据库表结构， 这就是导致数 据库表数据丢失的原因。 批注 [z7]: 显示生成的 SQL 语句。 批注 [z8]: 指定映射文件的路径。 批注 [z2]: 数据库驱动的名称。 批注 [z1]: 数据库的方言。
注意：初始化的代码是很耗资源的，所以将上面代码修改为：
HibernateUtils.java package com.it315.util; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; public final class HibernateUtils { private static SessionFactory sessionFactory; static { Configuration cfg = new Configuration(); sessionFactory = cfg.configure().buildSessionFactory(); } public static Session getSession(){ return sessionFactory.openSession(); } }
Hibernate学习笔记
Hibernate 复习笔记一、第一个应用实例1．搭建环境：新建一个名为HibernateDemo的java工程，并导入Hibernate的jar包，特别要注意除了导入lib下的jar包还需导入hibernate3.jar核心jar包。
由于涉及数据库操作，还应导入mysql驱动包。
说明，如果使用最新的hibernate，hibernate开发的基本jar包(7个) 来源：hibernate-distribution-3.3.2.GA.ziphibernate3.jarlib\required下的所有jar包2．简述Hibernate的作用：ORM：Object Relational Mapping，对象关系映射。
将java 程序中的对象自动持久化到关系数据库中。
而Hibernate的作用好比就是在java对象与关系数据库之间的一座桥梁，它主要负责两者之间的映射。
在Hibernate内部封装了JDBC 技术（但只是一个轻量级的封装，因而可以让程序设计人员更方便的以面向对象的思想操纵数据库），并向外提供API接口。
3．建新一个名为User.java的类，即是上面所说的java对象。
我们以后称这种类为实体类（或是持久化类），它的对象为实体对象（或是持久化对象）。
User.java内容如下：package com.asm.hibernate.domain;import java.util.Date;public class User {private int id;private String name;private Date date;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public Date getDate() {return date;}public void setDate(Date date) {this.date = date;}}4．编写配置文件：User.hbm.xml。
Hibernate学习笔记
Hibernate的名字的意义
将JDBC冷冻起来，hibernate的本身的意思是“冬眠”，意思就是让开发者对于JDBC的使用“冻结”起来，其实就是一个封装的概念，Hibernate其实就是对JDBC操作的一个封装
我们把Hibernate叫做一个持久层框架，就是因为hibernate专注于数据库的持久化实现
类和属性的名称不能随意修改，包括大小写，必须严格对应
关于表名和字段名不区分大小写
关于映射后的查询语句
在SQL语句中，你查询可以这样：
select ename,job,sal from emp
select * from emp
这里的*可以代表所有字段
注意，在hibernate中：
OR如何来映射？
1.必须借助于DB Driver连接描述，实际上一个hiberante工具
选择Database explorer，切换到DB Browser视图,新建一个DB Driver，名称可以任意起
2.使用Hibernate映射工具，开始R----O的转换
转换的时候你可以根据自己的需要来选择产生的类
3.Hibernate的连接工厂类HibernateSessionFactory，这个类中默认包含了如何连接数据库并获取数据库连接的代码，以及如何关闭数据库的代码
下一步，如何来操作数据库，比如查询
且慢，hiberante是基于ORM的实现
也就是，hiberante将数据库的表映射成了java类，所以你要对数据库的表来操作，需要先进行类的转换
//关闭数据库连接
HibernateSessionFactory.closeSession();
}