Inicio rápido: Uso de Java y JDBC con Azure Database for PostgreSQLQuickstart: Use Java and JDBC with Azure Database for PostgreSQL

En este tema se muestra cómo crear una aplicación de ejemplo que utiliza Java y JDBC para almacenar y recuperar información de Azure Database for PostgreSQL.This topic demonstrates creating a sample application that uses Java and JDBC to store and retrieve information in Azure Database for PostgreSQL.

JDBC es la API de Java estándar para conectarse a bases de datos relacionales tradicionales.JDBC is the standard Java API to connect to traditional relational databases.

Requisitos previosPrerequisites

Preparación del entorno de trabajoPrepare the working environment

Vamos a usar variables de entorno para limitar los errores tipográficos y para que sea más fácil personalizar la configuración siguiente para sus necesidades específicas.We are going to use environment variables to limit typing mistakes, and to make it easier for you to customize the following configuration for your specific needs.

Configure esas variables de entorno mediante los comandos siguientes:Set up those environment variables by using the following commands:

AZ_RESOURCE_GROUP=database-workshop
AZ_DATABASE_NAME=<YOUR_DATABASE_NAME>
AZ_LOCATION=<YOUR_AZURE_REGION>
AZ_POSTGRESQL_USERNAME=demo
AZ_POSTGRESQL_PASSWORD=<YOUR_POSTGRESQL_PASSWORD>
AZ_LOCAL_IP_ADDRESS=<YOUR_LOCAL_IP_ADDRESS>

Reemplace los marcadores de posición por los valores siguientes, que se usan a lo largo de este artículo:Replace the placeholders with the following values, which are used throughout this article:

  • <YOUR_DATABASE_NAME>: nombre del servidor de PostgreSQL.<YOUR_DATABASE_NAME>: The name of your PostgreSQL server. Debe ser único en Azure.It should be unique across Azure.
  • <YOUR_AZURE_REGION>: región de Azure que va a usar.<YOUR_AZURE_REGION>: The Azure region you'll use. Puede usar eastus de forma predeterminada, pero se recomienda que configure una región más cercana a la ubicación en la que vive.You can use eastus by default, but we recommend that you configure a region closer to where you live. Puede obtener la lista completa de las regiones disponibles; para ello, escriba az account list-locations.You can have the full list of available regions by entering az account list-locations.
  • <YOUR_POSTGRESQL_PASSWORD>: contraseña del servidor de bases de datos de PostgreSQL.<YOUR_POSTGRESQL_PASSWORD>: The password of your PostgreSQL database server. Esa contraseña debe tener un mínimo de ocho caracteres.That password should have a minimum of eight characters. Debe contener caracteres de tres de las siguientes categorías: Letras del alfabeto inglés mayúsculas y minúsculas, números (0-9) y caracteres no alfanuméricos (!, $, #, %, etc.).The characters should be from three of the following categories: English uppercase letters, English lowercase letters, numbers (0-9), and non-alphanumeric characters (!, $, #, %, and so on).
  • <YOUR_LOCAL_IP_ADDRESS>: dirección IP del equipo local, desde el que se ejecutará la aplicación de Java.<YOUR_LOCAL_IP_ADDRESS>: The IP address of your local computer, from which you'll run your Java application. Una manera cómoda de encontrarla es escribir en el explorador web la dirección whatismyip.akamai.com.One convenient way to find it is to point your browser to whatismyip.akamai.com.

A continuación, cree un grupo de recursos con el siguiente comando:Next, create a resource group by using the following command:

az group create \
    --name $AZ_RESOURCE_GROUP \
    --location $AZ_LOCATION \
  	| jq

Nota

Empleamos la utilidad jq para mostrar datos JSON y hacer que sean más legibles.We use the jq utility to display JSON data and make it more readable. Esta utilidad se instala de manera predeterminada en Azure Cloud Shell.This utility is installed by default on Azure Cloud Shell. Si esa utilidad no es de su agrado, puede quitar de forma segura la parte que hace referencia a | jq de todos los comandos que vamos a utilizar.If you don't like that utility, you can safely remove the | jq part of all the commands we'll use.

Creación de una instancia de Azure Database for PostgreSQLCreate an Azure Database for PostgreSQL instance

Lo primero que crearemos es un servidor administrado de PostgreSQL.The first thing we'll create is a managed PostgreSQL server.

Nota

Puede leer información más detallada sobre la creación de servidores de PostgreSQL en Creación de un servidor de Azure Database for PostgreSQL mediante Azure Portal.You can read more detailed information about creating PostgreSQL servers in Create an Azure Database for PostgreSQL server by using the Azure portal.

En Azure Cloud Shell, ejecute el siguiente comando:In Azure Cloud Shell, run the following command:

az postgres server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME \
    --location $AZ_LOCATION \
    --sku-name B_Gen5_1 \
    --storage-size 5120 \
    --admin-user $AZ_POSTGRESQL_USERNAME \
    --admin-password $AZ_POSTGRESQL_PASSWORD \
  	| jq

Este comando crea un servidor de MySQL pequeño.This command creates a small PostgreSQL server.

Configuración de una regla de firewall para el servidor de PostgreSQLConfigure a firewall rule for your PostgreSQL server

De forma predeterminada, las instancias de Azure Database for PostgreSQL están protegidas.Azure Database for PostgreSQL instances are secured by default. Tienen un firewall que no permite ninguna conexión entrante.They have a firewall that doesn't allow any incoming connection. Para poder usar la base de datos, es necesario agregar una regla de firewall que permita a la dirección IP local acceder al servidor de base de datos.To be able to use your database, you need to add a firewall rule that will allow the local IP address to access the database server.

Como hemos configurado nuestra dirección IP local al principio de este artículo, puede abrir el firewall del servidor con el siguiente comando:Because you configured your local IP address at the beginning of this article, you can open the server's firewall by running the following command:

az postgres server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME-database-allow-local-ip \
    --server $AZ_DATABASE_NAME \
    --start-ip-address $AZ_LOCAL_IP_ADDRESS \
    --end-ip-address $AZ_LOCAL_IP_ADDRESS \
  	| jq

Configuración de una base de datos PostgreSQLConfigure a PostgreSQL database

El servidor de PostgreSQL que creó anteriormente está vacío.The PostgreSQL server that you created earlier is empty. No tiene ninguna base de datos que pueda usar con la aplicación de Java.It doesn't have any database that you can use with the Java application. Cree una nueva base de datos llamada demo con el comando siguiente:Create a new database called demo by using the following command:

az postgres db create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name demo \
    --server-name $AZ_DATABASE_NAME \
  	| jq

Creación de un nuevo proyecto de JavaCreate a new Java project

Con su IDE favorito, cree un nuevo proyecto de Java y agregue un archivo pom.xml en el directorio raíz:Using your favorite IDE, create a new Java project, and add a pom.xml file in its root directory:

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>

    <properties>
        <java.version>1.8</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>42.2.12</version>
        </dependency>
    </dependencies>
</project>

Este archivo es un archivo de Apache Maven que configura el proyecto para usar:This file is an Apache Maven that configures our project to use:

  • Java 8Java 8
  • Un reciente controlador de PostgreSQL para JavaA recent PostgreSQL driver for Java

Preparación de un archivo de configuración para conectarse a Azure Database for PostgreSQLPrepare a configuration file to connect to Azure Database for PostgreSQL

Cree el archivo src/main/resources/application.properties y agregue:Create a src/main/resources/application.properties file, and add:

url=jdbc:postgresql://$AZ_DATABASE_NAME.postgres.database.azure.com:5432/demo?ssl=true&sslmode=require
user=demo@$AZ_DATABASE_NAME
password=$AZ_POSTGRESQL_PASSWORD
  • Reemplace las dos variables $AZ_DATABASE_NAME por el valor que configuró al principio de este artículo.Replace the two $AZ_DATABASE_NAME variables with the value that you configured at the beginning of this article.
  • Reemplace la variable $AZ_POSTGRESQL_PASSWORD por el valor que configuró al principio de este artículo.Replace the $AZ_POSTGRESQL_PASSWORD variable with the value that you configured at the beginning of this article.

Nota

Se anexa ?ssl=true&sslmode=require a la propiedad de configuración url para indicar al controlador de JDBC que use TLS (Seguridad de la capa de transporte) al conectarse a la base de datos.We append ?ssl=true&sslmode=require to the configuration property url, to tell the JDBC driver to use TLS (Transport Layer Security) when connecting to the database. Con Azure Database for PostgreSQL es obligatorio usar TLS, pero además es aconsejable hacerlo por seguridad.It is mandatory to use TLS with Azure Database for PostgreSQL, and it is a good security practice.

Creación de un archivo SQL para generar el esquema de la base de datosCreate an SQL file to generate the database schema

Usaremos el archivo src/main/resources/schema.sql para crear un esquema de la base de datos.We will use a src/main/resources/schema.sql file in order to create a database schema. Cree ese archivo con el siguiente contenido:Create that file, with the following content:

DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);

Incorporación del código de la aplicaciónCode the application

Conectarse a la base de datosConnect to the database

A continuación, agregue el código Java que usará JDBC para almacenar y recuperar datos del servidor de PostgreSQL.Next, add the Java code that will use JDBC to store and retrieve data from your PostgreSQL server.

Cree un archivo src/main/java/DemoApplication.java, que contiene:Create a src/main/java/DemoApplication.java file, that contains:

package com.example.demo;

import java.sql.*;
import java.util.*;
import java.util.logging.Logger;

public class DemoApplication {

    private static final Logger log;

    static {
        System.setProperty("java.util.logging.SimpleFormatter.format", "[%4$-7s] %5$s %n");
        log =Logger.getLogger(DemoApplication.class.getName());
    }

    public static void main(String[] args) throws Exception {
        log.info("Loading application properties");
        Properties properties = new Properties();
        properties.load(DemoApplication.class.getClassLoader().getResourceAsStream("application.properties"));

        log.info("Connecting to the database");
        Connection connection = DriverManager.getConnection(properties.getProperty("url"), properties);
        log.info("Database connection test: " + connection.getCatalog());

        log.info("Create database schema");
        Scanner scanner = new Scanner(DemoApplication.class.getClassLoader().getResourceAsStream("schema.sql"));
        Statement statement = connection.createStatement();
        while (scanner.hasNextLine()) {
            statement.execute(scanner.nextLine());
        }

        /*
        Todo todo = new Todo(1L, "configuration", "congratulations, you have set up JDBC correctly!", true);
        insertData(todo, connection);
        todo = readData(connection);
        todo.setDetails("congratulations, you have updated data!");
        updateData(todo, connection);
        deleteData(todo, connection);
        */

        log.info("Closing database connection");
        connection.close();
    }
}

Este código Java usará los archivos application.properties y schema.sql que se crearon antes para conectarse al servidor de PostgreSQL y crear un esquema que almacenará los datos.This Java code will use the application.properties and the schema.sql files that we created earlier, in order to connect to the PostgreSQL server and create a schema that will store our data.

En este archivo, puede ver que hemos comentado los métodos para insertar, leer, actualizar y eliminar datos: codificaremos esos métodos en el resto de este artículo y podrá quitar los comentarios uno tras otro.In this file, you can see that we commented methods to insert, read, update and delete data: we will code those methods in the rest of this article, and you will be able to uncomment them one after each other.

Nota

Las credenciales de la base de datos se almacenan en las propiedades user (usuario) y password (contraseña) del archivo application.properties.The database credentials are stored in the user and password properties of the application.properties file. Estas credenciales se usan al ejecutar DriverManager.getConnection(properties.getProperty("url"), properties);, ya que el archivo de propiedades se pasa como argumento.Those credentials are used when executing DriverManager.getConnection(properties.getProperty("url"), properties);, as the properties file is passed as an argument.

Ahora puede ejecutar esta clase principal con su herramienta favorita:You can now execute this main class with your favorite tool:

  • Con el IDE, debería poder hacer clic con el botón derecho en la clase DemoApplication y ejecutarla.Using your IDE, you should be able to right-click on the DemoApplication class and execute it.
  • Con Maven, puede ejecutar la aplicación mediante la ejecución de: mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication".Using Maven, you can run the application by executing: mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication".

La aplicación debería conectarse a Azure Database for PostgreSQL, crear un esquema de base de datos y cerrar la conexión, como debería ver en los registros de la consola:The application should connect to the Azure Database for PostgreSQL, create a database schema, and then close the connection, as you should see in the console logs:

[INFO   ] Loading application properties 
[INFO   ] Connecting to the database 
[INFO   ] Database connection test: demo 
[INFO   ] Create database schema 
[INFO   ] Closing database connection 

Creación de una clase de dominioCreate a domain class

Cree la nueva clase de Java Todo, junto a la clase DemoApplication y agregue el siguiente código:Create a new Todo Java class, next to the DemoApplication class, and add the following code:

package com.example.demo;

public class Todo {

    private Long id;
    private String description;
    private String details;
    private boolean done;

    public Todo() {
    }

    public Todo(Long id, String description, String details, boolean done) {
        this.id = id;
        this.description = description;
        this.details = details;
        this.done = done;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getDetails() {
        return details;
    }

    public void setDetails(String details) {
        this.details = details;
    }

    public boolean isDone() {
        return done;
    }

    public void setDone(boolean done) {
        this.done = done;
    }

    @Override
    public String toString() {
        return "Todo{" +
                "id=" + id +
                ", description='" + description + '\'' +
                ", details='" + details + '\'' +
                ", done=" + done +
                '}';
    }
}

Esta clase es un modelo de dominio asignado a la tabla todo que creó al ejecutar el script schema.sql.This class is a domain model mapped on the todo table that you created when executing the schema.sql script.

Inserción de datos en Azure Database for PostgreSQLInsert data into Azure Database for PostgreSQL

En el archivo src/main/java/DemoApplication.java, después del método main, agregue el método siguiente para insertar los datos en la base de datos:In the src/main/java/DemoApplication.java file, after the main method, add the following method to insert data into the database:

private static void insertData(Todo todo, Connection connection) throws SQLException {
    log.info("Insert data");
    PreparedStatement insertStatement = connection
            .prepareStatement("INSERT INTO todo (id, description, details, done) VALUES (?, ?, ?, ?);");

    insertStatement.setLong(1, todo.getId());
    insertStatement.setString(2, todo.getDescription());
    insertStatement.setString(3, todo.getDetails());
    insertStatement.setBoolean(4, todo.isDone());
    insertStatement.executeUpdate();
}

Ahora puede quitar la marca de comentario de las dos líneas siguientes en el método main:You can now uncomment the two following lines in the main method:

Todo todo = new Todo(1L, "configuration", "congratulations, you have set up JDBC correctly!", true);
insertData(todo, connection);

La ejecución de la clase main debería generar ahora la siguiente salida:Executing the main class should now produce the following output:

[INFO   ] Loading application properties 
[INFO   ] Connecting to the database 
[INFO   ] Database connection test: demo 
[INFO   ] Create database schema 
[INFO   ] Insert data 
[INFO   ] Closing database connection

Lectura de datos de Azure Database for PostgreSQLReading data from Azure Database for PostgreSQL

Vamos a leer los datos que se insertaron previamente para validar que el código funciona correctamente.Let's read the data previously inserted, to validate that our code works correctly.

En el archivo src/main/java/DemoApplication.java, después del método insertData, agregue el método siguiente para leer los datos de la base de datos:In the src/main/java/DemoApplication.java file, after the insertData method, add the following method to read data from the database:

private static Todo readData(Connection connection) throws SQLException {
    log.info("Read data");
    PreparedStatement readStatement = connection.prepareStatement("SELECT * FROM todo;");
    ResultSet resultSet = readStatement.executeQuery();
    if (!resultSet.next()) {
        log.info("There is no data in the database!");
        return null;
    }
    Todo todo = new Todo();
    todo.setId(resultSet.getLong("id"));
    todo.setDescription(resultSet.getString("description"));
    todo.setDetails(resultSet.getString("details"));
    todo.setDone(resultSet.getBoolean("done"));
    log.info("Data read from the database: " + todo.toString());
    return todo;
}

Ahora puede quitar la marca de comentario de la línea siguiente en el método main:You can now uncomment the following line in the main method:

todo = readData(connection);

La ejecución de la clase main debería generar ahora la siguiente salida:Executing the main class should now produce the following output:

[INFO   ] Loading application properties 
[INFO   ] Connecting to the database 
[INFO   ] Database connection test: demo 
[INFO   ] Create database schema 
[INFO   ] Insert data 
[INFO   ] Read data 
[INFO   ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have set up JDBC correctly!', done=true} 
[INFO   ] Closing database connection 

Actualización de datos en Azure Database for PostgreSQLUpdating data in Azure Database for PostgreSQL

Vamos a actualizar los datos que se insertaron anteriormente.Let's update the data we previously inserted.

En el archivo src/main/java/DemoApplication.java, después del método readData, agregue el método siguiente para actualizar los datos de la base de datos:Still in the src/main/java/DemoApplication.java file, after the readData method, add the following method to update data inside the database:

private static void updateData(Todo todo, Connection connection) throws SQLException {
    log.info("Update data");
    PreparedStatement updateStatement = connection
            .prepareStatement("UPDATE todo SET description = ?, details = ?, done = ? WHERE id = ?;");

    updateStatement.setString(1, todo.getDescription());
    updateStatement.setString(2, todo.getDetails());
    updateStatement.setBoolean(3, todo.isDone());
    updateStatement.setLong(4, todo.getId());
    updateStatement.executeUpdate();
    readData(connection);
}

Ahora puede quitar la marca de comentario de las dos líneas siguientes en el método main:You can now uncomment the two following lines in the main method:

todo.setDetails("congratulations, you have updated data!");
updateData(todo, connection);

La ejecución de la clase main debería generar ahora la siguiente salida:Executing the main class should now produce the following output:

[INFO   ] Loading application properties 
[INFO   ] Connecting to the database 
[INFO   ] Database connection test: demo 
[INFO   ] Create database schema 
[INFO   ] Insert data 
[INFO   ] Read data 
[INFO   ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have set up JDBC correctly!', done=true} 
[INFO   ] Update data 
[INFO   ] Read data 
[INFO   ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have updated data!', done=true} 
[INFO   ] Closing database connection 

Eliminación de datos en Azure Database for PostgreSQLDeleting data in Azure Database for PostgreSQL

Por último, vamos a eliminar los datos que se insertaron anteriormente.Finally, let's delete the data we previously inserted.

En el archivo src/main/java/DemoApplication.java, después del método updateData, agregue el método siguiente para eliminar los datos de la base de datos:Still in the src/main/java/DemoApplication.java file, after the updateData method, add the following method to delete data inside the database:

private static void deleteData(Todo todo, Connection connection) throws SQLException {
    log.info("Delete data");
    PreparedStatement deleteStatement = connection.prepareStatement("DELETE FROM todo WHERE id = ?;");
    deleteStatement.setLong(1, todo.getId());
    deleteStatement.executeUpdate();
    readData(connection);
}

Ahora puede quitar la marca de comentario de la línea siguiente en el método main:You can now uncomment the following line in the main method:

deleteData(todo, connection);

La ejecución de la clase main debería generar ahora la siguiente salida:Executing the main class should now produce the following output:

[INFO   ] Loading application properties 
[INFO   ] Connecting to the database 
[INFO   ] Database connection test: demo 
[INFO   ] Create database schema 
[INFO   ] Insert data 
[INFO   ] Read data 
[INFO   ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have set up JDBC correctly!', done=true} 
[INFO   ] Update data 
[INFO   ] Read data 
[INFO   ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have updated data!', done=true} 
[INFO   ] Delete data 
[INFO   ] Read data 
[INFO   ] There is no data in the database! 
[INFO   ] Closing database connection 

Limpieza de recursosClean up resources

Felicidades.Congratulations! Ha creado una aplicación de Java que usa JDBC para almacenar y recuperar datos de Azure Database for PostgreSQL.You've created a Java application that uses JDBC to store and retrieve data from Azure Database for PostgreSQL.

Para limpiar todos los recursos utilizados durante esta guía de inicio rápido, elimine el grupo de recursos con el siguiente comando:To clean up all resources used during this quickstart, delete the resource group using the following command:

az group delete \
    --name $AZ_RESOURCE_GROUP \
    --yes

Pasos siguientesNext steps