Hibernate映射继承

最新推荐文章于 2024-07-30 20:50:32 发布
最新推荐文章于 2024-07-30 20:50:32 发布
阅读量58 收藏
点赞数
文章标签： java 数据库 人工智能
原文链接：https://my.oschina.net/u/3848699/blog/2243393
版权

一、每一个具体类实现一个表

比如一个学生有照片，照片又分为工作照和生活照

实例

da6e9f17b9301d0a0e2cc27c371501f0f98.jpg

先创建一个学生类

Student.java

package com.java.model;

import java.util.Set;

public class Student {
	private String name;
	private int id;
	//一个学生有多个照片，用一个集合保存照片
	private Set<Image> images;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public Set<Image> getImages() {
		return images;
	}
	public void setImages(Set<Image> images) {
		this.images = images;
	}

	
}

Student.hbm.xml(设置主键id和学生名字)

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 要写package="com.java.model" -->
<hibernate-mapping package="com.java.model">

      <class name="Student" table="t_student">
		<id name="id" column="stuId">
			<generator class="native"></generator>
		</id>
		
		<property name="name" column="stuName"></property>
	</class>

</hibernate-mapping>

 

定义一个父类抽象类Image，抽象的类不能实例化

Image.java

package com.java.model;

public abstract class Image {
//	父类是抽象类，其中有抽象方法，那么子类继承父类，
//	并把父类中的所有抽象方法都实现（覆盖）了，
//	子类才有创建对象的实例的能力，否则子类也必须是抽象类。抽象类中可以有构造方法，
//	是子类在构造子类对象时需要调用的父类（抽象类）的构造方法。
	private int id;
	private String imageName;
	//多对一
	private Student student;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getImageName() {
		return imageName;
	}
	public void setImageName(String imageName) {
		this.imageName = imageName;
	}
	public Student getStudent() {
		return student;
	}
	public void setStudent(Student student) {
		this.student = student;
	}
	
}

然后设计两个子类WorkImage 、LifeImage继承Image，这样子类就可以使用父类的属性和方法了

package com.java.model;

public class WorkImage extends Image {
	
}

package com.java.model;

public class LifeImage extends Image {
	
}

子类继承子类继承父类，并把父类中的所有抽象方法都实现（覆盖）了，
子类才有创建对象的实例的能力，否则子类也必须是抽象类

配置WorkImage.hbm.xml使用的是父类Image的属性

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 要写package="com.java.model" -->
<hibernate-mapping package="com.java.model">

     <class name="WorkImage" table="t_workImage">
		<id name="id" column="workImageId">
			<generator class="native"></generator>
		</id>
		
		<property name="imageName" column="imageName"></property>
		<!-- 多对一 -->
		<many-to-one name="student" column="stuId" class="com.java.model.Student"></many-to-one>
	</class>
	
</hibernate-mapping>

 

配置LifeImage.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 要写package="com.java.model" -->
<hibernate-mapping package="com.java.model">

     <class name="LifeImage" table="t_lifeImage">
		<id name="id" column="lifeImageId">
			<generator class="native"></generator>
		</id>
		
		<property name="imageName" column="imageName"></property>
		<!-- 多对一 -->
		<many-to-one name="student" column="stuId" class="com.java.model.Student"></many-to-one>
	</class>
	
</hibernate-mapping>

StudentTest.java

package com.java.service;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.java.model.Image;
import com.java.model.Student;
import com.java.util.HibernateUtil;
public class StudentTest {

	private SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
	private Session session;
	
	@Before
	public void setUp() throws Exception {
		session=sessionFactory.openSession(); // 生成一个session
	    session.beginTransaction(); // 开启事务
	}

	@After
	public void tearDown() throws Exception {
		 session.getTransaction().commit(); // 提交事务
		 session.close(); // 关闭session
	}
    @Test
	public void testGetAllImages(){

  }
	
}

生成的数据表：

c9d6a36e0b11854a9d1d6490f51e97ade72.jpg

插入几条数据

7b15480f8dd1824d82567d888fd90412408.jpg58ce6f384a1ed1e123a75c1f4d98fe258a9.jpg

9be391e25f091c6037a757a26f6f4a2d920.jpg

StudentTest.java打印数据

        @Test
	public void testGetAllImages(){
    	//创建一个imageList集合
		List<Image> imageList=new ArrayList<Image>();
		int stuId=1;
		//取到学生id=1的所有图片，就是将lifeImage和workImage全部放到imageList，遍历处理
		List<Image> lifeImageList=(List<Image>)session.createQuery("from LifeImage l where l.student.id="+stuId).list();
		imageList.addAll(lifeImageList);
		List<Image> workImageList=(List<Image>)session.createQuery("from WorkImage w where w.student.id="+stuId).list();
		imageList.addAll(workImageList);
		Iterator it=imageList.iterator();
		while(it.hasNext()){
			Image image=(Image)it.next();
			System.out.println(image.getImageName());
		}
	}

0c35f6c38f48123be7130a31484721068cf.jpg

二、根类对应一个表

Student2.java

package com.java.model;

import java.util.Set;

public class Student2 {
	private String name;
	private int id;
	//一个学生有多个照片，用一个集合保存照片
	private Set<Image2> images;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public Set<Image2> getImages() {
		return images;
	}
	public void setImages(Set<Image2> images) {
		this.images = images;
	}


	
}

Student2.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 要写package="com.java.model" -->
<hibernate-mapping package="com.java.model">

      <class name="Student2" table="t_student2">
		<id name="id" column="stuId">
			<generator class="native"></generator>
		</id>
		
		<property name="name" column="stuName"></property>
		
		<!-- 一对多 -->
		 <set name="images">
			<key column="stuId"></key>
			<one-to-many class="com.java.model.Image2"/>
		 </set>
	</class>
	

</hibernate-mapping>

Image2.java

package com.java.model;

public  class Image2 {
//由根类对应一个表所以不能是abstract抽象类
	private int id;
	private String imageName;
	//多对一
	private Student2 student;
	
	private String imageType;//标识字段
	
	
	public String getImageType() {
		return imageType;
	}
	public void setImageType(String imageType) {
		this.imageType = imageType;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getImageName() {
		return imageName;
	}
	public void setImageName(String imageName) {
		this.imageName = imageName;
	}
	public Student2 getStudent() {
		return student;
	}
	public void setStudent(Student2 student) {
		this.student = student;
	}
	
	
	
}

Image2.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 要写package="com.java.model" -->
<hibernate-mapping package="com.java.model">

     <class name="Image2" table="t_Image2">
		<id name="id" column="ImageId">
			<generator class="native"></generator>
		</id>
		<!-- 父类要加一个字段imageType 辨别类别的字段为string类型  -->
		<discriminator column="imageType" type="string"></discriminator>
		<property name="imageName" column="imageName"></property>
		<!-- 多对一 -->
		<many-to-one name="student" column="stuId" class="com.java.model.Student2"></many-to-one>
	    
	    <!-- 把两个子类加上 -->
	    <subclass name="com.java.model.LifeImage2" discriminator-value="li"></subclass>
		<subclass name="com.java.model.WorkImage2" discriminator-value="wi"></subclass>
	
	</class>
	
</hibernate-mapping>

hibernate.cfg.xml

           <mapping resource="com/java/model/Student2.hbm.xml"/>
             <mapping resource="com/java/model/Image2.hbm.xml"/>

 

LifeImage2.java和WorkImage2.java

package com.java.model;

public class LifeImage2 extends Image2 {
	
}

package com.java.model;

public class WorkImage2 extends Image2 {
	
}

 

StudentTest.java

package com.java.service;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.java.model.Image;
import com.java.model.Student;
import com.java.util.HibernateUtil;
public class StudentTest {

	private SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
	private Session session;
	
	@Before
	public void setUp() throws Exception {
		session=sessionFactory.openSession(); // 生成一个session
	    session.beginTransaction(); // 开启事务
	}

	@After
	public void tearDown() throws Exception {
		 session.getTransaction().commit(); // 提交事务
		 session.close(); // 关闭session
	}

    @Test
	public void testGetAllImages2(){
    	
	}
	
}

创建的数据库：

（imType用来确定是WorkImage还是LifeImage,如果是li就是生活照，如果是wi就是工作照）

fe4e1b0df0937241fd0a1babf03adcc2db5.jpg

往数据库添加数据

7985e59069b1186b5664aac942c02799dd0.jpg5f2b6b18ba57e27c962e16919ea2c4b7c85.jpg

获取值

 @Test
	public void testGetAllImages2(){
    	Student2 student2=(Student2)session.get(Student2.class, 1);
		Set<Image2> images=student2.getImages();
		Iterator it=images.iterator();
		while(it.hasNext()){
			Image2 image=(Image2)it.next();
			System.out.println(image.getImageName());
		}
	}

41d343b4056e555b7860600e19ad53efa79.jpg

3.每个表对应一个类

Student3.java

package com.java.model;

import java.util.Set;

public class Student3 {
	private String name;
	private int id;
	//一个学生有多个照片，用一个集合保存照片
	private Set<Image3> images;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public Set<Image3> getImages() {
		return images;
	}
	public void setImages(Set<Image3> images) {
		this.images = images;
	}


	
}

Student2.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 要写package="com.java.model" -->
<hibernate-mapping package="com.java.model">

      <class name="Student3" table="t_student3">
		<id name="id" column="stuId">
			<generator class="native"></generator>
		</id>
		
		<property name="name" column="stuName"></property>
		
		<!-- 一对多 -->
		 <set name="images">
			<key column="stuId"></key>
			<one-to-many class="com.java.model.Image3"/>
		 </set>
	</class>
	

</hibernate-mapping>

Image3.java

package com.java.model;

public  class Image3 {
//由根类对应一个表所以不能是abstract抽象类
	private int id;
	private String imageName;
	
	private Student3 student;


	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getImageName() {
		return imageName;
	}
	public void setImageName(String imageName) {
		this.imageName = imageName;
	}
	public Student3 getStudent() {
		return student;
	}
	public void setStudent(Student3 student) {
		this.student = student;
	}

	
	
	
}

Image3.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 要写package="com.java.model" -->
<hibernate-mapping package="com.java.model">

     <class name="Image3" table="t_Image3">
		<id name="id" column="ImageId">
			<generator class="native"></generator>
		</id>
		
		<property name="imageName" column="imageName"></property>
		
		<!-- 多对一 -->
		<many-to-one name="student" column="stuId" class="com.java.model.Student3"></many-to-one>
	    
	    <!-- 把两个子类加上 -->

              <joined-subclass name="com.java.model.LifeImage3" table="t_lifeImage3">
			<key column="lifeImageId"></key>
		</joined-subclass>
		
		<joined-subclass name="com.java.model.WorkImage3" table="t_workImage3">
			<key column="workImageId"></key>
		</joined-subclass>	
	</class>
	
</hibernate-mapping>

hibernate.cfg.xml

           <mapping resource="com/java/model/Student3.hbm.xml"/>
             <mapping resource="com/java/model/Image3.hbm.xml"/>

LifeImage3.java和WorkImage3.java

package com.java.model;

public class LifeImage3 extends Image3 {
	
}

package com.java.model;

public class WorkImage3 extends Image3 {
	
}

StudentTest.java

package com.java.service;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.java.model.Image;
import com.java.model.Student;
import com.java.util.HibernateUtil;
public class StudentTest {

	private SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
	private Session session;
	
	@Before
	public void setUp() throws Exception {
		session=sessionFactory.openSession(); // 生成一个session
	    session.beginTransaction(); // 开启事务
	}

	@After
	public void tearDown() throws Exception {
		 session.getTransaction().commit(); // 提交事务
		 session.close(); // 关闭session
	}

    @Test
	public void testGetAllImages3(){
    	
	}
	
}

生成的数据库：

cfdbf9012d7bf17ef56099bbe01d346eee9.jpg

创建数据

1.f51a6cbc845215c2032c0a96b7910d9ca44.jpg

2。9058c6076e52dce9a24779918c911c78b11.jpg

3.放ImageId分类cfa267b299243a80a32394148edf55d41e9.jpga3d6e6b6e13b9c8678f8e31ba829c4eba81.jpg

 

打印数据StudentTest.java

 @Test
  	public void testGetAllImage3(){
    	Student3 student3=(Student3)session.get(Student3.class, 1);
		Set<Image3> images=student3.getImages();
		Iterator it=images.iterator();
		while(it.hasNext()){
			Image3 image=(Image3)it.next();
			System.out.println(image.getImageName());
		}
  		
  	}

f8df62c8fb31638c52294d56abc626307c6.jpg

 

 

转载于:https://my.oschina.net/u/3848699/blog/2243393

chici7332
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hibernate第九篇【组件映射、继承映射】
zhong_fucheng
05-08 1359
前言到目前位置，我们已经学习了一对一、一对多、多对一、多对多映射了…既然Hibernate是ORM实现的框架，它还提供了组件映射和继承映射..本博文主要讲解组件映射和继承映射Java主要的类主要有两种方式 组合关系，组合关系对应的就是组件映射 继承关系，继承关系对应的就是继承映射 组件映射组件映射实际上就是将组合关系的数据映射成一张表，组件类和被包含的组件类映射成一张表有的时候，两个类的关系明显不是
Hibernate 映射 xml方式
weixin_44196999的博客
10-29 314
Hibernate 映射 1.大对象映射 图片,视频,文本等可以转换为字节或字符数组,使用Blob 或 Clob 格式存入到数据库当中 ​ 只针对对象不大,不多的情况下. ​ 图片，视频使用 Blob 格式 ​ 文本使用 Clob格式 2.组件映射–组合映射 一个对象中包含另外一个对象 ​ 配置 hbm.xml时 , 引入 component 标签关联属性,其他不变. 例如 ...
Hibernate继承映射
FF小迷糊吖~
05-30 215
持久化框架开发雪梨作业之Hibernate继承映射
hibernate 映射继承关系
dongecs的博客
05-10 875
hibernate 映射继承关系实现方式一般有三种： 1. 继承关系树每个具体类对应一张表（不介绍） 2. 继承关系树的根类对应一张表 3. 继承关系树的每个类对应一张表先介绍关系： DayEmployee和MonthEmploy是Employee的子类，并且Company和Employee是一对多关系：具体代码如下：Company.javaimport java.util.H
hibernate 映射继承关系的三种方法
岛丶
12-23 524
subclass:<hibernate-mapping package="com.atguigu.hibernate.subclass"> <class name="Person" table="PERSONS" discriminator-value="PERSON"> <id name="id" type="java.lang.Integer"> <c
【Hibernate】继承映射
Dream it Possible
10-01 1349
【前言】     不知道大家是否还记得UML中的四种关系？自己回想了一下，还是没有忘记的，分别是继承、实现、依赖和关联。     怎么突然会想到这样一个问题？是因为在学习完Hibernate关联映射之后，紧接着又来了一个继承映射。关联和继承，都属于四种关系之一，所以，本篇博客就先提了个问题，下面就开始继承映射的学习。 【概述】     继承是面向对象语言的三大重要特性之一，它实
Hibernate - 继承关联关系映射
小小默：进无止境
10-15 613
对于面向对象的程序设计语言而言，继承和多态是两个最基本的概念。Hibernate 的继承映射可以理解持久化类之间的继承关系。例如：人和学生之间的关系。学生继承了人，可以认为学生是一个特殊的人，如果对人进行查询，学生的实例也将被得到。 Hibernate支持三种继承映射策略： 使用 subclass 进行映射： 对于继承关系中的子类使用同一个表，这就需要在数据库表中增加额外的区分子类类型的字段。 ...
Hibernate之继承映射
bighuan的博客
05-03 295
一,概述 继承关系对应的映射就叫做继承映射.继承映射有好多种解决方案: a.简单继承映射:有多少个子类就写多少个映射文件. b.所有子类映射到一张表,适用情况:子类教多，且子类较为简单，即只有个别属性！(通过一个特殊字段作为鉴别器区分是什么类对应的数据) 好处：因为使用一个映射文件， 减少了映射文件的个数. 缺点：不符合数据库设计原则. c.每个类映射一张表:一个映射文件，存储所有的子
Hibernate 简化继承映射
honghailiang的专栏
05-24 721
 http://www.ibm.com/developerworks/cn/java/j-hibernate/ 概述 Hibernate 是一个纯 Java 的对象关系映射和持久性框架，它允许您用 XML 配置文件把普通 Java 对象映射到关系数据库表。使用 Hibernate 能够节约大量项目开发时间，因为整个 JDBC 层都由这个框架管理。这意味着您的应用程序的数据访问层位于 Hi
Hibernate继承映射多态的详解
一个混迹Java界的攻城狮
03-01 1073
一.使用注解，继承映射写法      继承映射在Annotation中使用@Inheritance注解，并且需要使用strategy属性指定继承策略，继承策略有SINGLE_TABLE,TABLE_PER_CLASS和JOINED三种。      在这三种方法中查询速度：第二种方案 > 第一种方案 > 第三种方案。解耦程度：第三种方案 > 第一种方案 > 第二种方案       SING
hibernate 映射继承 demo
03-18
《Hibernate映射继承实战解析》 在Java世界中，Hibernate作为一款强大的对象关系映射（ORM）框架，极大地简化了数据库操作。它允许开发者用面向对象的方式处理数据，而无需关心底层SQL语句的编写。在大型项目中，...
Hibernate映射继承关系的三种方案.docx
06-19
在Java的ORM框架Hibernate中，映射继承关系是常见的需求，尤其在处理具有层次结构的实体类时。本文将详细探讨Hibernate中处理继承关系的三种映射策略：subclass、joined-subclass以及union-subclass。 首先，让我们...
用Hibernate映射继承关系
05-26
### 用Hibernate映射继承关系 #### 14.1 继承关系树的每个具体类对应一个表 在Hibernate中映射继承关系时，一种常见的策略是将继承关系树的每个具体类映射到单独的数据库表中。这种方法称为**表/类映射**(Table/...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 451
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 250
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 621
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 281
集合之Map
【Java算法专场】二分查找(下）
zhyhgx的博客
07-27 860
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
Hibernate继承映射策略解析
"这篇文档介绍了Hibernate框架中关于继承映射的三种策略，即每个继承层次一张表、每个具体类一张表以及每个类一张表。这些策略用于将面向对象的继承关系映射到关系数据库中，以适应不同场景的需求。文档详细讲解了每...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值