activeMQ在高并发下的使用

1. pom.xml文件

<!--activeMQ集成spring -->
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-jms -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jms</artifactId>
        <version>4.0.3.RELEASE</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.apache.activemq/activemq-pool -->
    <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-pool</artifactId>
        <version>5.9.0</version>
    </dependency>

    <!--activemq所需jar -->
    <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-all</artifactId>
        <version>5.9.0</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.apache.xbean/xbean-spring -->
    <dependency>
        <groupId>org.apache.xbean</groupId>
        <artifactId>xbean-spring</artifactId>
        <version>3.16</version>
    </dependency>
        <!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz</artifactId>
        <version>1.8.6</version>
    </dependency>

2 生产者和消费者在spring中的配置

<!--spring集成activeMQ的相关配置  -->
    <bean id="jmsFactory" class="org.apache.activemq.pool.PooledConnectionFactory"  
        destroy-method="stop">  
        <property name="connectionFactory">  
            <bean class="org.apache.activemq.ActiveMQConnectionFactory">  
                <property name="brokerURL">  
                    <value>tcp://192.168.0.104:61616</value>  
                </property>  
            </bean>  
        </property>  
        <property name="maxConnections" value="100"></property>  
    </bean>  
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
        <property name="connectionFactory" ref="jmsFactory" />  
        <!--点对点模式  -->
        <property name="defaultDestination" ref="destination" />  
        <property name="messageConverter">  
            <bean class="org.springframework.jms.support.converter.SimpleMessageConverter" />  
        </property>  
    </bean>  

    <bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">  
        <constructor-arg index="0" value="spring-wqueue" />  
    </bean>
    <bean id="destinationTopic" class="org.apache.activemq.command.ActiveMQTopic">  
        <constructor-arg index="0" value="spring-topic" />  
    </bean>

    <!-- 在spring中配置消费者，之后就不需要在程序中配置消费者了 -->
    <bean id="jmsContainer"
        class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="jmsFactory" />
        <property name="destination" ref="destinationTopic" />
        <property name="messageListener" ref="messageListener" />
    </bean>
    <bean id="messageListener"
        class="com.wyn.pro.wynpro.customermanager.test.MyMessageListener">
    </bean>

3 生产者类

package com.wyn.pro.wynpro.customermanager.test;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Service;

@Service
public class WQueueSender {
    @Autowired
    private JmsTemplate jt = null;
    //循环发送100条消息
    public void wsend(int i) {
        for(int j=0;j<100;j++) {
            jt.send(new MessageCreator() {
                public Message createMessage(Session s) throws JMSException {
                    TextMessage msg = s.createTextMessage(String.valueOf(i));
                    return msg;
                }
            });
        }
    }
}

4 service层做为生产者，向activeMQ发送消息

package com.wyn.pro.wynpro.customermanager.serviceImp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.wyn.pro.wynpro.commom.BaseServiceImp;
import com.wyn.pro.wynpro.customermanager.dao.CustomerMapper;
import com.wyn.pro.wynpro.customermanager.entity.Customer;
import com.wyn.pro.wynpro.customermanager.entity.CustomerQueryModel;
import com.wyn.pro.wynpro.customermanager.service.CustomerService;
import com.wyn.pro.wynpro.customermanager.test.WQueueSender;
@Service
//@Transactional
public class CustomerServiceImp extends BaseServiceImp<Customer, CustomerQueryModel> implements CustomerService {
    private CustomerMapper customerMapper;
    @Autowired
    public void setCustomerMapper(CustomerMapper customerMapper) {
        this.customerMapper=customerMapper;
        //重点为父类setDao
        super.setBaseMapper(customerMapper);
    }

    @Autowired
    private WQueueSender wqs;

    public void create1(int i) {
        wqs.wsend(i);
    }

}

5 如果在spring配置消费者

package com.wyn.pro.wynpro.customermanager.test;

import java.util.TimerTask;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

public class MyMessageListener implements MessageListener{


    @Override
    public void onMessage(Message arg0) {
        TextMessage message=(TextMessage) arg0;
        try {
            System.out.println("接受到消息"+message.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }

    }
}

5 如果代码实现消费者，并随程序一起启动

package com.wyn.pro.wynpro.customermanager.test;

import javax.jms.Connection;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MapMessage;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.ActiveMQMessageConsumer;
import org.apache.activemq.RedeliveryPolicy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import com.wyn.pro.wynpro.customermanager.entity.Customer;
import com.wyn.pro.wynpro.customermanager.service.CustomerService;

@Service
public class QueueReceive implements ServletContextListener{

    ActiveMQConnectionFactory cf =new ActiveMQConnectionFactory("tcp://localhost:61616");

    @Autowired
    CustomerService customerService;

    public void receive() throws Exception {
        Connection connection=null;
        final Session session;
        try {

            //启动多个线程来处理消息
            for(int i=0;i<10;i++) {
                //启动多线程处理
                new Wthread(customerService, cf).start();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //connection.close();
        }



    }

    @Override
    public void contextDestroyed(ServletContextEvent arg0) {

    }

    @Override
    public void contextInitialized(ServletContextEvent arg0) {
        ApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(arg0.getServletContext());
        QueueReceive bean = (QueueReceive) applicationContext.getBean("queueReceive");
        try {
            bean.receive();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//创建多线程共同处理消息
class Wthread extends Thread{
    CustomerService customerService;
    ActiveMQConnectionFactory cf ;
    public Wthread(CustomerService customerService, ActiveMQConnectionFactory cf) {
        super();
        this.customerService = customerService;
        this.cf = cf;
    }
    public void run() {
        Connection connection=null;
        final Session session;
        try {
            connection=cf.createConnection();
            connection.start();
            session=connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
            Destination destination=session.createQueue("spring-wqueue");
            ActiveMQMessageConsumer activeMQMessageConsumer=(ActiveMQMessageConsumer) session.createConsumer(destination);
            activeMQMessageConsumer.setMessageListener(new MessageListener() {

                @Override
                public void onMessage(Message message) {
                    int customeruuid=0;
                    System.out.println("----------接收到消息---------------");
                    try {
                    TextMessage textMessage=(TextMessage) message;
                    session.commit();
                        customeruuid = Integer.parseInt(textMessage.getText());
                    } catch (NumberFormatException e) {
                        e.printStackTrace();
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                    //增加同步锁，避免多线程同时操作数据库同一条数据
                    //同步锁针对的是操作数据库的对象(即customerService),而非this
                    synchronized (customerService) {
                        Customer customer = customerService.queryByUuid(customeruuid);
                        String pwd = customer.getPwd();
                        int num=Integer.parseInt(pwd);
                        String pwd1=String.valueOf(num+1);
                        customer.setPwd(pwd1);
                        customerService.update(customer);
                    }

                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}