hibernate（二）

最新推荐文章于 2023-05-08 11:56:46 发布
最新推荐文章于 2023-05-08 11:56:46 发布
阅读量170 收藏
点赞数
分类专栏： java csdn 文章标签： hibernate hibernate5.0 hibernate反向工程 hibernate映射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/venus321/article/details/76823164
版权
java 同时被 2 个专栏收录
101 篇文章 0 订阅
订阅专栏
csdn
25 篇文章 0 订阅
订阅专栏

经过前面的学习，现在是不是学hibernate有点得心应手，那赶紧趁热打铁进行下一章。

映射关系

  1. 一对多
  2. 多对一
  3. 一对一
  4. 多对多

hibernate单向一对多关联映射实例（一个班级可以有多个学生）

  • 创建实体类
package com.example.test.hibernate.entity;

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

public class Grade {
   private int gid;
   private String gdesc;
   private Set<Student> students = new HashSet<Student>();  
 /*  如何实现一对多映射
   在一方其定义多方的集合，可以使用set表示无序的，list表示有序的。*/
   
public Grade() {
	super();
	// TODO Auto-generated constructor stub
}
public Grade(int gid, String gdesc, Set<Student> students) {
	super();
	this.gid = gid;
	this.gdesc = gdesc;
	this.students = students;
}
public int getGid() {
	return gid;
}
public void setGid(int gid) {
	this.gid = gid;
}
public String getGdesc() {
	return gdesc;
}
public void setGdesc(String gdesc) {
	this.gdesc = gdesc;
}
public Set<Student> getStudents() {
	return students;
}
public void setStudents(Set<Student> students) {
	this.students = students;
}
public Grade(String gdesc) {
	super();
	this.gdesc = gdesc;
}


}


package com.example.test.hibernate.entity;

import java.util.Set;

public class Student {
	private int sid;
	public int getSid() {
		return sid;
	}
	public void setSid(int sid) {
		this.sid = sid;
	}
	private String name;
	private String sex;
	
	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;
	}
	public Student(int sid, String name, String sex) {
		super();
		this.sid = sid;
		this.name = name;
		this.sex = sex;
	}
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, String sex) {
		super();
		this.name = name;
		this.sex = sex;
	}
	
	

}

  • 配置数据库映射关系文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-8-6 10:09:41 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.example.test.hibernate.entity.Grade" table="GRADE">
        <id name="gid" type="integer">
            <column name="GID" />
            <generator class="increment" /> <!-- 主键生成策略，自增 -->
        </id>
        <property name="gdesc" type="java.lang.String">
            <column name="GDESC"   length="100"/>
        </property>
       <set name="students"  table="STUDENT">
       <key column="GID"></key>
       <one-to-many class="com.example.test.hibernate.entity.Student"/>
       </set>
     
    </class>
</hibernate-mapping>


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-8-6 10:09:41 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.example.test.hibernate.entity.Student" table="STUDENT">
        <id name="sid" type="integer">
            <column name="SID" />
            <generator class="increment" /> <!-- 主键生成策略，自增 -->
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" not-null="true"  length="20"/>
        </property>
        <property name="sex" type="java.lang.String" length="10">
            <column name="SEX" />
        </property>
     
    </class>
</hibernate-mapping>
  • 添加学生，班级
 public void testApp() {
       Grade g =new Grade("测试一班");
       Student s = new Student("刘锦", "男");
       Student s1 = new Student("刘锦1", "男");
       g.getStudents().add(s);//班级中的得到学生的集合对象，往里面添加学生。
       g.getStudents().add(s1);
       Session  session = HibernateUtils.getSession();
       Transaction t =  session.beginTransaction();
       session.save(g);
       session.save(s1);
       session.save(s);
       t.commit();
       HibernateUtils.closeSession();
  • 查询学生信息（查询是由班级到学生，注意查询方向）
 Session  session = HibernateUtils.getSession();
    	  Grade g = session.get(Grade.class,1);//根据Grade主键值取查询
    	  Set<Student> students =  g.getStudents();
    	  for(Student s:students){
    		  System.out.println(s.getName()+s.getSex());
    	  }
  • 修改学生信息
  Student s = session.get(Student.class,1);
    	  Grade g = new Grade("java 2班");
    	  g.getStudents().add(s);
    	  session.save(s);
    	  session.save(g);
    	  Transaction t = session.beginTransaction();
    	  t.commit();

  • 删除学生信息
  Student s = session.get(Student.class,1);
   
    	  session.delete(s);
    	  Transaction t = session.beginTransaction();
    	  t.commit();

hibernate单向多对一事例（基于学生----班级）

  • 修改持久化类
package com.example.test.hibernate.entity;

import java.util.Set;

public class Student {
	private int sid;
	private Grade grade;//在多方定义一方的引用，并且提供set、get方法
	
	public Grade getGrade() {
		return grade;
	}
	public void setGrade(Grade grade) {
		this.grade = grade;
	}
	public int getSid() {
		return sid;
	}
	public void setSid(int sid) {
		this.sid = sid;
	}
	private String name;
	private String sex;
	
	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;
	}
	public Student(int sid, String name, String sex) {
		super();
		this.sid = sid;
		this.name = name;
		this.sex = sex;
	}
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, String sex) {
		super();
		this.name = name;
		this.sex = sex;
	}
	
	

}



package com.example.test.hibernate.entity;

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

public class Grade {
   private int gid;
   private String gdesc;
 
   
public Grade() {
	super();
	// TODO Auto-generated constructor stub
}
public int getGid() {
	return gid;
}
public void setGid(int gid) {
	this.gid = gid;
}
public String getGdesc() {
	return gdesc;
}
public void setGdesc(String gdesc) {
	this.gdesc = gdesc;
}
public Grade(String gdesc) {
	super();
	this.gdesc = gdesc;
}


}
  • 配置关系映射文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-8-6 10:09:41 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.example.test.hibernate.entity.Student" table="STUDENT">
        <id name="sid" type="integer">
            <column name="SID" />
            <generator class="increment" /> <!-- 主键生成策略，自增 -->
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" not-null="true"  length="20"/>
        </property>
        <property name="sex" type="java.lang.String" length="10">
            <column name="SEX" />
        </property>
   <!--配置多对一关系 -->
     <many-to-one name="grade" class="com.example.test.hibernate.entity.Grade" column="GID"></many-to-one>
    </class>
</hibernate-mapping>
  • 添加学生信息
  Grade g = new Grade("java 3班");
    	  Student s = new Student("刘锦2", "男");
    	  Student s1 = new Student("刘锦3","男");
    	  s.setGrade(g);//通过这个可以给学生设置相应的班级的gid。
    	  s1.setGrade(g);
    	  session.save(g);
    	  session.save(s);
    	  session.save(s1);
    	  t.commit();

hibernate双向关联

在上述的例子中，学生到班级是单向多对一的关联，班级到学生是单向的一对多的关联，但是在实际中，班级和学生可能是双向，所以推出下面你的方法:

在一方和多方中都进行关联关系配置： 

package com.example.test.hibernate.entity;

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

public class Grade {
   private int gid;
   private String gdesc;
   private Set<Student> students = new HashSet<Student>();  
 /*  如何实现一对多映射
   在一方其定义多方的集合，可以使用set表示无序的，list表示有序的。*/
   
public Grade() {
	super();
	// TODO Auto-generated constructor stub
}
public Grade(int gid, String gdesc, Set<Student> students) {
	super();
	this.gid = gid;
	this.gdesc = gdesc;
	this.students = students;
}
public int getGid() {
	return gid;
}
public void setGid(int gid) {
	this.gid = gid;
}
public String getGdesc() {
	return gdesc;
}
public void setGdesc(String gdesc) {
	this.gdesc = gdesc;
}
public Set<Student> getStudents() {
	return students;
}
public void setStudents(Set<Student> students) {
	this.students = students;
}
public Grade(String gdesc) {
	super();
	this.gdesc = gdesc;
}


}


package com.example.test.hibernate.entity;

import java.util.Set;

public class Student {
	private int sid;
	private Grade grade;//在多方定义一方的引用，并且提供set、get方法
	
	public Grade getGrade() {
		return grade;
	}
	public void setGrade(Grade grade) {
		this.grade = grade;
	}
	public int getSid() {
		return sid;
	}
	public void setSid(int sid) {
		this.sid = sid;
	}
	private String name;
	private String sex;
	
	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;
	}
	public Student(int sid, String name, String sex) {
		super();
		this.sid = sid;
		this.name = name;
		this.sex = sex;
	}
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, String sex) {
		super();
		this.name = name;
		this.sex = sex;
	}
	
	

}

对象关系映射文件： 

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-8-6 10:09:41 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.example.test.hibernate.entity.Grade" table="GRADE">
        <id name="gid" type="integer">
            <column name="GID" />
            <generator class="increment" /> <!-- 主键生成策略，自增 -->
        </id>
        <property name="gdesc" type="java.lang.String">
            <column name="GDESC"   length="100"/>
        </property>
       <set name="students"  table="STUDENT">
       <key column="GID"></key>
       <one-to-many class="com.example.test.hibernate.entity.Student"/>
       </set>
     
    </class>
</hibernate-mapping>


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-8-6 10:09:41 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.example.test.hibernate.entity.Student" table="STUDENT">
        <id name="sid" type="integer">
            <column name="SID" />
            <generator class="increment" /> <!-- 主键生成策略，自增 -->
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" not-null="true"  length="20"/>
        </property>
        <property name="sex" type="java.lang.String" length="10">
            <column name="SEX" />
        </property>
   <!--配置多对一关系 -->
     <many-to-one name="grade" class="com.example.test.hibernate.entity.Grade" column="GID"></many-to-one>
    </class>
</hibernate-mapping>

添加学生： 

  Grade g = new Grade("java 3班");
    	  Student s = new Student("刘锦2", "男");
    	  Student s1 = new Student("刘锦3","男");
    	  g.getStudents().add(s1);
    	  g.getStudents().add(s);
    	  s.setGrade(g);
    	  s1.setGrade(g);
    	  session.save(g);
    	  session.save(s);
    	  session.save(s1);
    	  t.commit();

执行之后出现下面一个问题：


在这里因为进行了两次关联，所以他会多执行update，长期以往会影响性能，解决办法：

inverse

  • <set>节点的inverse属性指定关联关系的控制方向，默认由one维护。
  • 关联关系中，inverse设置为false，则主动方，由主动方负责维护关系。
  • 在一对多关联中，只能设置one方的inverse为true，这将有助于性能改善。
修改下面，即可解决上述问题： 

   <set name="students"  table="STUDENT" inverse="true">
       <key column="GID"></key>
       <one-to-many class="com.example.test.hibernate.entity.Student"/>
       </set>

cascade级联

在上述的代码保存时，我们已经将学生添加到班级中，在save班级的时候，可不可以不save学生，由此引出级联。

当设置cascade属性不为none时，hibernate会自动持久化所关联的对象

cascade属性的设置会带来性能上的变动，需要谨慎设置


  • all 对所有操作进行级联操作
  • save-update 执行保存和更新操作进行级联操作
  • delete 执行删除操作时进行级联操作
  • none 对所有操作不进行级联操作

双向关联

基于上述的例子中，进行了学生和班级的双向配置，这样的话，可以由学生查找到班级，也可以由班级查找到学生信息，这点需要区别单向。

Myeclipse添加数据库连接

在myeclipse中将项目开发模式调成hibernate开发视图，如下图：



点击db browers 新建一个数据库连接，进入下面的配置：



需要根据大家使用的数据库类型进行配置。配置成功，就可以在myeclipse中查看数据库信息。

Myeclipse中添加hibernate支持

先创建一个java project，右击项目名选择myeclipse，project facts，找到hibernate开始添加，但是根据不同版本的myeclipse，所支持的hibernate是有不同。



这个图上告诉我们的，就是hibernate配置信息是放在src下，还有就是是否要创建一个sessionFactory，你需要为它创建一个包。这个工厂里提供了一个方法就是获取session。








在上面我们已经在myeclipse上创建了数据库连接，在这里可以拿过来直接用。




选择hibernate核心包

经过上述的配置，已经完成项目对hibernate的支持，打开配置信息，你会发现已经配置完成了。


hibernate的反向工程

他可以根据数据库的表创建的持久化类和表与表的映射关系。

首先将hibernate切换到hibernate模式下，选中两种你需要反向生成的表，右击有个hibernate 反向，进入如下图：




在其中需要填写的是要填写项目的src目录，和存放表的持久化类和映射文件的包，勾选的是，询问是否一定要创建hbm文件和将映射文件是否添加到配置文件中，这些都是必须选的。



在这步中不需要，进行其他修改，只需要进行数据库主键的生成策略修改，这里使用的是mysql的自增长。

在完成上述的配置，项目多出以下变化：





经过这样，我们就在也不需要麻烦进行编写hbm文件了。
















venus321
关注
专栏目录
spring boot 2.1.4 hibernate 二级缓存 Caffeine实现
chengjili9361的博客
06-19 1170
The Ehcache second-level cache provider for Hibernate is deprecated 当我们使用hibernate-ehcache包（Ehcache 2）作为hibernate二级缓存时，系统会提示警告说已经过时了，那这时候找到spring...
hibernate二级缓存（二）二级缓存实现原理简单剖析
lan墨的博客
05-12 1516
hibernate二级缓存（一）二级缓存的实现原理 在前面我们将过hibernate二级缓存类似于一个插件，将缓存的具体实现分离，缓存的具体实现是通过hibernate.cache.region.factory_class参数配置指定。 1. hibernate二级缓存结构 hibernate二级缓存涉及到如下几个重要的接口： RegionFactory DomainDataRegion Ent...
hibernate+struts一对多增删改查demo（学生对班级）
05-10
利用struts1.2，hibernte3.0 mysql数据库 做的一个学生对班级增删改查的例子
基于struts2和hibernate的学生班级增删改查小示例
02-24
基于struts2和hibernate的学生班级增删改查小示例
Hibernate(四)一对多映射 补充二：单向多对一关系（学生->班级）
yangfan5314的专栏
07-12 632
数据库及其他文件见Hibernate(四)一对多映射 补充一：单向一对多关系（班级->学生） package com.imooc.entity;import java.io.Serializable;public class Grade implements Serializable{ /** * 班级 */ private static final long s
使用 Hibernate 二级缓存的步骤
DAO1024的博客
05-28 2496
1. 使用 Hibernate 二级缓存的步骤: 1). 加入二级缓存插件的 jar 包及配置文件: I. 复制 \hibernate-release-4.2.4.Final\lib\optional\ehcache\*.jar 到当前 Hibrenate 应用的类路径下. II. 复制 hibernate-release-4.2.4.Final\project\etc\eh
hibernate二级缓存测试
tuoxinquyu的专栏
08-13 1929
SessionFactory类： import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; import org.hibernate.stat.Statistics;public class HibernateSessionFactory {
hibernate二级缓存作用、配置
broccoli2的博客
08-09 2862
缓存：缓存是什么，解决什么问题？ 位于速度相差较大的两种硬件/软件之间的，用于协调两者数据传输速度差异的结构，均可称之为缓存Cache。缓存目的：让数据更接近于应用程序，协调速度不匹配，使访问速度更快。 缓存的范围分为3类: 1.事务范围（单Session即一级缓存） 事务范围的缓存只能被当前事务访问,每个事务都有各自的缓存,缓存内的数据通常采用相互关联的对象形式.缓存的生命周期依
spring boot集成ehcache 2.x 用于hibernate二级缓存
yiduyangyi的专栏
01-07 6020
spring boot集成ehcache 2.x 用于hibernate二级缓存[TOC] 本文将介绍如何在spring boot中集成ehcache作为hibernate的二级缓存。各个框架版本如下 spring boot：1.4.3.RELEASE spring framework: 4.3.5.RELEASE hibernate：5.0.1.Final（spring-boot-sta
Hibernate：二级缓存
燕双嘤
03-19 2070
缓存(Cache)：计算机领域非常通用的概念。它介于应用程序和永久性数据存储源(如硬盘上的文件或者数据库)之间，其作用是降低应用程序直接读写永久性数据存储源的频率，从而提高应用的运行性能。缓存中的数据是数据存储源中数据的拷贝。缓存的物理介质通常是内存。 Hibernate中提供了两个级别的缓存： 第一级别的缓存是 Session 级别的缓存，它是属于事务范围的缓存。这一级别的缓存由 hibernate 管理的。 第二级别的缓存是 SessionFactory 级别的缓存，它是属于进程范围的缓存。 .
Hibernate二级缓存
11-03
Hibernate二级缓存是一种提高应用程序性能的技术，它将数据存储在SessionFactory级别的缓存中，使得数据可以在不同的Session之间共享。这与一级缓存（Session级别）不同，一级缓存仅存在于单个Session生命周期内，当...
详解spring boot集成ehcache 2.x 用于hibernate二级缓存
08-30
"Spring Boot 集成 Ehcache 2.x 用于 Hibernate 二级缓存" 本篇文章主要介绍了如何在 Spring Boot 中集成 Ehcache 2.x 作为 Hibernate 的二级缓存，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。 Ehcache ...
hibernate二级缓存java包下载
05-21
二级缓存是 Hibernate 缓存策略的一部分，它在应用程序的多个会话之间共享数据，进一步优化了数据库访问效率。 二级缓存分为以下关键知识点： 1. **一级缓存与二级缓存的区别**： - 一级缓存：每个 Hibernate ...
java中hibernate二级缓存详解
08-30
Hibernate 二级缓存详解 Hibernate 中的二级缓存是 SessionFactory 级别的缓存，它是属于进程范围的缓存。二级缓存是可配置的缓存插件，默认情况下，SessionFactory 不会启用这个缓存插件。二级缓存中的数据是...
Hibernate二级缓存架包.rar
08-02
《深入理解Hibernate二级缓存：基于给定的配置与组件》 在Java的持久化框架领域，Hibernate无疑是最为广泛使用的工具之一。它提供了一种高效、便捷的方式来管理数据库对象，而其中的二级缓存机制则进一步提升了性能...
细说Hibernate的缓存机制
最新发布
孤鹰的博客
05-08 2416
2.1. 查询缓存：当使用 Session 对象执行查询操作时，如果一级缓存中没有数据，Hibernate 会在二级缓存中查找数据。2.2. 更新缓存：当使用 Session 对象执行更新操作时，Hibernate 会将更新后的数据存入一级缓存，并根据实体类的缓存策略更新二级缓存中的数据。2.3. 保存缓存：当使用 Session 对象执行保存操作时，Hibernate 会将新增的数据存入一级缓存，并根据实体类的缓存策略将数据插入到二级缓存。当 Session 对象被关闭时，一级缓存中的数据将被清除。
hibernate 缓存机制
林深不见鹿
04-15 2527
1. 一级缓存–session 在hibernate中，oid主键标识，当在session管理权限内，当第二次在使用某个对象时会从session 缓存中获取 2. 二级缓存—sessionFactory （1.） 内置缓存：hibernate自带的，不可卸载的，通常是在hibernate初始化阶段，hibernate会把映射元数据/预定于sql放到sessionFactory缓存中，内置缓存时只读的。 （2.）外置缓存：一个可以配置的缓存插件，可以由用户自定义配置选择缓存提供商，默认情况下sessionFa
synchronized修饰方法的缺点
venus321的博客
02-08 1221
public class Test176 { synchronized public void show() { String s1 = "这是处理的任务1"+Thread.currentThread().getName(); String s2 = "这是处理的任务2"+Thread.currentThread().getName(); tr...
解决csdn代码引起的排版问题
venus321的博客
03-23 1033
在csdn博客插入代码引起问题的解决办法
Hibernate二级缓存配置详解
"Hibernate二级缓存配置" 在Java应用程序中，Hibernate是一个流行的ORM（对象关系映射）框架，它允许开发者以面向对象的方式操作数据库。而二级缓存是Hibernate提供的一种优化策略，用于提高数据访问速度和减少对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值