Partilhar via

Usar a API do Java Message Service 2.0 com o Azure Service Bus Premium

  • Artigo

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

Nota

O suporte para a API Java Message Service (JMS) 2.0 só está disponível na camada premium.>

Pré-requisitos

Introdução ao Service Bus

Este guia pressupõe que você já tenha um namespace do Service Bus. 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 por meio do portal do Azure.

Configurar um ambiente de desenvolvimento Java

Para desenvolver aplicações Java, você precisa configurar o ambiente de desenvolvimento apropriado -

  • 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 apropriadas.
  • Um IDE Java é instalado para utilizar o JDK ou JRE. Por exemplo, Eclipse ou IntelliJ.

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

Quais recursos JMS são suportados?

A tabela a seguir lista os recursos do Java Message Service (JMS) que o Azure Service Bus suporta atualmente. Ele também mostra recursos que não são suportados.

Caraterística API Status
Queues
  • 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
Navegadores de fila
  • JMSContext.createBrowser(fila de fila)
  • JMSContext.createBrowser(fila de fila, String messageSelector)
Suportado
Mensagem Consumidor/
JMSConsumer
  • JMSContext.createConsumer( Destino de destino)
  • JMSContext.createConsumer( Destino de destino, String messageSelector)
  • JMSContext.createConsumer( Destino de destino, String messageSelector, boolean noLocal)

noLocal não é suportado no momento		 Suportado
Subscrições duradouras partilhadas
  • JMSContext.createSharedDurableConsumer(tópico do tópico, nome da cadeia de caracteres)
  • JMSContext.createSharedDurableConsumer(tópico do tópico, nome da cadeia de caracteres, mensagem da cadeia de caracteresSeletor)
Suportado
Subscrições duradouras não partilhadas
  • JMSContext.createDurableConsumer(tópico do tópico, nome da cadeia de caracteres)
  • createDurableConsumer(tópico do tópico, nome da cadeia de caracteres, String messageSelector, boolean noLocal)

noLocal não é suportado atualmente e deve ser definido como false		 Suportado
Subscrições partilhadas não duráveis
  • JMSContext.createSharedConsumer(tópico do tópico, String sharedSubscriptionName)
  • JMSContext.createSharedConsumer(tópico do tópico, String sharedSubscriptionName, String messageSelector)
Suportado
Subscrições não partilhadas não duradouras
  • JMSContext.createConsumer(Destino de destino)
  • JMSContext.createConsumer( Destino de destino, String messageSelector)
  • JMSContext.createConsumer( Destino de destino, String messageSelector, boolean noLocal)

noLocal não é suportado atualmente e deve ser definido como false		 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 da cadeia de caracteres)
Suportado
Transações entre entidades
  • Connection.createSession(true, Session.SESSION_TRANSACTED)
Suportado
Transações distribuídas Não suportado

Download da biblioteca de cliente Java Message Service (JMS)

Para utilizar todos os recursos disponíveis na camada premium, adicione a seguinte biblioteca ao caminho de compilação do projeto: azure-servicebus-jms. Este 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 a Identidade Gerenciada prontos para uso.

Nota

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

Codificação de aplicações Java

Depois que as dependências são importadas, os aplicativos Java podem ser escritos de maneira agnóstica do provedor JMS.

Conectando-se ao Barramento de Serviço do Azure usando JMS

Para se conectar ao Barramento de Serviço do Azure usando clientes JMS, você precisa da cadeia de conexão 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 apropriado ServiceBusConnectionString.

    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 a JMSContext (para clientes JMS 2.0)

    JMSContext jmsContext = factory.createContext();

    Importante

    Embora com nomes semelhantes, uma 'Sessão' JMS e uma 'Sessão' do Service Bus são completamente independentes uma da outra.

    No JMS 1.1, Session é um bloco de construção essencial da API que permite a MessageProducercriação do , MessageConsumere do Message próprio. Para obter mais detalhes, consulte 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 habilitar o processamento FIFO em filas e assinaturas.

Escrever o aplicativo JMS

Depois que o Session ou JMSContext é instanciado, seu aplicativo pode usar as APIs JMS familiares para executar operações de gerenciamento e de dados. Consulte a lista de recursos JMS suportados para ver quais APIs são suportadas. Aqui estão alguns trechos de código de exemplo para começar a usar o JMS -

Enviar 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);

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 duradoura partilhada sobre 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 mostrou como os aplicativos cliente Java que usam o Java Message Service (JMS) sobre AMQP 1.0 podem interagir com o Barramento de Serviço do Azure.

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

Conteúdos relacionados