Snabbstart: Använda Java och JDBC med Azure Database for PostgreSQL

Det här avsnittet visar hur du skapar ett exempelprogram som använder Java och JDBC för att lagra och hämta information i Azure Database for PostgreSQL.

JDBC är java-standard-API:et för att ansluta till traditionella relationsdatabaser.

Förutsättningar

• Ett Azure-konto. Om du inte har någon kan du skaffa en kostnadsfri utvärderingsversion.
• Azure Cloud Shell eller Azure CLI. Vi rekommenderar Azure Cloud Shell så att du loggas in automatiskt och har åtkomst till alla verktyg som du behöver.
• Ett Java Development Kit ,version 8 som stöds (ingår i Azure Cloud Shell).
• Apache Maven-byggverktyget.

Förbereda arbetsmiljön

Vi kommer att använda miljövariabler för att begränsa skrivfel och för att göra det enklare för dig att anpassa följande konfiguration för dina specifika behov.

Konfigurera dessa miljövariabler med hjälp av följande kommandon:

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>

Ersätt platshållarna med följande värden, som används i hela artikeln:

• <YOUR_DATABASE_NAME>: Namnet på PostgreSQL-servern. Det ska vara unikt i Azure.
• <YOUR_AZURE_REGION>: Den Azure-region som du ska använda. Du kan använda eastus som standard, men vi rekommenderar att du konfigurerar den region som är närmast dig. Du kan ha en fullständig lista över tillgängliga regioner genom att ange az account list-locations .
• <YOUR_POSTGRESQL_PASSWORD>: Lösenordet för PostgreSQL-databasservern. Lösenordet måste innehålla minst åtta tecken. Tecknen måste komma från tre av följande kategorier: Engelska versaler, engelska gemener, siffror (0–9) och specialtecken (som !, $, # eller %).
• <YOUR_LOCAL_IP_ADDRESS>: IP-adressen för den lokala datorn som du ska köra Java-programmet från. Ett praktiskt sätt att hitta det är att peka webbläsaren på whatismyip.akamai.com.

Skapa sedan en resursgrupp med hjälp av följande kommando:

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

Skapa en Azure Database for PostgreSQL instans

Det första vi skapar är en hanterad PostgreSQL-server.

I Azure Cloud Shellkör du följande kommando:

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

Det här kommandot skapar en liten PostgreSQL-server.

Konfigurera en brandväggsregel för PostgreSQL-servern

Azure Database for PostgreSQL-instanser skyddas som standard. Databaserna har en brandvägg som inte tillåter inkommande anslutningar. För att kunna använda databasen måste du lägga till en brandväggsregel som tillåter att den lokala IP-adressen får åtkomst till databasservern.

Eftersom du konfigurerade din lokala IP-adress i början av den här artikeln kan du öppna serverns brandvägg genom att köra följande kommando:

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

Konfigurera en PostgreSQL-databas

PostgreSQL-servern som du skapade tidigare är tom. Den har ingen databas som du kan använda med Java-programmet. Skapa en ny databas med demo namnet med hjälp av följande kommando:

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

Skapa ett nytt Java-projekt

Skapa ett nytt Java-projekt med hjälp av din favorit-IDE och lägg till pom.xml en fil i rotkatalogen:

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

Den här filen är en Apache Maven som konfigurerar vårt projekt att använda:

• Java 8
• En ny postgreSQL-drivrutin för Java

Förbereda en konfigurationsfil för att ansluta till Azure Database for PostgreSQL

Skapa en src/main/resources/application.properties-fil och lägg till:

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

• Ersätt de två $AZ_DATABASE_NAME variablerna med värdet som du konfigurerade i början av den här artikeln.
• Ersätt $AZ_POSTGRESQL_PASSWORD variabeln med det värde som du konfigurerade i början av den här artikeln.

Skapa en SQL fil för att generera databasschemat

Vi använder en src/main/resources/-fil schema.sql för att skapa ett databasschema. Skapa filen med följande innehåll:

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

Koda appen

Ansluta till databasen

Lägg sedan till Java-koden som ska använda JDBC för att lagra och hämta data från PostgreSQL-servern.

Skapa en src/main/java/DemoApplication.java-fil som innehåller:

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

Den här Java-koden använder filerna application.properties och schema.sql som vi skapade tidigare för att ansluta till PostgreSQL-servern och skapa ett schema som lagrar våra data.

I den här filen ser du att vi kommenterade metoder för att infoga, läsa, uppdatera och ta bort data. Vi kodar dessa metoder i resten av den här artikeln och du kommer att kunna avkommentera dem en efter varandra.

Nu kan du köra den här huvudklassen med ditt favoritverktyg:

• Med din IDE bör du kunna högerklicka på klassen DemoApplication och köra den.
• Med Maven kan du köra programmet genom att köra: mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication" .

Programmet ska ansluta till Azure Database for PostgreSQL, skapa ett databasschema och sedan stänga anslutningen, som du ser i konsolloggarna:

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

Skapa en domänklass

Skapa en ny Todo Java-klass bredvid DemoApplication klassen och lägg till följande kod:

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

Den här klassen är en domänmodell som mappats i todo tabellen som du skapade när du kör skriptet schema.sql.

Infoga data i Azure Database for PostgreSQL

I filen src/main/java/DemoApplication.java, efter main-metoden, lägger du till följande metod för att infoga data i databasen:

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

Nu kan du avkommenteringen av de två följande raderna i main metoden :

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

Nu bör följande utdata visas när huvudklassen körs:

[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

Läsa data från Azure Database for PostgreSQL

Nu ska vi läsa in tidigare infogade data för att verifiera att koden fungerar korrekt.

I filen src/main/java/DemoApplication.java efter metoden lägger du till följande metod för insertData att läsa data från databasen:

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

Nu kan du avkommenteringen av följande rad i main metoden :

todo = readData(connection);

Nu bör följande utdata visas när huvudklassen körs:

[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 

Uppdatera data i Azure Database for PostgreSQL

Nu ska vi uppdatera de data som vi tidigare infogade.

När du är kvar i filen src/main/java/DemoApplication.java efter metoden lägger du till följande metod för readData att uppdatera data i databasen:

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

Nu kan du avkommenteringen av de två följande raderna i main metoden :

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

Nu bör följande utdata visas när huvudklassen körs:

[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 

Ta bort data i Azure Database for PostgreSQL

Slutligen tar vi bort de data som vi infogade tidigare.

När du är kvar i filen src/main/java/DemoApplication.java efter metoden lägger du till följande metod för att updateData ta bort data i databasen:

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

Nu kan du avkommenteringen av följande rad i main metoden :

deleteData(todo, connection);

Nu bör följande utdata visas när huvudklassen körs:

[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 

Rensa resurser

Grattis! Du har skapat ett Java-program som använder JDBC för att lagra och hämta data från Azure Database for PostgreSQL.

Om du vill rensa alla resurser som används i den här snabbstarten tar du bort resursgruppen med följande kommando:

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

Nästa steg