Hibernate_抓取策略_Annotation

最新推荐文章于 2018-08-28 16:40:05 发布
最新推荐文章于 2018-08-28 16:40:05 发布
阅读量238 收藏
点赞数
分类专栏： hibernate 文章标签： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34805046/article/details/51476016
版权 
package org.com.test.model;

import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import org.hibernate.annotations.LazyCollection;
import org.hibernate.annotations.LazyCollectionOption;
@Entity
@Table(name="t_special")
public class Special {
	private int id;
	private String name;
	private String type;
	private Set<Classroom> classrooms;
	
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@OneToMany(mappedBy="special")
	@LazyCollection(LazyCollectionOption.EXTRA)
	public Set<Classroom> getClassrooms() {
		return classrooms;
	}
	public void setClassrooms(Set<Classroom> classrooms) {
		this.classrooms = classrooms;
	}
	
	
}


package org.com.test.model;

import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import org.hibernate.annotations.BatchSize;
import org.hibernate.annotations.Fetch;
import org.hibernate.annotations.FetchMode;
import org.hibernate.annotations.LazyCollection;
import org.hibernate.annotations.LazyCollectionOption;
@Entity
@Table(name="t_classroom")
@BatchSize(size=20)
public class Classroom {
	private int id;
	private String name;
	private int grade;
	private Set<Student> students;
	private Special special;
	
	public int getGrade() {
		return grade;
	}
	public void setGrade(int grade) {
		this.grade = grade;
	}
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@OneToMany(mappedBy="classroom")//给Student中的属性classroom维护关系
	@LazyCollection(LazyCollectionOption.EXTRA)//用Classroom查询收集学生的时候，默认EXTRA(自动关联)；使收集Student时有延迟加载
	@Fetch(FetchMode.SUBSELECT)//使收集Student时，使用关联子查询；让查询每个班的学生的时候不用每个班都发一条sql
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
	@ManyToOne(fetch=FetchType.LAZY)//默认是EAGER自动关联到Special，使用LAZY可以恢复延迟加载
	@JoinColumn(name="s_id")//Special在Classroom的表的列名
	public Special getSpecial() {
		return special;
	}
	public void setSpecial(Special special) {
		this.special = special;
	}
	
	
}


package org.com.test.model;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name="t_student")
public class Student {
	private int id;
	private String name;
	private String sex;
	private Classroom classroom;
	
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	@ManyToOne(fetch=FetchType.LAZY)
	@JoinColumn(name="c_id")
	public Classroom getClassroom() {
		return classroom;
	}
	public void setClassroom(Classroom classroom) {
		this.classroom = classroom;
	}
	
}


package org.com.test.test;

import java.util.List;

import org.com.test.model.Classroom;
import org.com.test.model.Student;
import org.com.test.util.HibernateUtil;
import org.hibernate.Session;
import org.junit.Test;
/**
 * 
 * @author asus_n56 基于Annotation配置的Demo
 *
 */
public class TestFetch {
	
	
	@Test
	public void test01(){
		Session session = null;
		try {
			/**
			 * 对于Annotation的配置而言，默认就是基于join的抓取的，所以只会发一条sql.
			 */
			session = HibernateUtil.getSession();
			session.beginTransaction();
			Student s = (Student)session.load(Student.class, 1);
			System.out.println(s.getName()+":"+s.getClassroom().getName()+":"+s.getClassroom().getSpecial().getName());
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtil.closeSession(session);
		}
		
	}
	
	
	@SuppressWarnings("unchecked")
	@Test
	public void test02(){
		Session session = null;
		try {
			/**
			 * 对于Annotation的配置没有延迟加载，此时会把所有的关联对象查询上来，发大量的sql语句
			 * 解决办法是：在Student的@ManyToOne(fetch=FetchType.LAZY)中这么设置；但是这样子，test01就发两条sql了。
			 */
			session = HibernateUtil.getSession();
			session.beginTransaction();
			List<Student> stus = session.createQuery("from Student").list();
			for (Student stu : stus) {
				//System.out.println(stu.getName());
				System.out.println(stu.getName()+";"+stu.getClassroom());//这个查询每个班都发一条sql
			}
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtil.closeSession(session);
		}
		
	}
	
	@SuppressWarnings("unchecked")
	@Test
	public void test03(){
		Session session = null;
		try {
			/**
			 * 在xml中配置的fetch=join仅仅是对load的对象有用，对HQL查询的对象没有用。所以会发出查询班级的sql。
			 * 解决这种问题有两种方案：一种是设置对象的抓取的batch-size
			 * 另一种方案：在HQL中使用fetch来指定抓取
			 */
			session = HibernateUtil.getSession();
			session.beginTransaction();
			List<Student> stus = session.createQuery("from Student").list();
			for (Student stu : stus) {
				//System.out.println(stu.getName());
				System.out.println(stu.getName()+";"+stu.getClassroom());
			}
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtil.closeSession(session);
		}
		
	}
	
	
	@SuppressWarnings("unchecked")
	@Test
	public void test04(){
		Session session = null;
		try {
			/**
			 * 在xml中配置的fetch=join仅仅是对load的对象有用，对HQL查询的对象没有用。所以会发出查询班级的sql。
			 * 解决这种问题有两种方案：一种是设置对象的抓取的batch-size
			 * 另一种方案：在HQL中使用fetch来指定抓取
			 * 特别注意：使用了join fetch 就不能使用count（*）
			 * 
			 * 基于Annotation由于默认的many to one 的抓取策略是EAGER的，所以在抓取classroom的时候会自动去抓取special
			 * 会发出大量的sql。此时可以继续发join fetch继续对关联的抓取；
			 * 或者直接将关联对象的fetch设置为lazy，但是使用lazy所带来的问题是在查询关联对象的时候会发出想用sql，影响效率
			 */
			session = HibernateUtil.getSession();
			session.beginTransaction();
			List<Student> stus = session.createQuery("select stu from Student stu "
					+ "join fetch stu.classroom cla join fetch cla.special").list();
			for (Student stu : stus) {
				System.out.println(stu.getName()+";"+stu.getClassroom());
			}
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtil.closeSession(session);
		}
		
	}
	
	/*
	 * ************************************************基于1的一方查询**************************************************	
	 */
		
		@SuppressWarnings("unchecked")
		@Test
		public void test05(){
			Session session = null;
			try {
				/**
				 * 对于通过HQL取班级列表并且获取相应的学生列表时，fecth=join就无效了
				 * 第一种方案可以设置set的batch-size来完成批量的抓取
				 * 第二中方案可以设置fetch=subselect,使用subselect会完成根据查询出来的班级进行一次对学生对象的子查询
				 * 	@OneToMany(mappedBy="classroom")
				 *	@LazyCollection(LazyCollectionOption.EXTRA)
				 *	@Fetch(FetchMode.SUBSELECT)
				 *	public Set<Student> getStudents() {
				 *		return students;
				 *	}
				 */
				session = HibernateUtil.getSession();
				session.beginTransaction();
				List<Classroom> clas = session.createQuery("from Classroom").list();
				for (Classroom cla : clas) {
					System.out.println(cla.getName());
					for (Student stu : cla.getStudents()) {
						System.out.println(stu.getName());
					}
				}
				session.getTransaction().commit();
			} catch (Exception e) {
				e.printStackTrace();
				session.getTransaction().rollback();
			}finally {
				HibernateUtil.closeSession(session);
			}
			
		}
}

业精_于勤
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate_3.2.0_符合Java习惯的关系数据库持久化
01-14
19.1.2. 调整抓取策略（Tuning fetch strategies） 19.1.3. 单端关联代理（Single-ended association proxies） 19.1.4. 实例化集合和代理（Initializing collections and proxies） 19.1.5. 使用批量抓取（Using...
HibernateAPI中文版.chm
10-07
19.1.2. 调整抓取策略（Tuning fetch strategies） 19.1.3. 单端关联代理（Single-ended association proxies） 19.1.4. 实例化集合和代理（Initializing collections and proxies） 19.1.5. 使用批量抓取（Using...
hibernate annotations
lhh_hoo的专栏
07-06 915
CascadeType.PERSIST （级联新建） CascadeType.REMOVE （级联删除） CascadeType.REFRESH （级联刷新） CascadeType.MERGE （级联更新）中选择一个或多个。 CascadeType.ALL 有时候CascadeType不行，解决方法：利用hibe
Hibernate中子查询（subselect）的使用
码农的田园
07-19 1万+
有些数据库不支持视图的创建，而实际业务中我们需要通过视图才能实现我们的需求，这时就可以使用Hibernate中子查询（subselect） 一，官方文档说明 There is no difference between a view and a base table for a Hibernate mapping. This is transparent at the database lev
hibernate annotation 之mappedBy 与 @JoinColumn区别
码农的田园
02-25 4671
1.一对多的映射(one-to-many) @Entity @Table(name="t_classroom") public class ClassRoom { private int id; private String className; private Set students; @OneToMany(mappedBy="room")　　 --->
Hibernate4
public_sbw的博客
02-02 201
Hibernate的多表操作： 1、交叉连接 2、内连接 显示内连接 sql: select * from 表A inner join 表B on 关联条件 hql: from 类 X inner join X.另在该的引用 with 条件 隐式内连接关联条件 hql: from 类 X where X.另在该的引用.关联外键对应 迫切内连接【****】 hql: select
hibernate LazyInitializationException 懒加载异常的四种解决方案
lxw1005192401的博客
08-28 5978
简介：org.hibernate.LazyInitializationException:could not initialize proxy - no Session （懒加载异常在默认情况下，hibernate为懒加载），这意味着在读取数据的时候，Session已经关闭。 解决方案（四种）：   第一种：在get属性方法上添加@JSON(Serialize=false)注解， 在转j...
hibernate3.2中文文档（chm格式）
08-16
19.1.2. 调整抓取策略（Tuning fetch strategies） 19.1.3. 单端关联代理（Single-ended association proxies） 19.1.4. 实例化集合和代理（Initializing collections and proxies） 19.1.5. 使用批量抓取（Using...
Hibernate+中文文档
02-22
19.1.2. 调整抓取策略（Tuning fetch strategies） 19.1.3. 单端关联代理（Single-ended association proxies） 19.1.4. 实例化集合和代理（Initializing collections and proxies） 19.1.5. 使用批量抓取（Using...
Lazy-Collection:用于 Java 的非严格（惰性）集合，其中可以基本上形成一系列函数，并且仅在请求时执行评估。 它使用 Java 7 作为默认 jdk 版本
06-17
懒惰收集 用于 Java 的非严格（惰性）集合，其中可以基本上形成一系列函数，并且仅根据需要执行评估。 它使用 Java 7 作为默认 JDK 版本。 该项目针对 JDK 7，因此不会有 lambda 和 java 8 流支持。 如果您正在寻找 lamda 支持以及可重用的 java 8 Stream，请查看 。 具有以下功能的 Java 函数库。 这个库很大程度上受到了 Scala 语言的启发。 尽量保持懒惰。 适用于可迭代、迭代器、数组等。 原始惰性集合 更多即将推出 快速开始 import com.lazy.collection.factory.LazyFactory ; import com.lazy.collection.impl.LazyCollection ; LazyCollection< Double> collection = LazyFactory .
2.LazyForCollection 工具类
06-24 176
package com.bjpowernode.hibernate; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; public class HibernateUtils { private static SessionFa
hibernate 通过子查询预抓取集合 fetch subselect join (最后遗留疑问)
java相关技术（partner4java专栏）希望对您的学习有所帮助
11-05 4222
（总结在后面）  通过子查询预抓取集合： view plaincopy to clipboardprint? <set fetch="subselect" ..>      @org.hibernate.annotations.Fetch(org.hibernate.annotations.FetchMode.SUBSELECT)   配置文
LazyInitializationException 懒加载异常的四种解决方案
今晚有风
10-09 1万+
简介：org.hibernate.LazyInitializationException: could not initialize proxy - no Session （懒加载异常在默认情况下，hibernate为懒加载），这意味着在读取数据的时候，Session已经关闭。 解决方案（四种）： 第一种：在get属性方法上添加@JSON(Serialize=false)注解，
Hibernate Annotations配置映射
再不努力我们就老了
03-07 1912
在JDK 5.0之后出现了一种新的注释技术Annotations，而Hibernate也在其3.0之后的版本中添加了对Annotations的支持。通过在实体类中添加Annotations注释，可以达到替代映射文件的效果。 各Annotations注释标记如下： @Entity 声明当前是一个持久化类 @Table 设置当前持久化类所映射的数据库表，如果当前类中没有使用@Table注解，
hibernate3.6.10 注解配置添加表字段注释
热门推荐
云守护的专栏
08-14 2万+
如果使用的是xml方式配置，则：
hibernate annotation
猿人的专栏
04-09 317
http://shenzhenchufa.blog.51cto.com/730213/291787 hibernate Annotation标签的使用: [1] 1.带注释的持久性类也是普通 POJO,它们只是具备了持久性注释的普通 POJO 。 2.事实上，您既可以保持字段的持久性（注释写在成员变量之上），也可以保持属性（注释写在getter方法之上）的持久性。 3
org.hibernate.annotations.Where粗略用法
weixin_30824277的博客
01-06 368
/*** 过滤条件为REC_STATUS='Y'的子类记录* REC_STATUS:数据库表列名, Y:值*/@Where(clause = "REC_STATUS='Y'") public Set<Dept> getChildren() { return children; } 转载于:https://www.cnblogs.com/rainbowdese...
point_cloud_annotation_tool
最新发布
11-26
point_cloud_annotation_tool（点云标注工具）是一种用于在点云数据上进行标注的工具。点云是由大量的点组成的三维数据模型，它常用于激光扫描、三维重建和自动驾驶等领域。在这些应用中，点云标注工具可以帮助人们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值