hibernate_1
来源：互联网 发布：有趣的javascript例子 编辑：程序博客网 时间：2024/06/07 17:42
02-hibernate中的实体-详解
hibernate中的实体规则
实体类创建的注意事项
1、持久化类提供无参构造
2、成员变量私有化，提供公共setter/getter方法，需提供属性
3、持久化类的属性使用包装类型
4、持久化类需提供oid，与数据库中的外键列对应
5、不要用final修饰class
关于主键类型
自然主键（少有）
表的业务列中，有某业务列符合，必须有，且不重复的特征时，该列可以作为主键使用
代理主键（常见）
表的业务列中，没有某业务列符合，必须有，且不重复的特征时，创建一个没有业务意义的列作为主键
03-hibernate中的实体-主键生成策略详解
<id name="cust_id" >
<!-- generator:主键生成策略.就是每条记录录入时,主键的生成规则.(7个)
identity : 主键自增.由数据库来维护主键值.录入时不需要指定主键.
sequence: Oracle中的主键生成策略.
increment(了解):主键自增.由hibernate来维护.每次插入前会先查询表中id最大值.+1作为新主键值，有线程安全。
Hibernate:
select
max(cust_id)
from
cst_customer
Hibernate:
insert
into
cst_customer
(cust_name, cust_source, cust_industry, cust_level, cust_linkman, cust_phone, cust_mobile, cust_id)
values
(?, ?, ?, ?, ?, ?, ?, ?)
hilo(了解):高低位算法.主键自增.由hibernate来维护.开发时不使用.
native:hilo+sequence+identity自动三选一策略.
uuid: 产生随机字符串作为主键. 主键类型必须为string类型.
assigned:自然主键生成策略. hibernate不会管理主键值.由开发人员自己录入.
-->
<generator class="increment"></generator>
</id>
04-hibernate中的对象状态
瞬时状态：没有id，与session无关联
持久化状态；有id，且与session有关联
游离状态| 托管状态：有id，但是与session无关联
@Test
//查看三种状态
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
Customer c = new Customer();// 没有id, 没有与session关联 => 瞬时状态
c.setCust_name("联想");// 瞬时状态
session.save(c);// 持久化状态, 有id,有关联
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//三种状态特点
//save方法: 其实不能理解成保存.理解成将瞬时状态转换成持久状态的方法
//主键自增 : 执行save方法时,为了将对象转换为持久化状态.必须生成id值.所以需要执行insert语句生成.
//increment: 执行save方法,为了生成id.会执行查询id最大值的sql语句.
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
Customer c = new Customer();// 没有id, 没有与session关联 => 瞬时状态
c.setCust_name("联想");// 瞬时状态
session.save(c);// 持久化状态, 有id,有关联
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//三种状态特点
// 持久化状态特点: 持久化状态对象的任何变化都会自动同步到数据库中.
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
Customer c = session.get(Customer.class, 1l);//持久化状态对象
c.setCust_name("微软公司");
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
上图可以理解hibernate的作用：持久化数据。无脑持久化，调用saveOrUpdate方法
05-hibernate中的一级缓存&快照_（理解原理即可，对实际项目并无实际意义）
缓存：提高效率，hibernate中的一级缓存也是为了提高操作数据库的效率
证明一级缓存的存在
@Test
//证明一级缓存存在
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
Customer c1 = session.get(Customer.class, 1l);
Customer c2 = session.get(Customer.class, 1l);
Customer c3 = session.get(Customer.class, 1l);
Customer c4 = session.get(Customer.class, 1l);
Customer c5 = session.get(Customer.class, 1l);
System.out.println(c3==c5);//true
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
console窗口：select语句只执行一次
Hibernate:
select
customer0_.cust_id as cust_id1_0_0_,
customer0_.cust_name as cust_nam2_0_0_,
customer0_.cust_source as cust_sou3_0_0_,
customer0_.cust_industry as cust_ind4_0_0_,
customer0_.cust_level as cust_lev5_0_0_,
customer0_.cust_linkman as cust_lin6_0_0_,
customer0_.cust_phone as cust_pho7_0_0_,
customer0_.cust_mobile as cust_mob8_0_0_
from
cst_customer customer0_
where
customer0_.cust_id=?
true
@Test
//
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
Customer c1 = session.get(Customer.class, 1l);
c1.setCust_name("哈哈");
c1.setCust_name("传智播客");
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//持久化状态对象其实就是放入session缓存中的对象
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
Customer c1 = new Customer();
c1.setCust_id(1l);//托管|游离
session.update(c1);//c1被放入session缓存了
Customer c2 = session.get(Customer.class, 1l);
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联 }
只执行一次sql语句
06-hibernate中的事务相关知识点-隔离级别设置&项目中的事务管理_
06-hibernate中的事务相关知识点-隔离级别设置&项目中的事务管理_
事务：四个特性
原子性a:要么全成功，要么全失败
隔离性i：多个事务并发产生问题
一致性c：数据总量操作前后不变
持久性d：事务一旦提交数据持久化到数据库
事务并发产生的问题：
脏读；读到未提交的数据
不可重复读：两次读取数据不一致
虚读：删表时，别人又添加，好像没删
隔离级别：
读未提交：解决不了任何问题
读已提交：脏读可解决
可重复读：脏读、不可重复读可解决（MySQL默认级别）
串行化：脏读、不可重复读、虚读都解决（效率低，完全不可重复）
hibernate中指定事务级别：
<!-- 指定hibernate操作数据库时的隔离级别
#hibernate.connection.isolation 1|2|4|8
00011读未提交
00102读已提交
01004可重复读
10008串行化
-->
<property name="hibernate.connection.isolation">4</property>
项目中如何管理事务：service中
业务开始之前打开事务 ，业务结束提交事务，中间出现问题回滚事务。
在dao层操作数据库需要用到session对象，在service控制事务也是使用session对象完成。我们要确保dao层和service层使用的是同一个session
在hibernate中，确保使用同一个session的问题，hibernate已经帮我们解决了。我们开发人员只需要调用sf。getCurrentSession（）方法即可获得与当前线程绑定的session对象
注意;调用getCurrentSession方法时必须在主配置文件中添加配置
<property name="hibernate.current_session_context_class">thread</property>
通过getCurrentSession方法获得的session对象当提交事务时，session对象会自动关闭，不要手动调用close方法。
package cn.itheima.d_tx;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
import cn.itheima.domain.Customer;
import cn.itheima.utils.HibernateUtils;
//测试getCurrentSession
public class Demo {
@Test
//返回同一个与线程绑定的session
public void fun1(){
Session session1 = HibernateUtils.getCurrentSession();
Session session2 = HibernateUtils.getCurrentSession();
System.out.println(session1==session2);//true
}
@Test
//返回不同的session
public void fun2(){
Session session1 = HibernateUtils.openSession();
Session session2 = HibernateUtils.openSession();
System.out.println(session1==session2);//false
}
}
07-hibernate中的HQL查询_
三种查询方式
HQL：hibernate query language（多表查询时使用，但复杂程度不大）
criteria查询：（单表查询方便）
原生查询（适合复杂业务查询）
HQL：查询
package cn.itheima.e_hql;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import cn.itheima.domain.Customer;
import cn.itheima.utils.HibernateUtils;
//测试HQL语句
public class Demo {
@Test
//基本查询
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1> 书写HQL语句
//String hql = " from cn.itheima.domain.Customer ";
String hql = " from Customer "; // 查询所有Customer对象
//2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
//3> 根据查询对象获得查询结果
List<Customer> list = query.list();//返回list结果
//query.uniqueResult();//接收唯一的查询结果
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态,有id ,没有关联
}
@Test
//条件查询
//HQL语句中,不可能出现任何数据库相关的信息的
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1> 书写HQL语句
String hql = " from Customer where cust_id = 1 "; //查询id为1Customer对象
//2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
//3> 根据查询对象获得查询结果
Customer c = (Customer) query.uniqueResult();
System.out.println(c);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态,有id ,没有关联
}
@Test
//条件查询
//问号占位符
public void fun3(){
//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 ,没有关联
}
@Test
//条件查询
//命名占位符
public void fun4(){
//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 ,没有关联
}
@Test
//分页查询
public void fun5(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1> 书写HQL语句
String hql = " from Customer "; // 查询所有Customer对象
//2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
//设置分页信息limit ?,?
query.setFirstResult(1);
query.setMaxResults(1);
//3> 根据查询对象获得查询结果
List<Customer> list = query.list();
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态,有id ,没有关联
}
}
08-hibernate中的Criteria查询_无语句调用查询
package cn.itheima.f_criteria;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;
import cn.itheima.domain.Customer;
import cn.itheima.utils.HibernateUtils;
//测试Criteria查询
public class Demo {
@Test
//基本查询
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//查询所有的Customer对象
Criteria criteria = session.createCriteria(Customer.class);
List<Customer> list = criteria.list();
System.out.println(list);
//Customer c = (Customer) criteria.uniqueResult();
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态,有id ,没有关联
}
@Test
//条件查询
//HQL语句中,不可能出现任何数据库相关的信息的
// > gt
// >=ge
// <lt
// <=le
// ==eq
// !=ne
// inin
// between andbetween
// like like
// is not null isNotNull
// is nullisNull
// oror
// andand
上述对应关系的API
java.lang.Object
org.hibernate.criterion.Restrictions
METHOD
Method Summary
static Criterion
allEq(Map propertyNameValues)
Apply an "equals" constraint to each property in the key set of aMap
static LogicalExpression
and(Criterion lhs,Criterion rhs)
Return the conjuction of two expressions
static Criterion
between(String propertyName,Object lo,Object hi)
Apply a "between" constraint to the named property
static Conjunction
conjunction()
Group expressions together in a single conjunction (A and B and C...)
static Disjunction
disjunction()
Group expressions together in a single disjunction (A or B or C...)
static SimpleExpression
eq(String propertyName,Object value)
Apply an "equal" constraint to the named property
static PropertyExpression
eqProperty(String propertyName,String otherPropertyName)
Apply an "equal" constraint to two properties
static SimpleExpression
ge(String propertyName,Object value)
Apply a "greater than or equal" constraint to the named property
static PropertyExpression
geProperty(String propertyName,String otherPropertyName)
Apply a "greater than or equal" constraint to two properties
static SimpleExpression
gt(String propertyName,Object value)
Apply a "greater than" constraint to the named property
static PropertyExpression
gtProperty(String propertyName,String otherPropertyName)
Apply a "greater than" constraint to two properties
static Criterion
idEq(Object value)
Apply an "equal" constraint to the identifier property
static Criterion
ilike(String propertyName,Object value)
A case-insensitive "like", similar to Postgresilike operator
static Criterion
ilike(String propertyName,String value,MatchMode matchMode)
A case-insensitive "like", similar to Postgresilike operator
static Criterion
in(String propertyName,Collection values)
Apply an "in" constraint to the named property
static Criterion
in(String propertyName,Object[] values)
Apply an "in" constraint to the named property
static Criterion
isEmpty(String propertyName)
Constrain a collection valued property to be empty
static Criterion
isNotEmpty(String propertyName)
Constrain a collection valued property to be non-empty
static Criterion
isNotNull(String propertyName)
Apply an "is not null" constraint to the named property
static Criterion
isNull(String propertyName)
Apply an "is null" constraint to the named property
static SimpleExpression
le(String propertyName,Object value)
Apply a "less than or equal" constraint to the named property
static PropertyExpression
leProperty(String propertyName,String otherPropertyName)
Apply a "less than or equal" constraint to two properties
static SimpleExpression
like(String propertyName,Object value)
Apply a "like" constraint to the named property
static SimpleExpression
like(String propertyName,String value,MatchMode matchMode)
Apply a "like" constraint to the named property
static SimpleExpression
lt(String propertyName,Object value)
Apply a "less than" constraint to the named property
static PropertyExpression
ltProperty(String propertyName,String otherPropertyName)
Apply a "less than" constraint to two properties
static NaturalIdentifier
naturalId()
static SimpleExpression
ne(String propertyName,Object value)
Apply a "not equal" constraint to the named property
static PropertyExpression
neProperty(String propertyName,String otherPropertyName)
Apply a "not equal" constraint to two properties
static Criterion
not(Criterion expression)
Return the negation of an expression
static LogicalExpression
or(Criterion lhs,Criterion rhs)
Return the disjuction of two expressions
static Criterion
sizeEq(String propertyName, int size)
Constrain a collection valued property by size
static Criterion
sizeGe(String propertyName, int size)
Constrain a collection valued property by size
static Criterion
sizeGt(String propertyName, int size)
Constrain a collection valued property by size
static Criterion
sizeLe(String propertyName, int size)
Constrain a collection valued property by size
static Criterion
sizeLt(String propertyName, int size)
Constrain a collection valued property by size
static Criterion
sizeNe(String propertyName, int size)
Constrain a collection valued property by size
static Criterion
sqlRestriction(String sql)
Apply a constraint expressed in SQL.
static Criterion
sqlRestriction(String sql,Object[] values,Type[] types)
Apply a constraint expressed in SQL, with the given JDBC parameters.
static Criterion
sqlRestriction(String sql,Object value,Type type)
Apply a constraint expressed in SQL, with the given JDBC parameter.
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//创建criteria查询对象
Criteria criteria = session.createCriteria(Customer.class);
//添加查询参数=>查询cust_id为1的Customer对象
criteria.add(Restrictions.eq("cust_id", 1l));
//执行查询获得结果
Customer c = (Customer) criteria.uniqueResult();
System.out.println(c);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态,有id ,没有关联
}
@Test
//分页查询
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//创建criteria查询对象
Criteria criteria = session.createCriteria(Customer.class);
//设置分页信息limit ?,?
criteria.setFirstResult(1);
criteria.setMaxResults(2);
//执行查询
List<Customer> list = criteria.list();
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态,有id ,没有关联
}
@Test
//查询总记录数
public void fun4(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//创建criteria查询对象
Criteria criteria = session.createCriteria(Customer.class);
//设置查询的聚合函数=>总行数
criteria.setProjection(Projections.rowCount());
//执行查询
Long count = (Long) criteria.uniqueResult();
System.out.println(count);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态,有id ,没有关联
}
}
09-hibernate中的原生SQL查询_
package cn.itheima.g_sql;
import java.util.Arrays;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;
import cn.itheima.domain.Customer;
import cn.itheima.utils.HibernateUtils;
//测试原生SQL查询
public class Demo {
@Test
//基本查询
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1 书写sql语句
String sql = "select * from cst_customer";
//2 创建sql查询对象
SQLQuery query = session.createSQLQuery(sql);
//3 调用方法查询结果
List<Object[]> list = query.list();
//query.uniqueResult();
for(Object[] objs : list){
System.out.println(Arrays.toString(objs));
}
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态,有id ,没有关联
}
@Test
//基本查询
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1 书写sql语句
String sql = "select * from cst_customer";
//2 创建sql查询对象
SQLQuery query = session.createSQLQuery(sql);
//指定将结果集封装到哪个对象中
query.addEntity(Customer.class);
//3 调用方法查询结果
List<Customer> list = query.list();
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态,有id ,没有关联
}
@Test
//条件查询
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//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 调用方法查询结果
List<Customer> list = query.list();
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态,有id ,没有关联
}
@Test
//分页查询
public void fun4(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1 书写sql语句
String sql = "select * from cst_customer limit ?,? ";
//2 创建sql查询对象
SQLQuery query = session.createSQLQuery(sql);
query.setParameter(0, 0);
query.setParameter(1, 1);
//指定将结果集封装到哪个对象中
query.addEntity(Customer.class);
//3 调用方法查询结果
List<Customer> list = query.list();
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态,有id ,没有关联
}
}
- hibernate_1
- Hibernate_1+N问题
- Hibernate持久化类和映射文件 Xxx-hbm.xml ----Hibernate_1
- 安卓等间采样缩放算法的实现与解决ZXing生成DATA MATRIX二维码太小的问题
- Hdu3999 The order of a Tree
- Mycat源码打包-包含各平台安装包
- 归并排序
- HDU 5707 Combine String(动态规划)
- hibernate_1
- Mysql HA 之主从复制
- 关于数据排序8.11
- BOM
- CodeForces-814C An impassioned circulation of affection
- scikit-learn数据预处理
- QAQ & 君临天下 || 天行九歌
- webService类型接口测试脚本开发
- 147_IO_节点流_字节流_文件读取_写出_追加文件
