Hibernate(二)之持久化类的编写规则

最新推荐文章于 2024-04-23 14:45:12 发布

欢乐·猿

最新推荐文章于 2024-04-23 14:45:12 发布

阅读量92

点赞数

本文链接：https://blog.csdn.net/weixin_42278316/article/details/102965509

版权

Hibernate的持久化类的编写规则

无参数构造
属性私有
属性尽量使用包装类
提供一个唯一OID与主键对应
不要使用final修饰

Hibernate的主键生成策略

主键分类

自然主键:具有业务含义的字段，eg表中的名字，身份证等
代理主键：不具有业务含义的字段，eg：ID、pid、nid等

主键生成策略
increment、identity、sequence、uuid
、native、assigned、foreign
在这里插入图片描述
Hibernate的持久化类的三种状态

瞬时态：没有唯一标识OID，没有被session管理
持久态：有唯一标识OID，已经被session管理
脱管态：有唯一标识OID，没有被session管理
状态转换：（了解）

	/**
	 *测试三种状态
	 */
	@Test
	public void test01(){
		//加载配置文件
		Configuration cfg = new Configuration().configure();
		//创建工厂
		SessionFactory sf = cfg.buildSessionFactory();
		//开启回话和事务
		Session session = sf.openSession();
		Transaction tx = session.beginTransaction();
		
		//瞬时态 :没有持久化标识oid,没有被session管理
		Customer customer = new Customer();
		customer.setCust_name("兴欣");
		
		//持久态 :  有持久化标识oid,被session管理
		Serializable id = session.save(customer);
		System.out.println("id="+id);
		
		tx.commit();
		session.close();
		
		//托管态 :   有持久化标识oid,没有被session管理
		System.out.println(customer);
		
	}

在这里插入图片描述

 /**
	 * 测试持久化类的持久态对象有自动更新数据库的能力
	 */
	@Test
	public void test02(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		
		Customer customer = session.get(Customer.class, 9l);
		customer.setCust_name("拉力和");
		
		//不用手动调用update方法就可以更新,依赖hibernate的一级缓存session
		//session.update(customer);
		tx.commit();
		session.close();
		
	}

Hibernate的一级缓存

一级缓存：Hibernate优化手段，称为是session级别缓存。
一级缓存：快照区
在这里插入图片描述

Hibernate解决Service事务

采用的是线程绑定的方式：

		<!-- 事务的隔离级别 4  -->
		<property name="hibernate.connection.isolation">4</property>
		
		<!-- 配置session 绑定本地线程 -->
		<property name="hibernate.current_session_context_class">thread</property>

Hibernate的其他的API
Query ：HQL 面向对象方式的查询。
SQLQuery ：SQL查询

package com.wangshi.hibernate.test01;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import org.junit.runner.Request;

import com.wangshi.hibernate.util.HibernateUtils;


/**
 * @author wanghaichuan
 *测试一级缓存session
 *一级缓存的特殊区域快照区的作用:确保一级缓存中的数据和数据库中的数据是否一致,不一致的话自动更新
 *
 *hibernate中使用 query的步骤：
 *1.获取hibernate的session对象；
 *2.编写HQL语句
 *3.调用session createQuery 创建查询对象；
 *4.如果HQL语句包含参数，则要调用setxxx设置参数
 *5.调用query对象的list()或者 uniqueResult() 方法执行查询
 *
 */

public class hibernateTest02 {
	

	@Test
		/**
	 * 证明hibernate的一级缓存
	 * 一级缓存的特殊区域快照区
	 */
	public void test01(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		//马上发一条sql查询一号客户,并 将数据存到一级缓存
		Customer customer1 = session.get(Customer.class, 9l);
		System.out.println("customer01="+customer1);
		
		//没有发生sql查询一号客户,到一级缓存中获取数据
		Customer customer2 = session.get(Customer.class, 9l);
		System.out.println("customer02="+customer2);
		
		//如果是TRUE,一级缓存存的是对象的地址
		System.out.println(customer1 == customer2);
		tx.commit();
		session.close();
		
	}
	
	/**
	 *hibernate的其他api
	 *查询 HQL之基本查询
	 */
	@Test
	public void test02(){
		//获取hibernate的session对象
		Session session = HibernateUtils.getCurrentSession();
		//开启事务
		Transaction tx = session.beginTransaction();
		
		//代码编写  查询Customer对象
		String hql="from Customer";
		 //根据HQL语句创建查询对象
		Query query = session.createQuery(hql);
		//根据查询对象获得查询结果
		List<Customer> list = query.list();// 返回list结果
		System.out.println("list"+list);
		
		//query.uniqueResult();//接收唯一的查询结果
		tx.commit();
		
	}
	
	@Test
	//条件查询
	//HQL语句中,不可能出现任何数据库相关的信息的
	public void test03(){
		//获得hibernate的session对象
		Session session = HibernateUtils.openSession();
		//开启事务
		Transaction tx = session.beginTransaction();
		
		//代码编写
		String hql = "from Customer where cust_id=9";
		Query query = session.createQuery(hql);
		
		Customer customer = (Customer)query.uniqueResult();
		
		System.out.println(customer);
		//释放资源
		tx.commit();
		session.close();
		
	}

	@Test
	//条件查询
	//问号占位符
	public void test04(){
		
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		Query query = session.createQuery("from Customer where cust_id=?");
		//设置参数
		//query.setLong(0, 9l);
		query.setParameter(0, 9l);
		
		Customer customer = (Customer) query.list();
		System.out.println(customer);
		
		tx.commit();
		session.close();

	}
	
	@Test
	//条件查询
	//命名占位符
	
	public void test05(){
		
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		Query query = session.createQuery("from Customer where cust_id=:cust_id");
		//设置参数
		query.setParameter("cust_id", 9l);
		
		Customer customer = (Customer) query.uniqueResult();
		System.out.println(customer);
		
		tx.commit();
		session.close();
		
	}

	@Test
	//分页查询
	public void test06(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		Query query = session.createQuery("from Customer ");
		//设置分页信息 limit
		//设置第一个记录的位置，从第几条记录开始，默认0；
		query.setFirstResult(1);
		//设置结果集的最大记录数，限制结果集范围
		query.setMaxResults(3);
		
		List<Customer> list =  query.list();
		System.out.println(list);
		tx.commit();
		session.close();
	}




}

Criteria ：QBC 完成面向对象化。

package com.wangshi.hibernate.test01;

import java.util.List;

import org.dom4j.bean.BeanAttribute;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

import com.wangshi.hibernate.util.HibernateUtils;

/**
 * @author wanghaichuan
 *测试Criteria查询  QBC
 *步骤：
 *1.获得hibernate的session对象
 *2.通过session获得Criterion对象
 *3.使用restrictions的静态方法创建criterion条件对象
 *4.添加查询条件
 *5.执行获得结果
 */
public class hibernateTest03 {
	
	//基本查询 Criteria
	@Test
	public void test(){
		Session session = HibernateUtils.openSession();
		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();
		
		tx.commit();
		session.close();
	}

	@Test
	//条件查询
	//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
	public void test02(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		Criteria criteria = session.createCriteria(Customer.class);
		//添加查询参数 => 查询cust_id为1的Customer对象
		criteria.add(Restrictions.eq("cust_id", 9l));
		
		Customer customer = (Customer) criteria.uniqueResult();
		System.out.println(customer);
		
		tx.commit();
		session.close();
	}
	
	@Test
	//分页查询
	public void test03(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		Criteria criteria = session.createCriteria(Customer.class);
		//设置分页信息 limit ?,?
		criteria.setFirstResult(0);
		criteria.setMaxResults(4);
		
		List<Customer>list = criteria.list();
		System.out.println(list);
		
		tx.commit();
		session.close();
	}
	
	@Test
	//查询总记录数
	public void test04(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		Criteria criteria = session.createCriteria(Customer.class);
		//设置查询的聚合函数 => 总行数
		criteria.setProjection(Projections.rowCount());
		
		Long count = (Long) criteria.uniqueResult();
		System.out.println(count);
		
		tx.commit();
		session.close();
	}
	
}

欢乐·猿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Hibernate(二)之持久化类的编写规则

Hibernate的持久化类的编写规则无参数构造属性私有属性尽量使用包装类提供一个唯一OID与主键对应不要使用final修饰Hibernate的主键生成策略主键分类自然主键:具有业务含义的字段，eg表中的名字，身份证等代理主键：不具有业务含义的字段，eg：ID、pid、nid等主键生成策略increment、identity、sequence、uuid、native、a...
复制链接

扫一扫