亚洲成av人片,亚洲一区二区三区高清不卡,成人av综合网

构徏ARTEMIS集群

paulwong — Wed, 30 Jun 2021 08:33:00 GMT

摘要: 如果多个ARTEMIS以单体的方式启动�Q�则各个实例互不相关�Q�不能实现高可用。集��因此需��多个实例组�?-集群�Q�以实现高可用，即集��内可实现实例的��p�|转移�Q�消息的负蝲均衡�Q�消息的重新分配。这需要在集群配置区指定所有所有实例的IP和PORT。但集群实例如果DOWN机，其保存的消息也会随之消失�Q�因此需要实现高可用�Q�有两种方式�Q�共享存储及消息复制。共享存储共享存储是由master/slave对组成，指两�?.. 阅读全文

paulwong 2021-06-30 16:33 发表评论

paulwong — Thu, 01 Apr 2021 08:36:00 GMT

https://my.oschina.net/u/1388595/blog/4545503

paulwong 2021-04-01 16:36 发表评论

在SPRING BOOT中��用多JMS CONNECTION

paulwong — Thu, 19 Mar 2020 01:45:00 GMT

使用自定义CONNECTION FACTORY�Q�这样会覆盖SPRING 的AUTO CONFIGURATION�?br />
ActiveMQConnectionFactoryFactory.java

import java.lang.reflect.InvocationTargetException;
import java.util.Collections;
import java.util.List;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.springframework.boot.autoconfigure.jms.activemq.ActiveMQConnectionFactoryCustomizer;
import org.springframework.boot.autoconfigure.jms.activemq.ActiveMQProperties;
import org.springframework.boot.autoconfigure.jms.activemq.ActiveMQProperties.Packages;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

/**
* Factory to create a {@link ActiveMQConnectionFactory} instance from properties defined
* in {@link SecondaryActiveMQProperties}.
*
* @author Phillip Webb
* @author Venil Noronha
*/
class ActiveMQConnectionFactoryFactory {

    private static final String DEFAULT_EMBEDDED_BROKER_URL = "vm://localhost?broker.persistent=false";

    private static final String DEFAULT_NETWORK_BROKER_URL = "tcp://localhost:61616";

    private final ActiveMQProperties properties;

    private final List factoryCustomizers;

    ActiveMQConnectionFactoryFactory(ActiveMQProperties properties,
            List factoryCustomizers) {
        Assert.notNull(properties, "Properties must not be null");
        this.properties = properties;
        this.factoryCustomizers = (factoryCustomizers != null) ? factoryCustomizers : Collections.emptyList();
    }

    public extends ActiveMQConnectionFactory> T createConnectionFactory(Class factoryClass) {
        try {
            return doCreateConnectionFactory(factoryClass);
        }
        catch (Exception ex) {
            throw new IllegalStateException("Unable to create " + "ActiveMQConnectionFactory", ex);
        }
    }

    private extends ActiveMQConnectionFactory> T doCreateConnectionFactory(Class factoryClass) throws Exception {
        T factory = createConnectionFactoryInstance(factoryClass);
        if (this.properties.getCloseTimeout() != null) {
            factory.setCloseTimeout((int) this.properties.getCloseTimeout().toMillis());
        }
        factory.setNonBlockingRedelivery(this.properties.isNonBlockingRedelivery());
        if (this.properties.getSendTimeout() != null) {
            factory.setSendTimeout((int) this.properties.getSendTimeout().toMillis());
        }
        Packages packages = this.properties.getPackages();
        if (packages.getTrustAll() != null) {
            factory.setTrustAllPackages(packages.getTrustAll());
        }
        if (!packages.getTrusted().isEmpty()) {
            factory.setTrustedPackages(packages.getTrusted());
        }
        customize(factory);
        return factory;
    }

    private extends ActiveMQConnectionFactory> T createConnectionFactoryInstance(Class factoryClass)
            throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        String brokerUrl = determineBrokerUrl();
        String user = this.properties.getUser();
        String password = this.properties.getPassword();
        if (StringUtils.hasLength(user) && StringUtils.hasLength(password)) {
            return factoryClass.getConstructor(String.class, String.class, String.class).newInstance(user, password,
                    brokerUrl);
        }
        return factoryClass.getConstructor(String.class).newInstance(brokerUrl);
    }

    private void customize(ActiveMQConnectionFactory connectionFactory) {
        for (ActiveMQConnectionFactoryCustomizer factoryCustomizer : this.factoryCustomizers) {
            factoryCustomizer.customize(connectionFactory);
        }
    }

    String determineBrokerUrl() {
        if (this.properties.getBrokerUrl() != null) {
            return this.properties.getBrokerUrl();
        }
        if (this.properties.isInMemory()) {
            return DEFAULT_EMBEDDED_BROKER_URL;
        }
        return DEFAULT_NETWORK_BROKER_URL;
    }
}

TwinJmsConnectionFactoryConfiguration.java

import java.util.stream.Collectors;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.messaginghub.pooled.jms.JmsPoolConnectionFactory;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.jms.JmsPoolConnectionFactoryFactory;
import org.springframework.boot.autoconfigure.jms.activemq.ActiveMQConnectionFactoryCustomizer;
import org.springframework.boot.autoconfigure.jms.activemq.ActiveMQProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Profile;

@Configuration
@Profile({"local"})
public class TwinJmsConnectionFactoryConfiguration {

    @Bean
    @ConfigurationProperties(prefix = "spring.activemq.primary")
    public ActiveMQProperties primaryActiveMQProperties() {
        return new ActiveMQProperties();
    }

    @Bean(destroyMethod = "stop")
    @Primary
    @ConditionalOnProperty(prefix = "spring.activemq.pool", name = "enabled", havingValue = "true")
    public JmsPoolConnectionFactory connectionFactory(ActiveMQProperties primaryActiveMQProperties,
            ObjectProvider factoryCustomizers) {
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactoryFactory(primaryActiveMQProperties,
                factoryCustomizers.orderedStream().collect(Collectors.toList()))
                .createConnectionFactory(ActiveMQConnectionFactory.class);
        return new JmsPoolConnectionFactoryFactory(primaryActiveMQProperties.getPool())
                .createPooledConnectionFactory(connectionFactory);
    }

    ////////////////////////////////////////////////////////////////////////////////
    @Bean
    @ConfigurationProperties(prefix = "spring.activemq.sescond")
    public ActiveMQProperties sescondActiveMQProperties() {
        return new ActiveMQProperties();
    }

    @Bean(destroyMethod = "stop")
    @ConditionalOnProperty(prefix = "spring.activemq.pool", name = "enabled", havingValue = "true")
    public JmsPoolConnectionFactory sescondPooledJmsConnectionFactory(ActiveMQProperties sescondActiveMQProperties,
            ObjectProvider factoryCustomizers) {
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactoryFactory(sescondActiveMQProperties,
                factoryCustomizers.orderedStream().collect(Collectors.toList()))
                .createConnectionFactory(ActiveMQConnectionFactory.class);
        return new JmsPoolConnectionFactoryFactory(sescondActiveMQProperties.getPool())
                .createPooledConnectionFactory(connectionFactory);
    }

}

paulwong 2020-03-19 09:45 发表评论

Which is better: PooledConnectionFactory or CachingConnectionFactory?

paulwong — Thu, 19 Mar 2020 01:37:00 GMT

From here:

The difference between the PooledConnectionFactory and the CachingConnectionFactory is a difference in implementation. Below are some of the characteristics that differ between them:

Although both the PooledConnectionFactory and the CachingConnectionFactory state that they each pool connections, sessions and producers, the PooledConnectionFactory does not actually create a cache of multiple producers. It simply uses a singleton pattern to hand out a single cached producer when one is requested. Whereas the CachingConnectionFactory actually creates a cache containing multiple producers and hands out one producer from the cache when one is requested.
The PooledConnectionFactory is built on top of the Apache Commons Pool project for pooling JMS sessions. This allows some additional control over the pool because there are features in Commons Pool that are not being used by the PooledConnectionFactory. These additional features include growing the pool size instead of blocking, throwing an exception when the pool is exhausted, etc. You can utilize these features by creating your own Commons Pool GenericObjectPool using your own customized settings and then handing that object to the PooledConnectionFactory via the setPoolFactory method. See the following for additional info: http://commons.apache.org/pool/api-1.4/org/apache/commons/pool/impl/GenericObjectPoolFactory.html
The CachingConnectionFactory has the ability to also cache consumers. Just need to take care when using this feature so that you know the consumers are cached according to the rules noted in the blog post.
But most importantly, the CachingConnectionFactory will work with any JMS compliant MOM. It only requires a JMS connection factory. This is important if you are using more than one MOM vendor which is very common in enterprise organizations (this is mainly due to legacy and existing projects). The important point is that the CachingConnectionFactory works very well with many different MOM implementations, not only ActiveMQ.

From here:

If you have clustered ActiveMQs, and use failover transport it has been reported that CachingConnectionFactory is not a right choice.
The problem I’m having is that if one box goes down, we should start sending messages on the other, but it seems to still be using the old connection (every send times out). If I restart the program, it’ll connect again and everything works. Source: Autoreconnect problem with ActiveMQ and CachingConnectionFactory
The problem is that cached connections to the failed ActiveMQ was still in use and that created the problem for the user. Now, the choice for this scenario is PooledConnectionFactory.
If you’re using ActiveMQ today, and chances are that you may switch to some other broker (JBoss MQ, WebSphere MQ) in future, do not use PooledConnectionFactory, as it tightly couples your code to ActiveMQ.

paulwong 2020-03-19 09:37 发表评论

Setting up ActiveMQ for HA-Load Balance

paulwong — Mon, 04 Nov 2019 08:14:00 GMT

In a typical enterprise applications, we often need messaging and asynchronous processing.
To satisfy this need, we need a reliable as well as scalable messaging infrastructure. In currently available messaging infrastructures Apache ActiveMQ stands out in terms of features and simplicity.

Apache ActiveMQ comes with lot of features in built and also provides a way to configure or tweak as per the needs of an application.

In this post , we will explore how to enable network of activeMQ brokers so that we achieve HA(High Availability) as well as load balance between consumers & producers.

I carried out my experiment on local machine with ACtiveMQ 5.8.0, but this can be easily upgraded to latest versions of ActiveMQ viz. 5.10.0

To have network of brokers, we need multiple brokers. So, I changed tcp and admin ports of brokers so that I can run multiple brokers on single machine.

To get brief background on network of broker, please visit this link

In this post we will setup below topology, we will mix failover and NOB to get work done,

1. Producer1 is configured to send messages to broker3 with failover to broker2

2. Producer2 is configured to send messages to broker2 with failover to broker3

3. Broker3, Broker2 are networked with Broker1as below

4. Broker1 is connected with broker4 with NOB.

5. Make sure you enable "advisorySupport" on the broker, which is essential for transparent routing of messages across brokers.

Dry Run:

1. Producer1 sends messages to queue "input.q" on broker3, where there are no active consumers, but it see subscriptions from broker1

2. Broker1 and broker 4 are has consumers which are looking at "input.q".

3. When broker3 receives a message it forwards it to broker1, as its in networked and has active consumers for "input.q"

4. When broker1 receives a messages on "input.q", it gets load balanced between broker1 and broker4 as both has consumers looking for "input.q".

5. Whenever broker3 goes down, producer1 switches transparently to broker2, as its configured with failover.

6. I used prefetch size as 1, so that you can load balancing on consumers

Sample activemq configurations can be downloaded from here.

paulwong 2019-11-04 16:14 发表评论

ACTIVE MQ HA

paulwong — Fri, 01 Nov 2019 02:46:00 GMT

�l�徏ACTIVEMQ CLUSTER�Q��得其中一个ACTIVE MQ DOWN掉时�Q�能自动切换到其他节炏V�?br />
ACTIVEMQ 只有MASTER-SLAVE模式�Q�集��中的多个节点共享消息的存储�Q�多个节点同时启动时�Q�竞争消息存储的锁，谁先取得�Q�谁��是MASTER�Q�当MASTER DOWN掉时�Q�锁被释放，SALVE中马上又竞争锁，取得者成为MASTER�?br />
�Ҏ��Q?br />

安装NFSV4
修改消息存储路径

<persistenceAdapter>
<kahaDB directory="/sharedFileSystem/sharedBrokerData"/>
persistenceAdapter>
客户端修改连接字�W�串

failover://(tcp://master:61616,tcp://slave:61616)?randomize=false

--�?img src="https://activemq.apache.org/assets/img/MasterFailed.png" alt="" />

https://my.oschina.net/hzchenyh/blog/716424

https://www.iteye.com/blog/shift-alt-ctrl-2069250

https://stackoverflow.com/questions/53542928/activemq-ha-on-failover

https://activemq.apache.org/shared-file-system-master-slave

ActiveMQ(6)-��Z��networkConnector的Broker-Cluster�Ҏ��
https://blog.csdn.net/jinjin603/article/details/78657387

Multi Data Centre Message Brokers with ActiveMQ
https://medium.com/thg-tech-blog/multi-data-centre-message-brokers-with-activemq-28495046370e

ActiveMQ中的NetworkConnector�Q�网�l�连接器�Q�详�?br />https://www.iteye.com/blog/manzhizhen-2116920

a

paulwong 2019-11-01 10:46 发表评论

ACTIVEMQ讄��预取消息数目

paulwong — Thu, 31 Oct 2019 03:28:00 GMT

当ACTIVEMQ的某个QUEUE有多个消费者，为避免某个消息者取了更多个消息处理�Q�而造成其他消费者无消息可处理的情况�Q�可以设�|�每个消费者不预取消息�Q�即每个消费者消费完单个消息后，再去取消息，�q�样其他消费者就能��^均的有消息可处理�?br />

https://stackoverflow.com/questions/35928089/activemq-how-to-prevent-message-from-going-to-dispatched-queue

讄��Ҏ��Q�在CONNECT STRING中设�|�：

tcp://localhost:61616?jms.prefetchPolicy.all=0

tcp://localhost:61616?jms.prefetchPolicy.queuePrefetch=0

queue = new ActiveMQQueue("TEST.QUEUE?consumer.prefetchSize=10");
consumer = session.createConsumer(queue);

http://activemq.apache.org/what-is-the-prefetch-limit-for.html

paulwong 2019-10-31 11:28 发表评论

Springboot ActiveMQ jmsTemplate配置

paulwong — Wed, 24 Jul 2019 03:40:00 GMT

@Configuration
@DependsOn(value="cachingConnectionFactory")
public class JmsTemplateConfiguration {

@Value("${wechat.sendmessage.queue}")
private String queueName;

@Value("${wechat.sendmessage.topic}")
private String topicName;

@Value("${spring.jms.pub-sub-domain}")
private boolean isPubSubDomain;

/**
* 定义点对炚w��?br /> * @return
*/
@Bean
public Queue queue() {
    return new ActiveMQQueue(queueName);
}

/**
* 定义一个主�?br /> * @return
*/
@Bean
public Topic topic() {
    return new ActiveMQTopic(topicName);
}

private final ObjectProvider destinationResolver;
private final ObjectProvider messageConverter;
private final CachingConnectionFactory cachingConnectionFactory;

@Autowired
public JmsTemplateConfiguration(ObjectProvider destinationResolver,
                                ObjectProvider messageConverter,
                                CachingConnectionFactory cachingConnectionFactory) {
    this.destinationResolver = destinationResolver;
    this.messageConverter = messageConverter;
    this.cachingConnectionFactory = cachingConnectionFactory;
}

/**
* 配置队列生��者的JmsTemplate
* @return JmsTemplate
*/
@Bean(name="jmsQueueTemplate")
public JmsTemplate jmsQueueTemplate() {
    //讄��创徏�q�接的工�?br />    //JmsTemplate jmsTemplate = new JmsTemplate(connectionFactory);
    //优化�q�接工厂�Q�这里应用缓存池 �q�接工厂��即�?/span>
    JmsTemplate jmsTemplate = new JmsTemplate(cachingConnectionFactory);
    //讄��默认消费topic
   //jmsTemplate.setDefaultDestination(topic());
    //讄��P2P队列消息�c�d��
    jmsTemplate.setPubSubDomain(isPubSubDomain);

    DestinationResolver destinationResolver = (DestinationResolver) this.destinationResolver.getIfUnique();
    if (destinationResolver != null) {
        jmsTemplate.setDestinationResolver(destinationResolver);
    }
    MessageConverter messageConverter = (MessageConverter) this.messageConverter.getIfUnique();
    if (messageConverter != null) {
        jmsTemplate.setMessageConverter(messageConverter);
    }
    //deliveryMode, priority, timeToLive 的开养I��要生效，必须配置为true�Q�默认false
    jmsTemplate.setExplicitQosEnabled(true);
    //DeliveryMode.NON_PERSISTENT=1:非持�?nbsp;; DeliveryMode.PERSISTENT=2:持久
    //定义持久化后节点挂掉以后�Q�重启可以��l�消�?
    jmsTemplate.setDeliveryMode(DeliveryMode.PERSISTENT);
    //默认不开启事�?/span>
    System.out.println("默认是否开启事务："+jmsTemplate.isSessionTransacted());
    //如果不启用事务，则会��D��XA事务失效�Q?br />    //作�ؓ生��者如果需要支持事务，则需要配�|�SessionTransacted为true
  //jmsTemplate.setSessionTransacted(true);
    //消息的应�{�方式，需要手动确认，此时SessionTransacted必须被设�|��ؓfalse�Q�且为Session.CLIENT_ACKNOWLEDGE模式
    //Session.AUTO_ACKNOWLEDGE  消息自动�{�收
    //Session.CLIENT_ACKNOWLEDGE  客户端调用acknowledge�Ҏ��手动�{�收
    //Session.DUPS_OK_ACKNOWLEDGE 不必必须�{�收�Q�消息可能会重复发�?/span>
    jmsTemplate.setSessionAcknowledgeMode(Session.CLIENT_ACKNOWLEDGE);
    return jmsTemplate;
}

/**
* 配置发布订阅生��者的JmsTemplate
* @return JmsTemplate
*/
@Bean(name="jmsTopicTemplate")
public JmsTemplate jmsTopicTemplate() {
    //讄��创徏�q�接的工�?br />   //JmsTemplate jmsTemplate = new JmsTemplate(connectionFactory);
    //优化�q�接工厂�Q�这里应用缓存池 �q�接工厂��即�?/span>
    JmsTemplate jmsTemplate = new JmsTemplate(cachingConnectionFactory);
    //讄��默认消费topic
  //jmsTemplate.setDefaultDestination(topic());
    //讄��发布订阅消息�c�d��
    jmsTemplate.setPubSubDomain(isPubSubDomain);

    //deliveryMode, priority, timeToLive 的开养I��要生效，必须配置为true�Q�默认false
    jmsTemplate.setExplicitQosEnabled(true);
    //DeliveryMode.NON_PERSISTENT=1:非持�?nbsp;; DeliveryMode.PERSISTENT=2:持久
    jmsTemplate.setDeliveryMode(DeliveryMode.PERSISTENT);

    //默认不开启事�?/span>
    System.out.println("是否开启事�?+jmsTemplate.isSessionTransacted());
    //如果session带有事务�Q��ƈ且事务成功提交，则消息被自动�{�收。如果事务回滚，则消息会被再�ơ传送�?br />    //jmsTemplate.setSessionTransacted(true);

    //不带事务的session的签收方式，取决于session的配�|��?br />    //默认消息��认方式�?�Q�即AUTO_ACKNOWLEDGE
    System.out.println("是否消息��认方式"+jmsTemplate.getSessionAcknowledgeMode());

    //消息的应�{�方式，需要手动确认，此时SessionTransacted必须被设�|��ؓfalse�Q�且为Session.CLIENT_ACKNOWLEDGE模式
    //Session.AUTO_ACKNOWLEDGE  消息自动�{�收
    //Session.CLIENT_ACKNOWLEDGE  客户端调用acknowledge�Ҏ��手动�{�收
    //Session.DUPS_OK_ACKNOWLEDGE 不必必须�{�收�Q�消息可能会重复发�?/span>
    jmsTemplate.setSessionAcknowledgeMode(Session.CLIENT_ACKNOWLEDGE);

    return jmsTemplate;
}

}

paulwong 2019-07-24 11:40 发表评论

Build Messaging Between Ruby/Rails Applications with ActiveMQ

paulwong — Fri, 12 Jul 2019 09:12:00 GMT

https://dev.to/kirillshevch/build-messaging-between-ruby-rails-applications-with-activemq-4fin

paulwong 2019-07-12 17:12 发表评论

RABBITMQ资源

paulwong — Fri, 28 Jun 2019 02:24:00 GMT

消息队列�?RabbitMQ
https://www.jianshu.com/p/79ca08116d57

Spring Boot 中��?RabbitMQ
https://juejin.im/post/59f194e06fb9a0451329ec53

paulwong 2019-06-28 10:24 发表评论

How to implement JMS ReplyTo using SpringBoot

paulwong — Thu, 27 Jun 2019 01:20:00 GMT

Request-Response is a message-exchange-pattern. In some cases, a message producer may want the consumers to reply to a message. The JMSReplyTo header indicates which destination, if any, a JMS consumer should reply to. The JMSReplyTo header is set explicitly by the JMS client; its contents will be a javax.jms.Destination object (either Topic or Queue).

In some cases, the JMS client will want the message consumers to reply to a temporary topic or queue set up by the JMS client. When a JMS message consumer receives a message that includes a JMSReplyTo destination, it can reply using that destination. A JMS consumer is not required to send a reply, but in some JMS applications, clients are programmed to do so.

For simplicity, this pattern is typically implemented in a purely synchronous fashion, as in web service calls over HTTP, which holds a connection open and waits until the response is delivered or the timeout period expires. However, request–response may also be implemented asynchronously, with a response being returned at some unknown later time.

For more information, check here.

Now, let’s jump into the code. In Spring, there are 2 ways to implement this (at least I know of).

Using JMSTemplate
Using Spring Integration

For demo purpose, I used ActiveMQ. However, you can implement this in other messaging systems like IBM MQ, Rabbit MQ, Tibco EMS, etc. In this demo, I send an ObjectMessage of type Order and reply with a Shipment object.

Using JMSTemplate

First, we include the required dependencies. Replace the activemq dependency with your messaging system’s jars if not using ActiveMQ
<dependencies>
     <dependency>
         <groupId>org.springframework.bootgroupId>
         <artifactId>spring-boot-starter-activemqartifactId>
     dependency>
     <dependency>
         <groupId>org.apache.activemq.toolinggroupId>
         <artifactId>activemq-junitartifactId>
         <version>${activemq.version}version>
         <scope>testscope>
     dependency>
     <dependency>
         <groupId>org.springframework.bootgroupId>
         <artifactId>spring-boot-starter-testartifactId>
         <scope>testscope>
     dependency>
dependencies>
Using the default spring.activemq. properties to configure the application with the ActiveMQ. However, you can do this inside a @Configuration class as well.
spring:
   activemq:
     broker-url: tcp://localhost:61616
     non-blocking-redelivery: true
     packages:
       trust-all: true
Note in the above configuration spring.activemq.packages.trust-all can be changed to spring.activemq.packages.trusted with the appropriate packages.
Now spring will do it’s magic and inject all the required Beans as usual :) However, in our code, we need to EnableJms
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.annotation.EnableJms;

@EnableJms
@Configuration
public class ActiveMQConfig {

public static final String ORDER_QUEUE = "order-queue";
public static final String ORDER_REPLY_2_QUEUE = "order-reply-2-queue";

}
First, we will configure the Producer
@Slf4j
@Service
public class Producer {

     @Autowired
     JmsMessagingTemplate jmsMessagingTemplate;

     @Autowired
     JmsTemplate jmsTemplate;
private Session session;

@PostConstruct
public void init(){
jmsTemplate.setReceiveTimeout(1000L);
         jmsMessagingTemplate.setJmsTemplate(jmsTemplate);

session = jmsMessagingTemplate.getConnectionFactory().createConnection()
                 .createSession(false, Session.AUTO_ACKNOWLEDGE);
}

     public Shipment sendWithReply(Order order) throws JMSException {

         ObjectMessage objectMessage = session.createObjectMessage(order);

         objectMessage.setJMSCorrelationID(UUID.randomUUID().toString());
         objectMessage.setJMSReplyTo(new ActiveMQQueue(ORDER_REPLY_2_QUEUE));
         objectMessage.setJMSCorrelationID(UUID.randomUUID().toString());
         objectMessage.setJMSExpiration(1000L);
         objectMessage.setJMSDeliveryMode(DeliveryMode.NON_PERSISTENT);

         return jmsMessagingTemplate.convertSendAndReceive(new ActiveMQQueue(ORDER_QUEUE),
                 objectMessage, Shipment.class); //this operation seems to be blocking + sync
     }
}
Note in the above code that, JmsMessagingTemplate is used instead of JmsTemplatebecause, we are interested in the method convertSendAndReceive. As seen in the method signature, it waits to receive the Shipment object from the consumer.
Next, we can see the Receiver
@Component
public class Receiver implements SessionAwareMessageListener<Message> {

     @Override
     @JmsListener(destination = ORDER_QUEUE)
     public void onMessage(Message message, Session session) throws JMSException {
         Order order = (Order) ((ActiveMQObjectMessage) message).getObject();
         Shipment shipment = new Shipment(order.getId(), UUID.randomUUID().toString());

         // done handling the request, now create a response message
         final ObjectMessage responseMessage = new ActiveMQObjectMessage();
         responseMessage.setJMSCorrelationID(message.getJMSCorrelationID());
         responseMessage.setObject(shipment);

         // Message sent back to the replyTo address of the income message.
         final MessageProducer producer = session.createProducer(message.getJMSReplyTo());
         producer.send(responseMessage);
     }
}
Using the javax.jms.Session the javax.jms.MessageProducer is created and used to send the reply message to the JMSReplyTo queue. In real life, this receiver could be a different application altogether.

Using Spring Integration

First, we include the required dependencies in addition to the above dependencies
<dependency>
<groupId>org.springframework.integrationgroupId>
<artifactId>spring-integration-jmsartifactId>
dependency>
Using the default spring.activemq. properties to configure the application with the ActiveMQ. However, you can do this inside a @Configuration class as well.
spring:
   activemq:
     broker-url: tcp://localhost:61616
     non-blocking-redelivery: true
     packages:
       trust-all: true
Note in the above configuration spring.activemq.packages.trust-all can be changed to spring.activemq.packages.trusted with the appropriate packages.
Next we create the required Beans for the Spring Integration.

@EnableIntegration
@IntegrationComponentScan
@Configuration
public class ActiveMQConfig {

     public static final String ORDER_QUEUE = "order-queue";
     public static final String ORDER_REPLY_2_QUEUE = "order-reply-2-queue";

     @Bean
     public MessageConverter messageConverter() {
         MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter();
         converter.setTargetType(MessageType.TEXT);
         converter.setTypeIdPropertyName("_type");
         return converter;
     }

     @Bean
     public MessageChannel requests() {
         return new DirectChannel();
     }

     @Bean
     @ServiceActivator(inputChannel = "requests")
     public JmsOutboundGateway jmsGateway(ActiveMQConnectionFactory activeMQConnectionFactory) {
         JmsOutboundGateway gateway = new JmsOutboundGateway();
         gateway.setConnectionFactory(activeMQConnectionFactory);
         gateway.setRequestDestinationName(ORDER_QUEUE);
         gateway.setReplyDestinationName(ORDER_REPLY_2_QUEUE);
         gateway.setCorrelationKey("JMSCorrelationID");
         gateway.setSendTimeout(100L);
         gateway.setReceiveTimeout(100L);
         return gateway;
     }

     @Autowired
     Receiver receiver;

     @Bean
     public DefaultMessageListenerContainer responder(ActiveMQConnectionFactory activeMQConnectionFactory) {
         DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
         container.setConnectionFactory(activeMQConnectionFactory);
         container.setDestinationName(ORDER_QUEUE);
         MessageListenerAdapter adapter = new MessageListenerAdapter(new Object() {

             @SuppressWarnings("unused")
             public Shipment handleMessage(Order order) {
                 return receiver.receiveMessage(order);
             }

         });
         container.setMessageListener(adapter);
         return container;
     }
}
Next, we will configure the MessagingGateway

@MessagingGateway(defaultRequestChannel = "requests")
public interface ClientGateway {
Shipment sendAndReceive(Order order);
}
We then Autowire this gateway in our Component class when we want to send and receive the message. A sample is shown below.

@Slf4j
@Component
public class Receiver {
     public Shipment receiveMessage(@Payload Order order) {
         Shipment shipment = new Shipment(order.getId(), UUID.randomUUID().toString());
         return shipment;
     }
}
Next we configure the Componen to process the Order message. After successful execution, this component will send the Shipment message to the JMSReplyTo queue. In real life, this receiver could be a different application altogether.

For those, who just want to clone the code, head out to aniruthmp/jms

Written on June 5, 2018
https://aniruthmp.github.io/Spring-JMS-request-response/

paulwong 2019-06-27 09:20 发表评论

paulwong — Wed, 26 Jun 2019 06:13:00 GMT

https://blog.51cto.com/1754966750/category17.html

paulwong 2019-06-26 14:13 发表评论

paulwong — Mon, 24 Jun 2019 09:42:00 GMT

现有的系�l�架构都是分布式的。有多个消息的发送者和多个消息的消费者。例如订单创建消息和订单支付消息�Q�我们需要保证先消费订单创徏消息�Q�然后消费订单支付消息�?br />
如何解决MQ消息消费��序问题
https://segmentfault.com/a/1190000014512075

jms-如何保证消息的顺�?br />https://leokongwq.github.io/2017/01/23/jms-message-order.html

paulwong 2019-06-24 17:42 发表评论

JMS最��单的解释

paulwong — Wed, 06 Jun 2012 02:18:00 GMT

JMS是远�E�调用的一�U�，如写了一个方法，惌��q�程JVM中的对象调用�Ӟ��׃��了这样一个规定，在本�w�的JVM中徏一个队列：List�Q�里面只能放�q�个�Ҏ��所需参数�c�d��的对象，如有马上执行本方法，执行后将此对象从队列中移除。远�E�对象如果想调用此方法，只需往�q�队列插对象卛_��?img src ="http://www.aygfsteel.com/paulwong/aggbug/380104.html" width = "1" height = "1" />

paulwong 2012-06-06 10:18 发表评论