ch11-Hibernate框架
跟我学Hibernate框架技术——Hibernate核心API及应用示例
(3)Session看作介于数据连接与事务管理一种中间接口 我们可以将session想象成一个持久对象的缓冲区, Hibernate能检测到这些持久对象的改变,并及时刷新 数据库。
(4)每一个Session实例和一个数据库事务绑定 通常将每一个Session实例和一个数据库事务绑定, 也就是说,每执行一个数据库事务(操作),都应该先 创建一个新的Session实例。
6、核心API介绍---Transaction接口 (1)Transaction接口是一个可选的API 事务将应用代码从下层的事务实现中抽象出来——这 可能是一个JDBC事务,一个JTA用户事务等 这样将允许应用通过一组一致的API控制事务边界。 (2)定义
注意:该接口有多个不同的事务的实现类
5、Session的编程规则 (1)需要随时更新和释放 注意应该要session.close()语句放在finally语句块中。 (2)Sessin 接口中针对单条记录的基本的CURD操作方法 save()方法:把Java对象保存数据库中 update()方法:更新数据库中的Java对象
delete()方法:把Java对象从数据库中删除 load()方法:从数据库中加载PO对象,但它应用了“懒查询” find()方法:从数据库中查询Java对象 get()方法:在Hibernate 3.0以上版中新增加的查询方法, 可以直接获得查询结果 (3)代码示例
2、三种状态相互转换的说明
3、核心API介绍--- Session接口
(1)它是轻量级的类 在Hibernate中,实例化的Session是一个轻量级的类, 创建和销毁它都不会占用很多资源。 这在实际项目中确实很重要,因为在客户程序中,可 能会不断地创建以及销毁Session对象,如果Session 的开销太大,会给系统带来不良影响。 (2)但它是非线程安 全的 由于Session对象是 非线程安全的,因 此最好是一个线程 只创建一个Session 对象(将它设计为 局部对象)。
Hibernate教程---看这一篇就够了
Hibernate教程---看这⼀篇就够了1 Hibernate概述1.1什么是hibernate框架(重点)1 hibernate框架应⽤在javaee三层结构中 dao层框架2 在dao层⾥⾯做对数据库crud操作,使⽤hibernate实现crud操作,hibernate底层代码就是jdbc,hibernate对jdbc进⾏封装,使⽤hibernate好处,不需要写复杂jdbc代码了,不需要写sql语句实现3 hibernate开源的轻量级的框架4 hibernate版本Hibernate3.xHibernate4.xHibernate5.x(学习)1.2 什么是orm思想(重点)1 hibernate使⽤orm思想对数据库进⾏crud操作2 在web阶段学习 javabean,更正确的叫法实体类3 orm:object relational mapping,对象关系映射⽂字描述:(1)让实体类和数据库表进⾏⼀⼀对应关系让实体类⾸先和数据库表对应让实体类属性和表⾥⾯字段对应(2)不需要直接操作数据库表,⽽操作表对应实体类对象画图描述2 Hibernate⼊门2.1 搭建hibernate环境(重点)第⼀步导⼊hibernate的jar包因为使⽤hibernate时候,有⽇志信息输出,hibernate本⾝没有⽇志输出的jar包,导⼊其他⽇志的jar包不要忘记还有mysql驱动的jar包第⼆步创建实体类package cn.itcast.entity;public class User {/*hibernate要求实体类有⼀个属性唯⼀的*/// private int uid;private String uid;private String username;private String password;private String address;// public int getUid() {// return uid;// }// public void setUid(int uid) {// this.uid = uid;// }public String getUsername() {return username;}public String getUid() {return uid;}public void setUid(String uid) {this.uid = uid;}public void setUsername(String username) {ername = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}}(1)使⽤hibernate时候,不需要⾃⼰⼿动创建表,hibernate帮把表创建第三步配置实体类和数据库表⼀⼀对应关系(映射关系)使⽤配置⽂件实现映射关系(1)创建xml格式的配置⽂件- 映射配置⽂件名称和位置没有固定要求- 建议:在实体类所在包⾥⾯创建,实体类名称.hbm.xml(2)配置是是xml格式,在配置⽂件中⾸先引⼊xml约束- 学过约束dtd、schema,在hibernate⾥⾯引⼊的约束dtd约束(3)配置映射关系<hibernate-mapping><!-- 1 配置类和表对应class标签name属性:实体类全路径table属性:数据库表名称--><class name="er" table="t_user"><!-- 2 配置实体类id和表id对应hibernate要求实体类有⼀个属性唯⼀值hibernate要求表有字段作为唯⼀值--><!-- id标签name属性:实体类⾥⾯id属性名称column属性:⽣成的表字段名称--><id name="uid" column="uid"><!-- 设置数据库表id增长策略native:⽣成表id值就是主键⾃动增长--><generator class="native"></generator></id><!-- 配置其他属性和表字段对应name属性:实体类属性名称column属性:⽣成表字段名称--><property name="username" column="username"></property><property name="password" column="password"></property><property name="address" column="address"></property></class></hibernate-mapping>第四步创建hibernate的核⼼配置⽂件(1)核⼼配置⽂件格式xml,但是核⼼配置⽂件名称和位置固定的- 位置:必须src下⾯- 名称:必须hibernate.cfg.xml(2)引⼊dtd约束(3)hibernate操作过程中,只会加载核⼼配置⽂件,其他配置⽂件不会加载第⼀部分:配置数据库信息必须的第⼆部分:配置hibernate信息可选的第三部分:把映射⽂件放到核⼼配置⽂件中<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><!-- 第⼀部分:配置数据库信息必须的 --><property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql:///hibernate_day01</property> <property name="ername">root</property><property name="hibernate.connection.password">root</property><!-- 第⼆部分:配置hibernate信息可选的--><!-- 输出底层sql语句 --><property name="hibernate.show_sql">true</property><!-- 输出底层sql语句格式 --><property name="hibernate.format_sql">true</property><!-- hibernate帮创建表,需要配置之后update: 如果已经有表,更新,如果没有,创建--><property name="hibernate.hbm2ddl.auto">update</property><!-- 配置数据库⽅⾔在mysql⾥⾯实现分页关键字 limit,只能使⽤mysql⾥⾯在oracle数据库,实现分页rownum让hibernate框架识别不同数据库的⾃⼰特有的语句--><property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property><!-- 第三部分:把映射⽂件放到核⼼配置⽂件中必须的--><mapping resource="cn/itcast/entity/User.hbm.xml"/></session-factory></hibernate-configuration>2.2 实现添加操作第⼀步加载hibernate核⼼配置⽂件第⼆步创建SessionFactory对象第三步使⽤SessionFactory创建session对象第四步开启事务第五步写具体逻辑 crud操作第六步提交事务第七步关闭资源@Testpublic void testAdd() {// 第⼀步加载hibernate核⼼配置⽂件// 到src下⾯找到名称是hibernate.cfg.xml//在hibernate⾥⾯封装对象Configuration cfg = new Configuration();cfg.configure();// 第⼆步创建SessionFactory对象//读取hibernate核⼼配置⽂件内容,创建sessionFactory//在过程中,根据映射关系,在配置数据库⾥⾯把表创建SessionFactory sessionFactory = cfg.buildSessionFactory(); // 第三步使⽤SessionFactory创建session对象// 类似于连接Session session = sessionFactory.openSession();// 第四步开启事务Transaction tx = session.beginTransaction();// 第五步写具体逻辑 crud操作//添加功能User user = new User();user.setUsername("⼩王");user.setPassword("250");user.setAddress("⽇本");//调⽤session的⽅法实现添加session.save(user);// 第六步提交事务mit();// 第七步关闭资源session.close();sessionFactory.close();}3 内容⽬录1 实体类编写规则2 hibernate主键⽣成策略(1)native(2)uuid3 实体类操作(1)crud操作(2)实体类对象状态4 hibernate的⼀级缓存5 hibernate的事务操作(1)事务代码规范写法6 hibernate其他的api(查询)(1)Query(2)Criteria(3)SQLQuery3.1 实体类编写规则1 实体类⾥⾯属性私有的2 私有属性使⽤公开的set和get⽅法操作3 要求实体类有属性作为唯⼀值(⼀般使⽤id值)4 实体类属性建议不使⽤基本数据类型,使⽤基本数据类型对应的包装类(1)⼋个基本数据类型对应的包装类- int – Integer- char—Character、- 其他的都是⾸字母⼤写⽐如 double – Double(2)⽐如表⽰学⽣的分数,假如 int score;- ⽐如学⽣得了0分,int score = 0;- 如果表⽰学⽣没有参加考试,int score = 0;不能准确表⽰学⽣是否参加考试l 解决:使⽤包装类可以了, Integer score = 0,表⽰学⽣得了0分,表⽰学⽣没有参加考试,Integer score = null;3.2 Hibernate主键⽣成策略1 hibernate要求实体类⾥⾯有⼀个属性作为唯⼀值,对应表主键,主键可以不同⽣成策略2 hibernate主键⽣成策略有很多的值3 在class属性⾥⾯有很多值(1)native:根据使⽤的数据库帮选择哪个值(2)uuid:之前web阶段写代码⽣成uuid值,hibernate帮我们⽣成uuid值3.3 实体类操作对实体类crud操作添加操作1 调⽤session⾥⾯的save⽅法实现根据id查询1 调⽤session⾥⾯的get⽅法实现修改操作1 ⾸先查询,修改值(1)根据id查询,返回对象删除操作1 调⽤session⾥⾯delete⽅法实现3.4 实体类对象状态(概念)1 实体类状态有三种(1)瞬时态:对象⾥⾯没有id值,对象与session没有关联(2)持久态:对象⾥⾯有id值,对象与session关联(3)托管态:对象有id值,对象与session没有关联2 演⽰操作实体类对象的⽅法(1)saveOrUpdate⽅法:实现添加、实现修改3.5 Hibernate的⼀级缓存什么是缓存1 数据存到数据库⾥⾯,数据库本⾝是⽂件系统,使⽤流⽅式操作⽂件效率不是很⾼。
Hibernate 框架
Page 10
10
使用Hibernate实现用户添加
public static void main(String[] args) { Configuration conf = new Configuration().configure();//1、读取配置文件 SessionFactory sf = conf.buildSessionFactory();// 2、创建SessionFactory Session session = sf.openSession();// 3、打开Session Transaction tx = null; try{ tx = session.beginTransaction();// 4、开始一个事务 // 5、持久化操作 User user = new User(); user.setUname("Hibernate user"); user.setUpass("password"); session.save(user); mit();// 6、 提交事务 }catch(Exception e){ if (null!=tx){tx.rollback();} e.printStackTrace(); }finally{ session.close();// 7、关闭Session } } 11
2
Page 2
Hibernate是一个优秀的持久化框架
什么是持久化?
瞬时状态: 保存在内存的程序数据,程序 退出后,数据就消失了,称为 瞬时状态 持久化: 将程序数据在瞬时状态和持久 状态之间转换的机制
持久状态: 保存在磁盘上的程序数据,程 序退出后依然存在,称为程序 数据的持久状态
Page 3
跟我学Hibernate框架技术——Hibernate框架技术基础
目录1.1 跟我学Hibernate框架技术——Hibernate框架技术基础 (2)1.1.1 O/R Mapping工具----Hibernate技术基础 (2)1.1.2 Hibernate和JDBC在性能上的对比 (9)1.1.3 Hibernate系统介绍 (12)1.1.4 Hibernate系统的应用环境 (18)1.1.5 Hibernate为什么如此成功 (20)1.1跟我学Hibernate框架技术——Hibernate框架技术基础1.1.1O/R Mapping工具----Hibernate技术基础1、Hibernate基本概念(1)Hibernate技术本质上是一个提供数据库服务的中间件●Hibernate 是一个面向Java 环境的对象/ 关系数据库映射工具,把Java类对应到数据库的table中,并且采用了xml技术、Java Reflection技术等。
●Hibernate技术本质上也是遵守的ODMG标准的,它的出色源于不断的升级、不断的维护、修改。
以及完善的文档、人气很旺的论坛。
还有很重要的一点就是它的易学易用性。
●Hibernate它不仅提供了从Java类到数据表的映射,也提供了数据查询和恢复等机制。
可以大幅度减少开发时人工使用SQL 和JDBC 处理数据的时间。
(2)Hibernate是一个开放源代码的对象关系映射框架●以OO的方式来操纵数据库它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
●Hibernate可以应用在任何使用JDBC的场合Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序实用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的J2EE架构中取代CMP,完成数据持久化的重任。
try{stmt=con.createStatement();rs=stmt.executeQuery("select * from student");metaData = rs.getMetaData();for(int column = 0; column < metaData.getColumnCount(); column++){System.out.print(metaData.getColumnName(column+1)+"\t");}while(rs.next()){for (int i = 1; i <= metaData.getColumnCount(); i++){System.out.print(rs.getObject(i)+"\t");}System.out.println("");}stmt.close(); //must closecon.close();}catch(SQLException e){}(3)主要的特点及与Entity EJB Bean的不同点Hibernate是JDBC的轻量级的对象封装它是一个独立的对象持久层框架,和应用服务器以及和EJB没有什么必然的联系。
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)框架,它可以
将Java对象映射到关系数据库中的表中,从而使得开发人员可以使用Java编程语言来访问和操作数据库。
Hibernate的使用流程如下:
1. 在Java类中定义实体对象及其属性和关系;
2. 在Hibernate中配置映射文件,将实体类映射为数据库表;
3. 通过Session API实现数据的增删改查操作。
Hibernate框架的优点有:
1. 开发效率高:Hibernate自动处理对象与数据库表之间的映射,使得开发人员可以将精力集中在业务逻辑上。
2. 数据库平台无关性好:Hibernate提供了一套底层数据库操作
接口,在数据操作层面上实现了面向对象与关系数据库的交互。
3. 透明性强:Hibernate框架屏蔽了大部分JDBC的细节,对于开发人员而言可以专注于业务需求的实现。
4. 高性能:Hibernate框架缓存机制、懒加载等一些优化措施,
可以改善数据库访问的性能。
同时,Hibernate还提供了一些高级特性,如事务管理、二级缓存、查询缓存、延迟加载等,可以更好地满足复杂应用的需要。
Java框架之Hibernate部分
Hibernate部分1.为什么要使用Hibernate开发你的项目呢?Hibernate的开发流程是怎么样的?为什么要使用①.对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码。
②.Hibernate 是一个基于JDBC的主流持久化框架,是一个优秀的ORM 实现。
他很大程度的简化DAO层的编码工作③.hibernate 的性能非常好,因为它是个轻量级框架。
映射的灵活性很出色。
它支持各种关系数据库,从一对一到多对多的各种复杂关系。
开发流程2.什么是延迟加载?延迟加载机制是为了避免一些无谓的性能开销而提出来的,所谓延迟加载就是当在真正需要数据的时候,才真正执行数据加载操作。
在Hibernate中提供了对实体对象的延迟加载以及对集合的延迟加载,另外在Hibernate3中还提供了对属性的延迟加载。
3.说一下hibernate的缓存机制A:hibernate一级缓存(1)hibernate支持两个级别的缓存,默认只支持一级缓存;(2)每个Session内部自带一个一级缓存;(3)某个Session被关闭时,其对应的一级缓存自动清除;B:hibernate二级缓存(1) 二级缓存独立于session,默认不开启;4.Hibernate的查询方式有哪些?本地SQL查询、Criteria、Hql5.如何优化Hibernate?1.使用双向一对多关联,不使用单向一对多2.灵活使用单向一对多关联3.不用一对一,用多对一取代4.配置对象缓存,不使用集合缓存5.一对多集合使用Bag,多对多集合使用Set6. 继承类使用显式多态7. 表字段要少,表关联不要怕多,有二级缓存撑腰6.Hibernate中GET和LOAD的区别?请注意如果没有匹配的数据库记录,load()方法可能抛出无法恢复的异常(unrecoverable exception)。
如果类的映射使用了代理(proxy),load()方法会返回一个未初始化的代理,直到你调用该代理的某方法时才会去访问数据库。
hibernate
hibernate hibernatehibernate是什么?1.hibernate是一个框架(framework)2.hibernate是一个orm框架[]orm(objectrelationmapping)对象关系映射框架oobject->业务层(只对对象操作)rrelation->关系数据库mmapping对象关系映射文件3.hibernate处于我们项目的持久层位置(正因为如此,所以有人又把hibernate称为持久层框架)4.hibernate实际上就是对jdbc进行了轻量级的封装.5.hibernate的基础还是我们java反射机制把对象持久化:把对象的信息保存到数据库或者是文件.总结:hibernate是对jdbc进行轻量级封装的orm框架,充当项目的持久层.为什么需要hibernate?快如入门案例:hiberante可以用在j2se项目,也可以用在j2ee(web项目中)struts是web框架,所以用在web项目我们使用手动配置hibernate方式开发一个hibernate项目,完成crud操作。
开发流程1.创建一个项目2.画出一个简单项目框架示意图3.引入hibernate开发包(从网上下载googlehibernate),完后我们4.开发hibernate有三种方法(开发顺序)我们使用第二种开发项目创建employe表.createtableemployee(idnumberprimarykey,namevarchar2(64)notnull, emailvarchar2(64)notnull, hiredatedatenotnull)创建一个序列,将来用于主键的自增长: --创建一个序列createsequenceemp_seq startwith1incrementby1minvalue1nomaxvaluenocyclenocache5.开发domain对象和对象关系映射文件对象关系映射文件:作用是用于指定domain对象和表的映射关系.,该文件的取名有规范:domain对象.hbm.xml,一般我们放在和domain对象同一个文件夹下(包下)我们的Employee.hbml.xml配置文件:br>"-//Hibernate/HibernateMappingDTD3.0//EN""/hibernate-mapping-3.0.dtd">emp_seq6.手动配置我们的hibernate.cfg.xml文件,该文件用于配置连接的数据库的类型,driver,,用户名,密码,url....同时管理对象关系映射文件,该文件的名称,我们一般不修改.hibernate.cfg.xml配置文件br>"-//Hibernate/HibernateConfigurationDTD3.0//EN""/hibernate-configuration-3.0.dtd">oracle.jdbc.driver.OracleDriverscotttigerjdbc:oracle:thin:@127.0.0.1:1521:orclhsp org.hibernate.dialect.OracleDialect true7.测试文件TestMain.java packagecom.hsp.view;importcom.hsp.util.; importjava.util.Date;importorg.hibernate.Session; importorg.hibernate.SessionFactory; importorg.hibernate.Transaction;importorg.hibernate.cfg.;importcom.hsp.domain.Employee; publicclassTestMain{/@paramargspublicstaticvoidmain(String[]args){//查询[load]->hql语句(hibernatequerylanguage)}publicstaticvoiddelEmp(){//删除//获取一个sessionSessionsession=MySessionFactory.getSessionFactory().open Session();Transactionts=session.beginTransaction();//删除1.先获取该雇员,然后删除Employeeemp=(Employee)session.load(Employee.class,3); session.delete(emp);mit();session.close();}publicstaticvoidupdateEmp(){//TODOAuto-generatedmethodstub//修改用户//获取一个会话Sessionsession=MySessionFactory.getSessionFactory().openSession();Transactionts=session.beginTransaction();//修改用户1.获取要修改的用户,2.修改//load是通过主键属性,获取该对象实例.表的记录对应Employeeemp=(Employee)session.load(Employee.class,3);emp.setName("韩顺平8");//update...emp.setEmail("************");mit();session.close();} publicstaticvoidaddEmployee(){//我们使用hibernate完成crud操作[这里我们只见对象,不见表]//现在我们不是用service,直接测试.//1。
【Hibernate】Hibernate框架配置详解
【Hibernate】Hibernate框架配置详解通过Hibernate我们可以⽅便地操作数据库读取出来的信息,减少了繁琐的JDBC操作。
⼀般情况下,有两种⽅式可以进⾏Hibernate的配置,⼀种是通过配置⽂件进⾏配置,另⼀种是通过注解进⾏配置。
我将通过注解简单介绍Hibernate框架的配置。
Hibernate框架的配置⼀般可以分为以下⼏个步骤:1.添加基本的Hibernate Jar包2.添加注解的Jar包3.编写Hibernate.cfg.xml⽂件4.编写POJO⽂件,并编写注释5.编写测试⽂件,导出到数据库进⾏测试。
⼀、导⼊基本的Hibernate Jar包⼆、导⼊Hibernate Annotation 的Jar包三、编写Hibernate.cfg.xml⽂件1<?xml version='1.0' encoding='UTF-8'?>2<!DOCTYPE hibernate-configuration PUBLIC3 "-//Hibernate/Hibernate Configuration DTD 3.0//EN"4 "/hibernate-configuration-3.0.dtd">56<!-- Generated by MyEclipse Hibernate Tools. -->7<hibernate-configuration>89<session-factory>10<!-- 配置JDBC连接属性 -->11<property name="myeclipse.connection.profile">12 com.mysql.jdbc.Driver13</property>14<property name="connection.url">15 jdbc:mysql://localhost:3306/basehibernate16</property>17<property name="ername">root</property>18<property name="connection.password">sa</property>19<property name="connection.driver_class">20 com.mysql.jdbc.Driver21</property>22<property name="dialect">23 org.hibernate.dialect.MySQLDialect24</property>2526<!-- ⾃动建表 -->27<property name="hbm2ddl.auto">auto</property>28<property name="connection.autocommit">true</property>29<mapping class="com.basehibernate.pojo.Department"/>30<mapping class="com.basehibernate.pojo.Employee"/>31<mapping class="com.basehibernate.pojo.Meal"/>32<mapping class="com.basehibernate.pojo.OrderMeal"/>33<mapping class="com.basehibernate.pojo.GradeMeal"/>34<mapping class="com.basehibernate.pojo.RewardMeal"/>3536</session-factory>3738</hibernate-configuration>不同数据库连接在Hibernate.cfg.xml中的配置不同,这⾥以MySQL为例。
hibernate百度百科
Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate 可以在应用EJB的J2EE架构中取代CMP,完成数据持久化的重任。
目录编辑本段Hibernate的核心接口一共有5个,分别为:Session、SessionFactory、Transaction、Query和Configuration。
这5个核心接口在任何开发中都会用到。
通过这些接口,不仅可以对持久化对象进行存取,还能够进行事务控制。
下面对这五个核心接口分别加以介绍。
Session接口Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流,包含了很多常见的SQL语句。
)。
但需要注意的是Session 对象是非线程安全的。
同时,Hibernate的session不同于JSP应用中的HttpSession。
这里当使用session这个术语时,其实指的是Hibernate中的session,而以后会将HttpSession对象称为用户session。
SessionFactory接口SessionFactory接口负责初始化Hibernate。
它充当数据存储源的代理,并负责创建Session对象。
这里用到了工厂模式。
需要注意的是SessionFactory并不是轻量级的,因为一般情况下,一个项目通常只需要一个SessionFactory就够,当需要操作多个数据库时,可以为每个数据库指定一个SessionFactory。
Configuration接口Configuration接口负责配置并启动Hibernate,创建SessionFactory 对象。
Hibernate框架分析
Hibernate小试牛刀1、概述Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了封装,Hibernate提供了强大,高性能的对象到关系型数据库的持久化服务,利用Hibernate,开发人员可以按照Java的基础语言进行持久层开发。
Hibernate提供的HQL是面向对象的查询语言,它在对象型数据和关系型数据库之间,构建了一条快速,高效,便捷的沟通渠道。
我们在本次课中要掌握持久化以及对象-关系映射等概念,并且掌握如何配置HIbernate,理解Hibernate的基础语义和配置文件中的各个元素。
我们要了解Hibernate的体系结构,和Hibernate中的事物管理,以及简单了解HQL语言。
最后要学会使用Hibernate开发应用程序。
2、Hibernate框架简介开发程序使用HIbernate框架的好处由于开发的多数软件产品都是基于数据库的,也就是说我们在一个软件中的操作多数都是对数据库中的数据进行的操作。
我们对数据库大量操作就会导致数据访问层的代码变得非常繁琐,并且直接降低了我们开发效率,想想我们之前写的Dao类,假如我们要操作好多表,每个表又有很多很多的字段,假如我们查询几个表的信息,是不是我们这里的DAO层代码就非常繁琐了。
我们把大把的时间放在编写DAO类,而且我们手动编写这些代码很容易出错,这也会为调试工作带来麻烦。
这和企业要求高效率开发相违背,那么有没有一套更好的访问数据库框架,使我们可以摆脱DAO层的困境呢?很显然,我们要学习的HIbernate框架就是这样一个框架。
3、理解持久化瞬时状态在程序运行的时候有些程序数据保存在内存当中,当程序退出后,这些数据就不复存在了。
所以我们称这些数据的状态为瞬时的。
持久状态就是我们在使用一些软件的时候,有些数据在程序退出以后,还以文件等形式保存在硬盘中,那么我们称这些数据的状态是持久的。
持久化就是将程序中的数据在瞬时状态和持久状态之间转换的机制,JDBC就是一种持久化机制,将程序数据直接保存成文件也是持久化机制的一种实现。
Hibernate框架的优势和适用场景
Hibernate框架的优势和适用场景Hibernate是一个开源的对象关系映射(Object Relational Mapping,简称ORM)框架,它提供了一种方便的方式来将Java对象映射到关系型数据库中,使得开发人员可以更加专注于业务逻辑的开发,而无需关注底层数据库操作的细节。
在本文中,我们将重点探讨Hibernate框架的优势以及其适用场景。
一、Hibernate框架的优势1. 提供了简化的数据库操作:使用Hibernate框架能够避免编写大量的SQL语句,因为它主要通过对象操作来实现数据的持久化,将Java对象直接映射到数据库表中。
这样可以极大地简化数据库操作,减少了开发人员的工作量。
2. 跨数据库平台的支持:Hibernate框架对于跨数据库平台的支持非常友好,开发人员不用担心因为使用不同的数据库而导致的兼容性问题。
Hibernate提供了统一的API,可以在多种不同的数据库系统之间无缝切换。
3. 提供了缓存机制:Hibernate具备有强大的缓存机制,可以提高系统的性能和响应速度。
一方面,Hibernate框架使用二级缓存来减少数据库交互次数,提高查询性能。
另一方面,Hibernate还提供了一级缓存,用于在会话期间缓存对象以及对象之间的关系,避免频繁地从数据库中加载数据。
4. 支持事务管理:Hibernate框架通过提供事务管理机制来确保数据的一致性和完整性。
通过使用Hibernate的事务管理功能,开发人员可以对数据库的操作进行隔离、回滚和提交等操作,确保在多线程或分布式环境下的数据一致性。
5. 易于测试和维护:使用Hibernate框架进行开发的代码具有良好的可测试性和可维护性。
因为Hibernate将业务逻辑和数据库操作解耦,使得代码的编写更加清晰易懂,同时也方便进行单元测试和代码维护。
二、Hibernate框架的适用场景1. 大型企业级应用:Hibernate框架适用于需要对大量复杂的数据进行处理的大型企业级应用。
hibernate框架的原理
hibernate框架的原理Hibernate是一个开源的持久化框架,用于将对象映射到关系数据库中。
它的目标是简化数据库操作和管理,并提供高性能、稳定性和可维护性。
Hibernate的原理主要基于以下几个方面:1. 对象关系映射(ORM):Hibernate使用Java对象与关系数据库之间的映射,将对象持久化到数据库中。
每个Java类都被映射到数据库中的一个表,类的属性则对应表的列。
通过配置文件或注解,Hibernate可以根据对象模型自动生成数据库表结构。
2. 对象状态管理:Hibernate使用一个叫做“Session”的上下文来管理对象的生命周期。
当获取或创建一个对象时,Hibernate 将对象置于持久化状态,使其与数据库同步。
一旦修改了对象的数据,Hibernate将自动检测并更新数据库。
在Session的范围内,可以进行查询、更新、删除等各种数据库操作。
3. 延迟加载与缓存:为了提高性能,Hibernate引入了延迟加载和缓存机制。
延迟加载允许只在需要时才从数据库中加载数据,减少了不必要的查询。
Hibernate还提供了一级和二级缓存,可以缓存对象和查询结果,减少数据库访问次数,提高响应速度。
4. 事务支持:Hibernate提供了对事务的支持,确保数据库操作的原子性、一致性、隔离性和持久性。
事务可以跨越多个数据库操作,保证数据的完整性。
5. 查询语言(HQL):Hibernate使用HQL(Hibernate Query Language)作为其查询语言,它类似于SQL语句,但是以面向对象的方式操作对象和属性,而不是表和列。
HQL可以通过条件、排序和投影等操作来查询、过滤和操作对象。
总之,Hibernate通过对象关系映射、对象状态管理、延迟加载、缓存和事务支持等机制,提供了一种简单方便、高效稳定的数据库操作方式。
它使开发人员可以更专注于业务逻辑的实现,而不需要手动编写大量的SQL语句,提高了开发效率和代码质量。
Hibernate框架分析
Hibernate框架分析Hibernate框架是一种开源的Java持久化框架,它以简单、高效的方式实现了对关系型数据库的操作。
本文将通过对Hibernate框架的分析,探讨其主要特点、使用场景以及优势等方面,帮助读者更好地了解和应用这一框架。
一、Hibernate框架概述Hibernate框架是由Gavin King于2001年创建的,它在JDBC的基础上提供了更高层次的数据访问抽象。
Hibernate的主要目标是简化Java应用程序与数据库之间的交互,并提高开发效率。
通过使用Hibernate,开发人员可以将关注点集中在对象上,而不必关注底层数据库的细节。
二、Hibernate框架的主要特点1. 对象关系映射(ORM):Hibernate框架通过将Java对象与数据库表之间建立映射关系,实现了对象与数据库的转换。
这样一来,开发人员可以直接操作Java对象,而无需编写复杂的SQL语句。
2. 透明的持久化:Hibernate框架通过使用session对象来管理Java 对象的生命周期,将对象从内存中持久化到数据库中,或者从数据库中读取对象到内存中。
开发人员可以使用简洁的API来操作对象,而无需关心底层的数据库细节。
3. 查询语言:Hibernate提供了一种名为Hibernate Query Language (HQL)的查询语言,它类似于SQL,但更加面向对象。
使用HQL可以方便地进行复杂的查询操作。
4. 缓存机制:Hibernate框架具有一级缓存和二级缓存的机制,在查询数据时可以有效地提高性能。
一级缓存存储在session级别,而二级缓存存储在应用程序级别。
5. 事务管理:Hibernate框架支持声明式的事务管理,可以保证数据库操作的原子性和一致性。
同时,它还支持分布式事务管理,可以满足高并发环境下的需求。
三、Hibernate框架的使用场景Hibernate框架适用于各种规模的Java应用程序,特别是对数据库交互较为频繁的应用。
Hibernate框架详细介绍
Hibernate框架详细介绍Hibernate是一个开源的对象关系映射(ORM)框架,它提供了一种简单且方便的方式来处理Java应用程序中的对象和关系数据库之间的映射。
本文将详细介绍Hibernate框架的原理、特点和使用方法。
一、Hibernate框架原理Hibernate框架通过将Java对象直接映射到数据库表中的行来实现对象与关系数据之间的映射。
它使用了持久化类、映射文件和配置文件来描述Java对象与数据库表之间的关系。
Hibernate通过ORM技术,将Java对象转化为SQL语句进行数据库操作,从而避免了手动编写SQL语句的麻烦。
二、Hibernate框架特点1. 高性能:Hibernate可以通过缓存机制和延迟加载来提高应用程序的性能。
它还提供了预定义的查询语言(HQL),可以更高效地操作数据库。
2. 简化数据库操作:Hibernate提供了一种面向对象的数据库访问方式,开发人员可以使用Java的面向对象编程方式进行数据库操作,无需编写复杂的SQL语句。
3. 支持多种数据库:Hibernate可以与各种关系型数据库进行集成,并且对于开发人员来说,切换底层数据库是非常方便的。
4. 可移植性强:由于Hibernate是一个跨数据库的框架,它在不同的数据库之间提供了一致的API,使得应用程序可以在不同的数据库之间进行迁移。
三、Hibernate框架使用方法1. 配置Hibernate:首先,需要在Java应用程序中添加Hibernate的相关依赖。
然后,创建一个Hibernate的配置文件,用于配置数据库连接信息、映射文件等。
2. 创建持久化类:在Java应用程序中创建持久化类,这些类通常与数据库中的表对应。
持久化类需要添加一些注解或XML配置,来描述与数据库表字段的映射关系。
3. 创建SessionFactory:SessionFactory是Hibernate的核心接口,它是线程安全的,用于创建Session对象。
Hibernate框架详细分析
Hibernate框架详细分析Hibernate是一个开源的、高性能的对象关系映射(ORM)框架,广泛应用于Java应用程序的数据持久层开发。
它提供了一种将Java对象与数据库表之间进行映射的方式,使得开发者能够在编写代码时,忽略底层数据库的操作细节,而专注于业务逻辑的实现。
本文将对Hibernate框架进行详细分析,介绍其主要特性、工作原理以及在开发中的应用。
一、Hibernate框架主要特性1. ORM映射:Hibernate的主要功能是将Java对象与关系数据库表进行映射,使得开发者能够通过操作Java对象来实现对数据库的增删改查操作,而无需直接编写SQL语句。
这大大简化了数据持久层的开发过程。
2. 类型映射:Hibernate支持将Java中的数据类型与数据库中的数据类型进行映射,提供了丰富的数据类型转换和映射机制,开发者可以灵活地处理不同数据类型之间的转换。
3. 透明性:Hibernate通过透明化数据库操作,使得开发者可以不用关心数据库的具体细节,大大提高了开发效率。
借助Hibernate的缓存机制,可以有效地减少数据库访问次数,提高系统性能。
4. 关联映射:Hibernate支持将Java对象之间的关联关系映射到数据库表之间的关联关系,开发者可以方便地使用对象之间的关系进行数据库操作。
二、Hibernate框架工作原理Hibernate框架的工作原理可以分为以下几个步骤:1. 配置阶段:首先需要在Hibernate的配置文件中配置数据库连接等基本信息。
配置文件通常以XML形式存在,开发者需要根据实际情况进行相应的配置。
2. 映射阶段:在配置完成后,需要将Java实体类与数据库表进行映射。
开发者需要在实体类中使用Hibernate提供的注解或XML标签来描述实体类与数据库表之间的映射关系。
3. 会话工厂阶段:在Hibernate框架中,会话工厂(SessionFactory)被认为是一个重量级的对象,需要使用工厂模式进行创建。
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对象的属性与数据库表的字段之间的映射关系,以及对象之间的关联关系。
详细介绍hibernate框架的意义和作用
详细介绍hibernate框架的意义和作用Hibernate框架的意义Hibernate框架是现今最流行的ORM(对象关系映射)工具之一,它为Java应用程序供应了一个通用的机制,将Java对象长久化到数据库中。
Hibernate具有与数据库无关的API,从而为Java开发人员供应了更高的抽象层次和开发效率。
下面从四个方面分别阐述Hibernate 框架的意义和作用。
提高代码质量和开发效率使用Hibernate框架可以很大程度地提高代码质量和开发效率。
Hibernate框架以对象为中心,使开发人员更便于思索和编写代码。
通过Hibernate的封装和抽象,不需要写简单的SQL语句,开发人员可以更加专注于业务规律的实现,从而提高开发效率。
此外,基于Hibernate框架的应用程序可以更快地进行测试和调试,从而保证了代码的质量和稳定性。
数据访问层的解藕和敏捷性Hibernate框架可以与多种数据库进行交互,而且不需要修改Java代码。
Hibernate供应了与数据库无关的API,从而将应用程序的数据访问层与详细的数据库实现解耦。
这种松散的耦合性是优秀软件设计的关键特征之一。
在很多场景中,应用程序需要支持不同的数据库,此时,使用Hibernate框架可以大大削减开发工作量,并提高敏捷性。
针对简单数据模型的使用当应用程序需要管理更简单的数据结构时,Hibernate框架是最佳选择之一。
Hibernate框架自动维护数据对象之间的关联关系,支持多对多、一对多、一对一等多种关联关系。
在面对更简单的数据结构时,Hibernate框架可以轻松地管理对象之间的关联关系和数据访问。
提高数据访问的性能Hibernate框架提高了应用程序的数据访问性能。
Hibernate使用缓存技术,将对象的状态存储在内存中。
这样,通过Hibernate访问的数据可以更快地读取和更新。
Hibernate框架还支持延迟加载,这意味着可以只在需要时加载数据,从而提高性能。
Hibernate框架详解
Hibernate框架详解1. 简介Hibernate是一个开源的ORM(对象关系映射)框架,旨在简化Java应用程序与关系数据库之间的交互。
它提供了一种对象关系映射的方式,使得开发者可以使用面向对象的方式操作数据库,而无需编写复杂的SQL语句。
Hibernate具有广泛的应用,并受到Java开发者的广泛欢迎。
2. 框架结构Hibernate框架主要包含以下组件:- Hibernate配置文件:配置数据库连接和其他框架相关属性;- 映射文件:定义Java类与数据库表之间的映射关系;- 会话工厂:用于创建和管理Hibernate会话,是Hibernate的核心组件,负责数据库连接管理和对象生命周期的管理;- 会话:表示Java应用程序与数据库之间的一个单个数据库连接,用于执行数据库操作;- 对象关系映射:将Java对象与数据库表之间的映射关系定义为映射文件,Hibernate通过映射文件实现对象关系映射。
3. 对象关系映射对象关系映射实际上是将Java对象与关系数据库表之间的映射,使得可以通过操作Java对象来实现对数据库的操作。
Hibernate通过映射文件定义了对象和表之间的映射关系,包括表名、列名、主键和外键等。
通过这种方式,Hibernate框架能够自动执行对象到数据库表的转换和数据库表到对象的转换。
4. Hibernate查询语言(HQL)Hibernate提供了一种称为Hibernate查询语言(HQL)的查询方式,它类似于SQL语言,但是使用了面向对象的概念。
开发者可以通过HQL查询对象,而无需直接操作数据库表。
HQL查询语句以面向对象的方式操作对象,使得查询更加直观和方便。
同时,HQL还支持查询缓存,可以提高查询性能。
5. Hibernate缓存Hibernate框架支持多级缓存机制,以提高应用程序性能。
Hibernate缓存分为三个级别:- 一级缓存:也称为会话缓存,位于会话对象中,缓存在会话的生命周期内,减少对数据库的访问。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
10
2. HIBERNATE框架快速入门
创建持久化类(POJO)
在创建持久化类时,应注意以下事项: 持久化类和类中的方法不能为final修饰; 创建的持久类建议实现Serializable序列化接口; 为持久类创建一个标识属性id,该属性映射数据库表 的主键字段; 类的各属性为private类型,并为类的各属性提供 public类型的访问器(setter和getter方法)。
<!-- 在操作数据库时是否打印SQL语句 -->
<property name="hibernate.show_sql">true</property> <!-- 打开 hbm2ddl.auto 选项将自动生成数据库模式(schema)- 直接加入数据库中 --> <property name="hbm2ddl.auto">update</property> <!-- 配置ORM映射文件 --> <mapping resource="com/henu/domain/Person.hbm.xml"></mapping> </session-factory> </hibernate-configuration>
目标:
掌握Eclipse项目Hibernate的配置方法; 掌握MyEclipse Hibernate项目的使用用法。
清 华 大 学 出 版 社
14
2. HIBERNATE框架快速入门
理解hibernate.cfg.xml
hibernate.connection.driver_class:指定连接数据库的 驱动工具类,如MySQL为“com.mysql.jdbc.Driver”, 若连接其它数据库,其驱动工具类名称参阅第4章内容。 hibernate.connection.url:指定连接数据库的URL,如 连接本地MySQL中的test数据库,其URL为 “jdbc:mysql://localhost:3306/test”。 hibernate.connection.password:指定连接数据库的 密码。 ername:指定连接数据库的 用户名。 hibernate.dialect:指定连接数据库的方言。
清 华 大 学 出 版 社
6
1. ORM概述
Hibernate的特点:
Hibernate对JDBC访问数据库的代码做了封装,大大简 化了数据访问层繁琐的重复性代码; Hibernate是一个基于JDBC的主流持久化框架,是一个 清 优秀的ORM实现工具。它很大程度上简化了DAO层的 华 大 编码工作; 学 出 版 Hibernate使用Java反射机制,而不是用字节码增强程 社 序来实现透明性; 由于Hibernate是一个轻量级框架,性能较好。 Hibernate映射的灵活性很出色,支持各种关系数据库, 从一对一到多对多的各种复杂关系。 7
清 华 大 学 出 版 社
8
2. HIBERNATE框架快速入门
复制以下文件至项目的WEB-INF/lib目录(含JDBC 驱动)
清 华 大 学 出 版 社
9
2. HIBERNATE框架快速入门
创建Hibernate配置文件hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <!-- 定义数据库连接驱动 --> <property name="hibernate.connection.driver_class"> com.mysql.jdbc.Driver</property> <!-- 定义数据库服务器地址 --> <property name="hibernate.connection.url"> jdbc:mysql://localhost:3306/test</property>
5
1. ORM概述
主流ORM框架:
Hibernate:JBoss属下的一个ORM工具,同时也是当前最为主流的 开源ORM框架。Hibernate对JDBC进行了轻量级的封装,将Java对象 与对象关系映射至关系型数据库中的数据表与数据表之间的关系。 mybatis:原名叫iBATIS,由Clinton Begin在2001年发起的开放源代 码项目,曾是Apache的一个开源项目,2010年这个项目由Apache迁 移到Google code,并且改名为mybatis。在对数据库的操作过程中, mybatis使用半自动的即开发人员可以手写SQL语句,在系统的数据库 优化方面提供了较多的空间。相对于Hibernate而言,mybatis只能算 是一个半自动化的ORM框架。 OJB:Apache的一个开源项目,是iBATIS的一个后继ORM产品。OJB 使用基于XML的对象关系映射。OJB能够完成从Java对象到关系数据 库的透明存储。 TopLink:一个Oracle公司的商业产品,TOPLink在关系数据库表中存 储Java对象和EJB提供了高度灵活和高效的机制。TopLink为开发人员 提供极佳的性能和选择,可以与任何数据库、任何应用服务器、任何 开发工具集和过程以及任何Java EE体系结构协同工作。
清 华 大 学 出 版 社
13
2. HIBERNATE框架快速入门
动手实践:
新建一个数据表User(ID,用户名,密码,类型,注册 时间,主键为ID); 为Java Web项目配置Hibernate支持能力; 编写数据表对应的POJO; 编写Hibernate的配置文件; 编写映射文件;
清 华 大 学 出 版 社
11
2. HIBERNATE框架快速入门
定义ORM映射文件
ORM映射文件的主要作用就是指定持久化类与数据库表之间的映射关系。Hibernate的映射文件也 采用XML文档格式,映射文件也保存至CLASSPATH指定的路径下。 <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <!-- class元素定义持久化类的具体包路径、关联的数据库及表名称 --> <class name="com.henu.domain.Person" table="person" catalog="test"> <!-- id元素定义表的主键对应持久化类中的属性名称、数据类型 --> <id name="id" type="ng.Integer"> <!-- column元素定义表的主键 --> <column name="id" /> <!-- generator元素定义表的主键生成方式,这里采用native方式 --> <generator class="native"></generator> </id> <!-- property元素定义持久化类的其它属性与表中列名之间的对照关系及数据类型等 --> <property name="name" type="ng.String"> <column name="name" length="20" not-null="true" /> </property> </class> </hibernate-mapping>
3
清 华 大 学 出 版 社
1. ORM概述
ORM(Object/Ralation
Mapping,ORM) 是解决在面向对象的编程中,程序设计语言 与关系型数据库发展不匹配而提出来的一种 中间层解决方案。 ORM是通过使用描述对象和数据库之间映射 的元数据,将应用程序中的对象自动持久化 到关系型数据库中,本质上是将数据从一种 形式转换成另外一种形式。 ORM帮助开发人员完成面向对象的程序设计 语言到关系型数据库的映射,从而实现在项 目中既保持以一种完全地面向对象的思想设 计与开发应用程序和持久化数据库,又能利 用关系型数据库的技术优势。
清华大学出版社
<!-- 数据库用户名 -->
<property name="ername">root</property> <!-- 数据库用户对应的密码 --> <property name="hibernate.connection.password">123</property> <!-- 数据库对应的方言 --> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>