Compartir vía

Uso de la API de Java Message Service 2.0 con Azure Service Bus Premium

  • Artículo

En este artículo se explica cómo usar la popular API de Java Message Service (JMS) 2.0 para interactuar con Azure Service Bus en el protocolo Advanced Message Queuing Protocol (AMQP) 1.0.

Nota:

La compatibilidad con la API de Java Message Service (JMS) 2.0 solo está disponible en el nivel Prémium.>

Requisitos previos

Introducción a Service Bus

En esta guía se da por hecho que ya dispone de un espacio de nombres de Service Bus. Si no es así, cree un espacio de nombres y una cola desde Azure Portal. Para obtener más información sobre cómo crear espacios de nombres y colas de Service Bus, vea Introducción a las colas de Service Bus a través de Azure Portal.

Configuración de un entorno de desarrollo de Java

Para desarrollar aplicaciones Java, debe configurar el entorno de desarrollo adecuado:

  • Debe instalarse una instancia de JDK (Java Development Kit) o JRE (Java Runtime Environment).
  • La instancia de JDK o JRE se agrega a la ruta de acceso de compilación y a las variables del sistema adecuadas.
  • Se instala un IDE de Java para usar la instancia de JDK o JRE. Por ejemplo, Eclipse o IntelliJ.

Para obtener más información sobre cómo preparar el entorno de desarrollo para Java en Azure, use esta guía.

¿Qué características de JMS se admiten?

En la tabla siguiente se enumeran las características de Java Message Service (JMS) que Azure Service Bus admite actualmente. También se muestran las características que no son compatibles.

Característica API Estado
Colas
  • JMSContext.createQueue( String queueName)
Compatible
Temas
  • JMSContext.createTopic( String topicName)
Compatible
Colas temporales
  • JMSContext.createTemporaryQueue()
Compatible
Temas temporales
  • JMSContext.createTemporaryTopic()
Compatible
Productor de mensajes /
JMSProducer
  • JMSContext.createProducer()
Compatible
Exploradores de colas
  • JMSContext.createBrowser(Queue queue)
  • JMSContext.createBrowser(Queue queue, String messageSelector)
Compatible
Consumidor de mensajes/
JMSConsumer
  • JMSContext.createConsumer( Destination destination)
  • JMSContext.createConsumer( Destination destination, String messageSelector)
  • JMSContext.createConsumer( Destination destination, String messageSelector, boolean noLocal)

Actualmente, noLocal no se admite.		 Compatible
Suscripciones duraderas compartidas
  • JMSContext.createSharedDurableConsumer(Topic topic, String name)
  • JMSContext.createSharedDurableConsumer(Topic topic, String name, String messageSelector)
Compatible
Suscripciones duraderas no compartidas
  • JMSContext.createDurableConsumer(Topic topic, String name)
  • createDurableConsumer(Topic topic, String name, String messageSelector, boolean noLocal)

Actualmente no se admite noLocal y debe establecerse en false.		 Compatible
Suscripciones no duraderas compartidas
  • JMSContext.createSharedConsumer(Topic topic, String sharedSubscriptionName)
  • JMSContext.createSharedConsumer(Topic topic, String sharedSubscriptionName, String messageSelector)
Compatible
Suscripciones no duraderas no compartidas
  • JMSContext.createConsumer(Destination destination)
  • JMSContext.createConsumer( Destination destination, String messageSelector)
  • JMSContext.createConsumer( Destination destination, String messageSelector, boolean noLocal)

Actualmente no se admite noLocal y debe establecerse en false.		 Compatible
Selectores de mensajes dependen del consumidor creado Compatible
Retraso de la entrega (mensajes programados)
  • JMSProducer.setDeliveryDelay( long deliveryDelay)
Compatible
Mensaje creado
  • JMSContext.createMessage()
  • JMSContext.createBytesMessage()
  • JMSContext.createMapMessage()
  • JMSContext.createObjectMessage( Serializable object)
  • JMSContext.createStreamMessage()
  • JMSContext.createTextMessage()
  • JMSContext.createTextMessage( String text)
Compatible
Transacciones entre entidades
  • Connection.createSession(true, Session.SESSION_TRANSACTED)
Compatible
Distributed transactions No compatibles

Descarga de la biblioteca cliente de Java Message Service (JMS)

Para usar todas las características disponibles en el nivel premium, agregue la siguiente biblioteca a la ruta de acceso del proyecto: azure-servicebus-jms. Este paquete proporciona algunos valores predeterminados necesarios, como los valores de las directivas de precarga, las directivas de reconexión, Microsoft Entra ID y la compatibilidad con las Identidades administradas.

Nota:

Para agregar azure-servicebus-jms a la ruta de acceso de compilación, use la herramienta de administración de dependencias que prefiera en su proyecto, como Maven o Gradle.

Codificación de las aplicaciones Java

Una vez que se han importado las dependencias, las aplicaciones de Java se pueden escribir en un proveedor de JMS de manera independiente.

Conexión a Azure Service Bus mediante JMS

Para conectarse a Azure Service Bus mediante clientes de JMS, necesita una cadena de conexión, que está disponible en Azure Portal, en la opción Cadena de conexión principal de las directivas de acceso compartido.

  1. Creación de una instancia de ServiceBusJmsConnectionFactorySettings

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

  2. Cree una instancia de ServiceBusJmsConnectionFactory con valor de ServiceBusConnectionString adecuado.

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

  3. Use ConnectionFactory para crear Connection y, a continuación, Session

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

    o JMSContext (para clientes de JMS 2.0).

    JMSContext jmsContext = factory.createContext();

    Importante

    Aunque la denominación es similar, una “sesión” de JMS y una “sesión” de Service Bus son completamente independientes entre sí.

    En JMS 1.1, una sesión es un bloque de creación esencial de la API que permite la creación de las instancias de MessageProducer, MessageConsumer y del propio Message. Para obtener más detalles, revise el modelo de programación de la API de JMS

    En Service Bus, las sesiones son construcciones del lado del servicio y del cliente para habilitar el procesamiento FIFO (PEPS) tanto en las colas como en las suscripciones.

Escritura de la aplicación JMS

Una vez creadas las instancias de Session o JMSContext, la aplicación puede usar las conocidas API de JMS para realizar operaciones de administración y de datos. Consulte la lista de características admitidas de JMS para ver las API compatibles. Estos son algunos fragmentos de código de ejemplo para empezar a trabajar con JMS:

Envío de mensajes a una cola y un tema

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

Recepción de mensajes desde una cola

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

Recepción de mensajes desde una suscripción duradera compartida en un tema

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

Resumen

En esta guía se muestra cómo las aplicaciones cliente de Java que usan Java Message Service (JMS) a través de AMQP 1.0 pueden interactuar con Azure Service Bus.

También puede utilizar AMQP 1.0 de Service Bus desde otros lenguajes, como .NET, C, Python y PHP. Los componentes creados utilizando estos lenguajes pueden intercambiar mensajes con seguridad y fidelidad gracias a la compatibilidad de AMQP 1.0 en Service Bus.

Contenido relacionado