Rychlý start: Použití Javy a JDBC s Azure Database for PostgreSQL

Toto téma ukazuje vytvoření ukázkové aplikace, která používá Javu a JDBC k ukládání a načítání informací v Azure Database for PostgreSQL.

JDBC je standardní rozhraní Java API pro připojení k tradičním relačním databázím.

Požadavky

• Účet Azure: Pokud ho nemáte, získejte bezplatnou zkušební verzi.
• Azure Cloud Shell nebo Azure CLI. Doporučujeme Azure Cloud Shell, abyste se přihlásili automaticky a měli přístup ke všem nástrojům, které budete potřebovat.
• Podporovaná sada Java Development Kitverze 8 (zahrnutá v Azure Cloud Shell).
• Nástroj pro sestavování Apache Maven.

Příprava pracovního prostředí

Proměnné prostředí použijeme k omezení chyb při psaní a usnadníme vám přizpůsobení následující konfigurace pro vaše konkrétní potřeby.

Nastavte tyto proměnné prostředí pomocí následujících příkazů:

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>

Zástupné symboly nahraďte následujícími hodnotami, které se používají v tomto článku:

• <YOUR_DATABASE_NAME>: Název vašeho serveru PostgreSQL. Měl by být jedinečný v rámci Azure.
• <YOUR_AZURE_REGION>: Oblast Azure, kterou budete používat. Standardně můžete použít eastus, ale doporučujeme nakonfigurovat oblast blíže k místu, kde se nacházíte. Úplný seznam dostupných oblastí můžete získat zadáním az account list-locations .
• <YOUR_POSTGRESQL_PASSWORD>: Heslo vašeho databázového serveru PostgreSQL. Toto heslo by mělo mít minimálně osm znaků. Znaky by měly pocházet z následujících tří kategorií: Velká písmena anglické abecedy, malá písmena anglické abecedy, číslice (0–9) a jiné než alfanumerické znaky (!, $, #, % atd.).
• <YOUR_LOCAL_IP_ADDRESS>: IP adresa místního počítače, ze kterého budete spouštět svou aplikaci v Javě. Pohodlným způsobem, jak ho najít, je nasuovat prohlížeč na whatismyip.akamai.com.

Dále vytvořte skupinu prostředků pomocí následujícího příkazu:

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

Vytvoření Azure Database for PostgreSQL instance

První věc, kterou vytvoříme, je spravovaný server PostgreSQL.

V Azure Cloud Shellspusťte následující příkaz:

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

Tento příkaz vytvoří malý server PostgreSQL.

Konfigurace pravidla brány firewall pro server PostgreSQL

Azure Database for PostgreSQL instance jsou ve výchozím nastavení zabezpečené. Obsahuje bránu firewall, která nepovoluje žádné příchozí připojení. Abyste mohli používat databázi, musíte přidat pravidlo brány firewall, které umožní přístup k databázovému serveru místní IP adrese.

Vzhledem k tomu, že jste na začátku tohoto článku nakonfigurovali svou místní IP adresu, můžete otevřít bránu firewall serveru spuštěním následujícího příkazu:

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

Konfigurace databáze PostgreSQL

Server PostgreSQL, který jste vytvořili dříve, je prázdný. Nemá žádnou databázi, kterou byste mohli použít s aplikací v Javě. Vytvořte novou databázi s názvem demo pomocí následujícího příkazu:

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

Vytvoření nového projektu v Javě

Pomocí svého oblíbeného integrovaného vývojového prostředí (IDE) vytvořte nový projekt Java a pom.xml do jeho kořenového adresáře přidejte soubor:

<?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>

Tento soubor je Apache Maven, který nakonfiguruje náš projekt pro použití:

• Java 8
• Nedávný ovladač PostgreSQL pro Javu

Příprava konfiguračního souboru pro připojení k Azure Database for PostgreSQL

Vytvořte soubor src/main/resources/application.properties a přidejte:

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

• Nahraďte $AZ_DATABASE_NAME dvě proměnné hodnotou, kterou jste nakonfigurovali na začátku tohoto článku.
• Nahraďte $AZ_POSTGRESQL_PASSWORD proměnnou hodnotou, kterou jste nakonfigurovali na začátku tohoto článku.

Vytvoření SQL k vygenerování schématu databáze

K vytvoření schématu databáze použijeme schema.sql soubor src/main/resources/. Vytvořte tento soubor s následujícím obsahem:

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

Vytvoření kódu aplikace

Připojte se k databázi.

Dále přidejte kód Java, který bude používat JDBC k ukládání a načítání dat ze serveru PostgreSQL.

Vytvořte soubor src/main/java/DemoApplication.java, který obsahuje:

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();
    }
}

Tento kód Java bude používat soubory application.properties a schema.sql, které jsme vytvořili dříve, aby se mohl připojit k serveru PostgreSQL a vytvořit schéma, ve které se budou ukládat naše data.

V tomto souboru vidíte, že jsme komentovali metody vkládání, čtení, aktualizace a odstraňování dat: Tyto metody budeme kódovat ve zbývající části tohoto článku a budete je moct odkomentovat jeden po druhém.

Teď můžete tuto hlavní třídu spustit pomocí svého oblíbeného nástroje:

• Pomocí integrovaného vývojového prostředí byste měli být schopni kliknout pravým tlačítkem na třídu DemoApplication a spustit ji.
• Pomocí Mavenu můžete aplikaci spustit spuštěním příkazu : mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication" .

Aplikace by se měla připojit k Azure Database for PostgreSQL, vytvořit schéma databáze a pak připojení zavřít, jak byste měli vidět v protokolech konzoly:

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

Vytvoření třídy domény

Vytvořte novou třídu Java vedle třídy a Todo DemoApplication přidejte následující kód:

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 +
                '}';
    }
}

Tato třída je doménový model mapovaný na todo tabulku, kterou jste vytvořili při provádění skriptu schema.sql.

Vložení dat do Azure Database for PostgreSQL

V souboru src/main/java/DemoApplication.java přidejte za metodu main následující metodu pro vložení dat do databáze:

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();
}

V metodě teď můžete odkomentovat následující dva main řádky:

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

Spuštění hlavní třídy by teď mělo produkci následujícího výstupu:

[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

Čtení dat z Azure Database for PostgreSQL

Pojďme si přečíst dříve vložená data, abyste ověřili, že náš kód funguje správně.

V souboru src/main/java/DemoApplication.java přidejte za metodu následující metodu pro čtení insertData dat z databáze:

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;
}

V metodě teď můžete odkomentovat následující main řádek:

todo = readData(connection);

Spuštění hlavní třídy by teď mělo produkci následujícího výstupu:

[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 

Aktualizace dat v Azure Database for PostgreSQL

Pojďme aktualizovat data, která jsme vložili dříve.

V souboru src/main/java/DemoApplication.java přidejte za metodu následující metodu pro aktualizaci readData dat v databázi:

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);
}

V metodě teď můžete odkomentovat následující dva main řádky:

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

Spuštění hlavní třídy by teď mělo produkci následujícího výstupu:

[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 

Odstranění dat v Azure Database for PostgreSQL

Nakonec odstraníme data, která jsme vložili dříve.

V souboru src/main/java/DemoApplication.java přidejte za metodu následující metodu updateData odstranění dat v databázi:

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);
}

V metodě teď můžete odkomentovat následující main řádek:

deleteData(todo, connection);

Spuštění hlavní třídy by teď mělo produkci následujícího výstupu:

[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 

Vyčištění prostředků

Gratulujeme! Vytvořili jste aplikaci v Javě, která používá JDBC k ukládání a načítání dat z Azure Database for PostgreSQL.

Pokud chcete vyčistit všechny prostředky použité během tohoto rychlého startu, odstraňte skupinu prostředků pomocí následujícího příkazu:

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

Další kroky