Condividi tramite

Introduzione alle richieste HTTP di Connessioni ibride di inoltro in Java

  • Articolo

In questa guida introduttiva si creano applicazioni mittente e ricevitore Java che inviano e ricevono messaggi usando il protocollo HTTP. Le applicazioni usano la funzionalità Connessioni ibride di Inoltro di Azure. Per informazioni di carattere generale su Inoltro di Azure, vedere Che cos'è il servizio di inoltro di Azure?.

In questa guida introduttiva vengono completati i passaggi seguenti:

  1. Creare uno spazio dei nomi di inoltro usando il portale di Azure.
  2. Creare una connessione ibrida nello spazio dei nomi usando il portale di Azure.
  3. Scrivere un'applicazione console server (listener) per ricevere messaggi.
  4. Scrivere un'applicazione console client (mittente) per inviare messaggi.
  5. Eseguire le applicazioni.

Prerequisiti

Creare uno spazio dei nomi tramite il portale di Azure

  1. Accedere al portale di Azure.

  2. Scegliere Tutti i servizi dal menu a sinistra. Selezionare Integrazione, cercare Inoltro, spostare il mouse su Inoltro e quindi selezionare Crea.

    Screenshot che mostra la selezione del pulsante Inoltro -> Crea.

  3. Nella pagina Crea spazio dei nomi seguire questa procedura:

    1. Scegliere una sottoscrizione di Azure in cui creare lo spazio dei nomi.

    2. Per Gruppo di risorse scegliere un gruppo di risorse esistente in cui inserire lo spazio dei nomi oppure crearne uno nuovo.

    3. Immettere un nome per lo spazio dei nomi Relay.

    4. Selezionare l'area in cui deve essere ospitato lo spazio dei nomi.

    5. Selezionare Rivedi e crea nella parte inferiore della pagina.

      Screenshot che mostra la pagina Crea spazio dei nomi.

    6. Nella pagina Rivedi e crea selezionare Crea.

    7. Dopo alcuni minuti viene visualizzata la pagina Inoltro per lo spazio dei nomi .

      Screenshot che mostra la home page per lo spazio dei nomi relay.

Ottenere le credenziali di gestione

  1. Nella pagina Inoltro selezionare Criteri di accesso condiviso nel menu a sinistra.

  2. Nella pagina Criteri di accesso condiviso selezionare RootManageSharedAccessKey.

  3. In Criteri di firma di accesso condiviso: RootManageSharedAccessKey selezionare il pulsante Copia accanto a Stringa di connessione primaria. La stringa di connessione viene copiata negli Appunti per un uso successivo. Incollare questo valore nel Blocco note o in un'altra posizione temporanea.

  4. Ripetere il passaggio precedente per copiare e incollare il valore di Chiave primaria in un percorso temporaneo per usarlo in seguito.

    Screenshot che mostra le informazioni di connessione per lo spazio dei nomi relay.

Creare una connessione ibrida usando il portale di Azure

Nella pagina Inoltro per lo spazio dei nomi seguire questa procedura per creare una connessione ibrida.

  1. Nel menu a sinistra, in Entità selezionare Connessioni ibride e quindi + Connessione ibrida.

    Screenshot che mostra la pagina Connessioni ibride.

  2. Nella pagina Crea connessione ibrida immettere un nome per la connessione ibrida e selezionare Crea.

    Screenshot che mostra la pagina Crea connessione ibrida.

Creare un'applicazione server (listener)

Per ascoltare e ricevere messaggi dall'inoltro, scrivere un'applicazione console Java.

Creare un'applicazione Java

Se è stata disabilitata l'opzione "Richiede autorizzazione client" durante la creazione dell'inoltro, è possibile inviare richieste all'URL delle connessioni ibride con qualsiasi browser. Per l'accesso a endpoint protetti, è necessario creare e passare un token nell'intestazione ServiceBusAuthorization, come illustrato di seguito.

Ecco una semplice struttura di progetto Maven e una classe Java che illustra l'invio di richieste a un URL di connessioni ibride con autorizzazione client che usa la libreria di inoltro di Azure.

Aggiungere il pacchetto di inoltro

Modificare il file pom.xml nel pacchetto dell'applicazione maven per includere il pacchetto di inoltro di Azure.

<dependency>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>azure-relay</artifactId>
    <version>0.0.6</version>
</dependency>

Eseguire mvn dependency:copy-dependencies -DoutputDirectory=lib nel progetto mvn per aggiungere il file JAR di dipendenza nella directory lib del progetto. Importa tutte le dipendenze del azure-relay pacchetto mvn. Questo pacchetto fornisce funzioni per costruire gli URI (Uniform Resource Identifier) e i token di inoltro.

Scrivere codice per inviare messaggi

  1. Aggiungere i file jar di dipendenza al ClassPath del Listener.java file.

    javac -cp lib/* src/main/java/com/example/listener/Listener.Java

  2. Importare le dipendenze nella Listener.java classe.

    import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Scanner;
import com.microsoft.azure.relay.HybridConnectionListener;
import com.microsoft.azure.relay.RelayConnectionStringBuilder;
import com.microsoft.azure.relay.RelayedHttpListenerResponse;
import com.microsoft.azure.relay.TokenProvider;

  3. Aggiungere quanto segue constants all'inizio del Listener.java file a una createConnectionString funzione Java per i dettagli della connessione ibrida.

    public static String createConnectionString(){
    StringBuilder connectionString = new StringBuilder();
    connectionString.append("Endpoint=sb://");
    connectionString.append("{namespace}");
    connectionString.append(".servicebus.windows.net/;SharedAccessKeyName=");
    connectionString.append("{keyrule}");
    connectionString.append(";SharedAccessKey=");
    connectionString.append("{key}");
    connectionString.append(";EntityPath=");
    connectionString.append("{path}");
    return connectionString.toString();
}

    Sostituire i segnaposto tra parentesi con i valori ottenuti durante la creazione della connessione ibrida.

    • namespace: spazio dei nomi dell'inoltro. Assicurarsi di usare il nome completo dello spazio dei nomi, ad esempio {namespace}.servicebus.windows.net.
    • path: nome della connessione ibrida.
    • keyrule - Nome della chiave criteri di accesso condiviso, che è RootManageSharedAccessKey per impostazione predefinita.
    • nst key - Chiave primaria dello spazio dei nomi salvato in precedenza.

  4. Aggiungere il codice seguente al file Listener.java. La funzione main dovrebbe essere simile al codice seguente:

    public static void main( String[] args ) throws URISyntaxException
{
    String CONNECTION_STRING_ENV_VARIABLE_NAME = createConnectionString();
    RelayConnectionStringBuilder connectionParams = new RelayConnectionStringBuilder(CONNECTION_STRING_ENV_VARIABLE_NAME);
    TokenProvider tokenProvider = TokenProvider.createSharedAccessSignatureTokenProvider(
                connectionParams.getSharedAccessKeyName(),
                connectionParams.getSharedAccessKey());
    HybridConnectionListener listener = new HybridConnectionListener(new URI(connectionParams.getEndpoint().toString() + connectionParams.getEntityPath()), tokenProvider);

    // The "context" object encapsulates both the incoming request and the outgoing response
    listener.setRequestHandler((context) -> {
        String receivedText = "";
        if (context.getRequest().getInputStream() != null) {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(context.getRequest().getInputStream(), "UTF8"))) {
                StringBuilder builder = new StringBuilder();
                String inputLine;
                while ((inputLine = reader.readLine()) != null) {
                    builder.append(inputLine);
                }
                receivedText = builder.toString();
            } catch (IOException e) {
                System.out.println(e.getMessage());
            }
        }
        System.out.println("requestHandler received " + receivedText);

        RelayedHttpListenerResponse response = context.getResponse();
        response.setStatusCode(202);
        response.setStatusDescription("OK");

        try {
            response.getOutputStream().write(("Echo: " + receivedText).getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }

        // The context MUST be closed for the message to be sent
        response.close();
    });

    listener.openAsync().join();

    Scanner in = new Scanner(System.in);
    System.out.println("Press ENTER to terminate this program.");
    in.nextLine();

    listener.close();
    in.close();
}

    Di seguito è riportato l'aspetto Listener.java del file:

    package com.example.listener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Scanner;
import com.microsoft.azure.relay.HybridConnectionListener;
import com.microsoft.azure.relay.RelayConnectionStringBuilder;
import com.microsoft.azure.relay.RelayedHttpListenerResponse;
import com.microsoft.azure.relay.TokenProvider;

 public class Listener
 {
    public static String createConnectionString(){
        StringBuilder connectionString = new StringBuilder();
        connectionString.append("Endpoint=sb://");
        connectionString.append("{namespace}");
        connectionString.append(".servicebus.windows.net/;SharedAccessKeyName=");
        connectionString.append("{keyrule}");
        connectionString.append(";SharedAccessKey=");
        connectionString.append("{key}");
        connectionString.append(";EntityPath=");
        connectionString.append("{path}");
        return connectionString.toString();
    }

    public static void main( String[] args ) throws URISyntaxException
    {
        String CONNECTION_STRING_ENV_VARIABLE_NAME = createConnectionString();
        RelayConnectionStringBuilder connectionParams = new RelayConnectionStringBuilder(CONNECTION_STRING_ENV_VARIABLE_NAME);
        TokenProvider tokenProvider = TokenProvider.createSharedAccessSignatureTokenProvider(
                    connectionParams.getSharedAccessKeyName(),
                    connectionParams.getSharedAccessKey());
        HybridConnectionListener listener = new HybridConnectionListener(new URI(connectionParams.getEndpoint().toString() + connectionParams.getEntityPath()), tokenProvider);

        // The "context" object encapsulates both the incoming request and the outgoing response
        listener.setRequestHandler((context) -> {
            String receivedText = "";
            if (context.getRequest().getInputStream() != null) {
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(context.getRequest().getInputStream(), "UTF8"))) {
                    StringBuilder builder = new StringBuilder();
                    String inputLine;
                    while ((inputLine = reader.readLine()) != null) {
                        builder.append(inputLine);
                    }
                    receivedText = builder.toString();
                } catch (IOException e) {
                    System.out.println(e.getMessage());
                }
            }
            System.out.println("requestHandler received " + receivedText);

            RelayedHttpListenerResponse response = context.getResponse();
            response.setStatusCode(202);
            response.setStatusDescription("OK");

            try {
                response.getOutputStream().write(("Echo: " + receivedText).getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            }

            // The context MUST be closed for the message to be sent
            response.close();
        });

        listener.openAsync().join();

        Scanner in = new Scanner(System.in);
        System.out.println("Press ENTER to terminate this program.");
        in.nextLine();

        listener.close();
        in.close();
    }
}

Creare un'applicazione client (mittente)

Per inviare messaggi all'inoltro, è possibile usare qualsiasi client HTTP o scrivere un'applicazione console Java.

Creare un'applicazione Java

Se è stata disabilitata l'opzione "Richiede autorizzazione client" durante la creazione dell'inoltro, è possibile inviare richieste all'URL delle connessioni ibride con qualsiasi browser. Per l'accesso a endpoint protetti, è necessario creare e passare un token nell'intestazione ServiceBusAuthorization, come illustrato di seguito.

Ecco una semplice struttura di progetto Maven e una classe Java che illustra l'invio di richieste a un URL di connessioni ibride con autorizzazione client che usa la libreria di inoltro di Azure.

Aggiungere il pacchetto di inoltro

Modificare il file pom.xml nel pacchetto dell'applicazione maven per includere il pacchetto di inoltro di Azure.

<dependency>
	<groupId>com.microsoft.azure</groupId>
	<artifactId>azure-relay</artifactId>
	<version>0.0.6</version>
</dependency>

Eseguire mvn dependency:copy-dependencies -DoutputDirectory=lib nel progetto mvn per aggiungere il file JAR di dipendenza nella directory lib del progetto. Importa anche tutte le dipendenze del azure-relay pacchetto mvn. Questo pacchetto fornisce funzioni per costruire gli URI (Uniform Resource Identifier) e i token di inoltro.

Scrivere codice per inviare messaggi

  1. Aggiungere i file jar di dipendenza al ClassPath del Sender.java file.

    javac -cp lib/* src/main/java/com/example/sender/Sender.Java

  2. Importare le dipendenze nella Sender.java classe.

    import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.time.Duration;
import java.util.Scanner;
import com.microsoft.azure.relay.RelayConnectionStringBuilder;
import com.microsoft.azure.relay.TokenProvider;

  3. Aggiungere quanto segue constants all'inizio del Sender.java file a una createConnectionString funzione Java per i dettagli della connessione ibrida.

    public static String createConnectionString(){
    StringBuilder connectionString = new StringBuilder();
    connectionString.append("Endpoint=sb://");
    connectionString.append("{namespace}");
    connectionString.append(".servicebus.windows.net/;SharedAccessKeyName=");
    connectionString.append("{keyrule}");
    connectionString.append(";SharedAccessKey=");
    connectionString.append("{key}");
    connectionString.append(";EntityPath=");
    connectionString.append("{path}");
    return connectionString.toString();
}

    Sostituire i segnaposto tra parentesi con i valori ottenuti durante la creazione della connessione ibrida.

    • namespace: spazio dei nomi dell'inoltro. Assicurarsi di usare il nome completo dello spazio dei nomi, ad esempio {namespace}.servicebus.windows.net.
    • path: nome della connessione ibrida.
    • keyrule - Nome della chiave criteri di accesso condiviso, che è RootManageSharedAccessKey per impostazione predefinita.
    • nst key - Chiave primaria dello spazio dei nomi salvato in precedenza.

  4. Aggiungere il codice seguente al file Sender.java. La funzione main dovrebbe essere simile al codice seguente.

    public static void main(String[] args) throws IOException {
    String CONNECTION_STRING_ENV_VARIABLE_NAME = createConnectionString();
    if (CONNECTION_STRING_ENV_VARIABLE_NAME == null || CONNECTION_STRING_ENV_VARIABLE_NAME.isEmpty()){
        System.err.println("Connection string is null or empty. Please check your createConnectionString method.");
        return;
    }
    RelayConnectionStringBuilder connectionParams = new RelayConnectionStringBuilder(CONNECTION_STRING_ENV_VARIABLE_NAME);
    TokenProvider tokenProvider = TokenProvider.createSharedAccessSignatureTokenProvider(
            connectionParams.getSharedAccessKeyName(), 
            connectionParams.getSharedAccessKey());
    URL url = buildHttpConnectionURL(connectionParams.getEndpoint().toString(), connectionParams.getEntityPath());
    String tokenString = tokenProvider.getTokenAsync(url.toString(), Duration.ofHours(1)).join().getToken();
    Scanner in = new Scanner(System.in);
    while (true) {
        System.out.println("Press ENTER to terminate this program.");
        String message = in.nextLine();
        int value = System.in.read();
        if (value == '\n' || value == '\r') {
            System.out.println("Terminating the program...");
            break;}
        // Starting a HTTP connection to the listener
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        // Sending an HTTP request to the listener
        // To send a message body, use POST
        conn.setRequestMethod((message == null || message.length() == 0) ? "GET" : "POST");
        conn.setRequestProperty("ServiceBusAuthorization", tokenString);
        conn.setDoOutput(true);
        OutputStreamWriter out = new OutputStreamWriter(conn.getOutputStream());
        out.write(message, 0, message.length());
        out.flush();
        out.close();
        // Reading the HTTP response
        String inputLine;
        BufferedReader reader = null;
        StringBuilder responseBuilder = new StringBuilder();
        try {
            InputStream inputStream = conn.getInputStream();
            reader = new BufferedReader(new InputStreamReader(inputStream));
            System.out.println("status code: " + conn.getResponseCode());
            while ((inputLine = reader.readLine()) != null) {
                responseBuilder.append(inputLine);
            }
            System.out.println("received back " + responseBuilder.toString());
        } catch (IOException e) {
            System.out.println("The listener is offline or could not be reached.");
            break;
        } finally {
            if (reader != null) {
                reader.close();
            }
        }
    }
    in.close();
}

static URL buildHttpConnectionURL(String endpoint, String entity) throws MalformedURLException {
    StringBuilder urlBuilder = new StringBuilder(endpoint + entity);

    // For HTTP connections, the scheme must be https://
    int schemeIndex = urlBuilder.indexOf("://");
    if (schemeIndex < 0) {
        throw new IllegalArgumentException("Invalid scheme from the given endpoint.");
    }
    urlBuilder.replace(0, schemeIndex, "https");
    return new URL(urlBuilder.toString());
}

    Di seguito è riportato l'aspetto Sender.java del file:

    package com.example.sender;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.time.Duration;
import java.util.Scanner;
import com.microsoft.azure.relay.RelayConnectionStringBuilder;
import com.microsoft.azure.relay.TokenProvider;

public class Sender
{
    public static String createConnectionString(){
        StringBuilder connectionString = new StringBuilder();
        connectionString.append("Endpoint=sb://");
        connectionString.append("{namespace}");
        connectionString.append(".servicebus.windows.net/;SharedAccessKeyName=");
        connectionString.append("{keyrule}");
        connectionString.append(";SharedAccessKey=");
        connectionString.append("{key}");
        connectionString.append(";EntityPath=");
        connectionString.append("{path}");
        return connectionString.toString();
        }
    public static void main(String[] args) throws IOException {
        String CONNECTION_STRING_ENV_VARIABLE_NAME = createConnectionString();
        if (CONNECTION_STRING_ENV_VARIABLE_NAME == null || CONNECTION_STRING_ENV_VARIABLE_NAME.isEmpty()){
            System.err.println("Connection string is null or empty. Please check your createConnectionString method.");
            return;
        }
        RelayConnectionStringBuilder connectionParams = new RelayConnectionStringBuilder(CONNECTION_STRING_ENV_VARIABLE_NAME);
        TokenProvider tokenProvider = TokenProvider.createSharedAccessSignatureTokenProvider(
                connectionParams.getSharedAccessKeyName(), 
                connectionParams.getSharedAccessKey());
        URL url = buildHttpConnectionURL(connectionParams.getEndpoint().toString(), connectionParams.getEntityPath());
        String tokenString = tokenProvider.getTokenAsync(url.toString(), Duration.ofHours(1)).join().getToken();
        Scanner in = new Scanner(System.in);
        while (true) {
            System.out.println("Press ENTER to terminate this program.");
            String message = in.nextLine();
            int value = System.in.read();
            if (value == '\n' || value == '\r') {
                System.out.println("Terminating the program...");
                break;}
            // Starting a HTTP connection to the listener
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            // Sending an HTTP request to the listener
            // To send a message body, use POST
            conn.setRequestMethod((message == null || message.length() == 0) ? "GET" : "POST");
            conn.setRequestProperty("ServiceBusAuthorization", tokenString);
            conn.setDoOutput(true);
            OutputStreamWriter out = new OutputStreamWriter(conn.getOutputStream());
            out.write(message, 0, message.length());
            out.flush();
            out.close();
            // Reading the HTTP response
            String inputLine;
            BufferedReader reader = null;
            StringBuilder responseBuilder = new StringBuilder();
            try {
                InputStream inputStream = conn.getInputStream();
                reader = new BufferedReader(new InputStreamReader(inputStream));
                System.out.println("status code: " + conn.getResponseCode());
                while ((inputLine = reader.readLine()) != null) {
                    responseBuilder.append(inputLine);
                }
                System.out.println("received back " + responseBuilder.toString());
            } catch (IOException e) {
                System.out.println("The listener is offline or could not be reached.");
                break;
            } finally {
                if (reader != null) {
                    reader.close();
                }
            }
        }
        in.close();
    }

    static URL buildHttpConnectionURL(String endpoint, String entity) throws MalformedURLException {
        StringBuilder urlBuilder = new StringBuilder(endpoint + entity);

        // For HTTP connections, the scheme must be https://
        int schemeIndex = urlBuilder.indexOf("://");
        if (schemeIndex < 0) {
            throw new IllegalArgumentException("Invalid scheme from the given endpoint.");
        }
        urlBuilder.replace(0, schemeIndex, "https");
        return new URL(urlBuilder.toString());
    }
}

Nota

Il codice di esempio in questo articolo usa un stringa di connessione per eseguire l'autenticazione in uno spazio dei nomi di Inoltro di Azure per semplificare l'esercitazione. È consigliabile usare l'autenticazione con ID Entra di Microsoft negli ambienti di produzione, invece di usare stringa di connessione o firme di accesso condiviso, che possono essere compromesse più facilmente. Per informazioni dettagliate e codice di esempio per l'uso dell'autenticazione di Microsoft Entra ID, vedere Autenticare e autorizzare un'applicazione con Microsoft Entra ID per accedere alle entità di inoltro di Azure e Autenticare un'identità gestita con Microsoft Entra ID per accedere alle risorse di Inoltro di Azure.

Eseguire le applicazioni

  1. Eseguire l'applicazione server: da un prompt dei comandi Java o dal tipo di java -cp <jar_dependency_path> com.example.listener.Listener.javaapplicazione .
  2. Eseguire l'applicazione client: da un prompt dei comandi Java o dal tipo di java -cp <jar_dependency_path> com.example.sender.Sender.javaapplicazione e immettere del testo.
  3. Assicurarsi che la console dell'applicazione server restituisca il testo immesso nell'applicazione client.

Congratulazioni, è stata creata un'applicazione di connessioni ibride end-to-end usando Java.

Passaggi successivi

In questa guida introduttiva sono state create applicazioni client e server Java che hanno usato HTTP per inviare e ricevere messaggi. La funzionalità Connessioni ibride di Inoltro di Azure supporta anche l'uso di WebSocket per l'invio e la ricezione di messaggi. Per informazioni sull'uso di WebSocket con Connessioni ibride di Inoltro di Azure, vedere la guida introduttiva di WebSocket.

In questa guida introduttiva è stato usato Java per creare applicazioni client e server. Per informazioni su come scrivere applicazioni client e server con .NET Framework, vedere la guida introduttiva di WebSocket .NET o la guida introduttiva di HTTP .NET.