SpringBoot系列之RabbitMQ使用实用教程

@

1. 消息队列概述

1.1 MQ的概述

消息队列（Message Queue，简称MQ），其本质是个队列，FIFO（First In First OUT，先入先出），MQ主要用于不同线程之间的线程通信。大多应用中，可通过消息服务中间件来提升系统异步通信、扩展解耦能力

两个重要概念：

  • 消息代理（message broker）和目的地（destination）

    （消息发送者发送消息以后，将由消息代理broker接管，然后再传递到指定目的地）

1.2 MQ目的地形式

主要两种形式的目的地：

  • 1.队列（queue）：也可以称作为点对点式，即点对点消息通信（point-to-point），主要特点是消息只有唯一的发送者和接收者，但是不能说只有一个接收者，因为有可能是主从模式

  • 2.主题（topic）：也可以称作发布订阅式，发送者（发布者）发送消息到主题，多个接收者（订阅者）监听（订阅）这个主题

2. 消息队列实现方式

2.1 常见MQ框架

MQ框架很多，比较流行的有RabbitMq、ActiveMq、ZeroMq、kafka，以及阿里开源的RocketMQ等等

2.2 MQ实现方式

MQ框架的实现方式有多种，比如jms、amqp、mqtt等等，本文主要对比一下JMS和AMQP

JMS（Java Message Service）JAVA消息服务：

  • 基于JVM消息代理的规范。ActiveMQ、HornetMQ是JMS实现



图来自：https://www.javatpoint.com/jms-tutorial

AMQP（Advanced Message Queuing Protocol）

  • 高级消息队列协议，也是一个消息代理的规范，兼容JMS， RabbitMQ是AMQP的实现



    引用尚硅谷视频教程的总结图示：

3. RabbitMQ简介

3.1 RabbitMQ简介

RabbitMQ 是一个由 Erlang 语言开发的 AMQP 的开源实现。

开发语言：Erlang – 面向并发的编程语言。

3.2 核心概念

引用尚硅谷的视频教程的归纳：

  • Message

    消息由消息头和消息体组成。消息体是不透明的，而消息头则由一系列的可选属性组成，这些属性包括routing-key（路由键）、priority（相对于其他消息的优先权）、delivery-

    该消息可能需要持久性存储）等。
  • Publisher

    消息的生产者，也是一个向交换器发布消息的客户端应用程序。
  • Exchange

    交换器，用来接收生产者发送的消息并将这些消息路由给服务器中的队列。

    Exchange有4种类型：direct(默认)，fanout, topic, 和headers，不同类型的Exchange转发消息的策略有所区别
  • Queue

    消息队列，用来保存消息直到发送给消费者。它是消息的容器，也是消息的终点。一个消息可投入一个或多个队列。消息一直在队列里面，等待消费者连接到这个队列将其取走。
  • Binding

    绑定，用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则，所以可以将交换器理解成一个由绑定构成的路由表。Exchange 和Queue的绑定可以是多对多的关系。
  • Connection

    网络连接，比如一个TCP连接。
  • Channel

    信道，多路复用连接中的一条独立的双向数据流通道。信道是建立在真实的TCP连接内的虚拟连接，AMQP 命令都是通过信道发出去的，不管是发布消息、订阅队列还是接收消息，这些动作都是通过信道完成。因为对于操作系统来说建立和销毁 TCP 都是非常昂贵的开销，所以引入了信道的概念，以复用一条 TCP 连接
  • Consumer

    消息的消费者，表示一个从消息队列中取得消息的客户端应用程序。
  • Virtual Host

    虚拟主机，表示一批交换器、消息队列和相关对象。虚拟主机是共享相同的身份认证和加

    密环境的独立服务器域。每个 vhost 本质上就是一个 mini 版的 RabbitMQ 服务器，拥有

    自己的队列、交换器、绑定和权限机制。vhost 是 AMQP 概念的基础，必须在连接时指定，

    RabbitMQ 默认的 vhost 是 / 。
  • Broker

    表示消息队列服务器实体

学习尚硅谷课件的这些理论知识后，就可以很容易地理解RabbitMQ的体系结构如图：

3.3 RabbitMQ运行机制

RabbitMQ是基于AMQP协议，AMQP 中增加了Exchange 和 Binding这两种角色，生产者发布消息后，发给代理Broker，主要还是由Exchange交换器处理，决定将消息发往那个消费者队列

3.4 Exchange类型

RabbitMQ目前共四种交换器类型：direct、fanout、topic、headers。headers 交换器和 direct 交换器完全一致，但性能差很多，用的比较少，所以只介绍三种类型

Direct Exchange：



图片来源：https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_MRG/2/html-single/Messaging_Programming_Reference/index.html

这种模式根据路由键（routing key）去匹配Bindings中的 binding key，如果完全一致，就发送消息到对应Queue

Fanout Exchange：

这种模式是常见的发布订阅模式，发消息方式类似于子网广播，队列只要绑定到对应的Exchange，生产者发送消息过来，有绑定的队列都能接收消息

Topic Exchange：



这种模式和Direct exchange有点像，不过Direct exchange是完全匹配，这种匹配方式是，先将路由键、bindings键根据点号隔开，# 表示匹配 0 个或多个单词， “*”表示匹配一个单词

4. RabbitMQ安装部署

本文介绍基于Docker系统的RabbitMQ安装部署

4.1 Docker版本部署RabbitMQ

查询rabbitMQ镜像：management版本，不指定默认为最新版本latest

  1.  docker search rabbitmq:management



拉取RabbitMQ镜像：

  1. docker pull rabbitmq:management

查看docker镜像列表：

  1. docker images

启动RabbitMQ：做下端口隐射

  1. docker run -d -p 15672:15672  -p  5672:5672  -e RABBITMQ_DEFAULT_USER=guest -e RABBITMQ_DEFAULT_PASS=guest --name rabbitmq --hostname=rabbitmqhostone  rabbitmq:management
  • -d 后台运行
  • -p 隐射端口
  • --name 指定rabbitMQ名称
  • RABBITMQ_DEFAULT_USER 指定用户账号
  • RABBITMQ_DEFAULT_PASS 指定账号密码

执行如上命令后访问：http://ip:15672/

输入默认账号密码：guest/guest



4.2 Admin新增用户

用户管理和权限管理都在Admin页签里

  • 1、超级管理员(administrator)

    可登陆管理控制台，可查看所有的信息，并且可以对用户，策略(policy)进行操作。
  • 2、监控者(monitoring)

    可登陆管理控制台，同时可以查看rabbitmq节点的相关信息(进程数，内存使用情况，磁盘使用情况等)
  • 3、策略制定者(policymaker)

    可登陆管理控制台, 同时可以对policy进行管理。但无法查看节点的相关信息
  • 4、普通管理者(management)

    仅可登陆管理控制台，无法看到节点信息，也无法对策略进行管理。
  • 5、其他

    无法登陆管理控制台，通常就是普通的生产者和消费者。

4.3 设置用户权限

默认是Vitual host如图所示



设置topic permissions

4.4 创建Virtual Hosts



新增后，记得对应用户也要设置权限，SpringBoot的yaml配置文件也得修改

4.5 其它管理配置

5. SpringBoot集成RabbitMQ

5.1 引入spring-boot-starter-amqp

  1. <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-amqp</artifactId>
  4.         </dependency>

5.2 RabbitMQ YAML配置

注意spring-boot-starter-amqp有自动配置类，有些配置可以不需要配，详情跟一下源码

  1. spring:
  2.   rabbitmq:
  3.     host: 192.168.7.135
  4.     port: 5672
  5.     username: guest
  6.     password: guest
  7.     virtual-host: /
  8.     #  支持发布确认
  9.     publisher-confirms: true
  10.     #  支持发布返回
  11.     publisher-returns: true
  12.     listener:
  13.       simple:
  14.         #  采用手动应答
  15.         acknowledge-mode: manual
  16.         #  当前监听容器数
  17.         concurrency: 1
  18.         #  最大数
  19.         max-concurrency: 1
  20.         #  是否支持重试
  21.         retry:
  22.           enabled: true

5.3 RabbitMQ Boot支持

开启支持RabbitMQ @EnableRabbit，同时配置自定义的AmqpTemplate Bean


  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. import org.springframework.amqp.core.*;
  5. import org.springframework.amqp.rabbit.annotation.EnableRabbit;
  6. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  7. import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.beans.factory.annotation.Qualifier;
  10. import org.springframework.context.annotation.Bean;
  11. import org.springframework.context.annotation.Configuration;
  12. import org.springframework.context.annotation.Primary;
  14. /**
  15.  * <pre>
  16.  *      RabbitMQ配置类
  17.  * </pre>
  18.  *
  19.  * <pre>
  20.  * @author mazq
  21.  * 修改记录
  22.  *    修改后版本:     修改人：  修改日期: 2020/04/07 11:48  修改内容:
  23.  * </pre>
  24.  */
  25. @Configuration
  26. @EnableRabbit
  27. public class RabbitMQConfig {
  29.     @Autowired
  30.     private RabbitTemplate rabbitTemplate;
  32.     @Bean
  33.     //@Primary
  34.     public AmqpTemplate amqpTemplate(){
  35.         Logger LOG = LoggerFactory.getLogger(AmqpTemplate.class);
  36.         //使用jackson 消息转换器(发送对象时候才开启)
  37.         //rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
  38.         rabbitTemplate.setEncoding("UTF-8");
  39.         rabbitTemplate.setMandatory(true);
  40.         // 开启returncallback    yml 需要配置publisher-returns: true
  41.         rabbitTemplate.setReturnCallback(((message,  replyCode, replyText, exchange, routingKey) -> {
  42.             String correlationId = message.getMessageProperties().getCorrelationId();
  43.             LOG.info("消息：{} 发送失败, 应答码：{} 原因：{} 交换机: {}  路由键: {}", correlationId, replyCode, replyText, exchange, routingKey);
  44.         }));
  45.         //开启消息确认  yml 需要配置   publisher-returns: true
  46.         rabbitTemplate.setConfirmCallback(((correlationData, ack, cause) ->{
  47.             if (ack) {
  48.                LOG.info("消息发送到交换机成功,correlationId:{}",correlationData.getId());
  49.             } else {
  50.                 LOG.info("消息发送到交换机失败,原因:{}",cause);
  51.             }
  52.         } ));
  53.         return rabbitTemplate;
  54.     }
  55. }

5.4 Direct Exchange例子

  1.  /**
  2.      * 声明直连交换机 支持持久化.
  3.      * @return the exchange
  4.      */
  5.     @Bean("directExchange")
  6.     public Exchange directExchange() {
  7.         return ExchangeBuilder.directExchange("amq.direct").durable(true).build();
  8.     }
  10.     @Bean("directQueue")
  11.     public Queue directQueue(){
  12.         return new Queue("directQueue", true, true, true);
  13.         //return QueueBuilder.durable("directQueue").build();
  14.     }
  16.     @Bean
  17.     public Binding directBinding(@Qualifier("directQueue")Queue queue,@Qualifier("directExchange")Exchange directExchange){
  18.         return BindingBuilder.bind(queue).to(directExchange).with("direct_routingKey").noargs();
  19.     }

在RabbitMQ管理平台，新增对应队列，并新增绑定如图所示：



消息生产者：

  1. package com.example.springboot.rabbitmq.component.direct;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.amqp.rabbit.connection.CorrelationData;
  6. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.stereotype.Component;
  10. import java.text.SimpleDateFormat;
  11. import java.util.Date;
  12. import java.util.UUID;
  14. /**
  15.  * <pre>
  16.  *   消息生产者
  17.  * </pre>
  18.  *
  19.  * <pre>
  20.  * @author mazq
  21.  * 修改记录
  22.  *    修改后版本:     修改人：  修改日期: 2020/04/07 13:42  修改内容:
  23.  * </pre>
  24.  */
  25. @Component
  26. public class DirectSender {
  28.     Logger LOG = LoggerFactory.getLogger(DirectSender.class);
  30.     @Autowired
  31.     private RabbitTemplate rabbitTemplate;
  32.     public void send(int i) {
  33.         String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
  34.         String content = i+":hello!"+date;
  35.         CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
  36.         LOG.info("class:{},message:{}","DirectSender",content);
  37.         this.rabbitTemplate.convertAndSend("amq.direct","direct_routingKey",content,correlationData);
  38.     }
  39. }

消息接收者：

  1. package com.example.springboot.rabbitmq.component.direct;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.amqp.rabbit.annotation.RabbitHandler;
  6. import org.springframework.amqp.rabbit.annotation.RabbitListener;
  7. import org.springframework.stereotype.Component;
  9. /**
  10.  * <pre>
  11.  *   消息消费者
  12.  * </pre>
  13.  *
  14.  * <pre>
  15.  * @author mazq
  16.  * 修改记录
  17.  *    修改后版本:     修改人：  修改日期: 2020/04/07 13:47  修改内容:
  18.  * </pre>
  19.  */
  20. @Component
  21. @RabbitListener(queues = {"directQueue"})
  22. public class DirectReceiver {
  23.     Logger LOG = LoggerFactory.getLogger(DirectReceiver.class);
  25.     @RabbitHandler
  26.     public void receiverMsg(String msg){
  27.         LOG.info("class:{},message:{}","DirectReceiver",msg);
  28.     }
  29. }

Junit测试：

  1. @Test
  2.     void directSend(){
  3.         directSender.send(1);
  4.     }



查询一下message：

5.5 Fanout Exchange例子

配置开启

  1. @Bean("fanoutQueueA")
  2.     public Queue fanoutQueueA(){
  3.         return new Queue("fanoutQueueA", true, true, true);
  4.     }
  6.     @Bean("fanoutQueueB")
  7.     public Queue fanoutQueueB(){
  8.         return new Queue("fanoutQueueB", true, true, true);
  9.     }
  11.     @Bean("fanoutQueueC")
  12.     public Queue fanoutQueueC(){
  13.         return new Queue("fanoutQueueC", true, true, true);
  14.     }
  16.     /**
  17.      * 声明一个Fanout类型的交换器
  18.      * @Author mazq
  19.      * @Date 2020/04/08 11:25
  20.      * @Param []
  21.      * @return org.springframework.amqp.core.FanoutExchange
  22.      */
  23.     @Bean("fanoutExchange")
  24.     public FanoutExchange fanoutExchange(){
  25.         return new FanoutExchange("fanoutExchange");
  26.     }
  28.     @Bean
  29.     public Binding fanoutABinding(@Qualifier("fanoutQueueA")Queue queue,FanoutExchange fanoutExchange){
  30.         return BindingBuilder.bind(queue).to(fanoutExchange);
  31.     }
  33.     @Bean
  34.     public Binding fanoutBBinding(@Qualifier("fanoutQueueB")Queue queue,FanoutExchange fanoutExchange){
  35.         return BindingBuilder.bind(queue).to(fanoutExchange);
  36.     }
  38.     @Bean
  39.     public Binding fanoutCBinding(@Qualifier("fanoutQueueC")Queue queue,FanoutExchange fanoutExchange){
  40.         return BindingBuilder.bind(queue).to(fanoutExchange);
  41.     }

新增3个接收者A、B、C：

  1. import org.slf4j.Logger;
  2. import org.slf4j.LoggerFactory;
  3. import org.springframework.amqp.rabbit.annotation.RabbitHandler;
  4. import org.springframework.amqp.rabbit.annotation.RabbitListener;
  5. import org.springframework.stereotype.Component;
  7. @Component
  8. @RabbitListener(queues = {"fanoutQueueA"})
  9. public class FanoutReceiverA {
  11.     Logger LOG = LoggerFactory.getLogger(FanoutReceiverA.class);
  13.     @RabbitHandler
  14.     public void process(String hello) {
  15.         LOG.info("AReceiver  : " + hello + "/n");
  16.     }
  17. }

FanoutReceiverB、FanoutReceiverC代码类似，不贴代码

Fanout模式是发布订阅模式，不需要绑定路由键，this.rabbitTemplate.convertAndSend("amq.fanout","",content,correlationData);，只要和fanout exchange绑定就可以，只要队列绑定了fanout exchange，发送者发消息后，exchange都会将消息发给对应消费者队列

  1. import com.example.springboot.rabbitmq.component.direct.DirectSender;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. import org.springframework.amqp.rabbit.connection.CorrelationData;
  5. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Component;
  9. import java.text.SimpleDateFormat;
  10. import java.util.Date;
  11. import java.util.UUID;
  13. @Component
  14. public class FanoutSender {
  16.     Logger LOG = LoggerFactory.getLogger(DirectSender.class);
  18.     @Autowired
  19.     private RabbitTemplate rabbitTemplate;
  21.     public void send() {
  22.         String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
  23.         String content = "hello!"+date;
  24.         CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
  25.         LOG.info("class:{},message:{}","FanoutSender",content);
  26.         this.rabbitTemplate.convertAndSend("amq.fanout","",content,correlationData);
  27.     }
  29. }

同理在RabbitMQ管理新增对应队列和绑定





用Junit进行测试消息发送，ReceiverA、B、C都可以接收到消息

5.6 Topic Exchange例子

新增两个队列，规则为topic.msg和topic.#，#表示匹配0或多个字符

  1. @Bean("topicQueueA")
  2.     public Queue topicQueueA(){
  3.         return new Queue("topicQueueA",true, true, true);
  4.     }
  6.     @Bean("topicQueueB")
  7.     public Queue topicQueueB(){
  8.         return new Queue("topicQueueB",true, true, true);
  9.     }
  11.     @Bean("topicExchange")
  12.     public TopicExchange topicExchange(){
  13.         return new TopicExchange("topicExchange");
  14.     }
  16.     @Bean
  17.     public Binding topicABinding(@Qualifier("topicQueueA")Queue queue,TopicExchange topicExchange){
  18.         return BindingBuilder.bind(queue).to(topicExchange).with("topic.msg");
  19.     }
  21.     @Bean
  22.     public Binding topicBBinding(@Qualifier("topicQueueB")Queue queue,TopicExchange topicExchange){
  23.         return BindingBuilder.bind(queue).to(topicExchange).with("topic.#");
  24.     }

接收者A代码：

  1. import com.example.springboot.rabbitmq.component.direct.DirectReceiver;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. import org.springframework.amqp.rabbit.annotation.RabbitHandler;
  5. import org.springframework.amqp.rabbit.annotation.RabbitListener;
  6. import org.springframework.stereotype.Component;
  8. @Component
  9. @RabbitListener(queues = {"topicQueueA"})
  10. public class TopicReceiverA {
  12.     Logger LOG = LoggerFactory.getLogger(DirectReceiver.class);
  14.     @RabbitHandler
  15.     public void receiverMsg(String msg){
  16.         LOG.info("class:{},message:{}","TopicReceiverA",msg);
  17.     }
  18. }

TopicB代码类似，不贴代码，给出两个发送者代码：

  1. import com.example.springboot.rabbitmq.component.direct.DirectSender;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. import org.springframework.amqp.rabbit.connection.CorrelationData;
  5. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Component;
  9. import java.text.SimpleDateFormat;
  10. import java.util.Date;
  11. import java.util.UUID;
  13. @Component
  14. public class TopicSender {
  16.     Logger LOG = LoggerFactory.getLogger(DirectSender.class);
  18.     @Autowired
  19.     private RabbitTemplate rabbitTemplate;
  21.     public void send1() {
  22.         String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
  23.         String content = "hello!"+date;
  24.         CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
  25.         LOG.info("class:{},message:{}","TopicSender",content);
  26.         this.rabbitTemplate.convertAndSend("amq.topic","topic.msg",content,correlationData);
  27.     }
  29.     public void send2() {
  30.         String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
  31.         String content = "hello!"+date;
  32.         CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
  33.         LOG.info("class:{},message:{}","TopicSender",content);
  34.         this.rabbitTemplate.convertAndSend("amq.topic","topic.msg1",content,correlationData);
  35.     }
  36. }

同理进行队列绑定

TopicA：



topicB：



路由键是topic.msg、topic.msg1，所以send1方法执行后，两个绑定键分别为topic.msg、topic.#的都可以收到消息，send2方法执行后，只有绑定键为topic.#的队列能收到消息

5.7 MQ对象支持例子

上面例子都是基于字符串的发送，接着可以进行对象数据的发送

  1. import lombok.*;
  3. import java.io.Serializable;
  5. /**
  6.  * User信息类
  7.  * @Author mazq
  8.  * @Date 2020/04/08 15:12
  9.  */
  10. @Data
  11. @AllArgsConstructor
  12. @ToString
  13. public class User implements Serializable{
  15.     private String name;
  17.     private String pwd;
  19. //    @Override
  20. //    public String toString() {
  21. //        return "User{" +
  22. //                "name='" + name + '\'' +
  23. //                ", pwd='" + pwd + '\'' +
  24. //                '}';
  25. //    }
  26. }
  1. //发送者
  2.     public void send(User user) {
  3.         LOG.info("Sender object: " + user.toString());
  4.         CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
  5.         this.rabbitTemplate.convertAndSend("amq.direct","direct_routingKey",user,correlationData);
  6.     }

发送者：

  1. import com.example.springboot.rabbitmq.model.User;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. import org.springframework.amqp.rabbit.annotation.RabbitHandler;
  5. import org.springframework.amqp.rabbit.annotation.RabbitListener;
  6. import org.springframework.stereotype.Component;
  8. /**
  9.  * <pre>
  10.  *   消息消费者
  11.  * </pre>
  12.  *
  13.  * <pre>
  14.  * @author mazq
  15.  * 修改记录
  16.  *    修改后版本:     修改人：  修改日期: 2020/04/07 13:47  修改内容:
  17.  * </pre>
  18.  */
  19. @Component
  20. @RabbitListener(queues = {"directQueue"})
  21. public class DirectReceiver {
  22.     Logger LOG = LoggerFactory.getLogger(DirectReceiver.class);
  24.     //接收者
  25.     @RabbitHandler
  26.     public void process(User user) {
  27.         LOG.info("Receiver object : " + user);
  28.     }
  29. }

修改配置类，需要换消息转换器

5.8 参考资料和代码例子

参考博客：

CSDN RabbitMQ教程

Springboot：RabbitMQ 详解

代码下载：github下载链接

SpringBoot系列之RabbitMQ使用实用教程的更多相关文章

  1. SpringBoot系列之自定义starter实践教程

    SpringBoot系列之自定义starter实践教程 Springboot是有提供了很多starter的,starter翻译过来可以理解为场景启动器,所谓场景启动器配置了自动配置等等对应业务模块的一 ...

  2. SpringBoot系列之日志框架使用教程

    目录 1.SpringBoot日志级别 1).日志级别简介 2).默认日志级别 3).配置日志级别 4).日志分组设置 2.SpringBoot日志格式设置 1).默认格式原理简介 2).默认日志格式 ...

  3. SpringBoot系列之集成Dubbo示例教程

    一.分布式基本理论 1.1.分布式基本定义 <分布式系统原理与范型>定义: "分布式系统是若干独立计算机的集合,这些计算机对于用户来说就像单个相关系统" 分布式系统(d ...

  4. SpringBoot系列之快速创建项目教程

    本博客简介一下SpringBoot快速创建工程的方法,主要介绍一下Spring Initializer,Spring Initializer是IntelliJ IDEA才集成的一种快速创建Spring ...

  5. SpringBoot系列之学习教程汇总

    对应SpringBoot系列博客专栏,例子代码,本博客不定时更新 一.配置篇 SpringBoot系列之@PropertySource读取yaml文件     >> source down ...

  6. SpringBoot系列之从入门到精通系列教程

    对应SpringBoot系列博客专栏,例子代码,本博客不定时更新 Spring框架:作为JavaEE框架领域的一款重要的开源框架,在企业应用开发中有着很重要的作用,同时Spring框架及其子框架很多, ...

  7. SpringBoot系列之集成logback实现日志打印(篇二)

    SpringBoot系列之集成logback实现日志打印(篇二) 基于上篇博客SpringBoot系列之集成logback实现日志打印(篇一)之后,再写一篇博客进行补充 logback是一款开源的日志 ...

  8. SpringBoot系列之日志框架介绍及其原理简介

    SpringBoot系列之日志框架介绍及其原理简介 1.常用日志框架简介 市面上常用日志框架:JUL.JCL.jboss-logging.logback.log4j.log4j2.slf4j.etc. ...

  9. Unix sed实用教程系列目录[已完成]

    本系列文章已经译完了,译自awk-sed@theunixschool,收获颇丰,作者没有讲明白的我做了补充,并且尝试讲的更清楚,整理成系列索引,方便学习,开篇非译文,是我为了方便后面的理解写的一篇,感 ...

随机推荐

  1. linux 安装 memcached

    1.Linux系统安装memcached,首先要先安装libevent库. yum install libevent libevent-deve 2.安装memcached yum install - ...

  2. 高可用Keepalived+LVS搭建流程

    本流程搭建1个master,1个backup节点的Keepalived,使用lvs轮询2个节点的服务. 一.使用版本 CentOS 7.7 Keepalived 1.3.5 ipvsadm 1.27( ...

  3. web安全测试（上）

    前情提要: 公司的安全测试一直是安全部经理全权负责,测试部只做功能和自动化. 但是2019是公司业绩腾飞的一年,业务量越来越大了,安全部经理实在做不过来. 于是他给整个测试部培训<安全测试> ...

  4. C# .Net Core 3.1 中关于Process.Start 启动Url链接的问题

    WPF 项目迁移到.Net Core中时居然出了一堆问题...(很无语) 今天在使用的时候居然发现Process.Start居然打不开Url链接了? 报 找不到指定文件 的异常?! 一.bug重现 首 ...

  5. Python中使用os模块执行远程命令

    1. 使用os模块远程执行命令 服务端代码 1 import socket 2 import os 3 4 sh_server = socket.socket() #创建一个socket对象 5 sh ...

  6. C语言程序设计（十一） 指针和数组

    第十一章 指针和数组 一旦给出数组的定义,编译系统就会为其在内存中分配固定的存储单元,相应的,数组的首地址也就确定了 C语言中的数组名有特殊的含义,它代表存放数组元素的连续存储空间的首地址 //L11 ...

  7. Vue2.0 【第一季】第2节 v-if v-else v-show 指令

    目录 Vue2.0 [第一季]第2节 v-if v-else v-show 指令 第二节 v-if v-else v-show 指令 2.1 v-if指令.v-else指令: 2.2 v-show的使 ...

  8. vue依赖注入

    大家可能知道常规组件传值,父传子使用子组件定义好的props值,子传父可以使用子组件里面定义的时间this.$emit(); 然后很多层的情况,一层一层慢慢传太慢,vue提供了依赖注入的钩子:prov ...

  9. js 模拟鼠标绘制方块

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...

  10. js 实现端口列表话

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...