Hibernate学习

Hibernate是一个操作数据库的框架，实现了对JDBC的封装

一、Hibernate 与 C3P0+dbutils 对比

1）创建

● hibernate：

创建hibernate.cfg.xml

配置驱动，数据库url、用户名、密码

数据库的方言

● c3p0+dbutils：

c3p0连接数据库：配置驱动、数据库url、用户名、密码

dbutils操作数据库

2）添加实体

● hibernate：

需要实体与表的映射文件xxx.hbm.xml：配置属性与字段的对应，添加主键生成策略

● c3p0+dbutils：

需要实体

3）操作数据库

● hibernate：

通过session操作数据库(开启事务)

session.save操作数据库中的表

● c3p0+dbutils：

通过QueryRunner操作数据库

写sql语句操作数据库中的表

二、配置文件

1）hibernate.cfg.xml配置

● 数据库驱动、url、用户名、密码
● 方言-org.hibernate.dialect.MySQLDialect；MySQLDialect：自动生成表需要添加表的类型MySQL5InnoDBDialect
● 显示并生成SQL语句
● 配置自动生成表
● orm文件位置

<?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>
    <!-- 负责初始化Hibernate -->
    <session-factory>
        <!-- 连接数据库驱动 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <!-- 数据库地址 -->
        <property name="hibernate.connection.url"><![CDATA[jdbc:mysql://localhost:3306/hibernatelearn?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8&useSSL=true]]></property>
        <!-- 数据库用户名 -->
        <property name="hibernate.connection.username">root</property>
        <!-- 数据库密码 -->
        <property name="hibernate.connection.password">123456</property>

        <!-- 配置数据库方言 -->
        <!-- <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
        
        <!-- 将Hibernate生成的SQL语句打印到控制台 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 格式化hibernate生成的SQL语句 -->
        <property name="hibernate.format_sql">true</property>
                
        <!-- 配置hibernate自动创建表
            create：            自动创建表，每次框架运行都会创建一张新的表，原来的数据将丢失（开发）
            create-drop：    自动建表，每次框架运行结束都会将所有表删除（开发环境中测试使用）
            update(推荐)：    自动生成表，如果表已经存在 则更新数据，如果表不存在 就会创建一张新的表
         -->
        <property name="hibernate.hbm2ddl.auto">update</property>
        
        <!-- 配置事务的隔离级别：
            1(0001)    读未提交：最低的隔离级别，最没用(最快)
            2(0010)    读已提交：可避免脏读，不能避免不可重复度
            4(0100)    可重复读：可以避免不可重复度，可以避免脏读(MySQL默认)
            8(1000)    串行化：最强大，三种都可以解决(最慢) 
         -->
        <property name="hibernate.connection.isolation">4</property>
        
        <!-- 配置事务（session与当前线程绑定） -->
        <property name="hibernate.current_session_context_class">thread</property>
        
        <!-- orm映射关系 -（O对象，R关系，M映射）-->
        <mapping resource="com/sikiedu/domain/User.bhm.xml"/>
        
    </session-factory>
</hibernate-configuration>

2）配置实体与表的映射文件xxx.hbm.xml

● id标签：
　　name：实体中的属性
　　column（可选）：数据库的列名
　　type（可选）：填写列(属性)的类型，hibernate会自动检测实体属性的类型（每个类型有三种写法：[ java类型 | hibernate类型 | 数据库类型 ]）
　　length（可选）：配置数据库中列的长度（默认值：使用数据库类型的最大长度）
　　◆ generator标签：主键生成策略
　　　　identity：主键自增
　　　　sequence：Oracle中主键生成的策略
　　　　native：identity+sequence(hibernate会根据连接的数据库自动选择(identity或sequence))
　　　　uuid：产生随机字符串作为主键，主键必须为String
　　　　assigned：手动指定
● property标签：除了id之外的普通属性
　　name：实体中的属性
　　column（可选）：数据库的列名
　　type（可选）：填写列(属性)的类型，hibernate会自动检测实体属性的类型（每个类型有三种写法：[ java类型 | hibernate类型 | 数据库类型 ]）
　　length（可选）：配置数据库中列的长度，默认值：使用数据库类型的最大长度
　　not-null（可选）：配置该属性(列)是否不能为空，默认值：false

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.sikiedu.domain.User" table="user">
        <id name="id" column="id">
            <!-- 主键生成策略 -->
            <generator class="uuid"></generator>
        </id>
        <property name="username" column="username"></property>
        <property name="password" column="password"></property>
        <property name="name" column="name"></property>
        <property name="email" column="email"></property>
        <property name="telephone" column="telephone"></property>
    </class>
</hibernate-mapping>

三、API讲解

1）Configuration：

// 读取hibernate.cfg.xml
Configuration config = new Configuration().configure();

2）SessionFactory：工厂类，用于创建session对象；

① 负责保存和使用所有配置信息，消耗内存资源大；

② 线程安全；

③ 保证一个web项目中，只创建一个

一般创建工具类使用

//得到SessionFactory
SessionFactory factory = config.buildSessionFactory();
//创建Session对象
Session openSession = factory.openSession();

3）Session（重点）：核心对象，实现数据库的增删改查

增：save

 - 本质：对象状态的转换，瞬时 - - - > 持久化

 - 目的：生成ID

public void addUser(User user) {
    // 读取hibernate.cfg.xml
    Configuration config = new Configuration().configure();
    // 获取SessionFactory工厂
    SessionFactory SessionFactory = config.buildSessionFactory();
    // 获取Session
    Session session = SessionFactory.openSession();
    // 打开事物
    Transaction transaction = session.beginTransaction();
    // 将user对象添加到数据库
    session.save(user);
    // 提交事务
    transaction.commit();
    // 关闭Session
    session.close();
}

删：delete

public void deleteUser(String id) {
    // 读取hibernate.cfg.xml
    Configuration config = new Configuration().configure();
    // 获取SessionFactory工厂
    SessionFactory SessionFactory = config.buildSessionFactory();
    // 获取Session
    Session session = SessionFactory.openSession();
    // 开启事物
    Transaction transaction = session.beginTransaction();
    // 得到指定ID的对象
    User user = session.get(User.class, id);
    // 将该对象在数据库中删除
    session.delete(user);
    // 提交事务
    transaction.commit();
    // 关闭Session
    session.close();
}

改：update

public void ChangeUser() {
    // 读取hibernate.cfg.xml
    Configuration config = new Configuration().configure();
    // 获取SessionFactory工厂
    SessionFactory SessionFactory = config.buildSessionFactory();
    // 获取Session
    Session session = SessionFactory.openSession();
    // 开启事物
    Transaction transaction = session.beginTransaction();
    // 得到指定ID的对象，并修改该对象的信息
    User user = session.get(User.class, "402880e56e2624ad016e2624b30d0000");//有ID,与Session有关联　　持久化状态
    user.setUsername("newUsername");
    // 更新数据库，将修改后的对象更新到数据库中
    session.update(user);
    // 提交事务
    transaction.commit();
    // 关闭Session
    session.close();
}

查：get

public User findUser(String id) {
    // 读取hibernate.cfg.xml
    Configuration config = new Configuration().configure();
    // 获取SessionFactory工厂
    SessionFactory SessionFactory = config.buildSessionFactory();
    // 获取Session
    Session session = SessionFactory.openSession();
    // 开启事物
    Transaction transaction = session.beginTransaction();
    // 根据ID获取对象
    User user = session.get(User.class, id);
    // 提交事务
    transaction.commit();
    // 关闭Session
    session.close();
    // 返回获取到的对象
    return user;
}

4）Transaction：事物处理对象

// 读取hibernate.cfg.xml
Configuration config = new Configuration().configure();
// 获取SessionFactory工厂
SessionFactory SessionFactory = config.buildSessionFactory();
// 获取Session
Session session = SessionFactory.openSession();
// 开启事物
Transaction transaction = session.beginTransaction();

//进行数据库操作...

// 提交事务
transaction.commit();
// 关闭Session
session.close();

四、创建实体

1）提供无参的构造器

2）提供属性 - 成员变量的私有化，提供get、set方法

3）类型 - 尽量使用包装类型

4）主键

5）不要加final（hibernate中使用代理机制）

五、对象的三种状态

1）瞬时状态：实体-没有ID，没有与Session关联

2）持久化状态：实体-有ID，与Session关联

特点：持久化状态对象的任何改变都会同步到数据库中

3）游离态：实体-有ID，没有与Session关联

Configuration config = new Configuration().configure();
SessionFactory SessionFactory = config.buildSessionFactory();
Session session = SessionFactory.openSession();
Transaction transaction = session.beginTransaction();
   
User user = new User();//=>没有ID,没有与session关联　　 瞬时状态
user.setName("newName");//=>没有ID,没有与session关联　　瞬时状态
session.save(user);//=>有ID,与session关联　　持久化状态；
// save本质：对象状态的转换,瞬时->持久化；save目的：生成ID

transaction.commit();
session.close();//=>没有与session关联,有ID　　游离态

对象三种状态的改变

六、一级缓存

提高效率

Configuration config = new Configuration().configure();
SessionFactory SessionFactory = config.buildSessionFactory();
Session session = SessionFactory.openSession();
Transaction transaction = session.beginTransaction();

// 获取ID为UserId的对象
// 有ID,与Session有关联    持久化状态
User user1 = session.get(User.class, UserId);
User user2 = session.get(User.class, UserId);
User user3 = session.get(User.class, UserId);
User user4 = session.get(User.class, UserId);
User user5 = session.get(User.class, UserId);
// 缓存的存在
System.out.println(user1==user5);// true

transaction.commit();
session.close();//=>没有与session关联,有ID　　游离态

七、事务

1）事务的性质

原子性：原子，不可再分，一个操作不能分为更小的操作，要么全都执行，要么全不执行
一致性：事务在完成时，必须使得所有的数据保持一致的状态（与开始事务前保持一样的状态）
隔离性：事务查看数据时数据所处的状态，要么是另一个并发事务修改它之前的状态，要么使另一并发事务修改它之后的状态，事务不会查看中间状态的数据
持久性：事务完成之后。它对于系统的影响是永久性的。（执行了就执行了，没有撤回(悔棋)的说法）

2）事务的隔离级别

脏读：读取了未提交事务中的数据
不可重复读取：对于数据库中的某个数据，一个事务范围内多次读取同一个数据，却有不同的值
幻读：

3）配置事务的隔离级别：hibernate.cfg.xml配置

1(0001) - 读未提交：最低的隔离级别，最没用(最快)
2(0010) - 读已提交：可避免脏读，不能避免不可重复度
3(0100) - 可重复读：可以避免不可重复度，可以避免脏读(MySQL默认)
8(1000) - 串行化：最强大，三种都可以解决(最慢) 

<!-- hibernate.cfg.xml配置事务隔离级别 -->
<property name="hibernate.connection.isolation">4</property>

5）事务小案例：根据 id 查找 user，如果找到就改变 user 的名字，否则不做任何变化

- 需要配置事务

<!-- 配置事务（session与当前线程绑定） -->
<property name="hibernate.current_session_context_class">thread</property>

public class HibernateUtils {
    private static SessionFactory sessionFactory = null;

    static {
        // 读取hibernate.cfg.xml
        Configuration configure = new Configuration().configure();
        // 获取SessionFactory工厂
        sessionFactory = configure.buildSessionFactory();
    }

    // 获取全新的Session
    public static Session getSession() {
        // 获取session
        return sessionFactory.openSession();
    }

    // 获取当前线程的Session
    public static Session getCurrentSession() {
        return sessionFactory.getCurrentSession();
    }
}

public User findUserById(String id) {
    // 获取当前线程的session
    Session session = HibernateUtils.getCurrentSession();
    return session.get(User.class, id);
}

public void ChangeUserByUserId(String id) {
    // 获取当前线程的session
    Session session = HibernateUtils.getCurrentSession();
    // 先拿到持久化User
    User user = session.get(User.class, id);
    // 改变User(持久化->beginTransaction.commit()提交事务才会同步到数据库)
    user.setUsername("新用户名");

}

public void addUser(User user) {

    // 获取当前线程的session，开启事物
    Session session = HibernateUtils.getCurrentSession();
    Transaction transaction = session.beginTransaction();
    try {
        // 根据ID查找对象
        User tuser = userDao.findUserById("94a80ab8-d049-4c73-bcc1-47206f56aafb");
        if (tuser != null) {
            // 如果找到了，根据ID修改名字
            userDao.ChangeUserByUserId(tuser.getId());
        } else {
            // 没找到，不做任何操作
        }
    } catch (Exception e) {
        e.printStackTrace();
        // 出错 - 回滚事务
        transaction.rollback();
    } finally {
        // 提交事务
        transaction.commit();
    }
}

八、HQL 与 Criteria 与 sql

1）HQL：不能出现表中的任何内容

（1）基本查询

String hql = "from com.sikiedu.domain.User";
Query<User> query = session.createQuery(hql);
List<User> list = query.list();// 查询多条数据

（2）条件查询 - 基本条件查询

String hql = "from com.sikiedu.domain.User where id = 1";
Query<User> query = session.createQuery(hql);
User user = query.uniqueResult();// 查询唯一数据

（3）条件查询 - ?占位符查询

String hql = "from com.sikiedu.domain.User where id = ?0";
Query query = session.createQuery(hql);
query.setParameter(0, id);// 设置参数
User user = (User) query.uniqueResult();// 查询唯一数据

（4）条件查询 - 命名占位符查询(推荐)

String hql = "from com.sikiedu.domain.User where id = :id";
Query query = session.createQuery(hql);
query.setParameter("id", id);// 设置参数
User user = (User) query.uniqueResult();// 查询唯一数据

（5）limit - 分页查询 

String hql = "from com.sikiedu.domain.User";
Query query = session.createQuery(hql);
query.setFirstResult(0);// 查询起始位置
query.setMaxResults(8);// 查询个数
List<User> list = query.list();

2）Criteria - CriteriaBuilder对象

（1）方法

gt 等于 > ge 等于 >=
lt 等于 < le 等于 <=
equal 等于 == nog 等于 !
between 等于 between and
like 等于 like 
isNotNull 等于 is not null / isNull 等于 is
null or 等于 or / and 等于 and
count 等于 总数 / avg 等于 平均值

（2）基本查询

CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
// createQuery ---> 查询条件(首先要知道查询什么类型数据)(实体Object User)
CriteriaQuery<User> createQuery = criteriaBuilder.createQuery(User.class);
Root<User> form = createQuery.from(User.class);
createQuery.select(form);
// 执行查询
List<User> list = session.createQuery(createQuery).getResultList();

（3）条件查询

CriteriaBuilder builder = session.getCriteriaBuilder();
// createQuery ---> 查询条件(首先要知道查询什么类型数据)(实体Object User)
CriteriaQuery<User> query = builder.createQuery(User.class);
Root<User> from = query.from(User.class);
query.select(from).where(from.get("id").in("402880e56e2624ad016e262536ff0001"));
// 执行查询，并获取查询结果
List<User> list = session.createQuery(query).getResultList();

（4）分页查询

// createQuery ---> 查询条件(首先要知道查询什么类型数据)(数Integer Long)
CriteriaQuery<User> createQuery = session.getCriteriaBuilder().createQuery(User.class);
Root<User> from = createQuery.from(User.class);
createQuery.select(from);
// 执行查询
Query<User> query = session.createQuery(createQuery);
query.setFirstResult(0);
query.setMaxResults(3);
List<User> list = query.list();

（5）查询总记录数

CriteriaBuilder builder = session.getCriteriaBuilder();
// createQuery ---> 查询条件(首先要知道查询什么类型数据)(数Integer Long)
CriteriaQuery<Long> query = builder.createQuery(Long.class);
Root<User> from = query.from(User.class);
query.select(builder.count(from));
// 查询名字带有i的人的总数 - query.select(builder.count(from)).where(builder.like(from.get("username"), "%泡%")); 
// 执行查询
Long count = session.createQuery(query).uniqueResult();

3）sql

（1）基本查询

String sql = "select * from user";
// 创建sql查询对象
NativeQuery<User> sqlQuery = session.createSQLQuery(sql);
// 封装数据
sqlQuery.addEntity(User.class);
// 接收list结果
List<User> list = sqlQuery.list();

（2）条件查询

String sql = "select * from user where username = ?";
// 创建sql查询对象
NativeQuery<User> sqlQuery = session.createSQLQuery(sql);
// 给?赋值
sqlQuery.setParameter(1, "泡泡");
// 封装数据
sqlQuery.addEntity("com.sikiedu.domain.User");
// 接收唯一结果
User user = sqlQuery.uniqueResult();

（3）分页查询

String sql = "select * from user limit ?,?";
// 创建sql查询对象
NativeQuery<User> sqlQuery = session.createSQLQuery(sql);
// 给?复制
sqlQuery.setParameter(1, 1);
sqlQuery.setParameter(2, 2);
// 封装数据
sqlQuery.addEntity(User.class);
// 获取查询结果
List<User> list = sqlQuery.list();

九、外键关联 - 一对多与多对多关系

传送门① 传送门②

1）多对一 / 一对多(重点)

一对多关系是关系型数据库中两个表之间的一种关系。通常在数据库层级中，两表之间是有主外键关系的。在ORM中，如何通过对象描述表之间的关系，是ORM核心。

2）多对多(重点)

多对多关系是关系数据库中两个表之间的一种数据关系，为了维护这种关系，通常会存在一张中间关系表。两张表都只和关系表间建立主外键关系。

- 其实就是在中间表中的两次一对多的关系。

3）例子

模拟用户和用户帖子和回复帖的映射关系，一个用户有多个帖子，一个帖子可以被多个用户回复。
一个用户发表的多个帖子，对应用户和帖子的一对多映射。
多个用户回复一个帖子，对应用户和帖子的多对一映射。

实体类：

package com.sikiedu.domain;

import java.util.HashSet;
import java.util.Set;

public class User {

    private String id;

    private String username;
    private String password;
    private String name;
    private String email;
    private String telephone;
    // 一对多 - 被paste表所引用
    private Set<Paste> pasteSet = new HashSet<Paste>();
    private Set<Paste> answerPasteSet = new HashSet<Paste>();

    public User() {
        super();
    }

    public String getId() {
        return id;
    }

    public void setId(String 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 getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getTelephone() {
        return telephone;
    }

    public void setTelephone(String telephone) {
        this.telephone = telephone;
    }

    public Set<Paste> getPasteSet() {
        return pasteSet;
    }

    public void setPasteSet(Set<Paste> pasteSet) {
        this.pasteSet = pasteSet;
    }

    public Set<Paste> getAnswerPasteSet() {
        return answerPasteSet;
    }

    public void setAnswerPasteSet(Set<Paste> answerPasteSet) {
        this.answerPasteSet = answerPasteSet;
    }

}

package com.sikiedu.domain;

import java.util.HashSet;
import java.util.Set;

public class Paste {

    private String id;
    private String title;
    private String content;
    private Integer offer;
    private Integer ansnum;
    private Integer glanceover;
    private String createtime;
    // 多对一 - 引用user表为外键属性
    private User user;
    // 一对多 - 被answer表所引用
    private Set<User> userAnswerSet = new HashSet<User>();

    public Paste() {
        super();
    }

    public String getId() {
        return id;
    }

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

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Integer getOffer() {
        return offer;
    }

    public void setOffer(Integer offer) {
        this.offer = offer;
    }

    public Integer getAnsnum() {
        return ansnum;
    }

    public void setAnsnum(Integer ansnum) {
        this.ansnum = ansnum;
    }

    public Integer getGlanceover() {
        return glanceover;
    }

    public void setGlanceover(Integer glanceover) {
        this.glanceover = glanceover;
    }

    public String getCreatetime() {
        return createtime;
    }

    public void setCreatetime(String createtime) {
        this.createtime = createtime;
    }

    public User getUser() {
        return user;
    }

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

    public Set<User> getUserAnswerSet() {
        return userAnswerSet;
    }

    public void setUserAnswerSet(Set<User> userAnswerSet) {
        this.userAnswerSet = userAnswerSet;
    }

}

package com.sikiedu.domain;

public class Answer {

    private String id;
    private String content;
    // 多对一 - 引用user表、paste表为外键属性
    private User user;
    private Paste paste;

    public Answer() {
        super();
    }

    public String getId() {
        return id;
    }

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

    public User getUser() {
        return user;
    }

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

    public Paste getPaste() {
        return paste;
    }

    public void setPaste(Paste paste) {
        this.paste = paste;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

}

hbm.xml映射文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.sikiedu.domain">
    <class name="User" table="user">
        <id name="id">
            <generator class="uuid"></generator>
        </id>
        <property name="username" column="username"></property>
        <property name="password" column="password"></property>
        <property name="name" column="name"></property>
        <property name="email" column="email"></property>
        <property name="telephone" column="telephone"></property>

        <!-- 一对多 - one-to-many - 被paste表所引用
            name：集合属性名称
            cascade：级联操作
                    ① save-update：级联保存，级联更新  （当一对多的'一'更新了'多'也会跟着更新）
                    ② delete：级联删除（当一对多的'一'删除了'多'也会跟着删除）
                    ③ all
            inverse：配置关系是否不维护
                    ① true：不维护
                    ② false：维护关系
                column：外键列名
                class：与他相关的对象的完整类名-->
        <set name="pasteSet">
            <key column="userid"></key>
            <one-to-many class="Paste" />
        </set>
        
        <!-- 多对多关系 - 转换为两个一对多 -->
        <set name="answerPasteSet">
            <!-- 指定关联的外键的列名 -->
            <key column="pasteid"></key>
            <!-- 指定关联的外键的实体类名 -->
            <one-to-many class="Answer"/>
        </set>
        
    </class>
</hibernate-mapping>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.sikiedu.domain">
    <class name="Paste" table="paste">
        <id name="id">
            <generator class="uuid"></generator>
        </id>
        <property name="title" column="title"></property>
        <property name="content" column="content"></property>
        <property name="offer" column="offer"></property>
        <property name="ansnum" column="ansnum"></property>
        <property name="glanceover" column="glanceover"></property>
        <property name="createtime" column="createtime"></property>
        
        <!-- 多对一  many-to-one - 外键关联指定user表为userid属性的约束 
            name：引用属性名
            class：与他关联的对象的完整类名
            column：外键列名 -->
        <!-- inverse：配置关系是否不维护
                    ① true：不维护
                    ② false：维护关系
             insert属性：
               性能优化：
               无论怎么放弃维护，总有一方需要维护（按默认值来就行）
               一般的开发中，一的方放弃维护，多的一方不放弃维护
         -->
        <many-to-one name="user" class="User" column="userid" insert="true"></many-to-one>
        
        <!-- 多对多关系   - 转换为两个一对多 -->
        <set name="userAnswerSet">
            <!-- 指定关联的外键的列名 -->
            <key column="userid"></key>
            <!-- 指定关联的外键的实体类名 -->
            <one-to-many class="Answer"/>
        </set>
        
    </class>
</hibernate-mapping>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.sikiedu.domain">
    <class name="Answer" table="answer">
        <id name="id">
            <generator class="uuid"></generator>
        </id>
        <property name="content" column="content"></property>
        <!-- 多对一  many-to-one - 外键关联指定user/paste表为userid/pasteid属性的约束 -->
        <many-to-one name="user" column="userid" class="User"></many-to-one>
        <many-to-one name="paste" column="pasteid" class="Paste"></many-to-one>
    </class>
</hibernate-mapping>

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>
        <property name="hibernate.connection.url"><![CDATA[jdbc:mysql://localhost:3306/hforum?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8&useSSL=true]]></property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">123456</property>

        <!-- 配置数据库方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>

        <!-- 将hibernate生成的sql语句打印到控制台 -->
        <property name="hibernate.show_sql"></property>

        <!-- 格式化hibernate生成的sql语句 -->
        <property name="hibernate.format_sql"></property>

        <!-- 配置hibernate自动创建表 -->
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- 配置数据库的隔离级别 -->
        <property name="hibernate.connection.isolation">4</property>

        <!-- 配置事务 (session与当前线程绑定) -->
        <property name="current_session_context_class">thread</property>

        <!-- orm映射关系 -（O对象，R关系，M映射）-->
        <mapping resource="com/sikiedu/domain/User.hbm.xml" />
        <mapping resource="com/sikiedu/domain/Paste.hbm.xml" />
        <mapping resource="com/sikiedu/domain/Answer.hbm.xml" />

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