SpringBoot 2.3.12.RELEASE整合RabittMQ 3.8.12

已于 2022-07-21 10:06:26 修改
阅读量596 收藏 1
点赞数
文章标签： spring boot java java-rabbitmq
于 2022-07-21 09:48:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46122292/article/details/125905911
版权
  • 导入依赖
<!--rabbitmq-->
 <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
  • 编写配置文件

application.yml:

spring:
  rabbitmq:
    host: 192.168.31.89
    port: 5672
    username: admin
    password: admin
     # 消费者监听相关配置
    listener:
      simple:
        retry:
          # 开启消费者(程序出现异常)重试机制，默认开启并一直重试
          enabled: true
          # 最大重试次数
          max-attempts: 5
          # 重试间隔时间(毫秒)
          initial-interval: 3000

Direct模式–整合SpringBoot

  • 创建生产者项目

pom

  <!--rabbitmq-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.73</version>
        </dependency>
  • 配置文件

application.yml

server:
  port: 8081
spring:
  rabbitmq:
    host: 192.168.31.89
    port: 5672
    username: admin
    password: admin
  • 编写Direct模式配置类
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * @Description: Direct模式配置
 */
@Configuration
public class DirectRabbitConfig {


    /**
     * 创建一个队列，名称为 queueOne.direct.queue
     * @return
     */
    @Bean
    public Queue queueOne() {
        /**
         * 参数解析：
         * new Queue (String name, boolean durable, boolean exclusive, boolean autoDelete)
         * name：队列名称
         * durable：是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
         * exclusive：默认是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
         * autoDelete：是否自动删除队列，当没有生产者或者消费者使用此队列，该队列会自动删除。
         */
        return new Queue("queueOne.direct.queue", true);
    }

    /**
     * 创建一个队列，名称为 queueTwo.direct.queue
     * @return
     */
    @Bean
    public Queue queueTwo() {
        return new Queue("queueTwo.direct.queue", true);
    }


    /**
     * 创建一个交换机，名称为 direct_test_exchange
     * @return
     */
    @Bean
    public DirectExchange directTestExchange() {
        return new DirectExchange("direct_test_exchange", true, false);
    }


    /**
     * 绑定交换机和队列1
     * 设置routingKey为queueOne
     * @return
     */
    @Bean
    public Binding bindingDirectAndQueueOne() {
        return BindingBuilder.bind(queueOne()).to(directTestExchange()).with("queueOne");
    }
    /**
     * 绑定交换机和队列2
     * 设置routingKey为queueTwo
     * @return
     */
    @Bean
    public Binding bindingDirectAndQueueTwo() {
        return BindingBuilder.bind(queueTwo()).to(directTestExchange()).with("queueTwo");
    }

}
  • 编写消息推送代码
import com.alibaba.fastjson.JSONObject;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * @Description: Direct模式-生产者
 */
@RestController
@RequestMapping("/direct")
public class DirectProducerController {

    /**
     * RabbitTemplate
     * 供了接收,发送等方法
     */
    @Autowired
    private  RabbitTemplate rabbitTemplate;

    /**
     * 交换机名称
     */
    private static  final String EXCHANGE_NAME = "direct_test_exchange";

    /**
     * 推送消息
     * @param routeKey 需要推送队列的路由key
     * @return
     */
    @GetMapping("/send/{routeKey}/{msg}")
    public String sendDirectMessage(@PathVariable("routeKey") String routeKey, @PathVariable("msg")String msg) {
//        String routeKeyOne="queueOne";
//        String routeKeyTwo="queueTwo";

        String Id= String.valueOf(UUID.randomUUID());
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String,Object> map=new HashMap<>();
        map.put("Id",Id);
        map.put("data",msg);
        map.put("createTime",createTime);

        rabbitTemplate.convertAndSend(EXCHANGE_NAME, routeKey, JSONObject.toJSONString(map));
         return msg+"-推送成功";
    }

}
  • 实现效果
    根据不同的routeKey将消息推送给不同的消费者
  • 访问接口
http://localhost:8081/direct/send/queueOne/aa

http://localhost:8082/direct/send/queueTwo/bb

  • 查看控制台
    在这里插入图片描述

  • 创建消费者项目
    pom与生产者一样

  <!--rabbitmq-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.73</version>
        </dependency>
  • 配置文件

application.yml

server:
  port: 8082
spring:
  rabbitmq:
    host: 192.168.31.89
    port: 5672
    username: admin
    password: admin
  • 编写队列一的消费者
import com.alibaba.fastjson.JSONObject;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Service;

import java.util.Map;

/**
 * @Description: Direct模式-消费者
 */
@RabbitListener(
        bindings = @QueueBinding(
                //队列名称，是否自动删除
                value = @Queue(value = "queueOne.direct.queue", autoDelete = "false"),
                //交换机名称，指定rabbitmq模式
                exchange = @Exchange(value = "direct_test_exchange",type = ExchangeTypes.DIRECT)
                )
)
@Service
public class DirectConsumerOneService {

    /**
     * 注解 @RabbitHandler 代表此方法是一个消息接收的方法。不要有返回值
     * @param testMessage
     */
    @RabbitHandler
    public void process(String testMessage) {
        System.out.println("DirectConsumerOneService : " + testMessage.toString());
        Map map = JSONObject.parseObject(testMessage, Map.class);
        System.out.println("map1-->"+map);
    }

}
  • 编写队列二的消费者
import com.alibaba.fastjson.JSONObject;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Service;

import java.util.Map;

/**
 * @Description: Direct模式-消费者
 */
@RabbitListener(
        bindings = @QueueBinding(
                //队列名称，是否自动删除
                value = @Queue(value = "queueTwo.direct.queue", autoDelete = "false"),
                //交换机名称，指定rabbitmq模式
                exchange = @Exchange(value = "direct_test_exchange",type = ExchangeTypes.DIRECT)
                )
)
@Service
public class DirectConsumerTwoService {

    /**
     * 注解 @RabbitHandler 代表此方法是一个消息接收的方法。不要有返回值
     * @param testMessage
     */
    @RabbitHandler
    public void process(String testMessage) {
        System.out.println("DirectConsumerTwoService : " + testMessage.toString());
        Map map = JSONObject.parseObject(testMessage, Map.class);
        System.out.println("map2-->"+map);
    }
}
  • 运行消费者，消费刚才推送的aa ,bb

在这里插入图片描述

  • 再次访问接口，推送消息，观察消费者接收情况
http://localhost:8081/direct/send/queueOne/cc

http://localhost:8081/direct/send/queueTwo/dd

在这里插入图片描述

注：以下模式的演示，都将在以上创建的项目中进行

Fanout模式–整合SpringBoot

  • 在生产者项目中编写Fanout模式配置类
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * @Description: Fanout模式配置
 */
@Configuration
public class FanoutRabbitConfig {

    /**
     * 创建一个队列，名称为 queueOne.fanout.queue
     * @return
     */
    @Bean
    public Queue queueFanoutOne() {
        return new Queue("queueOne.fanout.queue", true);
    }

    /**
     * 创建一个队列，名称为 queueTwo.fanout.queue
     * @return
     */
    @Bean
    public Queue queueFanoutTwo() {
        return new Queue("queueTwo.fanout.queue", true);
    }



    /**
     * 创建一个交换机，名称为 fanout_test_exchange
     * @return
     */
    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanout_test_exchange");
    }


    /**
     * 绑定交换机和队列1
     * 此处是fanout模式，所以不设置routingKey
     * @return
     */
    @Bean
    Binding bindingExchangeA() {
        return BindingBuilder.bind(queueFanoutOne()).to(fanoutExchange());
    }


    /**
     * 绑定交换机和队列2
     * 此处是fanout模式，所以不设置routingKey
     * @return
     */
    @Bean
    Binding bindingExchangeB() {
        return BindingBuilder.bind(queueFanoutTwo()).to(fanoutExchange());

    }

}
  • 编写生产者
import com.alibaba.fastjson.JSONObject;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * @Description: fanout模式-生产者
 */
@RestController
@RequestMapping("/fanout")
public class FanoutProducerController {

    /**
     * RabbitTemplate
     * 供了接收,发送等方法
     */
    @Autowired
    private  RabbitTemplate rabbitTemplate;

    /**
     * 交换机名称
     */
    private static  final String EXCHANGE_NAME = "fanout_test_exchange";

    /**
     * 推送消息
     * @return
     */
    @GetMapping("/send/{msg}")
    public String sendDirectMessage( @PathVariable("msg")String msg) {
        String Id = String.valueOf(UUID.randomUUID());
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String,Object> map=new HashMap<>();
        map.put("Id",Id);
        map.put("data",msg);
        map.put("createTime",createTime);

        rabbitTemplate.convertAndSend(EXCHANGE_NAME, "", JSONObject.toJSONString(map));
        return msg+"-fanout模式推送成功";
    }

}
  • 实现效果
    以广播的形式推送消息，2个消费者都可以消费同一条消息
  • 访问接口
http://localhost:8081/fanout/send/11

http://localhost:8081/fanout/send/22

  • 查看控制台
    在这里插入图片描述

  • 在消费者项目中编写消费者一

import com.alibaba.fastjson.JSONObject;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Service;
import java.util.Map;

/**
 * @Description: fanout模式-消费者
 */
@RabbitListener(
        bindings = @QueueBinding(
                //队列名称，是否自动删除
                value = @Queue(value = "queueOne.fanout.queue", autoDelete = "false"),
                //交换机名称，指定rabbitmq模式
                exchange = @Exchange(value = "fanout_test_exchange",type = ExchangeTypes.FANOUT)
                )
)
@Service
public class FanoutConsumerOneService {

    /**
     * 注解 @RabbitHandler 代表此方法是一个消息接收的方法。不要有返回值
     * @param testMessage
     */
    @RabbitHandler
    public void process(String testMessage) {
        System.out.println("FanoutConsumerOneService : " + testMessage.toString());
        Map map = JSONObject.parseObject(testMessage, Map.class);
        System.out.println("map1-->"+map);
    }

}
  • 在消费者项目中编写消费者二
import com.alibaba.fastjson.JSONObject;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Service;
import java.util.Map;

/**
 * @Description: fanout模式-消费者
 */
@RabbitListener(
        bindings = @QueueBinding(
                //队列名称，是否自动删除
                value = @Queue(value = "queueTwo.fanout.queue", autoDelete = "false"),
                //交换机名称，指定rabbitmq模式
                exchange = @Exchange(value = "fanout_test_exchange",type = ExchangeTypes.FANOUT)
                )
)
@Service
public class FanoutConsumerTwoService {

    /**
     * 注解 @RabbitHandler 代表此方法是一个消息接收的方法。不要有返回值
     * @param testMessage
     */
    @RabbitHandler
    public void process(String testMessage) {
        System.out.println("FanoutConsumerTwoService : " + testMessage.toString());
        Map map = JSONObject.parseObject(testMessage, Map.class);
        System.out.println("map2-->"+map);
    }

}
  • 运行消费者，消费刚才推送的11 ,22

在这里插入图片描述

  • 再次访问接口，推送消息，观察消费者接收情况
http://localhost:8081/fanout/send/33

http://localhost:8081/fanout/send/44

在这里插入图片描述

Topic 模式–整合SpringBoot

  • 在生产者项目中编写topic 模式配置类
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Description: Topic模式配置
 */
@Configuration
public class TopicRabbitConfig {


    /**
     * 创建一个队列，名称为 queueOne.topic.queue
     * @return
     */
    @Bean
    public Queue queueTopicOne() {
        return new Queue("queueOne.topic.queue", true);
    }

    /**
     * 创建一个队列，名称为 queueTwo.topic.queue
     * @return
     */
    @Bean
    public Queue queueTopicTwo() {
        return new Queue("queueTwo.topic.queue", true);
    }



    /**
     * 创建一个交换机，名称为topic_test_exchange
     * @return
     */
    @Bean
    TopicExchange exchange() {
        return new TopicExchange("topic_test_exchange");
    }


    /**
     * 绑定交换机和队列1
     * 匹配规则为：以queueOne为开头的且单词长度为3
     * @return
     */
    @Bean
    Binding bindingExchangeMessage() {
        return BindingBuilder.bind(queueTopicOne()).to(exchange()).with("queueOne.*.*");
    }

    /**
     * 绑定交换机和队列2
     * 匹配规则为：包含单词topic
     * @return
     */
    @Bean
    Binding bindingExchangeMessage2() {
        return BindingBuilder.bind(queueTopicTwo()).to(exchange()).with("#.topic.#");
    }

}
  • 编写生产者
import com.alibaba.fastjson.JSONObject;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * @Description: topic模式-生产者
 */
@RestController
@RequestMapping("/topic")
public class TopicProducerController {

    /**
     * RabbitTemplate
     * 供了接收,发送等方法
     */
    @Autowired
    private  RabbitTemplate rabbitTemplate;

    /**
     * 交换机名称
     */
    private static  final String EXCHANGE_NAME = "topic_test_exchange";

    /**
     * 推送消息
     * @param routeKey 需要推送队列的路由key
     * @return
     */
    @GetMapping("/send/{routeKey}/{msg}")
    public String sendDirectMessage(@PathVariable("routeKey") String routeKey, @PathVariable("msg")String msg) {
        String messageId = String.valueOf(UUID.randomUUID());
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String,Object> map=new HashMap<>();
        map.put("Id",messageId);
        map.put("data",msg);
        map.put("createTime",createTime);

        rabbitTemplate.convertAndSend(EXCHANGE_NAME, routeKey, JSONObject.toJSONString(map));
        return msg+"-topic模式推送成功";
    }

}
  • 实现效果
    按照不同的匹配规则，输入不同的匹配路径，会推送到与匹配路径相符合的队列中
  • 访问接口
http://localhost:8081/topic/send/queueOne.test.aa/11
http://localhost:8081/topic/send/queueOne.test.aa/22

http://localhost:8081/topic/send/topic/33
http://localhost:8081/topic/send/topic/44
  • 查看控制台
    在这里插入图片描述
  • 在消费者项目中编写消费者一
import com.alibaba.fastjson.JSONObject;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Service;

import java.util.Map;

/**
 * @Description: topic模式-消费者
 */
@RabbitListener(
        bindings = @QueueBinding(
                //队列名称，是否自动删除
                value = @Queue(value = "queueOne.topic.queue", autoDelete = "false"),
                //交换机名称，指定rabbitmq模式
                exchange = @Exchange(value = "topic_test_exchange",type = ExchangeTypes.TOPIC)
                )
)
@Service
public class TopicConsumerOneService {

    /**
     * 注解 @RabbitHandler 代表此方法是一个消息接收的方法。不要有返回值
     * @param testMessage
     */
    @RabbitHandler
    public void process(String testMessage) {
        System.out.println("TopicConsumerOneService : " + testMessage.toString());
        Map map = JSONObject.parseObject(testMessage, Map.class);
        System.out.println("map1-->"+map);
    }

}
  • 在消费者项目中编写消费者二
import com.alibaba.fastjson.JSONObject;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Service;

import java.util.Map;

/**
 * @Description: fanout模式-消费者
 */
@RabbitListener(
        bindings = @QueueBinding(
                //队列名称，是否自动删除
                value = @Queue(value = "queueTwo.topic.queue", autoDelete = "false"),
                //交换机名称，指定rabbitmq模式
                exchange = @Exchange(value = "topic_test_exchange",type = ExchangeTypes.TOPIC)
                )
)
@Service
public class TopicConsumerTwoService {

    /**
     * 注解 @RabbitHandler 代表此方法是一个消息接收的方法。不要有返回值
     * @param testMessage
     */
    @RabbitHandler
    public void process(String testMessage) {
        System.out.println("TopicConsumerTwoService : " + testMessage.toString());
        Map map = JSONObject.parseObject(testMessage, Map.class);
        System.out.println("map2-->"+map);
    }

}

  • 运行消费者，消费刚才推送的11 ,22，33，44
    在这里插入图片描述

  • 再次访问接口，推送消息，观察消费者接收情况

http://localhost:8081/topic/send/queueOne.test.aa/55

http://localhost:8081/topic/send/topic/66

在这里插入图片描述

亿只王菜菜
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
2.3rabbitMq整合springboot
plumblum的博客
01-29 414
rabbitMq整合springboot github地址：https://github.com/Plumblumpb/messageQueue-.git rabbitmq（可以先看这两篇文章）： https://blog.csdn.net/c_royi/article/details/86630777 https://blog.csdn.net/c_royi/article/details/86...
SpringBoot2.3.12.RELEASE优雅的全局异常处理（模板一）
HiterCoder
06-28 1775
参考：https://www.cnblogs.com/xuwujing/p/10933082.html 1、首先，需要引入maven依赖包，如下所示： 1 <?xml version="1.0" encoding="UTF-8"?> 2 <project xmlns="http://maven.apache.org/POM/4.0.0" 3 xmlns:xsi=...
rabbitmq的安装使用及spring amqp的使用
klz
10-03 1011
rabbitmq的安装使用及spring amqp的使用
微服务入门：RabbitMQ与SpringAMQP
沉迷写代码的程序猿的博客
07-19 1610
多个消费者绑定到一个队列，同一条消息只会被一个消费者处理通过设置prefetch来控制消费者预取的消息数量交换机的作用是什么？接收publisher发送的消息将消息按照规则路由到与之绑定的队列不能缓存消息，路由失败，消息丢失FanoutExchange的会将消息路由到每个绑定的队列声明队列、交换机、绑定关系的Bean是什么？QueueBindingDirect交换机与Fanout交换机的差异？Fanout交换机将消息路由给每一个与之绑定的队列@Queue@Exchange分割。...
SpringBoot整合RabbitMQ
jgdabc的博客
07-26 1288
然后启动类就不说了，一定要注意它的放置位置，涉及一个自动扫描的问题，我们尽量去把它扫描的范围放大，但是如果你再建立一个包把它放到里面可能就扫描不到相关的配置了，那么你就需要自己指定注解去扫描了。在这之前，我们还需要写一个配置类，主要配置队列啊，绑定，以及路由工作模式等等这些。这个配置类主要做了交换机和队列的创建以及绑定，具体的路由规则我们也指定了。之前我们生产者不是把消息存储到消息队列了们，我们消费者启动，就会把这些消息消费掉。我们后面的生产者主要采用了单元测试区启动，所以后面也引入流量单元测试的依赖。..
spring-boot-2.3.12.RELEASE-API文档-中文版.zip
07-13
赠送jar包：spring-boot-2.3.12.RELEASE.jar； 赠送原API文档：spring-boot-2.3.12.RELEASE-javadoc.jar； 赠送源代码：spring-boot-2.3.12.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-boot-2.3.12....
spring-boot-configuration-processor-2.3.12.RELEASE-API文档-中文版.zip
07-13
赠送jar包：spring-boot-configuration-processor-2.3.12.RELEASE.jar； 赠送原API文档：spring-boot-configuration-processor-2.3.12.RELEASE-javadoc.jar； 赠送源代码：spring-boot-configuration-processor-...
spring-boot-autoconfigure-2.3.12.RELEASE-API文档-中文版.zip
07-13
赠送jar包：spring-boot-autoconfigure-2.3.12.RELEASE.jar； 赠送原API文档：spring-boot-autoconfigure-2.3.12.RELEASE-javadoc.jar； 赠送源代码：spring-boot-autoconfigure-2.3.12.RELEASE-sources.jar； 赠送...
spring-boot-actuator-autoconfigure-2.3.12.RELEASE-文档-中英对照版.zip
07-13
赠送jar包：spring-boot-actuator-autoconfigure-2.3.12.RELEASE.jar； 赠送原API文档：spring-boot-actuator-autoconfigure-2.3.12.RELEASE-javadoc.jar； 赠送源代码：spring-boot-actuator-autoconfigure-2.3.12....
spring-boot-actuator-2.3.12.RELEASE-API文档-中英对照版.zip
07-13
赠送jar包：spring-boot-actuator-2.3.12.RELEASE.jar； 赠送原API文档：spring-boot-actuator-2.3.12.RELEASE-javadoc.jar； 赠送源代码：spring-boot-actuator-2.3.12.RELEASE-sources.jar； 赠送Maven依赖信息...
spring整合rabbitmq的整合版本
weixin_42650954的博客
04-01 2576
** * spring整合rabbitmq的整合版本 * */ @Configuration public class RabbitmqConfig { /** * 创建连接工厂 * @return */ @Bean public ConnectionFactory connectionFactory () { CachingConnectionFactory cachingConnectionFactory = new Cach.
Spring Boot整合RabbitMQ
z69183787的专栏
10-29 661
本文RabbitMQ版本为rabbitmq-server-3.7.17,erlang为erlang-22.0.7.请各位去官网查看版本匹配和下载,也可以留言,我发安装包 在Spring项目中，可以使用Spring-Rabbit去操作RabbitMQhttps://github.com/spring-projects/spring-amqp 尤其是在spring boot项目中只需要引入对应的amqp启动器依赖即可，方便的使用RabbitTemplate发送消息，使用注解接收消息。 搭建生...
SpringBoot集成RabbitMq
weixin_44787319的博客
06-07 227
记录学习
Dependency ‘org.springframework.boot:spring-boot-starter-test:not found 的解决方法
热门推荐
ambiyou的博客
05-10 4万+
关于Dependency ‘org.springframework.boot:spring-boot-starter-test:not found 的解决方法 使用IDEAs 创建第一个springboot 项目，在l配置pom,xml 中出现了一个很无语的问题 一直显示 “Dependency ‘org.springframework.boot:spring-boot-starter-test:not found *这个问题”。在各类网站查找解决方法，都没得用，直到最后快放弃的时候，在csdn上看到一篇
Spring Boot Admin
weixin_46666822的博客
04-28 9195
Spring Boot Admin可以将 Actuator 中的信息进行界面化的展示，用于监控所有 Spring Boot 应用的健康状况，提供实时警报功能。 使用步骤 1.服务器 1.Maven导入依赖 必须是web应用 所以导入spring-boot-starter-web admin版本必须和springboot一致 <dependency> <groupId>org.springframework.boot</groupId&gt
springboot版本为2.3.12.RELEASE的Nacos父工程pom设置
AKAHugo的博客
07-29 1474
springboot版本为2.3.12.RELEASE的Nacos父工程pom设置
Spring Boot 版本号说明
yangchao1125的博客
04-02 1万+
大家可以通过 https://spring.io/projects/spring-boot#learn 查看到当前 Spring Boot 的官方版本号，如下： 对上边的截图，我的理解是：由两个部分组成，一个是用来标识版本的 「版本号」，另外一个是该版本当前的 「发布状态」（即发布计划）。 我们以图中的 2.6.6 CURRENT GA 和 3.0.0-SNAPSHOT SNAPSHOT 来进一步说明哪部分是 「版本号」，哪部分是 「发布状态」，如下图： 下面分别说下 「版本号」 和 「发布状态」（发布
【SpringBoot 学习】53、Spring Boot 集成 Spring Boot Admin
Tellsea
04-23 475
如果把两个端搭建在同一个项目中也可以，但是客户端要是挂了，服务端也挂了，所以可以但没必要。为了实时监控项目问题，Spring Boot Admin 还配备了监听服务状态等信息发送邮件给指定邮箱。客户端直接注册到服务端即可，修改 application-dev.yml 配置文件。由于监控信息输入敏感信息，所以需要增加一个登录拦截器，只有登录成功才能访问。application-dev.yml 配置如下。application.yml 配置如下。客户端的主配置文件中需要增加如下配置。启动类增加注解服务端注解。
SpringBoot Admin升级boot等组件版本后无法监控微服务
weixin_39195030的博客
07-29 1488
spring-cloud-consul在v3.0.0（不包含M1等版本）及之上，meta数据获取不再兼容tags，因此使用该版本的cloud在于admin集成时，若监控服务存在context-path或者自定义的健康检查路径等，由于admin定义meata属性key均包含"."字符，因此大概率均会出现监控异常问题（推测结论，未完整验证所有版本）。到此，该问题排查基本结束，定义为spring-boot-admin与spring-cloud-consul版本兼容性问题。.....................
springboot 2.3.12.RELEASE集成swagger
最新发布
12-06
以下是在Spring Boot 2.3.12.RELEASE中集成Swagger的步骤： 1.在pom.xml文件中添加Swagger依赖： ```xml <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.9.2</version> </dependency> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger-ui</artifactId> <version>2.9.2</version> </dependency> ``` 2.创建Swagger配置类，用于配置Swagger： ```java @Configuration @EnableSwagger2 public class SwaggerConfig { @Bean public Docket api() { return new Docket(DocumentationType.SWAGGER_2) .select() .apis(RequestHandlerSelectors.any()) .paths(PathSelectors.any()) .build(); } } ``` 3.在Controller类中添加Swagger注解，用于描述API接口： ```java @RestController @RequestMapping("/api") @Api(value = "API", tags = "API接口") public class ApiController { @ApiOperation(value = "获取用户信息", notes = "根据用户ID获取用户信息") @ApiImplicitParam(name = "id", value = "用户ID", required = true, dataType = "int", paramType = "path") @GetMapping("/user/{id}") public User getUserById(@PathVariable int id) { // 根据ID获取用户信息 } } ``` 4.启动Spring Boot应用程序，访问http://localhost:8080/swagger-ui.html，即可查看Swagger UI界面，其中包含了所有API接口的详细信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

亿只王菜菜

各位爷，赏口饭吃吧

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值