1、当使用@RabbitListener注解时，且Jackson2JsonMessageConverter的setTypePrecedence默认为TypePrecedence.INFERRED时即默认为从接收方法端参数类型推断出反序列化类型，此时接收消息方法参数分情况如下：
 a、当只有一个非注释参数，或者使用@Payload注释的参数时取到推断的反序列化类型。
 b、我们忽略org.springframework.amqp.core.Message类型的参数，因为它们不涉及转换。
 c、注意，org.springframework.messaging.Message类型参数会取到实际参数类型getActualTypeArguments()。
判断逻辑的源码如下：
org.springframework.amqp.rabbit.listener.adapter.MessagingMessageListenerAdapter.MessagingMessageConverterAdapter：
 

private final class MessagingMessageConverterAdapter extends MessagingMessageConverter {


  private final Object bean;

  private final Method method;

  private final Type inferredArgumentType;

  private MessagingMessageConverterAdapter(Object bean, Method method) {
   this.bean = bean;
   this.method = method;
   this.inferredArgumentType = determineInferredType();
   if (logger.isDebugEnabled() && this.inferredArgumentType != null) {
    logger.debug("Inferred argument type for " + method.toString() + " is " + this.inferredArgumentType);
   }
  }

  @Override
  protected Object extractPayload(org.springframework.amqp.core.Message message) {
   MessageProperties messageProperties = message.getMessageProperties();
   if (this.bean != null) {
    messageProperties.setTargetBean(this.bean);
   }
   if (this.method != null) {
    messageProperties.setTargetMethod(this.method);
    if (this.inferredArgumentType != null) {
     messageProperties.setInferredArgumentType(this.inferredArgumentType);
    }
   }
   return extractMessage(message);
  }

  private Type determineInferredType() {
   if (this.method == null) {
    return null;
   }

   Type genericParameterType = null;


   for (int i = 0; i < this.method.getParameterTypes().length; i++) {
    MethodParameter methodParameter = new MethodParameter(this.method, i);
    /*
     * We're looking for a single non-annotated parameter, or one annotated with @Payload.
     * We ignore parameters with type Message because they are not involved with conversion.
     */
    if (isEligibleParameter(methodParameter)
      && (methodParameter.getParameterAnnotations().length == 0
      || methodParameter.hasParameterAnnotation(Payload.class))) {
     if (genericParameterType == null) {
      genericParameterType = methodParameter.getGenericParameterType();
      if (genericParameterType instanceof ParameterizedType) {
       ParameterizedType parameterizedType = (ParameterizedType) genericParameterType;
       if (parameterizedType.getRawType().equals(Message.class)) {
        genericParameterType = ((ParameterizedType) genericParameterType)
         .getActualTypeArguments()[0];
       }
      }
     }
     else {
      if (MessagingMessageListenerAdapter.this.logger.isDebugEnabled()) {
       MessagingMessageListenerAdapter.this.logger
         .debug("Ambiguous parameters for target payload for method " + this.method
           + "; no inferred type header added");
      }
      return null;
     }
    }
   }

   return genericParameterType;
  }

  /*
   * Don't consider parameter types that are available after conversion.
   * Message, Message<?> and Channel.
   */
  private boolean isEligibleParameter(MethodParameter methodParameter) {
   Type parameterType = methodParameter.getGenericParameterType();
   if (parameterType.equals(Channel.class)
     || parameterType.equals(org.springframework.amqp.core.Message.class)) {
    return false;
   }
   if (parameterType instanceof ParameterizedType) {
    ParameterizedType parameterizedType = (ParameterizedType) parameterType;
    if (parameterizedType.getRawType().equals(Message.class)) {
     return !(parameterizedType.getActualTypeArguments()[0] instanceof WildcardType);
    }
   }
   return !parameterType.equals(Message.class); // could be Message without a generic type
  }

 }

 @RabbitListener(queues = {"#{refreshQueue.getName()}"})
 public void rabbitMQListenerHandler(Message message) {


 }