Connect to OceanBase Cloud using Spring JDBC

This topic describes how to build an application by using the Spring JDBC framework, OceanBase Connector/J, and OceanBase Cloud. The application can perform basic database operations, including creating tables, inserting data, updating data, deleting data, querying data, and dropping tables.

Download the spring-jdbc-oceanbase-client sample project Connect to OceanBase Cloud using Spring JDBC (Oracle compatible mode)

Prerequisites

• You have registered an OceanBase Cloud account and created an instance and an Oracle-compatible tenant. For more information, see Create an instance and Create a tenant.

• You have installed JDK 1.8 and Maven.

• You have installed Eclipse.

  Note

  The code examples in this topic are run in Eclipse IDE for Java Developers 2022-03. You can also use any other tool that you prefer to run the code examples.

Procedure

1. Import the spring-jdbc-oceanbase-client project into Eclipse.
2. Obtain the URL of the OceanBase Cloud database.
3. Modify the database connection information in the spring-jdbc-oceanbase-client project.
4. Run the spring-jdbc-oceanbase-client project.

Step 1: Import the spring-jdbc-oceanbase-client project into Eclipse

1. Start Eclipse and choose File > Open Projects from File System.

2. In the dialog box that appears, click Directory to select the project directory and click Finish.

   Note

   When you import a Maven project into Eclipse, it automatically detects the pom.xml file in the project, downloads the required dependency libraries based on the described dependencies in the file, and adds them to the project.

   

3. View the project.

   

Step 2: Obtain the URL of the OceanBase Cloud database

1. Log in to the OceanBase Cloud console. In the instance list, expand the information of the target instance, and in the target tenant, choose Connect > Get Connection String.

   For more information, see Get connection string.

2. Fill in the corresponding information in the URL based on the created OceanBase Cloud database.

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

   Parameter description:

   • $host: the URL of the OceanBase Cloud database, for example, t********.********.oceanbase.cloud.

   • $port: the port of the OceanBase Cloud database. The default value is 1521.

   • $schema_name: the name of the schema to be accessed.

     Notice

     The user of the tenant must have the CREATE SESSION privilege and the CREATE TABLE, DROP TABLE, INSERT, DELETE, UPDATE, and SELECT privileges on the schema. For more information about user privileges, see Create and manage a user.

   • $user_name: the username.

   • $password: the password.

   For more information about the URL parameters of OceanBase Connector/J, see Database URL.

   Example:

   jdbc:oceanbase://t5******.********.oceanbase.cloud:1521/sys?user=oracle001&password=******
   

Step 3: Modify the database connection information in the spring-jdbc-oceanbase-client project

Modify the database connection information in the spring-jdbc-oceanbase-client/src/main/java/com/example/Main.java file based on the information obtained in Step 2: Obtain the URL of the OceanBase Cloud database.

Example:

• The URL of the OceanBase Cloud database is t5******.********.oceanbase.cloud.
• The port is 1521.
• The name of the schema to be accessed is sys.
• The username is oracle001.
• The password is ******.

Sample code:

...
        String url = "t5******.********.oceanbase.cloud:1521/sys";
        String username = "oracle001";
        String password = "******";
...

Step 4: Run the spring-jdbc-oceanbase-client project

1. In the Project Explorer view, find and expand the src/main/java directory.

2. Right-click the Main.java file and choose Run As > Java Application.

   

3. View the output in the console window of Eclipse.

   

Project code

Click spring-jdbc-oceanbase-client to download the project code, which is a compressed file named spring-jdbc-oceanbase-client.zip.

After decompressing the file, you will find a folder named spring-jdbc-oceanbase-client. The directory structure is as follows:

spring-jdbc-oceanbase-client
├── src
│   └── main
│       └── java
│           └── com
│                └── example
│                   └── Main.java
└── pom.xml

File description:

• src: the root directory for source code.
• main: the main code directory, containing the core logic of the application.
• java: the directory for Java source code.
• com: the directory for Java packages.
• example: the directory for packages of the sample project.
• Main.java: the main class, containing logic for creating tables and inserting data.
• pom.xml: the configuration file for the Maven project, used to manage project dependencies and build settings.

Introduction to the pom.xml file

The pom.xml file is a configuration file for Maven projects. It defines the project's dependencies, plugins, and build rules. Maven is a Java project management tool that can automatically download dependencies, compile, and package projects.

The pom.xml file in this topic includes the following parts:

1. File declaration statement.

   This statement declares that the file is an XML file using XML version 1.0 and character encoding UTF-8.

   Sample code:

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

2. Configure the namespaces and POM model version.

   1. Use xmlns to specify the POM namespace as http://maven.apache.org/POM/4.0.0.
   2. Use xmlns:xsi to specify the XML namespace as http://www.w3.org/2001/XMLSchema-instance.
   3. Use xsi:schemaLocation to specify the POM namespace as http://maven.apache.org/POM/4.0.0 and the location of the POM XSD file as http://maven.apache.org/xsd/maven-4.0.0.xsd.
   4. Use the <modelVersion> element to specify the POM model version used by the POM file as 4.0.0.

   Sample code:

   <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>
   
    <!-- Other configurations -->
   
   </project>
   

3. Configure basic information.

   1. Use <groupId> to specify the project's organization as com.example.
   2. Use <artifactId> to specify the project's name as spring-jdbc-oceanbase-client.
   3. Use <version> to specify the project's version as 1.0-SNAPSHOT.

   Sample code:

       <groupId>com.example</groupId>
       <artifactId>spring-jdbc-oceanbase-client</artifactId>
       <version>1.0-SNAPSHOT</version>
   

4. Configure the properties of the project's source files.

   Specify the Maven compiler plugin as maven-compiler-plugin and set the source and target Java versions to 8. This means that the project's source code is written using Java 8 features, and the compiled bytecode will also be compatible with the Java 8 runtime environment. This setup ensures that the project can correctly handle Java 8 syntax and features during compilation and runtime.

   Note

   Java 1.8 and Java 8 are different names for the same version.

   Sample code:

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

5. Configure the components that the project depends on.

   1. Add the oceanbase-client dependency library for interacting with the database:

      1. Use <groupId> to specify the dependency's organization as com.oceanbase.
      2. Use <artifactId> to specify the dependency's name as oceanbase-client.
      3. Use <version> to specify the dependency's version as 2.4.2.

      Note

      This part of the code defines the project's dependency on OceanBase Connector/J V2.4.2. For information about other versions, see OceanBase JDBC driver.

      Sample code:

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

   2. Add the spring-jdbc dependency library:

      1. Use <groupId> to specify the dependency's organization as org.springframework.
      2. Use <artifactId> to specify the dependency's name as spring-jdbc.
      3. Use <version> to specify the dependency's version as 5.2.0.RELEASE.

      Sample code:

              <dependency>
                  <groupId>org.springframework</groupId>
                  <artifactId>spring-jdbc</artifactId>
                  <version>5.2.0.RELEASE</version>
              </dependency>
      

Introduction to Main.java

The Main.java file is part of the sample program and demonstrates how to use the Spring JDBC framework to perform database operations. It first configures the database connection information and then creates a JdbcTemplate object to execute database operations. The code also includes examples of creating tables, inserting data, and querying data.

The code in the Main.java file in this topic mainly includes the following parts:

1. Define the package and import the necessary classes.

   1. Declare the package name of the current code as com.example.
   2. Import the JdbcTemplate class, which is the core class in the Spring JDBC framework for executing database operations.
   3. Import the DriverManagerDataSource class, which is a data source class provided by Spring that implements the DataSource interface and is used to configure database connection information.

   Sample code:

   package com.example;
   
   import org.springframework.jdbc.core.JdbcTemplate;
   import org.springframework.jdbc.datasource.DriverManagerDataSource;
   

2. Create a Main class and define the main method.

   1. Define a public class named Main as the entry point of the program. The class name must match the file name.
   2. Define a public static method main as the starting point of the program.
   3. Other database operations.

   Sample code:

   public class Main {
       public static void main(String[] args) {
           // Database connection information
           // Create a data source
           // Create a JdbcTemplate object
           // Create a table
           // Insert data
           // Update data
           // Delete data
           // Query data
           // Delete a table
       }
   }
   

3. Define the database connection information.

   Define the URL, username, and password for connecting to the database. You need to replace $host, $port, $schema_name, $user_name, and $password with the actual database connection information.

   Sample code:

           String url = "jdbc:oceanbase://$host:$port/$schema_name";
           String username = "$user_name";
           String password = "$password";
   

   Parameter description:

   • $host: the connection address of the OceanBase Cloud database, for example, t********.********.oceanbase.cloud.

   • $port: the port for connecting to the OceanBase Cloud database. The default value is 1521.

   • $schema_name: the name of the schema to be accessed.

     For more information about the URL parameters, see Database URL.

   • $user_name: the username for accessing the database.

   • $password: the password for accessing the database.

4. Create a data source.

   Create a DriverManagerDataSource object and configure the database connection information, including the driver class name, database URL, username, and password. The steps are as follows:

   1. Create a DriverManagerDataSource object to configure the database connection information.
   2. Set the driver class name: call the setDriverClassName method to set the database driver class name to com.oceanbase.jdbc.Driver. This is the driver class for connecting to the OceanBase Cloud database.
   3. Set the database URL: call the setUrl method to set the database URL.
   4. Set the username: call the setUsername method to set the database username.
   5. Set the password: call the setPassword method to set the database password.

   Sample code:

           DriverManagerDataSource dataSource = new DriverManagerDataSource();
           dataSource.setDriverClassName("com.oceanbase.jdbc.Driver");
           dataSource.setUrl(url);
           dataSource.setUsername(username);
           dataSource.setPassword(password);
   

5. Create a JdbcTemplate object.

   Create a JdbcTemplate object, which is one of the core classes in the Spring JDBC framework. The JdbcTemplate class provides methods for executing database operations, such as executing SQL statements, updating data, and querying data.

   Sample code:

           JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
   

6. Create a table.

   1. Define an SQL statement for creating a table. The SQL statement specifies the table name as test_springjdbc and defines two columns: one is a NUMBER type column named id, and the other is a VARCHAR2(20) type column named name.
   2. Execute the SQL statement for creating a table. The jdbcTemplate object calls the execute method to execute the SQL statement for creating a table as defined.
   3. Output a message indicating that the table was successfully created to the console.

   Sample code:

           String createTableSql = "CREATE TABLE test_springjdbc (id NUMBER, name VARCHAR2(20))";
           jdbcTemplate.execute(createTableSql);
           System.out.println("Create table successfully.");
   

7. Insert data.

   1. Define an SQL statement for inserting data. The SQL statement specifies the table to be inserted into as test_springjdbc, the columns as id and name, and the data to be inserted as (1,'A1'), (2,'A2'), and (1,'A3').
   2. Execute the SQL statement for inserting data. The jdbcTemplate object calls the update method to execute the SQL statement for inserting data as defined.
   3. Output a message indicating that the data was successfully inserted to the console.

   Sample code:

           String insertDataSql = "INSERT INTO test_springjdbc (id,name) VALUES (1,'A1'), (2,'A2'), (1,'A3')";
           jdbcTemplate.update(insertDataSql);
           System.out.println("Insert data successfully.");
   

8. Update data.

   1. Define an SQL statement for updating the name field of the record with id equal to 1 in the test_springjdbc table to A11.
   2. Execute the SQL statement using the jdbcTemplate object to apply the update operation to the database.
   3. Output a message indicating that the data was successfully updated to the console.

   Sample code:

           String updateDataSql = "UPDATE test_springjdbc SET name = 'A11' WHERE id = 1";
           jdbcTemplate.update(updateDataSql);
           System.out.println("Update data successfully.");
   

9. Delete data.

   1. Define an SQL statement for deleting the record with id equal to 2 from the test_springjdbc table.
   2. Execute the SQL statement using the jdbcTemplate object to apply the delete operation to the database.
   3. Output a message indicating that the data was successfully deleted to the console.

   Sample code:

           String deleteDataSql = "DELETE FROM test_springjdbc WHERE id = 2";
           jdbcTemplate.update(deleteDataSql);
           System.out.println("Delete data successfully.");
   

10. Query data.

    1. Define an SQL statement for querying data. The SQL statement uses SELECT * to select all columns from the test_springjdbc table.
    2. Execute the SQL statement for querying data. The jdbcTemplate object calls the query method to execute the SQL statement for querying data as defined and receives a callback function as a parameter.
    3. The code in the callback function uses the ResultSet object (rs) to obtain each row of data from the query results and process it. The callback function uses the getInt and getString methods to obtain the values of the id and name columns from the ResultSet object and prints them to the console. Finally, the callback function returns null.
    4. Output a message indicating that the data was successfully queried to the console.

    Sample code:

            String selectDataSql = "SELECT * FROM test_springjdbc";
            jdbcTemplate.query(selectDataSql, (rs, rowNum) -> {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                System.out.println("id: " + id + ", name: " + name);
                return null;
            });
            System.out.println("Query data successfully.");
    

11. Delete a table.

    1. Define an SQL statement to delete the test_springjdbc table from the database.
    2. Execute the SQL statement using the jdbcTemplate object to apply the table deletion to the database.
    3. Output a message indicating that the table was successfully deleted.

    Sample code:

            String deleteTableSql = "DROP TABLE test_springjdbc";
            jdbcTemplate.execute(deleteTableSql);
            System.out.println("Table drop successfully.");
    

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.example</groupId>
    <artifactId>spring-jdbc-oceanbase-client</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>com.oceanbase</groupId>
            <artifactId>oceanbase-client</artifactId>
            <version>2.4.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>
    </dependencies>

</project>

package com.example;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

public class Main {
    public static void main(String[] args) {
        // Database Connect Information
        String url = "jdbc:oceanbase://$host:$port/$schema_name";
        String username = "$user_name";
        String password = "$password";

        // create data source
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.oceanbase.jdbc.Driver");
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);

        // Create a JdbcTemplate object
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // Create table
        String createTableSql = "CREATE TABLE test_springjdbc (id NUMBER, name VARCHAR2(20))";
        jdbcTemplate.execute(createTableSql);
        System.out.println("Create table successfully.");

        // Insert data
        String insertDataSql = "INSERT INTO test_springjdbc (id,name) VALUES (1,'A1'), (2,'A2'), (1,'A3')";
        jdbcTemplate.update(insertDataSql);
        System.out.println("Insert data successfully.");

        // Update data
        String updateDataSql = "UPDATE test_springjdbc SET name = 'A11' WHERE id = 1";
        jdbcTemplate.update(updateDataSql);
        System.out.println("Update data successfully.");

        // Delete data
        String deleteDataSql = "DELETE FROM test_springjdbc WHERE id = 2";
        jdbcTemplate.update(deleteDataSql);
        System.out.println("Delete data successfully.");

        // Query data
        String selectDataSql = "SELECT * FROM test_springjdbc";
        jdbcTemplate.query(selectDataSql, (rs, rowNum) -> {
            int id = rs.getInt("id");
            String name = rs.getString("name");
            System.out.println("id: " + id + ", name: " + name);
            return null;
        });
        System.out.println("Query data successfully.");
        
        // Delete table
        String deleteTableSql = "DROP TABLE test_springjdbc";
        jdbcTemplate.execute(deleteTableSql);
        System.out.println("Table drop successfully.");
    }
}

References

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