Hibernate ManyToOne Mappings 多对一关联映射

最新推荐文章于 2020-02-13 11:51:16 发布
最新推荐文章于 2020-02-13 11:51:16 发布
阅读量2.7k 收藏
点赞数
分类专栏： Hibernate 文章标签： java hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaowanggedege/article/details/36876199
版权
Hibernate ManyToOne Mappings 多对一关联映射


Hibernate框架的使用步骤：
1、创建Hibernate的配置文件（hibernate.cfg.xml）
 2、创建持久化类，即其实例需要保存到数据库中的类（Employee.java）
 3、创建对象-关系映射文件（Employee.hbm.xml）

4、通过Hibernate API编写访问数据库的代码


例子：多个员工对应一个地址。

一、创建hibernate.cfg.xml 配置文件：

注意数据库名、用户名、密码是否填写正确。 

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM 
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory>
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

		<!-- Assume testone is the database name -->
		<property name="hibernate.connection.url">jdbc:mysql://localhost/testMany2One</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">root</property>
		<property name="hibernate.show_sql">true</property>
		
		<!-- List of XML mapping files -->
		<mapping resource="resource/Employee.hbm.xml" />

	</session-factory>
</hibernate-configuration>


二、创建持久化类，即其实例需要保存到数据库中的类（Employee.java、Address.java）

Employee.java
 
package com.jiangge.hblearn;

/**
 * @author jiangge
 */
public class Employee
{
	private int id;
	private String firstName;
	private String lastName;
	private int salary;
	private Address address;

	public Employee()
	{
	}

	public Employee(String firstName, String lastName, int salary,
			Address address)
	{
		this.firstName = firstName;
		this.lastName = lastName;
		this.salary = salary;
		this.address = address;
	}

	public int getId()
	{
		return id;
	}

	public void setId(int id)
	{
		this.id = id;
	}

	public String getFirstName()
	{
		return firstName;
	}

	public void setFirstName(String firstName)
	{
		this.firstName = firstName;
	}

	public String getLastName()
	{
		return lastName;
	}

	public void setLastName(String lastName)
	{
		this.lastName = lastName;
	}

	public int getSalary()
	{
		return salary;
	}

	public void setSalary(int salary)
	{
		this.salary = salary;
	}

	public Address getAddress()
	{
		return address;
	}

	public void setAddress(Address address)
	{
		this.address = address;
	}
}



Address.java
 
package com.jiangge.hblearn;

/**
 * @author shijiangge
 * @version 2014-7-4 上午11:05:39
 * 
 */
public class Address
{
	private int id;
	private String street;
	private String city;
	private String state;
	private String zipcode;

	public Address()
	{
	}

	public Address(String street, String city, String state, String zipcode)
	{
		this.street = street;
		this.city = city;
		this.state = state;
		this.zipcode = zipcode;
	}

	public int getId()
	{
		return id;
	}

	public void setId(int id)
	{
		this.id = id;
	}

	public String getStreet()
	{
		return street;
	}

	public void setStreet(String street)
	{
		this.street = street;
	}

	public String getCity()
	{
		return city;
	}

	public void setCity(String city)
	{
		this.city = city;
	}

	public String getState()
	{
		return state;
	}

	public void setState(String state)
	{
		this.state = state;
	}

	public String getZipcode()
	{
		return zipcode;
	}

	public void setZipcode(String zipcode)
	{
		this.zipcode = zipcode;
	}
}


在MySQL中创建表： 

create table EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   address    INT NOT NULL,
   PRIMARY KEY (id)
);


create table ADDRESS (
   id INT NOT NULL auto_increment,
   street_name VARCHAR(40) default NULL,
   city_name VARCHAR(40) default NULL,
   state_name VARCHAR(40) default NULL,
   zipcode VARCHAR(10) default NULL,
   PRIMARY KEY (id)
);



三、创建对象-关系映射文件（Employee.hbm.xml） 
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD//EN"
 "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!-- 
Hibernate Many-to-One 关联关系：
很多员工可以对应一个地址。


初级的程序员手写 Employee.hbm.xml 映射文件，而高级程序员使用XDoclet, Middlegen and AndroMDA这些技术，自动生成映射文件。

meta 标签是可选的，用来描述类。

Hibernate的主键生成策略：
【identity】采用数据库提供的主键生成机制。如DB2、SQL Server、MySQL 中的主键生成机制。
【native】由 Hibernate 根据使用的数据库自行判断采用 identity、hilo、sequence 其中一种作为主键生成方式。
 -->
<hibernate-mapping>
	<class name="com.jiangge.hblearn.Employee" table="EMPLOYEE">
		<meta attribute="class-description">
			This class contains the employee detail.
		</meta>
		<id name="id" type="int" column="id">
			<generator class="native" />
		</id>
		<property name="firstName" column="first_name" type="string" />
		<property name="lastName" column="last_name" type="string" />
		<property name="salary" column="salary" type="int" />
		<many-to-one name="address" column="address" class="com.jiangge.hblearn.Address" not-null="true" />
	</class>

	<class name="com.jiangge.hblearn.Address" table="ADDRESS">
		<meta attribute="class-description">
			This class contains the address detail.
		</meta>
		<id name="id" type="int" column="id">
			<generator class="native" />
		</id>
		<property name="street" column="street_name" type="string" />
		<property name="city" column="city_name" type="string" />
		<property name="state" column="state_name" type="string" />
		<property name="zipcode" column="zipcode" type="string" />
	</class>

</hibernate-mapping>



四、通过Hibernate API编写访问数据库的代码 

package test;

import java.util.*;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import com.jiangge.hblearn.Address;
import com.jiangge.hblearn.Employee;

/**
 * 测试类：CRUD操作
 * @author jiangge
 *
 */
public class ManageEmployee
{
	private static SessionFactory factory;

	public static void main(String[] args)
	{
		try
		{
			factory = new Configuration().configure().buildSessionFactory();
		} 
		catch (Throwable ex)
		{
			System.err.println("Failed to create sessionFactory object." + ex);
			throw new ExceptionInInitializerError(ex);
		}
		ManageEmployee ME = new ManageEmployee();

		/* Let us have one address object */
		Address address = ME.addAddress("Kondapur", "Hyderabad", "AP", "532");

		/* Add employee records in the database */
		Integer empID1 = ME.addEmployee("Manoj", "Kumar", 4000, address); //("Manoj", "Kumar", 4000, address);

		/* Add another employee record in the database */
		Integer empID2 = ME.addEmployee("Dilip", "Kumar", 3000, address);//("Dilip", "Kumar", 3000, address);

		/* List down all the employees */
		ME.listEmployees();

		/* Update employee's salary records */
		ME.updateEmployee(empID1, 5000);

		/* Delete an employee from the database */
		ME.deleteEmployee(empID2);

		/* List down all the employees */
		ME.listEmployees();

	}

	/* Method to add an address record in the database */
	public Address addAddress(String street, String city, String state, String zipcode)
	{
		Session session = factory.openSession();
		Transaction tx = null;
		Integer addressID = null;
		Address address = null;
		try
		{
			tx = session.beginTransaction();
			address = new Address(street, city, state, zipcode);
			addressID = (Integer) session.save(address);
			tx.commit();
		} 
		catch (HibernateException e)
		{
			if (tx != null)
				tx.rollback();
			e.printStackTrace();
		}
		finally
		{
			session.close();
		}
		return address;
	}

	/* Method to add an employee record in the database */
	public Integer addEmployee(String fname, String lname, int salary,
			Address address)
	{
		Session session = factory.openSession();
		Transaction tx = null;
		Integer employeeID = null;
		try
		{
			tx = session.beginTransaction();
			Employee employee = new Employee(fname, lname, salary, address);
			employeeID = (Integer) session.save(employee);
			tx.commit();
		} 
		catch (HibernateException e)
		{
			if (tx != null)
				tx.rollback();
			e.printStackTrace();
		} 
		finally
		{
			session.close();
		}
		return employeeID;
	}

	/* Method to list all the employees detail */
	public void listEmployees()
	{
		Session session = factory.openSession();
		Transaction tx = null;
		try
		{
			tx = session.beginTransaction();
			List employees = session.createQuery("FROM Employee").list();
			for (Iterator iterator = employees.iterator(); iterator.hasNext();)
			{
				Employee employee = (Employee) iterator.next();
				System.out.print("First Name: " + employee.getFirstName());
				System.out.print("  Last Name: " + employee.getLastName());
				System.out.println("  Salary: " + employee.getSalary());
				Address add = employee.getAddress();
				System.out.println("Address ");
				System.out.println("\tStreet: " + add.getStreet());
				System.out.println("\tCity: " + add.getCity());
				System.out.println("\tState: " + add.getState());
				System.out.println("\tZipcode: " + add.getZipcode());
			}
			tx.commit();
		} 
		catch (HibernateException e)
		{
			if (tx != null)
				tx.rollback();
			e.printStackTrace();
		} 
		finally
		{
			session.close();
		}
	}

	/* Method to update salary for an employee */
	public void updateEmployee(Integer EmployeeID, int salary)
	{
		Session session = factory.openSession();
		Transaction tx = null;
		try
		{
			tx = session.beginTransaction();
			Employee employee = (Employee) session.get(Employee.class,
					EmployeeID);
			employee.setSalary(salary);
			session.update(employee);
			tx.commit();
		}
		catch (HibernateException e)
		{
			if (tx != null)
				tx.rollback();
			e.printStackTrace();
		} 
		finally
		{
			session.close();
		}
	}

	/* Method to delete an employee from the records */
	public void deleteEmployee(Integer EmployeeID)
	{
		Session session = factory.openSession();
		Transaction tx = null;
		try
		{
			tx = session.beginTransaction();
			Employee employee = (Employee) session.get(Employee.class, EmployeeID);
			session.delete(employee);
			tx.commit();
		} 
		catch (HibernateException e)
		{
			if (tx != null)
				tx.rollback();
			e.printStackTrace();
		} 
		finally
		{
			session.close();
		}
	}
}



五、运行结果： 
mysql>  select * from EMPLOYEE;
+----+------------+-----------+--------+---------+
| id | first_name | last_name | salary | address |
+----+------------+-----------+--------+---------+
|  1 | Manoj      | Kumar     |   5000 |       1 |
+----+------------+-----------+--------+---------+
1 row in set

mysql> select * from ADDRESS;
+----+-------------+-----------+------------+---------+
| id | street_name | city_name | state_name | zipcode |
+----+-------------+-----------+------------+---------+
|  1 | Kondapur    | Hyderabad | AP         | 532     |
+----+-------------+-----------+------------+---------+
1 row in set

mysql> 




log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate: insert into ADDRESS (street_name, city_name, state_name, zipcode) values (?, ?, ?, ?)
Hibernate: insert into EMPLOYEE (first_name, last_name, salary, address) values (?, ?, ?, ?)
Hibernate: insert into EMPLOYEE (first_name, last_name, salary, address) values (?, ?, ?, ?)
Hibernate: select employee0_.id as id0_, employee0_.first_name as first2_0_, employee0_.last_name as last3_0_, employee0_.salary as salary0_, employee0_.address as address0_ from EMPLOYEE employee0_
First Name: Manoj  Last Name: Kumar  Salary: 4000
Address 
Hibernate: select address0_.id as id1_0_, address0_.street_name as street2_1_0_, address0_.city_name as city3_1_0_, address0_.state_name as state4_1_0_, address0_.zipcode as zipcode1_0_ from ADDRESS address0_ where address0_.id=?
	Street: Kondapur
	City: Hyderabad
	State: AP
	Zipcode: 532
First Name: Dilip  Last Name: Kumar  Salary: 3000
Address 
	Street: Kondapur
	City: Hyderabad
	State: AP
	Zipcode: 532
Hibernate: select employee0_.id as id0_0_, employee0_.first_name as first2_0_0_, employee0_.last_name as last3_0_0_, employee0_.salary as salary0_0_, employee0_.address as address0_0_ from EMPLOYEE employee0_ where employee0_.id=?
Hibernate: update EMPLOYEE set first_name=?, last_name=?, salary=?, address=? where id=?
Hibernate: select employee0_.id as id0_0_, employee0_.first_name as first2_0_0_, employee0_.last_name as last3_0_0_, employee0_.salary as salary0_0_, employee0_.address as address0_0_ from EMPLOYEE employee0_ where employee0_.id=?
Hibernate: delete from EMPLOYEE where id=?
Hibernate: select employee0_.id as id0_, employee0_.first_name as first2_0_, employee0_.last_name as last3_0_, employee0_.salary as salary0_, employee0_.address as address0_ from EMPLOYEE employee0_
First Name: Manoj  Last Name: Kumar  Salary: 5000
Address 
Hibernate: select address0_.id as id1_0_, address0_.street_name as street2_1_0_, address0_.city_name as city3_1_0_, address0_.state_name as state4_1_0_, address0_.zipcode as zipcode1_0_ from ADDRESS address0_ where address0_.id=?
	Street: Kondapur
	City: Hyderabad
	State: AP
	Zipcode: 532


参考文献：

易枭寒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JPA 中使用 @OneToMany 、@ManyToOne 等关系映射注解
小张Python
11-26 4573
JPA 做 ORM(Object Relational Mapping，对象关系映射)时，为了开发效率，通常会在实体类上用 hibernate 的关系关联注解。方法，可以解决了父子实体类打印输出时，因相互依赖循环嵌套中堆栈溢出问题；一起使用，既可以单向，也可以双向关联；）关系，一个组可以容纳多个学生，一对多；查询 GroupClass 对象，在输出打印对象的。该错误解决方法：在父类或子类对应的关联字段上，加上。，使用时会触发嵌套循环，造成栈溢出问题；外键关联，一般子实体类这边维护，因此由。
hibernate开发包
06-11
4. 关系映射（Relationship Mapping）：Hibernate支持一对一、一对多、多对一和多对多的关系映射，如`@OneToOne`、`@OneToMany`、`@ManyToOne`、`@ManyToMany`等，这些映射使得处理复杂的数据关联变得简单。...
hibernate manytoone
03-06
本代码为hibernate的manytoone的代码 博文链接：https://shaqiang32.iteye.com/blog/201307
Hibernate的那些事-manyToOne注解映射(Map集合)
skewen的专栏
04-21 4128
Hibernate @ManyToOne
进击的Nico
02-13 1033
在多方应设置一方的主键值，保存多方时，才能保证一方不会再次生成一条记录。 User user = new User(); user.setUserid(2); user.setUsername("test"); Event event = new Event (); event.setUser(user);
hibernate框架开发2016版视频 四天学习笔记完整版
04-18
- 关联映射：涵盖一对一、一对多、多对一、多对多等关联关系的配置和操作。 - 缓存机制：介绍Hibernate的一级缓存（Session级别）和二级缓存（SessionFactory级别），以及如何配置和利用缓存提高性能。 - 事务管理：...
Hibernate api
08-13
Hibernate API 是一个强大的Java持久化框架，用于简化数据库操作，它是对象关系映射（ORM）工具的代表之一。这个框架允许开发者用面向对象的方式处理数据，而无需直接编写SQL语句，大大提高了开发效率和代码的可维护...
Hibernate数据持久层框架 v5.3.36 正式版.zip
最新发布
03-21
此外，Hibernate支持懒加载和立即加载策略，通过`@ManyToOne`、`@OneToMany`、`@OneToOne`和`@ManyToMany`注解来管理关联关系。 Hibernate的主要组件包括： 1. Session：是Hibernate的基本工作单元，负责与数据库...
Hibernate之多对一单向映射（ManyToOne）
qq30211478的博客
08-30 450
（一）多对一单向映射基于注解的方式（在多方加外键，如果在一方加的话，会造成冗余） 在实体属性一级使用@ManyToOne注解来定义多对一关联: @Entity() public class Flight implements Serializable { @ManyToOne @JoinColumn(name="COMP_ID")//可以指定外键的名字即在数据库表中字段的名
Hibernate @ManyToOne -- 1
endercc的专栏
12-30 816
Class CreditCard @ManyToOne public Person getPerson() { return person; }TableCREATE TABLE `creditcard` (   `id` varchar(32) NOT NULL,   `createDate` datetime DEFAULT NULL,   `modifyDate` datetime
Hibernate的那些事-manyToOne映射
skewen的专栏
04-17 1641
hibernate——manytoone（单向）
archer的技术故事
06-25 926
hibernate——manytoone package com.xueyoucto.xueyou; import org.hibernate.annotations.*; import org.hibernate.annotations.CascadeType; import javax.persistence.*; import javax.persistence.Entity; imp
Hibernate_ManyToOne_Demo
qq_34805046的博客
05-20 344
package org.zttc.itat.test; import org.hibernate.Session; import org.junit.Test; import org.zttc.itat.model.Classroom; import org.zttc.itat.model.Student; import org.zttc.itat.util.HibernateUtil; pu
Hibernate Many-to-Many Mappings
xiaowanggedege的专栏
09-15 2424
创建表： create table EMPLOYEE ( id INT NOT NULL auto_increment, first_name VARCHAR(20) default NULL, last_name VARCHAR(20) default NULL, salary INT default NULL, PRIMARY KEY (id) );
hibernate中Annotation中manyToOne使用:
彻底拆分，一切可控！
12-27 818
在使用hibernate的Annotation配置方式进行配置的时候,如果使用了manyToOne的话一定要在数据库中把它们的主外键关系给设置好,否则在你向程序添加数据的时候就会出错,因为在hibernate看来,具有manyToOne的两个实体之间必然是具有外间关系的两个实体. 如果你不去设置的话,那么不好意思hibernate会自动的帮助你添加的,但即便如此也还是会出错的,因为他帮你
Spring Boot笔记-Hibernate中@ManyToOne及@OneToOne
IT1995的博客
02-13 5616
ER图如下： 这里只截取了部分，可见normalGoods表和user表中有关系。normalGoods和topGoods表有关系， 其中对应的表内容如下： normalGOods topGoods user 其中对应的代码如下： TopGoods.java package com.it1995.demo.object; import lombok.Data; ...
Hibernate关联映射详解：从一对一到多对多
在关联映射方面，Hibernate支持多种关系类型，包括一对一、一对多、多对一和多对多。这里主要讨论了一对多和多对多的关系。 1. 一对多关联映射：在Java对象模型中，一个父类对象可以有多个子类对象，这种关系在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值