activemq随笔

 

1、activemq配置

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.RedeliveryPolicy;
import org.apache.activemq.jms.pool.PooledConnectionFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.annotation.EnableJms;
import org.springframework.jms.config.DefaultJmsListenerContainerFactory;
import org.springframework.jms.config.JmsListenerContainerFactory;
import org.springframework.jms.core.JmsTemplate;

import javax.jms.ConnectionFactory;

/**
 * activemq配置
 */
@Configuration
@EnableJms
public class ActivemqConfig {
    @Value("${activemq.brokeAddress:tcp://192.001.21.21:9901}")
    private String brokeAddress;

    @Value("${activemq.pool.maxConnections:1}")
    private int maxConnections;

    @Value("${activemq.pool.expiryTimeout:1000000}")
    private long expiryTimeout;

    @Value("${activemq.alwaysSyncSend:true}")
    private boolean alwaysSyncSend;

    @Value("${activemq.sendTimeout:6000}")
    private int sendTimeout;

    @Value("${activemq.nonBlockingRedelivery:true}")
    private boolean nonBlockingRedelivery;

    @Value("${activemq.initialReconnectDelay:1000}")
    private int initialReconnectDelay;

    @Value("${activemq.randomize:false}")
    private String randomize;

    @Value("${activemq.startupMaxReconnectAttempts:10}")
    private int startupMaxReconnectAttempts;

    @Value("${activemq.timeout:2000}")
    private int timeout;

    @Value("${activemq.queuePrefetch:1}")
    private int queuePrefetch;

    @Value("${activemq.redeliveryPolicy.initialRedeliveryDelay:0}")
    private int initialRedeliveryDelay;

    @Value("${activemq.redeliveryPolicy.redeliveryDelay:1000}")
    private long redeliveryDelay;

    @Value("${activemq.redeliveryPolicy.maximumRedeliveries:6}")
    private int maximumRedeliveries;

    @Value("${activemq.redeliveryPolicy.maximumRedeliveriesDelay:180000}")
    private int maximumRedeliveriesDelay;

    @Value("${activemq.redeliveryPolicy.backOffMultiplier:2}")
    private int backOffMultiplier;

    @Value("${activemq.redeliveryPolicy.useExponentialBackOff:true}")
    private boolean useExponentialBackOff;

    @Bean(destroyMethod = "stop")
    public ConnectionFactory connectionFactory() {
        PooledConnectionFactory pooledConnectionFactory = new PooledConnectionFactory();
        String brokeUrl = "failover:(" + brokeAddress + ")?initialReconnectDelay=" + initialReconnectDelay
                + "&randomize=" + randomize + "&startupMaxReconnectAttempts=" + startupMaxReconnectAttempts
                + "&timeout=" + timeout + "&jms.prefetchPolicy.queuePrefetch=" + queuePrefetch;

        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
                brokeUrl);
        connectionFactory.setAlwaysSyncSend(alwaysSyncSend);
        connectionFactory.setSendTimeout(sendTimeout);
        connectionFactory.setNonBlockingRedelivery(nonBlockingRedelivery);
        RedeliveryPolicy redeliveryPolicy = new RedeliveryPolicy();
        redeliveryPolicy.setInitialRedeliveryDelay(initialRedeliveryDelay);
        redeliveryPolicy.setRedeliveryDelay(redeliveryDelay);
        redeliveryPolicy.setMaximumRedeliveries(maximumRedeliveries);
        redeliveryPolicy.setMaximumRedeliveryDelay(maximumRedeliveriesDelay);
        redeliveryPolicy.setBackOffMultiplier(backOffMultiplier);
        redeliveryPolicy.setUseExponentialBackOff(useExponentialBackOff);
        connectionFactory.setRedeliveryPolicy(redeliveryPolicy);

        pooledConnectionFactory.setConnectionFactory(connectionFactory);
        pooledConnectionFactory.setMaxConnections(maxConnections);
        pooledConnectionFactory.setExpiryTimeout(expiryTimeout);
        return pooledConnectionFactory;
    }

    @Bean(value = "jmsListenerContainerFactory")
    public JmsListenerContainerFactory<?> jmsListenerContainerFactory(ConnectionFactory connectionFactory) {
        DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
        factory.setCacheLevelName("CACHE_CONSUMER");
        factory.setSessionTransacted(true);
        factory.setConnectionFactory(connectionFactory);
        return factory;
    }

    @Bean(value = "topicListenerFactory")
    public JmsListenerContainerFactory<?> topicListenerFactory(ConnectionFactory connectionFactory) {
        DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setPubSubDomain(true);
        factory.setCacheLevelName("CACHE_CONSUMER");
        return factory;
    }

    @Bean
    public JmsTemplate jmsTemplate(ConnectionFactory connectionFactory) {
        return new JmsTemplate(connectionFactory);
    }

}

 2、生产者

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.JmsException;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.retry.annotation.EnableRetry;
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Component;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * jmsTemplate包装，实现带属性和重发机制
 */
@Component
@EnableRetry
public class Producer {

    Logger logger = LoggerFactory.getLogger(Producer.class);

    @Autowired
    private JmsTemplate jmsTemplate;

    public void send(String destinationName, Serializable content, HashMap<String, Object> properties) {
        send(destinationName, content, properties, false);
    }

    public void send(String destinationName, Serializable content) {
        send(destinationName, content, null, false);
    }

    public void sendPubSub(String destinationName, Serializable content, HashMap<String, Object> properties) {
        send(destinationName, content, properties, true);
    }

    public void sendPubSub(String destinationName, Serializable content) {
        send(destinationName, content, null, true);
    }


    @Retryable(value = JmsException.class, maxAttemptsExpression = "#{${max.attempts:3}}")
    public void send(final String destinationName, final Serializable content, final HashMap<String, Object> properties, boolean isPubSub) {
        try {
            logger.info("send={},message={}", destinationName, content);

            jmsTemplate.setPubSubDomain(isPubSub);

            jmsTemplate.send(destinationName, new MessageCreator() {
                @Override
                public Message createMessage(Session session) throws JMSException {
                    Message message = session.createObjectMessage(content);

                    if (properties != null) {
                        Set<Map.Entry<String, Object>> entries = properties.entrySet();
                        for (Map.Entry<String, Object> entry : entries) {
                            message.setObjectProperty(entry.getKey(), entry.getValue());
                        }
                    }

                    return message;
                }
            });

        } catch (JmsException e) {
            logger.warn(e.getLocalizedMessage());
            throw e;
        }
    }

    @Recover
    public void sendRecover(JmsException jmsException) {
        logger.error("sender error:" + jmsException.getLocalizedMessage());
    }

}

3、消费者监听

import java.util.HashMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSONObject;

@Component
public class ActivemqListener {
	private static final Logger logger = LoggerFactory.getLogger(ActivemqListener .class);


	@JmsListener(containerFactory = "jmsListenerContainerFactory", destination = QueueName)
	public void listener(String req) {
		logger.info("req:{}", req);
		try {
			//TODO

		} catch (Exception e) {
			
	    }
}