integración del resorte enrutamiento a subflujo en diferente clase

Dragutin Vujovic:

Estoy luchando por un par de días para hacer este trabajo. Lo que estoy tratando de lograr es llamar a diferentes flujos parciales (que son el flujo de Integración), desde el flujo principal, con base en el contenido del mensaje y después de acabados Subflow para volver al flujo principal. Su responsabilidad delegación como a una clase específica a fin de algo y al retorno a la corriente principal. Que la responsabilidad también puede requerir algunos pasos, por lo que su flujo implementado como así. Aquí está mi flujo principal:

public IntegrationFlow processingFlow(
  MessageChannel eventIn,
  MessageChannel eventOut,
  ChangedEventsLoader changedEventsLoader,
  CalculatorRouter calculatorRouter) {

return IntegrationFlows.from(eventIn)
    .handle(changedEventsLoader)
    .route(
        CalculatorRouter::getSportId,
        CalculatorRouter::routeCalculation)
    .channel(eventOut)
    .get();

}

Aquí está la implementación del enrutador:

@Service
@AllArgsConstructor
public class CalculatorRouter {
  private final MessageChannel eventOut;

  public RouterSpec<Integer, MethodInvokingRouter> routeCalculation(
      RouterSpec<Integer, MethodInvokingRouter> mapping) {
    return mapping
        .channelMapping(1, "subflowCalculationChannel")
        .defaultOutputToParentFlow();
  }

  public Integer getSportId(Event event) {
    return 1;
  }

  @Bean
  public MessageChannel subflowCalculationChannel() {
    return MessageChannels.direct().get();
  }
}

y aquí es un ejemplo de una corriente parcial:

@Configuration
@AllArgsConstructor
public class CalculatorExample {

  @Bean
  public IntegrationFlow calculateProbabilities(MessageChannel subflowCalculationChannel) {
    return IntegrationFlows.from(subflowCalculationChannel)
        .<Event>handle((p, m) -> p * 2)
        .get();
  }
}

El problema es que subflujo se pierda alguna conexión con el flujo principal. Traté de resolver que mediante el uso defaultOutputToParentFlow () en la parte de enrutamiento, pero eso no es suficiente.

Arteta:

A partir de una cierta versión hemos tomado la decisión de alinear el comportamiento del router DSL de Java con la configuración estándar con anotaciones o XML. Por lo tanto, si enviamos al router, no podemos esperar que responder desde allí. Podemos continuar sólo con el canal como una salida de flujos secundarios.

En el caso de tener una .channel(eventOut)en el flujo principal. Por lo tanto, todos sus sub-flujos de enrutamiento deben responder exactamente a este canal:

    .<Event>handle((p, m) -> corners1H2HCustomBet.getCalculation(p))
    .channel(eventOut)
    .get();

Creo que .defaultOutputToParentFlow();simplemente no tiene nada para usted, porque usted no tiene una asignación predeterminada. Y es que ya es historia ligeramente diferente: no tiene ningún efecto para otras asignaciones.

También debe prestar atención a este JavaDoc:

/**
 * Add a subflow as an alternative to a {@link #channelMapping(Object, String)}.
 * {@link #prefix(String)} and {@link #suffix(String)} cannot be used when subflow
 * mappings are used.
 * <p> If subflow should refer to the external {@link IntegrationFlow} bean and
 * there is a requirement to expect reply from there, such a reference should be
 * wrapped with a {@code .gateway()}:
 * <pre class="code">
 * {@code
 *     .subFlowMapping(false, sf -> sf.gateway(evenFlow())))
 * }
 * </pre>
 * @param key the key.
 * @param subFlow the subFlow.
 * @return the router spec.
 */
public RouterSpec<K, R> subFlowMapping(K key, IntegrationFlow subFlow) {

No se relaciona con la configuración de enrutamiento basado en canales, pero puede ser útil en el futuro.

ACTUALIZAR

Aquí está una muestra (Kotlin) para subFlowMappingy volver al flujo principal:

    @Bean
    fun splitRouteAggregate() =
            IntegrationFlow { f ->
                f.split()
                        .route<Int, Boolean>({ o -> o % 2 == 0 },
                                { m ->
                                    m.subFlowMapping(true) { sf -> sf.gateway(oddFlow()) }
                                            .subFlowMapping(false) { sf -> sf.gateway(evenFlow()) }
                                })
                        .aggregate()
            }

    @Bean
    fun oddFlow() =
            IntegrationFlow { flow ->
                flow.handle<Any> { _, _ -> "odd" }
            }

    @Bean
    fun evenFlow() =
            IntegrationFlow { flow ->
                flow.handle<Any> { _, _ -> "even" }
            }