Hibernate——映射

一、集合映射

参考：https://mp.weixin.qq.com/s/w9YWxMtK_bajTauSf4nKvQ
需求分析：当用户购买商品，用户可能有多个地址。
集合元素类型：String类型。

1.1 数据库表

用户表：保存着用户的信息。
地址表：保存着地址的信息。地址表使用外键来引用用户表

1.2 实体

由于地址只是使用String类型来保存着，那么我们直接使用一个User对象就可以了。
User.java

public class User {
    private String id;
    private String username;
    private String password;
    private Set<String> address; // 集合。
    //各种setter和getter
}

1.3 映射文件——set集合

User.hbm.xml

<hibernate-mapping package="com.my.entity">
    <class name="User" table="user">
        
        <id name="id" column="id" >
            <generator class="native"/>
        id>
        
        <property name="username" column="username"/>
        <property name="password" column="password"/>
        
        <set name="address" table="address">
            <key column="user_id"/>
            <element column="addr" type="string"/>
        set>
    class>
hibernate-mapping>

1.4 测试

App.java

public class App {
	private Configuration configuration; //获取加载配置管理类
	private SessionFactory factory; //创建Session工厂对象
	private Session session; //得到Session对象
	private Transaction transaction; //得到Session对象
	// 获取session。
	public static Session getSession() {
		configuration = new Configuration();    
        configuration.configure(); //加载映射文件！
        //configuration.configure().addClass(Dept.class).addClass(Employee.class);
        factory = configuration.buildSessionFactory();
        return factory.openSession();
	}
	
    public static void testCollectionMapping() {
        session = getSession();
        //使用Hibernate操作数据库，都要开启事务,得到事务对象
        transaction = session.getTransaction();     
        transaction.begin();//开启事务
        //创建对象
        User user = new User();
        user.setUsername("123");
        user.setPassword("1234");
        user.getAddress().add("广州");     
        session.save(user);
        
        transaction.commit();//提交事务     
        session.close();//关闭Session
    }
}

1.5 List集合

List集合和Set集合有什么区别…List集合是有序的，因此要多配置一个列来维护数据的有序性！

<list name="address" table="address">
	<key column="user_id"/>
	 
	<list-index column="indexNum"/>
	<element column="addr" type="string"/>
list>

1.6 Map集合

Map集合和Collection集合的区别就是键值对模型，那么在配置的时候多一个key即可！

<map name="address" table="address">
	<key column="user_id"  />
	<map-key type="string" column="short"/>
	<element type="string" column="addr"/>
map>

二、一对多和多对一映射

需求：部门与员工之间的关系。
——一个部门有多个员工; 【一对多】
——多个员工，属于一个部门 【多对一】
集合元素类型：对象。

2.1 数据库表

员工表应该使用一个外键来记住部门表。这样才可以维护员工和部门之间的关系。

2.2 实体

部门实体要使用一个集合来记住所有的员工，员工要使用一个对象引用着部门。
Dept.java

public class Dept {
    private int id ;
    private Set<Employee> set = new HashSet<Employee>();
    private String deptName;
}

Employee.java

public class Employee {
    private int id;
    private String empName;
    private double salary;
    private Dept dept;
}

2.3 映射文件

Dept.hbm.xml

<hibernate-mapping package="com.my.entity">
    <class name="Dept" table="dept">
        <id column="id" name="id">
            <generator class="native"/>
        id>
        
        <property name="deptName" column="deptname"/>
        
        <set  cascade="save-update" name="set" table="employee">
            
            <key column="dept_no"/>
            
            <one-to-many class="Employee"/>
        set>
    class>
hibernate-mapping>

Employee.hbm.xml

<hibernate-mapping package="com.my.entity">
    <class name="Employee" table="employee">
        <id column="id" name="id">
            <generator class="native"/>
        id>
        
        <property name="empName" column="empName"/>
        <property name="salary" column="salary"/>
        
        <many-to-one name="dept" class="Dept" column="dept_no"/>
    class>
hibernate-mapping>

2.4 测试

App.java

// 在“一”的一方测试
public static void testOneMapping() {
	session = getSession();
	//使用Hibernate操作数据库，都要开启事务,得到事务对象
	transaction = session.getTransaction();     
	transaction.begin(); //开启事务
        
	//创建对象
	Dept dept = new Dept();
	dept.setDeptName("开发部");
	Employee zs = new Employee();
	zs.setEmpName("张珊");
	zs.setSalary(1111);
	Employee ls = new Employee();
	ls.setEmpName("李四");
	ls.setSalary(2222);
	//添加关系
	dept.getSet().add(zs);
	dept.getSet().add(ls);
	session.save(dept);
	session.save(zs);
	session.save(ls);    
        
	transaction.commit();//提交事务
	session.close();//关闭Session
}
// 在“多”的一方测试
public static void testManyMapping() {
	session = getSession();
	transaction = session.getTransaction();     
	transaction.begin(); //开启事务
        
	//创建对象
	Dept dept = new Dept();
	dept.setDeptName("开发部");
	Employee zs = new Employee();
	zs.setEmpName("张珊");
	zs.setSalary(1111);
	Employee ls = new Employee();
	ls.setEmpName("李四");
	ls.setSalary(2222);
	//维护关系
	zs.setDept(dept);
	ls.setDept(dept);
	//添加关系
	session.save(dept);
	session.save(zs);
	session.save(ls);  
        
	transaction.commit();//提交事务
	session.close();//关闭Session
}

2.5 总结

保存数据，最好的通过多的一方来维护关系，这样可以减少update语句的生成，从而提高hibernate的执行效率！

关联	含义
双向关联	配置一对多与多对一
单项一对多关联	只配置一对多
单项多对一	只配置多对一

配置了哪一方，哪一方才有维护关联关系的权限！

三、多对多映射

需求：一个项目由多个员工开发，一个员工开发多个项目
集合元素类型：对象。

3.1 数据库表

一般地，如果是多对多的映射，我们都会使用一张中间表来保存它们的关联关系。

3.2 实体

一般是核心数据表对应一个JavaBean实体【中间表并不是核心数据表】，那么我们将会设计两个JavaBean对象。
Project.java

public class Project {
    private int projectId;
    private String projectName;
    //使用Set集合与developer实体维护关系
    private Set<Developer> developers = new HashSet<>();
}

Developer.java

public class Developer {
    private int developerId;
    private String developerName;
    //使用Set集合来维护与Project关系
    private Set<Project> projects = new HashSet<>();
}

3.3 映射文件

Project.hbm.xml

<hibernate-mapping package="com.my.many2many">
    <class name="Project" table="Project">
        <id name="projectId" column="projectId">
            <generator class="native"/>
        id>
        
        <property name="projectName" column="projectName"/>
        
        
        <set name="developers" table="developer_project">
            
            <key column="project_id"/>
            
            <many-to-many column="developer_id" class="Developer"/>
        set>
    class>
hibernate-mapping>

Developer.hbm.xml

<hibernate-mapping package="com.my.many2many">
    <class name="Developer" table="Developer">
        
        <id name="developerId" column="developerId">
            <generator class="native"/>
        id>
        
        <property name="developerName" column="developerName"/>
        
        
        <set name="projects" table="developer_project">
            
            <key column="developer_id"/>
            
            <many-to-many column="project_id" class="Project"/>
        set>
    class>
hibernate-mapping>

3.4 测试

App.java

public static void testMany2ManyMapping() {
	session = getSession();
	//使用Hibernate操作数据库，都要开启事务,得到事务对象
	transaction = session.getTransaction();
	//开启事务
	transaction.begin();
	//创建对象
	Developer cj = new Developer();
	Developer wc = new Developer();
	Developer lz = new Developer();
	Project ds = new Project();
	Project oa = new Project();
	//设置对象的数据
	cj.setDeveloperName("曹吉");
	wc.setDeveloperName("王春");
	lz.setDeveloperName("老张");
	oa.setProjectName("OA系统");
	ds.setProjectName("电商系统");
	//使用Project来关联数据【在多对多中，一样的】
	oa.getDevelopers().add(wc);
	oa.getDevelopers().add(lz);
	ds.getDevelopers().add(cj);
	ds.getDevelopers().add(wc);       
	//在Project映射文件中设置级联保存了
	session.save(oa);
	session.save(ds);
        
	//提交事务
	transaction.commit();
	//关闭Session
	session.close();
}

四、一对一的映射

需求：用户与身份证信息…一个用户对应一个身份证
集合元素类型：对象。

4.1 数据库表

第一种：在身份证的数据表中设置一个外键来维护用户的关系。这个外键也应该是唯一的【一个用户对应一张身份证】。
第二种：在身份证的数据表中使用主键+外键的方式来维护用户的关系。

4.2 实体

IdCard.java

public class IdCard {
    private int idCardId;
    private String idCardName;
    //维护与用户之间的关系
    private User user ;
}

User.java

public class User {
    private int userId;
    private String userName;
    //维护与身份证一对一的关系
    private IdCard idCard ;
}

4.3 映射文件

4.3.1 外键方式

即在idCard表中，增加一个字段（user_id），此字段与user表主键字段关联。
该字段的作用：维护两表的关系。
User.hbm.xml

<hibernate-mapping package="com.my.one2one">
    <class name="User" table="User">
        
        <id name="userId" column="userId">
            <generator class="native"/>
        id>
        
        <property name="userName" column="userName"/>
        
        <one-to-one name="idCard" class="IdCard"/>
    class>
hibernate-mapping>

IdCard.hbm.xml

<hibernate-mapping package="com.my.one2one">
    <class name="IdCard" table="IdCard">
        <id name="idCardId" column="idCardId">
            <generator class="native"/>
        id>
        <property name="idCardName" column="idCardName"/>
        
        
        <many-to-one name="user" column="user_id" class="User" unique="true" cascade="save-update"/>
hibernate-mapping>

4.3.2 主键+外键方式

即在idCard表中，增加一个字段（user_id）作为主键字段且也是外键字段，此字段与user表主键字段关联。
需要在IdCard.java类中添加以下属性。

private int userId;

User.hbm.xml

<hibernate-mapping package="com.my.one2one">
    <class name="User" table="User">
        <id name="userId" column="userId">
            <generator class="native"/>
        id>
        <property name="userName" column="userName"/>
        <one-to-one name="idCard" class="IdCard"/>
    class>
hibernate-mapping>

IdCard.hbm.xml

<hibernate-mapping package="com.my.one2one">
    <class name="userId" table="IdCard">
    	
        <id name="idCardId" column="userId">
        	
            <generator class="foreign">
                <param name="property">userparam>
            generator>
        id>
        <property name="idCardName" column="idCardName"/>
        <property name="idCardId" column="idCartId"/>
        
        <one-to-one name="user" class="User" constrained="true"/>
hibernate-mapping>

4.4 测试

4.4.1 外键方式

使用IdCard来维护关联关系，直接保存其对象即可。
App.java

public static void testOne2OneMapping1() {
	session = factory.getSession();
	transaction = session.getTransaction();
	transaction.begin();
	//创建对象
	User user = new User();
	IdCard idCard = new IdCard();
	//设置对象的数据
	user.setUserName("你好");
	idCard.setIdCardName("身份证001");
	//一对一关联数据
	idCard.setUser(user);    
	//保存对象的数据,idCard配置文件使用级联保存
	session.save(idCard);
        
	transaction.commit();
	session.close();
}

4.4.2 主键+外键方式

使用IdCard来维护关联关系，直接保存其对象即可。
App.java

public static void testOne2OneMapping2() {
	session = getSession();
	transaction = session.getTransaction();
	transaction.begin();
        
	//创建对象
	User user = new User();
	IdCard idCard = new IdCard();
	//设置对象的数据
	user.setUserName("你好");
	idCard.setIdCardName("身份证001");
	idCard.setIdCardId(4235);
	//一对一关联数据
	idCard.setUser(user);    
	//保存对象的数据,idCard配置文件使用级联保存
	session.save(idCard);
        
	transaction.commit();
	session.close();
}

五、组件映射

组合关系：两个类不是继承关系，但两个类的亲密程度很高，在一个类里边需要用到另外一个类，那么就在类中定义一个变量来维护另一个类的关系。
组件映射：实际上就是将组合关系的数据映射成一张表，组件类和被包含的组件类映射成一张表。
Java类的主要关系：
——组合关系，组合关系对应的就是组件映射
——继承关系，继承关系对应的就是继承映射
需求：汽车和轮子。汽车需要用到轮子，但是轮子的爸爸不可能是汽车。
集合元素类型：对象。

5.1 数据库表

5.2 实体

Wheel.java

public class Wheel {
	private int  count;
	private int size;
}

Car.java

public class Car {
	private int id;
	private String name;
	private Wheel wheel; // 使用变量维护Wheel
}

5.3 映射文件

IdCard.hbm.xml

<hibernate-mapping package="com.my.component" >
	<class name="Car" table="Car" >
		
		<id name="id" column="id">
			<generator class="native"/>
		id>
		
		<property name="name" column="name"/>
		
		<component name="wheel">
			<property name="count"/>
			<property name="size"/>
		component>
	class>
hibernate-mapping>

5.4 测试

App.java

public static void testCompoentMapping() {
	session = getSession();
	transaction = session.getTransaction();
	transaction.begin();
        
	//创建对象
	Wheel wheel = new Wheel();
	Car car = new Car();
	//设置对象的数据
	wheel.setCount(43);
	wheel.setSize(22);
	car.setName("宝马");
	//维护关系
	car.setWheel(wheel);  
	//保存对象的数据,idCard配置文件使用级联保存
	session.save(car);
        
	transaction.commit();
	session.close();
}

六、传统方式继承映射

传统方式继承的特点就是：有多少个子类就写多少个配置文件。
需求：动物、猫、猴子。猫继承着动物。

6.1 数据库表

id和name从Animal中继承，catchMouse是子类的具体行为。

6.2 实体

Animal.java

public abstract class Animal {
	private int id;
	private String name;
}

Cat.java

public class Cat extends Animal{	
	private String catchMouse;// 抓老鼠
}

6.3 映射文件

简单继承的映射文件很好写，在属性上，直接写父类的属性就可以了。
缺点：如果子类有很多，就需要写很多的配置文件。
Cat.hbm.xml

<hibernate-mapping package="com.my.extends" >
	<class name="Cat" table="cat" >
		
		<id name="id" column="id">
			<generator class="native"/>
		id>
		
		<property name="name" column="name" />
		<property name="catchMouse" column="catchMouse" />
	class>
hibernate-mapping>

6.4 测试

App.java

public static void testExtentsMapping() {
	session = getSession();
	transaction = session.getTransaction();
	transaction.begin();
        
	//创建对象
	Cat cat = new Cat();
	//设置对象的数据
	cat.setName("大花猫");
	cat.setCatchMouse("捉大老鼠");
	session.save(cat);
        
	transaction.commit();
	session.close();
}

每个子类都需要写成一个配置文件，映射成一张表。

七、把所有子类映射成一张表

将所有的子类都映射成一张表中。

7.1 数据库表

7.2 实体

实体和上面雷同，只多了一个猴子的实体表。
Monkey.java

public class Monkey extends Animal {
	private String eatBanana;// 吃香蕉
}

7.3 映射文件

使用了subClass这个节点和鉴别器

<hibernate-mapping package="com.my.extends">
	<class name="Animal" table="t_animal">
		<id name="id">
			<generator class="native"/>
		id>
		
		<discriminator column="type_"/>
		<property name="name"/>
		
		<subclass name="Cat" discriminator-value="cat_">
			<property name="catchMouse"/>
		subclass>
		
		<subclass name="Monkey" discriminator-value="monkey_">
    		 <property name="eatBanana"/>
		subclass>
	class>
hibernate-mapping>

7.4 测试

App.java

public static void testExtentsMapping2() {
	session = getSession();
	transaction = session.getTransaction();
	transaction.begin();
        
	//创建对象
	Cat cat = new Cat();
	Monkey monkey = new Monkey();
	//设置对象的数据
	cat.setName("大花猫");
	cat.setCatchMouse("捉大老鼠");
	monkey.setEatBanana("吃香蕉");
	monkey.setName("大猴子");
	session.save(cat);
    session.save(monkey);
        
	transaction.commit();
	session.close();
}

八、每个类映射一张表(3张表)

父类和子类都各对应一张表。那么就有三张表了。
这种结构看起来是完全面向对象，但是表之间的结构会很复杂，插入一条子类的信息，需要两条SQL。

8.1 数据库表

8.2 实体

同上。

8.3 映射文件

使用到了< joined-subclass >这个节点。

<hibernate-mapping package="com.my.extends">
	<class name="Animal" table="t_animal">
		<id name="id">
			<generator class="native"/>
		id>
		<property name="name"/>
		
		<joined-subclass name="Cat" table="cat_">
			
			<key column="animal_id"/>
			<property name="catchMouse"/>
		joined-subclass>
		<joined-subclass name="Monkey" table="monkey_">
			
			<key column="animal_id"/>
			<property name="eatBanana"/>
		joined-subclass>
	class>
hibernate-mapping>

8.4 测试

每保存一个子类对象需要两条SQL语句！
App.java

public static void testExtentsMapping3() {
	session = getSession();
	transaction = session.getTransaction();
	transaction.begin();
        
	//创建对象
	Cat cat = new Cat();
	Monkey monkey = new Monkey();
	//设置对象的数据
	cat.setName("大花猫");
	cat.setCatchMouse("捉大老鼠");
	monkey.setEatBanana("吃香蕉");
	monkey.setName("大猴子");
	session.save(cat);
    session.save(monkey);
        
	transaction.commit();
	session.close();
}

九、每个子类映射一张表， 父类不对应表(2张表)

提出问题：
1、使用过了一张表保存所有子类的数据，这不符合数据库设计规范。
2、每个子类、父类都拥有一张表…表结构太过于繁琐…添加信息时，过多的SQL。
解决问题：每个子类映射成一张表，父类不对应表…这和我们传统方式继承是一样的。只不过在hbm.xml文件中使用了这个节点，由于有了这个节点，我们就不需要每个子类都写一个配置文件了。

9.1 数据库表

9.2 实体

同上。

9.3 映射文件

1、想要父类不映射成数据库表，只要在class中配置为abstract即可
2、使用了union-subclass节点，主键就不能采用自动增长策略了。我们改成UUID即可。当然啦，对应的实体id类型要改成String。

<hibernate-mapping package="com.my.extends">	
	
	<class name="Animal" abstract="true" >
		<id name="id">
			
			<generator class="uuid"/>
		id>
		<property name="name"/>
		
		<union-subclass name="Cat" table="cat_">
			<property name="catchMouse"/>
		union-subclass>
		<union-subclass name="Monkey" table="monkey_">
			<property name="eatBanana"/>
		union-subclass>
	class>
hibernate-mapping>

9.4 测试

App.java

public static void testExtentsMapping4() {
	session = getSession();
	transaction = session.getTransaction();
	transaction.begin();
        
	//创建对象
	Cat cat = new Cat();
	Monkey monkey = new Monkey();
	//设置对象的数据
	cat.setName("大花猫");
	cat.setCatchMouse("捉大老鼠");
	monkey.setEatBanana("吃香蕉");
	monkey.setName("大猴子");
	session.save(cat);
    session.save(monkey);
        
	transaction.commit();
	session.close();
}

9.5 组件映射和继承映射总结

传统继承映射每个子类都对应一个配置文件，这样十分麻烦。因此.hbm.xml就给出了几个节点供我们使用.

9.5.1 subclass标签

表数：子类父类共有一张表。
缺点：
1、不符合数据库设计规范。
2、需要使用鉴别器。

9.5.2 joined-subclass标签

表数：子类、父类都有自己的表。
缺点：
1、表的结构太过繁琐。
2、插入数据时要生成SQL至少就要两条。

9.5.3 union-subclass标签——推荐

表数：子类拥有自己的表、父类不对应表。
缺点：
1、父类不对应表要使用abstract来修饰。
2、主键的id不能使用自增长策略，修改成UUID就好了。对应的JavaBean的id设置成String就好。