基于rabbitMQ实现在高并发下性能倍增

其他 2018-09-10 10:29:59 阅读次数: 0
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u011320740/article/details/78913553

以服务与服务之间的调用来举个例子，比如我们提供的是rest服务，那么如果在高并发下访问rest服务究竟能支撑多大的并发量呢？

下面我先提供一个小例子来测试下


项目目录结构如下：



具体代码如下：

UserController.java

package com.cwh.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.cwh.model.User;
import com.cwh.service.UserService;

@Controller
@RequestMapping(value="user")
public class UserController {

	@Autowired
	private UserService userService;
	
	@RequestMapping(value="/get/{id}",method=RequestMethod.GET)
	public @ResponseBody User getUser(@PathVariable("id")String id){
		User user = userService.getUser(id);
		return user;
		
	}
}

UserMapper.java

package com.cwh.inter;

import com.cwh.model.User;

public interface UserMapper {

	public User selectUserByID(String id);
}


User.java

package com.cwh.model;

import java.io.Serializable;

public class User implements Serializable{
	   
    /**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private int id;
    private String userName;
    private String userAge;
    private String userAddress;
   
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserAge() {
        return userAge;
    }
    public void setUserAge(String userAge) {
        this.userAge = userAge;
    }
    public String getUserAddress() {
        return userAddress;
    }
    public void setUserAddress(String userAddress) {
        this.userAddress = userAddress;
    }

}


UserService.java 
package com.cwh.service;

import com.cwh.model.User;

public interface UserService {

	public User getUser(String id);
}

UserServiceImpl.java

package com.cwh.service.impl;

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

import com.cwh.inter.UserMapper;
import com.cwh.model.User;
import com.cwh.service.UserService;
@Service("userService")
public class UserServiceImpl implements UserService {

	@Autowired
    UserMapper userMapper;
	public User getUser(String id) {
		// TODO Auto-generated method stub
		return userMapper.selectUserByID(id);
	}

}


applicationContext.xml 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
	http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.0.xsd
	">
<context:annotation-config/>
<context:component-scan base-package="com.cwh.*"/> 
<!-- <tx:annotation-driven proxy-target-class="true"/> -->
<context:property-placeholder location="classpath:*.properties"/><!-- 加载配置文件 -->
 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
     <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
     <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?characterEncoding=utf8"/>
     <property name="username" value="root"/>
     <property name="password" value=""/>
     <!-- 连接被泄露时是否打印 -->  
     <property name="logAbandoned" value="true"/>  
     <property name="initialSize" value="2"/>
     <property name="maxActive" value="2"/>
     <!--minIdle: 最小空闲连接-->    
     <property name="minIdle" value="2"/>  
     <!--maxIdle: 最大空闲连接-->    
     <property name="maxIdle" value="2"/>
     <!--maxWait: 超时等待时间以毫秒为单位 1000等于60秒-->  
   	 <property name="maxWait" value="1000"/> 
     <property name="poolPreparedStatements" value="true"/>
  </bean>

   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name="dataSource" ref="dataSource" />
    </bean>
   
    
  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
     <!--dataSource属性指定要用到的连接池-->
     <property name="dataSource" ref="dataSource"/>
     <!-- 所有配置的mapper文件 -->
     <property name="mapperLocations" value="classpath*:com/cwh/mapper/*.xml" />
  </bean>
 
  <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
     <property name="basePackage" value="com.cwh.inter" />    
  </bean>
</beans>


mybatis-config.xml 
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
	<typeAliases>
		<package name="com.cwh.model"/>
	</typeAliases>
</configuration>


spring-mvc.xml 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans    
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="com.cwh.controller" />
    <mvc:annotation-driven>  
    <!-- 启动JSON格式的配置 -->  
       <mvc:message-converters>    
       		<!-- 这里也可以自己定制class -->  
		    <bean id="jsonConverter" class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter"><!-- 这里也可以自己定制class -->  
		        <property name="supportedMediaTypes">    
		            <list>    
		                <value>text/html;charset=UTF-8</value>  <!-- 避免IE出现下载JSON文件的情况 -->  
		            </list>    
		        </property>      
		    </bean>    
		</mvc:message-converters>    
   </mvc:annotation-driven>  
   
    <mvc:resources mapping="/static/**" location="/WEB-INF/static/"/> 
    <mvc:default-servlet-handler/> 
    
    <bean
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix">
            <value>/WEB-INF/pages/</value>
        </property>
        <property name="suffix">
            <value>.jsp</value>
        </property>
    </bean>

</beans>


User.xml 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.cwh.inter.UserMapper"><!-- 对应接口 -->

	<resultMap id="ResultListUser" type="com.cwh.model.User" >
		<id column="id" property="id" jdbcType="INTEGER"/>
		<result column="userName" property="userName" jdbcType="VARCHAR"/>
        <result column="userAge" property="userAge" jdbcType="VARCHAR"/>
        <result column="userAddress" property="userAddress" jdbcType="VARCHAR"/>
	</resultMap>
	
	<select id="selectUserByID" parameterType="String" resultMap="ResultListUser">
		select * from user where id = #{id}
	</select>
	
</mapper>


log4j.properties 
###set log levels###
log4j.rootLogger=info, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=[%d{dd/MM/yy hh\:mm\:ss\:sss z}] %t %5p %c{2}\: %m%n


web.xml 
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">

	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath*:com/cwh/config/*.xml</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<listener>
		<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
	</listener>
	<servlet>
		<servlet-name>springMVC</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath*：com/cwh/config/spring-mvc.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
		
	</servlet>
	<servlet-mapping>
		<servlet-name>springMVC</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
</web-app>


pom.xml 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.cwh.rabbitMQ</groupId>
  <artifactId>rabbitMQ</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <properties>
		<junit.version>4.10</junit.version>
		<spring.version>4.1.6.RELEASE</spring.version>
		<mysql.version>5.1.22</mysql.version>
		<mybatis.version>3.2.7</mybatis.version>
		<mybatis-spring.version>1.2.2</mybatis-spring.version>
		<aspectjweaver.version>1.8.1</aspectjweaver.version>
		<javax.servlet-api.version>3.1.0</javax.servlet-api.version>
		<log4j.version>1.2.16</log4j.version>
		<slf4j.version>1.7.25</slf4j.version>
		<commons-dbcp.version>1.4</commons-dbcp.version>
		<fastjson.version>1.2.7</fastjson.version>
		<jstl.version>1.1.0</jstl.version>
		<standard.version>1.1.0</standard.version>
		<commons-configuration.version>1.6</commons-configuration.version>
		<commons-fileupload.version>1.2.1</commons-fileupload.version>
		
	</properties>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit.version}</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>${mybatis.version}</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>${mybatis-spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>${aspectjweaver.version}</version>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>${javax.servlet-api.version}</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>${log4j.version}</version>
		</dependency>
		<dependency>
		    <groupId>org.slf4j</groupId>
		    <artifactId>slf4j-api</artifactId>
		    <version>${slf4j.version}</version>
		</dependency>
		<dependency>
		    <groupId>org.slf4j</groupId>
		    <artifactId>slf4j-log4j12</artifactId>
		    <version>${slf4j.version}</version>
		</dependency>
		<dependency>
			<groupId>commons-fileupload</groupId>
			<artifactId>commons-fileupload</artifactId>
			<version>${commons-fileupload.version}</version>
		</dependency>
		<dependency>
			<groupId>commons-dbcp</groupId>
		    <artifactId>commons-dbcp</artifactId>
			<version>${commons-dbcp.version}</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>${fastjson.version}</version>
		</dependency>

		<dependency>
			<groupId>jstl</groupId>
			<artifactId>jstl</artifactId>
			<version>${jstl.version}</version>
		</dependency>
		<dependency>
			<groupId>taglibs</groupId>
			<artifactId>standard</artifactId>
			<version>${standard.version}</version>
		</dependency>
		<dependency>
			<groupId>commons-configuration</groupId>
			<artifactId>commons-configuration</artifactId>
			<version>${commons-configuration.version}</version>
		</dependency>
	</dependencies>
  <build>
  	<plugins>
  		<plugin>
  			<artifactId>maven-war-plugin</artifactId>
  			<configuration>
  				<version>3.0</version>
  			</configuration>
  		</plugin>
  	</plugins>
  </build>
</project>

上面代码是提供rest服务的实现；先启动访问下：


基本没问题，那么我来模拟下高并发下访问该服务，代码实现如下：

package com.cwh.test;

import java.util.concurrent.CountDownLatch;

import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;



public class Demo implements Runnable{
	private final CountDownLatch countDownLatch ;
	RestTemplate restTemplate = new RestTemplate();
	public Demo(CountDownLatch countDownLatch) {
		super();
		this.countDownLatch = countDownLatch;
	}
	public void run() {
		try {
			countDownLatch.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		//do
		ResponseEntity<String> result = restTemplate.getForEntity("http://localhost:8080/rabbitMQ/user/get/1", String.class);
		System.out.println(result);
	}
	public static void main(String[] args) throws InterruptedException {
		CountDownLatch countDownLatch = new CountDownLatch(1);
		for(int i=300;i>0;i--){
			new Thread(new Demo(countDownLatch)).start();
		}
		countDownLatch.countDown();
	}
}


运行模拟并发请求之后，发现以我服务提供的连接池配置来看基本支撑不住300个并发量：



那么如果我们需要更大的并发量该怎么解决呢？

其中一个解决方案就可以使用rabbitMQ来解决，采用架构如下，在客户端与服务端之间添加一个rabbitMQ服务：


RabbitMQ的安装可以参考该篇文章


具体实现代码如下：

1.pom.xml添加如下：

<rabbitmq.version>3.3.4</rabbitmq.version>
		<spring-rabbit.version>1.3.5.RELEASE</spring-rabbit.version>
		<jackson.version>2.8.9</jackson.version>

<dependency>
	        <groupId>com.rabbitmq</groupId>
	        <artifactId>amqp-client</artifactId>
	        <version>${rabbitmq.version}</version>
	    </dependency>
	    <dependency>  
            <groupId>org.springframework.amqp</groupId>  
            <artifactId>spring-rabbit</artifactId>  
            <version>${spring-rabbit.version}</version>  
        </dependency>  
        <!-- MQ转换json所需begin -->
        <dependency>
		    <groupId>com.fasterxml.jackson.core</groupId>
		    <artifactId>jackson-databind</artifactId>
		    <version>${jackson.version}</version>
		</dependency>
		<!-- MQ转换json所需end -->

2.添加spring-rabbit.xml 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
     http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
     http://www.springframework.org/schema/rabbit  
     http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--配置connection-factory，指定连接rabbit server参数username="guest" password="guest"  port="5672"-->
    <rabbit:connection-factory id="connectionFactory" virtual-host="/" host="192.168.27.129"/>

    <!--通过指定下面的admin信息，当前producer中的exchange和queue会在rabbitmq服务器上自动生成 -->
    <rabbit:admin id="connectAdmin" connection-factory="connectionFactory" />
    
    <!-- 消息对象json转换类 -->
    <bean id="jsonMessageConverter" class="org.springframework.amqp.support.converter.Jackson2JsonMessageConverter" />  


	<!-- begin读取信息 -->
    <!--定义recvqueue -->
    <rabbit:queue name="recvqueue" durable="true" auto-delete="false"
        exclusive="false" declared-by="connectAdmin" />
        
    <!-- 消息接收者 -->
    <bean id="messageReceiver" class="com.cwh.rabbit.MessageConsumer"></bean>
    
    <!-- queue litener 观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象 -->
    <rabbit:listener-container
        connection-factory="connectionFactory">
        <rabbit:listener queues="recvqueue" ref="messageReceiver" />
    </rabbit:listener-container>
    <!-- end读取信息 -->
    
    <!-- begin发送结果 -->
    <!--定义sendqueue -->
    <rabbit:queue name="sendqueue" durable="true" auto-delete="false"
        exclusive="false" declared-by="connectAdmin" />

    <!-- 定义direct exchange，绑定recvqueue -->
    <rabbit:direct-exchange name="exchangeTest"
        durable="true" auto-delete="false" declared-by="connectAdmin">
        <rabbit:bindings>
            <rabbit:binding queue="sendqueue" key="sendqueueKey"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:direct-exchange>
    
    <!--定义rabbit template用于数据的接收和发送 -->
    <rabbit:template id="amqpTemplate" connection-factory="connectionFactory"
        exchange="exchangeTest" message-converter="jsonMessageConverter" />
        
    <!-- end发送结果 -->

</beans>

3.创建消息消费者服务与生产者服务： 


package com.cwh.rabbit;

import java.io.IOException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;
import org.springframework.beans.factory.annotation.Autowired;

import com.cwh.model.User;
import com.cwh.service.UserService;

public class MessageConsumer implements MessageListener {
	private Logger logger = LoggerFactory.getLogger(MessageConsumer.class);  
    @Autowired
    UserService userService;
    @Autowired
    MessageProducer messageProducer;
    
    public void onMessage(Message message) {
        logger.info("consumer receive message------->:{}", message); 
        User user = userService.getUser(new String(message.getBody()));
        try {
			messageProducer.sendMessage(user);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
   }

}


package com.cwh.rabbit;

import java.io.IOException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MessageProducer {
    private Logger logger = LoggerFactory.getLogger(MessageProducer.class);  

    @Autowired 
    private AmqpTemplate amqpTemplate;  

    public void sendMessage(Object message) throws IOException {  
        logger.info("to send message:{}", message);  
        amqpTemplate.convertAndSend("sendqueueKey", message);  
    }  
}

4.模拟客户端实现如下： 

package com.cwh.test;

import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;

public class Recv {

	//队列名称  
    private final static String QUEUE_NAME = "sendqueue";  
  
    public static void main(String[] argv) throws java.io.IOException,  
            java.lang.InterruptedException, TimeoutException  
    {  
        //打开连接和创建频道，与发送端一样  
        ConnectionFactory factory = new ConnectionFactory();  
        factory.setHost("192.168.27.129");  
        Connection connection = factory.newConnection();  
        Channel channel = connection.createChannel();  
        //声明队列，主要为了防止消息接收者先运行此程序，队列还不存在时创建队列。  
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);  
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");  
          
        //创建队列消费者  
        QueueingConsumer consumer = new QueueingConsumer(channel);  
        //指定消费队列  
        channel.basicConsume(QUEUE_NAME, true, consumer);  
        while (true)  
        {  
            //nextDelivery是一个阻塞方法（内部实现其实是阻塞队列的take方法）  
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();  
            String message = new String(delivery.getBody());  
            System.out.println(" [x] Received '" + message + "'");  
        }  
  
    }  
}



package com.cwh.test;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Send implements Runnable{
	private final CountDownLatch countDownLatch ;
	//队列名称  
    private final static String QUEUE_NAME = "recvqueue";  
    public Send(CountDownLatch countDownLatch) {
		super();
		this.countDownLatch = countDownLatch;
	}
    public static void main(String[] argv) throws java.io.IOException, TimeoutException  
    {  
    	CountDownLatch countDownLatch = new CountDownLatch(1);
		for(int i=1000;i>0;i--){
			new Thread(new Send(countDownLatch)).start();
		}
		countDownLatch.countDown();
     }
    

	public void run() {
		try {
			countDownLatch.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		/** 
         * 创建连接连接到MabbitMQ 
         */  
        ConnectionFactory factory = new ConnectionFactory();  
        //设置MabbitMQ所在主机ip或者主机名  
        factory.setHost("192.168.27.129");  
        try {
        	 //创建一个连接  
            Connection connection = factory.newConnection();  
            //创建一个频道  
            Channel channel = connection.createChannel();  
            //指定一个队列  
            channel.queueDeclare(QUEUE_NAME, true, false, false, null);  
            //发送的消息  
            String message = "1";  
            //往队列中发出一条消息  
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());  
            System.out.println(" [x] Sent '" + message + "'");  
            //关闭频道和连接  
            channel.close();  
            connection.close();  
		} catch (Exception e) {
			// TODO: handle exception
		}
       
	}  
}

5.开始测试

启动rest服务，然后再运行客户端Recv

接着客户端执行Send开始模拟访问
发现1000个并发量一点压力都没有；






猜你喜欢

转载自blog.csdn.net/u011320740/article/details/78913553
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
BPM为企业带来的实际利益
好程序员web前端分享css常用属性缩写
Java文件下载（excel）
css样式的动态添加及显示和隐藏等零碎用法
axios全局配置以及拦截器
使用Logstash来实时同步MySQL和log日志数据到ES
C++获取当前时间（年月日、时分秒、毫秒）
Odoo产品分析 (四) -- 工具板块(11) -- 网站即时聊天(1)
Java环境配置正确，但是java、javac、java -version均返回“不是内部或外部命令，也不是可运行的程序或批处理文件”？
01 官网下载各种CentOS教程（超详细版）
每日归档
更多
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022