09. Hibernate note
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教程---看这一篇就够了
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部分学习笔记讲师:梁建全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框架用法
hibernate框架用法
Hibernate框架是一个开源的对象关系映射(ORM)框架,它可以
将Java对象映射到关系数据库中的表中,从而使得开发人员可以使用Java编程语言来访问和操作数据库。
Hibernate的使用流程如下:
1. 在Java类中定义实体对象及其属性和关系;
2. 在Hibernate中配置映射文件,将实体类映射为数据库表;
3. 通过Session API实现数据的增删改查操作。
Hibernate框架的优点有:
1. 开发效率高:Hibernate自动处理对象与数据库表之间的映射,使得开发人员可以将精力集中在业务逻辑上。
2. 数据库平台无关性好:Hibernate提供了一套底层数据库操作
接口,在数据操作层面上实现了面向对象与关系数据库的交互。
3. 透明性强:Hibernate框架屏蔽了大部分JDBC的细节,对于开发人员而言可以专注于业务需求的实现。
4. 高性能:Hibernate框架缓存机制、懒加载等一些优化措施,
可以改善数据库访问的性能。
同时,Hibernate还提供了一些高级特性,如事务管理、二级缓存、查询缓存、延迟加载等,可以更好地满足复杂应用的需要。
Hibernate 学习笔记 知识总结
HibernateNote一、hibernate与db中数据类型对照(xml方式)1.与ORACLE常用数据类型对照背景为灰色的表示常用,熟记。
2.与MySql数据类型对照背景为灰色的表示常用,熟记。
2.1 hibernate mysql基本类型映射2.2 Java 时间和日期类型的Hibernate 映射二、Hibernate关系配置1.annotation基本类型配置配置、Jar 包等:a) hibernate annotaion jarb) ejb3 persistence jarc) hibernate common-annotations.jarFAQ: @不给提示,配置eclipse属性信息content assist-activation--加上@通过@Basic 可以声明属性的存取策略:@Basic(fetch=FetchType.EAGER) 即时获取(默认的存取策略)@Basic(fetch=ZY) 延迟获取通过@Temporal 定义映射到数据库的时间精度:@Temporal(TemporalType=DATE) 日期@Temporal(TemporalType=TIME) 时间@Temporal(TemporalType=TIMESTAMP) 两者兼具2.annotation列属性映射使用@Column 映射到列@Column(name="columnName"; // 可选,列名(默认是属性名)boolean unique() default false; // 可选,是否在该列上设置唯一约束(默认false)boolean nullable() default true; // 可选,是否可以为空boolean insertable() default true; // 可选,该列是否作为生成insert语句中的一列boolean updatable() default true; // 可选,该列是否作为生成update语句中的一列String columnDefinition() default ""; // 可选,为这个特定列覆盖SQL DDL 片段(可能导致无法在不同数据库间移植)String table() default ""; // 可选,定义对应的表,默认为主表int length() default 255; // 可选,列长度int precision() default 0; // 可选,列十进制精度(decimal precision)int scale() default 0; // 可选,列十进制数范围(decimal scale)public class Person {@Column(name = "PERSONNAME", unique = true, nullable = false, updatable = true)private String name;@Column(name = "PHOTO", columnDefinition = "BLOB NOT NULL", secondaryTable="PER_PHOTO")private byte[] picture;}3.联合主键:必须实现po层Serializable接口<class name="Student" table="t_student"><composite-id name="studentId" class="StudentId"><key-property name="firstName" length="20"></key-property><key-property name="lastName" length="20"></key-property></composite-id><property name="pwd" length="20"></property>4.组合关系<class name="User" table="t_user" ><id name="id"><generator class="native"></generator></id><property name="name"></property><property name="phone" column="dianhua" length="30"></property><component name="address" class="Address" ><property name="city"></property><property name="street"></property><property name="zipcode"></property></component></class>5.一对多,多对一5.1 xml格式的:一方:<class name="Department" table="t_dept"><id name="id" ><generator class="native"></generator></id><property name="dname" length="20"></property><set name="employees" ><key><column name="department_id"></column></key><one-to-many class="Employee"/></set></class>多方:<class name="Employee" table="t_emp"><id name="id"><generator class="native"></generator></id><property name="ename"></property><many-to-one name="department" class="Department" column="department_id"></many-to-one>5.2 annotation方式的:多方:@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String mname;@ManyToOneprivate Student student;一方:@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String sname;private String pwd;@OneToMany(mappedBy="student")private Set<Money> moneys;6.一对一外键关联6.1 xml格式的:<class name="Address" table="t_address" ><id name="id"><generator class="native"></generator></id><property name="aname" length="20"></property><one-to-one name="company" class="Company" property-ref="address"></one-to-one> </class><class name="Company" table="t_com" >外键生成<id name="id"><generator class="native"></generator></id><property name="cname" length="20"></property><many-to-one name="address" class="Address" cascade="save-update"><column name="address_id" unique="true"></column></many-to-one></class>6.2 annotation格式的:@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String cname;@OneToOne(cascade=CascadeType.ALL)@JoinColumn(name="student_id",unique=true)private Student student;@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String sname;@OneToOne(mappedBy="student")private Course course;6.3 一对一主键关联annotation格式的:@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String cname;private Integer age;private String des;@OneToOne(cascade=CascadeType.ALL)@PrimaryKeyJoinColumnprivate Student student;@Id@GenericGenerator(name="cc",strategy="foreign",parameters={@Parameter(name="property",value="cour se")})@GeneratedValue(generator="cc")private Integer id;private String sname;private Integer age;private String des;@OneToOne(mappedBy="student",cascade=CascadeType.ALL)private Course course;7.多对多7.1 xml格式的:xml格式的:<class name="Course" table="t_course"><id name="id" ><generator class="native"></generator></id><property name="cname" length="20"></property><set name="students" table="student_course"><key><column name="course_id"></column></key><many-to-many class="Student" column="student_id"></many-to-many></set></class><class name="Student" table="t_student"><id name="id" ><generator class="native"></generator></id><property name="sname" length="20"></property><set name="courses" table="student_course"><key><column name="student_id"></column></key><many-to-many class="Course" column="course_id"></many-to-many></set></class>7.2 annotation格式的:@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String mname;@ManyToMany(mappedBy="moneys")private Set<Student> students;@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String sname;private String pwd;@ManyToManyprivate Set<Course> moneys;8.其他8.1不需要psersistence的字段a) Annotation:@Transientb) xml不写8.2映射日期与时间类型,指定时间精度a) Annotation:@Temporal(参数) 参数有3种只显示时间,只显示日期,时间日期都显示//@Temporal(TemporalType.DATE) 只显示日期//@Temporal(TemporalType.TIME) 只显示时间//@Temporal(TemporalType.TIMESTAMP) 显示日期与时间b) xml:指定type<class name="Teacher" table="Teacher" ><id name="id" column="id"></id>property name="name" type="time" /></class>三、hibernate序列Sequence<id name="id" ><generator class="native"></generator></id>其他常用的序列生成方式1.<generator class="sequence"/>这是一个非常简单的接口;某些应用程序可以选择提供他们自己特定的实现。
hibernate笔记
步步为营Hibernate全攻略(一)构建Hibernate框架环境任何一项新技术的出现都有它的必然性,Hibernate也不例外,所以在掌握Hibernate的具体应用之前我们一定先要了解Hibernate是什么?使用Hibernate会给我们的程序开发带来哪些好处?使用Hibernate的好处简单来讲体现在以下几个方面:1. Hibernate说白了就是对持久层进行的封装,它简化了对数据库的操作,使得我们可以以对象方式直接访问数据库中的数据。
实现了完全的OO思想。
2. 另外由于Hibernate对JDBC的彻底封装,使得我们可以不用在程序中写传统的sql语句便能实现对数据库的各种操作,极大的提高了生产力。
3. Hibernate支持MySQL,SQL Server等多种数据库。
Hibernate提供了多种数据库的接口,只要更改配置信息可以实现对不同数据库的操作,换句话说也就是你可以轻视的实现数据库更换。
说了这么多Hibernate的好处,那Hibernate到底该怎样用呢?别急下面我们就来看看Hibernate环境是如何搭建起来的。
1. 建立Java项目(也可以是java web项目)。
2. 导入相关jar包。
导入jar包的方式可以有两种。
第一种是直接添加外部jar包,也就是我们的“Add External JARs”。
另外一种是先建立自己的jar包库,然后向新建的库中加入jar包,如果使用这种方式最后一定不要忘记将建好的库引入到项目中。
两种方式均可,但一般更推荐第二种方式。
加入的jar包主要有以下这些:2.1在Hibernate_Home/lib/路径下的所有jar包。
2.2加入Hibernate核心jar包:hibernate3.jar。
2.3加入所使用的数据库的JDBC驱动包。
使用MySQL数据库则加入MySQL数据库驱动mysql-connector-java-3.1.13-bin.jar。
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 教程
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 之前,需要先创建一个会话工厂。
会话工厂负责创建会话对象,会话对象用于与数据库进行交互。
hibernate总结
Hibernate读书笔记-----Hibernate知识总结2012-07-16 11:24:31 我来说两句收藏我要投稿利用一个星期(实际上是两个星期的上午)的时间终于是结束了Hibernate,本来在四月份就可以结束的,但是由于为期一个月的实习,加上各种考试、三个课程设计,hibernate 的学习一直都是断断续续的,等到暑假有时间了,也差不多都忘记了,于是只有从头开始了。
下面是我就这个星期所学的知识的一个简要的总结。
一、Hibernate开发流程Hibernate是一个面向java环境的对象/关系数据库映射工具,用来把对象模型表示的对象映射到基于SQL的关系模型数据结构中去。
主要是完成面向对象的编程语言到关系型数据库的映射Hibernate的开发流程一般有如下几个步骤:1、编写domain对象:持久化类。
2、加入hibernate.jar和其依赖的包。
3、编写XX.hbm.xml映射文件。
4、编写hibernate.cfg.xml配置文件。
必须要提供以下几个参数:connection.driver_class、connection.url、ername、connection.password、dialect、hbm2ddl.auto。
5、编写HibernateUtil工具类、主要用于完成hibernate的初始化过程和提供一个获得session的方法(可选)。
6、编写实现类。
二、Hibernate的体系结构Hibernate有如下三种体系结构:非常简要的Hibernate体系结构的概要图:从这个图可以看出,Hibernate使用数据库和配置信息来为应用程序提供持久化服务(以及持久的对象)。
轻型”的体系结构方案,它要求应用程序提供自己的JDBC 连接并管理自己的事务全面解决”的体系结构方案,将应用层从底层的JDBC/JTA API中抽象出来,而让Hibernate来处理这些细节。
三、Hibernate的持久化类Hibernate采用完全面向对象的方式来操作数据库,通过Hibernate的支持,我们只需要管理对象的状态,无须关心底层数据库系统的细节。
hibernate常用方法
hibernate常用方法Hibernate是一个开源的对象-关系映射框架,用于简化Java应用程序与数据库之间的交互。
Hibernate提供了丰富的API来执行通用的数据库操作,包括插入、更新、删除和查询。
下面是Hibernate常用的方法:1. save(:将一个新的对象插入到数据库中,返回一个唯一标识符。
2. update(:更新数据库中的一个对象。
3. delete(:从数据库中删除一个对象。
4. get(:根据给定的唯一标识符查询数据库中的一个对象。
5. load(:根据给定的唯一标识符查询数据库中的一个对象并加载它。
6. saveOrUpdate(:根据对象的状态来决定是插入还是更新数据库中的对象。
7. merge(:将给定对象的状态合并到数据库中的对象。
8. persist(:将一个新的对象插入到数据库中,并立即执行同步。
9. lock(:锁定一个对象,防止其他会话对其进行修改。
10. clear(:清除会话缓存中的所有对象。
11. evict(:从会话缓存中移除给定的对象。
12. refresh(:强制会话重新从数据库中加载对象的状态。
13. flush(:将会话缓存中的所有操作发送到数据库中。
14. Criteria API:用于创建复杂的查询条件。
15. HQL(Hibernate Query Language):类似于SQL的查询语言,用于查询对象。
16. Native SQL:直接执行SQL语句来操作数据库。
17. Transaction API:用于管理事务的开始、提交和回滚。
18. Session API:用于管理Hibernate会话的生命周期。
19. SessionFactory API:用于创建和销毁Hibernate会话工厂。
20. Dialect API:用于不同数据库间的差异性处理。
这些方法涵盖了Hibernate的核心功能,开发者可以根据具体的需求选择合适的方法来操作数据库。
Hibernate完整文档
认识Hibernate的基本组件
实体类 实体类映射文件 Hibernate配置文件 辅助工具
Configuration
Configuration 类负责管理Hibernate 的配置信息。它包括如 下内容:
Hibernate运行的底层信息:数据库的URL、用户名、密码、JDBC驱动 类,数据库Dialect,数据库连接池等 Hibernate映射文件(*.hbm.xml)
创建持久化类 User.java
public class User { private long userId; private String userName; private String password; ….. }
Hibernate体验
创建类的映射文件 – User.hbm.xml
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="er“ table="T_User"> <id name="userId" type="long" column="User_ID"> <generator class=“identity"/> </id> <property name="userName" type=“string" column="User_Name"/> <property name="password" type=“string" column="Password"/> </class> </hibernate-mapping>
hibernate笔记
configuration.addClass(Customer.class);sf = configuration.buildSessionFactory();}(2)新增保存:save方法/**保存*/@Testpublic void save(){Session s = sf.openSession();Transaction tr = s.beginTransaction();Customer c = new Customer();c.setName("洪七公");c.setAge(60);c.setDes("帮助");s.save(c);mit();//实质上执行了2步操作,1:s.flush();//清理缓存,让session缓存中的数据与数据库同步,2:事务提交s.close();//Session的缓存就没有了}(3)更新:update方法/**更新*/@Testpublic void update(){Session s = sf.openSession();Transaction tr = s.beginTransaction();Customer c = new Customer();c.setId(3);c.setName("黄老邪");c.setAge(59);c.setDes("药师");s.update(c);mit();s.close();}(4)删除:delete方法@Testpublic void delete(){Session s = sf.openSession();Transaction tr = s.beginTransaction();Customer c = new Customer();c.setId(3);s.delete(c);mit();s.close();}(5)查询:get和load方法/**使用ID查询信息*/@Testpublic void findCustomerById(){Session s = sf.openSession();Transaction tr = s.beginTransaction();Customer c = (Customer) s.get(Customer.class, 2);System.out.println(c.getId()+" "+c.getName()+""+c.getAge()+" "+c.getDes());mit();s.close();}(6)查询:query查询(支持hql语句,sql语句,qbc语句)/**查询所有信息*/@Testpublic void findAllCustomerList(){Session s = sf.openSession();Transaction tr = s.beginTransaction();/**使用Hql语句:操作持久对象和属性* 复习sql语句:操作数据库表和数据库表的列*/Query query = s.createQuery("from Customer o");List<Customer> list = query.list();if(list!=null && list.size()>0){for(Customer c:list){System.out.println(c.getId()+" "+c.getName()+" "+c.getAge()+" "+c.getDes());}}mit();s.close();}●hibernate在内存地址中存在一个一级缓存,存在在一级缓存中的对象,就说明该对象具有了持久化的能力,如果对象具有持久化能力就能操作数据库。
详细介绍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缓存分为三个级别:- 一级缓存:也称为会话缓存,位于会话对象中,缓存在会话的生命周期内,减少对数据库的访问。
hibernate教程
hibernate教程Hibernate是一个开源的Java持久化框架,它提供了一种优雅而简单的方式来将Java对象映射到关系型数据库中。
它实现了Java持久化API(JPA)的规范,为企业级应用程序提供了强大的对象-关系映射(ORM)功能。
Hibernate的主要目标是提供一种简单的、高效的数据持久化解决方案。
使用Hibernate,开发人员可以通过Java编程语言,以面向对象的方式来处理数据库操作。
它消除了传统JDBC代码中的大量重复工作,使得开发更简洁、高效。
Hibernate采用了ORM的思想,即通过将Java类和数据库表进行映射来实现对象持久化。
通过使用Hibernate的注解或XML配置文件,我们可以定义Java类和数据库表之间的映射关系,Hibernate将负责创建数据库表、插入数据、查询数据等操作。
这种方式使得开发人员可以只关注业务逻辑,而不必关心具体的数据操作细节。
Hibernate提供了一套强大的查询语言——Hibernate Query Language(HQL),类似于SQL语言,但更加面向对象。
使用HQL,我们可以通过操作Java对象来进行查询,而不是直接操作数据库。
这样可以更加简化查询操作,并使得查询语句更易于维护。
除了HQL之外,Hibernate还支持原生的SQL查询,以及Criteria查询等方式。
Criteria查询提供了一种编程方式来创建查询条件,可以更加直观地表示查询条件,而不必编写复杂的查询语句。
Hibernate具有自动事务管理的能力,可以自动管理数据库事务的打开、提交和回滚。
开发人员只需要在需要进行事务操作的方法上添加@Transactional注解,Hibernate将负责管理事务的生命周期,使得开发更加方便。
Hibernate还提供了缓存机制,可以将经常查询的数据缓存在内存中,提高查询性能。
它支持一级缓存和二级缓存,一级缓存是与Session绑定的,而二级缓存是与SessionFactory绑定的。
Hibernate学习资料2009226
Hibernate 初识构建Hibernate 基础代码1.POJOPOJO 在Hibernate 语义中理解为数据库表所对应的Domain Object。
这里的POJO就是所谓的“P lain Ordinary J ava O bject”,字面上来讲就是无格式普通Java 对象,简单的可以理解为一个不包含逻辑代码的值对象(Value Object 简称VO)。
2.Hibernate 映射文件Hibernate 从本质上来讲是一种“对象-关系型数据映射”(O bject R elational M apping 简称ORM)。
前面的POJO 在这里体现的就是ORM中Object层的语义,而映射(Mapping)文件则是将对象(Object)与关系型数据(R elational)相关联的纽带,在Hibernate中,映射文件通常以“.hbm.xml”作为后缀。
由数据库产生基础代码通过Hibernate官方提供的MiddleGen for Hibernate 和Hibernate_Extension工具包,我们可以很方便的根据现有数据库,导出数据库表结构,生成ORM和POJO1) 首先,将Middlegen-Hibernate软件包解压缩(如解压缩到C:\Middlegen\ )。
2) 配置目标数据库参数进入MiddleGen 目录下的\config\database 子目录,根据我们实际采用的数据库打开对应的配置文件。
如这里我们用的是mysql数据库,对应的就是mysql.xml文件。
<property name="database.script.file"value="${src.dir}/sql/${name}-mysql.sql"/><property name="database.driver.file"value="${lib.dir}/mysql.jar"/><property name="database.driver.classpath"value="${database.driver.file}"/><property name="database.driver"value="org.gjt.mm.mysql.Driver"/><property name="database.url"value="jdbc:mysql://localhost/sample"/><property name="erid"value="user"/><property name="database.password"value="mypass"/><property name="database.schema"value=""/><property name="database.catalog"value=""/><property name="jboss.datasource.mapping"value="mySQL"/>修改MiddleGen 根目录下的build.xml 文件,此文件是Middlegen-Hibernate 的Ant构建配置。
hibernate 字段 注解 -回复
hibernate 字段注解-回复Hibernate是一个开源的Java持久化框架,用于将Java对象映射到关系数据库中。
在Hibernate中,可以使用注解来定义实体类与数据库表之间的映射关系。
本文将详细介绍Hibernate中字段注解的使用方法与作用。
首先,让我们了解一下Hibernate中常用的字段注解:1. @Column2. @Id3. @GeneratedValue4. @UniqueConstraint5. @JoinColumn6. @OneToOne7. @OneToMany8. @ManyToOne9. @ManyToMany10. @Transient接下来,我们逐一解释这些注解的作用和使用方法。
1. @Column注解用于将实体类的属性与数据库表中的列进行映射。
可以使用该注解定义列的名称、长度、是否允许为空等。
2. @Id注解用于标识实体类的主键属性。
3. @GeneratedValue注解用于定义主键的生成策略。
可以使用该注解指定生成策略为自增长、UUID、序列等。
4. @UniqueConstraint注解用于定义表的唯一约束条件。
可以使用该注解指定一个或多个字段的唯一性。
5. @JoinColumn注解用于定义实体类之间的关联关系。
可以使用该注解指定外键列的名称、关联表的名称等。
6. @OneToOne注解用于定义一对一的关联关系。
可以使用该注解指定关联的实体类属性、关联的外键列等。
7. @OneToMany注解用于定义一对多的关联关系。
可以使用该注解指定关联的实体类属性、关联的外键列等。
8. @ManyToOne注解用于定义多对一的关联关系。
可以使用该注解指定关联的实体类属性、关联的外键列等。
9. @ManyToMany注解用于定义多对多的关联关系。
可以使用该注解指定关联的实体类属性、关联的中间表等。
10. @Transient注解用于标识实体类的属性不需要进行持久化操作。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
<property name="bal" column="BALANCE" not-null="true"/>
po -> (pojo)
-> oid(唯一,中性)
-> getters/setters
-> 构造方法
三、Hibernate核心API(理解)
Configuration类:
Configuration对象用于配置和启动Hibernate。Hibernate应用通过Configuration实例来指定对象-关系映射文
ACTNO varchar(20) not null unique,BALANCE number(20));
步骤二:持久化类的设计
POJO----
POJO 在Hibernate 语义中理解为数据库表所对应的Domain Object。(此类中只含有属性、构造方法、get/set方法)
</class>
</hibernate-mapping>
步骤四:Hibernate配置文件
hibernate.cfg.xml或hibernate.properties
1.需要配置那些信息:持久化映射,方言,特性,登陆信息
多数使用默认的设置。
2) Hibernate是非常优秀、成熟的O/R Mapping框架。它提供了强大的对象和关系数据库映射以及查询功能。
规范:
1.一个映射文件对应一个持久类(一一对应)
2.映射文件的名字和它所描述的持久类的名字保持一致
3.映射文件应该与它所描述的类在同一包中
这里的POJO就是所谓的“Plain Ordinary Java Object”,字面上来讲就是无格式普通Java 对象,
简单的可以理解为一个不包含逻辑代码的值对象(Value Object 简称VO)。
步骤三:持久化类和关系数据库的映射
编写*.hbm.xml文件
如果应用有同时访问多个数据库,则需为每个数据库创建一个单独的SessionFactory。
Session接口:
是Hibernate应用最广泛的接口。它提供了和持久化相关的操作,如添加,删除,更改,加载和查询对象。
1)它是线程不安全的,因此在设计软件架构时,应尽量避免多个线程共享一个Session实例。
现阶段最佳的持久化工具:文档齐全、服务很好、工业标准、大量应用、易学
优点:封装JBDC、简单的API、轻量级(只做持久化)(用类库)、PO(持久对象)->POJO(纯JAVA)、开源
缺点:不够JDBC灵活
SUN的WEB高级应用 JSF SessionBean Persistence
WEB国内流行开源 Struts Spring Hibernate
一、 对象持久化的理论
1.对象持久化:内存中的对象转存到外部持久设备上,在需要的时候还可以恢复。
"/hibernate-mapping-3.0.dtd">
<hibernate-mapping package=".entity"><!--package指文件所在的包名 -->
<generator class="hilo">
<param name="table">t_hi</param>
<param name="column">hi</param>
</generator></id>
二、 ORM和Hibernate的相关知识(理解)
1) ORM:Object Relational Mapping
对象-关系映射实现了面向对象世界中对象到关系数据库中的表的自动的(和透明的)持久化,
使用元数据(meta data)描述对象与数据库间的映射。
按hibernate规范编写名字为hibernate.cfg.xml文件(默认放在工程文件夹下)
步骤一:设计和建立数据库表
可以用Hibernate直接生成映射表。
Oracle里建表: create table t_ad (oid number(15) primary key,
polymorphism=“implicit | explicit” //设置多态是显性(explicit)的还是隐性(implicit)的
where=“查询时使用的SQL的条件子句” //查询时使用的SQL的条件子句
lazy=“true | false” //设置延迟加载策略
件的位置或者动态配置Hibernate的属性,然后创建SessionFactory实例。
SessionFactory接口:
一个SessionFactory实例对应一个数据存储源。应用从SessionFactory中获取Session实例。
1)它是线程安全的,这意味着它的一个实例能够被应用的多个线程共享。
Query和Criteria接口:
这两个是Hibernate的查询接口,用于向数据库查询对象,以及控制执行查询的过程。
Query实例包装了一个HQL查询语句。
Criteria接口完全封装了基于字符串形式的查询语句,比Query接口更面向对象。Criteria更擅长于执行动态查询。
2)Session实例是轻量级的,这意味着在程序可以经常创建和销毁Session对象,
例如为每个客户请求分配单独的Session实例。
原则:一个线程一个Session;一个事务一个Session。
Transaction接口:
是Hibernate的事务处理接口,它对底层的事务接口进行封装。
补充:find方法也提供数据查询功能,但只是执行一些简单的HQL查询语句的快捷方式(已过时),远没有Query接口强大!
四、Hibernate开发步骤:(重点:必须掌握)
开始:(设置环境变量和配置)
在myeclipse里导入Hibernate的文件包(包括各数据库的驱动和其他的jar包,对版本敏感,注意各版本的兼容)
/>
一个实体对应一个xml文件,组件用id,非组件用property。
*.hbm.xml文件样板:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
5.结论:
1)对象持久化是必须的
2)必须使用DB来实现
3)Hibernate必须的(现阶段最佳选择)
开源工具的通常问题:1.文档不全;2.服务不全;3.标准化不够 BC
优点:功能完备、理论上效率高
缺点:复杂(难)、代码量大、面向R(过程;二维表关系)
2) EJB 仅讲Entity Bean
优点:封装JDBC
A、dialect:方言,就是拼驱动程序和SQL语句。每种数据库对应一种方言。其实就是指定了用那一种数据库。
2)它是重量级的,这意味着不能随意创建或者销毁,一个数据库只对应一个SessionFactory。
通常构建SessionFactory是在某对象Bean的静态初始化代码块中进行。
如果应用只是访问一个数据库,只需创建一个SessionFactory实例,并且在应用初始化的时候创建该实例。
dynamic-update=“true | false” //是否动态更新SQL。false:每次都更新所有属性;true:只更新修改的
dynamic-insert=“true | false” //是否动态插入SQL。false:每次都插入所有属性;true:只插入非空的
select-before-update=“true | false” //是否在update前查询对象是否被修改过,修改过才update
---该文件配置持久化类和数据库表之间的映射关系
<class name=“POJO的类全路径” table=“对应的库表名” //这两项一定要配置,其它的都可以不配置
discriminator-value=“discriminator_value” //区分不同子类的值,多态时使用。默认与类名一样
<class name="Account" table="student"><!-- name:POJO类的名; table数据库里对应的表名-->
<id name="oid" column="OID"><!-- OID:(唯一,中性)表自动生成的(需要另外添加hilo表) -->
4) 检索(大规模) //也很重要
5) 管理(备份、安全)
3.怎样进行对象持久化?(仅从JAVA方面讲)
物理: 1) 对象序列化
2) DB技术(JDBC 数据库)
4.怎样利用数据库做对象持久化?
软件开发的分层思想:
三层架构:
数据表现层 业务逻辑层 数据持久层
SUN的桌面应用 Swing AWT 普通Java类 JDBC
SUN的WEB基本应用 JSP 普通Servlet JDBC