[JAVA] Comment appliquer HandlerInterceptor à la passerelle entrante http de Spring Integration

Je joue avec Spring Integration au travail en ce moment, et j'utilise un gestionnaire défini par Bean (HttpRequestHandlingMessagingGateway) en utilisant Http.inboundGateway (Java DSL) ou <http-int: inbound-gateway> (espace de noms XML). J'étais un peu troublé parce que je ne pouvais pas appliquer HandlerInterceptor de Spring MVC à), mais j'ai découvert comment l'appliquer après avoir suivi la source de ʻIntegrationRequestMappingHandlerMapping`.

Dans Spring Integration

Exemple de définition de bean d'un gestionnaire utilisant JavaDSL

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

Exemple de définition de bean d'un gestionnaire utilisant un espace de noms XML

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

En définissant un bean tel que

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;
  }
}

Vous pouvez publier le même point de terminaison que lorsque vous avez créé le contrôleur.

Avec un Spring MVC normal (Handler basé sur @ RequestMapping) ...

Si vous avez un style qui implémente la méthode @ RequestMapping dans la classe Controller, vous pouvez appliquer le HandlerInterceptor en définissant le Bean suivant.

Exemple de définition de bean par JavaConfig

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MessageLoggingHandlerInterceptor())
                .addPathPatterns("/**") //Chemin applicable(modèle)Spécifier
                .excludePathPatterns("/static/**"); //Chemins à exclure(modèle)Spécifier
    }
}

Exemple de définition de bean par XML

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

Avec la passerelle entrante http de Spring Integration ...

Les gestionnaires définis à l'aide de la passerelle entrante HTTP Spring Integration gèrent les mappages de demandes séparément des MVC Spring standard. Plus précisément, le mappage des requêtes est géré dans un bean créé à partir d'une classe appelée ʻIntegrationRequestMappingHandlerMapping, et celui géré dans le bean de ʻIntegrationRequestMappingHandlerMapping est appliqué à HandlerInterceptor.

Pour appliquer HandlerInterceptor à la passerelle entrante http de Spring Integration ...

ʻIntegrationRequestMappingHandlerMapping (pour être exact, ʻAbstractHandlerMapping, qui est la classe parente de ʻIntegrationRequestMappingHandlerMapping) aHandlerInterceptor(pour être exact,HandlerInterceptor et" Apply path "et" Exclude path "holding MappedInterceptor. ) Est automatiquement détecté, il vous suffit donc de définir le Bean pour HandlerInterceptor.

Exemple de définition de bean par JavaConfig

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

Exemple de définition de bean par 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>

Cependant ... Si vous avez besoin de définir plusieurs HanderInterceptor et de contrôler l'ordre des applications, il n'y a aucune garantie que l'ordre de définition du bean = ordre de l'application, définissez donc le Bean de ʻIntegrationRequestMappingHandlerMapping et explicitement HanderInterceptor Vous devez spécifier `.

Définition du bean par JavaConfig

@Bean
public IntegrationRequestMappingHandlerMapping integrationRequestMappingHandlerMapping() { //Le nom du bean doit être integrationRequestMappingHandlerMapping
  IntegrationRequestMappingHandlerMapping mapping = new IntegrationRequestMappingHandlerMapping();
  mapping.setOrder(0); //l'ordre doit être égal à 0
  mapping.setInterceptors( //Ajouter un intercepteur mappé dans l'ordre dans lequel vous souhaitez appliquer
      new MappedInterceptor(new String[] {"/**"}, new String[] {"/static/**"},
          new CustomHandlerInterceptor()),
      new MappedInterceptor(new String[] {"/**"}, new String[] {"/static/**"},
          new MessageLoggingHandlerInterceptor()));
  return mapping;
}

Exemple de définition de bean par 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>

Résumé

Si vous souhaitez publier un point de terminaison pour HTTP, vous pouvez créer un contrôleur normalement! !! Cependant, comme il est nécessaire de prendre en charge des protocoles autres que HTTP dans le projet sur lequel je travaille actuellement, j'essaie de faire correspondre l'architecture de la coopération inter-système à l'aide de Spring Integration. Fondamentalement, je pense faire un traitement commun dans le monde de Spring Integration, mais certains traitements (sortie du journal de communication, etc.) semblent devoir être effectués avant d'entrer dans le monde de Spring Integration, donc HandlerInterceptor J'ai l'impression de l'avoir essayé.