一对一关联关系实例

最新推荐文章于 2022-01-11 20:59:16 发布
最新推荐文章于 2022-01-11 20:59:16 发布
阅读量3.2k 收藏 1
点赞数 1
文章标签： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/monkey_wei/article/details/104484115
版权

项目的文件结构：
在这里插入图片描述
HibernateSessionFactory.java

package addHibFile;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.omg.CORBA.PRIVATE_MEMBER;
import org.hibernate.HibernateException;

public class HibernateSessionFactory {
	private static String CONFIG_FILE_LOCATION="/hibernate.cfg.xml";
	private HibernateSessionFactory() {
		
	}
	private static final ThreadLocal threadLocal=new ThreadLocal();
	private static final Configuration cfg=new Configuration();
	private static SessionFactory sessionFactory;
	public static Session currentSession() throws HibernateException{
		Session session=(Session)threadLocal.get();
		if(session==null) {
			if(sessionFactory==null) {
				try {
					cfg.configure(CONFIG_FILE_LOCATION);
					sessionFactory=cfg.buildSessionFactory();
				}
				catch (Exception e) {
					// TODO: handle exception
					System.out.println("生成SessionFactory失败！！！");
					e.printStackTrace();
				}
			}
			session=sessionFactory.openSession();
			threadLocal.set(session);
		}
		return session;
	}
	
	public static void closeSession() throws HibernateException{
		Session session=(Session)threadLocal.get();
		threadLocal.set(null);
		if(session!=null) {
			session.close();
		}
	}
}

OneOneDAO.java

package DAO;
import addHibFile.HibernateSessionFactory;
import org.hibernate.*;
import PO.*;

public class OneOneDAO {
	//添加会员的方法
	public void addCompany(Company company) {
		Session session=HibernateSessionFactory.currentSession();
		Transaction ts=null;
		try {
			ts=session.beginTransaction();
			session.save(company);
			ts.commit();
		}catch (Exception e) {
			// TODO: handle exception
			ts.rollback();
			System.out.println("系统错误：在OneOneDAO的addCompany方法中出错：");
			e.printStackTrace();
		}finally {
			HibernateSessionFactory.closeSession();
		}
	}
	
	//获取会员信息
	public Company loadCompany(Integer id) {
		Session session=HibernateSessionFactory.currentSession();
		Transaction ts=null;
		Company company=null;
		try {
			ts=session.beginTransaction();
			company=(Company)session.get(Company.class, id);
			ts.commit();
		}catch (Exception e) {
			// TODO: handle exception
			ts.rollback();
			System.out.println("系统错误：在OneOneDAO中的loadCompany方法出错：");
			e.printStackTrace();
		}finally {
			HibernateSessionFactory.closeSession();
		}
		return company;
	}
	
	//添加客户信息
	public void addClient(Client client) {
		Session session=HibernateSessionFactory.currentSession();
		Transaction ts=null;
		try {
			ts=session.beginTransaction();
			session.save(client);
			ts.commit();
		}catch (Exception e) {
			// TODO: handle exception
			ts.rollback();
			System.out.println("系统错误：在OneOneDAO中的addClient方法中出错：");
			e.printStackTrace();
		}finally {
			HibernateSessionFactory.closeSession();
		}
	}
	
	//获取客户信息
	public Client loadClient(Integer id) {
		Session session=HibernateSessionFactory.currentSession();
		Transaction ts=null;
		Client client=null;
		try {
			ts=session.beginTransaction();
			client=(Client)session.get(Client.class, id);
			ts.commit();
		}catch (Exception e) {
			// TODO: handle exception
			ts.rollback();
			System.out.println("系统错误：在OneOneDAO中loadClient方法中出错：");
			e.printStackTrace();
		}finally {
			HibernateSessionFactory.closeSession();
		}
		return client;
	}
}

Address.java

package PO;
import java.io.Serializable;

public class Address implements Serializable{
	private Integer id;
	private String province;			//省份
	private String city;				//城市
	private String street;				//街道
	private String zipcode;				//邮编
	private Client client;				//关联另外一个类
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getProvince() {
		return province;
	}
	public void setProvince(String province) {
		this.province = province;
	}
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	public String getStreet() {
		return street;
	}
	public void setStreet(String street) {
		this.street = street;
	}
	public String getZipcode() {
		return zipcode;
	}
	public void setZipcode(String zipcode) {
		this.zipcode = zipcode;
	}
	public Client getClient() {
		return client;
	}
	public void setClient(Client client) {
		this.client = client;
	}
	
}

Address.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 解析文件的DTD -->
<!DOCTYPE hibernate-mapping PUBLIC
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
	<!-- 映射文件的根目录 -->
	<hibernate-mapping package="PO">
		<class name="Address" table="address">
			<id column="ID" name="id" type="integer">
				<generator class="identity"></generator>
			</id>
			<property name="province" column="PROVINCE" type="string"></property>
			<property name="city" column="CITY" type="string"></property>
			<property name="street" column="STREET" type="string"></property>
			<property name="zipcode" column="ZIPCODE" type="string"></property>
			<!-- 映射Client与Address的一对一外键关联 -->
			<one-to-one name="Client" class="PO.Client" property-ref="address"></one-to-one>
		</class>
	</hibernate-mapping>

Client.java

package PO;
import java.io.Serializable;

public class Client implements Serializable{
	private Integer id;
	private String clientname;			//客户名称
	private String phone;				//客户电话
	private String email;				//客户邮箱
	private Address address;			//关联另外一个PO
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getClientname() {
		return clientname;
	}
	public void setClientname(String clientname) {
		this.clientname = clientname;
	}
	public String getPhone() {
		return phone;
	}
	public void setPhone(String phone) {
		this.phone = phone;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}
	
}

cliemt.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 解析文件的DTD -->
<!DOCTYPE hibernate-mapping PUBLIC
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
	<!-- 映射文件的根目录 -->
	<hibernate-mapping package="PO">
		<class name="Client" table="client">
			<id column="ID" name="id" type="integer">
				<generator class="identity"></generator>
			</id>
			<property column="CLIENTNAME" name="clientname" type="string"></property>
			<property column="PHONE" name="phone" type="string"></property>
			<property column="EMAIL" name="email" type="string"></property>
			<!-- 映射Client到Address的一对一外键关联，唯一的多对一，实际上变成了一对一关系 -->
			<many-to-one name="address" class="PO.Address" column="address" cascade="all"
				lazy="false" unique="true"></many-to-one>
		</class>
	</hibernate-mapping>

Company.java

package PO;
import java.io.Serializable;

public class Company implements Serializable{
	private Integer id;					
	private String companyname;			//单位名称
	private String linkman;				//单位联系人
	private String telephone;			//联系电话
	private String email;				//邮箱
	private Login login;				//关联另外一个类，即Login类
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getCompanyname() {
		return companyname;
	}
	public void setCompanyname(String companyname) {
		this.companyname = companyname;
	}
	public String getLinkman() {
		return linkman;
	}
	public void setLinkman(String linkman) {
		this.linkman = linkman;
	}
	public String getTelephone() {
		return telephone;
	}
	public void setTelephone(String telephone) {
		this.telephone = telephone;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public Login getLogin() {
		return login;
	}
	public void setLogin(Login login) {
		this.login = login;
	}
	
}

Company.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 解析文件的DTD -->
<!DOCTYPE hibernate-mapping PUBLIC
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
	<!-- 映射文件的根目录 -->
	<hibernate-mapping package="PO">
		<class name="Company" table="company">
			<id column="ID" name="id" type="integer">
				<!-- 自增 -->
				<generator class="identity"></generator>
			</id>
			<property name="companyname" column="COMPANYNAME" type="string"></property>
			<property name="linkman" column="LINKMAN" type="string"></property>
			<property name="telephone" column="TELEPHONE" type="string"></property>
			<property name="email" column="EMAIL" type="string"></property>
			<!-- 映射Company与Login的一对一主键关联 -->
			<one-to-one name="login" cascade="all" class="PO.Login" lazy="false" fetch="join"
				outer-join="true"></one-to-one>
		</class>
	</hibernate-mapping>

Login.java

package PO;
import java.io.Serializable;

public class Login implements Serializable{
	private Integer id;				
	private String loginname;		//登陆账号
	private String loginpwd;		//登陆密码
	private Company company;		//关联另外一个类Company
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getLoginname() {
		return loginname;
	}
	public void setLoginname(String loginname) {
		this.loginname = loginname;
	}
	public String getLoginpwd() {
		return loginpwd;
	}
	public void setLoginpwd(String loginpwd) {
		this.loginpwd = loginpwd;
	}
	public Company getCompany() {
		return company;
	}
	public void setCompany(Company company) {
		this.company = company;
	}
	
}

Login.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 解析文件的DTD -->
<!DOCTYPE hibernate-mapping PUBLIC
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
	<!-- 映射文件的根目录 -->
	<hibernate-mapping package="PO">
		<class name="Login" table="login">
			<id column="ID" name="id" type="integer">
				<generator class="foreign">
					<param name="property">company</param>
				</generator>
			</id>
			<property name="loginname" column="LOGINNAME" type="string"></property>
			<property name="loginpwd" column="LOGINPWD" type="string"></property>
			<!-- 映射Company与Login的一对一关联 -->
			<one-to-one name="company" class="PO.Company" constrained="true"></one-to-one>
		</class>
	</hibernate-mapping>

TextBean.java

package text;
import PO.*;
import DAO.OneOneDAO;

public class TextBean {
	OneOneDAO dao=new OneOneDAO();
	
	//添加会员信息
	public void addCompany() {
		Company company=new Company();
		Login login=new Login();
		login.setLoginname("QQ");
		login.setLoginpwd("123");
		company.setCompanyname("清华大学出版设");
		company.setLinkman("某某某");
		company.setTelephone("123456754");
		company.setEmail("1234543qq.com");
		//持久化对象之间相互设置关联关系
		login.setCompany(company);
		company.setLogin(login);
		dao.addCompany(company);
	}
	
	//获取会员信息
	public Company loadCompany(Integer id) {
		return dao.loadCompany(id);
	}
	
	//添加客户信息
	public void addClient() {
		Client client=new Client();
		Address address=new Address();
		address.setCity("杭州");
		address.setProvince("杭州市");
		address.setStreet("红枫街道");
		address.setZipcode("100324");
		client.setClientname("hjw");
		client.setEmail("1235543qq.com");
		client.setPhone("23123");
		//PO对象之间相互设置关联关系
		address.setClient(client);
		client.setAddress(address);
		dao.addClient(client);
	}
	
	//获取客户信息
	public Client loadClient(Integer id) {
		return dao.loadClient(id);
	}
}

index.jsp

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@page import="text.TextBean" %>
<%@page import="PO.*" %>
<html>
	<head>
		<title>Hibernate5的一对一关系映射</title>
	</head>
	<body>
		<h2>Hibernate5的一对一关联映射</h2>
		<hr>
		<!-- 调用TextBean测试 -->
		<jsp:useBean id="test" class="text.TextBean"></jsp:useBean>
		<%
			test.addCompany();
			out.println("添加一个公司<br>");
			test.addClient();
			out.println("添加一个客户<br>");
			Integer id=new Integer(1);
			Company company=test.loadCompany(id);
			out.println("加载id为1的客户<br>");
			Login login=company.getLogin();
			out.println("获取公司的登陆账号<br>");
			Client client=test.loadClient(id);
			out.println("获取id为1的客户<br>");
			Address address=client.getAddress();
			out.println("获取该客户地址");
			out.println("<br>company.getCompanyname()="+company.getCompanyname());
			out.println("<br>company.getEmail()="+company.getEmail());
			out.println("<br>company.getLinkman()="+company.getLinkman());
			out.println("<br>company.getTelephone()="+company.getTelephone());
			out.println("<br>login.getLoginname()="+login.getLoginname());
			out.println("<br>login.getLoginpwd()="+login.getLoginpwd());
			out.println("<br>");
			out.println("<br>client.getClientname()="+client.getClientname());
			out.println("<br>client.getPhone()="+client.getPhone());
			out.println("<br>client.getEmail()="+client.getEmail());
			out.println("<br>address.getProvince()="+address.getProvince());
			out.println("<br>address.getCity()="+address.getCity());
			out.println("<br>address.getStreet()="+address.getStreet());
			out.println("<br>address.getZipcode()="+address.getZipcode());
		%>
	</body>
</html>

运行结果：

在这里插入图片描述

monkey_wei
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hibernate常用一对一、一对多、多对一、多对多映射关系真实例子(华南银行项目)
03-06
博文链接：https://davexin.iteye.com/blog/102726
关系数据库一对一关系模式应用示例
weixin_34008933的博客
05-28 671
关系数据库中，一对多关系使用的非常普遍，多对多关系也时有用到，而一对一关系用的非常之少，本篇将展示一个一对一关系的使用示例。 首先我们有这样一个数据库： 这是一个简单的商业数据库，现在有一个需求：要求用户可以上传多个图片以展示商品、商铺、市场、品牌，那么怎么设计呢？ 首先想到的是为每个表追加一个附属表用于专门存储图片，那么先创建市场照片表： 接着是商铺照片表： 马上你就会发现这样冗余很...
一对一 关联关系
Satisfy_555的博客
04-27 2119
说明：首先本demo是用maven搭建的，本来想只引入mybatis开发的相关jar包，然后发现一个个找也不是很好找，然后就想起之前用maven搭的SSM框架，其中mybatis就是可以用的，所以我直接使用的就是那个框架的pom.xml文件。如需要请参照本人之前写的博文‘用MAVEN搭建SSM（Spring+SpringMVC+MyBatis）整合小案例（用户登录功能）’中，当然，jar不一定是全...
Hibernate的一对一关联实例
lxx2844的专栏
07-19 1609
Hibernate的一对一关联实例 Hibernate中的表的关联有一对一，一对多和多对多三种关联方式，在这篇笔记和接下来的笔记中，我将用我自己的实际例子来说明如何具体实施。      我使用的Hibernate版本是2.1.8，在Hibernate的网站2.1.6版本的中文文档中有关一对一的关联有下面一段表述：5.1.11. 一对一持久化对象之间一对一的关联关系是通过one-to-o
一对一关系
anwenzhao0749的博客
09-28 297
@Entity @Table(name="person_one") public class Person { private Integer id; private String name; private IDCard idcard; @OneToOne(cascade={CascadeType.ALL},optional=false) ...
mybatis实现一对一关联映射实例代码
08-28
MyBatis 实现一对一关联映射实例代码 MyBatis 是一个基于 Java 的持久层框架，它提供了对数据库的访问和操作。在实际项目开发中，经常存在一对一的关系，如一个人对应一张身份证信息，这就是一对一的关系。下面我们...
hibernate关联关系多对一实例
07-07
6. **查询优化**：在处理多对一关联时，我们需要关注HQL（Hibernate Query Language）或JPA的Criteria API，以及JOIN fetch，以避免过多的数据库查询。例如，通过`join fetch`可以一次性获取学生和其关联的教师信息...
MyBatis的一对一关联映射
12-05
一对一关联映射是指两个实体类之间存在一对一的关系，即每个实体实例对应数据库中的一条记录，且这条记录在另一张表中也有唯一对应的记录。在 MyBatis 中，我们可以通过 XML 映射文件或者注解来配置这种关联关系。 ...
多对一双向关联关系实现源码
10-08
多对一关联关系是指在数据库中，一个实体（表）可以与多个其他实体（表）相关联，而另一个实体则对应于前者的多个实例。双向关联则是指在Java对象中，两个关联的实体都能直接访问对方。例如，一个学生可以属于多个...
一对多单向关联关系实现元源码
10-08
文件中的示例代码将展示如何在实践中创建和管理这些实体的实例，从而加深对一对多单向关联关系的理解。 总之，一对多单向关联关系在Hibernate中是一种常用的数据建模技术，它允许我们简洁地表示一个实体与多个其他...
Hibernate 一对一，一对多，多对多例子
12-29
Hibernate一对一，一对多，多对多例子，讲的非常清楚
hibernate一对一的例子
05-27
学习hibernate的时候，自己写了一个小例子，大家有需要用到的可以参考一下
一对一关联关系
Konaji
01-26 4314
一对一关联关系
一对一关联（one-to-one）
Leon_Jinhai_Sun的博客
01-11 407
在实际的开发中应用不多，因为一对一可以创建成一张表。 举例：设计学生表：学号、姓名、手机号码、班级、系别、身份证号码、家庭住址、籍贯、紧急联系人、... 拆为两个表：两个表的记录是一一对应关系。 基础信息表（常用信息）：学号、姓名、手机号码、班级、系别 档案信息表（不常用信息）：学号、身份证号码、家庭住址、籍贯、紧急联系人、... 两种建表原则： 外键唯一：主表的主键和从表的外键（唯一），形成主外键关系，外键唯一。 ..
《Hibernate学习笔记六》一对一关联关系详解
wojiushimogui的博客
05-02 978
《Hibernate学习笔记六》一对一关联关系详解从今天开始，就要开始学习关联关系了，其中关联关系，分为如下几种：1、一对一关联关系2、一对多关联关系3、多对一关联 关系 4、多对多关联关系总的来说，虽然有如上几种关联方式，但是我们可以理解它只是1中关联方式，就 多对多关联，这是因为其他的关联方式都可以理解为此关联方式的一种特殊方式。其中，上面提到的关联关系，都存在单向和双向的关联关系。这篇博文主要
java中对象的一对一的关系案例
java编程学习_java基础教程_booyzhang的博客
05-04 638
两个对象之间的一对一的关系 比如一个英雄(Hero)对应一个兵器(Weapon) //对象一对一的关系 public class HeroWeapon{ public static void main(String[] args){ Hero hero = new Hero("曹操",300); Weapon weapon = new Weapon("倚天剑",4); //对象...
一对一关联关系的使用
开心就好
11-24 577
一对一关系在实际生活中是比较常见的，例如学生与学生证的关系，通过学生证可以找到学生。一对一关系在Hibernate中的实现有两种方式，分别是主键关联和外键关联。 1．以主键关联 主键关联的重点是，关联的两个实体共享一个主键值。例如，Student与Card是一对一关系，它们在数据库中对应的表分别是t_student 和t_card。它们共用一个主键值id，这个主键可由t_stud...
models -- 一对一关系
weixin_30781107的博客
09-27 134
class Author(models.Model): name = models.CharField(max_length=30) def __str__(self): return self.name class AuthorDetail(models.Model): sex = models.BooleanField(ma...
mysql 1对1实例_mysql 多实例
weixin_30174223的博客
01-27 122
第三章mysql的多实例(一).MySQL5.6与MySQL5.7安装的区别一.二.MySQL用户权限管理三.MySQL连接管理四.MySQL启动关闭流程五.MySQL实例初始化配置六.MySQL多实例配置(二).MySQL的用户管理Linux上用户操作创建用户：useradd删除用户：userdel修改用户：usermodMySQL上用户操作创建用户：create user 、 grant#创建...
给我设计一个一对多表关联关系实例
最新发布
05-05
好的，假设我们要设计一个博客系统，其中有两个实体：用户和文章。一个用户可以写多篇文章，而一篇文章只能由一个用户撰写。 我们可以设计两个表：一个用户表和一个文章表。用户表包含用户的基本信息，例如用户ID、用户名、电子邮件地址、密码等等。文章表包含文章的标题、内容、发布日期、作者ID等等。 在数据库中，我们可以通过在文章表中添加一个外键列来实现一对多关联。具体来说，我们可以在文章表中添加一个“作者ID”列，并将其设置为用户表中的“用户ID”列的外键。这样，每篇文章都会与一个用户关联起来，而每个用户都可以有多篇文章。 下面是两个表的基本结构： 用户表（User） - 用户ID（UserID） - 用户名（Username） - 电子邮件地址（Email） - 密码（Password） 文章表（Article） - 文章ID（ArticleID） - 标题（Title） - 内容（Content） - 发布日期（PublishDate） - 作者ID（AuthorID）（外键，参考用户表中的UserID字段）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值