Como baixar JMS 2.0 Jar
Se você for um desenvolvedor Java que deseja usar a API Java Message Service (JMS) para se comunicar com sistemas de mensagens, talvez esteja se perguntando como fazer download da versão mais recente do arquivo jar JMS, que é JMS 2.0. Neste artigo, explicaremos o que é o JMS 2.0, quais recursos e benefícios ele oferece, como fazer o download e utilizá-lo em sua aplicação.
download jms 2.0 jar
Download File: https://tinurll.com/2vQ1Tc
O que é JMS 2.0?
O JMS 2.0 é a primeira atualização da especificação JMS desde que a versão 1.1 foi lançada em 2002. Faz parte da plataforma Java EE 7 e pode ser usado em aplicativos Java EE Web ou EJB, ou pode ser usado de forma independente em um ambiente Java SE.
O JMS 2.0 apresenta uma nova API para enviar e receber mensagens que reduz a quantidade de código que um desenvolvedor deve escrever. Ele também suporta injeção de recursos, o que permite que o servidor de aplicativos cuide da criação e gerenciamento de objetos JMS, simplificando ainda mais o aplicativo.
Recursos do JMS 2.0
A nova API é conhecida como API simplificada. Ele consiste em três novas interfaces: JMSContext, JMSProducer e JMSConsumer:
Contexto JMS substitui os objetos Connection e Session separados na API clássica por um único objeto.
Produtor JMS é um substituto leve para o objeto MessageProducer na API clássica. Ele permite que opções de entrega de mensagens, cabeçalhos e propriedades sejam configurados usando o encadeamento de métodos (às vezes conhecido como padrão de construtor).
JMSConsumer substitui o objeto MessageConsumer na API clássica e é usado de maneira semelhante.
A API simplificada oferece todos os recursos da API clássica, além de alguns recursos adicionais, como:
Suporte para entrega de mensagem assíncrona usando um objeto CompletionListener.
Suporte para assinaturas compartilhadas para tópicos, que permitem que vários consumidores compartilhem uma única assinatura.
Suporte para atraso de entrega, que permite que as mensagens sejam enviadas com um atraso especificado antes de serem entregues.
Suporte para contagem de entrega, que permite que as mensagens sejam anotadas com o número de vezes que foram entregues.
Benefícios do JMS 2.0
O principal benefício do JMS 2.0 é que ele facilita e agiliza o desenvolvimento de aplicativos que usam sistemas de mensagens. Ao usar a API simplificada, os desenvolvedores podem escrever menos linhas de código, evitar código clichê e focar na lógica de negócios de seus aplicativos.
Outro benefício do JMS 2.0 é que ele suporta injeção de recursos para aplicativos executados em um servidor de aplicativos Java EE. Isso significa que os desenvolvedores não precisam criar e gerenciar objetos JMS manualmente, mas podem contar com o servidor de aplicativos para fazer isso por eles. Isso reduz a complexidade e melhora a portabilidade do aplicativo.
Como baixar JMS 2.0 Jar para diferentes ambientes
Para usar o JMS 2.0 em seu aplicativo, você precisa fazer download do arquivo jms.jar que contém as interfaces JMS 2.0 e adicioná-lo ao seu caminho de classe. A forma de baixar o arquivo jms.jar depende do ambiente que você está utilizando para sua aplicação.
Baixando o JMS 2.0 Jar para aplicativos Java EE
Se você estiver desenvolvendo um aplicativo Java EE executado em um servidor de aplicativos compatível com Java EE 7, como GlassFish, WildFly ou WebLogic, não será necessário fazer download do arquivo jms.jar separadamente. O servidor de aplicativos já fornece as interfaces JMS 2.0 como parte da plataforma Java EE.
Tudo o que você precisa fazer é usar a injeção de recursos para obter um objeto JMSContext do servidor de aplicativos. Você pode fazer isso usando a anotação @Inject em um campo ou um parâmetro de método do tipo JMSContext. Por exemplo:
importar javax.inject.Inject; importar javax.jms.JMSContext; public class MyBean @Inject private JMSContext context; // usa o contexto para enviar e receber mensagens
Você também pode especificar o nome do connection factory e o destino que deseja usar com as anotações @JMSConnectionFactory e @JMSDestination, respectivamente. Por exemplo:
importar javax.inject.Inject; importar javax.jms.JMSContext; importar javax.jms.JMSConnectionFactory; importar javax.jms.JMSDestination; public class MyBean @Inject @JMSConnectionFactory("jms/MyConnectionFactory") @JMSDestination("jms/MyQueue") private JMSContext context; // usa o contexto para enviar e receber mensagens
Usando Injeção de Recursos
A injeção de recursos é a forma preferida de obter objetos JMS em um aplicativo Java EE, pois simplifica o código e o torna mais portátil. No entanto, se você precisar de mais controle sobre a criação e configuração de objetos JMS, também poderá usar a consulta JNDI para obtê-los do servidor de aplicativos.
Usando a Pesquisa JNDI
A consulta JNDI é uma forma alternativa de obter objetos JMS em um aplicativo Java EE, se a injeção de recursos não estiver disponível ou não for adequada para suas necessidades. Você pode usar a consulta JNDI para obter um connection factory e um destino do serviço de nomenclatura do servidor de aplicativos e, em seguida, usá-los para criar um objeto JMSContext. Por exemplo:
importar javax.jms.ConnectionFactory; importar javax.jms.Destination; importar javax.jms.JMSContext; importar javax.naming.InitialContext; public class MyBean contexto JMSContext privado; public void init() throws Exception // obtém connection factory e destino de JNDI InitialContext ic = new InitialContext(); ConnectionFactory cf = (ConnectionFactory) ic.lookup("jms/MyConnectionFactory"); Destino dest = (Destino) ic.lookup("jms/MinhaFila"); // cria contexto do objeto JMSContext = cf.createContext(); // usa contexto para enviar e receber mensagens
Baixando JMS 2.0 Jar para aplicativos Java SE
Se você estiver desenvolvendo um aplicativo Java SE independente que usa JMS 2.0, será necessário fazer download do arquivo jms.jar e adicioná-lo ao caminho de classe. Você também precisa baixar e adicionar os arquivos jar do provedor de mensagens específico que deseja usar, como ActiveMQ, HornetQ ou RabbitMQ.
Existem duas maneiras de baixar o arquivo jms.jar para aplicativos Java SE: usando a dependência do Maven ou usando o link direto para download.
Usando a dependência do Maven
Se você estiver usando o Maven como sua ferramenta de compilação, poderá adicionar a seguinte dependência ao seu arquivo pom.xml para baixar o arquivo jms.jar automaticamente:
<dependency> <groupId>javax.jms</groupId> <artifactId>javax.jms-api</artifactId> <version>2.0</version> </dependency>
Você também precisa adicionar as dependências do provedor de mensagens que deseja usar, de acordo com a documentação.
Usando o link de download direto
Se você não estiver usando o Maven, pode baixar o arquivo jms.jar diretamente no seguinte link:
Você também precisa baixar e adicionar os arquivos jar do provedor de mensagens que deseja usar, de acordo com a documentação.
Como usar JMS 2.0 Jar em seu aplicativo
Depois de fazer o download e incluir o arquivo jms.jar e os arquivos jar do provedor de mensagens em seu caminho de classe, você pode começar a usar o JMS 2.0 em seu aplicativo. Aqui estão alguns passos básicos a seguir:
Criando um Objeto JMSContext
A primeira etapa é criar um objeto JMSContext, que representa a conexão e a sessão com o sistema de mensagens. Você pode fazer isso usando o método createContext() do objeto ConnectionFactory obtido do provedor de mensagens. Por exemplo:
importar javax.jms.ConnectionFactory; importar javax.jms.JMSContext; // obtém connection factory do provedor de mensagens ConnectionFactory cf = ...; // cria objeto JMSContext JMSContext context = cf.createContext();
Você também pode especificar o modo de sessão e as credenciais do usuário como parâmetros do método createContext(), se necessário. Por exemplo:
importar javax.jms.ConnectionFactory; importar javax.jms.JMSContext; importar javax.jms.JMSException; // obtém connection factory do provedor de mensagens ConnectionFactory cf = ...; // cria objeto JMSContext com modo de reconhecimento automático e credenciais de usuário JMSContext context = cf.createContext("user", "password", JMSContext.AUTO_ACKNOWLEDGE);
Enviando e recebendo mensagens com objetos JMSProducer e JMSConsumer
A próxima etapa é criar um objeto JMSProducer e um objeto JMSConsumer, que são usados para enviar e receber mensagens, respectivamente. Você pode fazer isso usando os métodos createProducer() e createConsumer() do objeto JMSContext. Por exemplo:
importar javax.jms.Destination; importar javax.jms.JMSConsumer; importar javax.jms.JMSContext; importar javax.jms.JMSProducer; // obtém o destino do provedor de mensagens Destination dest = ...; // cria o objeto JMSProducer produtor JMSProducer = context.createProducer(); // cria o objeto JMSConsumer JMSConsumer consumer = context.createConsumer(dest);
Você também pode especificar opções de entrega de mensagens, cabeçalhos e propriedades para o produtor e o consumidor usando os métodos das interfaces JMSProducer e JMSConsumer. Por exemplo:
importar javax.jms.Destination; importar javax.jms.JMSConsumer; importar javax.jms.JMSContext; importar javax.jms.JMSProducer; importar javax.jms.Message; // obtém o destino do provedor de mensagens Destination dest = ...; // cria objeto JMSProducer com atraso de entrega de 10 segundos Produtor JMSProducer = context.createProducer().setDeliveryDelay(10000); // cria objeto JMSConsumer com seletor de mensagem JMSConsumer consumer = context.createConsumer(dest, "priority > 5"); // envia uma mensagem de texto com cabeçalho de prioridade produtor.setPriority(9).send(dest, "Hello"); // recebe uma mensagem de texto Message message = consumer.receive();
Usando API simplificada e encadeamento de métodos
Uma das vantagens do JMS 2.0 é que ele permite usar uma API simplificada e um encadeamento de métodos para escrever um código conciso e legível. Por exemplo, você pode usar o seguinte código para enviar e receber uma mensagem de texto em uma linha:
importar javax.jms.Destination; importar javax.jms.JMSContext; // obtém o destino do provedor de mensagens Destination dest = ...; // enviar e receber uma mensagem de texto em uma linha String response = context.createProducer().send(dest, "Hello").createReplyToConsumer().receiveBody(String.class);
Este código utiliza os seguintes métodos da interface JMSProducer:
send(Destination destination, String body): envia uma mensagem de texto para o destino especificado.
createReplyToConsumer(): cria um destino temporário e um consumidor para receber as respostas.
corporecebido(Classe c): recebe uma mensagem e retorna seu corpo como uma instância da classe especificada.
Conclusão
Neste artigo, aprendemos o que é o JMS 2.0, quais recursos e benefícios ele oferece e como baixá-lo e usá-lo em seu aplicativo. Vimos como usar injeção de recursos ou pesquisa JNDI para obter objetos JMS em um aplicativo Java EE e como usar a dependência Maven ou link de download direto para obtê-los em um aplicativo Java SE. Também vimos como usar a API simplificada e o encadeamento de métodos para escrever menos código e mais código legível.
Resumo do artigo
Os principais pontos deste artigo são:
JMS 2.0 é a versão mais recente da API Java Message Service que simplifica o desenvolvimento de aplicativos que usam sistemas de mensagens.
O JMS 2.0 apresenta uma nova API simplificada que consiste em três novas interfaces: JMSContext, JMSProducer e JMSConsumer.
O JMS 2.0 suporta injeção de recursos para aplicativos Java EE, o que permite que o servidor de aplicativos crie e gerencie objetos JMS para o aplicativo.
O JMS 2.0 suporta encadeamento de métodos para objetos JMSProducer e JMSConsumer, o que permite que opções de entrega de mensagens, cabeçalhos e propriedades sejam configurados usando um padrão de construtor.
O JMS 2.0 suporta alguns recursos adicionais, como entrega de mensagem assíncrona, assinaturas compartilhadas, atraso de entrega e contagem de entrega.
Para usar o JMS 2.0 em seu aplicativo, você precisa fazer o download do arquivo jms.jar e adicioná-lo ao seu caminho de classe. Você pode usar a dependência do Maven ou o link de download direto para obter o arquivo jms.jar para aplicativos Java SE. Não é necessário fazer download do arquivo jms.jar para aplicativos Java EE, pois ele é fornecido pelo servidor de aplicativos.
perguntas frequentes
Aqui estão algumas perguntas frequentes sobre o JMS 2.0:
Qual é a diferença entre JMS 2.0 e JMS 1.1?
A principal diferença entre o JMS 2.0 e o JMS 1.1 é que o JMS 2.0 apresenta uma nova API simplificada que reduz a quantidade de código que um desenvolvedor deve escrever para usar sistemas de mensagens. O JMS 2.0 também suporta alguns recursos adicionais que não estão disponíveis no JMS 1.1, como entrega assíncrona de mensagens, assinaturas compartilhadas, atraso na entrega e contagem de entrega.
Posso usar o JMS 2.0 com qualquer provedor de mensagens?
Você pode usar o JMS 2.0 com qualquer provedor de sistema de mensagens que suporte a especificação JMS 2.0 e forneça uma implementação de connection factory para ele. Alguns exemplos de provedores de mensagens que suportam JMS 2.0 são ActiveMQ, HornetQ, RabbitMQ e IBM MQ.
Posso usar o JMS 2.0 com qualquer versão do Java?
Você pode usar o JMS 2.0 com qualquer versão do Java que suporte a plataforma Java SE 7 ou superior. Isso inclui Java SE 7, Java SE 8, Java SE 9 e Java SE 10.
Posso misturar a API simplificada e a API clássica em meu aplicativo?
Sim, você pode misturar a API simplificada e a API clássica em sua aplicação, desde que as utilize com a mesma connection factory e objetos de destino. No entanto, é recomendável usar a API simplificada sempre que possível, pois oferece mais vantagens e menos complexidade do que a API clássica.
Onde posso encontrar mais informações sobre o JMS 2.0?
Você pode encontrar mais informações sobre o JMS 2.0 nas seguintes fontes:
O documento de especificação oficial:
O guia oficial do usuário:
O tutorial oficial:
A implementação de referência oficial:
0517a86e26