在项目中嵌入RabbitMQ时，出现了以下报错：

com.fasterxml.jackson.databind.JsonMappingException: Infinite recursion (StackOverflowError)
(through reference chain: 
    java.lang.reflect.Parameter["declaringExecutable"]
    -> java.lang.reflect.Method["parameters"]
    -> java.lang.reflect.Parameter[0]
    -> java.lang.reflect.Parameter["declaringExecutable"]
    -> java.lang.reflect.Method["parameters"]
    -> java.lang.reflect.Parameter[0]
    -> java.lang.reflect.Parameter["declaringExecutable"]
    -> java.lang.reflect.Method["parameters"]
    -> java.lang.reflect.Parameter[0]
    -> java.lang.reflect.Parameter["declaringExecutable"]
    -> java.lang.reflect.Method["parameters"]
    -> java.lang.reflect.Parameter[0]
    -> java.lang.reflect.Parameter["declaringExecutable"]
    -> java.lang.reflect.Method["parameters"]
    -> java.lang.reflect.Parameter[0]
    -> java.lang.reflect.Parameter["declaringExecutable"]
    -> java.lang.reflect.Method["parameters"]
    -> java.lang.reflect.Parameter[0]
    -> java.lang.reflect.Parameter["declaringExecutable"]
    -> java.lang.reflect.Method["parameters"]
    -> java.lang.reflect.Parameter[0]
    -> java.lang.reflect.Parameter["declaringExecutable"]
    -> java.lang.reflect.Method["parameters"]
    -> java.lang.reflect.Parameter[0]
    -> java.lang.reflect.Parameter["declaringExecutable"]
    -> java.lang.reflect.Method["parameters"]

出现这个错误的原因是fastjson在将对象转成json字符串时出现了错误，具体原因是RabbitMQ的Message对象不能转成json串，具体原因不太清楚，出现这个错误是我写了aop方法用于增强所有方法，让他打印参数列表和返回值，在打印时将对象转成了JSON字符串，然后在遇到Message对象后就出现了如图上转换失败的原因，解决办法就是忽略这个具体方法或者优化一下AOP的增强方法，相关代码如下：

AOP增强方法

package com.atguigu.ssyx.common.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.text.SimpleDateFormat;
import java.util.Date;

@Aspect
@Component
public class MyAspect {


    Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * 在目标方法执行完成之后执行增强逻辑
     * pointcut切入点表达式指定了要增强的方法
     * returning属性指定了目标方法的返回值，并将其传递给增强方法的参数
     */
    @AfterReturning(pointcut = "execution(* com.atguigu.ssyx..*(..)) && !within(com.atguigu.ssyx..SkuReceiver)", returning = "result")
//    joinPoint表示连接点，可以获取到目标方法的信息
    public void afterMethodExecution(JoinPoint joinPoint, Object result)  {

//      切入点获取签名获取方法名称
        String methodName = joinPoint.getSignature().getName();
//      切入点获取传入参数
        Object[] arguments = joinPoint.getArgs();
//      切入点通过反射getClass获取类名
        String className = joinPoint.getTarget().getClass().getName();
//      打印类名.方法名 参数列表
        logger.info("\n================"+"方法名称:"+ className + "." + methodName +"=============================================" );
        logger.info("参数列表:");
//      如果参数列表不为空并且长度大于0
        if (arguments != null && arguments.length > 0) {
//          切入点获取签名
            Signature signature = joinPoint.getSignature();
            Method method = getMethod(signature);
            if (method != null) {
//              通过method对象获取参数列表
                Parameter[] parameters = method.getParameters();
//              for循环打印参数列表
                for (int i = 0; i < parameters.length; i++) {
                    logger.info(parameters[i].getName() + ":" + getArgumentValue(arguments[i]) + ",");
                }
            }
        } else {
            System.out.print("无");
        }
        try {
//          打印返回值，将对象转成json串格式化输出
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
            System.out.print("返回值:\n" + objectMapper.writeValueAsString(result));
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        logger.info("===================================="+printTime()+"=============================");
        logger.info("");
    }

    private Method getMethod(Signature signature) {
        if (signature instanceof MethodSignature) {
            MethodSignature methodSignature = (MethodSignature) signature;
            return methodSignature.getMethod();
        }
        return null;
    }

    private String getArgumentValue(Object argument) {
        if (argument != null) {
            try {
                ObjectMapper objectMapper = new ObjectMapper();
                objectMapper.enable(SerializationFeature.INDENT_OUTPUT);

                return  objectMapper.writeValueAsString(argument);
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        }
        return "null";
    }

    private String printTime(){
        // 创建日期对象
        Date currentDate = new Date();
        // 创建日期格式化对象，指定日期格式
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 格式化日期对象为字符串
        String formattedDate = dateFormat.format(currentDate);
        // 打印当前时间
        return("当前方法执行时间: " + formattedDate);
    }

}

MQ消息队列接收端

package com.atguigu.ssyx.receiver;

import com.atguigu.ssyx.common.constant.MqConst;
import com.atguigu.ssyx.search.service.SkuService;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import java.io.IOException;

/**
 *MQ消息队列的接收端
 */
@Component
public class SkuReceiver {


    @Autowired
    private SkuService skuService;


    /**
     * 上架时消息队列的消费端
     * @param skuId
     * @param message
     * @param channel
     * @throws IOException
     */
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = MqConst.QUEUE_GOODS_UPPER, durable = "true"),
            exchange = @Exchange(value = MqConst.EXCHANGE_GOODS_DIRECT),
            key = {MqConst.ROUTING_GOODS_UPPER}
    ))
    public void upperSku(Long skuId, Message message, Channel channel) throws IOException {
        if (null != skuId) {
//          上传商品操作
            skuService.upperSku(skuId);
        }
        /**
         * 第一个参数：表示收到的消息的标号
         * 第二个参数：如果为true表示可以签收多个消息
         */
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }

    /**
     * 商品下架
     * @param skuId
     */
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = MqConst.QUEUE_GOODS_LOWER, durable = "true"),
            exchange = @Exchange(value = MqConst.EXCHANGE_GOODS_DIRECT),
            key = {MqConst.ROUTING_GOODS_LOWER}
    ))
    public void lowerSku(Long skuId, Message message, Channel channel) throws IOException {
        if (null != skuId) {
//          调用es将商品下架
            skuService.lowerSku(skuId);
        }
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }



}