Connect to OceanBase Database by using JFinal

This topic introduces how to build an application by using the JFinal framework and OceanBase Database. It also covers the use of the application for fundamental database operations, including table creation, data insertion, and data query.

Download the java-oceanbase-Jfinal sample project

Prerequisites

• You have installed OceanBase Database.
• You have installed JDK 1.8 and Maven.
• You have installed IntelliJ IDEA.

Procedure

1. Obtain the OceanBase Database connection string.
2. Import the java-oceanbase-Jfinal project into IDEA.
3. Set up the Tomcat runtime environment for the java-oceanbase-Jfinal project.
4. Modify the database connection information in the java-oceanbase-Jfinal project.
5. Run the java-oceanbase-Jfinal project.

Step 1: Obtain the OceanBase Database connection string

1. Contact the deployment personnel or administrator of OceanBase Database to obtain the database connection string.

   obclient -hxx.xx.xx.xx -P2883 -uroot@sys#cluster -p**** -A
   

2. Fill in the URL below based on the deployed OceanBase database.

   Note

   The URL here is required in the config.properties file.

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

   Parameters in the URL are described as follows:

   • host: the IP address for connecting to OceanBase Database. For connection through OceanBase Database Proxy (ODP), this parameter is the IP address of an ODP. For direct connection, this parameter is the IP address of an OBServer node.
   • port: the port for connecting to OceanBase Database. For connection through ODP, the default value is 2883, which can be customized when ODP is deployed. For direct connection, the default value is 2881, which can be customized when OceanBase Database is deployed.
   • schema_name: the name of the schema to access.
   • user_name: the tenant account. For connection through ODP, the tenant account can be in the username@tenant name#cluster name or cluster name:tenant name:username format. For direct connection, the tenant account is in the username@tenant name format.
   • password: the account password.

   For more information about URL parameters, see Database URL.

Step 2: Import the java-oceanbase-Jfinal project into IDEA

1. Start IntelliJ IDEA and choose File > Open....

   

2. In the Open File or Project window that appears, select the corresponding project file and click OK to import the project file.

3. IntelliJ IDEA automatically identifies all types of files in the project. In the Project window, you can view the directory structure, list of files, list of modules, and dependencies of the project. The Project window is usually on the far left side in IntelliJ IDEA and is displayed by default. If the Project window is closed, you can choose View > Tool Windows > Project from the menu or use the Alt + 1 shortcut to open the window.

   Note

   When you use IntelliJ IDEA to import a project, IntelliJ IDEA automatically detects the pom.xml file in the project, downloads the required libraries based on the dependencies defined in the file, and adds the libraries to the project.

4. View the project.

   

Step 3: Set up a Tomcat runtime environment for the java-oceanbase-Jfinal project

1. Download Tomcat 8.5.95.

   Download the Tomcat 8.5.95 package from the Apache Tomcat official website and decompress the package to the directory where you want to install Tomcat.

2. Configure Tomcat in IDEA.

   1. Open IntelliJ IDEA, click File and choose Settings > Plugins.
   2. In the search box in the middle of the Settings window, search for Smart Tomcat.
   3. Download the plug-in and then choose Apply. The Tomcat Server tab appears at the bottom of the left side of the Settings window.
   4. On the Tomcat Server tab, click the + button on the right, select the directory where you decompressed the Tomcat package, click Apply, and then click OK to complete the configuration.

   

3. Create a Tomcat runtime configuration.

   1. In the top toolbar of IDEA, choose Run > Edit Configurations.
   2. In the Run/Debug Configurations window, click + and choose Tomcat Server.
   3. Enter the running server name in Name.
   4. In the Configuration section, select the version that you installed for Tomcat sever, change the value of Context path to /, and set SSL port to 8080.
   5. In the Before launch section, click + and choose Launch Web Browser.
   6. Click Edit and enter the URL http://localhost:8080/hello/getData.
   7. Click Apply and then click OK to complete the configuration.

   

4. Run the Tomcat server.

   1. In the top toolbar of IDEA, select the Tomcat runtime configuration that you have just created.
   2. Click the green triangle to start the Tomcat server. You can view the startup logs of the Tomcat server in the Run window of IDEA.

Step 4: Modify the database connection information in the java-oceanbase-Jfinal project

Modify the database connection information in the config.properties file based on the information obtained in Step 1: Obtain the OceanBase Database connection string.

Here is an example:

• The name of the database driver is com.oceanbase.jdbc.Driver.
• The IP address of the OBServer node is 10.10.10.1.
• The port is 2881.
• The name of the schema to access is sys.
• The tenant account is sys@xyoracle, where xyoracle is a user tenant created in the Oracle mode of OceanBase Database, and sys is a username in the xyoracle tenant.
• The password is ******.

The sample code is as follows:

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

Step 5: Run the java-oceanbase-Jfinal project

1. Run path

   In the top toolbar of IDEA, select the Tomcat runtime configuration that you have just created. Click the green triangle to start the Tomcat server. Visit http://localhost:8080/hello/getData in Google Chrome or Internet Explorer to view the output.

2. Output

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

Project code introduction

Click java-oceanbase-Jfinal to download the project code, which is a compressed file named java-oceanbase-jfinal.zip.

After decompressing it, you will find a folder named java-oceanbase-Jfinal. The directory structure is as follows:

│--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

Here is a breakdown of the files and directories:

• pom.xml: the configuration file of the Maven project, which contains the dependencies, plug-ins, and build information of the project.
• .idea: the directory used in the Integrated Development Environment (IDE) for storing project-related configurations.
• src: the directory for storing source code of the project.
• main: the directory for storing main source code and resource files.
• java: the directory for storing Java source code.
• com: the root directory for storing the Java package.
• oceanbase: the root directory for storing the project.
• testjfinal: stores the relevant code of the JFinal framework.
• config: the directory that stores configuration files of the application.
• UserConfig.java: the user configuration class file.
• controller: the directory that stores controller files of the application.
• UserController.java: the user controller class file.
• pojo: stores JavaBeans or entity classes.
• User.java: stores the user entity class.
• resources: the directory that stores resource files, such as configuration files and SQL files.
• config.properties: the configuration file that stores database connection information.
• webapp: the web application directory that stores static resources and configuration files of the web application.
• WEB-INF: the WEB-INF directory that stores configuration files and other protected resource files of the web application.
• web.xml: the deployment descriptor file for the web application.
• test: the directory that stores the test code and resource files.
• target: the directory that stores compiled class files and JAR packages.

Code in pom.xml

To configure the pom.xml file, perform the following steps:

1. Declare the file.

   Declare the file to be an XML file that uses XML standard 1.0 and character encoding UTF-8.

   The sample code is as follows:

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

2. Configure the namespaces and the POM model version.

   1. Use xmlns to specify http://maven.apache.org/POM/4.0.0 as the default XML namespace for the POM.
   2. Use xmlns:xsi to specify http://www.w3.org/2001/XMLSchema-instance as the XML namespace for xsi-prefixed elements.
   3. Use xsi:schemaLocation to provide a mapping from the default XML namespace for the POM (http://maven.apache.org/POM/4.0.0) to the location of the POM's XML schema definition (XSD) file (http://maven.apache.org/xsd/maven-4.0.0.xsd).
   4. Use <modelVersion> to specify 4.0.0 as the model version used by the POM.

   The sample code is as follows:

   <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. Configure basic project information.

   1. Use <groupId> to specify com.oceanbase as the ID of the project group.
   2. Use <artifactId> to specify java-oceanbase-jfinal as the ID of the project.
   3. Use <version> to specify 1.0-SNAPSHOT as the version of the project.
   4. Use <packaging> to specify war (web archive) as the packaging method of the project.

   The sample code is as follows:

    <groupId>com.oceanbase</groupId>
    <artifactId>java-oceanbase-jfinal</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!-- Packaging method (default to jar) -->
    <packaging>war</packaging>
   

4. Configure Maven versions.

   Use <maven.compiler.source> and <maven.compiler.target> to set both the source and target Java versions to Java 8.

   The sample code is as follows:

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
   

5. Configure core dependencies.

   1. Specify com.jfinal as the ID of the group that the dependency belongs to, jfinal as the dependency ID, and 5.0.6 as the dependency version. This dependency allows the project to use the features of the JFinal framework.

      The sample code is as follows:

      <dependency>
          <groupId>com.jfinal</groupId>
          <artifactId>jfinal</artifactId>
          <version>5.0.6</version>
      </dependency>
      

   2. Specify com.alibaba as the ID of the group that the dependency belongs to, druid as the dependency ID, and 1.2.8 as the dependency version. This dependency allows the project to use the Druid library to manage and optimize the acquisition and release of database connections.

      The sample code is as follows:

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

   3. Specify com.oceanbase as the ID of the group that the dependency belongs to, oceanbase-client as the dependency ID, and 2.4.3 as the dependency version. This dependency allows the project to use the client features, such as connection, query, and transaction, provided by OceanBase.

      The sample code is as follows:

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

Code in config.properties

The config.properties file configures the information for connecting to OceanBase Database, including the class name of the database driver, connection URL, username, password, and connection pool settings. The application uses these configurations to obtain and manage database connections for database operations.

• Use db.app.driver to specify com.oceanbase.jdbc.Driver as the database driver for establishing a connection with OceanBase Database.

• Use db.app.url to specify the URL of the database to connect to.

• Use db.app.user to specify the username for connecting to the database.

• Use db.app.password to specify the password for connecting to the database.

• Use db.app.poolInitialSize to specify 3 as the initial size of the database connection pool. That is, three database connections are initially created.

• Use db.app.poolMaxSize to specify 10 as the maximum number of database connections allowed for the connection pool. That is, you can create up to 10 database connections in a connection pool.

• Use db.app.connectionTimeoutMillis to specify 100 ms as the timeout for obtaining a database connection. That is, if a connection cannot be obtained within 100 ms, a timeout exception is thrown.

• Use db.app.validationQuery to specify select 1 from dual as the SQL query for verifying a database connection. That is, when the application obtains a database connection from the connection pool, this query is executed to verify whether the connection is valid.

  The sample code is as follows:

    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
  

Code in web.xml

The web.xml file defines filters for the web application.

To configure the web.xml configuration file, perform the following steps:

1. Declare the file.

   Declare the file to be an XML file that uses XML standard 1.0 and character encoding UTF-8.

   The sample code is as follows:

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

2. Configure XML namespaces and the XML model version.

   1. Use xmlns:xsi to specify http://www.w3.org/2001/XMLSchema-instance as the XML namespace for xsi-prefixed elements.
   2. Use xmlns to specify http://java.sun.com/xml/ns/javaee as the default XML namespace.
   3. Use xsi:schemaLocation to provide a mapping from the default XML namespace (http://java.sun.com/xml/ns/javaee) to the location of the XML schema definition (XSD) file (http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd).
   4. Use id and version to specify WebApp_ID as the ID of the web application and 3.0 as the version.

   The sample code is as follows:

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

3. Configure the JFinal filter.

   Configure a filter named jfinal. Specify com.jfinal.core.JFinalFilter as the filter class. Use the initialization parameter configClass to specify com.oceanbase.testjfinal.config.UserConfig as the location of the configuration class for the JFinal framework. This filter allows the web application to use the JFinal framework and defines the behavior of the JFinal framework based on the specified configuration class.

   The sample code is as follows:

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

4. Configure the JFinal filter mapping.

   Apply the jfinal filter to all request paths, so that the filter is applied to all requests in the application.

   The sample code is as follows:

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

Code in UserConfig.java

The UserConfig.java file configures routes, plug-ins, database connections, and other related information for the application.

To configure the UserConfig.java file, perform the following steps:

1. Reference other classes and interfaces.

   Declare that the current file contains the following interfaces and classes:

   • StatFilter class: collects performance statistics on database accesses.
   • JdbcConstants class: defines database type constants.
   • WallFilter class: prevents SQL injection attacks.
   • PropKit class: reads configuration files.
   • ActiveRecordPlugin class: operates the database.
   • Db class: performs database operations.
   • OracleDialect class: specifies the dialect of the database.
   • DruidPlugin class: connects to the database.
   • Engine class: configures the template engine.
   • UserController class: processes user-related requests.
   • User class: used to pass and store user data.

   The sample code is as follows:

   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;
   

2. Define the UserConfig class.

   This class overrides the methods of the JFinalConfig class to configure information such as constants, routes, plug-ins, and database connections.

   1. Define the configConstant method.

      This method uses PropKit to read JFinal framework constants from the configuration file and configures the constants.

      The sample code is as follows:

      @Override
      public void configConstant(Constants constants) {
          PropKit.use("config.properties");
      }
      

   2. Define the configRoute method.

      This method calls the routes.add method to map the "/hello" path to the default access page of the UserController class, so as to configure a route.

      The sample code is as follows:

      @Override
      public void configRoute(Routes routes) {
          routes.add("/hello", UserController.class, "/");
      }
      

   3. Define the configEngine method.

      This method configures the template engine.

      The sample code is as follows:

      @Override
      public void configEngine(Engine engine) {
      }
      

   4. Define the configPlugin method.

      This method configures application plug-ins.

      • Call the init method to initialize the database connection and schema.

      • Create the DruidPlugin and ActiveRecordPlugin plug-ins and add them to plugins.

      • At the same time, call the addMapping method of activeRecordPlugin to map the User entity class to the TEST_USER database table.

      The sample code is as follows:

      @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. Define the createDruidPlugin method.

      This method creates a DruidPlugin plug-in and configures related parameters, including the connection pool size, SQL firewall, and connection error handling.

      • Call the get method of PropKit to obtain the values of database connection attributes from the configuration file, including the URL, username, password, and driver class. Create a DruidPlugin object and initialize the object with the obtained attribute values.

      • Call the addFilter method to add a StatFilter instance to DruidPlugin for collecting performance statistics on database accesses. Create a WallFilter instance and call the setDbType method to set the database type to OCEANBASE. Add the instance to DruidPlugin for SQL firewall filtering.

      • Call the setInitialSize method to set the initial size of the connection pool. Call the setMaxPoolPreparedStatementPerConnectionSize method to set the maximum number of preprocessed statements allowed for each connection pool. Call the setTimeBetweenConnectErrorMillis method to set the time interval between two connection errors. Call the setValidationQuery method to set the query for verifying a connection. Finally, return the created DruidPlugin instance.

        The sample code is as follows:

        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. Define the init method.

      This method initializes a database connection and creates database tables.

      • Call the initDbConnection method to initialize the database connection and return an ActiveRecordPlugin instance.

      • Execute an SQL statement to query whether the user table TEST_USER exists. If the user table does not exist, execute the CREATE TABLE statement to create a table named TEST_USER that contains the ID and NAME fields.

      • Close the connection of the ActiveRecordPlugin plug-in and release the database connection.

      The sample code is as follows:

      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. Define the initDbConnection method.

      This method initializes a database connection.

      • Call the createDruidPlugin method to create a DruidPlugin object and assign the object to the druidPlugin variable. DruidPlugin is then used to manage the database connection pool.

      • Call the createActiveRecordPlugin method to create an ActiveRecordPlugin object by taking the DruidPlugin object as the input parameter of the method. ActiveRecordPlugin is then used to manage database operations.

      • Call the druidPlugin.start method to start DruidPlugin. This method initializes the database connection pool.

      • Call the activeRecordPlugin.start method to start ActiveRecordPlugin. This method initializes database operation settings as configured.

      The sample code is as follows:

      private ActiveRecordPlugin initDbConnection() {
          DruidPlugin druidPlugin = createDruidPlugin();
          ActiveRecordPlugin activeRecordPlugin = createActiveRecordPlugin(druidPlugin);
      
          druidPlugin.start();
          activeRecordPlugin.start();
      
          return activeRecordPlugin;
      }
      

   8. Define the ConfigInterceptor and ConfigHandler methods.

      These methods are used for global configuration during system initialization.

      The sample code is as follows:

      @Override
      public void configInterceptor(Interceptors interceptors) {
      }
      
      @Override
      public void configHandler(Handlers handlers) {
      }
      

Code in UserController.java

The UserController.java file defines a class to insert data into the database, query the data, and return the query results to the client in JSON format by calling the getData method. The class uses the Db class provided by the JFinal framework to perform database operations, and uses the custom User class to map data, thus implementing database operations and result returning.

To configure the UserController.java file, perform the following steps:

1. Reference other classes and interfaces.

   Declare that the current file contains the following interfaces and classes:

   • Controller class: processes requests and responses.
   • Db class: performs database operations.
   • User class: maps database tables.
   • List interface: handles query result sets.

   The sample code is as follows:

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

2. Define the UserController class.

   This class provides a controller for the JFinal framework and calls the getData method to insert data into the database and query data in the database.

   1. Insert data. Call the Db.update method to execute the SQL statement that inserts two data records 1, "John" and 2, "Jane" into the TEST_USER table.
   2. Query data. Call the User.dao.find method to execute the SQL statement that queries all data from the TEST_USER table. Assign the query result to the users variable of the List type.
   3. Render data into the JSON format. Call the renderJson method to render the data stored in the users object into the JSON format and return it to the client.
   4. Handle exceptions. Call the catch statement block to print the stack information of an exception that is thrown during the execution.

   The sample code is as follows:

   public class UserController extends Controller {
       public void getData(){
   
           try {
   
               // Insert data.
               String insertDataSql = "INSERT INTO TEST_USER (ID, NAME) VALUES (?, ?)";
               Db.update(insertDataSql, 1, "John");
               Db.update(insertDataSql, 2, "Jane");
               // Query data.
               List<User> users;
               users = User.dao.find("SELECT * FROM TEST_USER");
               renderJson(users);
           }catch (Exception e){
               e.printStackTrace();
           }
       }
   
   }
   

Code in User.java

The User.java file is used to map a Java object to a database table.

To configure the User.java file, perform the following steps:

1. Reference the Model class.

   The Model class maps database tables and operates data.

2. Define the User class.

   The User class inherits methods from the Model class to perform database operations.

   The sample code is as follows:

   import com.jfinal.plugin.activerecord.Model;
   
   
       public class User extends Model<User> {
           public static final User dao = new User();
   
   }
   

Complete code examples

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

            // Insert data.
            String insertDataSql = "INSERT INTO TEST_USER (ID, NAME) VALUES (?, ?)";
            Db.update(insertDataSql, 1, "John");
            Db.update(insertDataSql, 2, "Jane");
            // Query data.
            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();

}

References

For more information about OceanBase Connector/J, see OceanBase Connector/J.