Spring 弹簧集成反应器配置

我正在运行一个使用spring集成处理任务的应用程序

我想让它同时处理多个任务，但到目前为止任何尝试都失败了

我的配置是：

ReactorConfiguration.java

@Configuration
@EnableAutoConfiguration
public class ReactorConfiguration {


    @Bean
    Environment reactorEnv() {
        return new Environment();
    }

    @Bean
    Reactor createReactor(Environment env) {
        return Reactors.reactor()
            .env(env)
            .dispatcher(Environment.THREAD_POOL)
            .get();
    }
}

@MessagingGateway(reactorEnvironment = "reactorEnv")
public interface TaskProcessor {
    @Gateway(requestChannel = "routeTaskByType", replyChannel = "")
    Promise<Result> processTask(Task task);
}

TaskProcessor.java

@Configuration
@EnableAutoConfiguration
public class ReactorConfiguration {


    @Bean
    Environment reactorEnv() {
        return new Environment();
    }

    @Bean
    Reactor createReactor(Environment env) {
        return Reactors.reactor()
            .env(env)
            .dispatcher(Environment.THREAD_POOL)
            .get();
    }
}

@MessagingGateway(reactorEnvironment = "reactorEnv")
public interface TaskProcessor {
    @Gateway(requestChannel = "routeTaskByType", replyChannel = "")
    Promise<Result> processTask(Task task);
}

我的测试代码可以简化如下：

Task task1 = new Task();
Task task2 = new Task();

Promise<Result> resultPromise1 = taskProcessor.processTask(task1).flush();
Promise<Result> resultPromise2 = taskProcessor.processTask(task2).flush();


while( !task1.isRunning() || !task2.isRunning() ){
    logger.info("Task2: {}, Task2: {}", task1, task2);
    Thread.sleep(1000);
}

logger.info("Yes! your tasks are running in parallel!");

Task task1=新任务（）；
任务task2=新任务（）；
Promise resultPromise1=taskProcessor.processTask（task1.flush（）；
Promise resultPromise2=taskProcessor.processTask（task2.flush（）；
而（！task1.isRunning（）| |！task2.isRunning（））{
info（“Task2:{}，Task2:{}”，task1，Task2）；
睡眠（1000）；
}
info（“是的！您的任务正在并行运行！”）；

但不幸的是，最后一行日志永远不会执行

有什么想法吗

---

非常感谢

好吧，我用简单的反应堆测试用例复制了它：

@Test
public void testParallelPromises() throws InterruptedException {
    Environment environment = new Environment();
    final AtomicBoolean first = new AtomicBoolean(true);
    for (int i = 0; i < 10; i++) {
        final Promise<String> promise = Promises.task(environment, () -> {
                    if (!first.getAndSet(false)) {
                        try {
                            Thread.sleep(1000);
                        }
                        catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    return "foo";
                }
        );
        String result = promise.await(10, TimeUnit.SECONDS);
        System.out.println(result);
        assertNotNull(result);
    }
}

@测试
public void TestParallelPromissions（）引发InterruptedException{
环境=新环境（）；
final AtomicBoolean first=新的AtomicBoolean（真）；
对于（int i=0；i<10；i++）{
最终承诺=承诺.任务（环境，（）->{
如果（！first.getAndSet（false））{
试一试{
睡眠（1000）；
}
捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
返回“foo”；
}
);
字符串结果=promise.await（10，TimeUnit.SECONDS）；
系统输出打印项次（结果）；
assertNotNull（结果）；
}
}

（与反应堆-2.0.6一起使用）

问题在于：

public static <T> Promise<T> task(Environment env, Supplier<T> supplier) {
    return task(env, env.getDefaultDispatcher(), supplier);
}

公共静态承诺任务（环境环境、供应商）{
返回任务（env，env.getDefaultDispatcher（），供应商）；
}

其中

DefaultDispatcher

是

RingBufferDispatcher扩展了SingleThreadDispatcher

由于

@MessagingGateway

基于请求/应答场景，因此我们正在该

RingBufferDispatcher

的线程中等待应答。由于您没有在那里返回reply（

Thread.sleep（999999）；

），我们无法接受

RingBuffer

中的下一个事件

您的

调度程序（Environment.THREAD\u POOL）

在这里没有帮助，因为它不会影响

环境。您应该考虑使用<代码> ReCurr.Debug。默认值= TycRePoLeExtor Outs/Cux>属性。类似于此文件的内容：

是的：请升级到最新的Reactor。
我几乎可以肯定我已尝试通过属性设置默认的dispatcher，明天我将首先再次测试它。无论如何，你是在建议我不应该使用MessagingGateway处理长时间的并发任务吗？非常感谢您，您可以将网关与下游ExecutorChannel一起使用，但不应将Reactor与默认的单线程
RingBufferDispatcher
一起使用。不过，它在最后一个反应堆2.1.0中是固定的，但尚未释放。