hibernate学习记录
Class.hbm.xml
关系配置
<class>
<set name="linkMens" lazy="" fetch="" batch-size= "" inverse="true" cascade="delete" >
<key column="lkm_cust_id" >key>
<one-to-many class="LinkMan" />
set>
<many-to-one name="customer" column="lkm_cust_id" class="Customer" >
many-to-one>
<set name="roles" table="sys_user_role" cascade="save-update" >
<key column="user_id" >key>
<many-to-many class="Role" column="role_id" >many-to-many>
set>
<set name="users" table="sys_user_role" inverse="true" >
<key column="role_id" >key>
<many-to-many class="User" column="user_id" >many-to-many>
set>
class>关联例子
//3操作
Customer c = new Customer();
c.setCust_name("课");
LinkMan lm1 = new LinkMan();
lm1.setLkm_name("王");
LinkMan lm2 = new LinkMan();
lm2.setLkm_name("刘");
//表达一对多,客户下有多个联系人
（如果客户放弃维护与联系人的关系. 维护关系的代码可以省略）
c.getLinkMens().add(lm1);
c.getLinkMens().add(lm2);
//表达对对对,联系人属于哪个客户
lm1.setCustomer(c);
lm2.setCustomer(c);
session.save(c);
session.save(lm1);（未级联都得保存）
session.save(lm2);
//3操作
//1> 获得要操作的客户对象
Customer c = session.get(Customer.class,1l);
//2> 创建联系人
LinkMan lm1 = new LinkMan();
lm1.setLkm_name("好");
//3> 将联系人添加到客户,将客户设置到联系人中
c.getLinkMens().add(lm1);
lm1.setCustomer(c);
//4> 执行保存
session.save(lm1);
//3操作
//1> 获得要操作的客户对象
Customer c = session.get(Customer.class,1l);
//2> 获得要移除的联系人
LinkMan lm = session.get(LinkMan.class, 3l);
//3> 将联系人从客户集合中移除
c.getLinkMens().remove(lm);
lm.setCustomer(null); Customer.hbm.xml
<hibernate-mapping package="cn.example.domain" >
<class name="Customer" table="cst_customer" >
<id name="cust_id" >
<generator class="native">generator>
id>
<property name="cust_name" column="cust_name" >
property>
<property name="cust_source" column="cust_source" >property>
<property name="cust_industry" column="cust_industry" >property>
<property name="cust_level" column="cust_level" >property>
<property name="cust_linkman" column="cust_linkman" >property>
<property name="cust_phone" column="cust_phone" >property>
<property name="cust_mobile" column="cust_mobile" >property>
hibernate-mapping>hibernate.cfg.xml
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driverproperty>
<property name="hibernate.connection.url">jdbc:mysql:///hibernate_32property>
<property name="hibernate.connection.username">rootproperty>
<property name="hibernate.connection.password">1234property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialectproperty>
<property name="hibernate.show_sql">trueproperty>
<property name="hibernate.format_sql">trueproperty>
<property name="hibernate.hbm2ddl.auto">updateproperty>
<property name="hibernate.connection.isolation">4property>
<property name="hibernate.current_session_context_class">threadproperty>
<mapping resource="cn/example/domain/Customer.hbm.xml" />
session-factory>
hibernate-configuration>API:
Configuration功能: 配置加载类.用于加载主配置,orm元数据加载
(Configuration).configure():读取指定主配置文件 => 空参加载方法,加载src下hibernate.cfg.xml文件
根据配置信息,创建 SessionFactory对象
SessionFactory sf = conf.buildSessionFactory();SessionFactory功能: 用于创建操作数据库核心对象session对象的工厂.
简单说功能就一个—创建session对象
注意:1.sessionfactory 负责保存和使用所有配置信息.消耗内存资源非常大.
2.sessionFactory属于线程安全的对象设计.
结论: 保证在web项目中,只创建一个sessionFactory.
打开一个新的session对象
Session session =sf.openSession();
获得一个与线程绑定的session对象
Session session =sf.getCurrentSession();session对象功能: 表达hibernate框架与数据库之间的连接(会话).session类似于JDBC年代的connection对象. 还可以完成对数据库中数据的增删改查操作.session是hibernate操作数据库的核心对象
session获得操作事务的Transaction对象
session.save(class);增
session.delete(class);删
session.update(class);改
session.saveorupdate(class);
session.get(Customer.class, 1l);查
session.load(Customer.class, 1l);查使用时加载获得操作事务的tx对象(未开启事物，建议使用下一种) Transaction tx = session.getTransaction(); 开启事务并获得操作事务的tx对象(建议使用) Transaction tx2 = session.beginTransaction();
例子：
public void fun(){
//1 创建,调用空参构造
Configuration conf = new Configuration().configure();
//2 根据配置信息,创建 SessionFactory对象
SessionFactory sf = conf.buildSessionFactory();
//3 获得session
Session session = sf.openSession();
//4 session获得操作事务的Transaction对象
//获得操作事务的tx对象
//Transaction tx = session.getTransaction();
//开启事务并获得操作事务的tx对象(建议使用)
Transaction tx2 = session.beginTransaction();
//----------------------------------------------
//1 获得要修改的对象
Customer c = session.get(Customer.class, 1l);
//2 修改
c.setCust_name("程序员");
//3 执行update
session.update(c);
//----------------------------------------------
tx2.commit();//提交事务
session.close();//释放资源
sf.close();//释放资源
}HQL例子
问号占位符
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1> 书写HQL语句
String hql = " from Customer where cust_id = ? "; // 查询所有Customer对象
//2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
//设置参数
//query.setLong(0, 1l);
query.setParameter(0, 1l);
//3> 根据查询对象获得查询结果
Customer c = (Customer) query.uniqueResult();
System.out.println(c);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
//命名占位符
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1> 书写HQL语句
String hql = " from Customer where cust_id = :cust_id "; // 查询所有Customer对象
//2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
//设置参数
query.setParameter("cust_id", 1l);
//3> 根据查询对象获得查询结果
Customer c = (Customer) query.uniqueResult();
System.out.println(c);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联//分页
//1> 书写HQL语句
String hql ="from Customer order by cust_id asc"; // 查询所有Customer对象
//2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
//设置分页信息 limit ?,?
query.setFirstResult(1);
query.setMaxResults(1);
//3> 根据查询对象获得查询结果
List<Customer> list = query.list();Criteria查询(单表条件查询)
//HQL语句中,不可能出现任何数据库相关的信息的
// > gt
// >= ge
// < lt
// <= le
// == eq
// != ne
// in in
// between and between
// like like
// is not null isNotNull
// is null isNull
// or or
// and and
//创建criteria查询对象
Criteria criteria = session.createCriteria(Customer.class);
//添加查询参数 => 查询cust_id为1的Customer对象
criteria.add(Restrictions.eq("cust_id", 1l));
//执行查询获得结果
Customer c = (Customer) criteria.uniqueResult();
//分页
//创建criteria查询对象
Criteria criteria = session.createCriteria(Customer.class);
//设置分页信息 limit ?,?
criteria.setFirstResult(1);
criteria.setMaxResults(2);
//执行查询
List list = criteria.list(); //查询总记录数
//创建criteria查询对象
Criteria criteria = session.createCriteria(Customer.class);
//设置查询的聚合函数 => 总行数
criteria.setProjection(Projections.rowCount());
//执行查询
Long count = (Long) criteria.uniqueResult();//离线Criteria
//Service/web层
DetachedCriteria **dc** = DetachedCriteria.forClass(Customer.class);
dc.add(Restrictions.idEq(6l));//拼装条件(全部与普通Criteria一致)
//dao层
Criteria c = **dc**.getExecutableCriteria(session);DetachedCriteria (多表关联)
第一步为对象中的命名建立别名
dc.createAlias("region", "r");
//指定封装的方式，这种为对象嵌套例如 （学校（班级（学生名）））如果没有为（学校）（班级（学生名））
detachedCriteria.setResultTransformer(DetachedCriteria.ROOT_ENTITY);原生SQL查询
//1 书写sql语句
String sql = "select * from cst_customer where cust_id = ? ";
//2 创建sql查询对象
SQLQuery query = session.createSQLQuery(sql);
query.setParameter(0, 1l);
//指定将结果集封装到哪个对象中
query.addEntity(Customer.class);
//3 调用方法查询结果(query.list()没有指定addEntity返回Object[])
List<Customer> list = query.list();//Hibernate Utils
public class HibernateUtils {
private static SessionFactory sf;
static{
//1 创建,调用空参构造
Configuration conf = new Configuration().configure();
//2 根据配置信息,创建 SessionFactory对象
sf = conf.buildSessionFactory();
}
//获得session => 获得全新session
public static Session openSession(){
//3 获得session
Session session = sf.openSession();
return session;
}
//获得session => 获得与线程绑定的session
public static Session getCurrentSession(){
//3 获得session
Session session = sf.getCurrentSession();
return session;
}
}- hibernate是一款orm框架
- orm:object relationg mapping. 对象关系映射
- HQL查询-hibernate Query Language(多表查询,但不复杂时使用)
- Criteria查询(单表条件查询)
- 原生SQL查询(复杂的业务查询)
hql多表（略）
//----------------------------------------------------
String hql = " from Customer c right join c.linkMens ";
（left join）（inner join）
Query query = session.createQuery(hql);
List list = query.list();
//HQL 迫切内连接 => 帮我们进行封装.返回值就是一个对象
public void fun2(){
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
String hql = " from Customer c inner join fetch c.linkMens ";
Query query = session.createQuery(hql);
List list = query.list(); //集合级别的关联
//fetch:select 单表查询
//lazy:true 使用时才加载集合数据.
//集合级别的关联
//fetch:select 单表查询
//lazy:false 立即记载集合数据
//集合级别的关联
//fetch:select 单表查询
//lazy:extra 极其懒惰.与懒加载效果基本一致. 如果只获得集合的size.只查询集合的size(count语句)
//集合级别的关联
//fetch:join 多表查询
//lazy:true|false|extra 失效.立即加载.
//fetch: subselect 子查询
//lazy: true 懒加载
//fetch: subselect 子查询
//lazy: false 立即加载
//fetch: subselect 子查询
//lazy: extra 极其懒惰
to -one name="customer" column="lkm_cust_id" class="Customer" fetch="join" lazy="proxy" >
to-one>
//fetch:select 单表查询
//lazy:proxy
//customer-true 懒加载
//fetch:join 多表
//lazy: 失效
//fetch:select 单表查询
//lazy:proxy
//customer-false 立即加载hibernate过滤
悲观锁在session.method里加锁就行 安全，并发效率低
乐观锁在class.hbm.xml里