Spring Websocket + SockJS + STOMP 실시 간 통신 실현 (4) - MessageHandler

목차

Message Handler 의 역할

Message Handler 실현 클래스

두 가지 Message Handler 는 어떤 차이 가 있 습 니까?

Message Handler 의 역할
지난 절 에서 우 리 는 ExecutorSubscribableChannel 클래스 가 하나의 인 스 턴 스 handlers 인 Message Handler 집합 을 가지 고 있 으 며 Message Channel 의 구독 자 이 며 Messages 를 처리 하 는 약속 으로 사용 된다 고 언급 한 적 이 있다.
Message Handler 는 하나의 인터페이스 입 니 다. 그 실현 클래스 는 반드시 실현 해 야 하 는 방법 입 니 다. handle Message (Message > message) 는 메시지 Message 를 처리 하 는 데 사 용 됩 니 다. 외부 에서 받 거나 응용 프로그램 내부 에서 전달 되 는 것 입 니 다.

/**
 * Contract for handling a {@link Message}.
 *
 * @author Mark Fisher
 * @author Iwein Fuld
 * @since 4.0
 */

     
      public
      
     
      interface
      
     
      MessageHandler
      {
	/**
	 * 
     
      Handle
      
     
      the
      
     
      given
      
     
      message
     .
	 * @param 
     
      message
      
     
      the
      
     
      message
      to be 
     
      handled
     
	 */
	
     
      void
      
     
      handleMessage
     (Message<?> message) 
     
      throws
      MessagingException;
}

메시지 핸들 러 구현 클래스
Message Handler 의 구체 적 인 실현 유형 은 모두 로 서로 다른 유형의 Message 를 처리 하 는 데 사용 된다.

미 실현 org.springframework.context.SmartLifecycle 인터페이스

UserRegistryMessageHandler

NoOpMessageHandler

실현 org.springframework.context.SmartLifecycle 인터페이스

SubProtocolWebSocketHandler

SimpAnnotationMethodMessageHandler

WebSocketAnnotationMethodMessageHandler

NoOpBrokerMessageHandler

SimpleBrokerMessageHandler

StompBrokerRelayMessageHandler

UserDestinationMessageHandler

두 가지 Message Handler 는 어떤 차이 가 있 습 니까?

먼저 org.springframework.context.SmartLifecycle 인터페이스 인 스마트 라 이 프 사이클 을 살 펴 보면 org.springframework.context.Lifecycle 과 org.springframework.context.Phased 의 확장 이다.솔직히 말 하면 SmartLifeCycle 인 터 페 이 스 를 실현 하면 언제든지 Bean 가 처 한 생명 주 기 를 판단 할 수 있 고 지 정 된 방법 으로 지 정 된 생명 주기 를 실현 할 수 있다.

SmartLifecycle :
 
     
      public
      
     
      interface
      
     
      SmartLifecycle
      
     
      extends
      
     
      Lifecycle
     , Phased {
   
     
      boolean
      
     
      isAutoStartup
     ();
   
     
      void
      
     
      stop
     (Runnable callback);
}

가 져 오기 AbstractBrokerMessageHandler 의 경우 NoOpBrokerMessage Handler, Simple BrokerMessage Handler, StompBrokerRelay Message Handler 의 부모 인터페이스 로 SmartLifecycle 실현 되 었 고 start (), stop () 방법 에서 각각 관련 MessageChannel 과 을 실현 했다.

여기 서 우 리 는 SmartLifecycle 인 터 페 이 스 를 실현 하지 못 하 는 Message Handler 는 Message Channel 을 연결 하지 않 아 도 되 고 다른 하 나 는 지정 한 수명 주기 에 Message Channel 을 구독 하거나 구독 하 는 데 사용 된다 는 것 을 알 수 있다.

AbstractBrokerMessageHandler:

     
      public
      
     
      abstract
      
     
      class
      
     
      AbstractBrokerMessageHandler
     
   	
     
      implements
      
     
      MessageHandler
     , ApplicationEventPublisherAware, SmartLifecycle {
   @Override
   
     
      public
      
     
      boolean
      
     
      isAutoStartup
     () {
   	
     
      return
      
     
      this
     .autoStartup;
   }
   @Override
   
     
      public
      int 
     
      getPhase
     () {
   	
     
      return
      Integer.MAX_VALUE;
   }
   @Override
   
     
      public
      
     
      void
      
     
      start
     () {
   	
     
      synchronized
      (
     
      this
     .lifecycleMonitor) {
   		logger.
     
      info
     ("Starting...");
   		
     
      this
     .clientInboundChannel.
     
      subscribe
     (
     
      this
     );
   		
     
      this
     .brokerChannel.
     
      subscribe
     (
     
      this
     );
   		if (
     
      this
     .clientInboundChannel 
     
      instanceof
      
     
      InterceptableChannel
     ) {
   			((InterceptableChannel) 
     
      this
     .clientInboundChannel).
     
      addInterceptor
     (0, 
     
      this
     .unsentDisconnectInterceptor);
   		}
   		
     
      startInternal
     ();
   		
     
      this
     .running = 
     
      true
     ;
   		logger.
     
      info
     ("Started.");
   	}
   }
   @Override
   
     
      public
      
     
      void
      
     
      stop
     () {
   	
     
      synchronized
      (
     
      this
     .lifecycleMonitor) {
   		logger.
     
      info
     ("Stopping...");
   		
     
      stopInternal
     ();
   		
     
      this
     .clientInboundChannel.
     
      unsubscribe
     (
     
      this
     );
   		
     
      this
     .brokerChannel.
     
      unsubscribe
     (
     
      this
     );
   		if (
     
      this
     .clientInboundChannel 
     
      instanceof
      
     
      InterceptableChannel
     ) {
   			((InterceptableChannel) 
     
      this
     .clientInboundChannel).
     
      removeInterceptor
     (
     
      this
     .unsentDisconnectInterceptor);
   		}
   		
     
      this
     .running = 
     
      false
     ;
   		logger.
     
      info
     ("Stopped.");
   	}
   }
   @Override
   
     
      public
      
     
      final
      
     
      void
      
     
      stop
     (Runnable callback) {
   	
     
      synchronized
      (
     
      this
     .lifecycleMonitor) {
   		
     
      stop
     ();
   		callback.run();
   	}
   }
   @Override
   
     
      public
      
     
      final
      
     
      boolean
      
     
      isRunning
     () {
   	
     
      return
      
     
      this
     .running;
   }
}