[JAVA] So wenden Sie HandlerInterceptor auf das http-Inbound-Gateway von Spring Integration an

Ich spiele gerade mit Spring Integration bei der Arbeit und verwende einen Bean-definierten Handler (HttpRequestHandlingMessagingGateway) mit Http.inboundGateway (Java DSL) oder <http-int: inbound-gateway> `(XML-Namespace). Ich war ein wenig beunruhigt, weil ich Spring MVCs "HandlerInterceptor" nicht auf ") anwenden konnte, aber ich fand heraus, wie ich es anwenden kann, nachdem ich der Quelle von" IntegrationRequestMappingHandlerMapping "gefolgt war.

Im Frühjahr Integration

Bean-Definitionsbeispiel für einen Handler mit JavaDSL

@Bean
public IntegrationFlow greetingInboundGatewayFlow(MessageChannel httpInboundChannel) {
  return IntegrationFlows.from(Http.inboundGateway("/greeting")
      .requestMapping(mapping -> mapping.methods(HttpMethod.GET))
      .requestChannel(httpInboundChannel)
  ).get();
}

Bean-Definitionsbeispiel für einen Handler mit XML-Namespace

<http-int:inbound-gateway
    path="/greeting" supported-methods="GET"
    request-channel="httpRequestChannel"/>

Durch Definieren einer Bean wie

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RequestMapping("/greeting")
@RestController
public class GreetingRestController {
  @GetMapping
  public String greeting() {
    // ...
    return responseMessage;
  }
}

Sie können denselben Endpunkt veröffentlichen, als Sie den Controller erstellt haben.

Mit einem normalen Spring MVC (@ RequestMapping-basierter Handler) ...

Wenn Sie einen Stil haben, der die @ RequestMapping-Methode in der Controller-Klasse implementiert, können Sie den HandlerInterceptor anwenden, indem Sie die folgende Bean definieren.

Bean-Definitionsbeispiel von JavaConfig

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MessageLoggingHandlerInterceptor())
                .addPathPatterns("/**") //Anwendbarer Pfad(Muster)Konkretisieren
                .excludePathPatterns("/static/**"); //Auszuschließende Pfade(Muster)Konkretisieren
    }
}

Beispiel für eine Bean-Definition per XML

<mvc:interceptors>
  <mvc:interceptor>
    <mvc:mapping path="/**"/>
    <mvc:exclude-mapping path="/static/**"/>
    <bean class="com.example.MessageLoggingHandlerInterceptor"/>
  </mvc:interceptor>
</mvc:interceptors>

Mit http Inbound-Gateway von Spring Integration ...

Handler, die mit dem http-Inbound-Gateway von Spring Integration definiert wurden, verwalten Anforderungszuordnungen getrennt von regulären Spring-MVCs. Insbesondere wird die Anforderungszuordnung in einer Bean verwaltet, die aus einer Klasse namens "IntegrationRequestMappingHandlerMapping" erstellt wurde, und die in der Bean von "IntegrationRequestMappingHandlerMapping" verwaltete Bean wird auf "HandlerInterceptor" angewendet.

So wenden Sie "HandlerInterceptor" auf das http-Inbound-Gateway von Spring Integration an ...

IntegrationRequestMappingHandlerMapping (um genau zu sein, AbstractHandlerMapping, die übergeordnete Klasse von IntegrationRequestMappingHandlerMapping) ist vom DI-Container zu HandlerInterceptor (um genau zu sein, MappedInterceptor, derHandlerInterceptor und "Pfad" und "Ausschluss" enthält. ) Wird automatisch erkannt, Sie müssen also nur die Bean für HandlerInterceptor definieren.

Bean-Definitionsbeispiel von JavaConfig

@Bean
public MappedInterceptor customHandlerInterceptor() {
  return new MappedInterceptor(
      new String[]{"/**"},
      new String[]{"/static/**"},
      new MessageLoggingHandlerInterceptor());
}

Beispiel für eine Bean-Definition per XML

<bean class="org.springframework.web.servlet.handler.MappedInterceptor">
  <constructor-arg name="includePatterns" value="/**"/>
  <constructor-arg name="excludePatterns" value="/static/**"/>
  <constructor-arg name="interceptor">
    <bean class="com.example.MessageLoggingHandlerInterceptor"/>
  </constructor-arg>
</bean>

Bean-Definition von JavaConfig

@Bean
public IntegrationRequestMappingHandlerMapping integrationRequestMappingHandlerMapping() { //Der Bean-Name muss integrationRequestMappingHandlerMapping sein
  IntegrationRequestMappingHandlerMapping mapping = new IntegrationRequestMappingHandlerMapping();
  mapping.setOrder(0); //Reihenfolge muss 0 sein
  mapping.setInterceptors( //Fügen Sie Mapped Interceptor in der Reihenfolge hinzu, in der Sie es anwenden möchten
      new MappedInterceptor(new String[] {"/**"}, new String[] {"/static/**"},
          new CustomHandlerInterceptor()),
      new MappedInterceptor(new String[] {"/**"}, new String[] {"/static/**"},
          new MessageLoggingHandlerInterceptor()));
  return mapping;
}

Beispiel für eine Bean-Definition per XML

<bean id="integrationRequestMappingHandlerMapping"
      class="org.springframework.integration.http.inbound.IntegrationRequestMappingHandlerMapping">
  <property name="order" value="0"/>
  <property name="interceptors">
    <array>
      <bean class="org.springframework.web.servlet.handler.MappedInterceptor">
        <constructor-arg name="includePatterns" value="/**"/>
        <constructor-arg name="excludePatterns" value="/static/**"/>
        <constructor-arg name="interceptor">
          <bean class="com.example.CustomHandlerInterceptor"/>
        </constructor-arg>
      </bean>
      <bean class="org.springframework.web.servlet.handler.MappedInterceptor">
        <constructor-arg name="includePatterns" value="/**"/>
        <constructor-arg name="excludePatterns" value="/static/**"/>
        <constructor-arg name="interceptor">
          <bean class="com.example.MessageLoggingHandlerInterceptor"/>
        </constructor-arg>
      </bean>
    </array>
  </property>
</bean>

Zusammenfassung

Wenn Sie einen Endpunkt für HTTP veröffentlichen möchten, können Sie einen Controller normal erstellen! !! Da in dem Projekt, an dem ich gerade arbeite, andere Protokolle als HTTP unterstützt werden müssen, versuche ich, die Architektur der systemübergreifenden Zusammenarbeit mithilfe von Spring Integration anzupassen. Grundsätzlich denke ich darüber nach, in der Welt der Spring-Integration eine gemeinsame Verarbeitung durchzuführen, aber einige Verarbeitungen (Ausgabe des Kommunikationsprotokolls usw.) scheinen vor dem Eintritt in die Welt der Spring-Integration durchgeführt werden zu müssen HandlerInterceptor` Es fühlt sich an, als hätte ich es versucht.