In questo articolo impareremo stabilire una connessione JDBC (Java DataBase Connectivity) attraverso un datasource accessibile tramite la libreria Agroal che consente di definire un java.sql.DataSource con connection pooling.

Un database pronto all'uso: Postgres

Avendo Linux come sistema di riferimento, iniziamo con un database verso il quale ci si possa connettere. Come visto in precedenza con la trattazione dell'accesso ai dati tramite le API Spring
in Quarkus, il modo più semplice e veloce è quello di utilizzare Docker per avere un'istanza Postgres immediatamente pronta all'uso.

Con Docker installato possiamo eseguire il comando run per avviare un'istanza Postgres:

docker run --ulimit memlock=-1:-1 -it --rm=true --memory-swappiness=0 --name postgres-quarkus -e POSTGRES_USER=scottus -e POSTGRES_PASSWORD=tigerus -e POSTGRES_DB=postgres -p 5432:5432 postgres:10.5

Successivamente installiamo un client a riga di comando per eseguire una connessione al database al fine di creare una tabella ed inserirvi dei dati:

apt install postgresql-client-common
apt-get install postgresql-client

La connessione al database Postgres è possibile quindi eseguendo il comando:

psql -h 0.0.0.0 --username=scottus postgres

specificando la password "tigerus" quando richiesto.

Ottenuto l'accesso al database eseguiamo i seguenti comandi SQL:

CREATE TABLE animal (
id bigint NOT NULL,
name character varying(100) NOT NULL,
type character varying(100) NOT NULL
);
INSERT INTO animal(id, name, type) VALUES (1, 'Tiger','Selvatic');
INSERT INTO animal(id, name, type) VALUES (2, 'Lion','Selvatic');
INSERT INTO animal(id, name, type) VALUES (3, 'Dog','Domestic');

per avere una tabella popolata da utilizzare con l'applicativo Quarkus.

DataSource JDBC

Dai precedenti articoli abbiamo imparato che tutto ciò che riguarda la configurazione in Quarkus risiede nel file application.properties, la configurazione di un datasource
non fa eccezione.

Attraverso poche proprietà, da specificare nel nostro file applicativo, saremo in grado di connetterci in pochi istanti. Apriamo l'application.properties e inseriamo
il seguente contenuto:

quarkus.datasource.db-kind=postgresql
quarkus.datasource.jdbc.url=jdbc:postgresql:postgres
quarkus.datasource.username=scottus
quarkus.datasource.password=tigerus
quarkus.datasource.jdbc.initial-size=10
quarkus.datasource.jdbc.min-size=10
quarkus.datasource.jdbc.max-size=20
quarkus.datasource.jdbc.background-validation-interval=2M
quarkus.datasource.jdbc.acquisition-timeout=5
quarkus.datasource.jdbc.validation-query-sql=SELECT 1
quarkus.datasource.jdbc.leak-detection-interval=2M

Attraverso le prime 4 proprietà specifichiamo il tipo di database al quel intendiamo collegarci, la stringa di connessione e le credenziali di accesso.

Le proprietà JDBC initial-size, min-size e max-size fanno riferimento alla dimensione iniziale del pool di connessioni, rispettivamente al suo valore minimo e massimo, durante l'esecuzione del server.

Il parametro background-validation-interval è l'intervallo di validazione delle connessioni idle (inattive) in background. Con acquisition-timeout definiamo invece il tempo massimo per l'acquisizione di una connessione.

La proprietà validation-query-sql permette di specificare una query da eseguire per la validazione di una connessione, mentre con il parametro leak-detection-interval definiamo l'intervallo temporale per il controllo delle connessioni perse. Concludiamo la configurazione aggiungendo le seguenti dipendenze Maven nel file pom.xml:

<dependency>
   <groupId>io.quarkus</groupId>
   <artifactId>quarkus-agroal</artifactId>
</dependency>
<dependency>
   <groupId>io.quarkus</groupId>
   <artifactId>quarkus-jdbc-postgresql</artifactId>
</dependency>
<dependency>
   <groupId>io.quarkus</groupId>
   <artifactId>quarkus-hibernate-orm</artifactId>
</dependency>

Un servizio di test

Siamo pronti per testare il lavoro svolto nei passi precedenti. Definiamo preliminarmente un servizio Rest che effettui una connesione al database, esegua una query verso
la tabella e restituisca una lista di animali in formato testo.

import io.agroal.api.AgroalDataSource;
import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
@Path("/jdbcService")
public class PostgresAccess {
    @Inject
    AgroalDataSource dataSource;
    @GET
    @Path("/test")
    @Produces(MediaType.TEXT_PLAIN)
    public Response testPostgres() throws SQLException {
        StringBuilder result = new StringBuilder();
        try(Connection connection=dataSource.getConnection()){
            Statement st = connection.createStatement();
            ResultSet rs = st.executeQuery("select * from animal");
            while(rs.next()){
                result.append(rs.getString(2)+" ");
            }
        }
        return  Response.ok(result).build();
    }
}

Avviamo l'applicazione Quarkus eseguendo il comando quarkus:dev da Intellij. Nell'immagine che segue mostriamo l'output dell'avvio di Quarkus per evidenziare il corretto caricamento delle librerie per l'accesso al database:

Utilizziamo Postman per eseguire facilmente la chiamata al servizio:

Come mostrato in Figura 2, il servizio risponde alla chiamata nel modo atteso, confermando il corretto funzionamento della configurazione definita nei paragrafi precedenti.