26.Hibernate-主键和映射.md

时间：2023-12-17 15:38:50

目录

1.复合主键映射

数据库表可以用复合主键映射。但是复合主键映射使用时候需要注意：在配置文件中，需要使用一个对象来表示复合主键

  • 单一主键
    <class name="Employee" table="employee">

        <!-- 主键 注意和类成员和表列名称的一致对应 -->

        <id name="empId" column="EmpId" >

            <!-- 主键的生成策略：

                 1.identity  自增长(mysql,db2)

                 2.sequence  自增长(序列)， oracle中自增长是以序列方法实现

                 3.native  自增长【会根据底层数据库自增长的方式选择identity或sequence】

                            如果是mysql数据库, 采用的自增长方式是identity

                            如果是oracle数据库， 使用sequence序列的方式实现自增长

                 4.increment  自增长(会有并发访问的问题，一般在服务器集群环境使用会存在问题。)

                 5.assigned  指定主键生成策略为手动指定主键的值

                 6.uuid      指定uuid随机生成的唯一的值

                 7.foreign   (外键的方式， one-to-one讲)

             -->

            <generator class="native" />

        </id>

        <!-- 非主键，同样一一映射

             name:类的属性名称

             column：表的字段名称

             length:设定字段的长度，默认为255

             type：设定映射表的类型，如果不写匹配类对应属性的类型

                     java类型：必须带完整包名：java.lang.String

                     hibernate类型：全部都是小写

        -->

        <property name="empName" column="EmpName"></property>

        <property name="workDate" column="WorkDate"></property>

    </class>
  • 复合主键

a. 首先需要将数据库表对应的对象类中的复合主键，提取为一个对象。所以需要新建一个类，将这个类对象作为表对象的属性。

特别要注意的是这个复合主键类对象一定要实现序列化方法

package per.liyue.code.hibernatehello;

import java.io.Serializable;

public class CompositeKeys implements Serializable {

    private String name = null;

    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;

    }

    private int id = 0;

}

b. 将序列化的对象添加到表对应的类对象中

public class Employee {

    private CompositeKeys  keys;

    private String empName;

    private Date workDate;

        ......

}

c. 在配置文件中将符合主键配置

    <class name="Employee" table="employee">

        <composite-id name="keys">

            <key-property name="name" type="String"></key-property>

            <key-property name="id" type="int"></key-property>

        </composite-id>

        <!-- 非主键，同样一一映射

             name:类的属性名称

             column：表的字段名称

             length:设定字段的长度，默认为255

             type：设定映射表的类型，如果不写匹配类对应属性的类型

                     java类型：必须带完整包名：java.lang.String

                     hibernate类型：全部都是小写

        -->

        <property name="empName" column="EmpName"></property>

        <property name="workDate" column="WorkDate"></property>

    </class>

目录

2.集合映射

2.1Set集合

假若有如下的数据库表：

  • 那么对应的类对象应该是
package per.liyue.code.hibernatecollection;

import java.util.Set;

/*

 * 带有集合的类

 */

public class User {

    private int userId;

    private String userName;

    public int getUserId() {

        return userId;

    }

    public void setUserId(int userId) {

        this.userId = userId;

    }

    public String getUserName() {

        return userName;

    }

    public void setUserName(String userName) {

        this.userName = userName;

    }

    public Set<String> getUserEmail() {

        return userEmail;

    }

    public void setUserEmail(Set<String> userEmail) {

        this.userEmail = userEmail;

    }

    //一个Set集合，对应数据库中的表，这个表的外键是User表的主键

    private Set<String> userEmail;

}
  • 配置映射文件:

    要注意的是Set集合的配置，对应的数据类型必须填写 
<?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">

<!-- Generated Nov 9, 2006 6:27:53 PM by Hibernate Tools 3.2.0.beta7 -->

<!-- package：类对象所在的包

     auto-import：表面是自动导入包，如果设定为false,则需要在执行hql语句时候将包名写清楚：

     Demo：在true时候可以写为session.createQuery("from Employee").list();

               在false时候必须写为session.createQuery("from per.liyue.code.hibernatehello.Employee").list();

 -->

<hibernate-mapping package="per.liyue.code.hibernatecollection" auto-import="true">

    <!-- 类与表的对应

         name:类名称

         table：表名称

     -->

    <class name="User" table="user">

        <!-- 主键 注意和类成员和表列名称的一致对应 -->

        <id name="userId" column="UserId" >

            <generator class="native" />

        </id>

        <property name="userName" column="UserName"></property>

        <!-- Set集合配置：

             set-name：要映射的Set集合类

             set-table：要映射的Set表

                 key-column：指定集合表的外键，也就是User表的主键

                     element-type：集合表其他字段的类型，必须填写！！！

                     element-column：集合表其他自动的表列名称

         -->

        <set name="userEmail" table="UserEmail">

            <key column="UserId"></key>

            <element type="string" column="EmailAddress"></element>

        </set>

    </class>

</hibernate-mapping>
  • 配置Hibernate配置文件：
<!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 name="foo">

        <!-- 数据库连接配置 -->

        <!-- 连接类 -->

        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

        <!-- 连接数据库 -->

        <property name="hibernate.connection.url">jdbc:mysql:///hi</property>

        <!-- 连接用户名 -->

        <property name="hibernate.connection.username">root</property>

        <!-- 连接密码 -->

        <property name="hibernate.connection.password">root</property>

        <!-- 数据库方言 -->

        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <!-- 其他配置 -->

        <property name="hibernate.show_sql"></property>

        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- 加载所有的映射 -->

        <mapping resource="per/liyue/code/hibernatehello/Employee.hbm.xml"/>

        <mapping resource="per/liyue/code/hibernatecollection/User.hbm.xml"/>

    </session-factory>

</hibernate-configuration>
  • 最后保存数据
package per.liyue.code.hibernatecollection;

import java.util.HashSet;

import java.util.Set;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

import org.junit.Test;

public class App {

    private static SessionFactory sf;

    static{

        sf = new Configuration().configure().buildSessionFactory();

    }

    @Test

    public void setOperation(){

        Session s = sf.openSession();

        s.beginTransaction();

        /*

         * Set：保存带Set的集合

         */

        User user = new User();

        user.setUserId(2);

        user.setUserName("李四");

        Set<String> email = new HashSet<>();

        email.add("a@a.com");

        email.add("b@b.com");

        user.setUserEmail(email);

        s.save(user);

        s.getTransaction().commit();

        s.close();

        sf.close();

    }

}

2.2其他集合

其他集合大体上类似Set集合，但是具体有不同

  • list

    list在配置文件中需要指定一个索引，因为list是有序的！！！

  • map

    map中key和value都需要指定类型

Demo：

将上文中的例子修改

package per.liyue.code.hibernatecollection;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

/*

 * 带有集合的类

 */

public class User {

    private int userId;

    private String userName;

    public int getUserId() {

        return userId;

    }

    public void setUserId(int userId) {

        this.userId = userId;

    }

    public String getUserName() {

        return userName;

    }

    public void setUserName(String userName) {

        this.userName = userName;

    }

    public Set<String> getUserEmail() {

        return userEmail;

    }

    public void setUserEmail(Set<String> userEmail) {

        this.userEmail = userEmail;

    }

    //一个Set集合，对应数据库中的表，这个表的外键是User表的主键

    private Set<String> userEmail;

    //一个List集合

    private List<String> userPhoneNumber = new ArrayList<>();

    public List<String> getUserPhoneNumber() {

        return userPhoneNumber;

    }

    public void setUserPhoneNumber(List<String> userPhoneNumber) {

        this.userPhoneNumber = userPhoneNumber;

    }

    //一个Map集合

    private Map<String, String> userAddress = new HashMap<>();

    public Map<String, String> getUserAddress() {

        return userAddress;

    }

    public void setUserAddress(Map<String, String> userAddress) {

        this.userAddress = userAddress;

    }

}
<?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">

<!-- Generated Nov 9, 2006 6:27:53 PM by Hibernate Tools 3.2.0.beta7 -->

<!-- package：类对象所在的包

     auto-import：表面是自动导入包，如果设定为false,则需要在执行hql语句时候将包名写清楚：

     Demo：在true时候可以写为session.createQuery("from Employee").list();

               在false时候必须写为session.createQuery("from per.liyue.code.hibernatehello.Employee").list();

 -->

<hibernate-mapping package="per.liyue.code.hibernatecollection" auto-import="true">

    <!-- 类与表的对应

         name:类名称

         table：表名称

     -->

    <class name="User" table="user">

        <!-- 主键 注意和类成员和表列名称的一致对应 -->

        <id name="userId" column="user_id" >

            <generator class="native" />

        </id>

        <property name="userName" column="user_name"></property>

        <!-- Set集合配置：

             set-name：要映射的Set集合类

             set-table：要映射的Set表

                 key-column：指定集合表的外键，也就是User表的主键

                     element-type：集合表其他字段的类型

                     element-column：集合表其他自动的表列名称

         -->

        <set name="userEmail" table="UserEmail">

            <key column="user_id"></key>

            <element type="string" column="email_address"></element>

        </set>

        <!-- List集合配置

             list-index:需要为list指定排序，因为list是有序的

         -->

        <list name="userPhoneNumber" table="UserPhoneNumber">

            <key column="user_id"></key>

            <list-index column="list_index"></list-index>

            <element type="string" column="phone_number"></element>

        </list>

        <!-- Map集合配置

         -->

         <map name="userAddress">

             <key column="user_id"></key>

             <map-key type="string" column="area"></map-key>

             <element type="string" column="address"></element>

         </map>

    </class>

</hibernate-mapping>

最后再修改实现类

package per.liyue.code.hibernatecollection;

import java.util.HashSet;

import java.util.Set;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

import org.junit.Test;

public class App {

    private static SessionFactory sf;

    static{

        sf = new Configuration().configure().buildSessionFactory();

    }

    @Test

    public void setOperation(){

        Session s = sf.openSession();

        s.beginTransaction();

        /*

         * Set：保存带Set的集合

         */

        User user = new User();

        user.setUserId(2);

        user.setUserName("孙五");

        Set<String> email = new HashSet<>();

        email.add("c@a.com");

        email.add("d@b.com");

        user.setUserEmail(email);

        /*

         * List:保存List

         */

        user.getUserPhoneNumber().add("189898989");

        user.getUserPhoneNumber().add("108080808");

        /*

         * Map:保存Map

         */

        user.getUserAddress().put("上海", "浦东");

        user.getUserAddress().put("杭州", "西湖");

        s.save(user);

        s.getTransaction().commit();

        s.close();

        sf.close();    

    }

}

目录

3.集合数据的读取

集合数据的读取采用懒加载方式：当映射正确的时候，使用到相关集合数据，hibernate才会想数据库发送执行语句

Demo:

将上述例子中的App类中增加读取函数

@Test

    public void GetCollection(){

        Session s = sf.openSession();

        s.beginTransaction();

        User user = (User) s.get(User.class, 4);

        System.out.println("查询到用户的信息：");

        System.out.println("用户ID：" + user.getUserId());

        System.out.println("用户名字：" + user.getUserName());

        /*

         * 懒加载：当有正确的映射时候，只有当使用集合相关数据时候，hibernate才会想数据库发送相关语句

         */

        System.out.println("用户邮箱：" + user.getUserEmail());

        System.out.println("用户电话: " + user.getUserPhoneNumber());

        System.out.println("用户地址: " + user.getUserAddress());

        s.getTransaction().commit();

        s.close();

        sf.close();

    }

可以得到结果：

查询到用户的信息：

用户ID：4

用户名字：孙五

用户邮箱：[d@b.com, c@a.com]

用户电话: [189898989, 108080808]

用户地址: {上海=浦东, 杭州=西湖}

目录

4.一对多和多对一映射

4.1概念

实际开发中，有很多情况例如上面的主数据类中保存了子数据类的对象，当时常常这个集合对象内容不是单一的基本数据类型，需要用对象方式来保存更多的数据。这个时候就存在了一对多和多对一的映射关系

4.2配置和开发

4.2.1关键点

配置的关键在于对主数据类和子数据类都可以配置对应的配置文件：

  • 单向关联：配置一对多
  • 单向关联：配置多对一
  • 双向关联：配置上面两种单向关联均配置

    注意：配置了哪一种情况，就可以根据哪一种情况来操作数据。也就是说配置了一对多则可以通过一来维护多（保存时候保存一关联保存多），配置了多对一则可以通过多来维护一（保存时候保存多关联保存一）。因此在使用时候，为了提高效率，建议先保存一的一方再去保存多，因为反过来的话执行一次insert后还要多执行一次update，会降低执行效率！

4.2.2实例

  • 有数据关系：

  • 编写主数据类和子数据类：

package per.liyue.code.hibernate_multimapping;

import java.util.HashSet;

import java.util.Set;

/*

 * 主数据类对象，包含了一个集合类型的属性，内容是另一个类的对象

 */

public class Department {

    private int depId;

    private String depName;

    private Set<Employee> employee = new HashSet<Employee>();

    public int getDepId() {

        return depId;

    }

    public void setDepId(int depId) {

        this.depId = depId;

    }

    public String getDepName() {

        return depName;

    }

    public void setDepName(String depName) {

        this.depName = depName;

    }

    public Set<Employee> getEmployee() {

        return employee;

    }

    public void setEmployee(Set<Employee> employee) {

        this.employee = employee;

    }

}
package per.liyue.code.hibernate_multimapping;

/*

 * 子数据类，这个类的对象是主数据类的集合元素

 */

public class Employee {

    private int empId;

    public int getEmpId() {

        return empId;

    }

    public void setEmpId(int empId) {

        this.empId = empId;

    }

    private String empName;

    public String getEmpName() {

        return this.empName;

    }

    public void setEmpName(String empName) {

        this.empName = empName;

    }

    //多对一：

    private Department dept;

    public Department getDept() {

        return dept;

    }

    public void setDept(Department dept) {

        this.dept = dept;

    }

}
  • 配置两个类的配置文件
    • 一对多的配置
<!-- 主数据类的配置文件 -->

<set name="主数据类中的子数据类的类对象" table="子数据类的表名称">

      <key column="主数据类的主键（也就是子数据类的外键）"></key>

      <one-to-many class="子数据类的类名称，注意同一个包下可以不带包名称，注意不要在不同包下重复用一个类名称"/>

</set>  


* 多对一的配置
<!-- 子数据类的配置文件 -->

<many-to-one name="子数据类中的主数据类对象" column="子数据类的外键（主数据类的主键）" class="主数据类名称"></many-to-one>
  • Demo：
<?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">

<!-- Generated Nov 9, 2006 6:27:53 PM by Hibernate Tools 3.2.0.beta7 -->

<!-- package：类对象所在的包

     auto-import：表面是自动导入包，如果设定为false,则需要在执行hql语句时候将包名写清楚：

     Demo：在true时候可以写为session.createQuery("from Employee").list();

               在false时候必须写为session.createQuery("from per.liyue.code.hibernatehello.Employee").list();

 -->

<hibernate-mapping package="per.liyue.code.hibernate_multimapping" auto-import="true">

    <class name="Department" table="Department">

        <!-- 主键 -->

        <id name="depId" column="dep_id" >

            <generator class="native" />

        </id>

        <property name="depName" column="dep_name"></property>

        <!-- 设置一对多关系：

            name:集合中的类对象对应的类

            table:集合中类对象对应的表

            key:子数据类中对应外键

            one-to-many:子数据类对应的类，如果是同一个包下的类可以不写包名

         -->

        <set name="employee" table="Employee">

            <key column="dep_id"></key>

            <one-to-many class="Employee"/>

        </set>

    </class>

</hibernate-mapping>  


<?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">

<!-- Generated Nov 9, 2006 6:27:53 PM by Hibernate Tools 3.2.0.beta7 -->

<!-- package：类对象所在的包

     auto-import：表面是自动导入包，如果设定为false,则需要在执行hql语句时候将包名写清楚：

     Demo：在true时候可以写为session.createQuery("from Employee").list();

               在false时候必须写为session.createQuery("from per.liyue.code.hibernatehello.Employee").list();

 -->

<hibernate-mapping package="per.liyue.code.hibernate_multimapping" auto-import="true">

    <class name="Employee" table="Employee">

        <!-- 主键 -->

        <id name="empId" column="emp_id" >

            <generator class="native" />

        </id>

        <property name="empName" column="emp_name"></property>

        <!-- 设置多对一关系：

            name：映射的主类对象

            column：外键的字段名称

            class:映射主类

         -->

        <many-to-one name="dept" column="dep_id" class="Department"></many-to-one>

    </class>

</hibernate-mapping>
  • 执行语句
package per.liyue.code.hibernate_multimapping;

import java.util.HashSet;

import java.util.Set;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

import org.junit.Test;

public class App_Save {

	private static SessionFactory sf;

	static{

		sf = new Configuration().configure().buildSessionFactory();

	}

	@Test

	/*

	* 一维护多，无论保存时候先保存部门还是后保存部门，必须要多执行相应的update语句保证id一致。

	*/

	public void DemoOne2Many(){

		Session s = sf.openSession();

		s.beginTransaction();

		Department dept = new Department();

		dept.setDepName("硬件开发部");

		Employee zhangSan = new Employee();

		zhangSan.setEmpName("王五");

		Employee liSi = new Employee();

		liSi.setEmpName("赵二");

		/*

		*这里的映射关系是一对多，也就是通过部门来维护员工

		*/

		dept.getEmployee().add(zhangSan);

		dept.getEmployee().add(liSi);		

		s.save(zhangSan);

		s.save(liSi);

		s.save(dept);

		s.getTransaction().commit();

		s.close();

		sf.close();	

	}

	@Test

	/*

	* 推荐方式：通过多来维护一，这样高效！

	*/

	public void DemoMany2One(){

		Session s = sf.openSession();

		s.beginTransaction();

		Department dept = new Department();

		dept.setDepName("软件开发部");

		Employee zhangSan = new Employee();

		zhangSan.setEmpName("张三");

		Employee liSi = new Employee();

		liSi.setEmpName("李四");

		/*

		*这里的映射关系是多对一，也就是通过员工来维护部门

		*/

		zhangSan.setDept(dept);

		liSi.setDept(dept);

		//这个时候如果部门保存在后面，则保存员工时候没有部门编号，会增加两条update语句

		s.save(dept);

		s.save(zhangSan);

		s.save(liSi);

		s.getTransaction().commit();

		s.close();

		sf.close();	

	}

}

执行的语句结果

一对多的情况：

Hibernate: insert into Employee (emp_name, dep_id) values (?, ?)

Hibernate: insert into Employee (emp_name, dep_id) values (?, ?)

Hibernate: insert into Department (dep_name) values (?)

Hibernate: update Employee set dep_id=? where emp_id=?

Hibernate: update Employee set dep_id=? where emp_id=?

多对一的情况：

Hibernate: insert into Department (dep_name) values (?)

Hibernate: insert into Employee (emp_name, dep_id) values (?, ?)

Hibernate: insert into Employee (emp_name, dep_id) values (?, ?)

在hibernate中唯一的方式把对象映射为外键的方式：many-to-one

建议通过多对一来维护，这样操作高效！

  • 读取数据
    • 懒加载：在执行的时候hibernate才发送并执行相关SQL语句
package per.liyue.code.hibernate_multimapping;

import java.util.HashSet;

import java.util.Set;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

import org.junit.Test;

public class App_Get {

	private static SessionFactory sf;

	static{

		sf = new Configuration().configure().buildSessionFactory();

	}

	@Test

	/*

	* 一对多和多对一的读取

	*/

	public void DemoOne2Many(){

		Session s = sf.openSession();

		s.beginTransaction();

		Department dep = (Department)s.get(Department.class, 1);

		System.out.println("从部门读取：" + dep.getDepId());

		/*

		* 懒加载：不执行下面的调用，hibernate不会向数据库发送相关语句并执行

		*/

		System.out.println("从部门读取：" + dep.getEmployee());

		Employee emp = (Employee)s.get(Employee.class, 2);

		System.out.println("从员工读取：" + emp.getEmpName());

		System.out.println("从员工读取：" + emp.getDept());

		s.getTransaction().commit();

		s.close();

		sf.close();	

	}

}

目录

5.反转：inverse

5.1概念

  • 表示反转控制，取消控制
  • 在一对多和多对一的关系中，一的一方可以设置inverse属性。

5.2实例

5.2.1配置

在上面的Department.hbm.xml中，在一对多的映射中可以设定：

<set name="employee" table="Employee" inverse="false">

            <key column="dep_id"></key>

            <one-to-many class="Employee"/>

        </set>

这里的false是默认值，表示主数据类有控制权限，如果设置为true则表示没有控制权限

5.2.2影响

  • 保存：有影响，解除关联后，子数据类依旧会保存，但是外键关联取消，保存为NULL
  • 读取：无影响
  • 解除关联关系：有影响，解除关联关系的用法是先读取，然后主类调用clear（）方法。如果解除，则则不能解除关系，但是不报错
  • 删除：有影响，解除后如果外键有值，删除会违反主外键约束而报错，如果外键没有值为NULL，则可以删除

目录

6.级联：cascade

6.1概念

级联操作的设置，在一对多和多对一均可配置。如在配置文件中：

<set name="employee" table="Employee" inverse="false" cascade="none">

            <key column="dep_id"></key>

            <one-to-many class="Employee"/>

</set>

6.2配置

只在一对多一方配置

级联操作有以下几种配置：

  • none：默认值，不级联操作
  • save-update：设置级联保存和更新。注意：save和update不能拆分使用
  • save-update,delete：设置级联保存、更新和删除
  • all： 全部

6.3inserse和cascade区别

不能在一起使用

目录

7.多对多映射

7.1关系

在实际应用中有多对多的映射关系：

不同的人有不同的角色，不同的角色对应多个人。在数据库中二者的关联关系通常放到另一个表中。形成了多对多映射

7.2配置和实现

7.2.1定义两个数据类

package per.liyue.code.hibernate_mu2mu;

import java.util.HashSet;

import java.util.Set;

/*

 * 数据类角色

 */

public class Role {

	private int roleId;

	private String roleName;

	//包含另一个数据类对象

	private Set<Person> person = new HashSet<>();

	public int getRoleId() {

		return roleId;

	}

	public void setRoleId(int roleId) {

		this.roleId = roleId;

	}

	public String getRoleName() {

		return roleName;

	}

	public void setRoleName(String roleName) {

		this.roleName = roleName;

	}

	public Set<Person> getPerson() {

		return person;

	}

	public void setPerson(Set<Person> person) {

		this.person = person;

	}

}

7.2.2配置二者的映射关系

<?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">

<!-- Generated Nov 9, 2006 6:27:53 PM by Hibernate Tools 3.2.0.beta7 -->

<!-- package：类对象所在的包

     auto-import：表面是自动导入包，如果设定为false,则需要在执行hql语句时候将包名写清楚：

     Demo：在true时候可以写为session.createQuery("from Employee").list();

               在false时候必须写为session.createQuery("from per.liyue.code.hibernatehello.Employee").list();

 -->

<hibernate-mapping package="per.liyue.code.hibernate_mu2mu" auto-import="true">

    <class name="Role" table="Role">

        <!-- 主键 -->

        <id name="roleId" column="r_id" >

            <generator class="native" />

        </id>

        <property name="roleName" column="r_name"></property>

        <!-- 设置多对多关系：

            name:

         -->

        <set name="person" table="Reletionship" inverse="false" cascade="none">

            <key column="r_id"></key>

            <many-to-many column="per_id" class="Person"></many-to-many>

        </set>

    </class>

</hibernate-mapping>  


<?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">

<!-- Generated Nov 9, 2006 6:27:53 PM by Hibernate Tools 3.2.0.beta7 -->

<!-- package：类对象所在的包

     auto-import：表面是自动导入包，如果设定为false,则需要在执行hql语句时候将包名写清楚：

     Demo：在true时候可以写为session.createQuery("from Employee").list();

               在false时候必须写为session.createQuery("from per.liyue.code.hibernatehello.Employee").list();

 -->

<hibernate-mapping package="per.liyue.code.hibernate_mu2mu" auto-import="true">

    <class name="Person" table="Person">

        <!-- 主键 -->

        <id name="personId" column="per_id" >

            <generator class="native" />

        </id>

        <property name="personName" column="per_name"></property>

        <!-- 设置多对多关系：

            name:另一个类对象的实例名称

            talbe:二者关系的数据库映射表

            key-column:当前类的主键，关系表的外键

            many-to-mangy-column:另一个类的主键，关系表中的另一个外键

            many-to-mangy-class:另一个类的类名称

         -->

        <set name="role" table="Reletionship" inverse="false" cascade="none" >

            <key column="per_id"></key>

            <many-to-many column="r_id" class="Role"></many-to-many>

        </set>

    </class>

</hibernate-mapping>

7.2.3实现业务

package per.liyue.code.hibernate_mu2mu;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

import org.junit.Test;

import per.liyue.code.hibernate_multimapping.Department;

import per.liyue.code.hibernate_multimapping.Employee;

public class App {

	private static SessionFactory sf;

	static{

		sf = new Configuration().configure().buildSessionFactory();

	}

	@Test

	/*

	*

	*/

	public void DemoMany2Many(){

		Session s = sf.openSession();

		s.beginTransaction();

		//创建

		Person p_zhangsan = new Person();

		p_zhangsan.setPersonName("张三");

		Person p_lisi = new Person();

		p_lisi.setPersonName("李四");

		Role r_teacher = new Role();

		r_teacher.setRoleName("教师");

		Role r_student = new Role();

		r_student.setRoleName("学生");

		Role r_developer = new Role();

		r_developer.setRoleName("开发");

		//关系

		p_zhangsan.getRole().add(r_teacher);

		p_zhangsan.getRole().add(r_developer);

		p_lisi.getRole().add(r_student);

		//保存

		s.save(p_zhangsan);

		s.save(p_lisi);

		s.save(r_teacher);

		s.save(r_student);

		s.save(r_developer);

		s.getTransaction().commit();

		s.close();

		sf.close();	

	}

}

8.映射关系配置总结

  • 一对多:


<set name="映射的集合属性" table="(可选)集合属性对应的外键表">

    <key column="外键表的，外键字段" />

    <one-to-many class="集合元素的类型" />

</set>
  • 多对一：


<many-to-one name="对象属性" class="对象类型" column="外键字段字段" />
  • 多对多


<set name="" table="">

    <key column="" />

    <many-to-many column="" class="">

</set>

目录

8.一对一映射

8.1分类

可以有两种一对一映射：

  • 基于外键，外键唯一
  • 基于主键

    假设有用户和身份证的一一映射，可以有下面的两种数据库表关系

那么两种模型下的实例为：

8.2有主键的映射

8.2.1类对象

8.2.2配置文件

8.2.3主配置和实现

8.3无主键的映射

8.3.1类对象

8.3.2配置文件

8.3.3主配置和实现

目录

9.组件映射

9.1适用范围

  • 组件映射指的是一个类中包含了另一个类的对象。是包含与被包含的概念
  • 映射会将两个类映射到一个表中

9.2实例

9.2.1类

package per.liyue.code.component_demo;/** * Created by liyue on 2016/10/21. */public class User{    private int id;    private String name;    private Wheel wheel;}```

```java

package per.liyue.code.component_demo;/** * Created by liyue on 2016/10/21. */public class Wheel{    private int count;    public int getCount()    {        return count;    }    public void setCount(int count)    {        this.count = count;    }    public int getSize()    {        return size;    }    public void setSize(int size)    {        this.size = size;    }    private int size;}```

## 9.2.2配置文件

```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"><!-- Generated Nov 9, 2006 6:27:53 PM by Hibernate Tools 3.2.0.beta7 --><!-- package：类对象所在的包     auto-import：表面是自动导入包，如果设定为false,则需要在执行hql语句时候将包名写清楚：     Demo：在true时候可以写为session.createQuery("from Employee").list();               在false时候必须写为session.createQuery("from per.liyue.code.hibernatehello.Employee").list(); --><hibernate-mapping package="per.liyue.code.component_demo.User" auto-import="true">    <class name="User" table="t_User">        <!-- 主键 -->        <id name="id" column="user_id" >            <generator class="native" />        </id>        <property name="name" column="user_name"></property>        <!--        组件关系        -->        <component name="wheel">            <!--组件成员-->            <property name="count"></property>            <property name="size"></property>        </component>    </class></hibernate-mapping>```

---

[toc]

---

# 10.继承映射

## 10.1概念

### 10.1.1简单继承

有多少个子类写多少个配置文件

// 动物类

public abstract class Animal {

private int id;

private String name;

<class name="Cat" table="t_Cat">

	<!-- 简单继承映射： 父类属性直接写 -->

	<id name="id">

		<generator class="native"></generator>

	</id>

	<property name="na"></property>

	<property name="catchMouse"></property>

</class>

@Test

public void getSave() {

	Session session = sf.openSession();

	session.beginTransaction();

	// 保存

// Cat cat = new Cat();

// cat.setName("大花猫");

// cat.setCatchMouse("抓小老鼠");

// session.save(cat);

	// 获取时候注意：当写hql查询的使用，通过父类查询必须写上类的全名

	Query q = session.createQuery("from cn.itcast.e_extends1.Animal");

	List<Animal> list = q.list();

	System.out.println(list);

	session.getTransaction().commit();

	session.close();

}


### 10.1.2复杂继承

* 多个子类共用一个表

不推荐使用，因为违反数据库设计原则。在子类数量众多且属性单一情况下适用。

* 每个子类用一个表

* 父类不对应表

## 10.2实例

相关文章