Hibernate 是个 ORM 框架，干的事就一句话：把 Java 对象和数据库表对应起来，让你操作对象就等于操作数据库，SQL 它帮你生成。

现在新项目基本上 MyBatis、JPA 当道，Hibernate 的 XML 配置玩法已经不常见了。但理解这套最早期的配置方式，对搞懂 ORM 到底在替我们做什么，挺有帮助。

这篇用最原始的 XML 配置（不是 SpringBoot 那种一键装配）走一遍 Hibernate 入门，重点是看清它需要哪些关键配置。

Hibernate 是干嘛的

它对 JDBC 做了一层很轻的对象化封装。

你平时写 JDBC 要自己拼 SQL、自己把 ResultSet 一列列读出来塞进对象，繁琐又容易错。

Hibernate 把这层包了：你把 POJO 类和数据库表的映射关系告诉它，它就能自动生成 SQL，自动把查出来的数据填进对象。

好处是关系清晰、代码简洁，操作数据库像操作普通对象一样自然。

国际惯例，先导包（这步略过）。本文全程用最早期的 XML 配置形式，就为了把配置项一个个看明白。

主配置文件

Hibernate 要跑起来，第一个要有的就是主配置文件 hibernate.cfg.xml，里面写数据库连接信息。

这里以 Oracle 为例：

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
  "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- 数据库方言：告诉 Hibernate 按哪种数据库的语法生成 SQL -->
        <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
        <!-- 连接地址 -->
        <property name="connection.url">jdbc:oracle:thin:@10.10.10.10:1521:Sobest</property>
        <!-- 用户名 -->
        <property name="connection.username">mebugs</property>
        <!-- 密码（真实项目别明文写，走加密或外部注入） -->
        <property name="connection.password">mebugs</property>
        <!-- JDBC 驱动类 -->
        <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>

        <!-- 以下是可选项，但很常用 -->
        <!-- 自动提交：不开的话有时候 insert 完数据库里查不到 -->
        <property name="connection.autocommit">true</property>
        <!-- session 上下文策略：JDBC 单应用用 thread，Web 容器里用 jta -->
        <property name="current_session_context_class">thread</property>
        <!-- 格式化打印 SQL，调试时好看 -->
        <property name="format_sql">true</property>
        <!-- 把生成的 SQL 打到控制台，学习阶段强烈建议开 -->
        <property name="show_sql">true</property>

        <!-- 挂上映射文件，可以挂多个 -->
        <mapping resource="com/mebugs/daoBean/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>
​

这里面最该记住的是 dialect（方言）：换数据库主要就是换它和驱动，Hibernate 靠方言决定生成什么风格的 SQL，这也是它号称跨数据库的底气。

另外学习阶段一定把 show_sql 打开，能看见它到底帮你生成了什么 SQL，ORM 就不再是黑盒了。

实体类

接着是一个普通的 POJO，用来跟表映射：

public class User {
    private int id;
    // 简单起见只放一个业务属性
    private String username;

    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; }
}
​

就是个普通类，带 getter/setter，没任何注解——因为这版映射关系全写在 XML 里。

映射文件

映射文件 User.hbm.xml，告诉 Hibernate 这个类的哪个属性对应表的哪一列。按惯例放在实体类同目录：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- package 写上，下面类名就不用写全限定名了 -->
<hibernate-mapping package="com.mebugs.daoBean">
    <!-- class 的 name 是类名，table 是对应的表名 -->
    <class name="User" table="user">
        <!-- id 标签声明主键：name 是属性名，column 是表的列名 -->
        <id name="id" type="int" column="id">
            <!-- 主键生成策略，下面细说 -->
            <generator class="identity"></generator>
        </id>
        <!-- 普通字段映射 -->
        <!-- type 建议直接写 java.lang.String，效率更高 -->
        <!-- 因为 Hibernate 自己的类型最终也要转成 Java 类型再去匹配列类型 -->
        <property name="username" type="java.lang.String" column="name"></property>
    </class>
</hibernate-mapping>
​

有个小细节：property 的 type 建议直接写成 java.lang.String 这种 Java 全类型，比写 Hibernate 的简写类型（如 string）略快，因为省了一道类型转换的查找。

主键生成策略

<generator> 这块值得单独说，它决定主键怎么生成。常见的几种：

• identity：交给数据库自增（MySQL、SQL Server 这类支持自增的），主键必须是数值类型。最常用。
• sequence：依赖数据库的序列（Oracle 常用）。
• increment：Hibernate 自己每次加 1。多线程下有并发风险，容易撞主键，别在多应用环境用。
• native：让 Hibernate 看数据库类型自动在 identity / sequence / hilo 里选一个。适合跨数据库。
• uuid：生成 128 位的唯一字符串做主键，跨库适应性最好，插入性能也好，但主键得是 String 类型。
• assigned：主键由你代码自己指定，Hibernate 不管。类型不限。
• hilo / foreign：前者用高低位算法另开表存状态，后者用在一对一关系里借别人的主键。用得较少。

挑的时候就看数据库：MySQL 用 identity，Oracle 用 sequence，想跨库用 native 或 uuid。

跑一遍 CRUD

配置和映射都齐了，写段代码把它跑起来，感受一下操作对象即操作数据库：

// 1. 读配置，构建配置对象
Configuration conf = new Configuration();
conf.configure("hibernate.cfg.xml");

// 2. 建会话工厂（重量级对象，整个应用建一个就够，别反复 new）
SessionFactory sf = conf.buildSessionFactory();

// 3. 开一个 session（轻量，用完即关）
Session session = sf.openSession();

// 4. 开启事务
session.beginTransaction();

// 5. 存一个对象，等价于一条 insert
User user = new User();
user.setUsername("mebugs");
// 持久化相关方法：save/update/saveOrUpdate/delete 分别对应增改删
session.save(user);

// 6. 提交事务（rollback 回滚，wasCommitted 检查是否已提交）
session.getTransaction().commit();

// 7. 收尾，关 session 和工厂
session.close();
sf.close();
​

整段看下来，我们从头到尾没碰一行 SQL，session.save(user) 就把插入干完了——这就是 ORM 要给你的体验。

实际项目里，第 1~2 步（读配置建工厂）会抽成一个工具类，全局复用一个 SessionFactory，别每次操作都重建，那玩意儿贵。

小结

Hibernate 入门就三样东西：主配置 hibernate.cfg.xml 管连接和方言，映射文件 .hbm.xml 管类和表的对应，再加 Configuration → SessionFactory → Session 这条调用链执行增删改查。

主键生成策略按数据库挑，MySQL 用 identity，Oracle 用 sequence，跨库用 native 或 uuid。

学习阶段务必开 show_sql，盯着它生成的 SQL 看，ORM 的"魔法"就都现原形了。

这版是最原始的 XML 配置，理解它之后，再去看注解版、SpringBoot 装配版，会轻松很多。