Hibernate5.4的环境搭建

（1）项目中添加Hibernate依赖

    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>5.4.2.Final</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.16</version>
    </dependency>

（2）项目中添加Hibernate配置文件

 <?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="connection.driver_class">com.mysql.jdbc.Driver</property>-->
         <property name="connection.driver_class">com.mysql.cj.jdbc.Driver</property>

         <!--数据库连接地址-->
         <!--<property name="connection.url">jdbc:mysql://localhost:3306/hibernatedemo</property>-->
         <property name="connection.url">jdbc:mysql://localhost:3306/hibernatedemo?serverTimezone=UTC</property>

         <!--数据库连接用户名-->
         <property name="connection.username">root</property>

         <!--数据库连接密码-->
         <property name="connection.password"></property>

         <!-- 配置内置连接池中的连接数 -->
         <property name="connection.pool_size">5</property>

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

         <!--&lt;!&ndash; Disable the second-level cache  &ndash;&gt;-->
         <!--<property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property>-->

         <!-- 操作数据库时，是否向控制台打印Sql语句 -->
         <property name="show_sql">true</property>

         <!-- 事务自动提交  -->
         <!--<property name="connection.autocommit">true</property>-->

         <!-- 将Session与线程绑定=> 只有配置了该配置,才能使用getCurrentSession -->
         <!--<property name="current_session_context_class">thread</property>-->

         <!-- 打印Sql语句前，是否将Sql语句格式化 -->
         <property name="format_sql">true</property>

         <!-- 生成表结构的策略配置
             update(最常用的取值): 如果当前数据库中不存在表结构,那么自动创建表结构.
                                  如果存在表结构,并且表结构与实体一致,那么不做修改
                                  如果存在表结构,并且表结构与实体不一致,那么会修改表结构.会保留原有列.
             create(很少):无论是否存在表结构.每次启动Hibernate都会重新创建表结构.(数据会丢失)
             create-drop(极少): 无论是否存在表结构.每次启动Hibernate都会重新创建表结构.每次Hibernate运行结束时,删除表结构.
             validate(很少):不会自动创建表结构.也不会自动维护表结构.Hibernate只校验表结构. 如果表结构不一致将会抛出异常.
          -->
         <property name="hbm2ddl.auto">update</property>

         <!-- 引入ORM映射文件 填写src之后的路径-->
         <mapping resource="User.hbm.xml"/>

         <!-- Names the annotated entity class -->
          <!--<mapping class="cn.coreqi.entities.Users"/>-->

     </session-factory>

 </hibernate-configuration>

（3）添加表对象关系映射文件 || 在实体类上添加注解（推介）

表对象关系映射文件

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

 <!--
         ORM元数据  表对象关系映射文件
         package : 配置该配置文件中类所在的包.
 -->
 <hibernate-mapping package="cn.coreqi.entities">

      <!--
         class标签: 配置实体与表的关系
          name属性: 实体类类名
          table属性: 与实体类对应的数据表名称
          dynamic-insert属性: 动态插入 默认值false
                             true=>如果字段值为null,不参与insert语句
          dynamic-update属性: 动态更新  默认值false
                             true=>没改动过的属性,将不会生成到update语句中
       -->
     <class name="Users" table="users">
         <!-- id标签: 配置实体类与数据表的主键映射
              name: 实体类中主键的属性名称
              column: 数据表中主键的列名
              length: 列的数据长度
              unsaved-value(不常用): 指定主键为什么值时,当做null来处理.
              access(强烈推荐不要用):field 那么在操作属性时,会直接操作对应的字段而不是get/set方法
           -->
         <id name="Id" column="Id">
             <!-- generator  主键生成策略
                     1.increment  数据库自己生成主键. 先从数据库中查询最大的ID值,将ID值加1作为新的主键
                     2.identity  依赖于数据的主键自增功能
                     3.sequence  序列,依赖于数据中的序列功能(Oracle).
                     4.hilo(纯了解,永远用不到) : Hibernate自己实现序列的算法,自己生成主键. (hilo算法 )
                     5.native 自动根据数据库判断,三选一. identity|sequence|hilo
                     6.uuid  生成32位的不重复随机字符串当做主键
                     7.assigned 自己指定主键值. 表的主键是自然主键时使用.
              -->
             <generator class="identity"/>
         </id>
         <!-- property  实体类属性与数据表中列的映射
                 name : 实体类中属性名称
                 column : 数据表中列的名称
                 length : 数据长度
                 precision: 小数点后的精度
                 scale:    有效位数
                 insert(一般不用): 该属性是否加入insert语句.
                 update(一般不用): 该属性是否加入update语句.
                 not-null : 指定属性的约束是否使用 非空
                 unique : 指定属性的约束是否使用 唯一
                 type: 表达该属性的类型，可以用三种方式指定属性
                     Ⅰ: java类型 java.lang.String
                     Ⅱ: 数据库类型指定 varchar
                     Ⅲ: Hibernate类型指定 string
         -->
         <property name="userName" column="UserName" type="string"/>
         <property name="passWord" column="PassWord" type="string"/>
         <property name="enabled" column="Enabled" type="int"/>
     </class>

 </hibernate-mapping>

添加了注解的实体类（推荐）启动此种方式需要在Hibernate配置文件中启动

62         <!-- Names the annotated entity class -->
63         <!--<mapping class="cn.coreqi.entities.Users"/>-->

 package cn.coreqi.entities;

 import org.hibernate.annotations.GenericGenerator;
 import javax.persistence.*;
 import java.io.Serializable;

 @Entity
 @Table(name = "users")
 public class Users implements Serializable {

     @Id
     @GeneratedValue(generator="diy")
     @GenericGenerator(name="diy", strategy = "identity")
     private Integer Id;
     @Column
     private String UserName;
     @Column
     private String PassWord;
     @Column
     private Integer Enabled;

     public Integer getId() {
         return Id;
     }

     public Users() {
     }

     public void setId(Integer id) {
         Id = id;
     }

     public String getUserName() {
         return UserName;
     }

     public void setUserName(String userName) {
         UserName = userName;
     }

     public String getPassWord() {
         return PassWord;
     }

     public void setPassWord(String passWord) {
         PassWord = passWord;
     }

     public Integer getEnabled() {
         return Enabled;
     }

     public void setEnabled(Integer enabled) {
         Enabled = enabled;
     }

     @Override
     public String toString() {
         return "Users{" +
                 "Id=" + Id +
                 ", UserName='" + UserName + '\'' +
                 ", PassWord='" + PassWord + '\'' +
                 ", Enabled=" + Enabled +
                 '}';
     }
 }

（4）编写dao文件

 package cn.coreqi.dao.hibernate;

 import cn.coreqi.entities.Users;
 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.boot.MetadataSources;
 import org.hibernate.boot.cfgxml.spi.LoadedConfig;
 import org.hibernate.boot.registry.StandardServiceRegistry;
 import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
 import org.hibernate.cfg.Configuration;
 import org.springframework.stereotype.Repository;

 import java.io.File;

 @Repository
 public class UsersHibernate {
     //private SessionFactory sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
     private final StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();
     private SessionFactory sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
     public void addUsers(){
         Session session = sessionFactory.openSession();
         Transaction ts = session.beginTransaction();
         Users users = new Users();
         users.setUserName("gaoxing");
         users.setPassWord("mmmmm");
         users.setEnabled(1);
         session.save(users);
         ts.commit();
         session.close();
     }
 }