Skip to content

Latest commit

 

History

History
287 lines (205 loc) · 12.2 KB

build-a-java-app-with-cockroachdb-hibernate.md

File metadata and controls

287 lines (205 loc) · 12.2 KB
title summary toc twitter
Build a Java App with CockroachDB and Hibernate
Learn how to use CockroachDB from a simple Java application with the Hibernate ORM.
true
false

This tutorial shows you how build a simple Java application with CockroachDB and the Hibernate ORM.

{% include {{page.version.version}}/app/java-version-note.md %}

{{site.data.alerts.callout_success}} For another use of Hibernate with CockroachDB, see our examples-orms repository. {{site.data.alerts.end}}

Before you begin

{% include {{page.version.version}}/app/before-you-begin.md %}

Step 1. Install the Gradle build tool

This tutorial uses the Gradle build tool to get all dependencies for your application, including Hibernate.

To install Gradle on Mac, run the following command:

{% include copy-clipboard.html %}

$ brew install gradle

To install Gradle on a Debian-based Linux distribution like Ubuntu:

{% include copy-clipboard.html %}

$ apt-get install gradle

To install Gradle on a Red Hat-based Linux distribution like Fedora:

{% include copy-clipboard.html %}

$ dnf install gradle

For other ways to install Gradle, see its official documentation.

Step 2. Create the maxroach user and bank database

{% include {{page.version.version}}/app/create-maxroach-user-and-bank-database.md %}

Step 3. Generate a certificate for the maxroach user

Create a certificate and key for the maxroach user by running the following command. The code samples will run as this user.

You can pass the --also-generate-pkcs8-key flag to generate a key in PKCS#8 format, which is the standard key encoding format in Java. In this case, the generated PKCS8 key will be named client.maxroach.key.pk8.

{% include copy-clipboard.html %}

$ cockroach cert create-client maxroach --certs-dir=certs --ca-key=my-safe-directory/ca.key --also-generate-pkcs8-key

Step 4. Run the Java code

The code below uses Hibernate to map Java methods to SQL operations. It perform the following steps which roughly correspond to method calls in the Sample class.

  1. Create an accounts table in the bank database as specified by the Hibernate Account class.
  2. Inserts rows into the table using session.save(new Account(int id, int balance)) (see Sample.addAccounts()).
  3. Transfer money from one account to another, printing out account balances before and after the transfer (see transferFunds(long fromId, long toId, long amount)).
  4. Print out account balances before and after the transfer (see Sample.getAccountBalance(long id)).

In addition, the code shows a pattern for automatically handling transaction retries by wrapping transactions in a higher-order function Sample.runTransaction(). It also includes a method for testing the retry handling logic (Sample.forceRetryLogic()), which will be run if you set the FORCE_RETRY variable to true.

It does all of the above using the practices we recommend for using Hibernate (and the underlying JDBC connection) with CockroachDB, which are listed in the Recommended Practices section below.

To run it:

  1. Download and extract [hibernate-basic-sample.tgz](https://github.com/cockroachdb/docs/raw/master/_includes/{{ page.version.version }}/app/hibernate-basic-sample/hibernate-basic-sample.tgz). The settings in [hibernate.cfg.xml](https://github.com/cockroachdb/docs/raw/master/_includes/{{ page.version.version }}/app/hibernate-basic-sample/hibernate.cfg.xml) specify how to connect to the database.

    {{site.data.alerts.callout_info}} The version of the CockroachDB Hibernate dialect in hibernate.cfg.xml corresponds to a version of CockroachDB. For more information, see Install Client Drivers: Hibernate. {{site.data.alerts.end}}

  2. Compile and run the code using [build.gradle](https://github.com/cockroachdb/docs/raw/master/_includes/{{ page.version.version }}/app/hibernate-basic-sample/build.gradle), which will also download the dependencies.

    {% include copy-clipboard.html %}

    $ gradle run

{{site.data.alerts.callout_success}} To clone a version of the code below that connects to insecure clusters, run the command below. Note that you will need to edit the connection string to use the certificates that you generated when you set up your secure cluster.

git clone https://github.com/cockroachlabs/example-app-java-hibernate/ {{site.data.alerts.end}}

The contents of Sample.java:

{% include copy-clipboard.html %}

{% include {{page.version.version}}/app/hibernate-basic-sample/Sample.java %}

Toward the end of the output, you should see:

APP: BEGIN;
APP: addAccounts() --> 1
APP: COMMIT;
APP: BEGIN;
APP: getAccountBalance(1) --> 1000
APP: COMMIT;
APP: BEGIN;
APP: getAccountBalance(2) --> 250
APP: COMMIT;
APP: getAccountBalance(1) --> 1000
APP: getAccountBalance(2) --> 250
APP: BEGIN;
APP: transferFunds(1, 2, 100) --> 100
APP: COMMIT;
APP: transferFunds(1, 2, 100) --> 100
APP: BEGIN;
APP: getAccountBalance(1) --> 900
APP: COMMIT;
APP: BEGIN;
APP: getAccountBalance(2) --> 350
APP: COMMIT;
APP: getAccountBalance(1) --> 900
APP: getAccountBalance(2) --> 350

To verify that the account balances were updated successfully, start the built-in SQL client:

{% include copy-clipboard.html %}

$ cockroach sql --certs-dir=certs --database=bank

To check the account balances, issue the following statement:

{% include copy-clipboard.html %}

SELECT id, balance FROM accounts;
  id | balance
+----+---------+
   1 |     900
   2 |     350
   3 |  314159
(3 rows)

Step 2. Create the maxroach user and bank database

{% include {{page.version.version}}/app/insecure/create-maxroach-user-and-bank-database.md %}

Step 3. Run the Java code

The code below uses Hibernate to map Java methods to SQL operations. It perform the following steps which roughly correspond to method calls in the Sample class.

  1. Create an accounts table in the bank database as specified by the Hibernate Account class.
  2. Inserts rows into the table using session.save(new Account(int id, int balance)) (see Sample.addAccounts()).
  3. Transfer money from one account to another, printing out account balances before and after the transfer (see transferFunds(long fromId, long toId, long amount)).
  4. Print out account balances before and after the transfer (see Sample.getAccountBalance(long id)).

In addition, the code shows a pattern for automatically handling transaction retries by wrapping transactions in a higher-order function Sample.runTransaction(). It also includes a method for testing the retry handling logic (Sample.forceRetryLogic()), which will be run if you set the FORCE_RETRY variable to true.

It does all of the above using the practices we recommend for using Hibernate (and the underlying JDBC connection) with CockroachDB, which are listed in the Recommended Practices section below.

To run it:

  1. Clone the example-app-java-hibernate repo to your machine:

    {% include copy-clipboard.html %}

    git clone https://github.com/cockroachlabs/example-app-java-hibernate/

  2. Compile and run the code using [build.gradle](https://github.com/cockroachdb/docs/raw/master/_includes/{{ page.version.version }}/app/insecure/hibernate-basic-sample/build.gradle), which will also download the dependencies.

    {% include copy-clipboard.html %}

    $ gradle run

The contents of Sample.java:

{% include copy-clipboard.html %}

{% include {{page.version.version}}/app/insecure/hibernate-basic-sample/Sample.java %}

Toward the end of the output, you should see:

APP: BEGIN;
APP: addAccounts() --> 1
APP: COMMIT;
APP: BEGIN;
APP: getAccountBalance(1) --> 1000
APP: COMMIT;
APP: BEGIN;
APP: getAccountBalance(2) --> 250
APP: COMMIT;
APP: getAccountBalance(1) --> 1000
APP: getAccountBalance(2) --> 250
APP: BEGIN;
APP: transferFunds(1, 2, 100) --> 100
APP: COMMIT;
APP: transferFunds(1, 2, 100) --> 100
APP: BEGIN;
APP: getAccountBalance(1) --> 900
APP: COMMIT;
APP: BEGIN;
APP: getAccountBalance(2) --> 350
APP: COMMIT;
APP: getAccountBalance(1) --> 900
APP: getAccountBalance(2) --> 350

To verify that the account balances were updated successfully, start the built-in SQL client:

{% include copy-clipboard.html %}

$ cockroach sql --insecure --database=bank

To check the account balances, issue the following statement:

{% include copy-clipboard.html %}

SELECT id, balance FROM accounts;
  id | balance
+----+---------+
   1 |     900
   2 |     350
   3 |  314159
(3 rows)

Recommended Practices

Use IMPORT to read in large data sets

If you are trying to get a large data set into CockroachDB all at once (a bulk import), avoid writing client-side code altogether and use the IMPORT statement instead. It is much faster and more efficient than making a series of INSERTs and UPDATEs. It bypasses the SQL layer altogether and writes directly to the storage layer of the database.

For more information about importing data from Postgres, see Migrate from Postgres.

For more information about importing data from MySQL, see Migrate from MySQL.

Use rewriteBatchedInserts for increased speed

We strongly recommend setting rewriteBatchedInserts=true; we have seen 2-3x performance improvements with it enabled. From the JDBC connection parameters documentation:

This will change batch inserts from insert into foo (col1, col2, col3) values (1,2,3) into insert into foo (col1, col2, col3) values (1,2,3), (4,5,6) this provides 2-3x performance improvement

Retrieve large data sets in chunks using cursors

New in v19.2: CockroachDB now supports the Postgres wire-protocol cursors for implicit transactions and explicit transactions executed to completion. This means the PGJDBC driver can use this protocol to stream queries with large result sets. This is much faster than paginating through results in SQL using LIMIT .. OFFSET.

For instructions showing how to use cursors in your Java code, see Getting results based on a cursor from the PGJDBC documentation.

Note that interleaved execution (partial execution of multiple statements within the same connection and transaction) is not supported when Statement.setFetchSize() is used.

What's next?

Read more about using the Hibernate ORM, or check out a more realistic implementation of Hibernate with CockroachDB in our examples-orms repository.

{% include {{page.version.version}}/app/see-also-links.md %}