hibernate-api详解
一、Configuration配置对象
Configuration用来读取hibernate.cfg.xml和User.hbm.xml两个配置文件
hibernate 核心配置文件种类
hibernate.cfg.xml 通常使用xml配置文件，可以配置内容更丰富。
hibernate.properties 用于配置key/value 形式的内容，key不能重复的。配置有很多的局限性。一般不用。
参考文件：hibernate-distribution-3.6.10.Final\project\etc\ hibernate.properties
提供了核心配置文件常用的配置项，及选择参数。
hibernate.cfg.xml详解：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- property 元素用于配置Hibernate中的属性
键:值
-->
<!-- hibernate.connection.driver_class : 连接数据库的驱动 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- hibernate.connection.username : 连接数据库的用户名 -->
<property name="hibernate.connection.username">root</property>
<!-- hibernate.connection.password : 连接数据库的密码 -->
<property name="hibernate.connection.password">1234</property>
<!-- hibernate.connection.url : 连接数据库的地址,路径 -->
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/EE19Day01</property>
<!-- show_sql: 操作数据库时,会 向控制台打印sql语句 -->
<property name="show_sql">true</property>
<!-- format_sql: 打印sql语句前,会将sql语句先格式化 -->
<property name="format_sql">true</property>
<!-- hbm2ddl.auto: 生成表结构的策略配置
update(最常用的取值): 如果当前数据库中不存在表结构,那么自动创建表结构.
如果存在表结构,并且表结构与实体一致,那么不做修改
如果存在表结构,并且表结构与实体不一致,那么会修改表结构.会保留原有列.
create(很少):无论是否存在表结构.每次启动Hibernate都会重新创建表结构.(数据会丢失)
create-drop(极少): 无论是否存在表结构.每次启动Hibernate都会重新创建表结构.每次Hibernate运行结束时,删除表结构.
validate(很少):不会自动创建表结构.也不会自动维护表结构.Hibernate只校验表结构. 如果表结构不一致将会抛出异常.
-->
<property name="hbm2ddl.auto">update</property>
<!-- 数据库方言配置
org.hibernate.dialect.MySQLDialect (选择最短的)
-->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- hibernate.connection.autocommit: 事务自动提交 -->
<property name="hibernate.connection.autocommit">true</property>
<!-- 将Session与线程绑定=> 只有配置了该配置,才能使用getCurrentSession -->
<property name="hibernate.current_session_context_class">thread</property>
<!-- 引入ORM 映射文件
填写src之后的路径（相对路径，相对src之后）
-->
<mapping resource="com/hcx/a_hello/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
User.hbm.xml详解：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- ORM元数据 表对象关系映射文件
package : 配置该配置文件中类所在的包. -->
<hibernate-mapping package="com.hcx.a_hello" >
<!-- class: 配置实体与表的关系
name : 填写实体的完整类名
table: 与实体对应表的名称
dynamic-insert:动态插入 默认值是false
true=>如果字段值为null,不参与insert语句
dynamic-update:动态更新 默认值"false"
true=> 没改动过的属性,将不会生成到update语句中
-->
<!-- ORM映射 实体与表 属性与列 -->
<class name="User" table="t_user" > <!-- 把哪个class表映射到哪张表 -->
<!-- id: 配置实体与表中 id对应
name: user对象中biaosh主键的属性名称
column: 主键在表中的列名
length: 列的数据长度
unsaved-value(不常用): 指定主键为什么值时,当做null来处理.
access(强烈推荐不要用):field 那么在操作属性时,会直接操作对应的字段而不是get/set方法
-->
<id name="id" column="id" length="255" >
<!-- generator:主键生成策略
1.increment 数据库自己生成主键. 先从数据库中查询最大的ID值,将ID值加1作为新的主键
2.identity 依赖于数据的主键自增功能
3.sequence 序列,依赖于数据中的序列功能(Oracle).
4.hilo(纯了解,永远用不到) : Hibernate自己实现序列的算法,自己生成主键. (hilo算法 )
5.native 自动根据数据库判断,三选一. identity|sequence|hilo
6.uuid 生成32位的不重复随机字符串当做主键
7.assigned 自己指定主键值. 表的主键是自然主键时使用.
-->
<generator class="uuid"></generator>
</id>
<!-- property : 实体中属性与表中列的对应
name : 实体中属性名称
column : 表中列的名称
length : 数据长度
precision: 小数点后的精度
scale: 有效位数
insert(一般不用): 该属性是否加入insert语句.
update(一般不用): 该属性是否加入update语句.
not-null : 指定属性的约束是否使用 非空
unique : 指定属性的约束是否使用 唯一
-->
<!--
type: 表达该属性的类型
可以用三种方式指定属性
java类型 数据库类型指定 Hibernate类型指定
java.lang.String varchar string
-->
<property name="name" column="name" update="true" type="string" ></property>
<property name="password" column="password"></property>
<property name="sal" column="sal" precision="2" scale="3" ></property>
</class>
</hibernate-mapping>
1.提供构造
new Configuration() ：hibernate将自动加载hibernate.properties文件
hibernate.properties文件必须存放在类路径（src）下
2.提供方法
configure() ：将加载src下的hibernate.cfg.xml
public Configuration configure() throws HibernateException{
configure("/hibernate.cfg.xml");
return this;
}
3.扩展api
configure(String) ：加载指定目录下的 xml文件
4.手动加载配置文件
// 手动加载指定的配置文件
config.addResource("com/hcx/a_hello/User.hbm.xml");
// 手动加载指定类，对应的映射文件 User--> User.hbm.xml
config.addClass(User.class);
// 手动加载指定的配置文件
config.addResource("com/hcx/a_hello/User.hbm.xml");
// 手动加载指定类，对应的映射文件 User--> User.hbm.xml
config.addClass(User.class);
常见异常：
开发中：将hbm.xml映射 配置 hibernate.cfg.xml
学习中：可以使用 addClass 或 addResource
case：
package com.hcx.b_api;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.junit.Test;
import com.hcx.a_hello.User;
//详解Configuration对象
public class Configuration_test {
@Test
//Configuration 用于加载配置文件
public void fun1(){
//1.1 调用configure() 方法=> 加载src下名为hibernate.cfg.xml
Configuration conf = new Configuration().configure();
//1.2 如果配置文件不符合默认加载规则.我们可以调用
//new Configuration().configure(file); 通过file加载
//new Configuration().configure(path); 通过路径加载
//1.3 可以通过Configuration对象加载 映射文件(不推荐)
//推荐hibernate.cfg.xml 使用 mapping 属性引入配置文件
//规范: 1>orm映射文件名称与实体的简单类名一致
// 2>orm映射文件 需要与实体的类在同一包下
conf.addClass(User.class);
}
}
二、SessionFactory工厂
SessionFactory 相当于java web连接池，用于管理所有session
获得方式：config.buildSessionFactory();
sessionFactory hibernate缓存配置信息（数据库配置信息、映射文件，预定义HQL语句 等）
SessionFactory线程安全，可以是成员变量，多个线程同时访问时，不会出现线程并发访问问题。
提供api：
//打开一个新的会话 session
factory.openSession();
//获得当前线程中绑定的会话session
factory.getCurrentSession();
//打开一个新的会话 session
factory.openSession();
//获得当前线程中绑定的会话session
factory.getCurrentSession();
hibernate支持，将创建的session绑定到本地线程中，底层使用ThreadLocal，在程序之间共享session。
1.必须在hibernate.cfg.xml 配置
<!-- 2 与本地线程绑定 -->
<property name="hibernate.current_session_context_class">thread</property>
2.如果提交或回滚事务，底层将自动关闭session
case：
package com.hcx.b_api;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.junit.Test;
import com.hcx.a_hello.User;
//详解SessionFactory对象
public class sessionfactory_test {
@Test
//SessionFactory 创建session的工厂
public void fun1(){
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
//3.1 openSession => 获得一个全新的Session对象
sf.openSession();
//3.2 getCurrentSession => 获得与当前线程绑定的session对象
// 调用getCurrentSession 需要加上一个配置: (在hibernate.cfg.xml中)
// <property name="hibernate.current_session_context_class">thread</property>
sf.getCurrentSession();
}
}
三、Session会话
Session 相当于 JDBC的 Connection-- 会话
通过session操作PO对象 --增删改查
session单线程，线程不安全，不能编写成成员变量。
session api
save保存
update更新
delete删除
get通过id查询，如果没有 null
load通过id查询，如果没有抛异常
createQuery("hql") 获得Query对象
createCriteria(Class)获得Criteria对象
case：
package com.hcx.b_api;
import java.util.Arrays;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.junit.Test;
import com.hcx.a_hello.User;
//详解Session对象
public class session_test {
@Test
//Session对象 用于操作数据库
//增
public void fun1(){
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//hibernate把对数据库的操作变成面向对象的操作
//创建一个想要增加的对象，交给session
User u = new User();
u.setName("jerry");
u.setPassword("1234");
//调用Session的save方法保存对象到数据库中
session.save(u);
//关闭资源
session.close();
sf.close();
}
@Test
//Session对象 用于操作数据库
//改
//获得修改之前的对象，对其进行修改
public void fun2(){
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//打开事务
Transaction ts = session.beginTransaction();
//先查询出你要修改的对象
User user = (User) session.get(User.class,1);
//参数1：要取的对象的类
//参数2：要修改的那条记录的id
//在查询结果上,进行修改
user.setName("汤姆");
//把修改之后的user对象传进去
session.update(user);
//提交事务
ts.commit();
//关闭资源
session.close();
sf.close();
}
@Test
//Session对象 用于操作数据库
//删
public void fun3(){
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//打开事务
Transaction ts = session.beginTransaction();
//--------------------------------------------------------
//先查询出你要修改的对象
User user = (User) session.get(User.class,2);
/*User user = new User();
user.setId(1);*/
//根据ID删除
session.delete(user);
//---------------------------------------------------------
//提交事务
ts.commit();
//关闭资源
session.close();
sf.close();
}
@Test
//Session对象 用于操作数据库
//查询get
public void fun4(){
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//打开事务
Transaction ts = session.beginTransaction();
//--------------------------------------------------------
//先查询出你要修改的对象
User user = (User) session.get(User.class,3);
//---------------------------------------------------------
//提交事务
ts.commit();
//关闭资源
session.close();
sf.close();
System.out.println(user);
}
@Test
//Session对象 用于操作数据库
//查询 load
public void fun5(){
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//打开事务
Transaction ts = session.beginTransaction();
//--------------------------------------------------------
//先查询出你要修改的对象
User user = (User) session.load(User.class,3);
//---------------------------------------------------------
//提交事务
ts.commit();
//关闭资源
session.close();
sf.close();
System.out.println(user);
}
//get: get方法被调用时立刻 发送sql语句查询
//load : 调用时并没有查询数据库,当我们需要使用该对象的时候,才查询数据
//------------------------------------------------------------------------------------------------------------
@Test
//Session对象 用于操作数据库
//查询所有User
public void fun6(){
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//打开事务
Transaction ts = session.beginTransaction();
//--------------------------------------------------------
//HQL语言 => Hibernate Query Language
//createQuery 传入hql语句查询
//select * from t_user;
Query query = session.createQuery("from com.hcx.a_hello.User");
//list 将语句执行,并返回结果
List<User> list = query.list();
System.out.println(list);
//---------------------------------------------------------
//提交事务
ts.commit();
//关闭资源
session.close();
sf.close();
}
@Test
//Session对象 用于操作数据库
//查询所有User
public void fun7(){
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//打开事务
Transaction ts = session.beginTransaction();
//--------------------------------------------------------
//Criteria 查询 => Hibernate独创的面向对象的查询=> 无语句
Criteria criteria = session.createCriteria(User.class);
//select * from t_user;
List<User> list = criteria.list();
System.out.println(list);
//---------------------------------------------------------
//提交事务
ts.commit();
//关闭资源
session.close();
sf.close();
}
@Test
//Session对象 用于操作数据库
//查询所有User
public void fun8(){
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//打开事务
Transaction ts = session.beginTransaction();
//--------------------------------------------------------
//原生的Sql查询
SQLQuery query = session.createSQLQuery("select * from t_user");
// addEntity 将查询结果封装到指定对象中
query.addEntity(User.class);
List<User> list = query.list();
System.out.println(list);
/*List<Object[]> list = query.list();
for(Object[] objs : list){
System.out.println(Arrays.toString(objs));
}*/
//---------------------------------------------------------
//提交事务
ts.commit();
//关闭资源
session.close();
sf.close();
}
//---------------------------------------------------------------------------
/*
* session.save();
* session.update();
* session.delete();
* session.get();
* session.load(); 对比get
* session.createQuery()
* session.createCritieria();
* session.createSqlQuery();
*
*/
//-------------------------------------------------------------------
//1 load方法.返回一个代理对象,获得其内容时,会查询数据库,是每次访问属性都会查询数据库吗?
//答:不是每次都查.代理对象中有一个标识是否被初始化的boolean型变量. 记录是否被初始化过.
//2 代理都是要基于接口的,用load方法返回的代理,就没有实现任何接口?
//答: java中的动态代理是基于接口. 而 Hibernate 是使用javassist-3.12.0.GA.jar 产生代理对象的.
// 该代理与被代理对象之间的关系是继承关系.与我们学的动态代理不是一种.所以不需要接口.
}
四、Transaction事务
开启事务beginTransaction()
获得事务getTransaction()
提交事务：commit()
回滚事务：rollback()
try{
//开启
//session操作
//提交
} catch(e){
//回滚
}
扩展：不需要手动的管理事务，之后所有的事务管理都交予spring。
package com.hcx.b_api;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.junit.Test;
import com.hcx.a_hello.User;
//详解Transaction对象
public class Transaction_test {
@Test
//Transaction 封装了事务的操作
//开启事务
//提交事务
//回滚事务
public void fun1(){
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//-------------------------------
//打开事务
Transaction ts = session.beginTransaction();
//获得已经打开的事务对象(很少用)
session.getTransaction();
//Transaction 控制如何关闭事务
//提交
ts.commit();
//回滚
ts.rollback();
//-------------------------------
session.close();
sf.close();
}
//事务的细节
@Test
public void fun2(){
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
SessionFactory sf = conf.buildSessionFactory();
//3 获得与当前线程绑定的session
Session session = sf.getCurrentSession();
//-------------------------------
//事务关闭时,会自动把与当前线程关联的session关闭,并删除
session.beginTransaction().commit();
//在获得当前线程绑定的session时. 获得的是新的session
Session session2 = sf.getCurrentSession();
System.out.println(session==session2);//false
//-------------------------------
session.close();
sf.close();
}
}
五、Query对象
hibernate执行hql语句
hql语句：hibernate提供面向对象查询语句，使用对象（类）和属性进行查询。区分大小写。
获得session.createQuery("hql")
方法：
list() 查询所有
uniqueResult()获得一个结果。如果没有查询到返回null，如果查询多条抛异常。
setFirstResult(int)分页，开始索引数startIndex
setMaxResults(int)分页，每页显示个数pageSize
case：
package com.hcx.b_api;
import java.util.Arrays;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.junit.Test;
import com.hcx.a_hello.User;
//详解Query对象
public class Query_test {
@Test
//Query对象 封装HQL语句的对象
//Query中封装查询细节api
public void fun1(){
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//打开事务
Transaction ts = session.beginTransaction();
//--------------------------------------------------------
Query query = session.createQuery("from com.hcx.a_hello.User ");
// Query query = session.createQuery("from com.hcx.a_hello.User where name='tom'");
//分页 limit index,count;
//指定结果从第几个开始拿
query.setFirstResult(0);
//指定拿几个结果
query.setMaxResults(2);
//query.list() 将hql语句执行,并返回结果(多行)
List<User> list = query.list();
System.out.println(list);
//uniqueResult 将hql语句执行,并返回结果(一行)
//User u = (User) query.uniqueResult();
//System.out.println(u);
//---------------------------------------------------------
//提交事务
ts.commit();
//关闭资源
session.close();
sf.close();
}
}
六、Criteria对象
l QBC（query bycriteria），hibernate提供纯面向对象查询语言，提供直接使用PO对象进行操作。
l 获得方式：Criteria criteria = session.createCriteria(User.class);
l 条件
criteria.add(Restrictions.eq("username", "tom"));
// Restrictions.gt(propertyName, value) 大于
// Restrictions.ge(propertyName, value) 大于等于
// Restrictions.lt(propertyName, value) 小于
// Restrictions.le(propertyName, value) 小于等于
// Restrictions.like(propertyName, value) 模糊查询，注意：模糊查询值需要使用 % _
case：
package com.hcx.b_api;
import java.util.Arrays;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;
import com.hcx.a_hello.User;
//详解Cretiaria对象
public class Cretiaria_test {
@Test
//Cretiaria对象 与 Query对象功能很像
//控制查询
public void fun1(){
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//打开事务
Transaction ts = session.beginTransaction();
//--------------------------------------------------------
//Criteria 查询 => Hibernate独创的面向对象的查询=> 无语句
Criteria criteria = session.createCriteria(User.class);
// 查找name属性值为tom的 记录
criteria.add(Restrictions.eq("name", "tom"));
//select * from t_user;
// list() 将查询执行,并返回结果(多行)
//List<User> list = criteria.list();
//System.out.println(list);
//返回一个查询结果
User u = (User) criteria.uniqueResult();
System.out.println(u);
//---------------------------------------------------------
//提交事务
ts.commit();
//关闭资源
session.close();
sf.close();
}
@Test
//Cretiaria对象 与 Query对象功能很像
//控制查询
public void fun2(){
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//打开事务
Transaction ts = session.beginTransaction();
//--------------------------------------------------------
//Criteria 查询 => Hibernate独创的面向对象的查询=> 无语句
Criteria criteria = session.createCriteria(User.class);
//查找名字中包含字母o的用户
criteria.add(Restrictions.like("name", "%o%"));
//返回一个查询结果
List<User> list = criteria.list();
System.out.println(list);
//---------------------------------------------------------
//提交事务
ts.commit();
//关闭资源
session.close();
sf.close();
}
@Test
//Cretiaria对象 与 Query对象功能很像
//> gt
//< lt
//= eq
//>= ge
//<= le
//like
//between
public void fun3(){
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//打开事务
Transaction ts = session.beginTransaction();
//--------------------------------------------------------
//Criteria 查询 => Hibernate独创的面向对象的查询=> 无语句
Criteria criteria = session.createCriteria(User.class);
//查找id大于3的用户
criteria.add(Restrictions.gt("id", 3));
//返回一个查询结果
List<User> list = criteria.list();
System.out.println(list);
//---------------------------------------------------------
//提交事务
ts.commit();
//关闭资源
session.close();
sf.close();
}
}
八、工具类
public class H3Utils {
// 会话工厂，整个程序只有一份。
private static SessionFactory factory;
static{
//1 加载配置
Configuration config = new Configuration().configure();
//2 获得工厂
factory = config.buildSessionFactory();
//3 关闭虚拟机时,释放SessionFactory
Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
@Override
public void run() {
System.out.println("虚拟机关闭!释放资源");
sf.close();
}
}));
}
/**
* 获得一个新的session
* @return
*/
public static Session openSession(){
return factory.openSession();
}
/**
* 获得当前线程中绑定session
* * 注意：必须配置
* @return
*/
public static Session getCurrentSession(){
return factory.getCurrentSession();
}
}
case：
package com.hcx.utils;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
//完成Hibernate工具类
//封装配置文件读取操作
//封装Sessionfactroy创建操作
//封装session获得操作
public class HibernateUtils {
private static SessionFactory sf;
static{
//1加载配置
Configuration conf = new Configuration().configure();
//2 根据Configuration 配置信息创建 SessionFactory
sf = conf.buildSessionFactory();
//
Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
@Override
public void run() {
System.out.println("虚拟机关闭!释放资源");
sf.close();
}
}));
}
public static org.hibernate.Session openSession(){
//3 获得session
Session session = sf.openSession();
return session;
}
public static org.hibernate.Session getCurrentSession(){
//3 获得session
Session session = sf.getCurrentSession();
return session;
}
public static void main(String[] args) {
System.out.println(openSession());
}
}
1671
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
