hibernate官方入门教程
hibernate的基本用法
hibernate的基本用法Hibernate是一个开源的Java框架,用于简化数据库操作。
它为开发人员提供了一个更加简单、直观的方式来管理数据库,同时也提高了应用程序的性能和可维护性。
本文将逐步介绍Hibernate的基本用法,包括配置、实体映射、数据操作等。
一、配置Hibernate1. 下载和安装Hibernate:首先,我们需要下载Hibernate的压缩包并解压。
然后将解压后的文件夹添加到Java项目的构建路径中。
2. 创建Hibernate配置文件:在解压后的文件夹中,可以找到一个名为"hibernate.cfg.xml"的文件。
这是Hibernate的主要配置文件,我们需要在其中指定数据库连接信息和其他相关配置。
3. 配置数据库连接:在"hibernate.cfg.xml"文件中,我们可以添加一个名为"hibernate.connection.url"的属性,用于指定数据库的连接URL。
除此之外,还需要指定数据库的用户名和密码等信息。
4. 配置实体映射:Hibernate使用对象关系映射(ORM)来将Java类映射到数据库表。
我们需要在配置文件中使用"mapping"元素来指定实体类的映射文件。
这个映射文件描述了实体类与数据库表之间的对应关系。
二、实体映射1. 创建实体类:我们需要创建一个Java类,用于表示数据库中的一行数据。
这个类的字段通常与数据库表的列对应。
同时,我们可以使用Hibernate提供的注解或XML文件来配置实体的映射关系。
2. 创建映射文件:可以根据个人喜好选择使用注解还是XML文件来配置实体类的映射关系。
如果使用XML文件,需要创建一个与实体类同名的XML文件,并在其中定义实体类与数据库表之间的映射关系。
3. 配置实体映射:在配置文件中,我们需要使用"mapping"元素来指定实体类的映射文件。
Hibernate入门之一
management --> <property name="current_session_context_class">thread</property> <mapping resource="test/domain/Employee.hbm.xml" />
</session-factory> </hibernate-configuration>
持久化技术之 Hibernate
Hibernate 入门之一:快速构建
余志勇 整理
1.1 Hibernate 是什么?
Hibernate facilitated the storage and retrieval of Java domain objects via Object/Relational Mapping. Today, Hibernate is a collection of related
Web8i 专注于信息技术,并传播之,联系我:chinayzy@
持久化技术之 Hibernate
oracle.jdbc.driver.OracleDriver </property> <property name="dialect">org.hibernate.dialect.Oracle9Dialect</proper ty> <!-Enable Hibernate's automatic session context
projects enabling developers to utilize POJO-style domain models in their applications in ways extending well beyond Object/Relational Mapping.
hibernate教程
hibernate教程Hibernate是一个开源的对象/关系映射框架,它提供了一种通过Java类对数据库操作的方式,能够帮助我们更加方便、灵活地操作数据库。
下面是一个简要的Hibernate教程。
1. 配置Hibernate:在使用Hibernate之前,需要先配置Hibernate的相关信息,如数据库连接等。
配置信息可以存放在一个XML文件中,通过读取XML文件来获取。
2. 创建实体类:在Hibernate中,数据库中的表与Java中的类是一一对应的关系,我们需要创建与数据库表对应的Java类。
在Java类中,可以定义属性来表示表中的列,并相应地定义getter和setter方法。
3. 定义映射文件:映射文件定义了Java类与数据库表之间的映射关系。
在映射文件中,需要指定类名、表名、属性与列的对应关系等。
4. 创建SessionFactory:SessionFactory是Hibernate的核心接口之一,用于创建Session对象。
SessionFactory负责初始化Hibernate的配置,以及创建数据库连接池。
5. 创建Session:Session是Hibernate处理持久化操作的接口。
它代表了一次对数据库的操作,可以用于保存、更新、删除对象,以及执行查询操作。
6. 保存对象:在Hibernate中,可以通过Session的save方法将Java对象保存到数据库中。
当调用save方法后,Hibernate会自动将Java对象转换为SQL语句,并执行保存操作。
7. 更新对象:通过Session的update方法可以更新数据库中的对象。
当调用update方法时,Hibernate会根据对象的状态,自动执行更新操作。
8. 删除对象:通过Session的delete方法可以删除数据库中的对象。
当调用delete方法时,Hibernate会自动执行删除操作。
9. 查询对象:Hibernate提供了一种面向对象的查询语言,称为HQL(Hibernate Query Language)。
Hibernate快速入门教程
一、第一个应用实例1.搭建环境:新建一个名为HibernateDemo的java工程,并导入Hibernate的jar包,特别要注意除了导入lib下的jar包还需导入hibernate3.jar核心jar包。
由于涉及数据库操作,还应导入mysql驱动包。
说明,如果使用最新的hibernate,hibernate开发的基本jar包(7个) 来源:hibernate-distribution-3.3.2.GA.zip hibernate3.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配置
Hibernate通过配置文件指定数据库连接信息、 映射配置和其他配置选项。开发人员可以根 据实际需求进行灵活的配置,以满足不同的 场景和需求。
Hibernate映射
数据库表和Java类的映射
Hibernate提供了灵活的映射机制,将数据库 表和Java类之间的关系进行映射。开发人员 可以通过注解或XML配置文件定义映射规则, 实现数据的转换和传递。
Hibernate事件模型
Hibernate通过事件模型实现了灵活的事件处 理机制。开发人员可以通过注册事件监听器, 对特定的事件进行处理,如对象的加载、保 存、更新和删除等操作。
批量操作和预处理语句
Hibernate提供了批量操作和预处理语句的支 持,用于提高数据库操作的效率。批量操作 可以将多个操作合并成一个批量操作,减少 与数据库的交互次数。预处理语句可以预先 编译好SQL语句,提高查询性能。
《Hibernate入门》PPT课 件
Hibernate入门课程是为了让您了解Hibernate框架的使用和优势。通过本课程, 您将深入了解Hibernate的基本概念、映射、HQL查询、高级特性以及与Spring 的整合等内容。
简介
什么是Hibernate?
Hibernate是一个Java持久化框架,用于将Java对象映射到数据库。它提供了ORM解决方案, 使开发人员能够以面向对象的方式访问数据库。
HQL查询示例
HQL可以进行各种查询操作,包括简单的单 表查询、多表关联查询、聚合查询等。开发 人员可以根据实际需求编写HQL查询语句, 方便地获取所需的数据。
Hibernate高级特性
一级缓存和二级缓存
Hibernate提供了一级缓存和二级缓存机制, 用于提高系统的性能。一级缓存是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菜鸟教程
hibernate菜鸟教程
Hibernate是一个开源的对象关系映射框架,它提供了将Java
对象映射到关系数据库中的功能,并支持数据库的CRUD操作。
通过Hibernate,开发人员可以摆脱传统的JDBC编程,
简化了数据持久化层的开发工作。
Hibernate的主要特点包括:
1. 对象关系映射:Hibernate的核心功能就是将Java对象和关
系数据库之间进行映射,开发人员不需要编写繁琐的SQL语
句来进行数据的持久化操作,只需要操作Java对象即可。
2. 高度可定制化:Hibernate提供了丰富的配置选项,可以根
据项目的需求进行灵活的配置。
开发人员可以使用XML文件
或者注解来定义映射关系。
3. 数据库无关性:Hibernate可以适用于多种关系数据库,开
发人员不需要关心不同数据库的SQL差异,只需要根据Hibernate的API进行开发即可,从而提高了开发的效率。
4. 缓存机制:Hibernate内置了一级缓存和二级缓存的支持,
可以提高数据的访问效率。
一级缓存是在Session级别的缓存,而二级缓存是在SessionFactory级别的缓存。
5. 延迟加载:Hibernate支持延迟加载机制,可以在需要访问
关联对象时再进行查询,提高了性能。
总之,Hibernate是一个非常强大且灵活的对象关系映射框架,能够极大地简化数据持久化层的开发工作,提高开发效率。
它已经成为了Java开发中非常重要的框架之一。
跟我学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程序首先我们将创建一个简单的控制台(console-based)hibernate程序。
我们使用内置数据库(in-memory database) (HSQL DB),所以我们不必安装任何数据库服务器。
让我们假设我们希望有一个小程序可以保存我们希望关注的事件(Event)和这些事件的信息。
(译者注:在本教程的后面部分,我们将直接使用Event而不是它的中文翻译“事件”,以免混淆。
)我们做的第一件事是建立我们的开发目录,并把所有需要用到的Java库文件放进去。
从Hibernate网站的下载页面下载Hibernate分发版本。
解压缩包并把/lib下面的所有库文件放到我们新的开发目录下面的/lib目录下面。
看起来就像这样:.+libantlr.jarcglib-full.jarasm.jarasm-attrs.jarscommons-collections.jarcommons-logging.jarehcache.jarhibernate3.jarjta.jardom4j.jarlog4j.jarThis is the minimum set of required libraries (note that we also copied hibernate3.jar, the main archive) for Hibernate. See the README.txt file in the lib/ directory of the Hibernate distribution for more information about required and optional third-party libraries. (Actually,Log4j is not required but preferred by many developers.) 这个是Hibernate运行所需要的最小库文件集合(注意我们也拷贝了Hibernate3.jar,这个是最重要的库)。
Hibernate教程_从入门到精通_第二篇(共四篇)
目标: •Hibernate API简介
Hinernate的体系结构(运行时)
SessionFactory:它保存了对当前数据库配置的所有映射关系,它是将某 个数据库的映射关系经过编译之后全部保存在内存中的。 它还是生成 Session的工厂,它在进行实例化的过程中将会用到ConnectionProvider。 一个SessionFactory对应一个数据库连接,当数据库连接改变时需要修改 SessionFactory Sesion: 是进行持久化操作的基础,所有的持久化操作都是在Session的 基础上进行的。它相当与JDBC中的Connection。它是Hibernate的持 久化 管理器的核心,提供了一系列的持久化操作方法。另外,它还持有一个针 对持久化对象的一级缓存,在遍历持久化对象或者根据持久化标识查找对 象的时候会用 到。 Transation:功能上和数据库中的事务完全一样,通过它实现对数据库中 事务的控制。Transation对象是Session对象产生的,所以他的生命周期比 Session短。一个Session的生命周期中可以有多个Transaction对象。 ConnectonProvider:主要作用是生成与数据库建立了连接的JDBC对象 ,同时他还作为数据库连接的缓冲池。通过ConnectionProvider实现了应 用程序和底层的DataSource和DriverManager的隔离。 TransactionFactory:是生成Transaction对象的工厂,通过 TransactionFactory实现了事务的封装,使其具体的实现方法与应用程序无 关。
判断一个实体对象是否处于瞬态: 该实体对象的<id>属性(如果存在)的值为空 如果在映射文件中为<id>设置了unsaved-value属性,并且 实体对象的id属性的值与unsaved-value属性的值相同 如果这个实体对象配置version属性,并且version属性的 空 在映射文件中为version属性设置了unsaved-value属性,并且 version属性的值与unsaved-value属性的值相同。 如果设置了interceptor,并且interceptor的isUnsaved() 方法的返回值为true
hibernate 教程
Hibernate 教程什么是 HibernateHibernate 是一种 Java 持久化框架,它提供了一种简单的方法来存储、检索和操作 Java 对象与关系数据库之间的数据。
Hibernate 是基于 Java Persistence API (JPA)标准的实现,是一个开放源代码的框架。
Hibernate 的优势1. 简化数据库操作Hibernate 提供了一个简单的面向对象的 API,让开发人员可以直接使用 Java 对象进行数据库操作,而无需编写复杂的SQL 语句。
通过 Hibernate,开发人员可以更专注于业务逻辑的实现,而不必关心底层的数据库细节。
2. 跨数据库的透明性Hibernate 提供了一种数据库无关的开发方式,它支持多种不同类型的数据库,如 MySQL、Oracle、PostgreSQL 等。
开发人员可以通过简单的配置,无缝切换不同的数据库,而不必修改代码。
3. 提高性能Hibernate 提供了一些缓存机制,可以有效地提高数据库访问性能。
通过缓存,Hibernate 可以减少对数据库的频繁访问,提高系统的响应速度。
4. 支持延迟加载Hibernate 具有延迟加载机制,它可以在需要使用对象时才从数据库中加载数据。
这种机制可以减少不必要的数据库访问,提高应用程序的性能。
Hibernate 的基本概念1. 实体类在 Hibernate 中,实体类是指映射到数据库表的 Java 类。
实体类包含了与数据库表中的字段对应的属性,以及与数据库表中的记录对应的对象。
2. 映射文件映射文件是用来描述实体类与数据库表之间的映射关系的配置文件。
通过映射文件,Hibernate 可以知道如何将实体类的属性映射到数据库表的字段,以及如何将数据库表的记录转换为实体类的对象。
3. 会话工厂在使用 Hibernate 之前,需要先创建一个会话工厂。
会话工厂负责创建会话对象,会话对象用于与数据库进行交互。
新手上路之java Hibernate:第一个Hibernate例子
新手上路之java Hibernate:第一个Hibernate例子一、Hibernate概述(一)什么是Hibernate?hibernate核心内容是ORM(关系对象模型)。
可以将对象自动的生成数据库中的信息,使得开发更加的面向对象。
这样作为程序员就可以使用面向对象的思想来操作数据库,而不用关心繁琐的JDBC。
所以,Hibernate处于三层架构中的D层(持久层)。
(二)使用Hibernate的优点1、Hibernate可以使用在Java的任何项目中,不一定非要使用在Java web项目中。
因为Hibernate不需要类似于tomact这些容器的支持,可以直接通过一个main方法进行测试。
2、通过下面的实例,可以发现使用Hibernate可以大大减少代码量。
3、由于使用了Hibernate,代码中不涉及具体的JDBC语句,所以就方便了代码的可移植性。
二、Hibernate开发的环境搭建(一)Hibernate的环境搭建非常简单,只需要引入Hibernate核心包(单击下载)以及Hibernate依赖包(单击下载)即可。
(二)加入数据库驱动。
下面的例子中主要是采用Mysql数据库来演示的,所以在这里引入MysqL的JDBC驱动(点击下载)。
(三)提供核心配置文件hibernate.cfg.xml文件(在src文件夹下即可)。
其中的配置如下(针对mysql)[html]view plain copy1.<!DOCTYPE hibernate-configuration PUBLIC2. "-//Hibernate/Hibernate Configuration DTD3.0//EN"3. "/hibernate-configuration-3.0.dtd">4.5.<hibernate-configuration>6.<session-factory>7.<!-- mysql数据库驱动 -->8.<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>9.<!-- mysql数据库名称 -->10.<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>11.<!-- 数据库的登陆用户名 -->12.<property name="ername">root</property>13.<!-- 数据库的登陆密码 -->14.<property name="hibernate.connection.password">root</property>15.<!-- 方言:为每一种数据库提供适配器,方便转换 -->16.<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>17.18.</session-factory>19.</hibernate-configuration>三、HIbernate第一个实例该实例的目录结构如下说明:最后一个HIBERNATE3里面包含了所有的需要引用的jar包1、新建一个普通的java项目,按照上面的步骤引入相关的jar包和配置文件2、建立User实体类[java]view plain copy1.import java.util.Date;2.3.public class User {4.private String id;5.private String username;6.private String password;7.private Date createTime;8.private Date expireTime;9.10.public String getId() {11.return id;12. }13.public void setId(String id) {14.this.id = id;15. }16.public String getUsername() {17.return username;18. }19.public void setUsername(String userName) {ername = userName;21. }22.public String getPassword() {23.return password;24. }25.public void setPassword(String password) {26.this.password = password;27. }28.public Date getCreateTime() {29.return createTime;30. }31.public void setCreateTime(Date createTime) {32.this.createTime = createTime;33. }34.public Date getExpireTime() {35.return expireTime;36. }37.public void setExpireTime(Date expireTime) {38.this.expireTime = expireTime;39. }40.}2、提供User.hbm.xml文件,完成实体类的映射[html]view plain copy1.<?xml version="1.0"?>2.<!DOCTYPE hibernate-mapping PUBLIC3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"4. "/hibernate-mapping-3.0.dtd">5.6.<hibernate-mapping>7.<class name="er">8.<id name="id">9.<generator class="uuid"/>10.</id>11.<property name="username"/>12.<property name="password"/>13.<property name="createTime"/>14.<property name="expireTime"/>15.</class>16.</hibernate-mapping>其中的property标签是将要生成是数据库表中的字段,在这里不用关心各个字段是什么类型的。
第二讲 Hibernate入门
基本概念
• 对象持久化:持久化的目的就是将内存中 的数据存储在关系数据库或磁盘文件和 XML数据文件中。 • O种 主要的持久化技术,需要同时使用面向对 象和关系数据库进行开发。
第一个Hibernate程序-HelloWorld
• 1、建立新的Java项目,名为Hibernate_01_HelloWorld • 2、学习建立User Library——Hibernate3.6,并加入相应 的jar包 • 1)项目右键Build path-》configure build path-》add library • 2)选择user library命名Hibernate3.6 • 3)在该library中加入所需的jar包(hibernate3、 required、jpa、slf4j-nop)
第二讲 Hibernate入门
• 环境准备 • Hibernate3.6.7 • slf4j -1.6 • Apache-log4j-1.2.16 • Junit4.9 • mysql-connector-java-5.1.15 • 学习资源 • • Hibernate zh_CN文档
第一个Hibernate程序-HelloWorld
• 3、引入mysql的jdbc包 • 4、在mysql中建立相对应的数据库和表 • 1)create database hibernate • 2)use hibernate • 3)create table student(id int primary key,name varchar(20),age int)
第一个Hibernate程序-HelloWorld
• 5、建立Hibernate配置文件hibernate.cfg.xml • 1)从参考手册中拷贝 • 2)修改对应的数据库连接 • 3)注释掉暂时用不上的内容 • 6、建立Student类 • 7、建立Student映射文件Student.hbm.xml • 1)参考手册
Hibernate讲义(1)
Hibernate讲义(1)--Hibernate入门Hibernate是一种强大高效的持久层查询服务器,它对JDBC进行了轻量级的封装,并以面向对象的思维方式,解决数据库的操作问题。
在基于MVC设计模式的Java Web应用中,Hibrenate可以作为应用的数据访问层。
1.1.1持久层与ORM数据持久化一般指将内存中的数据或对象存储到可长期保存的某种介质上,以使其比存活时间比创建该对象的进程时间要长。
在对数据或对象持久化后,可以重新获取并能保证在没有对其进行任何改动的情况下,与持久化之前的一样。
一般持久化的实现通过各种关系数据库来完成。
持久层就是专门负责持久化工作的逻辑层,由它统一与数据库层打交道。
持久层在数据存储器中负责存储或获取数据的一组类和组件,持久层必须包括一个业务领域实体的模型,在持久层中封装对数据库访问的细节,向业务逻辑公开接口。
对象-关系映射(Object/Relation Mapping,ORM)是随着面向对象的软件发方法发展而产生的,是为了解决面向对象与关系数据库存在的互不匹配现象而产生的技术。
对象和关系数据是业务实体的两种表现形式,业务实体在内存中表现为对象,在数据库中表现为关系数据。
ORM通过使用描述对象和数据库之间映射的元数据,将程序中的对象自动持久化到关系数据库中。
本质上就是将数据表映射为对象类,从一种形式转换到另外一种形式。
1.1.2Hibernate3 简介Hibernate是非常优秀、成熟的O/R Mapping框架,它提供了强大、高性能的Java对象和关系数据的持久化和查询功能。
Hibernate作为持久层的一项实现技术,运用DAO(Data Access Object)设计模式来实现对象和关系数据库之间的映射,对JDBC进行了轻量级的对象封装,在Java应用和关系数据库之间建立桥梁,Java程序员可以完全使用面向对象的编程思维来操作关系数据库。
Hibernate为Java 程序员提供了面向对象的API和接口来操纵数据库,从而避免了在业务逻辑中嵌入大量的JDBC访问和事物控制代码。
韩顺平 hibernate第2讲
hibernate 从入门到精通
主讲: 韩顺平
■
Criteria接口
Criteria接口也可用于面向对象方式的查询,关于它的具体用法我们 这里先不做介绍,简单看几个案例. 最简单案例:返回50条记录 Criteria crit = sess.createCriteria(Cat.class); crit.setMaxResults(50); List cats = crit.list(); 限制结果集内容 List cats = sess.createCriteria(Cat.class) .add( Restrictions.like("name", "Fritz%") ) .add( Restrictions.between("weight", minWeight, maxWeight) ) .list();
hibernate 从入门到精通
主讲: 韩顺平
hibernate 从入门到精通
主讲: 韩顺平
■ConfiguraFra bibliotekon类①负责管理hibernate的配置信息 ②读取hibernate.cfg.xml ③加载hibernate.cfg.xml配置文件中 配置的驱动,url,用户名,密码,连接池. ④管理 *.hbm.xml对象关系文件.
hibernate 从入门到精通
主讲: 韩顺平
■
对象关系映射文件(*.hbm.xml) ①该文件主要作用是建立表和类的映射关系,是不可或缺的重要文件. ②一般放在其映射的类同一个目录下,但不是必须的。 ③命名方式一般是 类名.hbm.xml,但不是必须的。 ④示意图:
*.hbm.xml 表
某个类
hibernate 从入门到精通
Hibernate学习过程
Hibernate学习过程第一章hibernate 入门一、jbosstools的安装hibernate是jboss公司的一个项目,所用STS工具并不支持hibernate配置文件的开发,jboss 集成开发包有大量的工具类。
1、导入工具过程:点击Help Install New Software接下来过程如图所示:Jboss工具安装成功如下2、创建一个java项目导入相应的包(hibernate_01中)。
在java项目中与web项目不同导入的jar包通常需要执行这一操作(Build Path->Add Build Path)二、创建hibernate配置文件在src目录下创建相应的hibernate.cfg.xml文件在这个文件中加上相应的数据库配置信息创建实体类User.java三、在实体类的包中创建相应的Use.hbm.xml文件,用来指定实体类和数据库映射关系与User.java 同一文件路径将配置文件User.hbm.xml添加到hibernate的cfg的配置文件中常用对象(Configuration , ServiceRegistry, SessionFactory)六、创建SessionFactory,SessionFactory是线程安全,所以整个SessionFactory应该基于单例的模式来创建(TestFirst.java中)Configuration cfg = new Configuration().configure();ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(cfg.getProperties()).buildServiceRegistry();SessionFactory factory = cfg.buildSessionFactory(serviceRegistry);七、创建sessionSession session = factory.openSession();八、通过session来进行各种操作以下代码完成了对象的添加操作try {session = factory.openSession();//开启事务session.beginTransaction();User u = new User();u.setNickname("张三");u.setPassword("123");u.setUsername("zhangsan");u.setBorn(new Date());session.save(u);//提交事务session.getTransaction().commit();} catch (HibernateException e) {e.printStackTrace();if(session!=null) session.getTransaction().rollback();} finally {if(session!=null) session.close();}体验hibernate的魅力吧请仔细研究关于User对象的增删改查(CRUD)在hibernate_01项目包中。
hibernate入门课件
3 复杂关系映射
Hibernate中的关联(Association)映射主要 有3种:一对一关联、一对多(或多对一)关联、 多对多关联。每种关联都可以分为单向和双向两 种。关联关系映射通常情况是最难配置正确的。
19
3.1 一对一映射
例如有表 student(sid,name,roomid); Room(rid,address)
主要内容
本讲主要内容
1.深入了解hibernate 2.掌握如何配置hibernate,完成对数据库
的增删改查操作 3.hibernate中复杂的映射(一对一,多对
一,一对多,多对多)
1
1. 了解hibernate
1.1回顾JDBC Java访问数据库最原始的方法是通过JDBC来完
成的。JDBC(Java Data Base Connectivity,java数据库连接)是一种用于 执行SQL语句的Java API,可以为多种关系数 据库提供统一访问,它由一组用Java语言编写的 类和接口组成。JDBC是J2EE标准的一部分,它 提供了一种基准,据此可以构建更高级的工具和 接口,使数据库开发人员能够编写数据库应用程 序。
Connection类:负责维护JSP/JAVA数据库程 序和数据库之间的联机。可atement类:通过Statement类所提供的方法,可 以利用标准的SQL命令,对数据库直接新增、删除或修改 操作
PreparedStatement类:PreparedStatement类 和Statement类的不同之处在于 PreparedStatement类对象会将传入的SQL命令事先 编好等待 使用,当有单一的SQL指令比多次执行时,用 PreparedStatement类会比Statement类有效率
经典heibernate教程,从入门到精通
持久化操作 save/update/delete/find
创建和销毁都相当耗费 创建和销毁都相当耗费 资源,通常一个系统内 资源,通常一个系统内 一个数据库只创建一个 一个数据库只创建一个 类似于JDBC中的 类似于JDBC中的 Connection Connection
Configuration Configuration 创建 SessionFactory SessionFactory 创建 Session Session 执行
相同点:
• • • 两者都是JAVA的数据库操作中间件。 两者对于数据库进行直接操作的对象都不是线程安全的,都需要及时关闭。 两者都可以对数据库的更新操作进行显式的事务处理。
不同点:
• • • 使用的SQL语言不同:JDBC使用的是基于关系型数据库的标准SQL语言,Hibernate 使用的是HQL(Hibernate query language)语言 操作的对象不同:JDBC操作的是数据,将数据通过SQL语句直接传送到数据库中执 行,Hibernate操作的是持久化对象,由底层持久化对象的数据更新到数据库中。 数据状态不同:JDBC操作的数据是“瞬时”的,变量的值无法与数据库中的值保持一 致,而Hibernate操作的数据是可持久的,即持久化对象的数据属性的值是可以跟数据 库中的值保持一致的。
2-2):添加配置文件 -- hibernate.cfg.xml
• <session-factory>
<property name="dialect"> org.hibernate.dialect.SQLServerDialect </property> <property name="connection.datasource">java:/comp/env/pubs</propert y> <property name="session_factory_name">hibernate</property> <mapping resource="com/aptech/jb/entity/User.hbm.xml" />
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
hibernate官方入门教程第一部分-第一个Hibernate程序首先我们将创建一个简单的控制台(console-based)hibernate程序。
我们使用内置数据库(in-memory database) (HSQL DB),所以我们不必安装任何数据库服务器。
让我们假设我们希望有一个小程序可以保存我们希望关注的事件(Event)和这些事件的信息。
(译者注:在本教程的后面部分,我们将直接使用Event而不是它的中文翻译“事件”,以免混淆。
)我们做的第一件事是建立我们的开发目录,并把所有需要用到的Java库文件放进去。
从Hibernate网站的下载页面下载Hibernate分发版本。
解压缩包并把/lib下面的所有库文件放到我们新的开发目录下面的/lib目录下面。
看起来就像这样:.+libantlr.jarcglib-full.jarasm.jarasm-attrs.jarscommons-collections.jarcommons-logging.jarehcache.jarhibernate3.jarjta.jardom4j.jarlog4j.jarThis is the minimum set of required libraries (note that we also copied hibernate3.jar, the main archive) for Hibernate. See the README.txt file in the lib/ directory of the Hibernate distribution for more information about required and optional third-party libraries. (Actually,Log4j is not required but preferred by many developers.) 这个是Hibernate运行所需要的最小库文件集合(注意我们也拷贝了Hibernate3.jar,这个是最重要的库)。
可以在Hibernate分发版本的lib/目录下查看README.txt,以获取更多关于所需和可选的第三方库文件信息(事实上,Log4j并不是必须的库文件但是许多开发者都喜欢用它)。
接下来我们创建一个类,用来代表那些我们希望储存在数据库里面的event.2.2.1. 第一个class我们的第一个持久化类是一个简单的JavaBean class,带有一些简单的属性(property)。
让我们来看一下代码:import java.util.Date;public class Event {private Long id;private String title;private Date date;Event() {}public Long getId() {return id;}private void setId(Long id) {this.id = id;}public Date getDate() {return date;}public void setDate(Date date) {this.date = date;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}}你可以看到这个class对属性(property)的存取方法(getter and setter method)使用标准的JavaBean命名约定,同时把内部字段(field)隐藏起来(private visibility)。
这个是个受推荐的设计方式,但并不是必须这样做。
Hibernate也可以直接访问这些字段(field),而使用访问方法(accessor method)的好处是提供了程序重构的时候健壮性(robustness)。
id 属性(property)为一个Event实例提供标识属性(identifier property)的值-如果我们希望使用Hibernate的所有特性,那么我们所有的持久性实体类(persistent entityclass)(这里也包括一些次要依赖类) 都需要一个标识属性(identifier property)。
而事实上,大多数应用程序(特别是web应用程序)都需要识别特定的对象,所以你应该考虑使用标识属性而不是把它当作一种限制。
然而,我们通常不会直接操作一个对象的标识符(identifier),因此标识符的setter方法应该被声明为私有的(private)。
这样当一个对象被保存的时候,只有Hibernate可以为它分配标识符。
你会发现Hibernate可以直接访问被声明为public,private和protected等不同级别访问控制的方法(accessor method)和字段(field)。
所以选择哪种方式来访问属性是完全取决于你,你可以使你的选择与你的程序设计相吻合。
所有的持久类(persistent classes)都要求有无参的构造器(no-argument constructor);因为Hibernate必须要使用Java反射机制(Reflection)来实例化对象。
构造器(constructor)的访问控制可以是私有的(private),然而当生成运行时代理(runtime proxy)的时候将要求使用至少是package级别的访问控制,这样在没有字节码编入(bytecode instrumentation)的情况下,从持久化类里获取数据会更有效率一些。
我们把这个Java源代码文件放到我们的开发目录下面一个叫做src的目录里。
这个目录现在应该看起来像这样:.+lib<Hibernate and third-party libraries>+srcEvent.java在下一步里,我们将把这个持久类(persisten class)的信息通知Hibernate2.2.2. 映射文件Hibernate需要知道怎样去加载(load)和存储(store)我们的持久化类的对象。
这里正是Hibernate映射文件(mapping file)发挥作用的地方。
映射文件告诉Hibernate它应该访问数据库里面的哪个表(table)和应该使用表里面的哪些字段(column)。
一个映射文件的基本结构看起来像这样:<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping>[...]</hibernate-mapping>注意Hibernate的DTD是非常复杂的。
你可以在你的编辑器或者IDE里面使用它来自动提示并完成(auto-completion)那些用来映射的XML元素(element)和属性(attribute)。
你也可以用你的文本编辑器打开DTD-这是最简单的方式来浏览所有元素和参数,查看它们的缺省值以及它们的注释,以得到一个整体的概观。
同时也要注意Hibernate不会从web上面获取DTD文件,虽然XML里面的URL也许会建议它这样做,但是Hibernate会首先查看你的程序的classpath。
DTD文件被包括在hibernate3.jar,同时也在Hibernate分发版的src/路径下。
在以后的例子里面,我们将通过省略DTD的声明来缩短代码长度。
但是显然,在实际的程序中,DTD声明是必须的。
在两个hibernate-mapping标签(tag)中间, 我们包含了一个 class元素(element)。
所有的持久性实体类(persistent entity classes)(再次声明,这里也包括那些依赖类,就是那些次要的实体)都需要一个这样的映射,来映射到我们的SQL database。
<hibernate-mapping><class name="Event" table="EVENTS"></class></hibernate-mapping>我们到现在为止做的一切是告诉Hibernate怎样从数据库表(table)EVENTS里持久化和加载Event类的对象,每个实例对应数据库里面的一行。
现在我们将继续讨论有关唯一标识属性(unique identifier property)的映射。
另外,我们不希望去考虑怎样产生这个标识属性,我们将配置Hibernate的标识符生成策略(identifier generation strategy)来产生代用主键。
<hibernate-mapping><class name="Event" table="EVENTS"><id name="id" column="EVENT_ID"><generator class="increment"/></id></class></hibernate-mapping>id元素是标识属性(identifer property)的声明, name="id" 声明了Java属性(property)的名字- Hibernate将使用getId()和setId()来访问它。
字段参数(column attribute)则告诉Hibernate我们使用EVENTS表的哪个字段作为主键。
嵌套的generator元素指定了标识符的生成策略-在这里我们使用increment,这个是非常简单的在内存中直接生成数字的方法,多数用于测试(或教程)中。
Hibernate同时也支持使用数据库生成(database generated),全局唯一性(globally unique)和应用程序指定(application assigned)(或者你自己为任何已有策略所写的扩展)这些方式来生成标识符。
最后我们还必须在映射文件里面包括需要持久化属性的声明。
缺省的情况下,类里面的属性都被视为非持久化的:<hibernate-mapping><class name="Event" table="EVENTS"><id name="id" column="EVENT_ID"><generator class="increment"/></id><property name="date" type="timestamp" column="EVENT_DATE"/> <property name="title"/></class></hibernate-mapping>和id元素类似,property元素的name参数告诉Hibernate使用哪个getter和setter方法。