Hibernate-总结

迈不过友情╰ 2022-07-11 07:12 116阅读 0赞

Hibernate作为轻量级的持久层框架，大大简化了编程人员操作步骤，提高了开发效率，使得开发更具对象化，增强了可移植性，实现了持久化（JPA）规范。

我们先来看一下框架结构：

![SouthEast][]

由Hibernate的体系结构我们可以看出，Hibernate通过session实现持久化状态与瞬时状态之间相互转化；SessionFactory用于创建Session实例；JDBC用于连接相应数据库；支持JNDI（Java Naming Directory Interface）和JTA（Java Transaction API）。

此次学习的Hibernate框架内容：

![SouthEast 1][]

Hibernate主要包括配置文件配置，关联映射的实现，提供的数据查询机制，以及优化策略。关键部分在于关联映射以及xml关联文件的配置，另外，Hibernate中提供的HQL机制大大简化了编程人员对SQL的编写，而是自动生成sql语句；针对于HQL生成的语句存在冗余，导致大量的数据库开关操作，因此提出了抓取策略，和缓存机制，大大提高系统性能。

#  【配置文件】 #

Hibernate配置文件必须连接数据库，需要添加数据库连接驱动，数据库地址，用户名和密码，数据库方言；实现数据库与实体映射，必须将配置好的映射文件添加入hibernate配置中：

<hibernate-configuration>
    	<session-factory>
    		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>
    		<property name="hibernate.connection.username">root</property>
    		<property name="hibernate.connection.password">root</property>
    		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
    		<property name="hibernate.show_sql">true</property>  
    		<property name="hibernate.format_sql">true</property>   
    		
    		<mapping resource="com/whp/hibernate/User.hbm.xml"></mapping>  
    	</session-factory>
    </hibernate-configuration>

除此之外最常用的二级缓存的配置也可以根据需要配置在session-factory中：

<class-cache class="com.whp.hibernate.Student" usage="read-only"/>

# 【xml映射文件】 #

我们先从一个简单的实例入手：

<hibernate-mapping>
    	<class name="com.whp.hibernate.Classes" table="t_classes">
    		<id name="id">
    			<generator class="native"/>
    		</id>
    		
    		<property name="name"/>
    		<set name="students" inverse="true">  
    			<key column="classesid"/>
    			<one-to-many class="com.whp.hibernate.Student"/>
    		</set>
    	</class>
    </hibernate-mapping>

针对每一个xml映射文件标签Hibernate提供了大量的属性，我们主要掌握一些常用的即可：

（1）<hibernate-mapping>标签通常为简化对类和jar包的引用，提供了Package属性。

（2）<class>标签除了name指定类名称，table指定表名之外，最常见的有：

select-befor-update:true|false 除非数据库要执行的update数据已经被修改，否则不会修改，在update之前先发出sql查询。

where：sql语句  在抓取类的对象时一直增加该where条件

batch-size：默认为1  抓取实例时的数量

optimistic-lock="none|version|dirty|all" 默认为version，乐观锁的策略

lazy="true|false" 指定是否进行延迟加载

mutable="true|false" 如果为false将不能被程序更新和删除

（3）<id>常见属性为name，type，column（对应数据库表字段名称），<generator>子元素是java类的名字，用来为持久化实例生成唯一标识，如果需要实例化某些配置或初始化参数，用<param>元素传递。

generator提供的class限定id的特性：

increment:在插入数据生成自增长的唯一标识

identity:支持int，short或者int的唯一标识

hilo：使用高地位算法生成的唯一标识符

sequence：在DB2，Oracle中使用序列，不支持mysql

uuid：128bit的标识符，由32位字符串组成

GUID：在sql，mysql中生成GUID字符串

native：根据底层数据库选择identity，sequence，hilo中一个

assigned：应用程序在save（）之前为对象动态生成的表示符

foreign：使用另外一个相关联的对象标识符，与<one-to-one>联合使用

（4）<discriminator> 鉴别器在一棵对象继承叔应用一个表的策略中，该元素是必须的。如下应用：

（5）<version> 在配置乐观锁时用到

（6）<peorperty>常用的属性为：name，column，type，unique，length

有关关系映射的配置请见博客：《[hibernate--关联映射][hibernate--]》

# 【查询】 #

hibernate支持Criteria query，HQL，Native SQL Queries三种查询结构。

标准化对象查询可以动态向查询语句中添加条件，如：

Criteria criteria=session.createCtriteria(User.class);
    	Criteria.add(Expression.like("name","J%"));
    	List users=criteria.list();

下面主要针对HQL查询展开讨论：

（1）简单属性查询：

List list=session.createQuery("select id,name from student").query();
    		For(Iterator iter=students.iterator();iterator.hasnext();){
    			Object[] obj=(Object[])iter.next();
    			System.out.println(obj[0]+","+obj[1]);
    		}

（2）想要查询返回实体结合，则需要添加构造函数：

List stuList=session.createQuery("select new Student(id,name) from Student").list();
    				
    	for(Iterator iterator=stuList.iterator();iterator.hasNext();){
    		Student student=(Student)iterator.next();
    		System.out.println("id:"+student.getId()+",name:"+student.getName());
    	}

（3）全部实体对象查询

List stuList=(List)session.createQuery("from Student").list();
    	
    	for(Iterator iterator=stuList.iterator();iterator.hasNext();){
    		Student student=(Student)iterator.next();
    		System.out.println("id:"+student.getId()+",name:"+student.getName());
    	}

（4）使用迭代器查询

Iterator iterator =session.createQuery("from Student").iterate();
    	while(iterator.hasNext()){
    		Student student=(Student)iterator.next();
    		System.out.println("id:"+student.getId()+",name:"+student.getName());
    	}

迭代器查询，数据返回时会出现 **N+1**问题，即查询出n条数据，会发出n+1条查询语句。 执行结果如下：

Hibernate: select student0_.id as col_0_0_ from t_student student0_
    	Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.createDate as createDate1_0_, student0_.classesid as classesid1_0_ from t_student student0_ where student0_.id=?
    	id:1,name:张三
    	Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.createDate as createDate1_0_, student0_.classesid as classesid1_0_ from t_student student0_ where student0_.id=?
    	id:2,name:李四
    	Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.createDate as createDate1_0_, student0_.classesid as classesid1_0_ from t_student student0_ where student0_.id=?
    	id:3,name:李老三
    	Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.createDate as createDate1_0_, student0_.classesid as classesid1_0_ from t_student student0_ where student0_.id=?
    	id:4,name:昆明
    	Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.createDate as createDate1_0_, student0_.classesid as classesid1_0_ from t_student student0_ where student0_.id=?
    	id:7,name:昆明
    	Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.createDate as createDate1_0_, student0_.classesid as classesid1_0_ from t_student student0_ where student0_.id=?
    	id:10,name:李老三
    	Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.createDate as createDate1_0_, student0_.classesid as classesid1_0_ from t_student student0_ where student0_.id=?
    	id:12,name:昆明
    	Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.createDate as createDate1_0_, student0_.classesid as classesid1_0_ from t_student student0_ where student0_.id=?
    	id:11,name:王老五

（5）条件查询：

1）使用占位符：

List stuList=session.createQuery("select s.id,s.name from Student s where s.name like ?")
    							.setParameter(0, "%李%")
    							.list();
    							
    		List stuList=session.createQuery("select s.id,s.name from Student s where s.id in(?,?,?,?,?)")
    							.setParameter(0,new Integer(1))
    							.setParameter(1,new Integer(2))
    							.setParameter(2,new Integer(3))
    							.setParameter(3,new Integer(4))
    							.setParameter(4,new Integer(5))
    							.list();

2）采用参数名称的形式：

List stuList=session.createQuery("select s.id,s.name from Student s where s.name like :myname")
    							.setParameter("myname", "%李%")
    							.list();
    							
    		List stuList=session.createQuery("select s.id,s.name from Student s where s.id in(:ids)")
    							.setParameterList("ids", new Object[]{new Integer(1),new Integer(1),new Integer(2),new Integer(3),new Integer(4)})
    							.list();

3）使用mysql函数：

List stuList=session.createQuery("select s.id,s.name from Student s where date_format(s.createDate,'%Y-%m')=?")
    							.setParameter(0, "2017-01")
    							.list();

4）分页查询：

List stuList=session.createQuery("from Student")
    						.setFirstResult(1)
    						.setMaxResults(5)
    						.list();
    		for(Iterator iterator=stuList.iterator();iterator.hasNext();){
    			Student student=(Student)iterator.next();
    			System.out.println("id:"+student.getId()+",name:"+student.getName());
    		}

5）对象导航查询：

List stuList=session.createQuery("from Student s where s.classes.name like '%二班%'")
    						.list();
    	for(Iterator iterator=stuList.iterator();iterator.hasNext();){
    		Student student=(Student)iterator.next();
    		System.out.println("id:"+student.getId()+",name:"+student.getName());
    		
    	}

6）内连接查询：

List stuList=session.createQuery("select c.name,s.name from Student s join s.classes c")
    							.list();
    	for(Iterator iterator=stuList.iterator();iterator.hasNext();){
    		Object[] objects=(Object[])iterator.next();
    		System.out.println("className:"+objects[0]+",StudentName:"+objects[1]);
    	}

7）统计查询

List stuList=session.createQuery("select count(*) from Student")
    							.list();
    	Long countLong=(Long)stuList.get(0);
    	System.out.println(countLong);
    	
    	Long countLong=(Long)session.createQuery("select count(*) from Student").uniqueResult();
    	System.out.println(countLong);
    	
    	Long countLong=(Long)session.createQuery("select count(*) from Student").setMaxResults(1).uniqueResult();
    	System.out.println(countLong);
    	
    	
    	//统计班级人数
    	String hqlString="select c.name,count(s) from Classes c join c.students s group by c.name order by c.name";
    				
    	List stuList=session.createQuery(hqlString)
    			.list();
    	for(Iterator iterator=stuList.iterator();iterator.hasNext();){
    		Object[] objects=(Object[])iterator.next();
    		System.out.println("className:"+objects[0]+",StudentNum:"+objects[1]);
    	}

（6）过滤器的使用：

a. 在映射文件中定义过滤器
    		<filter-def name="testFilter">
    			<filter-param name="myid" type="integer"/>
    		</filter-def>
    		b. <class>标签总引用过滤器
    		<filter name="testFilter" condition="id < :myid"></filter>
    		
    		c. 在session中调用
    
    Session.enableFilter("testFilter").setParameter("myid",new Integer(10));

# 【优化】 #

1. 锁，在高并发情况下为避免出现数据脏读问题提出的。分为乐观锁和悲观锁，悲观锁在执行过程中把数据锁住，只要事务不释放，任何其他用户不能查看和修改：

Inventory inventory=(Inventory)session.load(Inventory.class, "1001",LockMode.UPGRADE);

乐观锁不是一种锁，是一种检测冲突的手段，有很多实现方式，最主要是通过设置版本号，低版本数据不能更新高版本数据。实现过程如上面。

[SouthEast]: /images/20220711/1496cbff7bbd449ca201ab01ff40d21b.png
[SouthEast 1]: /images/20220711/3ffbf3c232b24026ba7ae986cc82727a.png
[hibernate--]: http://blog.csdn.net/whp15369657805/article/details/54580570