05.Hibernate中的关联关系映射,对象查询,二级缓存

最新推荐文章于 2021-02-15 22:43:59 发布
最新推荐文章于 2021-02-15 22:43:59 发布
阅读量1.4k 收藏
点赞数
分类专栏： Hibernate学习 文章标签： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ycjcson/article/details/112061809
版权

05.Hibernate中的关联关系映射,对象查询,二级缓存

1、关联关系映射

同表
组件配置

不同表
一对一关联映射

多对一
一对多
多对多

2、对象查询

OID
get:
load:
HQL(面向对象的查询语句)
条件查询
投影查询(只查询结果中的部分内容)
不封装对象
封装对象
分页查询
setFirstReult:查询的起始位置
setMaxResult:查询的内容数量
连接查询
迫切
因为结果数量对标了普通查询结果，所以需要去重复
非迫切
内联、左外连接、右外连接、全连接、交叉链接
报表查询(GROUP BY HAVING ,SUM,AVG,MAX,MIN,COUNT)
动态SQL
QBC
标准化查询
本地SQL
执行批量操作
使用HQL的步骤
1、创建Query对象
2、调用Query的方法

3、二级缓存(当Session被关闭之后，仍然缓存在SessionFactory中)

Session缓存
SessionFactory缓存
	
	两块
		内置缓存
			不是我们要操作的内容，里面存放了大量Hibernate的配置信息
		外置缓存
			默认处于关闭状态
			适合存放的内容
				频繁的被读取的内容，少有被修改的
				允许并发的数据
			Hibernate提供并发访问策略
				Nonstrict-read-write：非严格的读写，对应READ UNCOMMITTED
				Read-write:读写，对应READ COMMITTED
				Transaction:事务，对应REPEATABLE READ
				Read-only:只读，对应SERIALIZABLE
			可配置的缓存插件
				EHCache:
				OpenSymphony OSCache,SwarmCache,JBossCache
			配置二级缓存
				加入jar包:hibernate-release-5.4.22.Final\lib\optional\ehcache
				加入EHCache配置文件:hibernate-release-5.4.22.Final\project\etc
				开启Hibernate外置二级缓存的支持：
<propertyname="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.internal.EhcacheRegionFactory</property>
				设置哪些内容加入二级缓存：<class-cache usage="缓存策略" class="被缓存的类"/>

4、session与线程绑定

案例

案例1:多对一(一对多)

导入相应的jar包
创建实体类

创建一个班级类ClassInfo.java

package com.zb.entity;

import java.util.HashSet;
import java.util.Set;

public class ClassInfo {
	private Integer class_id;
	private String class_name;
	private String class_address;
	private String class_manager;
	// 关联关系配置在一段（一对多，数据库中怎么记录跟我们没有关系）
	private Set<StuInfo> stuInfos = new HashSet<StuInfo>();//初始化集合

	public Integer getClass_id() {
		return class_id;
	}

	public void setClass_id(Integer class_id) {
		this.class_id = class_id;
	}

	public String getClass_name() {
		return class_name;
	}

	public void setClass_name(String class_name) {
		this.class_name = class_name;
	}

	public String getClass_address() {
		return class_address;
	}

	public void setClass_address(String class_address) {
		this.class_address = class_address;
	}

	public String getClass_manager() {
		return class_manager;
	}

	public void setClass_manager(String class_manager) {
		this.class_manager = class_manager;
	}

	public Set<StuInfo> getStuInfos() {
		return stuInfos;
	}

	public void setStuInfos(Set<StuInfo> stuInfos) {
		this.stuInfos = stuInfos;
	}

	public ClassInfo() {
		super();
	}

	@Override
	public String toString() {
		return "ClassInfo [class_id=" + class_id + ", class_name=" + class_name + ", class_address=" + class_address
				+ ", class_manager=" + class_manager + ", classId=" + stuInfos + "]";
	}
}

创建一个学生类StuInfo.java

package com.zb.entity;

public class StuInfo {
	private Integer stu_id;
	private String stu_name;
	private String stu_sex;
	private Integer stu_age;
	private Integer class_id;
	// 关联关系保存在多的一端（多对一）
	//private ClassInfo classInfo;

	public Integer getStu_id() {
		return stu_id;
	}

	public void setStu_id(Integer stu_id) {
		this.stu_id = stu_id;
	}

	public String getStu_name() {
		return stu_name;
	}

	public void setStu_name(String stu_name) {
		this.stu_name = stu_name;
	}

	public String getStu_sex() {
		return stu_sex;
	}

	public void setStu_sex(String stu_sex) {
		this.stu_sex = stu_sex;
	}

	public Integer getStu_age() {
		return stu_age;
	}

	public void setStu_age(Integer stu_age) {
		this.stu_age = stu_age;
	}
/*
	public ClassInfo getClassInfo() {
		return classInfo;
	}

	public void setClassInfo(ClassInfo classInfo) {
		this.classInfo = classInfo;
	}
	public StuInfo(String stu_name, String stu_sex, Integer stu_age, ClassInfo classInfo) {
		super();
		this.stu_name = stu_name;
		this.stu_sex = stu_sex;
		this.stu_age = stu_age;
		this.classInfo = classInfo;
	}
 */
	
	
	public Integer getClass_id() {
		return class_id;
	}

	public StuInfo(String stu_name, String stu_sex) {
		super();
		this.stu_name = stu_name;
		this.stu_sex = stu_sex;
	}

	public void setClass_id(Integer class_id) {
		this.class_id = class_id;
	}

	public StuInfo() {
		super();
	}
/*
	@Override
	public String toString() {
		return "StuInfo [stu_id=" + stu_id + ", stu_name=" + stu_name + ", stu_sex=" + stu_sex + ", stu_age=" + stu_age
				+ ", classInfo=" + classInfo + "]";
	}
	*/
}
配置全局cfg.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
		"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
    	<!-- 数据库连接 -->
    	<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">123456</property>
		<property name="hibernate.connection.url">jdbc:mysql:///user_db?characterEncoding=UTF-8</property>
    	<!-- 数据库方言 -->
    	<property name="hibernate.dialect">org.hibernate.dialect.MySQL55Dialect</property>
    	<!-- 打印SQL -->
    	<property name="hibernate.show_sql">true</property>
    	<property name="hibernate.format_sql">true</property>
    	<!-- 表生成策略 -->
    	<property name="hibernate.hbm2ddl.auto">update</property>  
    	
    	<!-- 引入映射 -->
    	<mapping resource="class-mapping.hbm.xml"/>
    	<mapping resource="stu-mapping.hbm.xml"/>
    </session-factory>
</hibernate-configuration>
配置hbm.xml文件

stu-mapping.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
		"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
		"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.zb.entity.StuInfo" table="stu_info">
		<id name="stu_id" column="stu_id">
			<generator class="native"></generator>
		</id>
		<property name="stu_name" column="stu_name"></property>
		<property name="stu_sex" column="stu_sex"></property>
		<property name="stu_age" column="stu_age"></property>
		<property name="class_id" column="class_id"></property>
		<!-- 
			关联关系映射
				name:关联的属性名称
				class:关联的属性类型
				column:关联的列名
		 -->
        <!-- 多对一 -->
		<!-- <many-to-one name="classInfo" class="com.zb.entity.ClassInfo" column="class_id"></many-to-one> -->
	</class>
</hibernate-mapping>

class-mapping.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
		"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
		"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.zb.entity.ClassInfo" table="class_info">
		<id name="class_id" column="class_id">
			<generator class="native"></generator>
		</id>
		<property name="class_name" column="class_name"></property>
		<property name="class_address" column="class_address"></property>
		<property name="class_manager" column="class_manager"></property>
		
		<!-- 
			配置集合(Set-><set>;List-><list>)
				name:集合的名称
				table:关联的表的表名
		 -->
		<set name="stuInfos" table="stu_info">
			<!-- 
				配置集合对应的
					column:多端关联的一端的列名
			 -->
			<key column="class_id"/>
			<!-- 
				集合元素的类型，多端全类名
			 -->
			<one-to-many class="com.zb.entity.StuInfo"/>
		</set>
	</class>
</hibernate-mapping>
Test类
public class TestClass {
    SessionFactory sessionFactory = null;
    Session session = null;
    Transaction t = null;

    @Before
    public void qianZhi() {
        sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
        session = sessionFactory.openSession();
        t = session.beginTransaction();
        System.out.println("----------程序开始----------");
    }

    @After
    public void houZhi() {
        t.commit();
        session.close();
        System.out.println("----------程序结束----------");
    }
	
    //多对一
    @Test
    public void testMethod01() {
        List<StuInfo> listStuInfos = new ArrayList<StuInfo>();
        listStuInfos.add(session.get(StuInfo.class, 1));
        listStuInfos.add(session.get(StuInfo.class, 2));
        listStuInfos.add(session.get(StuInfo.class, 3));
        listStuInfos.add(session.get(StuInfo.class, 4));
        listStuInfos.add(session.get(StuInfo.class, 5));
        listStuInfos.add(session.get(StuInfo.class, 6));
        System.out.println(listStuInfos);

    }
    
	//一对多
    @Test
    public void testMethod02() {
        ClassInfo ci1 = session.get(ClassInfo.class, 1);
        ClassInfo ci2 = session.get(ClassInfo.class, 2);
        System.out.println(ci1);
        System.out.println(ci2);
    }
}

案例2:多对多

导入相应的jar包
创建实体类

创建学生类StuInfo2.java

package com.zb.entity;

import java.util.HashSet;
import java.util.Set;

public class StuInfo2 {
	private Integer stu_id;
	private String stu_name;
	private String stu_sex;
	private Integer stu_age;

	private Set<CourseInfo> courseInfos = new HashSet<CourseInfo>();

	public Integer getStu_id() {
		return stu_id;
	}

	public void setStu_id(Integer stu_id) {
		this.stu_id = stu_id;
	}

	public String getStu_name() {
		return stu_name;
	}

	public void setStu_name(String stu_name) {
		this.stu_name = stu_name;
	}

	public String getStu_sex() {
		return stu_sex;
	}

	public void setStu_sex(String stu_sex) {
		this.stu_sex = stu_sex;
	}

	public Integer getStu_age() {
		return stu_age;
	}

	public void setStu_age(Integer stu_age) {
		this.stu_age = stu_age;
	}

	public Set<CourseInfo> getCourseInfos() {
		return courseInfos;
	}

	public void setCourseInfos(Set<CourseInfo> courseInfos) {
		this.courseInfos = courseInfos;
	}
	
	public StuInfo2(String stu_name, String stu_sex) {
		super();
		this.stu_name = stu_name;
		this.stu_sex = stu_sex;
	}

	public StuInfo2() {
		super();
	}

	@Override
	public String toString() {
		return "StuInfo2 [stu_id=" + stu_id + ", stu_name=" + stu_name + ", stu_sex=" + stu_sex + ", stu_age=" + stu_age
				+ ", courseInfos=" + courseInfos + "]";
	}
}

创建课程实体类CourseInfo.java

package com.zb.entity;

import java.util.HashSet;
import java.util.Set;

public class CourseInfo {
	private Integer course_id;
	private String course_name;
	private String course_tname;

	private Set<StuInfo2> stuInfos = new HashSet<StuInfo2>();

	public Integer getCourse_id() {
		return course_id;
	}

	public void setCourse_id(Integer course_id) {
		this.course_id = course_id;
	}

	public String getCourse_name() {
		return course_name;
	}

	public void setCourse_name(String course_name) {
		this.course_name = course_name;
	}

	public String getCourse_tname() {
		return course_tname;
	}

	public void setCourse_tname(String course_tname) {
		this.course_tname = course_tname;
	}

	public Set<StuInfo2> getStuInfos() {
		return stuInfos;
	}

	public void setStuInfos(Set<StuInfo2> stuInfos) {
		this.stuInfos = stuInfos;
	}
	/*
	@Override
	public String toString() {
		return "CourseInfo [course_id=" + course_id + ", course_name=" + course_name + ", course_tname=" + course_tname
				+ ", stuInfos=" + stuInfos + "]";
	}
	*/
}
配置全局cfg.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
		"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
    	<!-- 数据库连接 -->
    	<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">123456</property>
		<property name="hibernate.connection.url">jdbc:mysql:///user_db?characterEncoding=UTF-8</property>
    	<!-- 数据库方言 -->
    	<property name="hibernate.dialect">org.hibernate.dialect.MySQL55Dialect</property>
    	<!-- 打印SQL -->
    	<property name="hibernate.show_sql">true</property>
    	<property name="hibernate.format_sql">true</property>
    	<!-- 表生成策略 -->
    	<property name="hibernate.hbm2ddl.auto">update</property>
    	
    	<!-- 引入映射 -->
    	<mapping resource="stu2-mapping.hbm.xml"/>
    	<mapping resource="course-mapping.hbm.xml"/>
    </session-factory>
</hibernate-configuration>
配置hbm.xml文件

stu2-mapping.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
		"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
		"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.zb.entity.StuInfo2" table="stu_info2">
		<id name="stu_id" column="stu_id">
			<generator class="native"></generator>
		</id>
		<property name="stu_name" column="stu_name"></property>
		<property name="stu_sex" column="stu_sex"></property>
		<property name="stu_age" column="stu_age"></property>
		
		<set name="courseInfos" table="stu_course_info">
			<!-- 我们提供给中间表的关联列 -->
			<key column="stu_id"/>
			<!-- 我们关联的中间表的关联列 -->
			<many-to-many class="com.zb.entity.CourseInfo" column="course_id"/>
		</set>
	</class>
</hibernate-mapping>

course-mapping.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
		"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
		"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.zb.entity.CourseInfo" table="course_info">
		<id name="course_id" column="course_id">
			<generator class="native"></generator>
		</id>
		<property name="course_name" column="course_name"></property>
		<property name="course_tname" column="course_tname"></property>
		<!-- 
			对多的映射关系
				name:集合名称
				table:因为两边都不是直接关联的，依赖的是中间表，所以此处写中间表的表名
		 -->
		<set name="stuInfos" table="stu_course_info">
			<key column="course_id"/>
			<many-to-many class="com.zb.entity.StuInfo2" column="stu_id"/>
		</set>
	</class>
</hibernate-mapping>
Test类
public class TestClass {
	SessionFactory sessionFactory = null;
	Session session = null;
	Transaction t = null;

	@Before
	public void qianZhi() {
		sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
		session = sessionFactory.openSession();
		t = session.beginTransaction();
		System.out.println("----------程序开始----------");
	}

	@After
	public void houZhi() {
		t.commit();
		session.close();
		System.out.println("----------程序结束----------");
	}
	
	@Test
	public void testMethod03() {
		StuInfo2 si1 = session.get(StuInfo2.class, 2);
		for(CourseInfo ci : si1.getCourseInfos()) {
			System.out.println(ci.getCourse_name());
		}
		System.out.println(si1);
	}
}

案例3:HQL(面向对象的查询语句)

创建实体类
package com.zb.entity;

import java.util.HashSet;
import java.util.Set;

public class StuInfo2 {
	private Integer stu_id;
	private String stu_name;
	private String stu_sex;
	private Integer stu_age;

	private Set<CourseInfo> courseInfos = new HashSet<CourseInfo>();

	public Integer getStu_id() {
		return stu_id;
	}

	public void setStu_id(Integer stu_id) {
		this.stu_id = stu_id;
	}

	public String getStu_name() {
		return stu_name;
	}

	public void setStu_name(String stu_name) {
		this.stu_name = stu_name;
	}

	public String getStu_sex() {
		return stu_sex;
	}

	public void setStu_sex(String stu_sex) {
		this.stu_sex = stu_sex;
	}

	public Integer getStu_age() {
		return stu_age;
	}

	public void setStu_age(Integer stu_age) {
		this.stu_age = stu_age;
	}

	public Set<CourseInfo> getCourseInfos() {
		return courseInfos;
	}

	public void setCourseInfos(Set<CourseInfo> courseInfos) {
		this.courseInfos = courseInfos;
	}
	
	public StuInfo2(String stu_name, String stu_sex) {
		super();
		this.stu_name = stu_name;
		this.stu_sex = stu_sex;
	}

	public StuInfo2() {
		super();
	}

	@Override
	public String toString() {
		return "StuInfo2 [stu_id=" + stu_id + ", stu_name=" + stu_name + ", stu_sex=" + stu_sex + ", stu_age=" + stu_age
				+ ", courseInfos=" + courseInfos + "]";
	}
}

package com.zb.entity;

public class NameAndSex {
	private String stu_name;
	private String stu_sex;


	public String getStu_name() {
		return stu_name;
	}

	public void setStu_name(String stu_name) {
		this.stu_name = stu_name;
	}

	public String getStu_sex() {
		return stu_sex;
	}

	public void setStu_sex(String stu_sex) {
		this.stu_sex = stu_sex;
	}
	
	public NameAndSex() {
		super();
	}

	public NameAndSex(String stu_name, String stu_sex) {
		super();
		this.stu_name = stu_name;
		this.stu_sex = stu_sex;
	}

	@Override
	public String toString() {
		return "NameAndSex [name=" + stu_name + ", sex=" + stu_sex + "]";
	}
}
Test类
public class TestClass {
	SessionFactory sessionFactory = null;
	Session session = null;
	Transaction t = null;

	@Before
	public void qianZhi() {
		sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
		session = sessionFactory.openSession();
		t = session.beginTransaction();
		System.out.println("----------程序开始----------");
	}

	@After
	public void houZhi() {
		t.commit();
		session.close();
		System.out.println("----------程序结束----------");
	}

	
	
	@Test
	public void testMethod04() {
		//创建HQL语句，它与SQL语句几乎相同，将其中的表名替换成对应的类名，列名替换为字段名
		String hql = " FROM StuInfo2 ";
		//创建Query对象
		Query query = session.createQuery(hql);
		//执行查询方法getResultList/list:查询一个list类型的结果
		List<StuInfo2> sis = query.getResultList();
		
		System.out.println(sis);
	}
	
	@Test
	public void testMethod05() {
		//创建HQL语句，它与SQL语句几乎相同，将其中的表名替换成对应的类名，列名替换为字段名
		String hql = " FROM StuInfo2 WHERE stu_age IN (15,18) ";
		//创建Query对象
		Query query = session.createQuery(hql);
		//执行查询方法getResultList/list:查询一个list类型的结果
		List<StuInfo2> sis = query.getResultList();
		
		for(StuInfo2 si : sis) {
			System.out.println(si.getStu_name());
		}
	}
	
	@Test
	public void testMethod06() {
		//创建HQL语句，它与SQL语句几乎相同，将其中的表名替换成对应的类名，列名替换为字段名
		String hql = " FROM StuInfo2 WHERE stu_age IN (?0,?1) ";
		//创建Query对象
		Query query = session.createQuery(hql);
		//如果有参数
		query.setParameter(0, 16);
		query.setParameter(1, 18);
		
		//执行查询方法getResultList/list:查询一个list类型的结果
		List<StuInfo2> sis = query.getResultList();
		
		for(StuInfo2 si : sis) {
			System.out.println(si.getStu_name());
		}
	}
	
	@Test
	public void testMethod07() {
		//创建HQL语句，它与SQL语句几乎相同，将其中的表名替换成对应的类名，列名替换为字段名
		String hql = " FROM StuInfo2 WHERE stu_sex = :sex ";
		//创建Query对象
		Query query = session.createQuery(hql);
		//如果有参数
		//query.setParameter(0, 16);
		//query.setParameter(1, 18);
		query.setParameter("sex", "女");
		
		//执行查询方法getResultList/list:查询一个list类型的结果
		List<StuInfo2> sis = query.getResultList();
		
		for(StuInfo2 si : sis) {
			System.out.println(si.getStu_name());
		}
	}
	
    //条件查询
	@Test
	public void testMethod08() {
		//创建HQL语句，它与SQL语句几乎相同，将其中的表名替换成对应的类名，列名替换为字段名
		String hql = " FROM StuInfo2 WHERE stu_sex = :sex AND stu_age = :age ";
		//创建Query对象
		Query query = session.createQuery(hql);
		//如果有参数
		query.setParameter("sex", "女");
		query.setParameter("age", 18);
		//执行查询方法getResultList/list:查询一个list类型的结果
		List<StuInfo2> sis = query.getResultList();
		
		for(StuInfo2 si : sis) {
			System.out.println(si.getStu_name());
		}
	}
	
    //条件查询
	@Test
	public void testMethod09() {
		List<StuInfo2> sis = session.createQuery(" FROM StuInfo2 WHERE stu_sex = :sex AND stu_age = :age ").
				setParameter("sex", "女").
				setParameter("age", 18).
				getResultList();
		for(StuInfo2 si : sis) {
			System.out.println(si.getStu_name());
		}
	}
	
    //投影查询(只查询结果中的部分内容)
	@Test
	public void testMethod10() {
		List<Object[]> sis = session.createQuery(" SELECT stu_name,stu_sex FROM StuInfo2 ").
				getResultList();
		for(Object[] os : sis) {
			System.out.println(Arrays.asList(os));
		}
	}
	
     //投影查询(只查询结果中的部分内容)
	@Test
	public void testMethod11() {
		List<StuInfo2> sis = session.createQuery(" SELECT new StuInfo2(stu_name,stu_sex) FROM StuInfo2 ").
				getResultList();
		for(StuInfo2 os : sis) {
			System.out.println(os);
		}
	}
    
    //投影查询(只查询结果中的部分内容)
    @Test
	public void testMethod12() {
		List<NameAndSex> sis = session.createQuery(" SELECT new NameAndSex(stu_name,stu_sex) FROM StuInfo2 ").
				getResultList();
		for(NameAndSex os : sis) {
			System.out.println(os);
		}
	}
}

案例4:HQL(分页查询)

创建实体类
package com.zb.entity;

import java.util.HashSet;
import java.util.Set;

public class StuInfo2 {
	private Integer stu_id;
	private String stu_name;
	private String stu_sex;
	private Integer stu_age;

	private Set<CourseInfo> courseInfos = new HashSet<CourseInfo>();

	public Integer getStu_id() {
		return stu_id;
	}

	public void setStu_id(Integer stu_id) {
		this.stu_id = stu_id;
	}

	public String getStu_name() {
		return stu_name;
	}

	public void setStu_name(String stu_name) {
		this.stu_name = stu_name;
	}

	public String getStu_sex() {
		return stu_sex;
	}

	public void setStu_sex(String stu_sex) {
		this.stu_sex = stu_sex;
	}

	public Integer getStu_age() {
		return stu_age;
	}

	public void setStu_age(Integer stu_age) {
		this.stu_age = stu_age;
	}

	public Set<CourseInfo> getCourseInfos() {
		return courseInfos;
	}

	public void setCourseInfos(Set<CourseInfo> courseInfos) {
		this.courseInfos = courseInfos;
	}
	
	public StuInfo2(String stu_name, String stu_sex) {
		super();
		this.stu_name = stu_name;
		this.stu_sex = stu_sex;
	}

	public StuInfo2() {
		super();
	}

	@Override
	public String toString() {
		return "StuInfo2 [stu_id=" + stu_id + ", stu_name=" + stu_name + ", stu_sex=" + stu_sex + ", stu_age=" + stu_age
				+ ", courseInfos=" + courseInfos + "]";
	}
}
Test类
public class TestClass {
	SessionFactory sessionFactory = null;
	Session session = null;
	Transaction t = null;

	@Before
	public void qianZhi() {
		sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
		session = sessionFactory.openSession();
		t = session.beginTransaction();
		System.out.println("----------程序开始----------");
	}

	@After
	public void houZhi() {
		t.commit();
		session.close();
		System.out.println("----------程序结束----------");
	}
    @Test
        public void testMethod13() {
            List<StuInfo> sis = session.createQuery(" FROM StuInfo ").
                    setFirstResult(4).
                    setMaxResults(2).
                    getResultList();

            for(StuInfo os : sis) {
                System.out.println(os.getStu_name());
            }
        }
}

案例5:HQL连接查询(迫切)

创建实体类
package com.zb.entity;

public class StuInfo {
	private Integer stu_id;
	private String stu_name;
	private String stu_sex;
	private Integer stu_age;
	private Integer class_id;
	// 关联关系保存在多的一端（多对一）
	//private ClassInfo classInfo;

	public Integer getStu_id() {
		return stu_id;
	}

	public void setStu_id(Integer stu_id) {
		this.stu_id = stu_id;
	}

	public String getStu_name() {
		return stu_name;
	}

	public void setStu_name(String stu_name) {
		this.stu_name = stu_name;
	}

	public String getStu_sex() {
		return stu_sex;
	}

	public void setStu_sex(String stu_sex) {
		this.stu_sex = stu_sex;
	}

	public Integer getStu_age() {
		return stu_age;
	}

	public void setStu_age(Integer stu_age) {
		this.stu_age = stu_age;
	}
/*
	public ClassInfo getClassInfo() {
		return classInfo;
	}

	public void setClassInfo(ClassInfo classInfo) {
		this.classInfo = classInfo;
	}
	public StuInfo(String stu_name, String stu_sex, Integer stu_age, ClassInfo classInfo) {
		super();
		this.stu_name = stu_name;
		this.stu_sex = stu_sex;
		this.stu_age = stu_age;
		this.classInfo = classInfo;
	}
 */
	
	
	public Integer getClass_id() {
		return class_id;
	}

	public StuInfo(String stu_name, String stu_sex) {
		super();
		this.stu_name = stu_name;
		this.stu_sex = stu_sex;
	}

	public void setClass_id(Integer class_id) {
		this.class_id = class_id;
	}

	public StuInfo() {
		super();
	}
/*
	@Override
	public String toString() {
		return "StuInfo [stu_id=" + stu_id + ", stu_name=" + stu_name + ", stu_sex=" + stu_sex + ", stu_age=" + stu_age
				+ ", classInfo=" + classInfo + "]";
	}
	*/
}

package com.zb.entity;

import java.util.HashSet;
import java.util.Set;

public class ClassInfo {
	private Integer class_id;
	private String class_name;
	private String class_address;
	private String class_manager;
	// 关联关系配置在一段（一对多，数据库中怎么记录跟我们没有关系）
	private Set<StuInfo> stuInfos = new HashSet<StuInfo>();//初始化集合

	public Integer getClass_id() {
		return class_id;
	}

	public void setClass_id(Integer class_id) {
		this.class_id = class_id;
	}

	public String getClass_name() {
		return class_name;
	}

	public void setClass_name(String class_name) {
		this.class_name = class_name;
	}

	public String getClass_address() {
		return class_address;
	}

	public void setClass_address(String class_address) {
		this.class_address = class_address;
	}

	public String getClass_manager() {
		return class_manager;
	}

	public void setClass_manager(String class_manager) {
		this.class_manager = class_manager;
	}

	public Set<StuInfo> getStuInfos() {
		return stuInfos;
	}

	public void setStuInfos(Set<StuInfo> stuInfos) {
		this.stuInfos = stuInfos;
	}

	public ClassInfo() {
		super();
	}

	@Override
	public String toString() {
		return "ClassInfo [class_id=" + class_id + ", class_name=" + class_name + ", class_address=" + class_address
				+ ", class_manager=" + class_manager + ", classId=" + stuInfos + "]";
	}
}
Test类
public class TestClass {
	SessionFactory sessionFactory = null;
	Session session = null;
	Transaction t = null;

	@Before
	public void qianZhi() {
		sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
		session = sessionFactory.openSession();
		t = session.beginTransaction();
		System.out.println("----------程序开始----------");
	}

	@After
	public void houZhi() {
		t.commit();
		session.close();
		System.out.println("----------程序结束----------");
	}
    
    //迫切查询
    @Test
	public void testMethod14() {
		//XXXX JOIN FETCH 
		List<Object[]> sis = session.createQuery(" SELECT SI.stu_name,SI.stu_sex,CI.class_name FROM StuInfo AS SI INNER JOIN ClassInfo AS CI ON SI.class_id = CI.class_id").
				getResultList();
		for(Object[] os : sis) {
			System.out.println(Arrays.toString(os));
		}
	}
    
    //报表查询(GROUP BY HAVING ,SUM,AVG,MAX,MIN,COUNT)
    @Test
	public void testMethod15() {
		Object[] sis = (Object[]) session.createQuery(" SELECT SUM(stu_age),AVG(stu_age) FROM StuInfo ").
				getSingleResult();
		for(Object os : sis) {
			System.out.println(os);
		}
	}
	
    //报表查询
	@Test
	public void testMethod16() {
		Object sis = session.createQuery(" SELECT SUM(stu_age) FROM StuInfo ").
				getSingleResult();
		System.out.println(sis);
	}
	
    //动态SQL
	@Test
	public void testMethod17() {
		NativeQuery nq = session.createSQLQuery(" INSERT INTO stu_info VALUES (DEFAULT,'老李','女',15,1) ");
		nq.executeUpdate();
	}
}

案例6:二级缓存的使用

配置二级缓存
			加入jar包:hibernate-release-5.4.22.Final\lib\optional\ehcache
			加入EHCache配置文件:hibernate-release-5.4.22.Final\project\etc
			开启Hibernate外置二级缓存的支持：<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.internal.EhcacheRegionFactory</property>
			设置哪些内容加入二级缓存：<class-cache usage="缓存策略" class="被缓存的类"/>
导入二级缓存相应的jar包
创建实体类
package com.zb.entity;

public class StuInfo {
	private Integer stu_id;
	private String stu_name;
	private String stu_sex;
	private Integer stu_age;
	private Integer class_id;

	public Integer getStu_id() {
		return stu_id;
	}

	public void setStu_id(Integer stu_id) {
		this.stu_id = stu_id;
	}

	public String getStu_name() {
		return stu_name;
	}

	public void setStu_name(String stu_name) {
		this.stu_name = stu_name;
	}

	public String getStu_sex() {
		return stu_sex;
	}

	public void setStu_sex(String stu_sex) {
		this.stu_sex = stu_sex;
	}

	public Integer getStu_age() {
		return stu_age;
	}

	public void setStu_age(Integer stu_age) {
		this.stu_age = stu_age;
	}
	
	
	public Integer getClass_id() {
		return class_id;
	}

	public StuInfo(String stu_name, String stu_sex) {
		super();
		this.stu_name = stu_name;
		this.stu_sex = stu_sex;
	}

	public void setClass_id(Integer class_id) {
		this.class_id = class_id;
	}

	public StuInfo() {
		super();
	}
}
配置cfg.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
		"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
    	<!-- 数据库连接 -->
    	<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">123456</property>
		<property name="hibernate.connection.url">jdbc:mysql:///user_db?characterEncoding=UTF-8</property>
    	<!-- 数据库方言 -->
    	<property name="hibernate.dialect">org.hibernate.dialect.MySQL55Dialect</property>
    	<!-- 打印SQL -->
    	<property name="hibernate.show_sql">true</property>
    	<property name="hibernate.format_sql">true</property>
    	<!-- 表生成策略 -->
    	<property name="hibernate.hbm2ddl.auto">update</property>
    	
    	<!-- 设置Hibernate使用的二级缓存的缓存插件(插件全类名) -->
    	<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.internal.EhcacheRegionFactory</property>
    	
    	<!-- 引入映射 -->
    	<mapping resource="stu-mapping.hbm.xml"/>
    	
    	<!-- 设置要缓存的类   有多个类需要设置二级缓存方法同理,在class属性写上对应类的包名 -->
    	<class-cache usage="read-only" class="com.zb.entity.StuInfo"/>
        <!-- 注意:class-cache标签必须写在映射文件之后,否则会报错. -->
    </session-factory>
</hibernate-configuration>
配置hbm.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
		"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
		"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.zb.entity.StuInfo" table="stu_info">
		<id name="stu_id" column="stu_id">
			<generator class="native"></generator>
		</id>
		<property name="stu_name" column="stu_name"></property>
		<property name="stu_sex" column="stu_sex"></property>
		<property name="stu_age" column="stu_age"></property>
		<property name="class_id" column="class_id"></property>
	</class>
</hibernate-mapping>
ehcache.xml(导入二级缓存包会有此文件)
<ehcache>
	<!-- 当内存缓存满了，则保存到磁盘的目标位置 -->
    <diskStore path="D://cache"/>
    <!-- 
    	maxElementsInMemory:内存缓存该对象的最大数量
        eternal:缓存的对象是否永久存在
        timeToIdleSeconds:最大空闲时间s
        timeToLiveSeconds:最大缓存时间s
        overflowToDisk:超出最大大小之后是否存放到磁盘中
     -->
    <defaultCache
        maxElementsInMemory="2"
        eternal="false"
        timeToIdleSeconds="20"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />
</ehcache>
Test类
public class TestClass {
	SessionFactory sessionFactory = null;
	Session session = null;
	Transaction t = null;

	@Before
	public void qianZhi() {
		sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
		session = sessionFactory.openSession();
		t = session.beginTransaction();
		System.out.println("----------程序开始----------");
	}

	@After
	public void houZhi() {
		t.commit();
		session.close();
		System.out.println("----------程序结束----------");
	}
    
    //测试二级缓存
    @Test
	public void testMethod18() {
		StuInfo si1 = session.get(StuInfo.class, 1);
		StuInfo si2 = session.get(StuInfo.class, 2);
		StuInfo si3 = session.get(StuInfo.class, 3);
		StuInfo si4 = session.get(StuInfo.class, 4);
		StuInfo si5 = session.get(StuInfo.class, 5);
		StuInfo si6 = session.get(StuInfo.class, 6);
		StuInfo si7 = session.get(StuInfo.class, 7);
	}
}
案例中使用到的数据库

CREATE TABLE class_info
(
	class_id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
	class_name VARCHAR(32) NOT NULL,
	class_address VARCHAR(32) NOT NULL,
	class_manager VARCHAR(32) NOT NULL
)

INSERT INTO class_info
VALUES
(DEFAULT,"Java53班","401","刘艳"),
(DEFAULT,"挖掘机1班","山东蓝翔","挖掘机")

CREATE TABLE stu_info
(
	stu_id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
	stu_name VARCHAR(32) NOT NULL,
	stu_sex VARCHAR(32) NOT NULL,
	stu_age INT NOT NULL,
	class_id INT NOT NULL,
	FOREIGN KEY (class_id) REFERENCES class_info(class_id)
)

INSERT INTO stu_info
VALUES
(DEFAULT,"小明","女",15,1),
(DEFAULT,"小黑","男",16,1),
(DEFAULT,"小白","女",18,1),
(DEFAULT,"老张","男",55,2),
(DEFAULT,"老王","女",66,2),
(DEFAULT,"老刘","男",88,2)

SELECT * FROM stu_info INNER JOIN class_info ON stu_info.class_id = class_info.class_id

CREATE TABLE course_info
(
	course_id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
	course_name VARCHAR(32) NOT NULL,
	course_tname VARCHAR(32) NOT NULL
)

INSERT INTO course_info
VALUES
(DEFAULT,"语文","语文老师"),
(DEFAULT,"数学","体育老师"),
(DEFAULT,"英语","美术老师")

CREATE TABLE stu_info2
(
	stu_id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
	stu_name VARCHAR(32) NOT NULL,
	stu_sex VARCHAR(32) NOT NULL,
	stu_age INT NOT NULL
)

INSERT INTO stu_info2
VALUES
(DEFAULT,"小明","女",15),
(DEFAULT,"小黑","男",16),
(DEFAULT,"小白","女",18)

CREATE TABLE stu_course_info
(
	stu_id INT NOT NULL,
	course_id INT NOT NULL,
	FOREIGN KEY (stu_id) REFERENCES stu_info2(stu_id),
	FOREIGN KEY (course_id) REFERENCES course_info(course_id)
)

INSERT INTO stu_course_info
VALUES
(1,1),
(1,2),
(1,3),
(2,2),
(2,3),
(3,1),
(3,3)
jv_xiaobai_yu
关注
专栏目录
Hibernate之二级缓存
zxy15974062965的博客
10-22 741
（一）、缓存：缓存是什么，解决什么问题？ 位于速度相差较大的两种硬件/软件之间的，用于协调两者数据传输速度差异的结构，均可称之为缓存Cache，缓存也被称为非关系型数据库。缓存目的：让数据更接近于应用程序，协调速度不匹配，使访问速度更快。 （二）、数据库类型：数据库分为两种类型，其中每一个类型都有一个典型的数据库 关系型数据库：数据与数据之间存在关系（联系）的数据库：sql、mysql、oracle 非关系型数据库：数据与数据之间是不存在关系的：...
hibernate利用关联关系查询对象
zhangqifeng专栏
10-23 1180
利用关联关系操纵对象 数据对象之间关联关系有一对一、一对多及多对多关联关系。在数据库操作中，数据对象之间的关联关系使用JDBC处理很困难。本节讲解如何在Hibernate中处理这些对象之间的关联关系。本节使用到4个类，它们分别是Student（学生）、Card（学生证）、Group（班级）和Course（课程），它们之间的关联关系如图1-1所示。这些实体存在级联(cascade)问题。例如，当删
hibernate多表查询映射对象
yanlp
08-30 227
在问答里和论坛中，经常看到有人问，怎样将使用本地SQL查询出来的结果映射为值对象的问题，这里就Hibernate中提供的方法做个结论。前提，这里没有使用属性的延迟加载技术。     假设有个值对像，如下： Java代码 package test;             public class Person {           private Long id...
hibernate关联对象的增删改查------查
程序员小董的专栏
07-11 1856
本篇博客是之前博客hibernate关联对象的增删改查------查 的后继,本篇代码的设定都在前文已经写好,因此读这篇之前,请先移步上一篇博客        //代码片5     SessionFactory sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory
SSH中Hibernate对象状态，一级缓存，关联关系映射(学习笔记)
weixin_42971363的博客
07-13 153
Hibernate对象状态 Hibernate三种状态: 1: 瞬时态 : 没有id即没保存,也脱离了sesion 2: 持久态 : 已经保存到数据库(有着完整的属性) 3：托管态 : 一个完整的对象，但是脱离了sesion 例: public void test(){ //三种状态相对于book实例而言 Session session=Hiber...
Hibernate 多表关联查询示例
fn_2015的博客
07-13 8664
TSettlementPaymentRec,TIsvSettlement,TC001CorpMessage三个Java Bean映射于T_Isv_Settlement，T_Isv_Settlement_Attach , T_C001_Corp_Messag表 其中T_Isv_Settlement，T_Isv_Settlement_Attach , T_C001_Corp_Messag 已
Hibernate4(关系映射-事务-原理-性能和二级缓存-最佳实践)
11-25
Hibernate 4是该框架的一个版本，它涵盖了关系映射、事务处理、原理、性能优化以及二级缓存的使用与最佳实践。以下知识点详细解释了这些关键概念。 1. 关系映射：在Hibernate框架中，关系映射是指对象与数据库表...
Hibernate二级缓存架包.rar
08-02
在Hibernate中，二级缓存是提升应用性能的关键组件之一。本文将深入探讨Hibernate的二级缓存机制及其重要性，以及如何配置和使用相关架包。 ### 1. Hibernate二级缓存概念 一级缓存是SessionFactory内部维护的缓存...
day37 05-HIbernate二级缓存：一级缓存更新同步到二级缓存及二级缓存配置文件
04-26
当对象在一级缓存中被修改并提交后，Hibernate会根据配置将这些变化同步到二级缓存中。这个过程包括了更新、删除和插入操作。值得注意的是，对于删除操作，Hibernate不仅会移除相应对象，还会清除可能存在的关联对象...
Hibernate-二级缓存总结 开发技术 - Java.zip
最新发布
03-29
在Java开发中，Hibernate是一个非常重要的对象关系映射（ORM）框架，它简化了数据库操作，使得开发者可以更专注于业务逻辑而不是数据库交互。本篇主要关注的是Hibernate的二级缓存，这是一个提高应用性能的关键特性...
hibernate 映射 List 值对象 简单映射
gudong2945的专栏
12-08 1346
接上篇《hibernate 映射 bag/idbag值对象 简单映射》 如果允许给一个User添加多个Task，并且要记录顺序怎么办？ 这个和List的语义相同用List映射 package com.ccay.test.valueCollection.list.xml; import java.util.ArrayList; import java.util.List; public c
hibernate mysql 关联查询_Hibernate关联映射及高级查询
weixin_35911805的博客
02-15 389
一、Hibernate中的关联关系1.1、单向一对多关联关系按照以下步骤配置hibernate中持久化类的一对多对象关联:(1).持久化类添加关联类的相关属性及getter/setter方法。(2).映射文件中建立该属性和数据库表字段的映射信息。比如班级对学生是一对多的关系，班级类Grade类和Grade.hbm.xml文件如下:package com.pb.hibernate.po;import...
hibernate的关联对象查询，且指定hibernate的封装对象和关联对象的方式
qq_33243148的博客
01-26 946
当subarea里面含有region对象时，使用这样的离线模糊查询是不行的。             dc.add(Restrictions.like("region.province","%"+province+"%"));             这里涉及到多表关联查询，使用别名来实现。             dc.createAlias("region","r");//就是添加别名,第一个...
SSH进阶（三）Hibernate----关联关系，HQL查询语言
qq_42112846的博客
07-17 3144
关联关系、HQL语言、关联表之间的查询   在mybatis种有关联关系，同样在Hibernate当中也是有关联关系得； 在mybatis当中多对一用的是associatej节点，而一对多对应得就是collection 相应得再hibernate当中多对一是many-to-one 而一对多是one-to-many 一、关联关系 1.首先来说hibernate种多对一得关系：   比如...
Hibernate对象状态&三种查询操作
weixin_30763397的博客
01-13 170
hibernate对象状态 public class Test { public static void main(String[] args) { Configuration configuration= new Configuration().configure(); SessionFactory sessionFactory = co...
Hibernate 一对多的联系（Set关联） 对象关系映射
starjuly的专栏
08-24 2705
Hibernate 一对多的联系（Set关联） 对象关系映射
【hibernate】——hql简单属性+实体对象查询
漫漫长途，终有回转；余味苦涩，终有回甘
06-05 2060
最近一直在研究hibernate，真是觉得越深入乐趣越多，由衷佩服hibernate的开发者，真正的体验到什么时灵活自如！真的很喜欢！     本文小编主要讲解hibernate中原生sql在查询简单属性和实体对象的怎么使用，以及几种不同的参数查询。     简单属性查询 1】 单个属性 //返回结果集属性列表，元素类型和实体类中的属性类型一致，其中Student对应的是程序中实体 L
Hibernate对象/关系映射：理解两级缓存机制
当一级缓存未找到数据时，会尝试在二级缓存中查找，如果二级缓存仍无果，才会去数据库进行查询。Hibernate是一个流行的Java ORM（对象关系映射）框架，它解决了面向对象编程与关系数据库之间的不匹配问题，提供了...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值