JMS e AMQP - RabbitMQ

Estou tentando entender o que o JMS e como ele está conectado à terminologia do AMQP. Eu sei que o JMS é uma API e o AMQP é um protocolo.

Aqui estão minhas suposições (e perguntas também)

• O RabbitMQ usa o protocolo AMQP (implementa o protocolo AMQP)
• Os clientes Java precisam usar as bibliotecas de clientes do protocolo AMQP para conectar / usar o RabbitMQ
• Onde a API JMS entra em jogo aqui? A API JMS deve usar as bibliotecas do cliente AMQP para conectar-se ao RabbitMQ?
• Normalmente, usamos o JMS para conectar os intermediários de mensagens como RabbitMQ, ActiveMQ, etc. Então, qual é o protocolo padrão usado aqui em vez do AMQP?

Algumas das opções acima podem ser idiotas. :-) Mas tentando envolver minha cabeça nisso.

Sua pergunta é um pouco confusa e se assemelha a uma pergunta difícil em um documento de perguntas :) (Como os professores sempre tentam fazer perguntas simples que tornam complexas: Espero que você não seja um professor :)) Vamos ver todos esses um por um.

Como você sabe:

A API Java Message Service (JMS) é uma API Java Message Oriented Middleware (MOM) para enviar mensagens entre dois ou mais clientes . O JMS faz parte da Java Platform, Enterprise Edition e é definido por uma especificação desenvolvida no Java Community Process como JSR 914. É um padrão de mensagens que permite que os componentes de aplicativos baseados no Java Enterprise Edition (Java EE) criem, envie, receba e leia mensagens. Ele permite que a comunicação entre diferentes componentes de um aplicativo distribuído seja pouco acoplada, confiável e assíncrona .

Agora (da Wikipedia ):

O Advanced Message Queuing Protocol (AMQP) é um protocolo de camada de aplicativo padrão aberto para middleware orientado a mensagens. Os recursos definidores do AMQP são orientação, enfileiramento, roteamento de mensagens (incluindo ponto a ponto e publicação e assinatura), confiabilidade e segurança.

E a coisa mais importante (novamente da Wikipedia):

Ao contrário do JMS, que apenas define uma API, o AMQP é um protocolo no nível do fio. Um protocolo no nível do fio é uma descrição do formato dos dados enviados pela rede como um fluxo de octetos. Consequentemente, qualquer ferramenta que possa criar e interpretar mensagens em conformidade com esse formato de dados pode interoperar com qualquer outra ferramenta compatível, independentemente da linguagem de implementação

Algumas coisas importantes que você deve saber:

1. Lembre-se de que o AMQP é uma tecnologia de mensagens que não implementa a API JMS.
2. O JMS é API e o AMQP é um protocolo. Portanto, não faz sentido dizer que o que é o protocolo padrão do JMS, é claro, os aplicativos clientes usam HTTP / S como o protocolo de conexão ao chamar um WebLogic Web Service.
3. JMS é apenas uma especificação de API. Não usa nenhum protocolo. Um provedor JMS (como ActiveMQ) pode estar usando qualquer protocolo subjacente para realizar a API JMS. Por exemplo: o Apache ActiveMQ pode usar qualquer um dos seguintes protocolos: AMQP, MQTT, OpenWire, REST (HTTP), RSS e Atom, Stomp, WSIF, WS Notification, XMPP. Eu sugiro que você leia Usando o Transporte JMS como o Protocolo de Conexão .

Boa sorte :)

Vamos começar da base.

O RabbitMQ é um MOM (Message Oriented Middleware), desenvolvido com o Erlang (uma linguagem de programação orientada para TLC) e implementando o protocolo de conexão AMQP (Advance Message Queuing Protocol). Atualmente, muitas APIs de clientes (por exemplo, Java, C ++, RESTful etc.) estão disponíveis para permitir o uso dos serviços de mensagens RabbitMQ.

JMS (Java Messaging Service) é um padrão JCP que define um conjunto de APIs estruturadas a serem implementadas por um MOM. Um exemplo de MOM que implementa (ou seja, é compatível com) as APIs JMS é ActiveMQ; há também o HornetMQ e outros. Esses middlewares obtêm as APIs JMS e implementam os padrões de troca adequadamente.

De acordo com o exposto acima, considerando o esqueleto das APIs JMS, uma instância do RabbitMQ e suas APIs Java Client, é possível desenvolver uma implementação JMS utilizando o RabbitMQ: a única coisa que se deve fazer nesse momento é implementar o padrão de troca (acima de RabbitMQ) de acordo com a especificação JMS.

A chave é: um conjunto de APIs, como JMS, pode ser implementado independentemente da tecnologia (neste caso, RabbitMQ).

O JMS, quando foi definido, não definiu um protocolo entre o cliente JMS e um servidor de mensagens. O cliente JMS, que implementa a API JMS, pode usar qualquer protocolo para se comunicar com o servidor de mensagens. O cliente só precisa estar em conformidade com a API do JMS. Isso é tudo. Geralmente, os clientes JMS usam um protocolo personalizado que seu servidor de mensagens compreende.

O AMQP, por outro lado, é um protocolo entre um cliente de mensagens e um servidor de mensagens. Um cliente JMS pode usar o AMQP como o protocolo para se comunicar com o servidor de mensagens. E há clientes assim disponíveis.

http://www.lshift.net/blog/2009/03/16/openamqs-jms-client-with-rabbitmq-server

• Onde a API JMS entra em jogo aqui? A API JMS deve usar as bibliotecas do cliente AMQP para conectar-se ao RabbitMQ?

O JMS é uma API, portanto, algumas APIs do JMS são implementadas no protocolo AMQP (como o Apache QPID JMS ), enquanto a maioria das APIs do JMS usa outros protocolos. Se a versão do protocolo AMQP for a mesma, esse cliente poderá se comunicar com outro cliente AMQP.

• Normalmente, usamos o JMS para conectar os intermediários de mensagens como RabbitMQ, ActiveMQ, etc. Então, qual é o protocolo padrão usado aqui em vez do AMQP?

Depende da sua configuração dessa API JMS. Para ActiveMQ, poderia ser AMQP, mas por padrão é 'openwire'

Quero sugerir um artigo, isso me ajudou muito a entender melhor qual é a diferença entre AMQP e JMS.

Aqui está o link para o artigo: http://www.wmrichards.com/amqp.pdf

https://spring.io/understanding/AMQP

O AMQP (Advanced Message Queuing Protocol) é uma especificação de conexão publicada publicamente para mensagens assíncronas. Cada byte de dados transmitidos é especificado. Essa característica permite que as bibliotecas sejam escritas em vários idiomas e executadas em vários sistemas operacionais e arquiteturas de CPU, o que cria um padrão de mensagens entre plataformas verdadeiramente interoperável.

O AMQP é frequentemente comparado ao JMS (Java Message Service), o sistema de mensagens mais comum na comunidade Java. Uma limitação do JMS é que as APIs são especificadas, mas o formato da mensagem não é. Ao contrário do AMQP, o JMS não tem requisitos para como as mensagens são formadas e transmitidas. Essencialmente, todo broker JMS pode implementar as mensagens em um formato diferente. Eles apenas precisam usar a mesma API.

Eu suspeito que você possa estar procurando esta documentação que diz, em parte:

O cliente JMS para vFabric RabbitMQ é uma biblioteca cliente para vFabric RabbitMQ. O vFabric RabbitMQ não é um provedor JMS, mas possui os recursos necessários para suportar os modelos de mensagens Fila JMS e Tópico. O JMS Client for RabbitMQ implementa a especificação JMS 1.1 na API do cliente RabbitMQ Java, permitindo assim que aplicativos JMS novos e existentes se conectem aos brokers RabbitMQ por meio do Advanced Message Queuing Protocol (AMQP).