Hibernate 基于注解的方式 实现的关系映射案例（一对一关系，一对多关系，多对多关系）

Hibernate 基于注解的方式 实现的关系映射案例（一对一关系，一对多关系，多对多关系）

本案例使用的hibernate版本为  hibernate-release-5.2.10.Final 

本案例创建了一个 Code（身份证）类，Items(商品)类，Orders(订单)类，User（用户）类。一个用户指南有一个身份证，一个身份证只属于一个用户，Code和User属于一对一关系；一个用户可以有多个订单，但一个订单只能属于一个用户，User 和 Orders 属于一对多关系；一个订单可以有多个商品，一个商品可以被多个订单包括，Orders 和 Items 属于多对多关系。下面是使用注解的方式完成一个案例表示他们之间的关系。

创建一个java项目：项目的结构如下：（lib文件夹用于存放jar包）

lib目录下则是hibernate5需要的jar包（注需要将jar加载到项目中：选中jar包右键 --》BuildPath--》Add to Build Path）

log4j.properties为日志配置文件（需要加载配置junit），此项目可以不需要日志，使用日志只是为了观察方便。
注：junit配置可以参考 http://blog.csdn.net/benxiaohai888/article/details/78231911

由于在主配置文件配置了字段创建数据表的配置，所以第一次加载时就会自动创建数据表

配置的代码：

<!-- 自动生成数据表（数据表的生成方式） -->
<property name="hbm2ddl.auto">update</property>

接下来是示例代码：

1、主配置文件 hibernate.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>
		<!-- 数据库URL -->
		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/db?characterEncoding=utf8</property>
		<!--数据库用户名， -->
		<property name="hibernate.connection.username">root</property>
		<!--数据库密码 -->
		<property name="hibernate.connection.password"></property>

		<!--配置二:数据库方言配置，配置数据库方言的作用是屏蔽数据库的差异，换句话说是使hibernate框架知道 要与哪种数据库取得联系 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>

		<!-- <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property> -->

		<!--配置三：其它配置 （这些配置可选） -->

		<!-- 是否在控制台显示sql语句 -->
		<property name="hibernate.show_sql">true</property>
		<!--是否格式化删除sql语句 -->
		<property name="hibernate.format_sql">true</property>
		<!-- 自动生成数据表（数据表的生成方式） -->
		<property name="hbm2ddl.auto">update</property>
		<!-- 将session绑定到当前线程 -->
		<property name="hibernate.current_session_context_class">thread</property>
		<!-- 设置事务的隔离级别 -->
		<property name="hibernate.connection.isolation">4</property>

		<!-- 配置四：映射配置 -->
		<!-- 基于注解的配置方式 -->
		<!-- <mapping class="cn.sz.entity.User" /> -->
		<mapping class="cn.sz.pojo.User" />
		<mapping class="cn.sz.pojo.Orders" />
		<mapping class="cn.sz.pojo.Items" />
		<mapping class="cn.sz.pojo.Code" />
	</session-factory>
</hibernate-configuration>
	

2、工具类（获取Session）HibernateUtil.java

package cn.sz.utils;

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

public class HibernateUtil {
	public static Session getSession() {
		Session session = null;
		// 创建一个读取主配置文件的对象
		Configuration cfg = new Configuration();
		// 读取主配置文件
		// cfg.configure("hibernate.cfg.xml");如果读取的主配置文件时默认的名字则可以省略参数
		cfg.configure();
		// 创建SessionFactory
		SessionFactory factory = cfg.buildSessionFactory();
		// 打开session
		// 我们在主配置中已经将session绑定到线程中，所以可以从线程中取出session
		// 不从线程中取出session，则可以使用 factory.openSession(); 方式获得session
		session = factory.getCurrentSession();
		return session;

	}

}

3、日志文件 log4j.properties

log4j.rootLogger=DEBUG,console,FILE
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.threshold=INFO
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] - %c -%F(%L) -%m%n
log4j.appender.FILE=org.apache.log4j.RollingFileAppender
log4j.appender.FILE.maxBackupIndex=100
##log4j.appender.FILE=org.apache.log4j.DailyRollingFileAppender 
log4j.appender.FILE.Append=true
log4j.appender.FILE.File=c:/error1.log
log4j.appender.FILE.Threshold=INFO
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] - %c -%F(%L) -%m%n
log4j.appender.FILE.MaxFileSize=1MB

4、身份证类 Code.java

package cn.sz.pojo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;

@Entity
@Table(name = "c_code")
public class Code {
	// 基于外键的配置
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Integer codeId;

	// 基于共享主键的配置
	// @Id
	// @GenericGenerator(name = "foreignKey", parameters = @Parameter(value =
	// "user", name = "property"), strategy = "foreign")
	// @GeneratedValue(generator = "foreignKey")
	// private Integer userId;

	private String code;

	// 基于外键的方式，一对一关系（用户和身份证）
	@OneToOne
	@JoinColumn(name = "userId")
	private User user;

	// 基于共享主键的配置
	// @OneToOne(cascade=CascadeType.ALL)
	// @PrimaryKeyJoinColumn
	// private User user;

	public Integer getCodeId() {
		return codeId;
	}

	public void setCodeId(Integer codeId) {
		this.codeId = codeId;
	}

	public String getCode() {
		return code;
	}

	public void setCode(String code) {
		this.code = code;
	}

	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}

}

5、商品类 Items.java

package cn.sz.pojo;

import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Entity
@Table(name = "c_items")
public class Items {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Integer itemsId;

	private String itemsname;

	// 多对多关系（订单和商品）
	@ManyToMany
	@JoinTable(name = "c_orders_items", joinColumns = { @JoinColumn(name = "itemsId") }, inverseJoinColumns = {
			@JoinColumn(name = "ordersId") })
	private Set<Orders> orderss;

	public Integer getItemsId() {
		return itemsId;
	}

	public void setItemsId(Integer itemsId) {
		this.itemsId = itemsId;
	}

	public String getItemsname() {
		return itemsname;
	}

	public void setItemsname(String itemsname) {
		this.itemsname = itemsname;
	}

	public Set<Orders> getOrderss() {
		return orderss;
	}

	public void setOrderss(Set<Orders> orderss) {
		this.orderss = orderss;
	}

}

6、订单类 Orders.java

package cn.sz.pojo;

import java.util.Set;

import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name = "c_orders")
public class Orders {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Integer ordersId;
	private String ordersName;

	// 一对多关系(用户和订单)
	@ManyToOne(cascade = CascadeType.ALL)
	@JoinColumn(name = "userId")
	@Basic(fetch = FetchType.LAZY)  添加此项配置并不能实现一的一方维护关系
	private User user;

	// 多对多关系(订单和商品)
	@ManyToMany
	@JoinTable(name = "c_orders_items", joinColumns = { @JoinColumn(name = "ordersId") }, inverseJoinColumns = {
			@JoinColumn(name = "itemsId") })
	private Set<Items> itemss;

	public Set<Items> getItemss() {
		return itemss;
	}

	public void setItemss(Set<Items> itemss) {
		this.itemss = itemss;
	}

	public Integer getOrdersId() {
		return ordersId;
	}

	public void setOrdersId(Integer ordersId) {
		this.ordersId = ordersId;
	}

	public String getOrdersName() {
		return ordersName;
	}

	public void setOrdersName(String ordersName) {
		this.ordersName = ordersName;
	}

	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}

}

7、用户类 User.java

package cn.sz.pojo;

import java.util.Date;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;

@Entity
@Table(name = "c_user")
public class User {
	// 基于外键的方式时，使用的配置(一对一关系)

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Integer userId;

	// 基于共享主键的方式，所使用的配置
	// @Id
	// @GeneratedValue(strategy = GenerationType.IDENTITY)
	// private Integer userId;

	private String userName;
	private Date birthday;

	// 一对多关系(用户和订单),添加cascade配置并不能实现一的一方维护关系
	@OneToMany(targetEntity = Orders.class, mappedBy = "user", cascade = CascadeType.ALL)
	private Set<Orders> orderss;

	// 基于外键的方式(一对一关系，用户和身份证)
	@OneToOne(mappedBy = "user", cascade = CascadeType.ALL)
	private Code code;

	// 基于共享主键的配置
	// @OneToOne
	// @PrimaryKeyJoinColumn
	// private Code code;

	public Code getCode() {
		return code;
	}

	public void setCode(Code code) {
		this.code = code;
	}

	public Integer getUserId() {
		return userId;
	}

	public void setUserId(Integer userId) {
		this.userId = userId;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	public Set<Orders> getOrderss() {
		return orderss;
	}

	public void setOrderss(Set<Orders> orderss) {
		this.orderss = orderss;
	}

}

8、测试类  UserOrOrders.java

package cn.sz.test;

import java.util.Date;
import java.util.HashSet;

import org.hibernate.Session;
import org.junit.Test;

import cn.sz.pojo.Code;
import cn.sz.pojo.Items;
import cn.sz.pojo.Orders;
import cn.sz.pojo.User;
import cn.sz.utils.HibernateUtil;

public class UserOrOrders {
	@Test
	public void testSave() {
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		// 创建一个用户
		User user = new User();
		user.setUserName("李四");
		user.setBirthday(new Date());

		// 创建两个订单
		Orders ord1 = new Orders();
		ord1.setOrdersName("订单1");

		Orders ord2 = new Orders();
		ord2.setOrdersName("订单2");

		// 创建两个商品
		Items i1 = new Items();
		i1.setItemsname("衣服");

		Items i2 = new Items();
		i2.setItemsname("裤子");

		// 订单一包括衣服和裤子
		HashSet<Items> set1 = new HashSet<>();
		set1.add(i1);
		set1.add(i2);
		ord1.setItemss(set1);// 商品绑定到订单

		// 订单二包括衣服
		HashSet<Items> set2 = new HashSet<>();
		set2.add(i1);
		ord2.setItemss(set2);// 商品绑定到订单

		// 订单绑定到用户
		ord1.setUser(user);
		ord2.setUser(user);

		// 创建身份证号
		Code code = new Code();
		code.setCode("123456");
		code.setUser(user);// 绑定到用户

		session.save(code);
		session.save(ord1);
		session.save(ord2);
		session.save(i1);
		session.save(i2);
		session.save(user);

		session.getTransaction().commit();
		session.close();
	}
}

测试结果：

第一次加载测试类时，会字段创建数据表和填充数据，数据表的结构和添加的信息如下：

身份证表（c_code）已经和用户表（c_user）关联:

商品表（c_items）数据：

商品表（c_items）信息和 订单表的关联信息已经在 c_orders_items 表中关联：

用户表（c_user）信息：

接下来是示例代码：

1、主配置文件 hibernate.cfg.xml