Connect to an OceanBase database using Spring JPA

Configure dependencies

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>8.0.25</version>
</dependency>
<dependency>
   <groupId>org.springframework.data</groupId>
   <artifactId>spring-data-jpa</artifactId>
   <version>1.10.1.RELEASE</version>
</dependency>


<!--Other Spring dependencies are omitted here.-->

Configuration files

The applicationContext.xml file

The information is as follows:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-4.2.xsd
         http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
         http://www.springframework.org/schema/mvc
         http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
         http://www.springframework.org/schema/data/jpa
         http://www.springframework.org/schema/data/jpa/spring-jpa.xsd"
        >

    <!-- Enable IOC annotation scanning -->
    <context:component-scan base-package="com.bjyada.demo" />
    <!-- Enable MVC annotation scanning -->
    <mvc:annotation-driven />

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
          destroy-method="close">
        <!-- Connection information -->
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

        <!-- Connection Pooling Info -->
        <property name="maxActive" value="${dbcp.maxActive}"/>
        <property name="maxIdle" value="${dbcp.maxIdle}"/>
        <property name="defaultAutoCommit" value="true"/>
        <!-- A connection times out if it is idle for one hour. -->
        <property name="timeBetweenEvictionRunsMillis" value="3600000"/>
        <property name="minEvictableIdleTimeMillis" value="3600000"/>
    </bean>

    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE"/>
        <property name="ignoreResourceNotFound" value="true"/>
        <property name="locations">
            <list>
                <!-- External -->
                <!--<value>file:${user.dir}/dbcp.properties</value>-->
                <!-- Internal -->
                <value>classpath*:dbcp.properties</value>
            </list>
        </property>
    </bean>

    <!-- Jpa Entity Manager configuration -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter"/>
        <property name="packagesToScan" value="com.bjyada.demo.entity"/>
        <property name="persistenceUnitName" value="primary"/>
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
                <!-- Set to none to prevent Hibernate from creating tables on startup.
                Automatically create, update, or validate the database table schema.
                validate: Validates the table schema when Hibernate is loaded.
                create: Recreates the table schema each time Hibernate is loaded.
                create-drop: Creates the table schema when Hibernate is loaded and drops it on exit.
                update: Automatically updates the database schema when Hibernate is loaded. -->
                <prop key="hibernate.hbm2ddl.auto">update</prop>
                <prop key="hibernate.show_sql">false</prop>
                <prop key="hibernate.format_sql">false</prop>
                <prop key="hibernate.temp.use_jdbc_metadata_defaults">false</prop>
            </props>
        </property>
    </bean>

    <bean id="hibernateJpaVendorAdapter" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
        <property name="database" value="${database.dialect}"/>
    </bean>

    <!-- Configure the transaction manager -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>

    <!-- Enable annotation-based transactions -->
    <tx:annotation-driven transaction-manager="transactionManager" />

    <!-- Configure the Spring Data JPA scan directory -->
    <jpa:repositories base-package="com.bjyada.demo" />
    <bean class="com.bjyada.demo.ExceptionHandler"></bean>
</beans>

The dbcp.properties file

The content is described as follows:

# OceanBase database
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://xxx.xxx.xxx.xxx:3306/test
jdbc.username=a****
jdbc.password=******
database.dialect=MYSQL
dbcp.maxIdle=5
dbcp.maxActive=40
useUnicode=true&characterEncoding=utf-8

The pom.xml file

The content includes the following:

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
   <version>****</version>
</dependency>
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>8.0.25</version>
</dependency>
  <!-- The rest is omitted. -->

The application.properties file

The following code shows only the configurations for the data source and JPA:

spring.datasource.url=jdbc:mysql://xxx.xxx.xxx.xxx:3306/test
spring.datasource.username=a****
spring.datasource.password=******
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect= org.hibernate.dialect.MySQL5Dialect

Test preparation

Entity class

The following is the code:

public class User implements Serializable {
    private Integer id;
    private String username;
    // Comment out some fields to test if the framework can automatically modify the table by adding new properties from the entity class.
    //private Date birthday;
    //private String sex;
    //private String address;
    // Constructors, getters, and setters are omitted here.
}

Database access interface

public interface UserDao extends JpaRepository<User,Serializable>{
    User findById(Integer id);
}

Code examples

Automatic table creation

Test method:

@Test
public void testInsert(){
  User user = new User();
  user.setId(1);
  user.setUsername("Test data");
  userDao.save(user);
}

Result:

Modify the table (add fields)

Uncomment the properties in the User class and run the following method:

@Test
public void testAlert(){
    User user = new User();
    user.setId(1);
    user.setUsername("Test data");
    user.setAddress("Beijing");
    user.setSex("Male");
    user.setBirthday(new Date());
    userDao.save(user);
}

Result:

OceanBase supports the `ALTER TABLE` feature of Spring JPA.

Persist data

Test Method:

@Test
public void testInsert(){
    List<User> list = new ArrayList<User>();
    list.add(new User(3,"asd", new Date(), "Male", "Zhangzhou"));
    list.add(new User(4,"qwe", new Date(), "Female", "Hangzhou"));
    list.add(new User(5,"zxc", new Date(), "Male", "Shanghai"));
    list.add(new User(6,"xcv", new Date(), "Female", "Hangzhou"));
    list.add(new User(7,"sdf", new Date(), "Male", "Hangzhou"));
    list.add(new User(8,"wer", new Date(), "Female", "Hangzhou"));
    list.add(new User(9,"ert", new Date(), "Male", "Zhangzhou"));
    list.add(new User(10,"rty", new Date(), "Female", "Shanghai"));
    list.add(new User(11,"tyu", new Date(), "Male", "Hangzhou"));
    
    list.forEach(s -> userDao.save(s));
}

Result:

OceanBase supports the `INSERT` feature of Spring JPA.

Query by primary key

Test method:

@Test
public void testFindOne(){
    Table_Test one = table_testDao.findOne("aaa");
    System.out.println(one);
}

Result:

OceanBase supports the `findOne` feature of Spring JPA.

Delete records by primary key or object

Test method:

@Test
public void testDelete(){
    table_testDao.delete("9998");
}

@Test
public void test6(){
    Table_Test a = new Table_Test();
    a.setChar_test("9997");
    table_testDao.delete(a);
}

Result:

OceanBase supports the `delete` feature of Spring JPA.

Modify records

Test method:

@Test
public void testChange(){
    Table_Test one = table_testDao.findOne("9996");
    System.out.println("Before modification:"+one);
    one.setVarchar2_test("Modified");
    one.setNchar_test("Modified");
    table_testDao.save(one);
    one = table_testDao.findOne("9996");
    System.out.println("After modification:"+one);
}

Result:

OceanBase supports the data modification feature of Spring JPA.

Full table query

Testing method:

@Test
public void testFindAll(){
    List<User> all = userDao.findAll();
    all.forEach(System.out::println);
}

Result:

OceanBase supports the `findAll` feature of Spring JPA.