Connect to OceanBase Cloud by using JFinal

This topic describes how to use the JFinal framework and OceanBase Cloud to build an application for basic database operations, such as table creation, data insertion, and data query.

Download the java-oceanbase-Jfinal sample project Connect to OceanBase Database by using JFinal (Oracle compatible mode)

Prerequisites

• You have registered an OceanBase Cloud account, and created a cluster instance and an Oracle-compatible tenant in OceanBase Cloud. For more information, see Create a cluster instance and Create a tenant.
• You have obtained the connection string of the Oracle-compatible tenant. For more information, see Obtain the connection string.
• You have installed Java Development Kit (JDK) 1.8 and Maven.
• You have installed IntelliJ IDEA.

Procedure

Step 1: Import the java-oceanbase-Jfinal project to IntelliJ IDEA

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

   

2. In the Open File or Project window, select the project files and click OK to import the files.

3. IntelliJ IDEA automatically identifies various files in the project. You can view project information such as the directory structure, file list, module list, and dependencies in the Project window. Generally, the Project window is at the leftmost of the UI of IntelliJ IDEA and is opened by default. If the Project window is closed, you can choose View > Tool Windows > Project in the menu bar or press Alt + 1 to open it.

   Note

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

4. View the project.

   

Step 2: Build the Tomcat runtime environment for the java-oceanbase-Jfinal project

1. Download Tomcat 8.5.95.

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

2. Configure Tomcat in IntelliJ IDEA.

   Start IntelliJ IDEA and choose File > Settings. In the Settings window, click Plugins in the left-side navigation pane. In the Plugins pane, search for Smart Tomcat in the search box and install it. Then, click Apply in the lower-right corner. Tomcat Server appears at the bottom of the left-side navigation pane of the Settings window. Click Tomcat Server and then click the plus sign (+) in the right-side pane that appears. Select the directory where Tomcat is decompressed, click Apply, and then click OK.

   

3. Create a Tomcat runtime configuration.

   In the top navigation bar of IntelliJ IDEA, choose Run > Edit Configurations. In the Run/Debug Configurations window, click the plus sign (+) and select Tomcat Server. Enter the server name in the Name field. On the Configuration tab, select the installed version from the Tomcat sever drop-down list, change the value of Context path to /, and set SSL port to 8080. In the Before launch section, click the plus sign (+) and choose Launch Web Browser. Click Edit and enter http://localhost:8080/hello/getData in the URL field. Click Apply and then click OK.

   

4. Run the Tomcat server.

   In the top navigation bar of IntelliJ IDEA, select the Tomcat runtime configuration you just created. Click the Run button (a green triangle) to start the Tomcat server. You can view the startup logs of the Tomcat server in the Run window of IntelliJ IDEA.

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

Modify the database connection information in the config.properties file based on the obtained connection string mentioned in the "Prerequisites" section.

Here is an example:

db.app.driver=com.oceanbase.jdbc.Driver
db.app.url=jdbc:oceanbase://t5******.********.oceanbase.cloud:3306/sys
db.app.user=test_user
db.app.password=******
db.app.poolInitialSize=3
db.app.poolMaxSize=10
db.app.connectionTimeoutMillis=100
db.app.validationQuery=select 1 from dual

• The name of the database driver is com.oceanbase.jdbc.Driver.
• The endpoint is t5******.********.oceanbase.cloud.
• The access port is 3306.
• The name of the database to be accessed is sys.
• The tenant account is test_user.
• The password is ******.

Step 4: Run the java-oceanbase-Jfinal project

1. Specify the run path.

   In the top navigation bar of IntelliJ IDEA, select the Tomcat runtime configuration you just created. Click the Run button (a green triangle) to start the Tomcat server. Enter the URL http://localhost:8080/hello/getData in Google Chrome or Internet Explorer to view the running result.

2. View the running result.

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

Project code

Click here to download the project code, which is a package named java-oceanbase-Jfinal.

Decompress the package to obtain 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

The files and directories are described as follows:

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

Code in pom.xml

Perform the following steps to configure the pom.xml file:

1. Declare the file.

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

   The sample code is as follows:

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

2. Configure namespaces and the POM model version.

   1. xmlns: the default XML namespace for the POM, which is set to http://maven.apache.org/POM/4.0.0.
   2. xmlns:xsi: the XML namespace for XML elements prefixed with xsi, which is set to http://www.w3.org/2001/XMLSchema-instance.
   3. xsi:schemaLocation: the location of an XML schema definition (XSD) file. The value consists of two parts: the default XML namespace (http://maven.apache.org/POM/4.0.0) and the URI of the XSD file (http://maven.apache.org/xsd/maven-4.0.0.xsd).
   4. <modelVersion>: the POM model version used by the POM file, which is set to 4.0.0.

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

   1. <groupId>: the ID of the project group, which is set to com.oceanbase.
   2. <artifactId>: the name of the project, which is set to java-oceanbase-jfinal.
   3. <version>: the version of the project, which is set to 1.0-SNAPSHOT.
   4. <packaging>: the packaging mode of the project, which is set to WAR. In this mode, archive files of the web application are packaged in the WAR format.

   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 the Maven version.

   Set the source code version and target code version of the compiler to Java 8 by using <maven.compiler.source> and <maven.compiler.target>, respectively.

   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. Define a dependency named jfinal that belongs to the com.jfinal group and whose version is 5.0.6. With this dependency, you can use 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. Define a dependency named druid that belongs to the com.alibaba group and whose version is 1.2.8. With this dependency, you can 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. Define a dependency named oceanbase-client that belongs to the com.oceanbase group and whose version is 2.4.3. With this dependency, you can use the features of OBClient, such as connections, queries, and transactions.

      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 stores the connection information of OceanBase Cloud, including the class name of the database driver and the URL, username, password, and connection pool configurations. You can use the following parameters to establish and manage database connections for database operations in the application:

• db.app.driver: the database driver used to establish a connection with OceanBase Cloud, which is set to com.oceanbase.jdbc.Driver.

• db.app.url: the URL for connecting to the database.

• db.app.user: the username for connecting to the database.

• db.app.password: the password for connecting to the database.

• db.app.poolInitialSize: the initial size of the database connection pool, which is set to 3, indicating that three database connections are initially created.

• db.app.poolMaxSize: the maximum number of database connections allowed for the connection pool, which is set to 10, indicating that you can create a maximum of 10 database connections in a connection pool.

• db.app.connectionTimeoutMillis: the timeout period for obtaining a database connection, which is set to 100 ms, indicating that if a connection cannot be obtained within 100 ms, a timeout exception is thrown.

• db.app.validationQuery: the SQL query statement for verifying database connections, which is set to select 1 from dual. When you request a connection from the connection pool, this query statement is executed to verify the connection.

  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 configures a filter for the web application.

Perform the following steps to configure the web.xml file:

1. Declare the file.

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

   The sample code is as follows:

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

2. Configure the XML namespace and the XML model version.

   1. xmlns:xsi: the XML namespace for XML elements prefixed with xsi, which is set to http://www.w3.org/2001/XMLSchema-instance.
   2. xmlns: the default XML namespace for the POM, which is set to http://java.sun.com/xml/ns/javaee.
   3. xsi:schemaLocation: 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. <id> and <version>: the ID and version of the web application, which are respectively set to WebApp_ID and 3.0.

   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 a JFinal filter.

   Configure a filter named jfinal. With this filter, you can use the JFinal framework in the web application. Set the class of the filter to com.jfinal.core.JFinalFilter. 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 mappings of the JFinal filter.

   Apply the JFinal filter named jfinal to all request paths, namely, 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 the routing, plug-in, and database connection information of the application.

Perform the following steps to configure the UserConfig.java file:

1. Reference other classes and APIs.

   Declare this file to contain the following APIs and classes:

   • StatFilter class: collects statistics about the database access performance.
   • JdbcConstants class: defines database type constants.
   • WallFilter class: prevents SQL injection attacks.
   • PropKit class: reads configuration files.
   • ActiveRecordPlugin class: operates the database.
   • Db class: executes database operations.
   • OracleDialect class: specifies a dialect of the database.
   • DruidPlugin class: connects to the database.
   • Engine class: configures the template engine.
   • UserController class: processes user requests.
   • User class: transmits and stores 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.

   Rewrite the methods in the JFinalConfig class to configure constant, routing, plug-in, and database connection information.

   1. Define the configConstant method.

      Use this method to configure constants of the JFinal framework and use PropKit to read configurations from the configuration file.

      The sample code is as follows:

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

   2. Define the configRoute method.

      Use this method to configure route mappings. Call the routes.add method to map the "/hello" path to the default access page of the UserController class.

      The sample code is as follows:

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

   3. Define the configEngine method.

      Use this method to configure the template engine.

      The sample code is as follows:

      @Override
      public void configEngine(Engine engine) {
      }
      

   4. Define the configPlugin method.

      Use this method to configure plug-ins of the application. Call the init method to initialize the database connection and schema. Create the DruidPlugin and ActiveRecordPlugin plug-ins and add them to plugins. 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 database connection attributes from the configuration file, including the URL, username, password, and driver class. Then, create a DruidPlugin object and use the obtained attribute values to initialize the object. Call the addFilter method to add a StatFilter instance to DruidPlugin for collecting access performance statistics of the database. Create a WallFilter instance, call the setDbType method to set the database type to OceanBase Cloud, and then add the instance to DruidPlugin for SQL firewall-based filtering. Call the setInitialSize method to set the initial size of the connection pool, the setMaxPoolPreparedStatementPerConnectionSize method to set the maximum number of prepared statements allowed in each connection pool, the setTimeBetweenConnectErrorMillis method to set the interval for a retry upon an error, and the setValidationQuery method to set the query statement for verifying connections. Then, 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.

      Use this method to initialize database connections and create 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 to 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.

      Use this method to initialize the database connection. First, call the createDruidPlugin method to create a DruidPlugin object and assign it to the druidPlugin variable. This method is used to create and configure DruidPlugin objects for database connection pool management. Then, call the createActiveRecordPlugin method to create an ActiveRecordPlugin object and pass the DruidPlugin object as parameters to the createActiveRecordPlugin method. This method is used to create and configure ActiveRecordPlugin objects for database operation management. Call the druidPlugin.start method to start the DruidPlugin object to initialize the database connection pool. Finally, call the activeRecordPlugin.start method to start the ActiveRecordPlugin object. This method initializes database operation settings based on configurations.

      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 uses the getData method to insert data into the database, query data from the database, and return the query result to the client in the JavaScript Object Notation (JSON) format. The Db class provided by the JFinal framework is used to perform database operations, and the custom User class is used to map data, thereby implementing database operations and result returning.

Perform the following steps to configure the UserController.java file:

1. Reference other classes and APIs.

   Declare this file to contain the following APIs and classes:

   • Controller class: processes requests and responses.
   • Db class: executes database operations.
   • User class: maps database tables.
   • List interface: operates the query result set.

   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.

   Use this class to provide a controller for the JFinal framework, and use the getData method to insert data into and query data from the database.

   1. Insert data. Call the Db.update method to execute an SQL statement to insert two data records "1, John" and "2, Jane" into the TEST_USER table.
   2. Query data. Call the User.dao.find method to execute an SQL statement to query all data from the TEST_USER table. The query result is assigned 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 maps database tables and Java objects.

Perform the following steps to configure the User.java file:

1. Reference the Model class.

   Use the Model class to map database tables and operate data.

2. Define the User class.

   The User class inherits the methods provided in the Model class for 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

<?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 the property 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.