Utilizar a API 2.0 do Java Message Service com Azure Service Bus Premium

Artigo
03/21/2023

Este artigo explica como utilizar a popular API do Serviço de Mensagens Java (JMS) 2.0 para interagir com Azure Service Bus através do protocolo AMQP 1.0 (Advanced Message Queueing Protocol).

Nota

O suporte para a API 2.0 do Java Message Service (JMS) só está disponível no escalão premium.>

Pré-requisitos

Introdução ao Service Bus

Este guia pressupõe que já tem um espaço de nomes do Service Bus. Se não o fizer, crie um espaço de nomes e uma fila com o portal do Azure. Para obter mais informações sobre como criar espaços de nomes e filas do Service Bus, consulte Introdução às filas do Service Bus através do portal do Azure.

Configurar um ambiente de Desenvolvimento Java

Para desenvolver aplicações Java, tem de configurar o ambiente de desenvolvimento adequado –

O JDK (Java Development Kit) ou o JRE (Java Runtime Environment) estão instalados.
O JDK ou JRE é adicionado ao caminho de compilação e às variáveis de sistema adequadas.
É instalado um IDE Java para utilizar o JDK ou JRE. Por exemplo, Eclipse ou IntelliJ.

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

Que funcionalidades do JMS são suportadas?

A tabela seguinte lista as funcionalidades do Serviço de Mensagens Java (JMS) que Azure Service Bus atualmente suportadas. Também mostra funcionalidades que não são suportadas.

Funcionalidade	API	Estado
Filas	JMSContext.createQueue( String queueName)	Suportado
Tópicos	JMSContext.createTopic( String topicName)	Suportado
Filas temporárias	JMSContext.createTemporaryQueue()	Suportado
Tópicos temporários	JMSContext.createTemporaryTopic()	Suportado
Produtor de Mensagens/ JMSProducer	JMSContext.createProducer()	Suportado
Browsers de fila	JMSContext.createBrowser(Fila de espera) JMSContext.createBrowser(Fila de fila, Mensagem de cadeiaSeletor)	Suportado
Consumidor de Mensagens/ JMSConsumer	JMSContext.createConsumer( Destino de destino) JMSContext.createConsumer( Destino de destino, String messageSelector) JMSContext.createConsumer( Destino de destino, String messageSelector, booleano noLocal) noLocal não é atualmente suportado	Suportado
Subscrições duráveis partilhadas	JMSContext.createSharedDurableConsumer(Tópico, Nome da cadeia) JMSContext.createSharedDurableConsumer(Tópico, Nome da cadeia, Mensagem de cadeiaSeletor)	Suportado
Subscrições duráveis não partilhadas	JMSContext.createDurableConsumer(Tópico, Nome da cadeia) createDurableConsumer(Tópico, Nome da cadeia, Mensagem de cadeiaSeletor, booleano noLocal) noLocal não é atualmente suportado e deve ser definido como falso	Suportado
Subscrições não duráveis partilhadas	JMSContext.createSharedConsumer(Tópico, String sharedSubscriptionName) JMSContext.createSharedConsumer(Tópico, String sharedSubscriptionName, String messageSelector)	Suportado
Subscrições não duráveis não partilhadas	JMSContext.createConsumer(Destino de destino) JMSContext.createConsumer( Destino de destino, String messageSelector) JMSContext.createConsumer( Destino de destino, String messageSelector, booleano noLocal) noLocal não é atualmente suportado e deve ser definido como falso	Suportado
Seletores de mensagens	depende do consumidor criado	Suportado
Atraso na Entrega (mensagens agendadas)	JMSProducer.setDeliveryDelay( entrega longaDelay)	Suportado
Mensagem criada	JMSContext.createMessage() JMSContext.createBytesMessage() JMSContext.createMapMessage() JMSContext.createObjectMessage( Objeto serializável) JMSContext.createStreamMessage() JMSContext.createTextMessage() JMSContext.createTextMessage( Texto de cadeia)	Suportado
Transações entre entidades	Connection.createSession(true, Session.SESSION_TRANSACTED)	Suportado
Transações distribuídas		Não suportado

Transferir a biblioteca de cliente do Java Message Service (JMS)

Para utilizar todas as funcionalidades disponíveis no escalão premium, adicione a seguinte biblioteca ao caminho de compilação do projeto.

Azure-servicebus-jms

Nota

Para adicionar o Azure-servicebus-jms ao caminho de compilação, utilize a ferramenta de gestão de dependências preferencial para o seu projeto, como o Maven ou o Gradle.

Codificar aplicações Java

Assim que as dependências tiverem sido importadas, as aplicações Java podem ser escritas de forma agnóstica.

Ligar a Azure Service Bus com o JMS

Para se ligar a Azure Service Bus com clientes JMS, precisa da cadeia de ligação que está disponível nas "Políticas de Acesso Partilhado" no portal do Azure em Cadeia de Ligação Primária.

Instanciar o ServiceBusJmsConnectionFactorySettings

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

Instanciar com ServiceBusJmsConnectionFactory o adequado ServiceBusConnectionString.

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

Utilize o ConnectionFactory para criar um Connection e, em seguida, um Session
```
Connection connection = factory.createConnection();
Session session = connection.createSession();
```
ou um JMSContext (para clientes JMS 2.0)
```
JMSContext jmsContext = factory.createContext();
```
Importante

Embora com o mesmo nome, uma "Sessão" JMS e uma "Sessão" do Service Bus são completamente independentes umas das outras.

No JMS 1.1, a Sessão é um bloco modular essencial da API que permite a MessageProducercriação do , MessageConsumere do Message próprio. Para obter mais detalhes, veja o modelo de programação da API JMS

No Service Bus, as sessões são construções do lado do serviço e do cliente para permitir o processamento FIFO em filas e subscrições.

Escrever a aplicação JMS

Assim que o Session ou JMSContext tiver sido instanciado, a sua aplicação pode utilizar as APIs JMS familiares para realizar operações de gestão e dados. Veja a lista de funcionalidades do JMS suportadas para ver que APIs são suportadas. Seguem-se alguns fragmentos de código de exemplo para começar a utilizar o JMS –

Enviar mensagens para uma fila e 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);

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

Receber mensagens de uma subscrição durável partilhada num 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 mostrou como as aplicações cliente Java que utilizam o Java Message Service (JMS) através do AMQP 1.0 podem interagir com Azure Service Bus.

Também pode utilizar o AMQP 1.0 do Service Bus a partir de outros idiomas, incluindo .NET, C, Python e PHP. Os componentes criados com estes idiomas diferentes podem trocar mensagens de forma fiável e em total fidelidade com o suporte amQP 1.0 no Service Bus.

Passos seguintes

Para obter mais informações sobre Azure Service Bus e detalhes sobre entidades do Java Message Service (JMS), consulte as ligações abaixo -