C'est une continuation de l'article suivant. Nous continuerons d'introduire le développement d'applications Java qui accèdent à Amazon SQS. Pour l'environnement, utilisez le conteneur Elastic MQ au lieu de SQS et utilisez la file d'attente standard créée pour la file d'attente.
Développement d'une application Java utilisant Amazon SQS (Partie 1)
Dans l'article précédent, l'accès SQS a été effectué à l'aide du kit AWS SDK, mais lorsqu'il s'agit de messagerie en Java, de nombreuses personnes peuvent penser au standard JMS (Java Messaging Service). Pour JMS, la bibliothèque de messagerie Java Amazon SQS est fournie pour SQS, nous allons donc vous montrer comment accéder à SQS en l'utilisant. Cette bibliothèque rend SQS disponible pour les applications JMS existantes avec des modifications minimes.
Utilisation de JMS et d'Amazon SQS-Amazon Simple Queue Service
Veuillez noter que la cible de support de la bibliothèque est limitée à une partie de JMS1.1 (transmission / réception de messages dans le modèle point à point).
Pour tirer parti de la bibliothèque de messagerie Java Amazon SQS, vous devez ajouter des dépendances de bibliothèque avec le SDK. Lorsque vous utilisez Maven, définissez-le dans pom.xml comme suit.
<dependency>
<groupId>software.amazon.awssdk</groupId>
<artifactId>sqs</artifactId>
</dependency>
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>amazon-sqs-java-messaging-lib</artifactId>
<version>1.0.4</version>
<type>jar</type>
</dependency>
Utilisez la ConnectionFactory fournie par la bibliothèque pour vous connecter à SQS. Étant donné que nous utilisons le conteneur Elastic MQ cette fois, nous devons remplacer l'URL du point de terminaison comme dans l'article précédent. Il utilise également un générateur de client différent de celui lors de la connexion directe avec le SDK.
L'exemple de code d'ici est basé sur ce qui suit. Exemple d'utilisation de Java avec la file d'attente standard Amazon SQS à l'aide de JMS
AmazonSQSClientBuilder builder = AmazonSQSClientBuilder.standard();
builder.setEndpointConfiguration(new EndpointConfiguration("http://localhost:9324", "us-east-1"));
SQSConnectionFactory connectionFactory = new SQSConnectionFactory(
new ProviderConfiguration(),
builder
);
SQSConnection connection = connectionFactory.createConnection();
Vous pouvez envoyer et recevoir des messages en établissant une session JMS après la connexion. À partir de ce moment, l'interface standard JMS sera utilisée. Voici un exemple de code pour envoyer un message.
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
Queue queue = session.createQueue("testqueue");
MessageProducer producer = session.createProducer(queue);
TextMessage message = session.createTextMessage("Hello World!");
producer.send(message);
La réception du message est mise en œuvre comme suit.
Message receivedMessage = consumer.receive(1000);
if (receivedMessage != null) {
System.out.println("Received: " + ((TextMessage) receivedMessage).getText());
}
La réception asynchrone des messages par les écouteurs JMS est également possible.
MessageConsumer consumer = session.createConsumer(queue);
consumer.setMessageListener(new MyListener());
connection.start();
MyListener.java
public class MyListener implements MessageListener {
@Override
public void onMessage(Message message) {
//Message de processus
}
}
Déconnectez-vous comme dans le cas du SDK.
connection.close();
C'est la fin de l'accès SQS par JMS. Si vous connaissez JMS, vous constaterez qu'il peut être utilisé avec une implémentation similaire.
Le standard est JMS, mais récemment, il devrait y avoir beaucoup de gens qui développent à l'aide de Spring Boot et Spring JMS, alors je vais enfin présenter la méthode d'accès lors de l'utilisation de ceux-ci.
Ici, j'ai fait référence au contenu du lien ci-dessous. Developing messaging system with Spring Boot, JMS and AWS SQS
Ici, nous ajoutons les dépendances de démarrage Spring-JMS et Spring Boot à pom.xml. Il existe différents composants dans Spring, mais si vous souhaitez utiliser les exemples de code suivants, ajoutez le contenu suivant à la définition jusqu'à présent.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<version>2.1.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jms</artifactId>
<version>5.1.4.RELEASE</version>
</dependency>
Spring Boot vous permet d'implémenter des définitions de bean en Java, implémentez donc la classe Config pour activer Spring JMS. Spring JMS est activé en ajoutant l'annotation EnableJms. Il crée également une ConnectionFactory (le contenu est le même que pour JMS) et implémente une définition de Bean pour JmsTemplate qui l'utilise.
@EnableJms
@Configuration
public class JmsConfig {
public SQSConnectionFactory sqsConnectionFactory() {
AmazonSQSClientBuilder builder = AmazonSQSClientBuilder.standard();
builder.setEndpointConfiguration(new EndpointConfiguration("http://localhost:9324", "us-east-1"));
SQSConnectionFactory connectionFactory = new SQSConnectionFactory(
new ProviderConfiguration(),
builder
);
return connectionFactory;
}
@Bean
public JmsTemplate defaultJmsTemplate() {
return new JmsTemplate(sqsConnectionFactory());
}
En injectant le JmsTemplate défini dans la classe Config, la classe qui envoie et reçoit des messages n'a pas besoin de connaître la connexion à SQS. JmsTemplate est une classe Template pour l'envoi et la réception de messages fournis par Spring JMS, et peut être implémentée très facilement s'il s'agit d'un simple processus d'envoi et de réception.
@Autowired
private JmsTemplate jmsTemplate;
...
public void sendToSQS(String destination, String message) {
jmsTemplate.convertAndSend(destination, message);
}
Spring JMS vous permet d'implémenter des POJO pilotés par message appelés MDP (Message-Driven POJO). Voici un exemple de code de réception d'un message par MDP. En ajoutant l'annotation JmsListener, lorsqu'un message entre dans la file d'attente spécifiée dans l'attribut de destination, il est reçu et le processus de la méthode est appelé.
@JmsListener(destination="testqueue")
public void receive(TextMessage message) {
System.out.println("received: "+message);
}
Pour utiliser MDP, il est nécessaire d'implémenter la définition de Bean suivante de ListenerContainerFactory dans la classe Config.
@Bean
public DefaultJmsListenerContainerFactory jmsListenerContainerFactory() {
DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
factory.setConnectionFactory(sqsConnectionFactory());
factory.setDestinationResolver(new DynamicDestinationResolver());
factory.setConcurrency("3-10");
factory.setSessionAcknowledgeMode(Session.CLIENT_ACKNOWLEDGE);
return factory;
}
Spring le fait en interne, vous n'avez donc pas à vous en soucier dans votre application.
Vous pouvez voir que vous pouvez accéder à SQS de manière assez simple en utilisant Spring JMS. Lorsque vous utilisez Elastic MQ comme alternative à SQS, je crains qu'il soit nécessaire d'écraser l'URL du point de terminaison pour la connexion, mais si vous utilisez bien la fonction de profil de Spring, etc., vous pouvez basculer intelligemment entre les environnements. Je pense que c'est.
Quand sera-t-il possible de vérifier avec le SQS actuel?
Recommended Posts