springboot知识总结(logger和RabbitMQ)

最新推荐文章于 2024-07-05 15:46:54 发布
最新推荐文章于 2024-07-05 15:46:54 发布
阅读量610 收藏
点赞数
分类专栏： 框架 文章标签： rabbitmq spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55946115/article/details/120170944
版权

SpringBoot与日志

日志的作用是用来追踪和记录我们的程序运行中的信息，我们可以利用日志很快定位问题，追踪分析。

市面常用日志框架

在这里插入图片描述
日志门面：
JCL：阿帕奇公司的jakarta创建的，2014年最后一次更新，不选择
jboss-logging： 生来就不适合程序员调用。
日志实现：
log4j和logback是出自同一个人，因为log4j存在性能问题，然后就创建了logback。
JUL：是在log4j出现后，再次出现一个日志工具
Log4j2：是阿帕奇公司创建的，性能与功能很好。
使用：
在使用日志的时候，我们是希望通过日志门面进行调用日志实现的功能，然而在上述日志框架中，SLF4j与logback，log4j出自一个人，那么适配性肯定也是最高，所以就选用SLF4j+logback进行使用

SLF4j的使用

在开发中，我们不直接调用日志实现，而是要通过日志门面去调用。官网
首先导入SLF4j的jar包，入门程序：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloWorld {
  public static void main(String[] args) {
    Logger logger = LoggerFactory.getLogger(HelloWorld.class);
    logger.info("Hello World");
  }
}

SLF是日志门面，那么对应的就有其日志实现
在这里插入图片描述
使用配置文件进行配置的时候，只需要调用其日志实现的配置文件。

注意：实际中，在开发的过程中可能会有不同的框架的底层调用了不同的日志框架，那么如何通过SLF4
j进行统一呢。
在这里插入图片描述
步骤：

  1. 将原来的日志实现排除出去。
  2. 用中间包来替换其他的日志框架
  3. 导入SLF4j的的实现

springboot日志

在这里插入图片描述
springboot底层也是通过SLF4j的方式，去替换其他的日志功能。

配置： 每次启动程序控制台都会有日志打印出来，那么就存在日志基本默认配置

@Test
    void contextLoads() {
        Logger logger = LoggerFactory.getLogger(Self4jTestApplicationTests.class);
        //日志输出级别从小到大,trace<debug<info<warn<error
        logger.trace("跟踪...");
        logger.debug("debug...");
        logger.info("info...");
        logger.warn("warn...");
        logger.error("error...");
        //2021-09-08 08:29:52.301  INFO 17220 --- [           main] c.s.s.Self4jTestApplicationTests         : info...
        //2021-09-08 08:29:52.301  WARN 17220 --- [           main] c.s.s.Self4jTestApplicationTests         : warn...
        //2021-09-08 08:29:52.301 ERROR 17220 --- [           main] c.s.s.Self4jTestApplicationTests         : error...
        //通过打印结果发现spring的输出级别在info
    }

通过配置文件可以改变日志配置规则

# 改变日志的打印级别
logging.level.cn.supperbro.self4jtest=trace
# 设置输出路径
# logging.file.path=
# 设置输出文件名
logging.file.name=./spring/log/test.log

在这里插入图片描述
指定配置
在类路径下放上某个日志实现的配置文件即可，spring在检测到用户配置后，就不启用默认的配置
在这里插入图片描述
例如：
指定logback.xml，logback框架会直接拿到该文件，如果是logback-spring.xml就会通过spring去加载，就可以拓展spring的功能。

SpringBoot与消息中间件

消息中间件

简介

消息中间件是基于队列与消息传递技术，在网络环境中为应用系统提供同步或异步、可靠的消息传输的支撑性软件系统。

  1. 大多数应用中，消息中间件可以提供异步通信和拓展解耦的能力。
  2. 消息代理和目的地：当消息发送之后，有消息代理接管，并且消息代理能够保证消息传递到目的地。
  3. 消息队列主要有两种类型的目的地
    队列：点对点的通信
    主题：发布/订阅
  4. 点对点式：消息发送者发送消息后，将消息存放在队列当中，消息接收者接收消息后，就将消息从队列里面移除。有唯一的消息发送者和唯一的消息接收者，但是并不代表就只有一个的消息接收者
  5. 主题/订阅，消息发送者将消息发布到某个主题，那么订阅这个主题的接收者就会同时接收到这个消息。
  6. JMS（Java Message Service）协议与AMQP（Advanced Message Queuing PProtocol）协议
    在这里插入图片描述

应用场景

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

RabbitMQ

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

AMQP ：Advanced Message Queue，高级消息队列协议。它是应用层协议的一个开放标准，为面向消息的中间件设计，基于此协议的客户端与消息中间件可传递消息，并不受产品、开发语言等条件的限制。

RabbitMQ 最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。具体特点包括：

  • 可靠性（Reliability） RabbitMQ 使用一些机制来保证可靠性，如持久化、传输确认、发布确认。
  • 灵活的路由（Flexible Routing） 在消息进入队列之前，通过 Exchange
    来路由消息的。对于典型的路由功能，RabbitMQ 已经提供了一些内置的 Exchange 来实现。针对更复杂的路由功能，可以将多个Exchange 绑定在一起，也通过插件机制实现自己的 Exchange 。
  • 消息集群（Clustering） 多个 RabbitMQ 服务器可以组成一个集群，形成一个逻辑 Broker 。
  • 高可用（Highly Available Queues） 队列可以在集群中的机器上进行镜像，使得在部分节点出问题的情况下队列仍然可用。
  • 多种协议（Multi-protocol） RabbitMQ 支持多种消息队列协议，比如 STOMP、MQTT 等等。
  • 多语言客户端（Many Clients） RabbitMQ 几乎支持所有常用语言，比如 Java、.NET、Ruby 等等。
  • 管理界面（Management UI） RabbitMQ 提供了一个易用的用户界面，使得用户可以监控和管理消息 Broker 的许多方面。
  • 跟踪机制（Tracing） 如果消息异常，RabbitMQ 提供了消息跟踪机制，使用者可以找出发生了什么。
  • 插件机制（Plugin System） RabbitMQ 提供了许多插件，来从多方面进行扩展，也可以编写自己的插件。

概念

消息模型
所有 MQ 产品从模型抽象上来说都是一样的过程：
消费者（consumer）订阅某个队列。生产者（producer）创建消息，然后发布到队列（queue）中，最后将消息发送到监听的消费者。
在这里插入图片描述
基本概念
在这里插入图片描述

Message
消息，消息是不具名的，它由消息头和消息体组成。消息体是不透明的，而消息头则由一系列的可选属性组成，这些属性包括routing-key（路由键）、priority（相对于其他消息的优先权）、delivery-mode（指出该消息可能需要持久性存储）等。

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

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

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

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

Connection
网络连接，比如一个TCP连接。

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

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

Virtual Host
虚拟主机，表示一批交换器、消息队列和相关对象。虚拟主机是共享相同的身份认证和加密环境的独立服务器域。每个 vhost 本质上就是一个 mini 版的 RabbitMQ 服务器，拥有自己的队列、交换器、绑定和权限机制。vhost 是 AMQP 概念的基础，必须在连接时指定，RabbitMQ 默认的 vhost 是 / 。

Broker
表示消息队列服务器实体。

AMQP的消息路由

AMQP 中消息的路由过程和 Java 开发者熟悉的 JMS 存在一些差别，AMQP 中增加了 Exchange 和 Binding 的角色。生产者把消息发布到 Exchange 上，消息最终到达队列并被消费者接收，而 Binding 决定交换器的消息应该发送到那个队列。

在这里插入图片描述

Exchange 类型

Exchange分发消息时根据类型的不同分发策略有区别，目前共四种类型：direct、fanout、topic、headers 。headers 匹配 AMQP 消息的 header 而不是路由键，此外 headers 交换器和 direct 交换器完全一致，但性能差很多，目前几乎用不到了，所以直接看另外三种类型：
direct
direct 交换器
消息中的路由键（routing key）如果和 Binding 中的 binding key 一致， 交换器就将消息发到对应的队列中。路由键与队列名完全匹配，如果一个队列绑定到交换机要求路由键为“dog”，则只转发 routing key 标记为“dog”的消息，不会转发“dog.puppy”，也不会转发“dog.guard”等等。它是完全匹配、单播的模式。

fanout
在这里插入图片描述
每个发到 fanout 类型交换器的消息都会分到所有绑定的队列上去。fanout 交换器不处理路由键，只是简单的将队列绑定到交换器上，每个发送到交换器的消息都会被转发到与该交换器绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。fanout 类型转发消息是最快的。

topic
在这里插入图片描述
topic 交换器通过模式匹配分配消息的路由键属性，将路由键和某个模式进行匹配，此时队列需要绑定到一个模式上。它将路由键和绑定键的字符串切分成单词，这些单词之间用点隔开。它同样也会识别两个通配符：符号“#”和符号“”。#匹配0个或多个单词，匹配不多不少一个单词。

MQ的安装

一般来说安装 RabbitMQ 之前要安装 Erlang ，可以去Erlang官网下载。接着去RabbitMQ官网下载安装包，之后解压缩即可。
windows安装：

  1. 下载Erlang，设置其环境变量
  2. 测试安装成功
D:\rabbitMQ\install-rabbitmq\rabbitmq_server-3.9.5\sbin>erl
Eshell V12.0  (abort with ^G)
1>
  1. 同样，安装RabbitMQ，在安装好的sbin目录下，命令行安装插件
D:\rabbitMQ\install-rabbitmq\rabbitmq_server-3.9.5\sbin>rabbitmq-plugins enable rabbitmq_management
  1. 同样测试
D:\rabbitMQ\install-rabbitmq\rabbitmq_server-3.9.5\sbin>rabbitmqctl status
  1. sbin目录下，双击rabbitmq-server启动访问http：//localhost：15672，账号密码guest

RabbitMQ 运行和管理

启动
启动很简单，找到安装后的 RabbitMQ 所在目录下的 sbin 目录，可以看到该目录下有6个以 rabbitmq 开头的可执行文件，直接执行 rabbitmq-server 即可，下面将 RabbitMQ 的安装位置以 . 代替，启动命令就是：

D:\rabbitMQ\install-rabbitmq\rabbitmq_server-3.9.5\sbin>rabbitmq-server

后台启动
如果想让 RabbitMQ 以守护程序的方式在后台运行，可以在启动的时候加上 -detached 参数：

D:\rabbitMQ\install-rabbitmq\rabbitmq_server-3.9.5\sbin>rabbitmq-server -detached

查询服务器状态
sbin 目录下有个特别重要的文件叫 rabbitmqctl ，它提供了 RabbitMQ 管理需要的几乎一站式解决方案，绝大部分的运维命令它都可以提供。
查询 RabbitMQ 服务器的状态信息可以用参数 status ：

D:\rabbitMQ\install-rabbitmq\rabbitmq_server-3.9.5\sbin>rabbitmqctl status

关闭 RabbitMQ 节点
我们知道 RabbitMQ 是用 Erlang 语言写的，在Erlang 中有两个概念：节点和应用程序。节点就是 Erlang 虚拟机的每个实例，而多个 Erlang 应用程序可以运行在同一个节点之上。节点之间可以进行本地通信（不管他们是不是运行在同一台服务器之上）。比如一个运行在节点A上的应用程序可以调用节点B上应用程序的方法，就好像调用本地函数一样。如果应用程序由于某些原因奔溃，Erlang 节点会自动尝试重启应用程序。
如果要关闭整个 RabbitMQ 节点可以用参数 stop ：

D:\rabbitMQ\install-rabbitmq\rabbitmq_server-3.9.5\sbin>rabbitmqctl stop

关闭 RabbitMQ 应用程序
如果只想关闭应用程序，同时保持 Erlang 节点运行则可以用 stop_app：

./sbin/rabbitmqctl stop_app

启动 RabbitMQ 应用程序

./sbin/rabbitmqctl start_app

重置 RabbitMQ 节点

./sbin/rabbitmqctl reset

该命令将清除所有的队列。

查看已声明的队列

./sbin/rabbitmqctl list_queues

查看交换器

./sbin/rabbitmqctl list_exchanges

该命令还可以附加参数，比如列出交换器的名称、类型、是否持久化、是否自动删除：

./sbin/rabbitmqctl list_exchanges name type durable auto_delete

查看绑定

./sbin/rabbitmqctl list_bindings

JAVA客户端访问

  1. 导入依赖
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>4.1.0</version>
</dependency>
  1. 消息生产者
package rabbitmq;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Producer {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        //设置 RabbitMQ 地址
        factory.setHost("localhost");
        //建立到代理服务器到连接
        Connection conn = factory.newConnection();
        //获得信道
        Channel channel = conn.createChannel();
        //声明交换器
        String exchangeName = "hello-exchange";
        channel.exchangeDeclare(exchangeName, "direct", true);

        String routingKey = "hola";
        //发布消息
        for (int i = 0; i < 10; i++) {
            byte[] messageBodyBytes = "你好,rabbitMQ".getBytes();
            channel.basicPublish(exchangeName, routingKey, null, messageBodyBytes);
        }
        channel.close();
        conn.close();
    }
}
  1. 消息消费者
package rabbitmq;

import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer {

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setHost("localhost");
        //建立到代理服务器到连接
        Connection conn = factory.newConnection();
        //获得信道
        final Channel channel = conn.createChannel();
        //声明交换器
        String exchangeName = "hello-exchange";
        channel.exchangeDeclare(exchangeName, "direct", true);
        //声明队列
        String queueName = channel.queueDeclare().getQueue();
        String routingKey = "hola";
        //绑定队列，通过键 hola 将队列和交换器绑定起来
        channel.queueBind(queueName, exchangeName, routingKey);

        while(true) {
            //消费消息
            boolean autoAck = false;
            String consumerTag = "";
            channel.basicConsume(queueName, autoAck, consumerTag, new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag,
                                           Envelope envelope,
                                           AMQP.BasicProperties properties,
                                           byte[] body) throws IOException {
                    String routingKey = envelope.getRoutingKey();
                    String contentType = properties.getContentType();
                    System.out.println("消费的路由键：" + routingKey);
                    System.out.println("消费的内容类型：" + contentType);
                    long deliveryTag = envelope.getDeliveryTag();
                    //确认消息
                    channel.basicAck(deliveryTag, false);
                    System.out.println("消费的消息体内容：");
                    String bodyStr = new String(body, "UTF-8");
                    System.out.println(bodyStr);

                }
            });
        }
    }
}

SpringBoot与RabbitMQ

  1. 首先导入场景依赖
		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
  1. 导入场景配置器以后，我们会发现spring-boot-starter-amqp做了很多默认配置，可以查看配置文件
    在这里插入图片描述
    查看配置文件可以发现：
    配置CachingConnectionFactory的链接工厂，绑定了链接的默认配置文件
    在这里插入图片描述
    进而绑定到我们外部配置文件application.properties/yaml；配置前缀为spring.rabbitmq
    那么就可以通过配置文件进行简单的配置
spring.rabbitmq.host=localhost
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
#都会有默认配置

接下来，我们还发现spring也会去配置定义一个RabbitMQ的操作模板配置
在这里插入图片描述
除了定义了消息的生产消费，同时也有RabbitAdmin去操作交换机和队列等操作

public AmqpAdmin amqpAdmin(ConnectionFactory connectionFactory) {
			return new RabbitAdmin(connectionFactory);
		}

接下来就可以定义一个交换机和队列进行操作

  1. 定义一个ExChange，类型为direct； supperbro.exchange.direct
  2. 定义队列 supperbro
  3. 绑定该队列，定义路由键 supperbro
    在这里插入图片描述
    准备工作完成之后就可以使用springboot的RabbitMQ场景进行操作了

发送消息

//自动装配RabbitTemplate
    @Autowired
    RabbitTemplate rabbitTemplate;
    @Test
    void contextLoads() {
        //rabbitTemplate.send("交换机","路由键","消息");
        //需要自己去定义消息头和消息体
        Map<String,Object> map = new HashMap<>();
        map.put("msg","the first");
        map.put("body", Arrays.asList("hello",true));
        //该方法把map当作消息体，自动序列化发送给我们的RabbitMQ服务器
        rabbitTemplate.convertAndSend("supperbro.exchange.direct","supperbro", map);
    }

在这里插入图片描述
接收数据

@Test
    void consumer(){
        //接收数据，消费数据,会自动反序列化
        Object supperbro = rabbitTemplate.receiveAndConvert("supperbro");
        System.out.println(supperbro);
        //{msg=the first, body=[hello, true]}
    }

上述中我们可以看到，消息生产时，序列化的规则为默认规则

 private MessageConverter messageConverter = new SimpleMessageConverter();

同样可以去定制化序列化规则

package cn.supperbro.rabbitmqtest.config;

import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MessageConverterConfigure {
    //向容器添加一个MessageConverter，自动配置会根据容器是否存在该组件进行仲裁
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }
}

再次运行
在这里插入图片描述
实际开发场景中，我们的消息消费不应该是手动获取，而是应该设置监听，监听队列的消息。
@EnableRabbit作用在启动类上，标注开启RabbitMQ注解驱动
@RabbitListener作用在业务逻辑上用来消费队列数据

package cn.supperbro.rabbitmqtest.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;

import java.util.Map;

@Service
public class RabbitConsumer {
    //设置监听的队列
    @RabbitListener(queues = "supperbro")
    public void listenQueue(Map<String,Object> map){
        Logger logger = LoggerFactory.getLogger(RabbitConsumer.class);
        System.out.println(map.get("msg"));
    }
}

上述中，交换机，队列，绑定都是通过手动配置好的，那么通过Java语言如何去实现，上述在分析自动配置中，有一个AmqpAdmin可以去配置定义Exchange等信息。

@Autowired
    AmqpAdmin amqpAdmin;
    @Test
    public void testAmqpAdmin(){
        //创建一个Exchange
        //amqpAdmin.declareExchange(new DirectExchange("supperbro.amqpAdmin"));
        //创建一个队列
        //amqpAdmin.declareQueue(new Queue("supperbro.ampqAdmin.queue",true));
        //绑定队列
        //public Binding(String destination, Binding.DestinationType destinationType, String exchange, String routingKey, @Nullable Map<String, Object> arguments)
        amqpAdmin.declareBinding(new Binding("supperbro.ampqAdmin.queue", Binding.DestinationType.QUEUE,"supperbro.amqpAdmin","supperbro.ampqAdmin.key",null));
    }
SF_ONE
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rabbitmq配置参数解析在springboot中
天然玩家的博客
04-25 658
我在使用RabbitMQ组件的过程中，一些配置参数，如RabbitMQ连接、发布者、监听者， 这些参数均是抄过来的，并不知道真生的含义， 现打算弄清楚每个参数的含义，为后续的线上遇到问题，调参做准备。 成为调参架构师...
spring boot 中logback日志输出到RabbitMq中
chen846262292的专栏
12-18 5979
最近在接口项目开始使用微服务设计构架，使用的是现在流行的spring cloud技术栈。 网关做权限，限流，日志记录等前置统一入口。在网关统一记录请求及相应日志，单实例的时候情况下，没有问题，但是想到网关压力比较大，于是决定启动多个实例。但是为了查询日志方便，多实例记录的日志打算不分开，还是记录到同一个文件中（按天分割），看到这里可能有人会问，分布式日志收集，为什么不用ELK呢？我们是有ELK系...
springboot中logback-spring.xml中日志输出到rabbitmq
qq_34412985的博客
11-19 664
<?xml version="1.0" encoding="UTF-8"?> <configuration scan="true" debug="false"> <shutdownHook class="ch.qos.logback.core.hook.DelayingShutdownHook"/> <appender name="CONS...
Logback 整合 RabbitMQ 实现统一日志输出
最新发布
qq_20314141的博客
07-05 38
公司项目做了集群实现请求分流，由于线上或多或少会出现请求失败或系统异常，为了查看失败请求的日志信息，我们得将所有服务的日志文件都打开来进行问题的定位分析，操作起来非常麻烦。因此，我们开发组决定设计一套日志查看系统来解决上述问题。
log4j2精华之异步日志MQ篇
洪晓鸿
04-13 624
如何在Spring Boot中通过RabbitMQ实现日志异步记录的一个简单示例。你可以根据实际需求对其进行扩展和优化。
Spring集成Rabbitmq收集Logback日志，利用进行Logstash数据整理存储到Elasticsearch中
盲目的拾荒者的博客
08-08 8178
项目中我们常用的是把Logback打印的日志存储到文件中保存到硬盘上，这样不利于日志的收集和分析。 以下演示在SpringBoot中通过rabbitmq收集logback日志存储到Elasticsearch中。 环境准备：安装RabbitMQ，安装Elasticsearch和Elasticsearch-Head(可视化插件)，安装Logstash.====》之前博客已经介绍过了。 pom.x...
rabbitmq-logger：记录错误和异常int Rabbitmq交换
02-26
将错误和异常记录为int Rabbitmq交换。 Rabbitmq Logger为提供了两个扩展。 RabbitMqLoggerExtension用于将错误/异常记录到rabbitmq范围中。 您应该在要将错误消息记录到rabbitmq的所有项目上使用此扩展名。 ...
Python logging设置和logger解析
09-18
在本文中，我们将深入理解logging模块的设置和logger解析。 首先，我们要了解logging.basicConfig()函数。这个函数用于初始化日志的基本配置，包括日志级别、输出目标和格式。level参数设定日志记录的最低阈值，...
C# Logger C# 的日志工具
04-02
例如，`Logger.Debug("调试信息")`、`Logger.Info("信息")`、`Logger.Warn("警告")` 和 `Logger.Error("错误")` 分别用于记录不同级别的日志信息。对于更复杂的用例，还可以使用`Logger.Log()`方法，通过传入自定义...
SpringBoot通过yml和xml文件配置日志输出方法
08-26
SpringBoot 通过 yml 和 xml 文件配置日志输出方法 在本文中，我们将详细介绍如何使用 SpringBoot 通过 yml 和 xml 文件配置日志输出方法。 SpringBoot框架默认使用 Logback 进行日志输出，我们可以通过 ...
SpringBoot如何使用feign实现远程接口调用和错误熔断
08-25
SpringBoot 使用 Feign 实现远程接口调用和错误熔断 Feign 是一种基于 Java 的声明式 Web 服务客户端，SpringBoot 通过 Feign 可以轻松地实现远程接口调用和错误熔断。在本文中，我们将详细介绍如何使用 Feign 实现...
RabbitMQ 日志
y19910825的博客
03-26 2201
RabbitMQ 日志 1.安装插件rabbitmq_tracing https://www.cnblogs.com/li150dan/p/9529049.html 启用日志插件命令：rabbitmq-plugins enable rabbitmq_tracing 2.到管理页面添加tracing 点击“Admin”菜单，右边会多出一个“Tracing”的菜单，填写Name...
Logback整合RabbitMQ 实现统一日志输出
我的博客
08-13 390
公司项目做了集群实现请求分流，由于线上或多或少会出现请求失败或系统异常，为了查看失败请求的日志信息，我们得将所有服务的日志文件都打开来进行问题的定位分析，操作起来非常麻烦。因此，我们开发组决定设计一套日志查看系统来解决上述问题。
IDEA中Spring Boot项目取消冗余日志
t8t359的博客
08-08 439
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U2o2dfUU-1691461886037)(C:/Users/huang/Desktop/课程笔记/基础框架笔记/基础框架8笔记/Mybatisplus笔记/assets/1631021315906.png)]**说明:**logback.xml的配置内容，不是我们学习的重点，如果有兴趣可以自行百度查询。解决控制台打印日志过多的相关操作可以不用去做，一般会被用来方便我们查看程序运行的结果。
RabbitMQ的日志
我的博客
08-13 3917
若要仅为错误创建附加日志文件，请创建具有错误级别的附加处理程序。
RabbitMQ amqp_client的使用
weixin_43849190的博客
07-05 1080
可以看到有一条消息,使用了默认的交换机，路游key值为hello，消息体为"hello damage!
日志一直打印 DEBUG o.s.amqp.rabbit.listener.BlockingQueueConsumer
dawei5565的博客
01-17 933
<?xml version="1.0" encoding="UTF-8"?> <configuration> <logger name="org.springframework.amqp.rabbit.listener.BlockingQueueConsumer" level="WARN" /> <logger name="org.springf...
java记录日志不打印控制台,java异常在控制台和日志里面的打印记录
weixin_35671798的博客
03-13 2327
1、e.printStackTrace()打印在哪里在catch中的e.printStackTrace()将打印到控制台2、e.printStackTrace()打印的内容是什么import org.apache.logging.log4j.Logger;public class ExceptionTest {private static final Logger logger=LogManage...
java的springboot框架中使用logback日志框架使用RabbitHandler注解为什么获取不到消费的traceId信息？
gb4215287的博客
09-06 906
java的springboot框架中使用logback日志框架使用RabbitHandler注解为什么获取不到消费的traceId信息？
springboot默认logger
06-08
<pattern>%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} : %msg%n%throwable ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值