欢迎来到小房子杂记 返回顶部

JavaEE之Hibernate框架

Hibernate 学习笔记

一、hibernate 简介

二、hibernate 架构

三、hibernate ORM

四、hibernate 配置

五、hibernate 注释

六、hibernate 对象

七、hibernate 基本的增删改查

八、hibernate HQL语句

九、hibernate Criteria

十、hibernate 原生sql

十一、hibernate 表关系的处理

 

一、hibernate 简介

  1. Hibernate 是由 Gavin King 于 2001 年创建的开放源代码的对象关系框架。它强大且高效的构建具有关系对象持久性和查询服务的 Java 应用程序。

  2. Hibernate 将 Java 类映射到数据库表中，从 Java 数据类型中映射到 SQL 数据类型中，并把开发人员从 95% 的公共数据持续性编程工作中解放出来。

  3. 支持的数据库：Hibernate 支持几乎所有的主要 RDBMS。

 

二、hibernate 架构

  1. Hibernate 是传统 Java 对象和数据库服务器之间的桥梁，用来处理基于 O/R 映射机制和模式的那些对象。

  2. Hibernate 架构是分层的，作为数据访问层，你不必知道底层 API 。Hibernate 利用数据库以及配置数据来为应用程序提供持续性服务（以及持续性对象）。

     

  3. Hibernate 在三层架构中的地位

 

三、hibernate ORM

ORM 表示 Object-Relational Mapping (ORM)，是一个方便在关系数据库和类似于 Java， C# 等面向对象的编程语言中转换数据的技术。ORM 系统相比于普通的 JDBC 有以下的优点：

  1. 使用业务代码访问对象而不是数据库中的表

  2. 从面向对象逻辑中隐藏 SQL 查询的细节

  3. 基于 JDBC 的 'under the hood'

  4. 没有必要去处理数据库实现

  5. 实体是基于业务的概念而不是数据库的结构

  6. 事务管理和键的自动生成

  7. 应用程序的快速开发

 

四、hibernate 配置（以MySQL为例）

  1. 环境搭建（可以到 http://www.hibernate.org/downloads 下载hibernate相关jar包），除了hibernate需要的jar包外，还要导入数据库驱动。

     

  2. Hibernate框架核心配置文件（hibernate.cfg.xml）

    <!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>
            <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernatedemo?characterEncoding=utf8</property>
            <property name="hibernate.connection.username">root</property>
            <property name="hibernate.connection.password">123456</property>
    ​
            <!--可选项-->
            <!--是否输出hibernate相关信息到控制台-->
            <property name="hibernate.show_sql">true</property>
            <property name="hibernate.format_sql">true</property>
    ​
            <!--配置方言-->
            <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
            
            <!--配置建表策略-->
            <property name="hibernate.hbm2ddl.auto">update</property>
    ​
            <!--关联一下 ORM 文件-->
            <mapping resource="cn/edu/dgut/bean/User.hbm.xml"></mapping>
        </session-factory>
    </hibernate-configuration>

 

  1. Hibernate 持久化类

    public class User {
        private int id;
        private String username;
        private String password;
        private String address;
    ​
        public int getId() {
            return id;
        }
    ​
        public void setId(int id) {
            this.id = id;
        }
    ​
        public String getUsername() {
            return username;
        }
    ​
        public void setUsername(String username) {
            this.username = username;
        }
    ​
        public String getPassword() {
            return password;
        }
    ​
        public void setPassword(String password) {
            this.password = password;
        }
    ​
        public String getAddress() {
            return address;
        }
    ​
        public void setAddress(String address) {
            this.address = address;
        }
    ​
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }

     

  2. Hibernate 映射文件（User.hbm.xml）

    <!DOCTYPE hibernate-mapping PUBLIC
            "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
            "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    <hibernate-mapping>
        <!--ORM 映射  实体类和 数据表映射-->
        <class name="cn.edu.dgut.bean.User" table="tb_user">
            <id name="id" column="id">
                <!--设置主键策略-->
                <generator class="native"></generator>
            </id>
            <property name="username" column="username"></property>
            <property name="password" column="password"></property>
            <property name="address" column="address"></property>
        </class>
    ​
    </hibernate-mapping>

 

五、hibernate 注释

Hibernate 注释是无需使用 XML 文件来定义映射的最新方法。你可以额外使用注释或直接代替 XML 映射元数据。

Hibernate 注释是一种强大的来给对象和关系映射表提供元数据的方法。所有的元数据被添加到 POJO java 文件代码中，这有利于用户在开发时更好的理解表的结构和 POJO。

  1. 添加注释相关jar包

    hibernate-annotations.jar, hibernate-comons-annotations.jar和 ejb3-persistence.jar

     

  2. 用带有注释的 Employee 类来映射使用定义好的 Employee 表的对象

    import javax.persistence.*;
    ​
    @Entity
    @Table(name = "EMPLOYEE")
    public class Employee {
       @Id @GeneratedValue
       @Column(name = "id")
       private int id;
    ​
       @Column(name = "first_name")
       private String firstName;
    ​
       @Column(name = "last_name")
       private String lastName;
    ​
       @Column(name = "salary")
       private int salary;  
    ​
       public Employee() {}
       public int getId() {
          return id;
       }
       public void setId( int id ) {
          this.id = id;
       }
       public String getFirstName() {
          return firstName;
       }
       public void setFirstName( String first_name ) {
          this.firstName = first_name;
       }
       public String getLastName() {
          return lastName;
       }
       public void setLastName( String last_name ) {
          this.lastName = last_name;
       }
       public int getSalary() {
          return salary;
       }
       public void setSalary( int salary ) {
          this.salary = salary;
       }
    }

    Hibernate 检测到 @Id 注释字段并且认定它应该在运行时通过字段直接访问一个对象上的属性。如果你将 @Id 注释放在 getId() 方法中，你可以通过默认的 getter 和 setter 方法来访问属性。因此，所有其它注释也放在字段或是 getter 方法中，决定于选择的策略。下一节将解释上面的类中使用的注释。

     

  3. 注释

    @Entity 注释

    • EJB 3 标准的注释包含在 javax.persistence 包，所以我们第一步需要导入这个包。第二步我们对 Employee 类使用 @Entity 注释，标志着这个类为一个实体 bean，所以它必须含有一个没有参数的构造函数并且在可保护范围是可见的。

    @Table 注释

    • @table 注释允许您明确表的详细信息保证实体在数据库中持续存在。

    • @table 注释提供了四个属性，允许您覆盖的表的名称，目录及其模式,在表中可以对列制定独特的约束。现在我们使用的是表名为 EMPLOYEE。

    @Id 和 @GeneratedValue 注释

    • 每一个实体 bean 都有一个主键，你在类中可以用 @Id 来进行注释。主键可以是一个字段或者是多个字段的组合，这取决于你的表的结构。

    • 默认情况下，@Id 注释将自动确定最合适的主键生成策略，但是你可以通过使用 @GeneratedValue 注释来覆盖掉它。strategy 和 generator 这两个参数我不打算在这里讨论，所以我们只使用默认键生成策略。让 Hibernate 确定使用哪些生成器类型来使代码移植于不同的数据库之间。

    @Column Annotation

    @Column 注释用于指定某一列与某一个字段或是属性映射的细节信息。您可以使用下列注释的最常用的属性:

    • name 属性允许显式地指定列的名称。

    • length 属性为用于映射一个值，特别为一个字符串值的列的大小。

    • nullable 属性允许当生成模式时，一个列可以被标记为非空。

    • unique 属性允许列中只能含有唯一的内容

       

  4. 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.connection.driver_class">com.mysql.jdbc.Driver</property>
            <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernatedemo?characterEncoding=utf8</property>
            <property name="hibernate.connection.username">root</property>
            <property name="hibernate.connection.password">123456</property>
    ​
            <!--可选项-->
            <!--是否输出hibernate相关信息到控制台-->
            <property name="hibernate.show_sql">true</property>
            <property name="hibernate.format_sql">true</property>
    ​
            <!--配置方言-->
            <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
            
            <!--配置建表策略-->
            <property name="hibernate.hbm2ddl.auto">update</property>
    ​
            <!--关联一下 ORM 文件-->
            <mapping resource="cn/edu/dgut/bean/User.hbm.xml"></mapping>
        </session-factory>
    </hibernate-configuration>

     

六、hibernate 主要对象

  1. SessionFactory 对象

  • 配置对象被用于创造一个 SessionFactory 对象，使用提供的配置文件为应用程序依次配置 Hibernate，并允许实例化一个会话对象。SessionFactory 是一个线程安全对象并由应用程序所有的线程所使用。

  • SessionFactory 是一个重量级对象所以通常它都是在应用程序启动时创造然后留存为以后使用。每个数据库需要一个 SessionFactory 对象使用一个单独的配置文件。所以如果你使用多种数据库那么你要创造多种 SessionFactory 对象。

     

  1. Session 对象

  • 一个会话被用于与数据库的物理连接。Session 对象是轻量级的，并被设计为每次实例化都需要与数据库的交互。持久对象通过 Session 对象保存和检索。

  • Session 对象不应该长时间保持开启状态因为它们通常情况下并非线程安全，并且它们应该按照所需创造和销毁。

     

  1. Transaction 对象

  • 一个事务代表了与数据库工作的一个单元并且大部分 RDBMS 支持事务功能。在 Hibernate 中事务由底层事务管理器和事务（来自 JDBC 或者 JTA）处理。

  • 这是一个选择性对象，Hibernate 应用程序可能不选择使用这个接口，而是在自己应用程序代码中管理事务。

     

  1. Query 对象

  • Query 对象使用 SQL 或者 Hibernate 查询语言（HQL）字符串在数据库中来检索数据并创造对象。一个查询的实例被用于连结查询参数，限制由查询返回的结果数量，并最终执行查询。

     

  1. Criteria 对象

  • Criteria 对象被用于创造和执行面向规则查询的对象来检索对象。

     

七、hibernate 基本的增删改查

  1. 创建sql会话对象的过程封装成工具类

    public class HibernateUtil {
    ​
        private static SessionFactory sessionFactory = null;
        static {
            // 创建配置对象，读取hibernate.cfg.xml配置文件
            Configuration configuration = new Configuration().configure();
            // 创建一个会话工厂
            sessionFactory = configuration.buildSessionFactory();
        }
    ​
        // 返回一个会话对象
        public static Session getSession() {
            // 开启会话，类似于jdbc中的connection
            return sessionFactory.openSession();
        }
    }

     

    1. 基本的增删改查

    public class HbmDemo01 {
        /*// 创建配置对象
        Configuration configuration = new Configuration().configure();
        // 创建一个会话工厂
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        // 开启会话
        Session session = sessionFactory.openSession();*/
    ​
        //增
        @Test
        public void save() {
            // 调用工具类，得到一个会话对象
            Session session = HibernateUtil.getSession();
            // 开启事务
            Transaction transaction = session.beginTransaction();
    ​
            // 创建一个用户对象，并设置属性初始值
            User user = new User();
            user.setUsername("瑞兹");
            user.setPassword("666666");
            user.setAddress("符文之地");
    ​
            // 操作数据库，进行插入数据
            session.save(user);
    ​
            // 提交事务
            transaction.commit();
            //transaction.rollback();
    ​
        }
    ​
        //删
        @Test
        public void delete() {
            Session session = HibernateUtil.getSession();
            // 开启事务
            Transaction transaction = session.beginTransaction();
    ​
            // 从数据库查询出对应id数据
            User user = session.get(User.class, 1);
    ​
            // 操作数据库，进行删除数据
            session.delete(user);
    ​
            // 提交事务
            transaction.commit();
        }
    ​
        //改
        @Test
        public void update() {
            Session session = HibernateUtil.getSession();
            // 开启事务
            Transaction transaction = session.beginTransaction();
    ​
            // 从数据库查询出对应id数据
            User user = session.get(User.class, 2);
            user.setUsername("亚索");
            user.setAddress("艾欧尼亚");
    ​
            // 操作数据库，进行删除数据
            session.update(user);
    ​
            // 提交事务
            transaction.commit();
        }
    ​
        //查
        @Test
        public void query() {
            Session session = HibernateUtil.getSession();
            // 开启事务
            Transaction transaction = session.beginTransaction();
    ​
            // 从数据库查询出对应id数据
            User user = session.get(User.class, 2);
    ​
            // 输出查询到的数据
            System.out.println(user);
    ​
            // 提交事务
            transaction.commit();
        }
    }

 

八、hibernate HQL语句

Hibernate 查询语言（HQL）是一种面向对象的查询语言，类似于 SQL，但不是去对表和列进行操作，而是面向对象和它们的属性。 HQL 查询被 Hibernate 翻译为传统的 SQL 查询从而对数据库进行操作。

public class HbmDemo02 {
    @Test
    public void query1() {
        Session session = HibernateUtil.getSession();
        String hql = " from cn.edu.dgut.bean.User ";
​
        // 创建HQL对象
        Query query = session.createQuery(hql);
​
        // 从数据库查询出对应数据
        List<User> users = query.list();
​
        // 输出查询到的数据
        for (User user : users) {
            System.out.println(user);
        }
    }
​
    @Test
    public void query2() {
        Session session = HibernateUtil.getSession();
        String hql = " from cn.edu.dgut.bean.User where id=2";
​
        // 创建HQL对象
        Query query = session.createQuery(hql);
​
        // 从数据库查询出对应数据
        User user = (User) query.uniqueResult();
​
        // 输出查询到的数据
        System.out.println(user);
    }
​
    @Test
    public void query3() {
        Session session = HibernateUtil.getSession();
        // JDBC 中预编译模板技术   PrepareStatment   Statment
//        String hql = " from cn.edu.dgut.bean.User where id=? ";
        String hql = " from cn.edu.dgut.bean.User where id=:id ";
​
        // 创建HQL对象
        Query query = session.createQuery(hql);
        // 设置预编译模板占位符的值
//        query.setInteger(0, 3);
//        query.setInteger("id", 3);
​
//        query.setParameter(0,5);
        query.setParameter("id", 5);
​
        // 从数据库查询出对应数据
        User user = (User) query.uniqueResult();
​
        // 输出查询到的数据
        System.out.println(user);
    }
​
    @Test
    public void query4() {
        Session session = HibernateUtil.getSession();
        String hql = " from User ";
​
        // 创建HQL对象
        Query query = session.createQuery(hql);
        // 分页查询参数设置
        query.setFirstResult(0);
        query.setMaxResults(3);
​
        // 从数据库查询出对应数据
        List<User> users = query.list();
​
        // 输出查询到的数据
        for (User user : users) {
            System.out.println(user);
        }
    }
}

 

九、hibernate Criteria

Hibernate 提供了操纵对象和相应的 RDBMS 表中可用的数据的替代方法。一种方法是标准的 API，它允许你建立一个标准的可编程查询对象来应用过滤规则和逻辑条件。

Hibernate Session 接口提供了 createCriteria() 方法，可用于创建一个 Criteria 对象，使当您的应用程序执行一个标准查询时返回一个持久化对象的类的实例。

public class HbmDemo03 {
    // Criteria无语句 面向对象来查询
​
    @Test
    public void query1() {
        Session session = HibernateUtil.getSession();
​
        Criteria criteria = session.createCriteria(User.class);
​
        // 从数据库查询出对应数据
        List<User> users = criteria.list();
​
        // 输出查询到的数据
        for (User user : users) {
            System.out.println(user);
        }
    }
​
    @Test
    public void query2() {
        Session session = HibernateUtil.getSession();
​
        Criteria criteria = session.createCriteria(User.class);
​
        // 从数据库查询出对应数据
        criteria.add(Restrictions.eq("username", "亚索"));
​
        // 条件查询，查询id为1的用户数据
        User user = (User) criteria.uniqueResult();
​
        // 输出查询到的数据
        System.out.println(user);
    }
​
    @Test
    public void query3() {
        Session session = HibernateUtil.getSession();
​
        // 根据用户名模糊查询
        Criteria criteria = session.createCriteria(User.class);
        criteria.add(Restrictions.like("username", "%艾%"));
​
        // 模糊查询
        List<User> users = criteria.list();
        // 输出查询到的数据
        for (User user : users) {
            System.out.println(user);
        }
​
    }
​
    @Test
    public void query4() {
        Session session = HibernateUtil.getSession();
​
        // 分页查询
        Criteria criteria = session.createCriteria(User.class);
        criteria.setFirstResult(0);
        criteria.setMaxResults(4);
​
        // 分页查询
        List<User> users = criteria.list();
​
        // 输出查询到的数据
        for (User user : users) {
            System.out.println(user);
        }
    }
​
    @Test
    public void query5() {
        Session session = HibernateUtil.getSession();
​
        Criteria criteria = session.createCriteria(User.class);
        criteria.setProjection(Projections.count("id"));
​
        // 聚合函数(总行数)查询
        Long count = (Long) criteria.uniqueResult();
​
        System.out.println("总用户数为：" + count);
    }
}

 

十、hibernate 原生sql

如果你想使用数据库特定的功能如查询提示或 Oracle 中的 CONNECT 关键字的话，你可以使用原生 SQL 数据库来表达查询。Hibernate 3.x 允许您为所有的创建，更新，删除，和加载操作指定手写 SQL ，包括存储过程。

public class HbmDemo04 {
    // 原生sql查询
​
    @Test
    public void query1() {
        Session session = HibernateUtil.getSession();
​
        // 编写sql语句
        String sql = "select * from tb_user ";
        // 创建sql查询对象
        SQLQuery sqlQuery = session.createSQLQuery(sql);
        // 指定将结果集封装到哪个对象
        sqlQuery.addEntity(User.class);
​
        // 从数据库查询出对应数据
        List<User> users = sqlQuery.list();
​
        // 输出查询到的数据
        for (User user : users) {
            System.out.println(user);
        }
    }
​
    @Test
    public void query2() {
        Session session = HibernateUtil.getSession();
​
        String sql = "select * from tb_user where address=?";
        SQLQuery sqlQuery = session.createSQLQuery(sql);
        sqlQuery.setParameter(0, "艾欧尼亚");
​
        // 指定将结果集封装到哪个对象
        sqlQuery.addEntity(User.class);
​
        // 条件查询，查询id为1的用户数据
        User user = (User) sqlQuery.uniqueResult();
​
        // 输出查询到的数据
        System.out.println(user);
    }
​
    @Test
    public void query3() {
        Session session = HibernateUtil.getSession();
​
        String sql = "select * from tb_user where username like ? ";
        SQLQuery sqlQuery = session.createSQLQuery(sql);
        sqlQuery.setParameter(0, "%亚%");
​
        sqlQuery.addEntity(User.class);
​
        // 模糊查询
        List<User> users = sqlQuery.list();
        // 输出查询到的数据
        for (User user : users) {
            System.out.println(user);
        }
​
    }
​
    @Test
    public void query4() {
        Session session = HibernateUtil.getSession();
​
        String sql = "select * from tb_user ";
        SQLQuery sqlQuery = session.createSQLQuery(sql);
        sqlQuery.setFirstResult(0);
        sqlQuery.setMaxResults(5);
​
        sqlQuery.addEntity(User.class);
​
        // 分页查询
        List<User> users = sqlQuery.list();
​
        // 输出查询到的数据
        for (User user : users) {
            System.out.println(user);
        }
    }
​
}

 

十一、hibernate 表关系的处理

  1. 一对多表关系

    • 实体类

      public class User {
          private int id; // 用户id
          private String username; //用户名
          private String password; //密码
          private String address;  //住址
          List<Skin> skins = new ArrayList<>(); //皮肤
      ​
          public int getId() {
              return id;
          }
      ​
          public void setId(int id) {
              this.id = id;
          }
      ​
          public String getUsername() {
              return username;
          }
      ​
          public void setUsername(String username) {
              this.username = username;
          }
      ​
          public String getPassword() {
              return password;
          }
      ​
          public void setPassword(String password) {
              this.password = password;
          }
      ​
          public String getAddress() {
              return address;
          }
      ​
          public void setAddress(String address) {
              this.address = address;
          }
      ​
          public List<Skin> getSkins() {
              return skins;
          }
      ​
          public void setSkins(List<Skin> skins) {
              this.skins = skins;
          }
      ​
          @Override
          public String toString() {
              return "User{" +
                      "id=" + id +
                      ", username='" + username + '\'' +
                      ", password='" + password + '\'' +
                      ", address='" + address + '\'' +
                      ", skins=" + skins +
                      '}';
          }
      }
      public class Skin {
          private int id; // 皮肤id
          private String skinName; // 皮肤名字
          private boolean colors;  // 是否有炫彩皮肤
          private User user; // 对应英雄
      ​
          public Skin() {
          }
      ​
          public Skin(String skinName, boolean colors) {
          }
      ​
          public int getId() {
              return id;
          }
      ​
          public void setId(int id) {
              this.id = id;
          }
      ​
          public String getSkinName() {
              return skinName;
          }
      ​
          public void setSkinName(String skinName) {
              this.skinName = skinName;
          }
      ​
          public boolean isColors() {
              return colors;
          }
      ​
          public void setColors(boolean colors) {
              this.colors = colors;
          }
      ​
          public User getUser() {
              return user;
          }
      ​
          public void setUser(User user) {
              this.user = user;
          }
      ​
      }

    • ORM 映射（实体类和数据表映射）

      <!DOCTYPE hibernate-mapping PUBLIC
              "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
              "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
      <hibernate-mapping package="cn.edu.dgut.bean">
          <!--ORM 映射  实体类和 数据表映射-->
          <class name="User" table="tb_user">
              <id name="id" column="id">
                  <!--设置主键策略-->
                  <generator class="native"></generator>
              </id>
              <property name="username" column="username"></property>
              <property name="password" column="password"></property>
              <property name="address" column="address"></property>
      ​
              <!--配置一对多关系-->
              <list name="skins" cascade="all">
                  <key column="uid"></key>
                  <index column="[index]"></index>
                  <one-to-many class="Skin"></one-to-many>
              </list>
          </class>
      </hibernate-mapping>
      <!DOCTYPE hibernate-mapping PUBLIC
              "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
              "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
      <hibernate-mapping package="cn.edu.dgut.bean">
          <!--ORM 映射  实体类和 数据表映射-->
          <class name="Skin" table="tb_skin">
              <id name="id" column="id">
                  <!--设置主键策略-->
                  <generator class="native"></generator>
              </id>
              <property name="skinName" column="skin_name"></property>
              <property name="colors" column="colors"></property>
      ​
              <!--配置多对一关系-->
              <many-to-one name="user" column="uid" class="User"></many-to-one>
          </class>
      ​
      </hibernate-mapping>

    • HibernateUtil和hibernate.cfg.xml（关联ORM映射文件即可）基本不变

    • 测试类

      public class HbmDemo01 {
          @Test
          public void save() {
              // 调用工具类，得到一个会话对象
              Session session = HibernateUtil.getSession();
              // 开启事务
              Transaction transaction = session.beginTransaction();
      ​
              // 创建一个用户对象，并设置属性初始值
              User user = new User();
              user.setUsername("亚索");
              user.setPassword("666666");
              user.setAddress("艾欧尼亚");
      ​
              Skin skin1 = new Skin();
              skin1.setSkinName("原计划");
              skin1.setColors(false);
              Skin skin2 = new Skin();
              skin2.setSkinName("黑夜使者");
              skin2.setColors(false);
              Skin skin3 = new Skin();
              skin3.setSkinName("奥德赛");
              skin3.setColors(true);
      ​
              user.getSkins().add(skin1);
              user.getSkins().add(skin2);
              user.getSkins().add(skin3);
      ​
              skin1.setUser(user);
              skin2.setUser(user);
              skin3.setUser(user);
      ​
              // 操作数据库，进行插入数据
              session.save(user);
      //        session.save(skin1);
      //        session.save(skin2);
      //        session.save(skin3);
      ​
              // 提交事务
              transaction.commit();
      ​
          }
      }

       

  2. 多对多表关系

    • 实体类

      public class Hero {
          private int heroid; // 英雄id
          private String heroname; //英雄名
          private String password; //密码
          private String address;  //住址
          Set<Route> routes = new HashSet<>(); //路线
      ​
          public int getHeroid() {
              return heroid;
          }
      ​
          public void setHeroid(int heroid) {
              this.heroid = heroid;
          }
      ​
          public String getHeroname() {
              return heroname;
          }
      ​
          public void setHeroname(String heroname) {
              this.heroname = heroname;
          }
      ​
          public String getPassword() {
              return password;
          }
      ​
          public void setPassword(String password) {
              this.password = password;
          }
      ​
          public String getAddress() {
              return address;
          }
      ​
          public void setAddress(String address) {
              this.address = address;
          }
      ​
          public Set<Route> getRoutes() {
              return routes;
          }
      ​
          public void setRoutes(Set<Route> routes) {
              this.routes = routes;
          }
      ​
          @Override
          public String toString() {
              return "Hero{" +
                      "heroid=" + heroid +
                      ", heroname='" + heroname + '\'' +
                      ", password='" + password + '\'' +
                      ", address='" + address + '\'' +
                      ", routes=" + routes +
                      '}';
          }
      }
      public class Route {
          private int routeid; // 路线id
          private String routename; // 路线名字
          Set<Hero> heroes = new HashSet<>(); // 对应英雄
      ​
          public int getRouteid() {
              return routeid;
          }
      ​
          public void setRouteid(int routeid) {
              this.routeid = routeid;
          }
      ​
          public String getRoutename() {
              return routename;
          }
      ​
          public void setRoutename(String routename) {
              this.routename = routename;
          }
      ​
          public Set<Hero> getHeroes() {
              return heroes;
          }
      ​
          public void setHeroes(Set<Hero> heroes) {
              this.heroes = heroes;
          }
      ​
          @Override
          public String toString() {
              return "Route{" +
                      "routename='" + routename + '\'' +
                      '}';
          }
      }

    • ORM 映射（实体类和数据表映射）

      <!DOCTYPE hibernate-mapping PUBLIC
              "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
              "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
      <hibernate-mapping package="cn.edu.dgut.bean">
          <!--ORM 映射  实体类和 数据表映射-->
          <class name="Hero" table="tb_hero">
              <id name="heroid" column="heroid">
                  <!--设置主键策略-->
                  <generator class="native"></generator>
              </id>
              <property name="heroname" column="heroname"></property>
              <property name="password" column="password"></property>
              <property name="address" column="address"></property>
              <!--
                        set  表示配置set 集合
      ​
                        name 填写引用对方的 实体属性名称
      ​
                        tbale 填写 中间表的表名
      ​
      ​
               key   colunm 属性 填写 当前 实体 在第三方表中 外键 名称
      ​
               many-to-many  表示  多对多关系配置
      ​
               column  填写  你引用对方实体的 对应的外键名称    rid
      ​
                      -->
              <!--配置多对多关系-->
              <set name="routes" cascade="all" inverse="true" table="tb_hero_route">
                  <key column="hid"></key>
                  <many-to-many column="rid" class="Route"></many-to-many>
              </set>
          </class>
      </hibernate-mapping>
      <!DOCTYPE hibernate-mapping PUBLIC
              "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
              "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
      <hibernate-mapping package="cn.edu.dgut.bean">
          <!--ORM 映射  实体类和 数据表映射-->
          <class name="Route" table="tb_route">
              <id name="routeid" column="routeid">
                  <!--设置主键策略-->
                  <generator class="native"></generator>
              </id>
              <property name="routename" column="routename"></property>
      ​
              <!--配置多对多关系-->
              <set name="heroes" table="tb_hero_route" >
                  <key column="rid"></key>
                  <many-to-many column="hid" class="Hero"></many-to-many>
              </set>
          </class>
      ​
      </hibernate-mapping>

    • HibernateUtil和hibernate.cfg.xml（关联ORM映射文件即可）基本不变

    • 测试类

      public class HbmDemo01 {
          @Test
          public void save() {
              // 调用工具类，得到一个会话对象
              Session session = HibernateUtil.getSession();
              // 开启事务
              Transaction transaction = session.beginTransaction();
      ​
              // 创建一个用户对象，并设置属性初始值
              Hero hero = new Hero();
              hero.setHeroname("嘉文四世");
              hero.setPassword("123456");
              hero.setAddress("德玛西亚");
      ​
              Hero hero2 = new Hero();
              hero2.setHeroname("盖伦");
              hero2.setPassword("666888");
              hero2.setAddress("德玛西亚");
      ​
              // 创建路线对象，并设置属性初始值
              Route route1 = new Route();
              route1.setRoutename("中路");
              Route route2 = new Route();
              route2.setRoutename("上路");
              Route route3 = new Route();
              route3.setRoutename("打野");
      ​
              // 将路线和英雄关联
              hero.getRoutes().add(route1);
              hero.getRoutes().add(route2);
              hero.getRoutes().add(route3);
      ​
              // 将英雄和路线关联
              route1.getHeroes().add(hero);
              route2.getHeroes().add(hero);
              route3.getHeroes().add(hero);
      ​
              hero2.getRoutes().add(route1);
              hero2.getRoutes().add(route2);
              hero2.getRoutes().add(route3);
      ​
              route1.getHeroes().add(hero2);
              route2.getHeroes().add(hero2);
              route3.getHeroes().add(hero2);
      ​
              // 操作数据库，进行插入数据
              session.save(hero);
              session.save(hero2);
      ​
              // 提交事务
              transaction.commit();
      ​
          }
      }

       

 

本文是学习hibernate的笔记总结，欢迎大家批评指正，有什么问题可以评论区交流。

参考链接：https://www.w3cschool.cn/hibernate/npyd1iek.html

 

posted @ 2020-08-08 11:31  小房子杂记  阅读(305)  评论(0)    收藏  举报