Java 丢失和“丢失”；“未确认”；具有Spring集成AMQP和RabbitMQ的消息

我试图创建2个简单的应用程序；一个是将消息发布到RabbitMQ通道，另一个是从通道接收消息并在控制台中打印出来。发件人应用程序启动并立即发布10条消息

我在客户端控制台上看到的只是打印的消息的大约一半。 当我检查RabbitMQ web客户端时，我还看到其中一条消息始终处于“未确认”状态

当我阅读文档时，据我所知，“amqp入站/出站网关”是实现这一点的简单方法。 你能帮我理解为什么我丢失了一些信息，而其中一条处于“未确认”状态吗？ 另外，我应该如何更改它以获取另一端的所有消息

先谢谢你

以下是发件人端的xml配置和文件：

integrationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:int="http://www.springframework.org/schema/integration"
  xmlns:int-amqp="http://www.springframework.org/schema/integration/amqp"
  xmlns:rabbit="http://www.springframework.org/schema/rabbit"
  xmlns:context="http://www.springframework.org/schema/context"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/integration
    http://www.springframework.org/schema/integration/spring-integration.xsd
    http://www.springframework.org/schema/integration/amqp 
    http://www.springframework.org/schema/integration/amqp/spring-integration-amqp.xsd
    http://www.springframework.org/schema/rabbit 
    http://www.springframework.org/schema/rabbit/spring-rabbit.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context.xsd">

<!-- Configuration for Component Scan -->
<context:component-scan base-package="com.amqp.sample" />

<context:property-placeholder location="classpath*:rabbitmq.properties"/>

<int:gateway id="taskGateway" service-interface="com.amqp.sample.TaskGateway" default-request-channel="processChannel" />
<int-amqp:channel id="processChannel"
   connection-factory="connectionFactory" 
   message-driven="true"
   queue-name="ha.rabbit.channel" />

<!-- RabbitMQ Connection Factory -->
<rabbit:connection-factory id="connectionFactory"
    addresses="${rabbitmq.addresses}" 
    username="${rabbitmq.username}"
    password="${rabbitmq.password}" />

<rabbit:template id="amqpTemplate" 
    connection-factory="connectionFactory"
    reply-timeout="-1" />

<rabbit:admin connection-factory="connectionFactory" />


<int-amqp:outbound-gateway  request-channel="processChannel" 
                            reply-channel="processChannel" 
                            reply-timeout="-1" />

</beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:int="http://www.springframework.org/schema/integration"
  xmlns:int-amqp="http://www.springframework.org/schema/integration/amqp"
  xmlns:rabbit="http://www.springframework.org/schema/rabbit"
  xmlns:context="http://www.springframework.org/schema/context"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/integration
    http://www.springframework.org/schema/integration/spring-integration.xsd
    http://www.springframework.org/schema/integration/amqp 
    http://www.springframework.org/schema/integration/amqp/spring-integration-amqp.xsd
    http://www.springframework.org/schema/rabbit 
    http://www.springframework.org/schema/rabbit/spring-rabbit.xsd
    http://www.springframework.org/schema/context 
  http://www.springframework.org/schema/context/spring-context.xsd">

  <!-- Configuration for Component Scan -->
  <context:component-scan base-package="com.amqp.sample" />

  <context:property-placeholder location="classpath*:rabbitmq.properties"/>

  <!-- RabbitMQ Connection Factory -->
  <rabbit:connection-factory id="connectionFactory"
        addresses="${rabbitmq.addresses}" 
        username="${rabbitmq.username}"
        password="${rabbitmq.password}" />

  <rabbit:template id="amqpTemplate" connection-factory="connectionFactory"/>
  <rabbit:admin connection-factory="connectionFactory" />

  <int:channel id="inputChannel"/>

  <int-amqp:inbound-gateway request-channel="inputChannel" reply-channel="inputChannel" 
    queue-names="ha.rabbit.channel" 
    connection-factory="connectionFactory" 
    amqp-template="amqpTemplate"/>

  <int:service-activator input-channel="inputChannel" ref="taskProcessService" method="process" />

</beans>

Application.Java

import org.springframework.messaging.Message;

import com.amqp.sample.model.Task;

public interface TaskGateway {

  void processTaskRequest(Message<Task> message);
}

import java.io.Serializable;

public class Task implements Serializable {

    private static final long serialVersionUID = -2138235868650860555L;
    private int id;
    private String name;

    public int getId() {
      return id;
    }

    public void setId(int id) {
      this.id = id;
    }

    public String getName() {
      return name;
    }

    public void setName(String name) {
      this.name = name;
    }

    public Task(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Task [id=" + id + ", name=" + name + "]";
    }

}

@PropertySources({
 @PropertySource("classpath:application.properties"),
})
@EnableConfigurationProperties
@ComponentScan
@EnableAutoConfiguration
@ImportResource("classpath:integrationContext.xml")
public class Application extends SpringBootServletInitializer {
  public static final Logger logger = LoggerFactory.getLogger(Application.class);

  private static TaskGateway taskGateway;

  public static void main(String[] args) {
    ApplicationContext context=SpringApplication.run(Application.class, args);

    taskGateway = context.getBean(TaskGateway.class);
    for(int i=0; i<10; i++){
      Message<Task> message = MessageBuilder.withPayload(getTask(i)).build();
      taskGateway.processTaskRequest(message);
    }
  }

  /**
     * Creates a sample task returns.
     *
     * @return Task
     */
    private static Task getTask(final int id) {
        return new Task(id, "Task with ID:" + id);
    }

  @Override
  protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
    return application.sources(Application.class);
  }

}

import org.springframework.messaging.Message;

public interface ProcessService<T> {

    /**
     * Processes incoming message(s)
     *
     * @param message SI Message.
     */
    void process(Message<T> message);

}

@PropertySources({
 @PropertySource("classpath:application.properties"),
})
@EnableConfigurationProperties
@ComponentScan
@EnableAutoConfiguration
@ImportResource("classpath:integrationContext.xml")
public class Application extends SpringBootServletInitializer {
  public static final Logger logger = LoggerFactory.getLogger(Application.class);


  public static void main(String[] args) {
    ApplicationContext context = SpringApplication.run(Application.class, args);
  }

  @Override
  protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
    return application.sources(Application.class);
  }

}

---

首先，网关用于请求/应答场景；由于您的客户端不需要响应，并且服务不返回响应，因此您应该使用通道适配器而不是网关。试试看，如果你还有麻烦就回来

编辑

@SpringBootApplication
@IntegrationComponentScan
public class So40680673Application {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(So40680673Application.class, args);
        FooGate gate = context.getBean(FooGate.class);
        for (int i = 0; i < 10; i++) {
            System.out.println(gate.exchange("foo" + i));
        }
        context.close();
    }

    @MessagingGateway(defaultRequestChannel = "out.input")
    public interface FooGate {

        String exchange(String out);
    }

    @Bean
    public IntegrationFlow out(AmqpTemplate amqpTemplate) {
        return f -> f.handle(Amqp.outboundGateway(amqpTemplate).routingKey(queue().getName()));
    }

    @Bean
    public IntegrationFlow in(ConnectionFactory connectionFactory) {
        return IntegrationFlows.from(Amqp.inboundGateway(connectionFactory, queue().getName()))
                .<String, String>transform(String::toUpperCase)
                .get();
    }

    @Bean
    public Queue queue() {
        return new AnonymousQueue();
    }

}

@springboot应用程序
@集成组件扫描
公共类SO40680673应用程序{
公共静态void main（字符串[]args）{
ConfigurableApplicationContext上下文=SpringApplication.run（So40680673Application.class，args）；
FooGate-gate=context.getBean（FooGate.class）；
对于（int i=0；i<10；i++）{
系统输出打印LN（门交换（“foo”+i））；
}
context.close（）；
}
@MessagingGateway（defaultRequestChannel=“out.input”）
公共接口FooGate{
串交换（串出）；
}
@豆子
公共集成流出（AmqpTemplate AmqpTemplate）{
返回f->f.handle（Amqp.outboundGateway（amqpmetplate）.routingKey（queue（）.getName（））；
}
@豆子
公共集成流程输入（ConnectionFactory ConnectionFactory）{
返回IntegrationFlows.from（Amqp.inboundGateway（connectionFactory，queue（）.getName（）））
.transform（字符串：：toUpperCase）
.get（）；
}
@豆子
公共队列（）{
返回新的匿名队列（）；
}
}

加里，谢谢你的回复。事实上，我计划稍后在发件人端记录收到的消息。这就是我选择这些通道的原因之一。您能帮我修复网关的代码吗？客户端的回复超时为-1（

rabbitmplate

）；你的呼叫线程将永远等待一个永远不会出现的回复。一旦您解决了这个问题，我建议您打开调试日志记录，并在客户端和服务器中跟踪消息。我不准备帮助调试虚假配置；对不起，我理解。我将更改回复超时并从那里开始调试。同时，您是否有任何使用网关将amqp与rabbitmq示例代码/配置进行简单集成的示例，我可以将其用作示例？再次感谢您的帮助。我添加了一个示例；它使用JavaDSL而不是XML，但功能是相同的。

@SpringBootApplication
@IntegrationComponentScan
public class So40680673Application {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(So40680673Application.class, args);
        FooGate gate = context.getBean(FooGate.class);
        for (int i = 0; i < 10; i++) {
            System.out.println(gate.exchange("foo" + i));
        }
        context.close();
    }

    @MessagingGateway(defaultRequestChannel = "out.input")
    public interface FooGate {

        String exchange(String out);
    }

    @Bean
    public IntegrationFlow out(AmqpTemplate amqpTemplate) {
        return f -> f.handle(Amqp.outboundGateway(amqpTemplate).routingKey(queue().getName()));
    }

    @Bean
    public IntegrationFlow in(ConnectionFactory connectionFactory) {
        return IntegrationFlows.from(Amqp.inboundGateway(connectionFactory, queue().getName()))
                .<String, String>transform(String::toUpperCase)
                .get();
    }

    @Bean
    public Queue queue() {
        return new AnonymousQueue();
    }

}