Snabbstart: Använda Java och JDBC med Azure Database for PostgreSQL
GÄLLER FÖR: Azure Database for PostgreSQL – enskild server
Viktigt!
Azure Database for PostgreSQL – enskild server är på väg att dras tillbaka. Vi rekommenderar starkt att du uppgraderar till Azure Database for PostgreSQL – flexibel server. Mer information om hur du migrerar till Azure Database for PostgreSQL – flexibel server finns i Vad händer med Azure Database for PostgreSQL – enskild server?.
Den här artikeln 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.
I den här artikeln innehåller vi två autentiseringsmetoder: Microsoft Entra-autentisering och PostgreSQL-autentisering. Fliken Lösenordslös visar Microsoft Entra-autentiseringen och fliken Lösenord visar PostgreSQL-autentisering.
Microsoft Entra-autentisering är en mekanism för att ansluta till Azure Database for PostgreSQL med hjälp av identiteter som definierats i Microsoft Entra-ID. Med Microsoft Entra-autentisering kan du hantera databasanvändares identiteter och andra Microsoft usluge på en central plats, vilket förenklar behörighetshanteringen.
PostgreSQL-autentisering använder konton som lagras i PostgreSQL. Om du väljer att använda lösenord som autentiseringsuppgifter för kontona lagras dessa autentiseringsuppgifter i user
tabellen. Eftersom dessa lösenord lagras i PostgreSQL måste du hantera rotationen av lösenorden själv.
Förutsättningar
- Ett Azure-konto. Om du inte har redan har en kan du skaffa en kostnadsfri utvärderingsversion.
- Azure Cloud Shell eller Azure CLI 2.37.0 eller senare krävs. Vi rekommenderar Azure Cloud Shell så att du loggas in automatiskt och har åtkomst till alla verktyg du behöver.
- Ett Java Development Kit som stöds, version 8 (ingår i Azure Cloud Shell).
- Apache Maven-byggverktyget.
Förbereda arbetsmiljön
Konfigurera först vissa miljövariabler. Kör följande kommandon i Azure Cloud Shell:
export AZ_RESOURCE_GROUP=database-workshop
export AZ_DATABASE_SERVER_NAME=<YOUR_DATABASE_SERVER_NAME>
export AZ_DATABASE_NAME=demo
export AZ_LOCATION=<YOUR_AZURE_REGION>
export AZ_POSTGRESQL_AD_NON_ADMIN_USERNAME=<YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>
export AZ_LOCAL_IP_ADDRESS=<YOUR_LOCAL_IP_ADDRESS>
export CURRENT_USERNAME=$(az ad signed-in-user show --query userPrincipalName -o tsv)
export CURRENT_USER_OBJECTID=$(az ad signed-in-user show --query id -o tsv)
Ersätt platshållarna med följande värden, som används i hela artikeln:
<YOUR_DATABASE_SERVER_NAME>
: Namnet på din PostgreSQL-server, som ska vara unik i Hela Azure.<YOUR_AZURE_REGION>
: Den Azure-region som du ska använda. Du kan användaeastus
som standard, men vi rekommenderar att du konfigurerar den region som är närmast dig. Du kan se den fullständiga listan över tillgängliga regioner genom att angeaz account list-locations
.<YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>
: Användarnamnet för postgreSQL-databasservern. Kontrollera att användarnamnet är en giltig användare i din Microsoft Entra-klientorganisation.<YOUR_LOCAL_IP_ADDRESS>
: IP-adressen för den lokala datorn som du ska köra Spring Boot-programmet från. Ett praktiskt sätt att hitta det är att öppna whatismyip.akamai.com.
Viktigt!
När du anger <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME> måste användarnamnet redan finnas i din Microsoft Entra-klientorganisation, annars kan du inte skapa en Microsoft Entra-användare i databasen.
Skapa sedan en resursgrupp med hjälp av följande kommando:
az group create \
--name $AZ_RESOURCE_GROUP \
--location $AZ_LOCATION \
--output tsv
Skapa en Azure Database for PostgreSQL-instans
I följande avsnitt beskrivs hur du skapar och konfigurerar din databasinstans.
Skapa en PostgreSQL-server och konfigurera administratörsanvändare
Det första du skapar är en hanterad PostgreSQL-server med en administratörsanvändare.
Kommentar
Du kan läsa mer detaljerad information om hur du skapar PostgreSQL-servrar i Skapa en Azure Database for PostgreSQL-server med hjälp av Azure-portalen.
Om du använder Azure CLI kör du följande kommando för att se till att det har tillräcklig behörighet:
az login --scope https://graph.microsoft.com/.default
Kör sedan följande kommando för att skapa servern:
az postgres server create \
--resource-group $AZ_RESOURCE_GROUP \
--name $AZ_DATABASE_SERVER_NAME \
--location $AZ_LOCATION \
--sku-name B_Gen5_1 \
--storage-size 5120 \
--output tsv
Kör nu följande kommando för att ange Microsoft Entra-administratörsanvändaren:
az postgres server ad-admin create \
--resource-group $AZ_RESOURCE_GROUP \
--server-name $AZ_DATABASE_SERVER_NAME \
--display-name $CURRENT_USERNAME \
--object-id $CURRENT_USER_OBJECTID
Viktigt!
När du anger administratör läggs en ny användare till i Azure Database for PostgreSQL-servern med fullständig administratörsbehörighet. Endast en Microsoft Entra-administratör kan skapas per PostgreSQL-server och val av en annan skriver över den befintliga Microsoft Entra-administratören som konfigurerats för servern.
Det här kommandot skapar en liten PostgreSQL-server och anger Active Directory-administratören till den inloggade användaren.
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 gör att den lokala IP-adressen kan komma åt 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_SERVER_NAME-database-allow-local-ip \
--server $AZ_DATABASE_SERVER_NAME \
--start-ip-address $AZ_LOCAL_IP_ADDRESS \
--end-ip-address $AZ_LOCAL_IP_ADDRESS \
--output tsv
Om du ansluter till PostgreSQL-servern från Windows podsistem za Linux (WSL) på en Windows-dator måste du lägga till WSL-värd-ID:t i brandväggen.
Hämta IP-adressen för värddatorn genom att köra följande kommando i WSL:
cat /etc/resolv.conf
Kopiera IP-adressen efter termen nameserver
och använd sedan följande kommando för att ange en miljövariabel för WSL IP-adressen:
AZ_WSL_IP_ADDRESS=<the-copied-IP-address>
Använd sedan följande kommando för att öppna serverns brandvägg till din WSL-baserade app:
az postgres server firewall-rule create \
--resource-group $AZ_RESOURCE_GROUP \
--name $AZ_DATABASE_SERVER_NAME-database-allow-local-ip \
--server $AZ_DATABASE_SERVER_NAME \
--start-ip-address $AZ_WSL_IP_ADDRESS \
--end-ip-address $AZ_WSL_IP_ADDRESS \
--output tsv
Konfigurera en PostgreSQL-databas
PostgreSQL-servern som du skapade tidigare är tom. Använd följande kommando för att skapa en ny databas.
az postgres db create \
--resource-group $AZ_RESOURCE_GROUP \
--name $AZ_DATABASE_NAME \
--server-name $AZ_DATABASE_SERVER_NAME \
--output tsv
Skapa en PostgreSQL-användare som inte är administratör och bevilja behörighet
Skapa sedan en icke-administratörsanvändare och bevilja alla behörigheter till databasen.
Kommentar
Du kan läsa mer detaljerad information om hur du skapar PostgreSQL-användare i Skapa användare i Azure Database for PostgreSQL.
Skapa ett SQL-skript med namnet create_ad_user.sql för att skapa en icke-administratörsanvändare. Lägg till följande innehåll och spara det lokalt:
cat << EOF > create_ad_user.sql
SET aad_validate_oids_in_tenant = off;
CREATE ROLE "$AZ_POSTGRESQL_AD_NON_ADMIN_USERNAME" WITH LOGIN IN ROLE azure_ad_user;
GRANT ALL PRIVILEGES ON DATABASE $AZ_DATABASE_NAME TO "$AZ_POSTGRESQL_AD_NON_ADMIN_USERNAME";
EOF
Använd sedan följande kommando för att köra SQL-skriptet för att skapa microsoft Entra-användaren som inte är administratör:
psql "host=$AZ_DATABASE_SERVER_NAME.postgres.database.azure.com user=$CURRENT_USERNAME@$AZ_DATABASE_SERVER_NAME dbname=$AZ_DATABASE_NAME port=5432 password=$(az account get-access-token --resource-type oss-rdbms --output tsv --query accessToken) sslmode=require" < create_ad_user.sql
Använd nu följande kommando för att ta bort den tillfälliga SQL-skriptfilen:
rm create_ad_user.sql
Skapa ett nytt Java-projekt
Använd din favorit-IDE, skapa ett nytt Java-projekt med Java 8 eller senare och lägg till en pom.xml fil i rotkatalogen med följande innehåll:
<?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.3.6</version>
</dependency>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity-extensions</artifactId>
<version>1.0.0</version>
</dependency>
</dependencies>
</project>
Den här filen är en Apache Maven-fil som konfigurerar ditt projekt att använda Java 8 och en postgreSQL-drivrutin för Java nyligen.
Förbereda en konfigurationsfil för att ansluta till Azure Database for PostgreSQL
Skapa en src/main/resources/application.properties-fil och lägg sedan till följande innehåll:
cat << EOF > src/main/resources/application.properties
url=jdbc:postgresql://${AZ_DATABASE_SERVER_NAME}.postgres.database.azure.com:5432/${AZ_DATABASE_NAME}?sslmode=require&authenticationPluginClassName=com.azure.identity.extensions.jdbc.postgresql.AzurePostgresqlAuthenticationPlugin
user=${AZ_POSTGRESQL_AD_NON_ADMIN_USERNAME}@${AZ_DATABASE_SERVER_NAME}
EOF
Kommentar
Konfigurationsegenskapen url
har ?sslmode=require
lagts till för att instruera JDBC-drivrutinen att använda TLS (Transport Layer Security) vid anslutning till databasen. Att använda TLS är obligatoriskt med Azure Database for PostgreSQL, och det är en bra säkerhetspraxis.
Skapa en SQL-fil för att generera databasschemat
Du använder en src/main/resources/schema.sql-fil för att skapa ett databasschema. Skapa filen och lägg sedan till följande innehåll:
cat << EOF > src/main/resources/schema.sql
DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);
EOF
Koda appen
Ansluta till databasen
Lägg sedan till Java-koden som använder JDBC för att lagra och hämta data från PostgreSQL-servern.
Skapa en src/main/java/DemoApplication.java-fil och lägg sedan till följande innehåll:
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());
}
/* Prepare for data processing in the PostgreSQL server.
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 application.properties och de schema.sql filer som du skapade tidigare för att ansluta till PostgreSQL-servern och skapa ett schema som lagrar dina data.
I den här filen kan du se att vi har kommenterat metoder för att infoga, läsa, uppdatera och ta bort data. Du kodar dessa metoder i resten av den här artikeln och du kommer att kunna avkommenteras en efter en.
Kommentar
Databasautentiseringsuppgifterna lagras i user
egenskaperna för password
filen application.properties. Dessa autentiseringsuppgifter används när du kör DriverManager.getConnection(properties.getProperty("url"), properties);
, eftersom egenskapsfilen skickas som ett argument.
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 med hjälp av följande kommando:
mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication"
.
Programmet bör ansluta till Azure Database for PostgreSQL, skapa ett databasschema och sedan stänga anslutningen, som du bör se 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 mappas i tabellen todo
som du skapade när du körde schema.sql skriptet.
Infoga data i Azure Database for PostgreSQL
I filen src/main/java/DemoApplication.java lägger du efter huvudmetoden 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();
}
Du kan nu avkommenta de två följande raderna main
i metoden:
Todo todo = new Todo(1L, "configuration", "congratulations, you have set up JDBC correctly!", true);
insertData(todo, connection);
Körning av huvudklassen bör nu generera följande utdata:
[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
Om du vill verifiera att koden fungerar korrekt läser du de data som du tidigare infogade.
I filen src/main/java/DemoApplication.java lägger du efter insertData
metoden till följande metod för 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;
}
Du kan nu avkommentara följande rad i main
metoden:
todo = readData(connection);
Körning av huvudklassen bör nu generera följande utdata:
[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
Uppdatera sedan de data som du infogade tidigare.
I filen src/main/java/DemoApplication.java lägger du efter readData
metoden till följande metod för 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);
}
Du kan nu avkommenta de två följande raderna main
i metoden:
todo.setDetails("congratulations, you have updated data!");
updateData(todo, connection);
Körning av huvudklassen bör nu generera följande utdata:
[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
Ta slutligen bort de data som du infogade tidigare.
I filen src/main/java/DemoApplication.java lägger du efter updateData
metoden till följande metod för att 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);
}
Du kan nu avkommentara följande rad i main
metoden:
deleteData(todo, connection);
Körning av huvudklassen bör nu generera följande utdata:
[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 under den här snabbstarten tar du bort resursgruppen med följande kommando:
az group delete \
--name $AZ_RESOURCE_GROUP \
--yes