Hibernate笔记

关注

原创最新推荐文章于 2026-06-19 12:28:03 发布 1k 阅读 AI 写同款· GEO 优化 ›

hibernate配置文件 hibernate配置文件里面提供了连接数据库数据库使用的方言是否打印SQL语句 sql语句的格式以及对象-关系映射文件的地址等立即下载

Hibernate

 Hibernate 简单应用(单表)
1. 导入hibernate所需要的jar包:
antlr.jar:用来解析 HQL 语句。
cglib.jar:用来修改类。
asm.jar:在运行时候修改类。依赖于 cglib.jar。commons-collections:提供集合功能,比 java 类中的集合提供更强大的功能。commons-logging.jar:记录日志。jta.jar:分布式事务。当有跨数据库访问的时候,需要这个包。dom4j.jar:用来解析 XML 文件。
(记得导入数据库 jar 包)

2. 配置hibernate.cfg.xml文件(放在“src”下)

<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN""http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd

<hibernate-configuration><session-factory>

<propertyname="hibernate.dialect">

</property

org.hibernate.dialect.MySQLDialect

批注 [z1]: 数据库的方言。

批注 [z2]: 数据库驱动的名称。

批注 [z3]: 连接数据库的 URL 地址。批注 [z4]: 用户名。
批注 [z5]: 密码。

批注 [z6]: 每次加载 hibernate,重新创建数据库表结构,这就是导致数据库表数据丢失的原因。

批注 [z7]: 显示生成的 SQL 语句。批注 [z8]: 指定映射文件的路径。

<property
name="hibernate.connection.driver_class"> </prope

rty>
<property

name="hibernate.connection.url"> </property>

<mapping resource="

</session-factory></hibernate-configuration>

com.mysql.jdbc.Driver

jdbc:mysql:///zhaohan

</property>

root

</property>

123

create

true

com/it315/domain/User.hbm.xml

"/>

Validate:加载 hibernate 时,验证创建数据库表结构。
create:每次加载 hibernate,重新创建数据库表结构,这就是导致数据库表数据丢失的原因。

Hbm2ddl.auto 的配置参数:

传智博客—赵涵笔记 1

3. User.java

4. User.hbm.xml

create-drop:加载 hibernate 时创建,退出是删除表结构。update :加载 hibernate 自动更新数据库结构。

package com.it315.domain;import java.util.Date;public class User {

private long id;private String name;private Date birthday;......set,get方法省略

}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping

package=" ">

<class name="User" table="

</id>
<property name="name" column="

com.it315.domain

批注 [z9]: User.java 所在的包。
批注 [z10]: 与 User.java 映射的表名。

批注 [z11]: 由 hibernate 根据底层数据库自行判断采用identity,hilo,sequence 其中一种作为主键生成方式。

批注 [z12]: Name 属性对应生成表中的 user_name 字段。

UserTable

native

"></property>

user_name

</class></hibernate-mapping>

package com.it315.main;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;import com.it315.domain.User;

public class Main {
public static void main(String[] args) {

Configuration = new Configuration();

批注 [z13]: Configuration 实例会根据当前的数据库配置信息,构造SessionFactory 实例并返回。

cfg

5. Main.java

传智博客—赵涵笔记 2

批注 [z14]: 如果配置文件的名称不是默认的“hibernat e.cfg .xml”,那么 configure()方法要指定文件名。

批注 [z15]: Session 是持久层操作的基础,相当于 jdbc 中的 connection.

批注 [z16]: 对数据有更改的操作都要开启事务和提交事务。Hibernate默认的事务是关闭的。

SessionFactory sessionfactory =cfg. .buildSessionFactory();

Session = sessionfactory.openSession();

User user = new User();user.setName("zhaohan");user.setBirthday(new Date());
Transaction tc = session. ;

session.save(user);

tc.commit();}

}

configure()

session

beginTransaction()

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();}

}

package com.it315.main;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.Transaction;import com.it315.domain.User;
import com.it315.util.HibernateUtils;

Domain Object的限制:
○1 必须有一个无参数的构造方法。
○2 有无意义的表示符 id.(可选)
○3 非 final 的,对懒加载有影响。(可选)

注意 :初始化的代码是很耗资源的,所以将上面代码修改为:HibernateUtils.java

Main.java

传智博客—赵涵笔记 3

public class Main {
public static void main(String[] args) {

Session session = null;Transaction tc = null;try {

session = HibernateUtils.getSession();

User user = new User();user.setName("zhaohan");user.setBirthday(new Date());

tc = session.beginTransaction();session.save(user);
tc.commit();

} catch (Exception e) {if(tc != null){

tc.rollback();

throw new RuntimeException(e.getMessage(),e);}

} finally {
if(session != null){

session.close();}

}}

}

<id name="id"

unsaved-value="0"

批注 [z17]: 设置没有保存的对象的id 值为-1。调用 session 的
saveOr Updat e()方法,如果这个对象的 id 和设置的这个-1 是相等的,那么说明这个对象没有被保存过,就保存。如果不相等,那么就更新。

 注意:
Hibernate 中的几个重要方法:

○1 save 和 persist 的区别(在没有开启事务的前提下是有区别的,如果开启了事务,则效果是一样的。)

○1 save 在没有开启事务的前提下,会将数据插入数据库,但是当发现事务没有开启的话,插入的数据就会立刻回滚。

○2 persist 在没有开启事务的前提下,不会产生 insert 语句。○2 saveOrUpdate

○3 get 和 load 的区别
□1 调用 get()方法,会立刻访问数据库。生成 select 语句。
□2 调用 load()方法,返回一个代理对象,只有在取得对象属性的时候才会真正的去访

传智博客—赵涵笔记 4

问数据库。例如:

批注 [z18]: 得到的这个 user 对象,是从 User 类继承来的。

static User getUser(long id){Session session = null;

Transaction tc = null;

try {
session = HibernateUtils.getSession();
User user = (User)session.load(User.class, id);System.out.println( );

System.out.println(user.getName());

return user;
} catch (Exception e) {

if (tc != null) {tc.rollback();

throw new RuntimeException(e.getMessage(), e);}

} finally {
if (session != null) {

session.close();}

}

return null;}

user.getClass()

package com.it315.UserDaoImpl;

Hibernate 中的对象的几种状态:
○1 瞬时:数据库中没有数据与之对应,超过作用域会被 JVM 垃圾回收器回收,一般是 new

出来且与 session 没有关联的对象。
○2 持久:数据库中有数据与之对应,当前与 session 有关联,并且相关联的 session 没

有关闭,事务没有提交,持久对象状态发生改变 ,在事务提交时会影响到数据库

(hibernate 能检测到)。
○3 托管:数据库中有数据与之相应,但当前没有 session 与之关联。托管对象状态发生改

变,hibernate 不能检测到。

判断对象的状态是根据 session 判断的,看它与 session 是否关联。例如:刚查到的对象,在 session 还没有关闭之前,是持久状态,因为数据库中有数据与它对应,且相关联的 session 没有关闭,这时候修改它的属性,hibernate 能检测到。若在 session关闭之后,虽然数据库中也有数据与它相对应,但没有与 session 关联,所以变为托管状态。

 增,删,改,查:UserDaoImpl.java

传智博客—赵涵笔记 5

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;import com.it315.daoI.UserDaoI;import com.it315.domain.User;
import com.it315.util.HibernateUtils;

public class UserDaoImpl implements UserDaoI {Session session = HibernateUtils.getSession();

Transaction tc = null;

@Override
public void saveUser(User user) {

try {
tc = session.beginTransaction();session.save(user);
tc.commit();

} finally {
if (session != null) {

session.close();}

}}

@Override
public User findUserById(long id) {

try {
User user = (User) session.get(User.class, id);return user;

} finally {
if (session != null) {

session.close();}

}}

@Override
public User findUserByName(String name) {

try {
Query q = session

.createQuery("from User as user where user.name =?");q.setString(0, name);

传智博客—赵涵笔记 6

");

/*Query q = session
.createQuery("from User as user where user.name

q.setString("*/

User user = (User) q.uniqueResult();

name

批注 [z19]: name 是随便起的。

批注 [z20]: 和上面批注的 name 保持一致。

name

", name);

return user;} finally {

if (session != null) {session.close();

}}

}

@Override
public void updateUser(User user) {

try {
tc = session.beginTransaction();session.update(user);tc.commit();

} finally {
if (session != null) {

session.close();}

}}

public void saveOrUpdate(User user){try {

tc = session.beginTransaction();session.saveOrUpdate(user);tc.commit();

} finally {
if (session != null) {

session.close();}

}}

@Override
public void remove(User user) {

try {
tc = session.beginTransaction();

传智博客—赵涵笔记 7

session.delete(user);

tc.commit();} finally {

if (session != null) {session.close();

}}

package com.it315.test;import java.util.Date;
import org.junit.BeforeClass;import org.junit.Test;

import com.it315.UserDaoImpl.UserDaoImpl;import com.it315.daoI.UserDaoI;
import com.it315.domain.User;

public class UserDaoImplTest {static UserDaoI dao = null;static User user = null;

@BeforeClass
public static void setUpBeforeClass() throws Exception {

dao = new UserDaoImpl();
user = new User();user.setName("zhangsan");user.setBirthday(new Date());

}

@Test
public void testFindUserById() {

User user = dao.findUserById(19);

System.out.println(user.getName());}

@Test
public void testFindUserByName() {

User user = dao.findUserByName("mali");

System.out.println(user.getBirthday());}

@Test

Test.java

传智博客—赵涵笔记 8

public void testRemove() {user.setId(19);dao.remove(user);

}

@Test
public void testSaveUser() {

dao.saveUser(user);}

@Test
public void testUpdateUser() {

user.setId(19);user.setName("maik");dao.updateUser(user);

}}

package com.it315.domain;public class Department {

private int id;private String name;get(),set()方法省略......

}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping

package="com.it315.domain">
<class name="Department" table="Department">

</id>

</hibernate-mapping>

 关联和集合的映射
1. 多对一(Employee-Department)○1 Department.java

○2 Department.hbm.xml

传智博客—赵涵笔记 9

○3 Employee.java

○4 Employee.hbm.xml

批注 [z21]: 员工与部门之间是多对一的关系。在这里将 Employee.java里的 depart 属性映射为 Employee 表中的 depart_id 字段。

默认是与部门的 id 进行关联,如果想指定关联的字段:<many-to-one name="depart"column= "depa rt_id "

propert y-ref ="nam e"/>

package com.it315.domain;public class Employee {

private int id;
private String name;private int age;
private Department depart;get(),set()方法省略......
}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping

package="com.it315.domain">
<class name="Employee" table="Emlpoyee">

</id>
<property name="name" column="employee_name"></property><property name="age" column="employee_age"></property>
< column="depart_id" />

</class></hibernate-mapping>

many-to-one name="depart"

......

<mapping resource="com/it315/domain/Department.hbm.xml"/><mapping resource="com/it315/domain/Employee.hbm.xml"/>......

package com.it315.test;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;import com.it315.domain.Department;import com.it315.domain.Employee;import com.it315.util.HibernateUtils;

○5 hibernate.cfg.xml

○6 Test.java

传智博客—赵涵笔记 10

批注 [z22]: 清除一级缓存。读取数据时默认是先去一级缓存中查询,一级缓存中没有的话才去数据库里查询。

public class Test {
public static void main(String[] args) {

Session session = null;Transaction tc = null;try {

session = HibernateUtils.getSession();tc = session.beginTransaction();

Department depart = new Department();depart.setName("JiShu");

session.save(depart);

Employee emp = new Employee();emp.setAge(20);emp.setName("zhaohan");emp.setDepart(depart);

session.save(emp);

session. ;

System.out.println("----------------------------");

Employee emp1 = (Employee)session.get(Employee.class,emp.getId());

System.out.println(emp1.getName());

tc.commit();

} finally {
if (session != null) {

session.close();}

}}

}

clear()

Hibernate: insert into Department (department_name) values (?)Hibernate: insert into Emlpoyee (employee_name, employee_age, depart_id)values (?, ?, ?)
----------------------------
zhaohan
JiShu

不调用 clear()方法输出的语句是:

传智博客—赵涵笔记 11

掉用 clear()方法输出的语句是:

Hibernate: insert into Department (department_name) values (?)Hibernate: insert into Emlpoyee (employee_name, employee_age, depart_id)values (?, ?, ?)
----------------------------
Hibernate: select employee0_.id as id1_0_, employee0_.employee_name asemployee2_1_0_, employee0_.employee_age as employee3_1_0_,employee0_.depart_id as depart4_1_0_ from Emlpoyee employee0_ whereemployee0_.id=?
zhaohan
Hibernate: select department0_.id as id0_0_,department0_.department_name as department2_0_0_ from Departmentdepartment0_ where department0_.id=?
JiShu

CREATE TABLE `department` (
`id` int(11) NOT NULL auto_increment,`department_name` varchar(255) default NULL,PRIMARY KEY (`id`)

) ENGINE=InnoDB DEFAULT CHARSET=gbk;

CREATE TABLE `emlpoyee` (
`id` int(11) NOT NULL auto_increment,
`employee_name` varchar(255) default NULL,
`employee_age` int(11) default NULL,
`depart_id` int(11) default NULL,
PRIMARY KEY (`id`),
KEY `FK44624656163671D3` (`depart_id`),
CONSTRAINT `FK44624656163671D3` FOREIGN KEY (`depart_id`) REFERENCES

`department` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

package com.it315.domain;import java.util.Set;

public class Department {
private int id;
private String name;
private Set<Employee> employee;get(),set()方法省略......

表的定义语句为:

2. 一对多(Department-Employee)○1 Department.java

传智博客—赵涵笔记 12

}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.it315.domain">

<key column="

<one-to-many class="Employee" /></set>

</class></hibernate-mapping>

employee

批注 [z23]: 映射 Department 的employee 属性,它的类型是 set 类型。

批注 [z24]: 生成外键的字段名。(注意这个字段名要和 Employee 表中定义的外键字段名相同。)

depart_id

" />

package com.it315.domain;public class Employee {

private int id;
private String name;private int age;
private Department depart;get(),set()方法省略......

}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping

package="com.it315.domain">
<class name="Employee" table="Emlpoyee">

</id>
<property name="name" column="employee_name" /><property name="age" column="employee_age" /><many-to-one name="depart" column=" "/>

批注 [z25]: 这个字段名要和Department.hbm.xml 里 set 集合映射的 key 的字段名相同。

depart_id

○2 Department.hbm.xml

○3 Employee.java

○4 Employee.hbm.xml

传智博客—赵涵笔记 13

</class></hibernate-mapping>

package com.it315.test;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.Transaction;import com.it315.domain.Department;import com.it315.domain.Employee;import com.it315.util.HibernateUtils;

public class Test {
public static void main(String[] args) {

save();

test();

}
static void save() {

Session session = null;Transaction tc = null;try {

session = HibernateUtils.getSession();tc = session.beginTransaction();

Department depart = new Department();depart.setName("jishu");session.save(depart);

Set<Employee> set = new HashSet<Employee>();

Employee emp = new Employee();emp.setAge(20);emp.setName("lisa");emp.setDepart(depart);session.save(emp);set.add(emp);

Employee emp1 = new Employee();emp1.setAge(21);emp1.setName("zhangsan");emp1.setDepart(depart);session.save(emp1);set.add(emp1);

○5 Test.java

传智博客—赵涵笔记 14

System.out.println("-------------------");depart.setEmployee(set);
tc.commit();

} finally {
if (session != null) {

session.close();}

}}

static void test() {Session session = null;try {

session = HibernateUtils.getSession();

Department depart =(Department)session.get(Department.class, 1);

Set<Employee> set = depart.getEmployee();for(Employee emp : set){

System.out.println(emp.getName());}

} finally {
if(session != null){

session.close();}

}}

}

Hibernate: insert into Department (department_name) values (?)Hibernate: insert into Emlpoyee (employee_name, employee_age, depart_id)values (?, ?, ?)
Hibernate: insert into Emlpoyee (employee_name, employee_age, depart_id)values (?, ?, ?)
-------------------
Hibernate: update Emlpoyee set depart_id=? where id=?
Hibernate: update Emlpoyee set depart_id=? where id=?
Hibernate: select department0_.id as id0_0_,

○6 运行结果:

传智博客—赵涵笔记 15

department0_.department_name as department2_0_0_ from Departmentdepartment0_ where department0_.id=?
Hibernate: select employee0_.depart_id as depart4_1_, employee0_.id asid1_, employee0_.id as id1_0_, employee0_.employee_name asemployee2_1_0_, employee0_.employee_age as employee3_1_0_,employee0_.depart_id as depart4_1_0_ from Emlpoyee employee0_ whereemployee0_.depart_id=?

zhangsanlisa

CREATE TABLE `department` (
`id` int(11) NOT NULL auto_increment,`department_name` varchar(255) default NULL,PRIMARY KEY (`id`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

`department` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

package com.it315.domain;

public class Room {private int id;private int floor;private Door door;get(),set()方法省略......}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

表的定义语句为:

3. 一对一(Room-Door)○1 Room.java

○2 Room.hbm.xml

传智博客—赵涵笔记 16

批注 [z26]: 通过外键生成主键。

批注 [z27]: 告诉当前表主键上存在一个约束。

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.it315.domain">

</class></hibernate-mapping>

package com.it315.domain;

public class Door {private int id;private int number;private Room room;get(),set()方法省略......}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.it315.domain">

</id>
<property name="number" />
<one-to-one name="room" />

</class></hibernate-mapping>

foreign

constrained="true"

package com.it315.test;
import org.hibernate.Session;import org.hibernate.Transaction;import com.it315.domain.Door;import com.it315.domain.Room;

○3 Door.java

○4 Door.hbm.xml

○5 Test.java

传智博客—赵涵笔记 17

import com.it315.util.HibernateUtils;

public class Test {
public static void main(String[] args) {

add();

select();

}

public static void add() {Session session = null;Transaction tc = null;try {

session = HibernateUtils.getSession();tc = session.beginTransaction();

Room r = new Room();r.setFloor(1);

Door d = new Door();d.setNumber(2);d.setRoom(r);

session.save(r);session.save(d);

tc.commit();} finally {

if (session != null) {session.close();

}}

}

public static void select() {Session session = null;try {

session = HibernateUtils.getSession();
Room r = (Room) session.get(Room.class, 1);System.out.println(r.getDoor().getNumber());

} finally {
if (session != null) {

session.close();}

}

传智博客—赵涵笔记 18

}}

Hibernate: insert into room (floor) values (?)
Hibernate: insert into door (number, id) values (?, ?)
Hibernate: select room0_.id as id1_1_, room0_.floor as floor1_1_,door1_.id as id0_0_, door1_.number as number0_0_ from room room0_ leftouter join door door1_ on room0_.id=door1_.id where room0_.id=?
2

CREATE TABLE `room` (
`id` int(11) NOT NULL auto_increment,`floor` int(11) default NULL,
PRIMARY KEY (`id`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `door` (
`id` int(11) NOT NULL,
`number` int(11) default NULL,
PRIMARY KEY (`id`),
KEY `FK2F23AE66854F71` (`id`),
CONSTRAINT `FK2F23AE66854F71` FOREIGN KEY (`id`) REFERENCES `room`

(`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.it315.domain">

<many-to-one name="room" column="room_id" unique="true"/></class>

</hibernate-mapping>

结果:

表的定义语句为:

两张表共用一个主键,所以只执行了一条查询语句。一对一的另一种方法:

Door.hbm.xml

传智博客—赵涵笔记 19

表的定义语句为:

CREATE TABLE `room` (
`id` int(11) NOT NULL auto_increment,`floor` int(11) default NULL,
PRIMARY KEY (`id`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `door` (
`id` int(11) NOT NULL auto_increment,
`number` int(11) default NULL,
`room_id` int(11) default NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `room_id` (`room_id`),
KEY `FK2F23AEB8C4C155` (`room_id`),
CONSTRAINT `FK2F23AEB8C4C155` FOREIGN KEY (`room_id`) REFERENCES `room`

(`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

package com.it315.domain;import java.util.Set;

public class Teacher {
private int id;
private String name;
private Set<Student> students;get(),set()方法省略......

public String toString() {
return "id=" + this.id + "name=" + this.name + "students="

+ this.getStudents();

}}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.it315.domain">

这种写法其实是多对一加了一个限制,外键只允许有一个,所以才有一对一的效果。4. 多对多(teacher-student)

○1 Teacher.java

○2 Teacher.hbm.xml

传智博客—赵涵笔记 20

批注 [z28]: 生成表的名字。生成表中有两个字段,一个是 teacher 的 id,一个是 student 的 id.

</id>
<property name="name" column="teacher_name" /><set name="students" table=" ">

<many-to-many class="Student" column="student_id"/></set>

</class></hibernate-mapping>

teacher_student

package com.it315.domain;import java.util.Set;

public class Student {
private int id;
private String name;
private Set<Teacher> teachers;get(),set()方法省略......

public String toString() {
return "id=" + this.id + "name=" + this.name;

}}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.it315.domain">

<many-to-many class="Teacher" column="teacher_id" /></set>

</class></hibernate-mapping>

○3 Student.java

○4 Student.hbm.xml

○5 Test.java
传智博客—赵涵笔记 21

package com.it315.test;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.Transaction;import com.it315.domain.Student;import com.it315.domain.Teacher;import com.it315.util.HibernateUtils;

public class Test {
public static void main(String[] args) {

add();

select();}

static void add(){
Session session = null;Transaction ts = null;try{

session = HibernateUtils.getSession();ts = session.beginTransaction();

Set<Teacher> set1 = new HashSet<Teacher>();

Teacher teacher1 = new Teacher();teacher1.setName("t1");set1.add(teacher1);

Teacher teacher2 = new Teacher();teacher2.setName("t2");set1.add(teacher2);

Set<Student> set2 = new HashSet<Student>();

Student student1 = new Student();student1.setName("s1");set2.add(student1);

Student student2 = new Student();student2.setName("s2");set2.add(student2);

teacher1.setStudents(set2);teacher2.setStudents(set2);

传智博客—赵涵笔记 22

session.save(teacher1);session.save(teacher2);session.save(student1);session.save(student2);

ts.commit();

}finally{
if(session != null){

session.close();}

}}

static void select(){Session session = null;Transaction ts = null;try{

session = HibernateUtils.getSession();
ts = session.beginTransaction();
Teacher teacher = (Teacher)session.get(Teacher.class, 1);

System.out.println(teacher.getStudents());

}finally{
if(session != null){

session.close();}

}}

}

Hibernate: insert into Teacher (teacher_name) values (?)
Hibernate: insert into Teacher (teacher_name) values (?)
Hibernate: insert into Student (student_name) values (?)
Hibernate: insert into Student (student_name) values (?)
Hibernate: insert into teacher_student (teacher_id, student_id) values(?, ?)

Hibernate: insert into teacher_student (teacher_id, student_id) values(?, ?)
Hibernate: insert into teacher_student (teacher_id, student_id) values(?, ?)

Hibernate: insert into teacher_student (teacher_id, student_id) values

○6 运行结果:

传智博客—赵涵笔记 23

(?, ?)
Hibernate: select teacher0_.id as id0_0_, teacher0_.teacher_name asteacher2_0_0_ from Teacher teacher0_ where teacher0_.id=?
Hibernate: select students0_.teacher_id as teacher1_1_,students0_.student_id as student2_1_, student1_.id as id2_0_,student1_.student_name as student2_2_0_ from teacher_student students0_left outer join Student student1_ on students0_.student_id=student1_.idwhere students0_.teacher_id=?
[id=1name=s1, id=2name=s2]

CREATE TABLE `teacher` (
`id` int(11) NOT NULL auto_increment,`teacher_name` varchar(255) default NULL,PRIMARY KEY (`id`)

) ENGINE=InnoDB DEFAULT CHARSET=gbk;

CREATE TABLE `student` (
`id` int(11) NOT NULL auto_increment,`student_name` varchar(255) default NULL,PRIMARY KEY (`id`)

) ENGINE=InnoDB DEFAULT CHARSET=gbk;

CREATE TABLE `teacher_student` (
`teacher_id` int(11) NOT NULL,
`student_id` int(11) NOT NULL,
PRIMARY KEY (`student_id`,`teacher_id`),
KEY `FK2E2EF2DE7E54D71F` (`teacher_id`),
KEY `FK2E2EF2DE6DB98C7F` (`student_id`),
CONSTRAINT `FK2E2EF2DE6DB98C7F` FOREIGN KEY (`student_id`) REFERENCES

`student` (`id`),
CONSTRAINT `FK2E2EF2DE7E54D71F` FOREIGN KEY (`teacher_id`) REFERENCES

`teacher` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

package com.it315.domain;

public class Name {
private String firstName;private String lastName;get(),set()方法省略......

}

○7 表的定义语句:

5. 组件映射(user-name)○1 Name.java

传智博客—赵涵笔记 24

○2 User.java

○3 User.hbm.xml

批注 [z29]: 说明 name 属性是由firstName 和 lastName 两个属性组成。

package com.it315.domain;

public class User {private int id;private Name name;private int age;get(),set()方法省略......

}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.it315.domain">

</component>

</hibernate-mapping>

package com.it315.test;
import org.hibernate.Session;
import org.hibernate.Transaction;import com.it315.domain.Name;
import com.it315.domain.User;
import com.it315.util.HibernateUtils;

public class Test {
public static void main(String[] args) {

User user = new User();user.setAge(20);

Name name = new Name();name.setFirstName("zhang");name.setLastName("san");

○4 Test.java

传智博客—赵涵笔记 25

批注 [z30]: 表中会多加一个字段,用来记录保存数据的顺序,读取的时候就会按照这个字段上的值的顺序读取。

user.setName(name);

Session session = null;Transaction tc = null;try{

session = HibernateUtils.getSession();tc = session.beginTransaction();

session.save(user);

tc.commit();}finally{

if(session != null){session.close();

}}

CREATE TABLE `user` (
`id` int(11) NOT NULL auto_increment,`first_name` varchar(255) default NULL,`last_name` varchar(255) default NULL,`user_age` int(11) default NULL,PRIMARY KEY (`id`)

) ENGINE=InnoDB DEFAULT CHARSET=gbk;

......
<list name = “employee”>

<one-to-many class = “Employee” /></list>

......

<list-index column = “order_col” />

○5 表的定义语句

 讨论映射集合为什么用 set?......
private list employees;......

如果改用 list 的话,读取的时候就会按照保存的顺序读取,例如:

因为我们读取数据时候对读取的顺序并没有要求,所以不必要耗费系统资源用 list 读取。如果想用 list,但又不需要顺序的话,可以这样:

传智博客—赵涵笔记 26

批注 [z31]: Bag 的底层借助 List 实现,但却屏蔽了 List 的有序性。Bag集合为无序集,且允许出现重复元素,是 Hibernate 自定义的集合类型。

批注 [z32]: 表示放弃维护关系,默认是 false.

......
< name = “employee”>

<one-to-many class = “Employee” /></bag>

......

bag

......

teacher1.setStudents(set2);teacher2.setStudents(set2);student1.setTeachers(set1);student2.setTeachers(set1);

......
<set name="teachers" table="teacher_student" >

<many-to-many class="Teacher" column="teacher_id" /></set>

......

inverse="true"

static void save() {
Session session = null;

Transaction tc = null;try {

session = HibernateUtils.getSession();tc = session.beginTransaction();

Department depart = new Department();depart.setName("jishu");session.save(depart);

Set<Employee> set = new HashSet<Employee>();

 Inverse和cascade(Employee-Department)○1 在上面“多对多”的例子中,如果:

这样会报错,发生主键冲突。
这时候可以放弃学生的维护关系,这样在保存学生的时候就不会在中间表中产生数据。

One-to-many 维护关联关系就是更新外键;many-to-many 维护关联关系就是在中间表增减记录。

注意:配置 one-to-one 的对象不维护关联关系。
如果使用 List 的话,为了保持顺序,不能放弃对关系的维护。

○2 在上面“一对多”的例子中,将 Test.java 中的 save()方法改为:

传智博客—赵涵笔记 27

批注 [z33]: 设置级联保存和更新。当保存部门的时候,连同与它有关的其他对象信息一并保存。

Employee emp = new Employee();emp.setAge(20);emp.setName("lisa");emp.setDepart(depart);//session.save(emp);set.add(emp);

Employee emp1 = new Employee();emp1.setAge(21);emp1.setName("zhangsan");emp1.setDepart(depart);//session.save(emp1);set.add(emp1);

System.out.println("-------------------");depart.setEmployee(set);
tc.commit();

} finally {
if (session != null) {

session.close();}

}

<set name="employee" inverse="true"

</set>

cascade="save-update"

package com.it315.domain;

public class Skiller extends Employee {private String skill;get(),set()方法省略......

}

然后在 Department.hbm.xml 文件中:

一般对 many-to-one 和 many-to-many 不设置级联,在 one-to-one 和one-to-many 中设置级联。

 继承的映射○1 Skiller.java

传智博客—赵涵笔记 28

○2 Sales.java

○3 Employee.java

批注 [z34]: 普通员工的值是 0.

批注 [z35]: 定义了一个鉴别器,类型为 int 型,列名是 type.

批注 [z36]: 技术员工的值是 1,也可以都不赋值,如果不赋值的话,默认在表的字段中用包名+类名区分。

package com.it315.domain;

public class Sales extends Employee {private int sell;get(),set()方法省略......

}

package com.it315.domain;

public class Employee {private int id;private String name;private int age;

public String toString() {
return "id=" + this.id + "name=" + this.name;

}}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping

package="com.it315.domain">
<class name="Employee" table="Emlpoyee"

</id>

<property name="name" column="employee_name" /><property name="age" column="employee_age" /><subclass name="Skiller"

</subclass>

</class></hibernate-mapping>

discriminator-value="0"

discriminator-value="1"

○4 Employee.hbm.xml

传智博客—赵涵笔记 29

○5 Test.java

package com.it315.test;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;import com.it315.domain.Employee;import com.it315.domain.Sales;
import com.it315.domain.Skiller;import com.it315.util.HibernateUtils;

public class Test {
public static void main(String[] args) {

add();

select();}

static void add() {
Session session = null;Transaction tc = null;try {

session = HibernateUtils.getSession();tc = session.beginTransaction();

Employee em1 = new Employee();em1.setAge(20);em1.setName("el1");

Skiller em2 = new Skiller();em2.setAge(30);em2.setName("e2");em2.setSkill("skill");

Sales em3 = new Sales();em3.setAge(40);em3.setName("e3");em3.setSell(15);

session.save(em1);session.save(em2);session.save(em3);

tc.commit();} finally {

if (session != null) {

传智博客—赵涵笔记 30

session.close();}

}}

static void select() {Session session = null;try {

session = HibernateUtils.getSession();String hql = "from Employee";
Query q = session.createQuery(hql);System.out.println(q.list());

} finally {
if (session != null) {

session.close();}

}}

}

Hibernate: insert into Emlpoyee (employee_name, employee_age, type)values (?, ?, 0)
Hibernate: insert into Emlpoyee (employee_name, employee_age, skill,type) values (?, ?, ?, 1)

Hibernate: insert into Emlpoyee (employee_name, employee_age, sell, type)values (?, ?, ?, 2)
Hibernate: select employee0_.id as id0_, employee0_.employee_name asemployee3_0_, employee0_.employee_age as employee4_0_, employee0_.skillas skill0_, employee0_.sell as sell0_, employee0_.type as type0_ fromEmlpoyee employee0_

[id=1name=el1, id=2name=e2, id=3name=e3]

CREATE TABLE `emlpoyee` (
`id` int(11) NOT NULL auto_increment,`type` int(11) NOT NULL,
`employee_name` varchar(255) default NULL,`employee_age` int(11) default NULL,`skill` varchar(255) default NULL,
`sell` int(11) default NULL,
PRIMARY KEY (`id`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

○6 运行结果:

○7 生成表的定义语句:

传智博客—赵涵笔记 31

因为在技术和销售两个类里可能会有多个字段,所以放在一张表里会对系统的优化造成影响。所以要将每个子类建立一张表。
Employee.hbm.xml

批注 [z37]: 生成的表名:skiller.

批注 [z38]: 查询有关 skiller 的信息,会根据这个 emp-id 外键字段去查找。

<key column="

</class>

skiller

emp_id

Hibernate: insert into Emlpoyee (employee_name, employee_age) values(?, ?)
Hibernate: insert into Emlpoyee (employee_name, employee_age) values(?, ?)

Hibernate: insert into skiller (skill, emp_id) values (?, ?)Hibernate: insert into Emlpoyee (employee_name, employee_age) values(?, ?)
Hibernate: insert into sales (sell, emp_id) values (?, ?)
Hibernate: select employee0_.id as id0_, employee0_.employee_name asemployee2_0_, employee0_.employee_age as employee3_0_,employee0_1_.skill as skill1_, employee0_2_.sell as sell2_, case whenemployee0_1_.emp_id is not null then 1 when employee0_2_.emp_id is notnull then 2 when employee0_.id is not null then 0 end as clazz_ from Emlpoyeeemployee0_ left outer join skiller employee0_1_ onemployee0_.id=employee0_1_.emp_id left outer join sales employee0_2_ onemployee0_.id=employee0_2_.emp_id
[id=1name=el1, id=2name=e2, id=3name=e3]

CREATE TABLE `emlpoyee` (
`id` int(11) NOT NULL auto_increment,`employee_name` varchar(255) default NULL,`employee_age` int(11) default NULL,

" />

运行结果:

这种映射在效率上不是很理想。生成表的定义语句:

传智博客—赵涵笔记

PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `sales` (
`emp_id` int(11) NOT NULL,
`sell` int(11) default NULL,
PRIMARY KEY (`emp_id`),
KEY `FK682490C46FD469B` (`emp_id`),
CONSTRAINT `FK682490C46FD469B` FOREIGN KEY (`emp_id`) REFERENCES

`emlpoyee` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `skiller` (
`emp_id` int(11) NOT NULL,
`skill` varchar(255) default NULL,
PRIMARY KEY (`emp_id`),
KEY `FK7FFD86BE46FD469B` (`emp_id`),
CONSTRAINT `FK7FFD86BE46FD469B` FOREIGN KEY (`emp_id`) REFERENCES

`emlpoyee` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

</subclass>

</class>

如果销售类中有很多字段,而技术类中只有很少字段,那么需要混合使用“一个类继承体系一张表”和“ 每个子类一张表”。

 懒加载
利用上面 “组件映射” 那个例子:
传智博客—赵涵笔记 33

Lazy.java

批注 [z39]: 这里调用了 user 的getAge()方法,那么会去访问数据库,但此时 session 已经关闭,所以这里会抛出代理没有初始化的异常。

package com.it315.test;
import org.hibernate.Session;
import org.hibernate.Transaction;import com.it315.domain.Name;
import com.it315.domain.User;
import com.it315.util.HibernateUtils;

public class lazy {
public static void main(String[] args) {

add();
User user = select();System.out.println( );

}

static void add() {
User user = new User();user.setAge(20);

Name name = new Name();name.setFirstName("zhang");name.setLastName("san");

user.setName(name);

Session session = null;Transaction tc = null;try {

session = HibernateUtils.getSession();tc = session.beginTransaction();

session.save(user);

tc.commit();} finally {

if (session != null) {session.close();

}}

}

static User select() {Session session = null;User user = null;
try {

session = HibernateUtils.getSession();

user.getAge()

传智博客—赵涵笔记 34

批注 [z40]: 调用 load()方法返回的是一个代理对象,里面没有值,只有第一次去调用它的方法的时候才会去数据库里查询。

批注 [z41]: 初始化代理对象,传的参数必须是代理对象。

} finally {
if (session != null) {

session.close();}

}

return user;}

}

user

= (User)session.load(User.class, 1);

static User select() {
Session session = null;

User user = null;try {

session = HibernateUtils.getSession();user = (User)session.load(User.class, 1);

;

} finally {
if (session != null) {

session.close();}

}

return user;}

}

Hibernate.initialize(user)

......
<class name="Door" table="door">

用 load()实现懒加载必须保证 session 没有关闭。Hibernate 提供了一种代理对象初始化的方法:

这时候再运行上面那段程序, 就不会出现异常了。

○1 一对一懒加载
必须同时满足下面三个条件, 才能实现懒加载。Lazy != false
Constrained = true
Fetch = select

因为查找 room 的时候一般需要一同把 door 的信息列出来,而查找 door 的时候却不一定要把房间的信息列出来,所以在次我将 room 设为懒加载。

Door.hbm.xml

传智博客—赵涵笔记 35

批注 [z42]: 默认设置。使用代理的方式懒加载。

批注 [z43]: Fetch 是设置通过 door 获取 room 的信息时的抓取方式。Join是一条 select 语句全部查询出来,这样无法实现懒加载,所以用 select。必须通过第二条 select 语句才能查询处 room 的信息。(select 是默认配置)

批注 [z44]: Door 不是代理对象,我们设置的 Room 是代理对象,所以我们将 Room 作为参数传进去。

</generator></id>

<property name="number" />
<one-to-one name="room" constrained="true"

</class>......

lazy="proxy"

fetch="select"

package com.it315.test;
import org.hibernate.Hibernate;import org.hibernate.Session;
import com.it315.domain.Door;
import com.it315.util.HibernateUtils;

public class Lazy {
public static void main(String[] args) {

Test.add();
Door door = select();System.out.println(door.getRoom());

}

static Door select() {Session session = null;Door door = null;
try {

session = HibernateUtils.getSession();door = (Door) session.get(Door.class, 1);

;

} finally {
if (session != null) {

session.close();}

}

return door;}

}

Hibernate.initialize(door.getRoom())

Lazy.java

○2 一对多懒加载必须满足以下两个条件 :Lazy != falseFetch = select

因为默认的配置就是 lazy =传智博客—赵涵笔记

proxy,fetch =

select,所以配置文件不需要修改。

Lazy.java

批注 [z45]: 当确定只有一个结果的时候用 uniqueResult()方法,否则用list().

package com.it315.test;
import org.hibernate.Hibernate;import org.hibernate.Session;
import com.it315.domain.Department;import com.it315.util.HibernateUtils;

public class Lazy {
public static void main(String[] args) {

Test.save();
Department depart = select();System.out.println(depart.getEmployee());

}
static Department select(){

Session session = null;Department depart = null;try{

session = HibernateUtils.getSession();
depart = (Department)session.get(Department.class, 1);Hibernate.initialize(depart.getEmployee());

}finally{
if(session != null){

session.close();}

}

return depart;}

}

static void select(){
Session session = null;

List list = null;try{

session = HibernateUtils.getSession();
String hql = "from Department as depart where depart.name=:n";Query q = session.createQuery(hql);q.setString("n","jishu");
Department depart = (Department) ;

q.uniqueResult()

若不想使用懒加载,只需要在配置文件中将 lazy 的值改为 false,或者将 fetch 的值改为 join.

 HQL和Criteria一.最简单 HQL 的查询:

传智博客—赵涵笔记 37

批注 [z46]: 其实索引。
批注 [z47]: 获取最大记录数。

list = q.list();
for(Iterator iter = list.iterator();iter.hasNext();){

Department depart = (Department)iter.next();

System.out.println(depart.getName());}

}finally{
if(session != null){

session.close();}

}}

Query q = session.createQuery(hql);
List list = q.list();
for(Iterator iter = list.iterator();iter.hasNext();){

Object[] rs = (Object[])iter.next();Department d1 = (Department)rs[0];Employee e1 = (Employee)rs[1];

}

setFirstResult(begin)

setMaxResults(count)

;

Criteria crit = session.createCriteria(Department.class);list = crit.list();
for(Iterator iter = list.iterator();iter.hasNext();){

Department depart = (Department)iter.next();

System.out.println(depart.getName());}

Criteria crit = session.createCriteria(Department.class);

○1 如果查询语句是这样:
String hql = “select depart,emp from Department depart,Employee asemp ”+”where depart.id=emp.depart.id and depart.id=:id”;
应当这样遍历:

查询几个对象, 数组长度就是几。

○2 如果查询语句是这样:
String hql = “from java.lang.Object”;这样的 hql 语句会将所有的对象都查一遍。

○3 分页
q. ;

二 . Criteria○1

○2

传智博客—赵涵笔记 38

crit.add(

crit.addOrder(

list = crit.list();

Restrictions.eq("name","jishu")

);

批注 [z48]: 属性 name 的值必须是jishu.

批注 [z49]: Id 必须在 1 和 10 之间。批注 [z50]: 按照 id 的倒序排列。

Restrictions.between("id", 1, 10)

);

Order.desc("id")

);

crit.setFirstResult(1);crit.setMaxResults(10);

static void test() {
Session session = null;

try {
session = HibernateUtils.getSession();Department depart =

(Department)session.get(Department.class, 1);System.out.println(depart.getEmployee());

System.out.println("----------");

Department depart1 =(Department)session.get(Department.class, 1);

System.out.println(depart1.getEmployee());} finally {

if(session != null){session.close();

}}

}

相当于这样的 SQl 语句:
Select * from Department where name=”jishu” and id between 1 and 10 orderby id desc

○3 分页

 缓存一.一级缓存

○

两次查询的都是 id 为 1 的 Department 对象,因为有一级缓存,所以在第一次查询到了以后,将查询到的对象以及 id 值一同保存在 Map 集合中,在第二次执行相同操作的时候,就不会从数据库里查询,直接去一级缓存中读取数据。这也就是为什么只执行了一个查询语句的原因。

如果在System.out.println("----------");这一句后面添加:session.clear();
这样就把一级缓存清除了,在第二次查询具有相同id的对象的时候,一级缓存中没有数据 ,

所以会去数据库中查询 ,这样就出现了第二条查询语句。
如果一级缓存中的对象特别多 ,只想清空某一个对象的缓存, 可以调用evict方法 ,传参

数是对象类型:
传智博客—赵涵笔记 39

session.evict(depart);

注意:save,update,saveOrUpdate,load,get,list,iterate,lock这些方法都将会对象放在一级缓存中,一级缓存不能控制缓存的数量 ,所以要注意大批量的操作数据时可能造成内存溢出。

○2

static void test() {
Session session = null;

Transaction tc = null;try {

session = HibernateUtils.getSession();tc = session.beginTransaction();Department depart =

(Department)session.get(Department.class, 1);System.out.println(depart.getName());

depart.setName("sell");

tc.commit();} finally {

if(session != null){session.close();

}}

}

......<hibernate-configuration>

<session-factory>
<property name="hibernate.dialect">

org.hibernate.dialect.MySQLDialect</property>

<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver

</property>

此时对象为持久状态,所以它的值可以修改,并且生成了updaet语句。

如果在depart.setName(“sell”);这句下面清除一级缓存,那么将不会生成update语句,并且表中的字段也不会修改。因为它的更新是根据一级缓存来和数据库进行同步的。调用setName()方法的时候是不会更新数据的,它的属性值全在一级缓存里,只有在提交事务的时候才会更新数据库。这时候如果将一级缓存清掉,hibernate将无法检测到这种属性变化。

一级缓存的作用范围是很小的,当session关闭,那么一级缓存中的数据也不在了。

二.二级缓存

Update,saveorUpdate,list,iterator,get,load,一级Query,Criteria都会填充二级缓存。Save这个方法不适合 native生成方式的主键。
○1
hibernate.cfg.xml

传智博客—赵涵笔记 40

<property name="hibernate.connection.url">jdbc:mysql:///zhaohan

</property>
<property name="hibernate.connection.username">root</property><property name="hibernate.connection.password">123</property><property name="hbm2ddl.auto">create</property>
<property name="show_sql">true</property>

</property>
<mapping resource="com/it315/domain/Department.hbm.xml" /><mapping resource="com/it315/domain/Employee.hbm.xml" />

<class-cache usage=" "

</session-factory></hibernate-configuration>

true

批注 [z51]: True 为默认值,打开二级缓存。(Hiberna te.pr oper ties文件中第 479 行。)

批注 [z52]: 表示用HashtableCacheProvider 这个缓存实现。(Hibernate.properties 文件中第 494 行提供了多种缓存实现。)

批注 [z53]: 说明缓存中的数据是只读的,不能更改,这样就不需要手工清除缓存;
usage=" read- write "说明放入缓存中的数据是可读可写的。

批注 [z54]: 表示对哪个对象实现二级缓存。

org.hibernate.cache.HashtableCacheProvider

read-write

class="com.it315.domain.Department"

static void cache(){
Session session = HibernateUtils.getSession();
Department depart = (Department)session.get(Department.class,

1);

System.out.println(depart.getName());session.close();

System.out.println("---------------");
Session session1 = HibernateUtils.getSession();

Department depart1 = (Department)session1.get(Department.class,

System.out.println(depart1.getName());

session1.close();}

Hibernate: select department0_.id as id0_0_,department0_.department_name as department2_0_0_ from Departmentdepartment0_ where department0_.id=?
jishu
---------------
jishu

Test.java

运行结果:

传智博客—赵涵笔记 41

两次查询都是查询同一id 的同一对象, 第二次查询默认会去一级缓存中查找, 这时候发现session已经关闭,一级缓存中没有数据,然后会去二级缓存中查找。(二级缓存中没有才会去数据库中查找)发现二级缓存中有这个对象, 所以只出现了一条select 语句。

○2HibernateUtils.java

批注 [z55]: 打开统计信息,默认为true.

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 SessionFactory getSessionFactory(){

return sessionFactory;}

public static Session getSession(){return sessionFactory.openSession();

}}

......

org.hibernate.cache.HashtableCacheProvider</property>

<class-cache usage="read-write"class="com.it315.domain.Employee" />

<class-cache usage="read-only"class="com.it315.domain.Department" />

......

true

public class Test {
public static void main(String[] args) {

save();cache();

Hibernate.cfg.xml

Test.java

传智博客—赵涵笔记 42

批注 [z56]: 得到统计信息。(只统计二级缓存,不统计一级缓存)

Statistics s =

System.out.println("往二级缓存中放了"+s.getSecondLevelCachePutCount()+"次");

;

System.out.println("命中了"+s.getSecondLevelCacheHitCount()+" 次

");

System.out.println(s.getSecondLevelCacheMissCount()+"次在缓存中没有找到");

}

static void save() {
Session session = null;

Transaction tc = null;try {

session = HibernateUtils.getSession();tc = session.beginTransaction();

Department depart = new Department();depart.setName("jishu");session.save(depart);

Set<Employee> set = new HashSet<Employee>();

Employee emp = new Employee();emp.setAge(20);emp.setName("lisa");emp.setDepart(depart);set.add(emp);

Employee emp1 = new Employee();emp1.setAge(21);emp1.setName("zhangsan");emp1.setDepart(depart);set.add(emp1);

depart.setEmployee(set);

tc.commit();

} finally {
if (session != null) {

session.close();}

}

HibernateUtils.getSessionFactory().getStatistics()

传智博客—赵涵笔记 43

}

static void cache(){
Session session = HibernateUtils.getSession();
Department depart = (Department)session.get(Department.class,

1);

}

System.out.println(depart.getName());
session.close();
System.out.println("---------------");
Session session1 = HibernateUtils.getSession();
Department depart1 = (Department)session1.get(Department.class,

System.out.println(depart1.getName());session1.close();

Hibernate: insert into Department (department_name) values (?)Hibernate: insert into Emlpoyee (employee_name, employee_age, depart_id)values (?, ?, ?)
Hibernate: insert into Emlpoyee (employee_name, employee_age, depart_id)values (?, ?, ?)
Hibernate: select department0_.id as id0_0_,department0_.department_name as department2_0_0_ from Departmentdepartment0_ where department0_.id=?
jishu
---------------
jishu

往二级缓存中放了1次

批注 [z57]: 这一次是第一回查询Department 对象的时候,将查询到的department 放进缓存中。

批注 [z58]: 第二次查找 Department对象的时候是从二级缓存中查找到的。

批注 [z59]: 第一次查询 Department对象的时候会去缓存中查找,没有查找到,所以去数据库中查找的。

批注 [z60]: 保存一个部门和两个员工信息的时候放进二级缓存,共放了三次。

批注 [z61]: 两次查找部门信息都是从二级缓存中读取,所以命中两次,没有生成 select 语句。

命中了1次

1次在缓存中没有找到

jishu---------------jishu

往二级缓存中放了3次

命中了2次

运行结果是:

查看命中次数有助于对程序的优化,如果二级缓存中保存的对象有很多 ,而命中率却很少的话,那就浪费了资源。

执行save操作的时候,是会把保存的对象放进二级缓存中的,因为save方法是否将对象放进二级缓存是和主键生成策略有关的,如果是native的话,就不会把对象放进二级缓存。上例中Department和Employee两个主键生成方式都是native,所以在保存两个对象的时候不会放进二级缓存中。

如果将两个对象的主键生成方式都改成hilo,那么执行的结果为:

传智博客—赵涵笔记 44

批注 [z62]: 在缓存中查找数据都查找到了,所以没有 miss.

0次在缓存中没有找到

static void cache(){
Session session = HibernateUtils.getSession();
Department depart = (Department)session.get(Department.class,

1);

System.out.println(depart.getName());session.close();

System.out.println("---------------");
Session session1 = HibernateUtils.getSession();

Department depart1 = (Department)session1.get(Department.class,

System.out.println(depart1.getName());session1.close();

Session session2 = HibernateUtils.getSession();

String hql = "from Employee emp where emp.id = 32768";Query q = session2.createQuery(hql);
Employee em = (Employee)q.uniqueResult();System.out.println(em.getAge());

session2.close();}

jishu
---------------
jishu
Hibernate: select employee0_.id as id1_, employee0_.employee_name asemployee2_1_, employee0_.employee_age as employee3_1_,employee0_.depart_id as depart4_1_ from Emlpoyee employee0_ whereemployee0_.id=32768
20
往二级缓存中放了3次
命中了2次

有三个方法会从二级缓存中读取数据:iterator,get,load。Iterator方法指的是Query的 iterator方法。例如:

Iterator iter = query.iterate();Iter.next();

使用下面例子进行说明 :

○1 HQL查询

运行结果:

传智博客—赵涵笔记 45

批注 [z63]: 这个信息是从缓存中查询的。

0次在缓存中没有找到

static void cache(){
Session session = HibernateUtils.getSession();String hql = "from Employee";
Query q = session.createQuery(hql);
Iterator iter = q.iterate();while(iter.hasNext()){

Employee em = (Employee)iter.next();

System.out.println(em.getName());}

session.close();System.out.println("----------------");

Session session1 = HibernateUtils.getSession();
Employee em = (Employee)session1.get(Employee.class, 32768);System.out.println(em.getAge());

session1.close();}

Hibernate: select employee0_.id as col_0_0_ from Emlpoyee employee0_Hibernate: select employee0_.id as id1_0_, employee0_.employee_name asemployee2_1_0_, employee0_.employee_age as employee3_1_0_,employee0_.depart_id as depart4_1_0_ from Emlpoyee employee0_ whereemployee0_.id=?

lisa
Hibernate: select employee0_.id as id1_0_, employee0_.employee_name asemployee2_1_0_, employee0_.employee_age as employee3_1_0_,employee0_.depart_id as depart4_1_0_ from Emlpoyee employee0_ whereemployee0_.id=?
zhangsan
----------------

往二级缓存中放了2次命中了1次
2次在缓存中没有找到

HQL查询会生成select语句从数据库中查找,不会去二级缓存中去查找。所以建议在根据id查找数据的时候要用get 方法。

○2 iterator方法

运行结果:

这样如果有N个对象,那么就会出现N+1条查询语句。如果缓存中没有对象但遍历的对象又很多的情况下,用iterator 方法的话并不是很好,但若是第二次查询的话,会把系统优化很多。

查询缓存:

传智博客—赵涵笔记 46

上面例一中,HQL查询不会去缓存中查找,我们可以通过配置使Query和Criteria都从缓存中查找,但是因为命中率较低,所以默认配置是关闭的。(hibernate.properties 文件中第484行)

通过Query或Criteria 查找数据库得到的结果集,hibernate 会把查询语句当作key,把返回结果的id做为value存到缓存里去。那么第二次执行相同查询语句的时候,发现缓存里有相关信息,那么就会拿到缓存中所有id 的集合,然后再根据id去一级缓存和二级缓存中去找 ,找不到就去数据库中查找。

将cache.use_query_cache配置为true打开查询缓存,并且调用query.setCacheable(true)或criteria.setCacheable(true)。

注意:查询缓存不是一级缓存 ,也不是二级缓存。如果没有十足把握 ,不要打开查询缓存,这样会对性能有严重影响。

清除二级缓存:

批注 [z64]: 将缓存中的所有Department 对象全部清除。如果只想清除 id 为 1 的 Department 对象,只需要:
evict(D epart ment. clas s,1)

static void cache(){
Session session = HibernateUtils.getSession();
Department depart = (Department)session.get(Department.class,

1);

}

System.out.println(depart.getName());session.close();

System.out.println("---------------");

Session session1 = HibernateUtils.getSession();
Department depart1 = (Department)session1.get(Department.class,

System.out.println(depart1.getName());session1.close();

HibernateUtils.getSessionFactory().evict(Department.class);

jishu
---------------
Hibernate: select department0_.id as id0_0_,department0_.department_name as department2_0_0_ from Departmentdepartment0_ where department0_.id=?
jishu
往二级缓存中放了4次
命中了1次
1次在缓存中没有找到

.......

运行结果:

换OSCacheProvider缓存实现:

传智博客—赵涵笔记 47

批注 [z65]: “sql”参数为配置文件中的命名查询名称。

org.hibernate.cache.OSCacheProvider

</property>

......

<one-to-many class="Employee" /></set>

</class>

<query name="sql">
from Department depart where depart.id = 1

</query>......

static void cache(){
Session session = HibernateUtils.getSession();Query q = session. ;

Department depart = (Department)q.uniqueResult();System.out.println(depart.getName());session.close();

}

getNamedQuery("sql")

for(int i=0;i<1000000;i++){

只需要将原来的缓存实现换成OSCacheProvider,并且把OSCacheProvider包oscache-2.1.jar导入。

使用缓存的条件:

1. 读取大于修改
2. 数据量不能超过内存容量3. 对数据要有独享的控制4. 可以容忍出现无效数据

 将查询语句写在配置文件中

 注意大批量操作的问题
大批量的操作数据时可能造成内存溢出,解决办法如下:

1. 清除session中的数据

传智博客—赵涵笔记 48

批注 [z66]: 只能出现在字段上,不能出现在方法上.

批注 [z67]: 默认设置是 CLASS,但设置成 RUNTIME 才能获取到这个Annotation.

Session.save(obj);if(i%50==0){

session.flush();

session.clear();}

}

package com.it315.jpa;
import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;

@Retention(RetentionPolicy.public @interface HelloWorld {}

@Target(ElementType.FIELD)

RUNTIME

)

package com.it315.jpa;public class TestBean {

@HelloWorld
private String name;private int age;get(),set()方法省略......

}

package com.it315.jpa;
import java.lang.annotation.Annotation;import java.lang.reflect.Field;

public class Test {
public static void main(String[] args) throws SecurityException,

每当有50条数据的时候, 就和数据库同步一次 ,然后清除一级缓存中的对象。

2. 用StatelessSession接口,它没有一级缓存,也不和二级缓存,查询缓存交互,通过该接口的操作会立即发送给数据库,与JDBC的功能一样。
StatelessSession s = sessionFactory.openStatelessSession();该接口的方法和session类似。

 Annotation
○1 HolloWorld.java

@Target({ElementType.METHOD,ElementType.FIELD})既可以出现在字段上,也可以出现在方法上。里面是一个数组,要中花括号括起来。

○2 Bean.java

○3 Test.java

传智博客—赵涵笔记 49

NoSuchFieldException {

test();}

static void test() throws SecurityException, NoSuchFieldException {Class = TestBean.class;

Field

Boolean b = field.
if (b) {
Annotation annotation = field. ;

System.out.println(annotation.getClass());} else {

System.out.println("没有这个Annota tion");}