1. Session缓存 Session缓存（Hibernate一级缓存），在 Session 接口的实现中包含一系列的 Java 集合, 这些 Java 集合构成了 Session 缓存。只要 Session 实例没有结束生命周期, 且没有清理缓存，则存放在它缓存中的对象也不会结束生命周期。
Session 缓存可减少 Hibernate 应用程序访问数据库的频率。
两次获取同一个对象：
①第一次获取Users对象时会去数据库中查找，找到之后把Users对象的引用赋给user引用变量，同时还会把Users对象的引用给到Session缓存中，
②若再次查找同一个Users变量，首先会去Session中找有没有，若缓存中有就不去查询数据库，直接从缓存中获取
/**
* Session缓存（Hibernate一级缓存），在 Session 接口的实现中包含一系列的 Java 集合,
*这些 Java 集合构成了 Session 缓存。
*只要 Session 实例没有结束生命周期, 且没有清理缓存，则存放在它缓存中的对象也不会结束生命周期
*Session 缓存可减少 Hibernate 应用程序访问数据库的频率。
* 两次获取同一个对象：
* ①第一次获取Users对象时会去数据库中查找，找到之后把Users对象的引用赋给user引用变量，
* 同时还会把Users对象的引用给到Session缓存中，
* ②若再次查找同一个Users变量，首先会去Session中找有没有，若缓存中有就不去查询数据库，直接从缓存中获取
*/
@Test
public void testSessionCache(){
Users user = (Users) session.get(Users.class, 8);
System.out.println(user);
Users user2 = (Users) session.get(Users.class, 8);
System.out.println(user2);
}2. flush方法：使数据表中的记录和Session缓存中的对象的状态保持一致，为保持一致，则可能会发送对应的SQL语句
* 提下情况会调用该方法：
* 1.在Transaction的commit方法中，先调用session的Flush方法，在提交事务
* 2.显式的调用flush()方法可能会发送SQL语句，但不会提交事务
* 3.注意：在未提交事务或显式的调用session.flush()方法之前，也有可能进行flush()操作。
* ①.执行HQL或QBC查询，会先进行flush()操作，以得到数据表的最新的记录
* ②.若记录的ID是由底层数据库使用自增的方式生成的则在调用save()方法后，就会立即发送INSERT语句，因为save方法后
* 必须保证对象的ID是存在的
/**
* flush方法：使数据表中的记录和Session缓存中的对象的状态保持一致，为保持一致，则可能会发送对应的SQL语句
*提下情况会调用该方法：
* 1.在Transaction的commit方法中，先调用session的Flush方法，在提交事务
* 2.显式的调用flush()方法可能会发送SQL语句，但不会提交事务
* 3.注意：在未提交事务或显式的调用session.flush()方法之前，也有可能进行flush()操作。
* ①.执行HQL或QBC查询，会先进行flush()操作，以得到数据表的最新的记录
* ②.若记录的ID是由底层数据库使用自增的方式生成的则在调用save()方法后，就会立即发送INSERT语句，因为save方法后
*必须保证对象的ID是存在的
*/
@Test
public void testSessionFlush(){
Users users = (Users) session.get(Users.class, 8);
users.setLoginName("Jack");
//session.flush();
//System.out.println("flush()");
//HQL查询
Users user2 = (Users) session.createCriteria(Users.class).uniqueResult();
System.out.println(user2);
}
//使用save()方法，会立即执行SQL语句，而不用等到事务提交，其他方法需要等到事务提交之后到能执行SQL语句
@Test
public void testSessionFlush2(){
Users user = new Users("mengqi", "123", "孟奇", "河南省郑州市", "19843244908", "163@.com", new Date());
session.save(user);
} 3. reflush():获取数据表中最新的记录，该方法会强制执行查询，
* 手动修改表中的记录，使用reflush()，再次打印user时，打印的记录就会和之前打印的不一致，此时打印的是手动修改后的记录，即最新是记录，若打印的不是最新的则是MYSQL数据库的隔离级别问题，MYSQL默认的隔离级别为REPEATABLE READ(可重复读)，需要改成READ COMMITED（读已提交）。
* 在Hibernate的配置文件中，可以显示的设置隔离级别，每一个隔离级别都对应一个数字
* 1对应READ UNCOMMITED
* 2对应READ COMMITED
* 4对应REPEATABLE READ
* 8对应SERIALIZEABLE
*Hibernate通过Hibernate配置文件指定，Hibernate.connection.isolation属性设置事务的隔离级别
/**
* reflush():获取数据表中最新的记录，该方法会强制执行查询，
* 手动修改表中的记录，使用reflush()，再次打印user时，打印的记录就会和之前打印的不一致，此时打印
* 的是手动修改后的记录，即最新是记录，若打印的不是最新的则是MYSQL数据库的隔离级别问题，
* MYSQL默认的隔离级别为REPEATABLE READ(可重复读)，需要改成READ COMMITED（读已提交）
* 在Hibernate的配置文件中，可以显示的设置隔离级别，每一个隔离级别都对应一个数字
* 1对应READ UNCOMMITED
* 2对应READ COMMITED
* 4对应REPEATABLE READ
* 8对应SERIALIZEABLE
*Hibernate通过Hibernate配置文件指定，Hibernate.connection.isolation属性设置事务的隔离级别
*/
@Test
public void testReFlush(){
Users user = (Users) session.get(Users.class, 8);
System.out.println(user);
//在此打印断点，打印出的user与上一个打印的user没有什么不同
System.out.println(user);
//此时手动修改了表中的记录，使用reflush()，再次打印user时，打印的记录就会和之前打印的不一致，此时打印
//的是手动修改后的记录，即最新是记录，若打印的不是最新的则是MYSQL数据库的隔离级别问题，
//MYSQL默认的隔离级别为REPEATABLE READ(可重复读)，需要改成
session.refresh(user);
System.out.println(user);
} 4. claer()：清理缓存，两次查询同一条记录，中间使用clear()清理之后，第二条查询也会发送一条记录
/**
* claer():清理缓存，两次查询同一条记录，中间使用clear()清理之后，第二条查询也会发送一条记录
*/
@Test
public void testClear(){
Users users = (Users) session.get(Users.class, 8);
session.clear();
Users users2 = (Users) session.get(Users.class, 8);
} 5. save()
* ①把对象加入到Session缓存中，使一个临时对象变为持久化对象
* ②选用映射文件指定的标识符生成器，为对象分配ID
* ③在flush()缓存时会发送一条INSERT语句
* ④在save()方法之前设置ID属性值是无效的，但不抛出异常
* ⑤持久化对象的ID是不能被修改的
/**
* save():
* ①把对象加入到Session缓存中，使一个临时对象变为持久化对象
* ②选用映射文件指定的标识符生成器，为对象分配ID
* ③在flush()缓存时会发送一条INSERT语句
* ④在save()方法之前设置ID属性值是无效的，但不抛出异常
* ⑤持久化对象的ID是不能被修改的
*/
@Test
public void testSave(){
Users user = new Users("wangqiang", "123", "王强", "河南省", "18292389876", "163@qq.com", new Date());
//save()方法前后的对象区别在于save()之后会给对象分配ID
System.out.println("user:"+user);
session.save(user);
System.out.println("user:"+user);
//在save()方法前修改ID是无效的
Users user2 = new Users("wangqiang", "1234", "王强", "河南省", "18292389876", "163@qq.com", new Date());
user2.setId(100);
session.save(user2);
System.out.println("user2:"+user2);//为id赋值失败
user2.setId(100);
} 6. Persist()：也会执行INSERT操作，作用与save()一致
与save的主要内容区别：
persist把一个瞬态的实例持久化，但是并"不保证"标识符(identifier主键对应的属性)被立刻填入到持久化实例中，标识符的填入可能被推迟到flush的时候。
save, 把一个瞬态的实例持久化标识符，及时的产生,它要返回标识符，所以它会立即执行Sql insert
/**
* Persist()：也会执行INSERT操作，作用与save()一致，与save的主要内容区别：
persist把一个瞬态的实例持久化，但是并"不保证"标识符(identifier主键对应的属性)被立刻填入到持久化实例中，标识符的填入可能被推迟到flush的时候。
save, 把一个瞬态的实例持久化标识符，及时的产生,它要返回标识符，所以它会立即执行Sql insert
*:
*/
@Test
public void testPersist(){
Users user = new Users("wangwei", "123", "王伟", "河南省", "19483928495", "163@qq.com", new Date());
user.setId(100);
session.persist(user);
} 7. GET()和Load()的区别
* 1.get方法会立即加载该对象，立即执行查询
* load方法，若不使用该对象，则不会立即加载，而返回一个代理对象，不会立即执行查询操作
* 2.若数据表中没有对应的记录get返回null，load会抛出异常
* 3.load方法可能会抛出懒加载异常，因为load方法是在使用对象的时候再执行查询操作，
* 假如在使用对象之前把session关闭，即需要初始化代理对象之前已经关闭了Session，同时又在使用加载的对象，
* 就会出现懒加载异常，若不使用加载的对象，则没有问题
* get在使用对象之前关闭session则没有问题。
* GET()和Load()的区别
* 1.get方法会立即加载该对象，立即执行查询
* load方法，若不使用该对象，则不会立即加载，而返回一个代理对象，不会立即执行查询操作
* 2.若数据表中没有对应的记录get返回null，load会抛出异常
* 3.load方法可能会抛出懒加载异常，因为load方法是在使用对象的时候再执行查询操作，
* 假如在使用对象之前把session关闭，即需要初始化代理对象之前已经关闭了Session，同时又在使用加载的对象，
* 就会出现懒加载异常，若不使用加载的对象，则没有问题
* get在使用对象之前关闭session则没有问题。
*
*/
@Test
public void testGet(){
Users user = (Users) session.get(Users.class, 5);
session.close();
System.out.println(user);
}
@Test
public void testLoad(){
Users user = (Users) session.load(Users.class, 5);
session.close();//使用对象前关闭session，出现懒加载异常org.hibernate.LazyInitializationException，不使用则没有问题
System.out.println(user);
} 8. Update()
* 1.若更新一个持久化对象，不需要显示的调用update()方法，因为在调用Transaction的commit方法时，会先执行
*Session的flush()方法
* 2.更新一个游离对象时，需要显式的调用Session的update方法，可以把一个游离对象变为一个持久化对象
*注意：
* ①.若显式的调用Session的update方法，则无论游离的对象中属性有没有变化，都会发送update语句
*可以使用Xxx.hbm.xml文件的class节点设置select-before-update=true（默认为false），
*但通常并不设置此属性
* ②.若数据表中没有对应的记录，但还调用了update方法，会抛出异常
* ③.当 update() 方法关联一个游离对象时, 如果在 Session 的缓存中已经存在相同 OID 的持久化对象，
* 会抛出异常
/**
* Update()
* 1.若更新一个持久化对象，不需要显示的调用update()方法，因为在调用Transaction的commit方法时，会先执行
*Session的flush()方法
* 2.更新一个游离对象时，需要显式的调用Session的update方法，可以把一个游离对象变为一个持久化对象
*注意：
* ①.若显式的调用Session的update方法，则无论游离的对象中属性有没有变化，都会发送update语句
*可以使用Xxx.hbm.xml文件的class节点设置select-before-update=true（默认为false），
*但通常并不设置此属性
* ②.若数据表中没有对应的记录，但还调用了update方法，会抛出异常
* ③.当 update() 方法关联一个游离对象时, 如果在 Session 的缓存中已经存在相同 OID 的持久化对象，
* 会抛出异常
*/
@Test
public void testUpdate(){
Users user = (Users) session.get(Users.class, 8);
//1.
transaction.commit();
//关闭session，user对象成为游离对象
session.close();
//②更改游离对象的id，使update方法更新一个数据库中不存在的记录，结果是抛出异常
//user.setId(100);
//虽然又开启了一个Session，但是这个Session与上一个Session并没有联系。
session = sessionFactory.openSession();
transaction = session.beginTransaction();
//③虽然这只是一个简单的查询，但是执行查询会在session缓存中关联ID为8的一个持久化对象，
//当显式执行下面的update方法时，会把id为8的游离对象也关联到session缓存中，但是Session缓存中不能有
//两个相同ID的对象
Users users = (Users) session.get(Users.class, 8);
user.setLoginName("Nick");
//2.只有显式的调用session的update方法才能让设置的LoginName属性生效
session.update(user);
} 9. SaveOrUpdate():若是一个临时对象则执行save，游离对象执行update
* 注意:
* 1.若OID不为null，但数据表中没有与之对应的记录则会抛出异常，因为虽然OID不为空，也是一个游离对象，
*但是数据表中没有对应的记录无法执行update语句。
* 2.了解:OID值等于id的unsaved-value属性值的对象，也被认为是一个游离对象，unsave-value是映射文件中id子节点的属性
/**
* SaveOrUpdate():若是一个临时对象则执行save，游离对象执行update
* 注意:
* 1.若OID不为null，但数据表中没有与之对应的记录则会抛出异常，因为虽然OID不为空，也是一个游离对象，
*但是数据表中没有对应的记录无法执行update语句。
* 2.了解:OID值等于id的unsaved-value属性值的对象，也被认为是一个游离对象，unsave-value是映射文件中id子节点的属性
*/
@Test
public void testSaveOrUpdate(){
//临时对象，调用saveOrUpdate()方法，执行insert语句
Users user = new Users("wangmei", "123", "王梅", "河南省", "19483928495", "163@qq.com", new Date());
//设置id为8对应数据库表中存在的记录，调用saveOrUpdate()方法，执行update语句
user.setId(8);
//该值等于映射文件中id子节点的unsave-value属性值，所以可以调用saveOrUpdate()方法，执行insert语句
user.setId(100);
session.saveOrUpdate(user);
} 10. Delete():Session的delete()方法既可以删除一个游离对象，又可以删除一个持久化对象，
* ①只要OID和数据表中一条记录对应，就会准备执行Delete操作，若OID在数据表中没有对应的记录，则会抛出异常。
* ②可以通过设置Hibernate配置文件中的一个hibernate.use_identifier_rollback 属性
*来把持久化对象或游离对象的 OID 设置为 null, 使它们变为临时对象
/**
* Delete():Session的delete()方法既可以删除一个游离对象，又可以删除一个持久化对象，
* ①只要OID和数据表中一条记录对应，就会准备执行Delete操作，若OID在数据表中没有对应的记录，则会抛出异常。
* ②可以通过设置Hibernate配置文件中的一个hibernate.use_identifier_rollback 属性
*来把持久化对象或游离对象的 OID 设置为 null, 使它们变为临时对象
*/
@Test
public void testDelete(){
//因为数据表中id为8的记录已经被删除了，所以该对象是游离对象
// Users user = new Users();
// user.setId(8);
//持久化对象也可以删除
Users user = (Users) session.get(Users.class, 7);
session.delete(user);
//执行完delete之后，该对象还是有ID值的，若之后想要对该对象执行saveOrUpdate方法，则会强制发送update语句
//但是，数据表中已经没有这条记录，就会抛异常
System.out.println(user);
} 11. Evict():从Session中把指定的持久化对象移除
/**
* Evict():从Session中把指定的持久化对象移除
*
*/
@Test
public void testEvict(){
Users user = (Users) session.get(Users.class, 4);
Users user2 = (Users) session.get(Users.class, 5);
user.setLoginName("Lucy");
user2.setLoginName("Jack");
//虽然更新了两个对象的值，但是由于user对象从session中移除，所以只对user2执行了update
session.evict(user);
} 12. doWork():调用存储过程，需要获取Connection
/**
* doWork():调用存储过程，需要获取Connection
*/
@Test
public void testDoWork(){
session.doWork(new Work() {
@Override
public void execute(Connection conn) throws SQLException {
//没有配置C3P0数据源时连接是从数据库中获取的：com.mysql.jdbc.JDBC4Connection@42f92dbc
//配置C3P0数据源之后从连接池中获取连接：com.mchange.v2.c3p0.impl.NewProxyConnection@66ee2542
System.out.println(conn);
//调用存储过程
}
});
} 13. dynamic-update:class节点的属性不设置的话执行更新操作的话，会更新全部的属性值，设置之后仅更新修改后的属性值
*好处：减少数据库的操作
/**
* dynamic-update:class节点的属性，不设置的话执行更新操作的话，会更新全部的属性值，设置之后仅更新修改后的属性值
*好处：减少数据库的操作
*/
@Test
public void testdynamicUpdate(){
Users user = (Users) session.get(Users.class, 4);
user.setLoginPwd("1234");
} 14. 主键生成策略：increment主键生成器时会出现并发的问题，连续执行两次该方法，模仿两个线程同时访问同一个数据表
* 由于是自增，但是是两个线程，所以会造成两个线程的id自增之后，id值重复，无法执行SQL语句
/**
* 主键生成策略：increment主键生成器时会出现并发的问题，连续执行两次该方法，模仿两个线程同时访问同一个数据表
* 由于是自增，但是是两个线程，所以会造成两个线程的id自增之后，id值重复，无法执行SQL语句
* @throws InterruptedException
*/
@Test
public void testIdGenerator() throws InterruptedException{
Users user = new Users("wangwei", "123", "王伟", "河南省", "19483928495", "163@qq.com", new Date());
session.save(user);
//Thread.sleep(5000);
} 15. ①派生属性②Java 时间和日期类型的 Hibernate 映射
/**
* ①派生属性
* ②Java 时间和日期类型的 Hibernate 映射
*/
@Test
public void testPropertyUpdate(){
Users user = (Users) session.get(Users.class, 1);
user.setLoginName("AAA");
System.out.println(user.getDesc());
System.out.println(user.getDate().getClass());
} 16. 大文件属性映射
/**
* 大文件属性映射数据库
* @throws Exception
*/
@Test
public void testBlob() throws Exception{
Users user = new Users("wangwei", "123", "王伟", "河南省", "19483928495", "163@qq.com", new Date());
user.setContent("CONTENT");
//文件的输入流
InputStream inputStream = new FileInputStream("1.jpg");
Blob image = Hibernate.getLobCreator(session).createBlob(inputStream, inputStream.available());
user.setImage(image);
session.save(user);
Users user2 = (Users) session.get(Users.class, 1);
Blob image2 = user2.getImage();
//输出流输出文件
InputStream inputStream2 = image2.getBinaryStream();
//仅显示文件的大小
System.out.println("图片大小：" + inputStream2.available());
} 17.映射组成关系：即一个没有id的自定义类是另一个自定义类中的属性，那么这个属性可以使用映射组成关系来映射
/**
* 映射组成关系：即一个没有id的自定义类是另一个自定义类中的属性，那么这个属性可以使用映射组成关系来映射
*/
@Test
public void testComponent(){
Worker worker = new Worker();
Pay pay = new Pay();
pay.setMonthlyPay(1000);
pay.setYearPay(12000);
pay.setVocationWithPay(5);
worker.setName("ABC");
worker.setPay(pay);
session.save(worker);
}以上方法的需要的 实体类
Users.java
package com.test.withXml.entity;
import java.io.Serializable;
import java.sql.Blob;
import java.util.Date;
public class Users implements Serializable {
private static final long serialVersionUID = 1L;
private Integer id;
private String loginName;
private String loginPwd;
private String name;
private String address;
private String phone;
private String mail;
//日期格式
private Date date;
//派生的属性
private String Desc;
//大文本属性
private String content;
//二进制文件
private Blob image;
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public Blob getImage() {
return image;
}
public void setImage(Blob image) {
this.image = image;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getLoginName() {
return loginName;
}
public void setLoginName(String loginName) {
this.loginName = loginName;
}
public String getLoginPwd() {
return loginPwd;
}
public void setLoginPwd(String loginPwd) {
this.loginPwd = loginPwd;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getMail() {
return mail;
}
public void setMail(String mail) {
this.mail = mail;
}
public String getDesc() {
return Desc;
}
public void setDesc(String desc) {
Desc = desc;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
//1.
public Users(String loginName, String loginPwd, String name,
String address, String phone, String mail, Date date) {
super();
this.loginName = loginName;
this.loginPwd = loginPwd;
this.name = name;
this.address = address;
this.phone = phone;
this.mail = mail;
this.date = date;
}
//2.
public Users() {
}
@Override
public String toString() {
return "Users [loginName=" + loginName + ", loginPwd=" + loginPwd
+ ", name=" + name + ", address=" + address + ", phone="
+ phone + ", mail=" + mail + ", date=" + date + "]";
}
}
Worker.java
package com.test.withXml.entity;
/**
* @author
* @version: 1.0
* @Created on: 2018-1-17 下午10:03:14
* 类说明：工人
*/
public class Worker {
private Integer id;
private String name;
private Pay pay;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Pay getPay() {
return pay;
}
public void setPay(Pay pay) {
this.pay = pay;
}
}映射文件User.hbm.xml
<!-- 映射文件 -->
<hibernate-mapping>
<!-- class节点中的name属性对应实体类的名字，table属性对应数据表的名字，catalog对应数据库的名字 -->
<class name="com.test.withXml.entity.Users" table="users"
catalog="hibernate_xml" dynamic-update="true">
<!-- class节点下必须有一个<id>节点，用于定义实体类的标识属性（对应数据表中的主键），
id节点的name属性对应实体类的属性，type对应该属性的Java类型
-->
<id name="id" type="java.lang.Integer" unsaved-value="100">
<!-- column用于指定数据库表的列名 -->
<column name="Id"></column>
<!-- generator用于指定主键的生成器策略 ，使用native表示让底层数据库主键自增的方式生成，使用这种方式
产生的ID会在执行Session的save()方法的时候，先执行SQL语句，在提交事务的意外情况。
hilo表示使用Hibernate高低算法生成ID，使用该算法时，要在数据库中建立一张额外的表，
默认表名为hibernate_unique_key,默认字段为integer类型，名称是next_hi，并设置初始值-->
<generator class="native"></generator>
</id>
<!-- properties节点与id类似，用于映射普通属性 -->
<property name="loginName" type="java.lang.String">
<column name="LoginName" length="50"></column>
</property>
<property name="loginPwd" type="java.lang.String">
<column name="LoginPwd" length="16"></column>
</property>
<property name="name" type="java.lang.String">
<column name="Name" length="16"></column>
</property>
<property name="address" type="java.lang.String">
<column name="Address" length="16"></column>
</property>
<property name="phone" type="java.lang.String">
<column name="Phone" length="16"></column>
</property>
<property name="mail" type="java.lang.String">
<column name="Mail" length="20"></column>
</property>
<!-- 映射派生属性，即对象中需要一个属性但是数据表中不需要再添加一个字段，使用派生属性即可 -->
<property name="desc" formula="(SELECT concat(LoginName, ': ', LoginPwd) FROM users n WHERE n.id = id)"></property>
<!-- 映射date（日期）、time（时间）、timestamp（时间戳），此时映射的是时间 -->
<property name="date" type="date">
<column name="Date" length="20"></column>
</property>
<!-- 映射大文本属性 -->
<property name="content">
<column name="Content" sql-type="mediumtext"></column>
</property>
<property name="image">
<column name="Image" sql-type="mediumblob"></column>
</property>
</class>
</hibernate-mapping>Worker.hbm.xml
<hibernate-mapping package="com.test.withXml.entity">
<class name="Worker" table="WORKER">
<id name="id" type="java.lang.Integer">
<column name="ID" />
<generator class="native" />
</id>
<property name="name" type="java.lang.String">
<column name="NAME" />
</property>
<!-- 映射组成关系，即该属性不是一个基本数据类型，而是一个自定义的类，的引用类型 -->
<component name="pay" class="Pay">
<!-- 指定组成关系的组件属性 -->
<property name="monthlyPay" column="MonthlyPay"></property>
<property name="yearPay" column="YearPay"></property>
<property name="vocationWithPay" column="VocationWithPay"></property>
</component>
</class>
</hibernate-mapping>