Es ist eine Fortsetzung des folgenden Artikels. Wir werden weiterhin die Entwicklung von Java-Anwendungen einführen, die auf Amazon SQS zugreifen. Verwenden Sie für die Umgebung den Elastic MQ-Container anstelle von SQS und verwenden Sie die erstellte Standardwarteschlange für die Warteschlange.
Entwickeln einer Java-Anwendung, die Amazon SQS verwendet (Teil 1)
Im vorherigen Artikel wurde der SQS-Zugriff mit dem AWS SDK durchgeführt. Wenn es jedoch um Messaging in Java geht, denken viele Menschen möglicherweise an den Standard-JMS (Java Messaging Service). Für JMS wird die Amazon SQS Java Messaging Library für SQS bereitgestellt, sodass wir Ihnen zeigen, wie Sie damit auf SQS zugreifen können. Diese Bibliothek stellt SQS vorhandenen JMS-Anwendungen mit minimalen Änderungen zur Verfügung.
Verwenden von JMS und Amazon SQS-Amazon Simple Queue Service
Bitte beachten Sie, dass das Support-Ziel der Bibliothek auf einen Teil von JMS1.1 beschränkt ist (Senden / Empfangen von Nachrichten im Punkt-zu-Punkt-Modell).
Um die Vorteile der Amazon SQS Java Messaging Library nutzen zu können, müssen Sie zusammen mit dem SDK Bibliotheksabhängigkeiten hinzufügen. Wenn Sie Maven verwenden, definieren Sie es in pom.xml wie folgt.
<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>
Verwenden Sie die von der Bibliothek bereitgestellte ConnectionFactory, um eine Verbindung zu SQS herzustellen. Da wir diesmal den Elastic MQ-Container verwenden, müssen wir die Endpunkt-URL wie im vorherigen Artikel überschreiben. Es wird auch ein anderer Client Builder verwendet als bei der direkten Verbindung mit dem SDK.
Das Codebeispiel von hier basiert auf dem Folgenden. Beispiel für die Verwendung von Java mit der Amazon SQS-Standardwarteschlange unter Verwendung von 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();
Sie können Nachrichten senden und empfangen, indem Sie nach dem Herstellen einer Verbindung eine JMS-Sitzung einrichten. Ab diesem Zeitpunkt wird die JMS-Standardschnittstelle verwendet. Das Folgende ist ein Codebeispiel zum Senden einer Nachricht.
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);
Der Nachrichtenempfang wird wie folgt implementiert.
Message receivedMessage = consumer.receive(1000);
if (receivedMessage != null) {
System.out.println("Received: " + ((TextMessage) receivedMessage).getText());
}
Ein asynchroner Empfang von Nachrichten durch JMS-Listener ist ebenfalls möglich.
MessageConsumer consumer = session.createConsumer(queue);
consumer.setMessageListener(new MyListener());
connection.start();
MyListener.java
public class MyListener implements MessageListener {
@Override
public void onMessage(Message message) {
//Nachricht verarbeiten
}
}
Trennen Sie die Verbindung wie im Fall des SDK.
connection.close();
Dies ist das Ende des SQS-Zugriffs durch JMS. Wenn Sie mit JMS vertraut sind, werden Sie feststellen, dass es mit einer ähnlichen Implementierung verwendet werden kann.
Der Standard ist JMS, aber in letzter Zeit sollten viele Leute mit Spring Boot oder Spring JMS entwickeln. Schließlich werde ich die Zugriffsmethode einführen, wenn ich diese verwende.
Hier habe ich auf den Inhalt des unten stehenden Links verwiesen. Developing messaging system with Spring Boot, JMS and AWS SQS
Hier fügen wir die Abhängigkeiten von Spring-JMS und Spring Boot Starter zu pom.xml hinzu. In Spring gibt es verschiedene Komponenten. Wenn Sie jedoch die folgenden Codebeispiele ausführen möchten, fügen Sie der Definition den folgenden Inhalt hinzu.
<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>
Mit Spring Boot können Sie Bean-Definitionen in Java implementieren. Implementieren Sie daher die Config-Klasse, um Spring JMS zu aktivieren. Spring JMS wird durch Hinzufügen der EnableJms-Annotation aktiviert. Außerdem wird eine ConnectionFactory erstellt (der Inhalt ist der gleiche wie für JMS) und die Bean-Definition von JmsTemplate implementiert, die sie verwendet.
@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());
}
Durch das Einfügen der in der Config-Klasse definierten JmsTemplate muss die Klasse, die Nachrichten sendet und empfängt, die Verbindung zu SQS nicht kennen. JmsTemplate ist eine Vorlagenklasse zum Senden und Empfangen von Nachrichten, die von Spring JMS bereitgestellt wird, und kann sehr einfach implementiert werden, wenn es sich um einen einfachen Sende- und Empfangsprozess handelt.
@Autowired
private JmsTemplate jmsTemplate;
...
public void sendToSQS(String destination, String message) {
jmsTemplate.convertAndSend(destination, message);
}
Mit Spring JMS können Sie nachrichtengesteuerte POJOs implementieren, die als MDPs (Message-Driven POJOs) bezeichnet werden. Unten finden Sie ein Codebeispiel für den Empfang einer Nachricht per MDP. Durch Hinzufügen der JmsListener-Annotation wird eine Nachricht empfangen und der Prozess der Methode aufgerufen, wenn sie in die im Zielattribut angegebene Warteschlange eingeht.
@JmsListener(destination="testqueue")
public void receive(TextMessage message) {
System.out.println("received: "+message);
}
Um MDP verwenden zu können, muss die folgende Bean-Definition von ListenerContainerFactory in der Config-Klasse implementiert werden.
@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 erledigt dies intern, sodass Sie sich in Ihrer Anwendung keine Sorgen machen müssen.
Sie können sehen, dass Sie mit Spring JMS auf relativ einfache Weise auf SQS zugreifen können. Wenn Sie Elastic MQ als Alternative zu SQS verwenden, befürchte ich, dass die Endpunkt-URL für die Verbindung überschrieben werden muss. Wenn Sie jedoch die Spring-Profilfunktion usw. verwenden, können Sie intelligent zwischen Umgebungen wechseln. Ich glaube, es ist.
Wann kann mit dem tatsächlichen SQS überprüft werden?
Recommended Posts