您的位置: 首页  >  文章  >  Hibernate——笔记02

Hibernate——笔记02

分类: 文章 • 2024-04-28 19:33:20

Hibernate主键增长策略

  1. native（自增长）
  2. uuid（使用长度为16位uuid作为主键值）
    1）映射文件的配置
		<id name="uid" column="uid">
			<!-- 
				设置字段属性
				class:native 就是设置该字段为主键并且自增长
			 	class:uuid 使用长度为16位uuid作为主键值
			 -->
			<generator class="native"></generator>
		</id>

实体类的操作

  1. 实体类对象的状态
    1）瞬时态：与session没关系且id没有值
    2）持久态：与session有关系且id有值
    3）托管态：与session没关系且id有值
  2. 通过实体类的增删改查操作
    1）save()：保存，参数为实体类对象
    2）delete()：删除，参数为实体类对象
    3）update()：更新，参数为实体类对象
    4）get(Class clazz, serializable arg )：查询，根据id查询，参数为删除对象对应的实体类，以及主键值
查询
package tqb.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import tqb.entity.User;
import utils.HibernateUtils;

/**
 * get方法测试
 * 通过id查询数据
 * @author tqb
 *
 */
public class Demo2 {
	
	@Test
	public void testGet(){
		//使用工具类获得对象
		SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
		
		//获得session
		Session session = sessionFactory.openSession();
		
		//开启事务
		Transaction transaction = session.beginTransaction();
		
		User user = session.get(User.class, 1);
		System.out.println(user);
		
		//提交事务
		transaction.commit();
		
		session.close();
		sessionFactory.close();
	}
}
更新
package tqb.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import tqb.entity.User;
import utils.HibernateUtils;

/**
 * 修改数据 
 * @author tqb
 *
 */
public class Demo3 {
	@Test
	public void testUpdate(){
		SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
		Session session = sessionFactory.openSession();
		
		Transaction transaction = session.beginTransaction();
		
		/**
		 * 一般我们在做修改数据之前，首先进行查询
		 * 这时的user对象我们称呼为持久态对象（与session有关联的对象）
		 */
		User user = session.get(User.class, 1);
		user.setUsername("lisi");
		user.setPwd("654321");
		//这时倘若用save也会有相同的效果，这和user对象的状态有关
		session.update(user);
		
		transaction.commit();
		session.close();
		sessionFactory.close();
	}
}
删除
package tqb.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import tqb.entity.User;
import utils.HibernateUtils;

/**
 * 删除操作
 * @author tqb
 *
 */
public class Demo4 {
	@Test
	public void testDelete(){
		SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		
		/*
		 * 首先进行查询操作
		 */
		User user = session.get(User.class, 1);
		session.delete(user);
		
		transaction.commit();
		session.close();
		sessionFactory.close();
	}
}
SaveOrUpdate方法的使用
package tqb.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import tqb.entity.User;
import utils.HibernateUtils;

/**
 * SaveOrUpdate方法测试
 * 状态不同，效果不同
 * 实体对象的三种状态
 * 瞬时态（对象里没有id值且和session没有关系）、持久态（对象有id值且和session有关系）、托管态（对象有id值但是和session没有关系）
 * @author tqb
 *
 */
public class Demo5 {
	@Test
	public void testSaveOrUpdate(){
		SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		
		//对象是持久态，更新
//		User user = session.get(User.class, 1);
//		user.setUsername("wangmazi");
//		session.saveOrUpdate(user);
		
		//对象是托管态,更新
//		User user = new User();
//		user.setUid(1);
//		user.setUsername("zhangsan");
//		user.setPwd("123");
//		session.saveOrUpdate(user);
		
		//对象是瞬时态，插入
		User user = new User();
		user.setUsername("wangmazi");
		user.setPwd("123");
		session.saveOrUpdate(user);
		
		transaction.commit();
		session.close();
		sessionFactory.close();
	}
}

代码的规范化书写

package tqb.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import tqb.entity.User;
import utils.HibernateUtils;

/**
 * hibernate代码的规范性书写
 * 
 * @author tqb
 *
 */
public class Demo8 {
	@Test
	public void fun() {
		SessionFactory sessionFactory = null;
		Session session = null;
		Transaction transaction = null;
		try {
			sessionFactory = HibernateUtils.getSessionFactory();
			session = sessionFactory.openSession();
			transaction = session.beginTransaction();

			User user = session.get(User.class, 1);
			System.out.println(user);

		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		} finally {
			//项目中不用关闭
			if (sessionFactory != null)
				sessionFactory.close();
		}
	}
}

Hibernate的缓存机制

  1. Hibernate的缓存机制拥有一级缓存机制和二级缓存机制
  2. 一级缓存机制（默认开启）
    1）使用范围：session开启到session关闭
    2）在第一次查询时将user持久态对象保存到一级缓存区
    3）在第二次查询时在缓存区判断是否存在，存在的话直接拿来使用，不在的话执行第二步
  3. 二级缓存机制（默认关闭，很少使用，或者不使用）
  4. 一级缓存机制的特性
    1）更新数据时，若更新的数据与原先查询出来保存在副本的数据不同时，不用写更新语句即可更新
验证代码
package tqb.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import tqb.entity.User;
import utils.HibernateUtils;

/**
 * hibernate的一级缓存机制（默认打开）和二级缓存机制（默认关闭）
 * 一级缓存机制：
 * 第一次查询时将得到的user对象保存到缓存区，且打印sql语句
 * 第二次查询在缓存区查找是否存在
 * 存在的话直接拿来
 * @author tqb
 *
 */
public class Demo6 {
	@Test
	public void fun(){
		SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
		Session session = sessionFactory.openSession();
		
		Transaction transaction = session.beginTransaction();
		
		//输出sql语句，打印user
		User user = session.get(User.class, 1);
		System.out.println(user);
		
		//打印user
		User user1 = session.get(User.class, 1);
		System.out.println(user1);
		
		transaction.commit();
		
		session.close();
		sessionFactory.close();
	}
}
验证结果

Hibernate——笔记02

一级缓存机制的特性
package tqb.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import tqb.entity.User;
import utils.HibernateUtils;

/**
 * 一级缓存机制的特性
 * @author tqb
 *
 */
public class Demo7 {
	@Test
	public void fun(){
		SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
		Session session = sessionFactory.openSession();
		
		Transaction transaction = session.beginTransaction();
		
		User user = session.get(User.class, 1);
		user.setUsername("wangwu");
		
		//此处不用写update依然会进行更新操作，因为hibernate会自动进行检测（判断缓存区的数据与副本数据是否相同，相同则会更新，不相同则不会）
//		session.update(user);
		
		transaction.commit();
		
		session.close();
		sessionFactory.close();
	}
}

session与Hibernate的绑定

  1. 在核心配置文件中添加如下内容
  2. session不用关闭，每次使用完成后自动关闭，sessionFactory不用关闭，实际项目中是一直开启的
<property name="hibernate.current_session_context_class">thread</property>

package tqb.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import tqb.entity.User;
import utils.HibernateUtils;

/**
 1. 在hibernate中绑定Session
 2. 在核心配置文件中添加如下：
 3. <property name="hibernate.current_session_context_class">thread</property>
 4. @author tqb
 5.  */
public class Demo9 {
	@Test
	public void fun(){
		Session session = null;
		Transaction transaction = null;
		try {
			//调用sessionFactory的getCurrentSession方法
			session = HibernateUtils.getSessionObject();
			transaction = session.beginTransaction();

			User user = session.get(User.class, 1);
			System.out.println(user);

		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}
	}
}

Hibernate其它API的使用

  1. Query：使用hql（hibernate query language）进行查询，结果为实体类对象的所有集合
  2. Criteria：结果为实体类对象的所有集合
  3. SQLQuery：使用正常的sql查询语句进行查询，结果为数组形式的所有集合
Query
package tqb.test;

import java.util.List;

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

import tqb.entity.User;
import utils.HibernateUtils;

/**
 * 使用Query对象查询所有结果
 * @author tqb
 *
 */
public class Demo10 {
	@Test
	public void fun(){
		Session session = null;
		Transaction transaction = null;
		try {
			//调用sessionFactory的getCurrentSession方法
			session = HibernateUtils.getSessionObject();
			transaction = session.beginTransaction();
			
			//参数为hql语言（hibernate query language）
			Query query = session.createQuery("from User");
			List<User> list = query.list();
			for (User user : list) {
				System.out.println(user);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}
	}
}
Criteria
package tqb.test;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import tqb.entity.User;
import utils.HibernateUtils;

/**
 * 使用Criteria查询所有结果
 * @author tqb
 *
 */
public class Demo11 {
	@Test
	public void fun(){
		Session session = null;
		Transaction transaction = null;
		try {
			//调用sessionFactory的getCurrentSession方法
			session = HibernateUtils.getSessionObject();
			transaction = session.beginTransaction();
			
			Criteria criteria = session.createCriteria(User.class);
			List<User> list = criteria.list();
			for (User user : list) {
				System.out.println(user);
			}
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}
	}
}
SQLQuery
package tqb.test;

import java.util.List;

import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import tqb.entity.User;
import utils.HibernateUtils;

public class Demo12 {
	@Test
	public void fun(){
		Session session = null;
		Transaction transaction = null;
		try {
			//调用sessionFactory的getCurrentSession方法
			session = HibernateUtils.getSessionObject();
			transaction = session.beginTransaction();
			
			//参数为sql查询语句
			SQLQuery sqlQuery = session.createSQLQuery("select * from t_user");
			//查询出来的结果是数组
//			List<Object[]> list = sqlQuery.list();
//			for (Object[] objects : list) {
//				System.out.println(Arrays.toString(objects));
//			}
			
			//将查询结果添加成指定的实体对象
			sqlQuery.addEntity(User.class);
			List<User> list = sqlQuery.list();
			for (User user : list) {
				System.out.println(user);
			}
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}
	}
}

相关推荐