Compartilhar via

Usar a API do Serviço de Mensagens do Java 2.0 com o Barramento de Serviço Premium do Azure

  • Artigo

Este artigo explica como usar a API do popular Serviço de Mensagens Java (JMS) 2.0 para interagir com o Barramento de Serviço do Azure por meio do protocolo AMQP 1.0 (Advanced Message Queueing Protocol).

Observação

O suporte para a API do JMS (Java Message Service) 2.0 está disponível somente na camada Premium.>

Pré-requisitos

Introdução ao Barramento de serviço

Este guia pressupõe que você já tenha um namespace do barramento de serviço. Caso contrário, crie um namespace e uma fila usando o Portal do Azure. Para obter mais informações sobre como criar namespaces e filas do Barramento de Serviço, consulte Introdução às filas do Barramento de Serviço no portal do Azure.

Configurar um ambiente de desenvolvimento Java

Para desenvolver aplicativos Java, você precisa configurar o ambiente de desenvolvimento apropriado -

  • O JDK (Java Development Kit) ou o JRE (Java Runtime Environment) têm de estar instalados.
  • O JDK ou o JRE são adicionados ao caminho de compilação e às variáveis de sistema apropriadas.
  • Um Java IDE é instalado para utilizar o JDK ou o JRE. Por exemplo, Eclipse ou IntelliJ.

Para saber mais sobre como preparar o seu ambiente de desenvolvedor para Java no Azure, utilize este guia.

Quais recursos do Serviço de Mensagens do Java têm suporte?

A tabela a seguir lista os recursos do JMS (Java Message Service) que o Barramento de Serviço do Azure suporta atualmente. Ele também mostra recursos sem suporte.

Recurso API Status
Filas
  • JMSContext.createQueue( String queueName)
Com suporte
Tópicos
  • JMSContext.createTopic( String topicName)
Com suporte
Filas temporárias
  • JMSContext.createTemporaryQueue()
Com suporte
Tópicos temporários
  • JMSContext.createTemporaryTopic()
Com suporte
Produtor de mensagem/
JMSProducer
  • JMSContext.createProducer()
Com suporte
Navegadores de fila
  • JMSContext.createBrowser(Queue queue)
  • JMSContext.createBrowser(Queue queue, String messageSelector)
Com suporte
Consumidor de mensagens/
JMSConsumer
  • JMSContext.createConsumer( Destination destination)
  • JMSContext.createConsumer( Destination destination, String messageSelector)
  • JMSContext.createConsumer( Destination destination, String messageSelector, boolean noLocal)

No momento, não há suporte para o noLocal		 Com suporte
Assinaturas duráveis compartilhadas
  • JMSContext.createSharedDurableConsumer(Topic topic, String name)
  • JMSContext.createSharedDurableConsumer(Topic topic, String name, String messageSelector)
Com suporte
Assinaturas duráveis não compartilhadas
  • JMSContext.createDurableConsumer(Topic topic, String name)
  • createDurableConsumer(Topic topic, String name, String messageSelector, boolean noLocal)

noLocal não tem suporte no momento e deve ser definido como false		 Com suporte
Assinaturas não duráveis compartilhadas
  • JMSContext.createSharedConsumer(Topic topic, String sharedSubscriptionName)
  • JMSContext.createSharedConsumer(Topic topic, String sharedSubscriptionName, String messageSelector)
Com suporte
Assinaturas não duráveis não compartilhadas
  • JMSContext.createConsumer(Destination destination)
  • JMSContext.createConsumer( Destination destination, String messageSelector)
  • JMSContext.createConsumer( Destination destination, String messageSelector, boolean noLocal)

noLocal não tem suporte no momento e deve ser definido como false		 Com suporte
Seletores de mensagens depende do consumidor criado Com suporte
Atraso de entrega (mensagens agendadas)
  • JMSProducer.setDeliveryDelay( longo deliveryDelay)
Com suporte
Mensagem criada
  • JMSContext.createMessage()
  • JMSContext.createBytesMessage()
  • JMSContext.createMapMessage()
  • JMSContext.createObjectMessage( Serializable object)
  • JMSContext.createStreamMessage()
  • JMSContext.createTextMessage()
  • JMSContext.createTextMessage( String text)
Com suporte
Transações entre entidades
  • Connection.createSession(true, Session.SESSION_TRANSACTED)
Com suporte
Transações distribuídas Sem suporte

Baixando a biblioteca de cliente do Serviço de Mensagens do Java (JMS)

Para utilizar todos os recursos disponíveis na camada premium, adicione a seguinte biblioteca ao caminho de build do projeto: azure-servicebus-jms. Esse pacote fornece alguns padrões necessários, como valores de política de pré-busca, políticas de reconexão, ID do Microsoft Entra e suporte à Identidade Gerenciada prontos para uso.

Observação

Para adicionar o azure-servicebus-jms ao caminho de compilação, use a ferramenta de gerenciamento de dependência de sua preferência no projeto, como o Maven ou o Gradle.

Codificando os aplicativos Java

Depois que as dependências são importadas, os aplicativos Java podem ser gravados de maneira independente do provedor JMS.

Conectando-se ao barramento de serviço do Azure usando o JMS

Para se conectar ao barramento de serviço do Azure usando clientes do JMS, você precisa da cadeia de conexão que está disponível nas 'Políticas de Acesso Compartilhado' no portal do Azure em Cadeia de Conexão Primária.

  1. Instanciar o ServiceBusJmsConnectionFactorySettings

    ServiceBusJmsConnectionFactorySettings connFactorySettings = new ServiceBusJmsConnectionFactorySettings();
connFactorySettings.setConnectionIdleTimeoutMS(20000);

  2. Instancie o ServiceBusJmsConnectionFactory com o ServiceBusConnectionString apropriado.

    String ServiceBusConnectionString = "<SERVICE_BUS_CONNECTION_STRING_WITH_MANAGE_PERMISSIONS>";
ConnectionFactory factory = new ServiceBusJmsConnectionFactory(ServiceBusConnectionString, connFactorySettings);

  3. Use o ConnectionFactory para criar um Connection e, em seguida, um Session,

    Connection connection = factory.createConnection();
Session session = connection.createSession();

    ou então um JMSContext (para clientes do JMS 2.0)

    JMSContext jmsContext = factory.createContext();

    Importante

    Embora tenham nomes parecidos, a Session do JMS e a Session do barramento de serviço são completamente independentes uma da outra.

    No JMS 1.1, Session é um bloco de construção fundamental da API que permite a criação do MessageProducer, do MessageConsumer e do próprio Message. Para obter mais detalhes, examine o modelo de programação da API do JMS

    No Barramento de Serviço, as sessions são constructos no lado do cliente e do serviço para habilitar o processamento de PEPS em filas e assinaturas.

Escrever o aplicativo JMS

Depois que o Session ou JMSContext for instanciado, seu aplicativo poderá usar as APIs JMS familiares para executar operações de gerenciamento e de dados. Consulte a lista de recursos de JMS com suporte e veja quais APIs têm suporte. Confira aqui alguns trechos de código de exemplo para começar a usar o JMS –

Enviando mensagens para uma fila e um tópico

// Create the queue and topic
Queue queue = jmsContext.createQueue("basicQueue");
Topic topic = jmsContext.createTopic("basicTopic");
// Create the message
Message msg = jmsContext.createMessage();

// Create the JMS message producer
JMSProducer producer = jmsContext.createProducer();

// send the message to the queue
producer.send(queue, msg);
// send the message to the topic
producer.send(topic, msg);

Recebendo mensagens de uma fila

// Create the queue
Queue queue = jmsContext.createQueue("basicQueue");

// Create the message consumer
JMSConsumer consumer = jmsContext.createConsumer(queue);

// Receive the message
Message msg = (Message) consumer.receive();

Recebendo mensagens de uma assinatura durável compartilhada em um tópico

// Create the topic
Topic topic = jmsContext.createTopic("basicTopic");

// Create a shared durable subscriber on the topic
JMSConsumer sharedDurableConsumer = jmsContext.createSharedDurableConsumer(topic, "sharedDurableConsumer");

// Receive the message
Message msg = (Message) sharedDurableConsumer.receive();

Resumo

Este guia demonstrou como os aplicativos de cliente Java que usam o Serviço de Mensagens do Java (JMS) por meio do protocolo AMQP 1.0 podem se conectar ao Barramento de Serviço do Azure.

Você também pode usar o AMQP 1.0 do Service Bus de outras linguagens, incluindo .NET, C, Python e PHP. Os componentes criados com essas diferentes linguagens podem trocar mensagens de forma confiável e com total fidelidade usando o suporte do AMQP 1.0 no Service Bus.

Conteúdo relacionado