跳到主要内容
版本：V1.0.0

Hibernate 连接 seekdb 示例程序

本文将介绍如何使用 Hibernate 框架和 seekdb 构建一个应用程序，实现创建表、插入数据和查询数据等基本操作。

点击下载 java-oceanbase-hibernate 示例工程

前提条件​

  • 您已安装 seekdb。

  • 您已安装 JDK 1.8 和 Maven。

  • 您已安装 IntelliJ IDEA。

    信息

    本文档运行代码使用的工具是 IntelliJ IDEA 2021.3.2 (Community Edition) 版本，您也可以根据个人喜好选择适合自己的工具运行示例代码。

操作步骤​

信息

本文中给出的操作步骤是基于 Windows 环境生成。如果您使用的是其他操作系统环境或编译器，那么操作步骤可能会略有不同。

  1. 获取 seekdb 连接串。
  2. 导入 java-oceanbase-hibernate 项目到 IDEA 中。
  3. 修改 java-oceanbase-hibernate 项目中的数据库连接信息。
  4. 运行 java-oceanbase-hibernate 项目。

步骤一：获取 seekdb 连接串​

  1. 联系 seekdb 部署人员或者管理员获取相应的数据库连接串。

    mysql -hxx.xx.xx.xx -P2881 -uroot -p**** -A

  2. 根据已部署的 seekdb 填写下面 URL 的对应信息。

    信息

    在 hibernate.cfg.xml 文件中需要这里的 URL 信息。

    jdbc:oceanbase://host:port/schema_name?user=$user_name&password=$password

    参数说明：

    • host：提供 seekdb 的连接 IP。使用实际的 IP 替换，也可以使用本地 IP 及 127.0.0.1。
    • port：提供 seekdb 接端口。使用实际的端口替换，默认是 2881，在部署 seekdb 时可自定义。
    • schema_name：需要访问的 Schema 名称。
    • user_name：通过 -u 参数指定，格式为 用户。默认用户为 root。
    • password：提供账户密码。

更多 URL 参数说明信息，请参见 数据库 URL。

步骤二：将导入 java-oceanbase-hibernate 项目到 IDEA 中​

  1. 打开 IntelliJ IDEA，选择 File > Open... 选项。

    file

  2. 在弹出的 Open File or Project 窗口中，选择对应的项目文件，单击 OK 完成项目文件导入。

  3. IntelliJ IDEA 将会自动识别项目中的各类文件，并在 Project 工具窗口中，可以查看项目的目录结构、文件列表、模块列表、依赖关系等信息。Project 工具窗口通常位于 IntelliJ IDEA 界面的最左侧，默认情况下是打开的。如果 Project 工具窗口被关闭了，可以通过点击菜单栏中的 View > Tool Windows > Project 或者使用快捷键 Alt + 1 来重新打开它。

    信息

    当使用 IntelliJ IDEA 导入项目时，IntelliJ IDEA 会自动检测项目中的 pom.xml 文件，并根据文件中描述的依赖关系自动下载所需的依赖库，并将它们添加到项目中。

  4. 查看项目情况。

hibernate

步骤三：修改 java-oceanbase-hibernate 项目中的数据库连接信息​

根据 步骤一：获取 seekdb 连接串 中的信息修改 hibernate.cfg.xml 文件中的数据库连接信息。

提示

如果需要添加 JDBC 连接串的额外属性信息，请参见 数据库 URL。

示例如下：

  • 数据库驱动的名称为：com.mysql.cj.jdbc.Driver
  • seekdb 的 IP 地址为 172.30.xxx.xxx。
  • 访问端口使用的是 2881。
  • 需要访问的 Schema 名称为 test。
  • 连接账户是 root。
  • 密码是 ******。

示例代码如下：

<property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://172.30.xxx.xxx:2881/test</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">******</property>

步骤四：运行 java-oceanbase-hibernate 项目​

运行路径​

  1. 在项目结构中找到 src > test > java 中找到 TestHibernate.java 文件。
  2. 在工具菜单栏中选择 运行(U) > 运行 > TestHibernate，或直接单击右上角绿色三角形运行。
  3. 通过 IDEA 的控制台来查看项目的日志信息和输出结果。

运行结果​

User{id=2, name='update'}
User{id=3, name='user_insert3'}
User{id=4, name='user_insert4'}
User{id=5, name='user_insert5'}

常见问题​

1. 连接超时​

如果遇到连接超时问题，可以在 JDBC URL 中配置连接超时参数：

jdbc:mysql://host:port/database?connectTimeout=30000&socketTimeout=60000

2. 字符集问题​

为确保正确的字符编码，在 JDBC URL 中设置正确的字符集参数：

jdbc:mysql://host:port/database?characterEncoding=utf8&useUnicode=true

3. SSL 连接​

要启用与 seekdb 的 SSL 连接，在 JDBC URL 中添加以下参数：

jdbc:mysql://host:port/database?useSSL=true&requireSSL=true

4. 账号密码中的特殊字符​

如果用户名或密码包含特殊字符（如 #），需要进行 URL 编码：

String encodedPassword = URLEncoder.encode(password, "UTF-8");
提示

使用 MySQL Connector/J 8.x 时，确保账号密码不包含井号(#)。否则，可能会遇到连接错误。

项目代码介绍​

点击 java-oceanbase-hibernate 下载项目代码，这是一个名为 java-oceanbase-hibernate.zip 的压缩包。

解压后，得到一个名为 java-oceanbase-hibernate 的文件夹。目录结构如下所示：

│--pom.xml
│
├─.idea
├─src
│  ├─main
│  │  ├─java
│  │  │  └─com
│  │  │      └─oceanbase
│  │  │          ├─dao
│  │  │          │   └─--UserDao.java
│  │  │          │
│  │  │          └─pojo
│  │  │              └─--User.java
│  │  │
│  │  └─resources
│  │      │--hibernate.cfg.xml
│  │      │
│  │      └─com
│  │          └─oceanbase
│  │              └─pojo
│  │                  └─--User.hbm.xml
│  │
│  └─test
│      └─java
│          └─--TestHibernate.java
│
└─target

文件说明：

  • pom.xml：Maven 项目的配置文件，包含了项目的依赖、插件、构建等信息。
  • .idea：IDE（集成开发环境）中使用的目录，用于存储项目相关的配置信息。
  • src：通常用于表示项目中存放源代码的目录。
  • main: 存放主要的源代码和资源文件的目录。
  • java: 存放 Java 源代码的目录。
  • com: 存放 Java 包的根目录。
  • oceanbase: 存放项目的根目录。
  • dao: 存放数据访问对象（Data Access Object）包，用于访问数据库或其他数据存储服务。
  • UserDao.java：用户数据访问对象，用于操作用户数据的增删改查等操作。
  • User.java：用户持久化对象，用于映射用户数据表的字段。
  • pojo: 持久化对象（Plain Old Java Object），存放与数据库表对应的 Java 类。用于映射数据库表或其他数据存储结构。
  • resources: 存放资源文件的目录，如配置文件、SQL 文件等。
  • hibernate.cfg.xml: 存放 Hibernate 的配置文件，用于配置 Hibernate 的基本参数和设置数据源等信息。
  • User.hbm.xml: 存放用户持久化对象的映射文件，用于定义用户持久化对象和用户数据表之间的映射关系。
  • test: 存放测试代码和资源文件的目录。
  • TestHibernate.java: 存放测试 Hibernate 的 Java 类。
  • target: 存放编译后的 Class 文件、Jar 包等文件的目录。

pom.xml 代码介绍​

提示

如果您只是想验证示例，那么请使用默认代码，无需修改。您也可以按照以下讲解，根据自己的需求修改 pom.xml 文件。

pom.xml 配置文件内容如下：

  1. 文件声明语句。

    声明本文件是一个 XML 文件，使用的 XML 版本是 1.0，字符编码方式是 UTF-8。

    代码如下：

    <?xml version="1.0" encoding="UTF-8"?>

  2. 配置 POM 的命名空间和 POM 模型版本。

    1. 通过 xmlns 指定 POM 的命名空间为 http://maven.apache.org/POM/4.0.0。
    2. 通过 xmlns:xsi 指定 XML 命名空间为 http://www.w3.org/2001/XMLSchema-instance。
    3. 通过 xsi:schemaLocation 指定 POM 的命名空间为 http://maven.apache.org/POM/4.0.0，并指定 POM 的 XSD 文件的位置为 http://maven.apache.org/xsd/maven-4.0.0.xsd。
    4. 通过 <modelVersion> 元素指定该 POM 文件使用的 POM 模型版本为 4.0.0。

    代码如下：

    <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
    </project>

  3. 基本信息配置。

    1. 通过 <groupId> 指定项目标识为 com.oceanbase。
    2. 通过 <artifactId> 指定项目依赖为 java-oceanbase-hibernate。
    3. 通过 <version> 项目的版本号为 1.0-SNAPSHOT。

    代码如下：

     <groupId>com.oceanbase</groupId>
     <artifactId>java-oceanbase-hibernate</artifactId>
     <version>1.0-SNAPSHOT</version>

  4. 通过 <build> 定义项目的构建过程。

    1. 通过 <plugins> 指定项目中配置的插件。
    2. 通过 <plugin> 指定项目中配置一个插件。
    3. 通过 <groupId> 指定项目标识为 org.apache.maven.plugins。
    4. 通过 <artifactId> 指定项目依赖为 maven-compiler-plugin。
    5. 通过 <configuration> 指定配置的插件的参数。
    6. 通过 <source> 指定编译器的源代码版本为 8。
    7. 通过 <target> 指定编译器的源代码版本为 8。

    代码如下：

     <build>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <configuration>
                     <source>8</source>
                     <target>8</target>
                 </configuration>
             </plugin>
         </plugins>
     </build>

  5. 通过 <dependencies> 定义项目所依赖组件。

    1. 指定依赖项所属的组织为 com.oceanbase，名称为 oceanbase-client，版本号为 2.4.2。

      代码如下：

          <dependencies>
          <dependency>
              <groupId>com.oceanbase</groupId>
              <artifactId>oceanbase-client</artifactId>
              <version>2.4.2</version>
          </dependency>
          </dependencies>

    2. 指定依赖项所属测试架构为 junit，名称为 junit，版本号为 4.13。

      代码如下：

          <dependencies>
          <dependency>
              <groupId>junit</groupId>
              <artifactId>junit</artifactId>
              <version>4.13</version>
          </dependency>
          </dependencies>

    3. 指定依赖项所属架构为 org.hibernate，核心库为 hibernate-core，版本号为 5.2.17.Final。

      代码如下：

      <dependencies>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.2.17.Final</version>
        </dependency>
      </dependencies>

    4. 指定依赖项所属架构为 org.hibernate，数据源库为 hibernate-c3p0，版本号为 5.2.17.Final。

      代码如下：

      <dependencies>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>5.2.17.Final</version>
        </dependency>
      </dependencies>

User.hbm.xml 代码介绍​

User.hbm.xml 文件是一个 Hibernate 的映射文件，用于将 Java 对象映射到数据库中的表。

User.hbm.xml 文件的代码主要包括以下几个部分：

  1. 文件声明语句。

    声明本文件是一个 XML 文件，使用的 XML 版本是 1.0，字符编码方式是 UTF-8。同时指定了 Hibernate 映射文件的 DTD 版本和位置，指定 DTD 文档类型为 hibernate-mapping，版本为 3.0，语言为 EN，文件所在的 URL 为 http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd

    代码如下：

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

  2. 配置映射文件。

    定义一个 Hibernate 映射文件，将名为 User 的实体类映射到名为 test_hibernate_mysql 的数据库表。

    1. 通过 package 属性指定映射文件中的 Java 包为 com.oceanbase.pojo。
    2. 通过 class 标签映射数据表中的数据，name 属性指定 Java 类名为 User，table 属性指定数据库表名为 test_hibernate_mysql。
    3. 通过 id 定义主键属性，name 属性指定 Java 类 User 的成员变量为 id，column 属性指定数据库字段名称为 USER_ID。
    4. 通过 generator 定义主键生成策略，class 属性指定主键生成器的类型为 sequence，param 元素指定数据库中的序列名称为 SQ_USER，name 属性指定该属性对应数据库表中的 USER_NAME 列，并指定该属性的数据类型为字符串。

    代码如下：

    <hibernate-mapping package="com.oceanbase.pojo">
    <class name="User" table="test_hibernate_mysql">
        <!-- Configure primary key generation strategy -->
        <id name="id" column="USER_ID">
            <generator class="sequence">
                <param name="sequence">SQ_USER</param>
            </generator>
        </id>
        <!-- Configuration Tables and Properties -->
        <property name="name" column="USER_NAME" type="string"/>
    </class>
    </hibernate-mapping>

hibernate.cfg.xml 代码介绍​

hibernate.cfg.xml 文件是一个 Hibernate 的配置文件，用于配置 Hibernate 的运行环境和连接数据库的参数。

hibernate.cfg.xml 文件的代码主要包括以下几个部分：

  1. 文件声明语句。

    声明本文件是一个 XML 文件，使用的 XML 版本是 1.0，字符编码方式是 UTF-8。同时指定了 Hibernate 配置文件的 DTD 版本和位置，指定 DTD 文档类型为 hibernate-configuration，版本为 3.0，语言为 EN，文件所在的 URL 为 http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd

    代码如下：

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

  2. 配置 configuration 参数。

    <hibernate-configuration> 根目录元素中通过 <session-factory> 元素设置 Hibernate 的会话工厂，用于创建和管理会话对象。会话工厂包括了连接数据库的驱动程序类名、URL、用户名和密码，连接池的相关参数，数据库方言、SQL 输出和格式化、自动创建数据库表、当前会话上下文、批量处理和二级缓存等配置。

    1. 配置数据库信息。

      配置 Hibernate 与连接数据库的参数，包括了连接数据库的驱动程序类名、URL、用户名和密码。

      • 通过 hibernate.connection.driver_class 指定数据库驱动程序为 com.mysql.cj.jdbc.Driver，用于与 seekdb 建立连接。
      • 通过 hibernate.connection.url 元素指定数据库的 URL，包括数据库的地址、端口号、数据库名称等信息。
      • 通过 hibernate.connection.username 元素指定连接数据库的用户名。
      • 通过 hibernate.connection.password 元素指定连接数据库的密码。

      代码如下：

          <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
          <property name="hibernate.connection.url">jdbc:oceanbase://host:port/schema_name</property>
          <property name="hibernate.connection.username">user_name</property>
          <property name="hibernate.connection.password">******</property>

    2. 配置连接池信息。

      配置 Hibernate 使用的连接池的相关参数。指定连接池为 C3P0，参数的设置包括连接池的最大和最小连接数、超时时间、连接的最大空闲时间、缓存的 Statement 对象数量、连接的空闲测试时间、一次性获取的连接数以及连接的验证方式。

      信息

      以下参数仅供参考，并非完整支持的参数列表，若需要配置其他参数，请参考相关文档以获取更详细的参数信息。

      • 通过 hibernate.connection.provider_class 指定连接池为 C3P0，用于管理数据库连接的创建和释放。
      • 通过 hibernate.c3p0.max_size 指定连接池的最大连接数为 60。
      • 通过 hibernate.c3p0.min_size 指定连接池的最小连接数为 30。
      • 通过 hibernate.c3p0.checkoutTimeout 指定连接池获取连接的超时时间为 30000 毫秒。
      • 通过 hibernate.c3p0.timeout 指定连接池的最大空闲时间为 2000 毫秒，超过该时间将被关闭。
      • 通过 hibernate.c3p0.max_statements 指定连接池中缓存的最大 SQL 语句数为 100 条。
      • 通过 hibernate.c3p0.idle_test_period 指定连接池中空闲连接的检测周期为 3000 毫秒。
      • 通过 hibernate.c3p0.acquire_increment 指定连接池动态增长时的连接数增量为 3 条。
      • 通过 hibernate.c3p0.validate 指定连接池连接时验证为 true。

      代码如下：

      <property name="hibernate.connection.provider_class">org.hibernate.c3p0.internal.C3P0ConnectionProvider</property>
      <property name="hibernate.c3p0.max_size">60</property>
      <property name="hibernate.c3p0.min_size">30</property>
      <property name="hibernate.c3p0.checkoutTimeout">30000</property>
      <property name="hibernate.c3p0.timeout">20000</property>
      <property name="hibernate.c3p0.max_statements">100</property>
      <property name="hibernate.c3p0.idle_test_period">3000</property>
      <property name="hibernate.c3p0.acquire_increment">3</property>
      <property name="hibernate.c3p0.validate">true</property>

    3. 配置 SQL 交互信息。 配置 Hibernate 与数据库连接的相关信息。包括数据库方言、SQL打印和格式化、表的自动创建、当前会话上下文、批处理大小、缓存使用以及加载映射文件。

      • 通过 dialect 指定使用的数据库方言为 MySQL 5.7，用于以确保与特定数据库的兼容性。
      • 通过 hibernate.show_sql 设置是否在控制台上打印 Hibernate 生成的 SQL 语句。
      • 通过 hibernate.format_sql 设置是否格式化打印的 SQL 语句。
      • 通过 hbm2ddl.auto 设置自动创建表格。
      • 通过 current_session_context_class 指定使用线程级别的当前会话上下文。
      • 通过 hibernate.jdbc.batch_size 设置批处理的大小。
      • 通过 hibernate.cache.use_second_level_cache 设置是否启用二级缓存。
      • 指定加载映射文件为 com/oceanbase/pojo/User.hbm.xml。

      代码如下：

        <property name="dialect">org.hibernate.dialect.MySQL57Dialect</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <property name="hbm2ddl.auto">create</property>
        <property name="current_session_context_class">thread</property>
        <property name="hibernate.jdbc.batch_size">10</property>
        <property name="hibernate.cache.use_second_level_cache">false</property>
        <mapping resource="com/oceanbase/pojo/User.hbm.xml"/>

UserDao.java 代码介绍​

UserDao.java 文件通过用户数据访问对象（DAO）类，使用 Session 对象实现了用户数据的增删改查操作。

UserDao.java 文件的代码主要包括以下几个部分：

  1. 引用其他类和接口。

    声明当前文件包含以下接口和类：

    • User 类：用于操作用户对象。
    • Session 类：用于与数据库进行交互。
    • SessionFactory 类：用于创建 Session 实例。
    • Transaction 类：用于管理数据库事务。
    • Configuration 类：用于加载 Hibernate 的配置文件。
    • Query 类：用于执行查询操作。
    • List 接口：用于操作查询结果集合。

    代码如下：

    import com.oceanbase.pojo.User;
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.hibernate.cfg.Configuration;
    import org.hibernate.query.Query;
    import java.util.List;

  2. 定义 UserDao 类。

通过为 UserDao 的 Java 类，作为数据访问对象，用于对用户对象进行持久化操作。该类封装了一系列与数据库交互相关的方法，对用户对象进行增删改查等操作。通过调用 UserDao 类中的方法，可以方便地与数据库进行交互，实现持久化操作。

  1. 对 UserDao 类实例进行初始化操作。

    使用对象初始化块的方式，在类的实例化过程中初始化 Session 对象。

    首先创建一个 Configuration 对象，并调用 configure 方法来读取 Hibernate 的配置文件（hibernate.cfg.xml）。然后，通过调用 buildSessionFactory 方法创建一个 SessionFactory 对象。最后，通过调用 openSession 方法创建一个 Session 对象，并将其赋值给 session 变量。

    代码如下：

    private Session session;
    {
        Configuration cfg = new Configuration().configure();
        // Create SessionFactory
        SessionFactory sessionFactory = cfg.buildSessionFactory();
        session = sessionFactory.openSession();
    } //Read the hibernate.cfg.xml file

  2. 设定 ID 查询对应的用户信息。

    通过 selectUserById 方法，提供的 ID 参数查询对应的用户信息。

    使用 session 的 get 方法，通过传入的 User.class 和 ID 参数，从数据库中获取对应 ID 的 User 记录，并将其存储在 user 变量中。

    代码如下：

    public User selectUserById(int ID) {
        User user = session.get(User.class, ID);
        return user;
    }

  3. 根据用户名查询用户信息。

    通过 selectUserbyName 方法，根据用户名查询用户信息。 首先定义 HQL（Hibernate Query Language）语句，用于查询指定名称的用户数据。其中表名为 test_hibernate_mysql，表别名为 u，查询字段名为 name。通过使用 Session 对象的 createQuery 方法创建一个 Query 对象，并将 HQL 语句和实体类作为参数传入。使用 Query 对象的 setParameter 方法设置查询参数，其中 0 表示参数的位置，name 表示参数的值。使用 Query 对象的 list 方法执行查询，并将查询结果转换为 User 对象列表。

    代码如下：

    public List<User> selectUserbyName(String name) {
      String sql = "FROM test_hibernate_mysql u WHERE u.name =?";
      Query<User> query = session.createQuery(sql, User.class);
      query.setParameter(0, name);
      List<User> users = query.list();
      return users;
    }

  4. 查询所有用户数据。

    通过 selectUser 方法，实现了查询所有用户数据的方法。 定义一个 SQL 语句，用于查询所有用户数据。使用 Session 对象的 createNativeQuery 方法创建一个 Query 对象，并将 SQL 语句作为参数传入。然后，使用 addEntity 方法将实体类 User 添加到查询中，以便将查询结果转换为 User 对象列表。使用 Query 对象的 getResultList 方法执行查询，并将查询结果转换为 User 对象列表。

    代码如下：

    public List<User> selectUser() {
        String sql = "SELECT * FROM test_hibernate_mysql";
        Query<User> query = session.createNativeQuery(sql).addEntity(User.class);
        List<User> users = query.getResultList();
        return users;
    }

  5. 插入用户数据。

    通过 insertUser 方法，插入用户信息。 指定一个 User 类型的参数 user，用于传入要插入的用户对象。通过调用 Hibernate Session 的 beginTransaction 方法创建一个事务对象，并将其保存在变量 beginTransaction 中。使用 save 方法将用户对象保存到数据库中。通过调用 Session 的 getTransaction 方法获取当前事务，并调用 commit 方法提交事务，将之前的操作持久化到数据库，并返回插入操作的结果。

    代码如下：

    public int insertUser(User user) {
        // open transaction
        Transaction beginTransaction = session.beginTransaction();
        session.save(user);
        session.getTransaction().commit();
        return 1;
    }

  6. 删除用户数据。

    通过 deleteUserById 方法，从数据库中删除传入的 ID 所对应的用户记录。 指定一个整型参数 id，用于传入要删除的用户 ID。通过调用 Hibernate Session 的 beginTransaction 方法开始一个新的事务。使用 get 方法根据指定的用户 ID 和实体类类型（User.class）获取对应的用户对象。使用 delete 方法删除用户对象。通过调用 Session 的 getTransaction 方法获取当前事务，并调用 commit 方法提交事务，删除用户信息持久化到数据库，并返回删除操作的结果。

    代码如下：

    public int deleteUserById(int id) {
        // open transaction
        session.beginTransaction();
        User user = session.get(User.class, id);
        session.delete(user);
        session.getTransaction().commit();
        return 1;
    }

  7. 修改用户数据。

    通过 updateUserById 方法，更新对应的用户信息。 指定一个 User 类型的参数 user，用于指定要更新的用户数据。使用 Session 对象的 beginTransaction 方法开启一个事务。使用 Session 对象的 get 方法根据用户 ID 获取对应的 User 对象。使用 Session 对象的 merge 方法将传入的 User 对象与获取到的 User 对象进行合并，将传入的用户数据更新到数据库中。使用 Session 对象的 getTransaction 方法获取当前事务，并调用 commit 方法提交事务，并返回修改操作的结果。

    代码如下：

    public int updateUserById(User user) {
        // open transaction
        session.beginTransaction();
        User user1 = session.get(User.class, user.getId());
        session.merge(user);
        session.getTransaction().commit();
        return 1;
    }

User.java 代码介绍​

User.java 文件通过用户数据访问对象（DAO）类，通过 Session 对象实现了用户数据的增删改查操作。

User.java 文件的代码主要包括以下几个部分：

  1. 引用其他类。

    声明当前文件使用 JPA 注解配置了相关类与数据库表的映射关系：

    • Column 注解：用于标识实体类中的属性与数据库表中的列的对应关系。
    • Entity 注解：用于映射数据库中的表。
    • GeneratedValue 注解：用于表示该属性的值是自动生成的。
    • GenerationType 注解：用于指定主键生成策略。
    • Id 注解：用于指定唯一标识属性。
    • Table 注解：用于表示实体类对应的表名。

    代码如下：

    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.Table;

  2. 映射数据库中的表。

    映射数据库表的实体类，并指定实体类对应的表名为 test_hibernate_mysql。

    代码如下：

    @Entity
    @Table(name = "test_hibernate_mysql")

  3. 定义 User 类。

    用于与数据库中的一个名为 test_hibernate_mysql 的表格进行映射。

    1. 定义两个属性 id 和 name。 使用注解标识了 User 类中的 id 和 name 属性与数据库表中的列的对应关系。 通过 @Id 注解标识 id 属性为主键，@GeneratedValue 注解指定了主键的生成策略为序列，@Column 注解指定了属性与数据库表中的列的映射关系。id 属性用于存储用户 ID，name 属性用于存储用户名。

      代码如下：

      @Id
      @GeneratedValue(strategy = GenerationType.SEQUENCE)
      @Column(name = "user_id")
      private int id;

      @Column(name = "user_name")
      private String name;

    2. 创建 User 对象。

      定义 User 类的两个构造方法，用于创建 User 对象。 定义一个无参构造方法用于 Hibernate 查询操作。定义了一个有参构造方法，用于初始化 id 和 name 属性。

      代码如下：

      public User() {
      }

      public User(int id, String name) {
          this.id = id;
          this.name = name;
      }

    3. 获取和设置 id 和 name 值。

      定义 User 类中的四个方法，用于获取和设置 id 和 name 属性的值。 getId 方法，用于获取 id 值，setId 方法，用于设置 id 值。getName 方法，用于获取用户名 name 的值。setName 方法，用于设置用户名 name 的值。

      代码如下：

      public int getId() {
          return id;
      }

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

      public String getName() {
          return name;
      }

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

    4. 返回 User 对象的字符串表示形式。

      重写 User 类中的 toString 方法，用于返回 User 对象的字符串表示形式。 定义 @Override 覆盖父类中的同名方法。定义 toString 方法，用于返回 User 对象的字符串表示形式。通过字符串拼接，将 id 和 name 属性的值格式化为一个字符串，返回给调用者 User。

      代码如下：

      @Override
      public String toString() {
          return "User{" +
                  "id=" + id +
                  ", name='" + name + '\'' +
                  '}';
      }

TestHibernate.java 代码介绍​

TestHibernate.java 文件通过对 UserDao 对象执行插入、删除、更新和查询操作，展示 Hibernate 的基本数据库操作功能。

TestHibernate.java 文件的代码主要包括以下几个部分：

  1. 引用其他类和接口。

    声明当前文件相关的类和接口，包括 UserDao、User、Session、SessionFactory、Configuration 等。

    • UserDao 类：用于执行与用户相关的数据库操作。
    • User 类：用于操作用户对象。
    • Session 类：用于与数据库进行会话操作。
    • SessionFactory 类：用于创建 Session 对象。
    • Configuration 类：用于配置 Hibernate。
    • SessionImpl 类：用于获取底层的 JDBC 连接。
    • Test 注解：用于标记测试方法。
    • IOException 类：用于处理 IO 异常。
    • Connection 类：用于获取 JDBC 连接。
    • SQLException 类：用于处理 SQL 异常。
    • List 类：用于存储查询结果集。
    • UUID 类：用于生成唯一标识符。

    代码如下：

    import com.oceanbase.dao.UserDao;
    import com.oceanbase.pojo.User;
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.cfg.Configuration;
    import org.hibernate.internal.SessionImpl;
    import org.junit.Test;
    import java.io.IOException;
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.List;
    import java.util.UUID;

  2. 定义 testHibernate 方法。 testHibernate 方法包含了插入、删除、更新和查询等基本操作。 创建 UserDao 对象，循环插入 5 条用户数据。调用 insertUser 方法插入用户数据。调用 deleteUserById 方法删除 id 为 1 的用户数据。调用 updateUserById 方法更新 id 为 2 的用户数据。调用 selectUser 方法查询所有用户数据。遍历查询结果并打印到控制台。

    代码如下：

    public class TestHibernate {
        @Test
        public void testHibernate() throws SQLException, IOException {
            UserDao userDao = new UserDao();
            for (int i = 1; i <= 5; i++) {
                userDao.insertUser(new User(i, "user_insert" + i));
            }
            int deleteUserById = userDao.deleteUserById(1);
            int update = userDao.updateUserById(new User(2, "update"));
            List<User> users = userDao.selectUser();
            users.forEach(System.out::println);
        }
    }

完整的代码展示​

pom.xml​

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.oceanbase</groupId>
    <artifactId>java-oceanbase-hibernate</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.27</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.2.17.Final</version>
        </dependency>
        <!-- Hibernate c3p0 connection pool-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>5.2.17.Final</version>
        </dependency>

    </dependencies>

</project>

User.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.oceanbase.pojo">
    <class name="User" table="test_hibernate_mysql">
        <!-- Configure primary key generation strategy -->
        <id name="id" column="USER_ID">
            <generator class="sequence">
                <param name="sequence">SQ_USER</param>
            </generator>
        </id>
        <!-- Configuration Tables and Properties -->
        <property name="name" column="USER_NAME" type="string"/>
    </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.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://host:port/schema_name</property>
        <property name="hibernate.connection.username">user_name</property>
        <property name="hibernate.connection.password">******</property>
        <property name="hibernate.connection.provider_class">org.hibernate.c3p0.internal.C3P0ConnectionProvider</property>
        <property name="hibernate.c3p0.max_size">60</property>
        <property name="hibernate.c3p0.min_size">30</property>

        <property name="hibernate.c3p0.checkoutTimeout">30000</property>
        <property name="hibernate.c3p0.timeout">20000</property>

        <property name="hibernate.c3p0.max_statements">100</property>
        <property name="hibernate.c3p0.idle_test_period">3000</property>
        <property name="hibernate.c3p0.acquire_increment">3</property>
        <property name="hibernate.c3p0.validate">true</property>

        <property name="dialect">org.hibernate.dialect.MySQL57Dialect</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <property name="hbm2ddl.auto">create</property>
        <property name="current_session_context_class">thread</property>
        <property name="hibernate.jdbc.batch_size">10</property>
        <property name="hibernate.cache.use_second_level_cache">false</property>
        <mapping resource="com/oceanbase/pojo/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

UserDao.java​

package com.oceanbase.dao;

import com.oceanbase.pojo.User;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.Query;

import java.util.List;


public class UserDao {
    private Session session;
    {
        Configuration cfg = new Configuration().configure();
        // Create SessionFactory
        SessionFactory sessionFactory = cfg.buildSessionFactory();
        session = sessionFactory.openSession();
    } //Read the hibernate.cfg.xml file
//    private Session session = HibernateUtil.getSession();

    public User selectUserById(int ID) {
        User user = session.get(User.class, ID);
        return user;
    }

    public List<User> selectUserbyName(String name) {
        String sql = "FROM test_hibernate_mysql u WHERE u.name =?";
        Query<User> query = session.createQuery(sql, User.class);
        query.setParameter(0, name);
        List<User> users = query.list();
        return users;
    }

    public List<User> selectUser() {
        String sql = "SELECT * FROM test_hibernate_mysql";
        Query<User> query = session.createNativeQuery(sql).addEntity(User.class);
        List<User> users = query.getResultList();
        return users;
    }

    public int insertUser(User user) {
        // open transaction
        Transaction beginTransaction = session.beginTransaction();
        session.save(user);
        session.getTransaction().commit();
        return 1;
    }

    public int deleteUserById(int id) {
        // open transaction
        session.beginTransaction();
        User user = session.get(User.class, id);
        session.delete(user);
        session.getTransaction().commit();
        return 1;
    }

    public int updateUserById(User user) {
        // open transaction
        session.beginTransaction();
        User user1 = session.get(User.class, user.getId());
        session.merge(user);
        session.getTransaction().commit();
        return 1;
    }

}

User.java​

package com.oceanbase.pojo;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;


@Entity
@Table(name = "test_hibernate_mysql")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    @Column(name = "user_id")
    private int id;

    @Column(name = "user_name")
    private String name;

    public User() {
    }

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

TestHibernate.java​

import com.oceanbase.dao.UserDao;
import com.oceanbase.pojo.User;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.internal.SessionImpl;
import org.junit.Test;

import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.UUID;


public class TestHibernate {
    @Test
    public void testHibernate() throws SQLException, IOException {
        UserDao userDao = new UserDao();
        for (int i = 1; i <= 5; i++) {
            userDao.insertUser(new User(i, "user_insert" + i));
        }
        int deleteUserById = userDao.deleteUserById(1);
        int update = userDao.updateUserById(new User(2, "update"));
        List<User> users = userDao.selectUser();
        users.forEach(System.out::println);
    }
}

相关文档​

更多 OceanBase Connector/J 的信息，请参见 OceanBase JDBC 驱动程序

Contents

编辑此页