Introdução às solicitações HTTP de Conexões Híbridos de Retransmissão no Java

• NET
• Node.js

Neste início rápido, você criará aplicativos Java remetente e receptor que enviam e recebem mensagens usando o protocolo HTTP. Os aplicativos usam o recurso Conexões Híbridas da Retransmissão do Azure. Para saber mais sobre a Retransmissão do Azure em geral, confira Retransmissão do Azure.

Neste início rápido, você segue os seguintes passos:

1. Criar um namespace de Retransmissão usando o Portal do Azure.
2. Crie uma conexão híbrida nesse namespace usando o Portal do Azure.
3. Escreva um aplicativo de console do servidor (ouvinte) para receber mensagens.
4. Escreva um aplicativo de console de cliente (remetente) para enviar mensagens.
5. Execute aplicativos.

Pré-requisitos

• Java. Certifique-se de que está executando o JDK 1.8+
• Maven. Certifique-se de que o Maven está instalado
• SDK de Retransmissão do Azure. Examinar o SDK do Java
• Uma assinatura do Azure. Se você não tiver uma conta gratuita, crie uma antes de começar.

Criar um namespace usando o portal do Azure

1. Entre no portal do Azure.

2. Selecione Todos os serviços no menu esquerdo. Selecione Integração, procure por Retransmissões, passe o mouse sobre Retransmissões e clique em Criar.

   

3. Na página Criar namespace, siga estas etapas:

   1. Escolha uma assinatura do Azure na qual criar o namespace.

   2. Em Grupo de recursos, escolha um grupo de recursos existente no qual colocar o namespace ou crie um.

   3. Insira um nome para o namespace de Retransmissão.

   4. Selecione o país ou região no qual o namespace deve ser hospedado.

   5. Selecione Revisar + criar na parte inferior da página.

      

   6. Na página Examinar + criar escolha Criar.

   7. Depois de alguns minutos, você verá a página de Retransmissão do namespace.

      

Obter credenciais de gerenciamento

1. Na página Retransmissão, selecione Políticas de acesso compartilhado no menu à esquerda. `

2. Na página Políticas de acesso compartilhado, selecione RootManageSharedAccessKey.

3. Em Política de SAS: RootManageSharedAccessKey, clique no botão Copiar ao lado da opção Cadeia de Conexão Primária. Isso copiará a cadeia de conexão para a área de transferência para uso posterior. Cole esse valor no Bloco de notas ou em outro local temporário.

4. Repita a etapa anterior para copiar e colar o valor de Chave primária para um local temporário para uso posterior.

   

Criar uma conexão híbrida usando o portal do Azure

Na página Retransmissão para seu namespace, siga estas etapas para criar uma conexão híbrida.

1. No menu à esquerda, em Entidades, selecione Conexões Híbridas e selecione + Conexão Híbrida.

   

2. Na página Criar Conexão Híbrida, insira um nome para a conexão híbrida e selecione Criar.

   

Criar um aplicativo de servidor (escuta)

Para escutar e receber mensagens da Retransmissão, escreva um aplicativo de console Java.

Criar um aplicativo Java

Se tiver desativado a opção "Requer Autorização do Cliente" ao criar a Retransmissão, você poderá enviar solicitações para a URL de Conexões Híbridas com qualquer navegador. Para acessar os pontos de extremidade protegidos, você precisa criar e passar um token no cabeçalho ServiceBusAuthorization, que é mostrado aqui.

Aqui está uma estrutura do projeto Maven simples e uma classe Java que demonstra o envio de solicitações para uma URL de Conexões Híbridas com autorização do cliente utilizando a biblioteca de Retransmissão do Azure.

Adicionar o pacote de Retransmissão

Modifique seu arquivo pom.xml no seu pacote de aplicativos do Maven para incluir o pacote de Retransmissão do Azure.

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

Execute mvn dependency:copy-dependencies -DoutputDirectory=lib em seu projeto mvn para adicionar o arquivo jar de dependência no diretório lib do seu projeto. Ele importa todas as dependências do pacote mvn do azure-relay. Esse pacote fornece funções para construir identificadores de recursos uniformes (URIs) e tokens de Retransmissão.

Escrever código para enviar mensagens

1. Adicione os arquivos jar de dependência ao ClassPath do arquivo Listener.java.

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

2. Importe as dependências para a classe Listener.java.

   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. Adicione o seguinte constants à parte superior do arquivo Listener.java a uma função java createConnectionString para obter os detalhes da conexão híbrida.

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

   Substitua os espaços reservados entre colchetes pelos valores obtidos quando você criou a conexão híbrida.

   • namespace - o namespace de retransmissão. Use o nome totalmente qualificado do namespace, por exemplo, {namespace}.servicebus.windows.net.
   • path - o nome da conexão híbrida.
   • keyrule — Nome da sua chave de Políticas de Acesso Compartilhado, que é RootManageSharedAccessKey por padrão.
   • nst key — A chave primária do namespace que você salvou anteriormente.

4. Adicione o seguinte código ao arquivo Listener.java. A função principal deverá se parecer com o seguinte código:

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

   Veja abaixo como o seu arquivo Listener.java deverá ficar:

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

Criar um aplicativo de cliente (remetente)

Para enviar mensagens à Retransmissão, use qualquer cliente HTTP ou escreva um aplicativo de console Java.

Criar um aplicativo Java

Se tiver desativado a opção "Requer Autorização do Cliente" ao criar a Retransmissão, você poderá enviar solicitações para a URL de Conexões Híbridas com qualquer navegador. Para acessar os pontos de extremidade protegidos, você precisa criar e passar um token no cabeçalho ServiceBusAuthorization, que é mostrado aqui.

Aqui está uma estrutura do projeto Maven simples e uma classe Java que demonstra o envio de solicitações para uma URL de Conexões Híbridas com autorização do cliente utilizando a biblioteca de Retransmissão do Azure.

Adicionar o pacote de Retransmissão

Modifique seu arquivo pom.xml no seu pacote de aplicativos do Maven para incluir o pacote de Retransmissão do Azure.

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

Execute mvn dependency:copy-dependencies -DoutputDirectory=lib em seu projeto mvn para adicionar o arquivo jar de dependência no diretório lib do seu projeto. Ele também importa todas as dependências do pacote mvn do azure-relay. Esse pacote fornece funções para construir identificadores de recursos uniformes (URIs) e tokens de Retransmissão.

Escrever código para enviar mensagens

1. Adicione os arquivos jar de dependência ao ClassPath do arquivo Sender.java.

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

2. Importe as dependências para a classe Sender.java.

   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. Adicione o seguinte constants à parte superior do arquivo Sender.java a uma função java createConnectionString para obter os detalhes da conexão híbrida.

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

   Substitua os espaços reservados entre colchetes pelos valores obtidos quando você criou a conexão híbrida.

   • namespace - o namespace de retransmissão. Use o nome totalmente qualificado do namespace, por exemplo, {namespace}.servicebus.windows.net.
   • path - o nome da conexão híbrida.
   • keyrule — Nome da sua chave de Políticas de Acesso Compartilhado, que é RootManageSharedAccessKey por padrão.
   • nst key — A chave primária do namespace que você salvou anteriormente.

4. Adicione o seguinte código ao arquivo Sender.java. A função principal deverá se parecer com o código a seguir.

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

   Veja abaixo como o seu arquivo Sender.java deverá ficar:

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

Executar os aplicativos

1. Execute o aplicativo de servidor: de um prompt de comando Java ou tipo de aplicativo java -cp <jar_dependency_path> com.example.listener.Listener.java.
2. Execute o aplicativo cliente: de um prompt de comando Java ou tipo de aplicativo java -cp <jar_dependency_path> com.example.sender.Sender.java e insira um texto.
3. Certifique-se de que o console do aplicativo de servidor exiba o texto inserido no aplicativo de cliente.

Parabéns, você criou um aplicativo de Conexões Híbridas completo usando o Java!

Próximas etapas

Neste início rápido, você criou aplicativos cliente e de servidor Java que usavam HTTP para enviar e receber mensagens. O recurso Conexões Híbridas da Retransmissão do Azure também dá suporte ao uso de WebSockets para enviar e receber mensagens. Para saber como usar o WebSockets com as Conexões Híbridas da Retransmissão do Azure, confira o Início Rápido do WebSockets.

Neste início rápido, você usou o Java para criar aplicativos cliente e de servidor. Para saber como escrever aplicativos cliente e servidor usando o .NET Framework, confira o Início Rápido do WebSockets .NET ou o Início Rápido do HTTP .NET.