Jfinal 连接 OceanBase 数据库示例程序

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

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

Jfinal 连接 OceanBase 数据库示例程序（Oracle 模式）

前提条件

您已安装 OceanBase 数据库。
您已安装 JDK 1.8 和 Maven。
您已安装 IntelliJ IDEA。

说明

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

操作步骤

说明

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

获取 OceanBase 数据库连接串。
导入 java-oceanbase-Jfinal 项目到 IDEA 中。
搭建 java-oceanbase-Jfinal 项目的 Tomcat 运行环境。
修改 java-oceanbase-Jfinal 项目中的数据库连接信息。
运行 java-oceanbase-Jfinal 项目。

步骤一：获取 OceanBase 数据库连接串

联系 OceanBase 数据库部署人员或者管理员获取相应的数据库连接串。
```
obclient -hxx.xx.xx.xx -P2883 -uroot@sys#cluster -p**** -A
```
根据已部署的 OceanBase 数据库填写下面 URL 的对应信息。

说明

在 config.properties 文件中需要这里的 URL 信息。
```
jdbc:oceanbase://host:port/schema_name?user=$user_name&password=$password
```
参数说明：
- host：提供 OceanBase 数据库连接 IP。ODP 连接的方式是一个 ODP 地址；直连方式是一个 OBServer 节点的 IP 地址。
- port：提供 OceanBase 数据库连接端口。ODP 连接的方式默认是 2883，在部署 ODP 时可自定义；直连方式默认是 2881，在部署 OceanBase 数据库时可自定义。
- schema_name：需要访问的 Schema 名称。
- user_name：提供租户的连接账户。ODP 连接方式的常用格式有两种：用户名@租户名#集群名 或者 集群名:租户名:用户名；直连方式格式：用户名@租户名。
- password：提供账户密码。

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

步骤二：导入 `java-oceanbase-Jfinal` 项目到 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-Jfinal` 项目的 Tomcat 运行环境

下载 Tomcat 8.5.95 版本。在 Apache Tomcat 官网下载 Tomcat 8.5.95 版本的压缩包。解压下载的压缩包到您想要安装 Tomcat 的目录。
在 IDEA 中配置 Tomcat。打开 IntelliJ IDEA，进入 File 菜单，选择 Settings > Plugins。在 Settings 窗口中间的搜索框中搜索 Smart Tomcat，下载后选择 Apply，此时 Settings 窗口左侧最下方跳出 Tomcat Server 页签，进入 Tomcat Server 页签，单击右侧的 + 按钮，选择您解压缩的 Tomcat 目录，单击 Apply 后单击 OK，完成配置。
创建 Tomcat 运行配置。

在 IDEA 的顶部工具栏中，选择 Run > Edit Configurations。在 Run/Debug Configurations 窗口中，单击 + 按钮，选择 Tomcat Server，填写运行服务器名称 Name，在 Configuration 选择框中选择 Tomcat sever 为您安装的版本，修改 Context path 值为 /，填写 SSL port 值为 8080。在 Before launch 选择框中，单击 +，选择 Launch Web Browser。单击 Edit 填写 URL 为 http://localhost:8080/hello/getData。单击 Apply 后单击 OK，完成配置。
运行 Tomcat 服务器。

在 IDEA 的顶部工具栏中，选择您刚刚创建的 Tomcat 运行配置。点击运行按钮绿色三角形启动 Tomcat 服务器。您可以在 IDEA 的 Run 窗口中查看 Tomcat 服务器的启动日志。

步骤四：修改 `java-oceanbase-Jfinal` 项目中的数据库连接信息

根据 步骤一：获取 OceanBase 数据库连接串 中的信息修改 config.properties 文件中的数据库连接信息。

示例如下：

数据库驱动的名称为：com.oceanbase.jdbc.Driver
OBServer 节点的 IP 地址为 10.10.10.1。
访问端口使用的是 2881。
需要访问的 Schema 名称为 sys。
租户的连接账户是 sys@xyoracle。xyoracle 是在 OceanBase 数据库中创建的一个 Oracle 模式的用户租户，sys 是租户 xyoracle 的用户名称。
密码是 ******。

示例代码如下：

db.app.driver=com.oceanbase.jdbc.Driver
db.app.url=jdbc:oceanbase://10.10.10.1:2881/sys
db.app.user=sys@xyoracle
db.app.password=******
db.app.poolInitialSize=3
db.app.poolMaxSize=10
db.app.connectionTimeoutMillis=100
db.app.validationQuery=select 1 from dual

步骤五：运行 `java-oceanbase-Jfinal` 项目

运行路径。

在 IDEA 的顶部工具栏中，选择您刚刚创建的 Tomcat 运行配置。点击运行按钮绿色三角形启动 Tomcat 服务器。在谷歌或 IE 浏览器中打开路径 http://localhost:8080/hello/getData，查看运行结果。

运行结果。

[{"ID":1,"NAME":"John"},{"ID":2,"NAME":"Jane"}]

项目代码介绍

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

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

│--pom.xml
│
├─.idea
│
├─src
│  ├─main
│  │  ├─java
│  │  │  └─com
│  │  │      └─oceanbase
│  │  │          └─testjfinal
│  │  │              ├─config
│  │  │              │   └─UserConfig.java
│  │  │              │
│  │  │              ├─controller
│  │  │              │   └─UserController.java
│  │  │              │
│  │  │              └─pojo
│  │  │                  └─User.java
│  │  │
│  │  ├─resources
│  │  │    └─config.properties
│  │  │    
│  │  └─webapp    
│  │      └─WEB-INF
│  │          └─web.xml
│  │             
│  │                
│  │
│  └─test
│      └─java
│         
│
└─target

文件说明：

pom.xml：Maven 项目的配置文件，包含了项目的依赖、插件、构建等信息。
.idea：IDE（集成开发环境）中使用的目录，用于存储项目相关的配置信息。
src：通常用于表示项目中存放源代码的目录。
main: 存放主要的源代码和资源文件的目录。
java: 存放 Java 源代码的目录。
com: 存放 Java 包的根目录。
oceanbase: 存放项目的根目录。
testjfinal：存放 JFinal 框架的相关代码。
config：配置文件目录，包含应用程序的配置类文件。
UserConfig.java：用户配置类文件。
controller：控制器目录，包含应用程序的控制器类文件。
UserController.java：用户控制器类文件。
pojo: 存放 JavaBean 或实体类。
User.java：存放用户实体类。
resources: 存放资源文件的目录，如配置文件、SQL 文件等。
config.properties: 存放数据库连接信息的配置文件。
webapp：Web 应用程序目录，包含 Web 应用程序的静态资源和配置文件。
WEB-INF：Web 应用程序的 WEB-INF 目录，用于存放配置文件和其他受保护的资源文件。
web.xml：Web 应用程序的部署描述符文件。
test: 存放测试代码和资源文件的目录。
target: 存放编译后的 Class 文件、Jar 包等文件的目录。

pom.xml 代码介绍

说明

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

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

文件声明语句。

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

代码如下：
```
<?xml version="1.0" encoding="UTF-8"?>
```
配置 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>
```
配置基本信息。
1. 通过 <groupId> 指定项目标识为 com.oceanbase。
2. 通过 <artifactId> 指定项目依赖为 java-oceanbase-jfinal。
3. 通过 <version> 指定项目的版本号为 1.0-SNAPSHOT。
4. 通过 <packaging> 指定项目的打包方式为 WAR 文件（Web 应用程序归档文件）。
代码如下：
```
 <groupId>com.oceanbase</groupId>
 <artifactId>java-oceanbase-jfinal</artifactId>
 <version>1.0-SNAPSHOT</version>
 
 <packaging>war</packaging>
```
配置 MAVEN 版本。

通过 <maven.compiler.source> 和 <maven.compiler.target> 指定了编译器的源代码版本和目标代码版本都为 Java 8。

代码如下：
```
 <properties>
     <maven.compiler.source>8</maven.compiler.source>
     <maven.compiler.target>8</maven.compiler.target>
 </properties>
```
配置核心依赖。
1. 指定依赖项所属的组织为 com.jfinal，名称为 jfinal，版本号为 5.0.6，通过该依赖可以使用 JFinal 框架的功能。
  
  代码如下：
```
<dependency>
    <groupId>com.jfinal</groupId>
    <artifactId>jfinal</artifactId>
    <version>5.0.6</version>
</dependency>
```
2. 指定依赖项所属的组织为 com.alibaba，名称为 druid，版本号为 1.2.8，通过该依赖可以使用 Druid 库，用于管理和优化数据库连接的获取和释放。
  
  代码如下：
```
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.8</version>
</dependency>
```
3. 指定依赖项所属的组织为 com.oceanbase，名称为 oceanbase-client，版本号为 2.4.3，通过该依赖可以使用 OceanBase 提供的客户端功能，如连接、查询、事务等。
  
  代码如下：
```
    <dependencies>
    <dependency>
        <groupId>com.oceanbase</groupId>
        <artifactId>oceanbase-client</artifactId>
        <version>2.4.3</version>
    </dependency>
    </dependencies>
```

config.properties 文件介绍

config.properties 文件配置连接到 OceanBase 数据库的数据库连接信息。包括数据库驱动程序的类名、连接 URL、用户名、密码，以及连接池的相关配置。这些配置项用于在应用程序中获取和管理数据库连接，以便进行数据库操作。

通过 db.app.driver 指定数据库驱动程序为 com.oceanbase.jdbc.Driver，用于与 OceanBase 数据库建立连接。
通过 db.app.url 指定连接数据库的 URL。
通过 db.app.user 指定连接数据库的用户名。
通过 db.app.password 指定连接数据库的密码。
通过 db.app.poolInitialSize 指定数据库连接池的初始大小为 3，即初始时创建 3 个数据库连接。
通过 db.app.poolMaxSize 指定数据库连接池的最大为 10，即连接池中最多可以创建 10 个数据库连接。
通过 db.app.connectionTimeoutMillis 指定数据库连接的超时时间为 100 ms，即在获取数据库连接时，如果超过 100ms 仍未获取到连接，则抛出超时异常。

通过 db.app.validationQuery 指定用于验证数据库连接的 SQL 查询语句为 select 1 from dual，即在从连接池中获取连接时，会执行这个查询语句来验证连接的有效性。

代码如下：

  db.app.driver=com.oceanbase.jdbc.Driver
  db.app.url=jdbc:oceanbase://host:port/schema_name
  db.app.user=user_name
  db.app.password=******
  db.app.poolInitialSize=3
  db.app.poolMaxSize=10
  db.app.connectionTimeoutMillis=100
  db.app.validationQuery=select 1 from dual

web.xml 代码介绍

web.xml 文件用于配置 Web 应用程序的过滤器。

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

文件声明语句。

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

代码如下：
```
<?xml version="1.0" encoding="UTF-8"?>
```
配置 XML 的命名空间和 XML 模型版本。
1. 通过 xmlns:xsi 指定 XML 命名空间为 http://www.w3.org/2001/XMLSchema-instance。
2. 通过 xmlns 指定 XML 的命名空间为 http://java.sun.com/xml/ns/javaee。
3. 通过 xsi:schemaLocation 指定 XML 的命名空间为 http://java.sun.com/xml/ns/javaee 和 XML 的 XSD 文件的位置为 http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd。
4. 通过 <id> 和 <version> 元素指定 Web 应用程序的 ID 为 WebApp_ID，版本号为 3.0。
代码如下：
```
 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
          xmlns="http://java.sun.com/xml/ns/javaee" 
          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" 
          id="WebApp_ID" 
          version="3.0">
```
配置 JFinal 过滤器。

配置了一个名为 jfinal 的过滤器，用于在 Web 应用程序中使用 JFinal 框架。指定过滤器的类为 com.jfinal.core.JFinalFilter。通过指定初始化参数 configClass，指定了 JFinal 框架的配置类的位置为 com.oceanbase.testjfinal.config.UserConfig。这个过滤器用于在 Web 应用程序中使用 JFinal 框架，并根据指定的配置类来配置 JFinal 框架的行为。

代码如下：
```
 <filter>
     <filter-name>jfinal</filter-name>
     <filter-class>com.jfinal.core.JFinalFilter</filter-class>
     <init-param>
         <param-name>configClass</param-name>
         
         <param-value>com.oceanbase.testjfinal.config.UserConfig</param-value>
     </init-param>
 </filter>
```
配置 JFinal 过滤器映射。

将 jfinal 过滤器应用到所有的请求路径，即该过滤器将应用于应用程序中的所有请求。

代码如下：
```
 <filter-mapping>
     <filter-name>jfinal</filter-name>
     <url-pattern>/*</url-pattern>
 </filter-mapping>
```

UserConfig.java 文件介绍

UserConfig.java 文件用于配置应用程序的路由、插件、数据库连接等相关信息。

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

引用其他类和接口。

声明当前文件包含以下接口和类：
- StatFilter 类：用于统计数据库访问的性能。
- JdbcConstants 类：用于定义数据库类型的常量。
- WallFilter 类：用于防止 SQL 注入攻击。
- PropKit 类：用于读取配置文件。
- ActiveRecordPlugin 类：用于操作数据库。
- Db 类：用于执行数据库操作。
- OracleDialect 类：用于指定数据库的方言。
- DruidPlugin 类：用于连接数据库。
- Engine 类：用于配置模板引擎。
- UserController 类：用于处理用户相关的请求。
- User 类：用于传递和存储用户数据。
代码如下：
```
import com.alibaba.druid.filter.stat.StatFilter;
import com.alibaba.druid.util.JdbcConstants;
import com.alibaba.druid.wall.WallFilter;
import com.jfinal.config.*;
import com.jfinal.kit.PropKit;
import com.jfinal.plugin.activerecord.ActiveRecordPlugin;
import com.jfinal.plugin.activerecord.Db;
import com.jfinal.plugin.activerecord.dialect.OracleDialect;
import com.jfinal.plugin.druid.DruidPlugin;
import com.jfinal.template.Engine;
import com.oceanbase.testjfinal.controller.UserController;
import com.oceanbase.testjfinal.pojo.User;
```
定义 UserConfig 类。

通过重写 JFinalConfig 类的各个方法，可以配置常量、路由、插件和数据库连接等信息。
1. 定义 configConstant 方法。
  
  用于配置 JFinal 框架的常量，使用 PropKit 读取配置文件中的配置。
  
  代码如下：
```
@Override
public void configConstant(Constants constants) {
    PropKit.use("config.properties");
}
```
2. 定义 configRoute 方法。
  
  用于配置路由映射，使用 routes.add 方法将 "/hello" 路径映射到 UserController 类的默认访问页面。
  
  代码如下：
```
@Override
public void configRoute(Routes routes) {
    routes.add("/hello", UserController.class, "/");
}
```
3. 定义 configEngine 方法。
  
  用于配置模板引擎。
  
  代码如下：
```
@Override
public void configEngine(Engine engine) {
}
```
4. 定义 configPlugin 方法。
  
  用于配置应用程序的插件。通过调用 init 方法进行初始化数据库连接和表结构，创建了 DruidPlugin 和 ActiveRecordPlugin 插件，并将它们添加到 plugins 中。同时，通过调用 activeRecordPlugin 的 addMapping 方法，添加了数据库表和实体类的映射关系，将 TEST_USER 表与 User 类进行映射。
  
  代码如下：
```
@Override
public void configPlugin(Plugins plugins) {
    init();
    DruidPlugin druidPlugin = createDruidPlugin();
    plugins.add(druidPlugin);

    ActiveRecordPlugin activeRecordPlugin = createActiveRecordPlugin(druidPlugin);
    activeRecordPlugin.addMapping("TEST_USER", User.class);
    plugins.add(activeRecordPlugin);
}
```
5. 定义 createDruidPlugin 方法。
  
  用于 DruidPlugin 插件的创建和相关参数的配置，包括连接池大小、SQL 防火墙、连接错误处理等。
  - 通过调用 PropKit 的 get 方法，获取配置文件中的数据库连接相关属性值，包括 URL、用户名、密码和驱动类。然后创建 DruidPlugin 对象，并使用获取到的属性值进行初始化。
  - 通过调用 addFilter 方法，向 DruidPlugin 中添加了一个 StatFilter 实例，用于统计数据库访问的性能。创建一个 WallFilter 实例，通过 setDbType 方法设置数据库类型为 OceanBase，并将其添加到 DruidPlugin 中，用于进行 SQL 防火墙过滤。
  - 通过调用 setInitialSize 方法设置连接池的初始大小；setMaxPoolPreparedStatementPerConnectionSize 方法设置每个连接池的最大预处理语句数量；setTimeBetweenConnectErrorMillis 方法设置两次连接错误之间的时间间隔；setValidationQuery 方法设置连接的验证查询语句。最后，返回创建的 DruidPlugin 实例。
    
    代码如下：
```
private DruidPlugin createDruidPlugin() {
    DruidPlugin druidPlugin = new DruidPlugin(
            PropKit.get("db.app.url"),
            PropKit.get("db.app.user"),
            PropKit.get("db.app.password"),
            PropKit.get("db.app.driver")
    );

    druidPlugin.addFilter(new StatFilter());
    WallFilter wallFilter = new WallFilter();
    wallFilter.setDbType(JdbcConstants.OCEANBASE);
    druidPlugin.addFilter(wallFilter);

    druidPlugin.setInitialSize(PropKit.getInt("db.app.poolInitialSize"));
    druidPlugin.setMaxPoolPreparedStatementPerConnectionSize(PropKit.getInt("db.app.poolMaxSize"));
    druidPlugin.setTimeBetweenConnectErrorMillis(PropKit.getInt("db.app.connectionTimeoutMillis"));
    druidPlugin.setValidationQuery("select 1 from dual");

    return druidPlugin;
}
```
6. 定义 init 方法。
  
  用于初始化数据库连接和创建数据库表。通过调用 initDbConnection 方法初始化数据库连接，并返回一个 ActiveRecordPlugin 实例。其次，通过执行 SQL 语句查询用户表 TEST_USER 是否存在。如果用户表不存在，则执行 CREATE TABLE 语句创建名为 TEST_USER 的数据库表，该表包含 ID 和 NAME 两个字段。最后关闭 ActiveRecordPlugin 插件的连接，释放数据库连接。
  
  代码如下：
```
public void init() {
    ActiveRecordPlugin arp = initDbConnection();
    boolean tableExists = Db.queryInt("SELECT COUNT(*) FROM USER_TABLES WHERE TABLE_NAME = 'TEST_USER'") > 0;
    if (!tableExists) {
        String sql = "CREATE TABLE TEST_USER (ID NUMBER(10), NAME VARCHAR2(50))";
        Db.update(sql);
    }
    arp.stop();
}
```
7. 定义 initDbConnection 方法。
  
  用于初始化数据库的连接。首先通过调用 createDruidPlugin 方法创建 DruidPlugin 对象，并将其赋值给变量 druidPlugin，该方法负责创建和配置 DruidPlugin，用于数据库连接池的管理。其次通过调用 createActiveRecordPlugin 方法创建 ActiveRecordPlugin 对象，并将 DruidPlugin 对象作为参数传递到该方法中，该方法负责创建和配置 ActiveRecordPlugin，用于数据库操作的管理。然后调用 druidPlugin.start 方法启动 DruidPlugin 初始化数据库连接池。最后调用 activeRecordPlugin.start 方法启动 ActiveRecordPlugin，该方法会根据配置来初始化数据库操作的相关设置。
  
  代码如下：
```
private ActiveRecordPlugin initDbConnection() {
    DruidPlugin druidPlugin = createDruidPlugin();
    ActiveRecordPlugin activeRecordPlugin = createActiveRecordPlugin(druidPlugin);

    druidPlugin.start();
    activeRecordPlugin.start();

    return activeRecordPlugin;
}
```
8. 定义 ConfigInterceptor 和 ConfigHandler 方法。
  
  用来在系统初始化过程中进行全局配置。
  
  代码如下：
```
@Override
public void configInterceptor(Interceptors interceptors) {
}

@Override
public void configHandler(Handlers handlers) {
}
```

UserController.java 文件介绍

UserController.java 文件通过 getData 方法插入数据到数据库并查询数据，并将查询结果以 JSON 格式返回给客户端。通过使用 JFinal 框架提供的 Db 类执行数据库操作，以及使用自定义的 User 类进行数据映射，实现了对数据库的操作和数据返回的功能。

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

引用其他类和接口。

声明当前文件包含以下接口和类：
- Controller 类：用于处理请求和响应。
- Db 类：用于执行数据库操作。
- User 类：用于映射数据库表。
- List 接口：用于操作查询结果集合。
代码如下：
```
import com.jfinal.core.Controller;
import com.jfinal.plugin.activerecord.Db;
import com.oceanbase.testjfinal.pojo.User;

import java.util.List;
```
定义 UserController 类。

用于给 JFinal 框架提供控制器，使用 getData 方法对数据库进行插入数据和查询数据操作。
1. 插入数据。使用 Db.update 方法执行 SQL 插入语句，在名为 TEST_USER 的表中插入了两条数据，ID 为 1 和 2，名称分别为 John 和 Jane。
2. 查询数据。使用 User.dao.find 方法执行 SQL 查询语句，从名为 TEST_USER 的表中查询所有数据。查询结果会被赋值给一个 List 类型的变量 users。
3. 渲染 JSON 数据。使用 renderJson 方法，将保存在 users 对象中的数据渲染成 JSON 格式，并返回给客户端。
4. 异常处理。如果在执行操作过程中捕获到异常，通过 catch 语句块打印异常的堆栈信息。
代码如下：
```
public class UserController extends Controller {
    public void getData(){

        try {

            // 插入数据
            String insertDataSql = "INSERT INTO TEST_USER (ID, NAME) VALUES (?, ?)";
            Db.update(insertDataSql, 1, "John");
            Db.update(insertDataSql, 2, "Jane");
            //查询数据
            List<User> users;
            users = User.dao.find("SELECT * FROM TEST_USER");
            renderJson(users);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

}
```

User.java 文件介绍

User.java 文件用于实现数据库表与 Java 对象的映射。

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

引用 Model 类。

Model 类用于映射数据库表和操作数据。

定义 User 类。

User 类通过继承的 Model 类提供的方法来进行数据库操作。

代码如下：

import com.jfinal.plugin.activerecord.Model;


    public class User extends Model<User> {
        public static final User dao = new User();

}

完整的代码展示

pom.xml

config.properties

web.xml

UserConfig.java

UserController.java

User.java

<?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-jfinal</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!-- Packaging method (default to jar) -->
    <packaging>war</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.jfinal</groupId>
            <artifactId>jfinal</artifactId>
            <version>5.0.6</version>
        </dependency>


        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>

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

db.app.driver=com.oceanbase.jdbc.Driver
db.app.url=jdbc:oceanbase://host:port/schema_name
db.app.user=user_name
db.app.password=
db.app.poolInitialSize=3
db.app.poolMaxSize=10
db.app.connectionTimeoutMillis=100
db.app.validationQuery=select 1 from dual

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
    <filter>
        <filter-name>jfinal</filter-name>
        <filter-class>com.jfinal.core.JFinalFilter</filter-class>
        <init-param>
            <param-name>configClass</param-name>
            <!-- your jfinal configuration location -->
            <param-value>com.oceanbase.testjfinal.config.UserConfig</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>jfinal</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

package com.oceanbase.testjfinal.config;

import com.alibaba.druid.filter.stat.StatFilter;
import com.alibaba.druid.util.JdbcConstants;
import com.alibaba.druid.wall.WallFilter;
import com.jfinal.config.*;
import com.jfinal.kit.PropKit;
import com.jfinal.plugin.activerecord.ActiveRecordPlugin;
import com.jfinal.plugin.activerecord.Db;
import com.jfinal.plugin.activerecord.dialect.OracleDialect;
import com.jfinal.plugin.druid.DruidPlugin;
import com.jfinal.template.Engine;
import com.oceanbase.testjfinal.controller.UserController;
import com.oceanbase.testjfinal.pojo.User;

public class UserConfig extends JFinalConfig {
    @Override
    public void configConstant(Constants constants) {
        // Read properties configuration
        PropKit.use("config.properties");
    }

    @Override
    public void configRoute(Routes routes) {
        // Set the default access page for project startup, which does not need to be set in the web.
        routes.add("/hello", UserController.class, "/");
    }

    @Override
    public void configEngine(Engine engine) {
    }

    @Override
    public void configPlugin(Plugins plugins) {
        init();
        DruidPlugin druidPlugin = createDruidPlugin();
        plugins.add(druidPlugin);

        ActiveRecordPlugin activeRecordPlugin = createActiveRecordPlugin(druidPlugin);
        activeRecordPlugin.addMapping("TEST_USER", User.class);
        plugins.add(activeRecordPlugin);
    }

    private DruidPlugin createDruidPlugin() {
        DruidPlugin druidPlugin = new DruidPlugin(
                PropKit.get("db.app.url"),
                PropKit.get("db.app.user"),
                PropKit.get("db.app.password"),
                PropKit.get("db.app.driver")
        );

        druidPlugin.addFilter(new StatFilter());
        WallFilter wallFilter = new WallFilter();
        wallFilter.setDbType(JdbcConstants.OCEANBASE);
        druidPlugin.addFilter(wallFilter);

        druidPlugin.setInitialSize(PropKit.getInt("db.app.poolInitialSize"));
        druidPlugin.setMaxPoolPreparedStatementPerConnectionSize(PropKit.getInt("db.app.poolMaxSize"));
        druidPlugin.setTimeBetweenConnectErrorMillis(PropKit.getInt("db.app.connectionTimeoutMillis"));
        druidPlugin.setValidationQuery("select 1 from dual");

        return druidPlugin;
    }

    private ActiveRecordPlugin createActiveRecordPlugin(DruidPlugin druidPlugin) {
        ActiveRecordPlugin activeRecordPlugin = new ActiveRecordPlugin(druidPlugin);
        activeRecordPlugin.setDialect(new OracleDialect());

        return activeRecordPlugin;
    }

    public void init() {
        ActiveRecordPlugin arp = initDbConnection();
        boolean tableExists = Db.queryInt("SELECT COUNT(*) FROM USER_TABLES WHERE TABLE_NAME = 'TEST_USER'") > 0;
        if (!tableExists) {
            String sql = "CREATE TABLE TEST_USER (ID NUMBER(10), NAME VARCHAR2(50))";
            Db.update(sql);
        }
        arp.stop();
    }

    private ActiveRecordPlugin initDbConnection() {
        DruidPlugin druidPlugin = createDruidPlugin();
        ActiveRecordPlugin activeRecordPlugin = createActiveRecordPlugin(druidPlugin);

        druidPlugin.start();
        activeRecordPlugin.start();

        return activeRecordPlugin;
    }

    @Override
    public void configInterceptor(Interceptors interceptors) {
    }

    @Override
    public void configHandler(Handlers handlers) {
    }
}

package com.oceanbase.testjfinal.controller;

import com.jfinal.core.Controller;
import com.jfinal.plugin.activerecord.Db;
import com.oceanbase.testjfinal.pojo.User;

import java.util.List;

public class UserController extends Controller {
    public void getData(){

        try {

            // 插入数据
            String insertDataSql = "INSERT INTO TEST_USER (ID, NAME) VALUES (?, ?)";
            Db.update(insertDataSql, 1, "John");
            Db.update(insertDataSql, 2, "Jane");
            //查询数据
            List<User> users;
            users = User.dao.find("SELECT * FROM TEST_USER");
            renderJson(users);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

}

package com.oceanbase.testjfinal.pojo;

import com.jfinal.plugin.activerecord.Model;


    public class User extends Model<User> {
        public static final User dao = new User();

}