Hibernate 连接 seekdb 示例程序
本文将介绍如何使用 Hibernate 框架和 seekdb 构建一个应用程序，实现创建表、插入数据和查询数据等基本操作。
点击下载 java-oceanbase-hibernate 示例工程
前提条件
-
您已安装 seekdb。
-
您已安装 JDK 1.8 和 Maven。
-
您已安装 IntelliJ IDEA。
信息本文档运行代码使用的工具是 IntelliJ IDEA 2021.3.2 (Community Edition) 版本，您也可以根据个人喜好选择适合自己的工具运行示例代码。
操作步骤
本文中给出的操作步骤是基于 Windows 环境生成。如果您使用的是其他操作系统环境或编译器，那么操作步骤可能会略有不同。
- 获取 seekdb 连接串。
- 导入
java-oceanbase-hibernate项目到 IDEA 中。 - 修改
java-oceanbase-hibernate项目中的数据库连接信息。 - 运行
java-oceanbase-hibernate项目。
步骤一：获取 seekdb 连接串
-
联系 seekdb 部署人员或者管理员获取相应的数据库连接串。
mysql -hxx.xx.xx.xx -P2881 -uroot -p**** -A -
根据已部署的 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 中
-
打开 IntelliJ IDEA，选择 File > Open... 选项。
-
在弹出 的 Open File or Project 窗口中，选择对应的项目文件，单击 OK 完成项目文件导入。
-
IntelliJ IDEA 将会自动识别项目中的各类文件，并在 Project 工具窗口中，可以查看项目的目录结构、文件列表、模块列表、依赖关系等信息。Project 工具窗口通常位于 IntelliJ IDEA 界面的最左侧，默认情况下是打开的。如果 Project 工具窗口被关闭了，可以通过点击菜单栏中的 View > Tool Windows > Project 或者使用快捷键 Alt + 1 来重新打开它。
信息当使用 IntelliJ IDEA 导入项目时，IntelliJ IDEA 会自动检测项目中的 pom.xml 文件，并根据文件中描述的依赖关系自动下载所需的依赖库，并将它们添加到项目中。
-
查看项目情况。
步骤三：修改 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 项目
运行路径
- 在项目结构中找到 src > test > java 中找到
TestHibernate.java文件。 - 在工具菜单栏中选择 运行(U) > 运行 > TestHibernate，或直接单击右上角绿色三角形运行。
- 通过 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 配置文件内容如下：
-
文件声明语句。
声明本文件是一个 XML 文件，使用的 XML 版本是
1.0，字符编码方式是UTF-8。代码如下：
<?xml version="1.0" encoding="UTF-8"?> -
配置 POM 的命名空间和 POM 模型版本。
- 通过
xmlns指定 POM 的命名空间为http://maven.apache.org/POM/4.0.0。 - 通过
xmlns:xsi指定 XML 命名空间为http://www.w3.org/2001/XMLSchema-instance。 - 通过
xsi:schemaLocation指定 POM 的命名空间为http://maven.apache.org/POM/4.0.0，并指定 POM 的 XSD 文件的位置为http://maven.apache.org/xsd/maven-4.0.0.xsd。 - 通过
<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> - 通过
-
基本信息配置。
- 通过
<groupId>指定项目标识为com.oceanbase。 - 通过
<artifactId>指定项目依赖为java-oceanbase-hibernate。 - 通过
<version>项目的版本号为1.0-SNAPSHOT。
代码如下：
<groupId>com.oceanbase</groupId>
<artifactId>java-oceanbase-hibernate</artifactId>
<version>1.0-SNAPSHOT</version> - 通过
-
通过
<build>定义项目的构建过程。- 通过
<plugins>指定项目中配置的插件。 - 通过
<plugin>指定项目中配置一个插件。 - 通过
<groupId>指定项目标识为org.apache.maven.plugins。 - 通过
<artifactId>指定项目依赖为maven-compiler-plugin。 - 通过
<configuration>指定配置的插件的参数。 - 通过
<source>指定编译器的源代码版本为 8。 - 通过
<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> - 通过
-
通过
<dependencies>定义项目所依赖组件。-
指定依赖项所属的组织为
com.oceanbase，名称为oceanbase-client，版本号为2.4.2。代码如下：
<dependencies>
<dependency>
<groupId>com.oceanbase</groupId>
<artifactId>oceanbase-client</artifactId>
<version>2.4.2</version>
</dependency>
</dependencies> -
指定依赖项所属测试架构为
junit，名称为junit，版本号为4.13。代码如下：
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
</dependency>
</dependencies> -
指定依赖项所属架构为
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> -
指定依赖项所属架构为
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 文件的代码主要包括以下几个部分：
-
文件声明语句。
声明本文件是一个 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"> -
配置映射文件。
定义一个 Hibernate 映射文件，将名 为
User的实体类映射到名为test_hibernate_mysql的数据库表。- 通过
package属性指定映射文件中的 Java 包为com.oceanbase.pojo。 - 通过
class标签映射数据表中的数据，name属性指定 Java 类名为User，table属性指定数据库表名为test_hibernate_mysql。 - 通过
id定义主键属性，name属性指定 Java 类User的成员变量为id，column属性指定数据库字段名称为USER_ID。 - 通过
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 文件的代码主要包括以下几个部分：
-
文件声明语句。
声明本文件是一个 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"> -
配置
configuration参数。<hibernate-configuration>根目录元素中通过<session-factory>元素设置 Hibernate 的会话工厂，用于创建和管理会话对象。会话工厂包括了连接数据库的驱动程序类名、URL、用户名和密码，连接池的相关参数，数据库方言、SQL 输出和格式化、自动创建数据库表、当前会话上下文、批量处理和二级缓存等配置。-
配置数据库信息。
配置 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> - 通过
-
配置连接池信息。
配置 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> - 通过
-
配置 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 文件的代码主要包括以下几个部分：
-
引用其他类和接口。
声明当前文件包含以下接口和类：
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; -
定义
UserDao类。
通过为 UserDao 的 Java 类，作为数据访问对象，用于对用户对象进行持久化操作。该类封装了一系列与数据库交互相关的方法，对用户对象进行增删改查等操作。通过调用 UserDao 类中的方法，可以方便地与数据库进行交互，实现持久化操作。
-
对
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 -
设定 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;
} -
根据用户名查询用户信息。
通过
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;
} -
查询所有用户数据。
通过
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;
} -
插入用户数据。
通过
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;
} -
删除用户数据。
通过
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;
} -
修改用户数据。
通过
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 文件的代码主要包括以下几个部分：
-
引用其他类。
声明当前文件使用 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; -
映射数据库中的表。
映射数据库表的实体类，并指定实体类对应的表名为
test_hibernate_mysql。代码如下：
@Entity
@Table(name = "test_hibernate_mysql") -
定义
User类。用于与数据库中的一个名为
test_hibernate_mysql的表格进行映射。-
定义两个属性
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; -
创建
User对象。定义
User类的两个构造方法，用于创建User对象。 定义一个无参构造方法用于 Hibernate 查询操作。定义了一个有参构造方法，用于初始化id和name属性。代码如下：
public User() {
}
public User(int id, String name) {
this.id = id;
this.name = name;
} -
获取和设置
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;
} -
返回
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 文件的代码主要包括以下几个部分：
-
引用其他类和接口。
声明当前文件相关的类和接口，包括
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; -
定义
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 驱动程序