springmvc(18)使用WebSocket 和 STOMP 实现消息功能

// 当新连接建立的时候，被调用;
public void afterConnectionEstablished(WebSocketSession session)
throws Exception {
logger.info("Connection established");
}

// 当连接关闭时被调用；
@Override
public void afterConnectionClosed(
WebSocketSession session, CloseStatus status) throws Exception {
logger.info("Connection closed. Status: " + status);
}

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer{
 @Override
 public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
  registry.addHandler(getTextHandler(), "/websocket/p2ptext");
 } // 将 ChatTextHandler 处理器 映射到  /websocket/p2ptext 路径下.
 
 @Bean
 public ChatTextHandler getTextHandler() {
  return new ChatTextHandler();
 }
}

XHR streaming
XDR streaming
iFrame event source
iFrame HTML file
XHR polling
XDR polling
iFrame XHR polling
JSONP polling

// 将 ChatTextHandler 映射到 /chat/text 路径下.
 @Override
 public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
  registry.addHandler(getTextHandler(), "/websocket/p2ptext").withSockJS();
// withSockJS() 方法声明我们想要使用 SockJS 功能，如果WebSocket不可用的话，会使用 SockJS；
 }

<script src="http://cdn.sockjs.org/sockjs-0.3.min.js"></script>

var url = 'p2ptext';
var sock = new SockJS(url);

SEND
destination:/app/marco
content-length:20

{\"message\":\"Marco!\"}

package com.spring.spittr.web;

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.AbstractWebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {
  @Override
  public void configureMessageBroker(MessageBrokerRegistry config) {
      config.enableSimpleBroker("/topic", "/queue");
      config.setApplicationDestinationPrefixes("/app");
      // 应用程序以 /app 为前缀，而 代理目的地以 /topic 为前缀.
      // js.url = "/spring13/app/hello" -> @MessageMapping("/hello") 注释的方法.
  }

  @Override
  public void registerStompEndpoints(StompEndpointRegistry registry) {
      registry.addEndpoint("/hello").withSockJS();
      // 在网页上我们就可以通过这个链接 /server/hello ==<c:url value='/hello'></span> 来和服务器的WebSocket连接
  }
}

@Override
 public void configureMessageBroker(MessageBrokerRegistry registry) {
  // 启用了 STOMP 代理中继功能，并将其代理目的地前缀设置为 /topic and /queue .
  registry.enableStompBrokerRelay("/queue", "/topic")
   .setRelayPort(62623);
  registry.setApplicationDestinationPrefixes("/app"); // 应用程序目的地.
 }

package com.spring.spittr.web;

import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;

import com.spring.pojo.Greeting;
import com.spring.pojo.HelloMessage;

@Controller
public class GreetingController {
	
	@MessageMapping("/hello")
	@SendTo("/topic/greetings")
	public Greeting greeting(HelloMessage message) throws Exception {
		System.out.println("receiving " + message.getName());
		System.out.println("connecting successfully.");
		return new Greeting("Hello, " + message.getName() + "!");
	}
}

@SubscribeMapping({"/marco"})
public Shout handleSubscription() {
Shout outgoing = new Shout();
outgoing.setMessage("Polo!");
return outgoing;
}

//this line.
        function connect() {
            var socket = new SockJS("<c:url value='/hello'/>");
            stompClient = Stomp.over(socket);
            stompClient.connect({}, function(frame) {
                setConnected(true);
                console.log('Connected: ' + frame);
                stompClient.subscribe('/topic/greetings', function(greeting){
                    showGreeting(JSON.parse(greeting.body).content);
                });
                
                stompClient.subscribe('/app/macro',function(greeting){
                	alert(JSON.parse(greeting.body).content);
                	showGreeting(JSON.parse(greeting.body).content);
                });
            });
        }
        
        function sendName() {
            var name = document.getElementById('name').value;
            stompClient.send("/app/hello", {}, JSON.stringify({ 'name': name }));
        }

package com.spring.spittr.web;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.messaging.simp.SimpMessageSendingOperations;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.messaging.simp.annotation.SubscribeMapping;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import com.spring.pojo.Greeting;
import com.spring.pojo.HelloMessage;

@Controller
public class GreetingController {
	
	// @MessageMapping defines the sending addr for client.
	// 消息发送地址: /server/app/hello
	@MessageMapping("/hello")
	@SendTo("/topic/greetings")
	public Greeting greeting(HelloMessage message) throws Exception {
		System.out.println("receiving " + message.getName());
		System.out.println("connecting successfully.");
		return new Greeting("Hello, " + message.getName() + "!");
	}
	
	@SubscribeMapping("/macro")
	public Greeting handleSubscription() {
		System.out.println("this is the @SubscribeMapping('/marco')");
		Greeting greeting = new Greeting("i am a msg from SubscribeMapping('/macro').");
		return greeting;
	}
	
	/*@MessageMapping("/feed")
	@SendTo("/topic/feed")
	public Greeting greetingForFeed(HelloMessage message) throws Exception {
		System.out.println("receiving " + message.getName());
		System.out.println("connecting successfully.");
		return new Greeting("i am /topic/feed, hello " + message.getName() + "!");
	}*/

	//	private SimpMessagingTemplate  template;
	// SimpMessagingTemplate implements SimpMessageSendingOperations. 
	private SimpMessageSendingOperations  template;

    @Autowired
    public GreetingController(SimpMessageSendingOperations  template) {
        this.template = template;
    }

    @RequestMapping(path="/feed", method=RequestMethod.POST)
    public void greet(
    		@RequestParam String greeting) {
        String text = "you said just now " + greeting;
        this.template.convertAndSend("/topic/feed", text);
    }
}

package com.spring.spittr.web;

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.AbstractWebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {
  @Override
  public void configureMessageBroker(MessageBrokerRegistry config) {
      config.enableSimpleBroker("/topic", "/queue");
      config.setApplicationDestinationPrefixes("/app");
      // 应用程序以 /app 为前缀，而 代理目的地以 /topic 为前缀.
      // js.url = "/spring13/app/hello" -> @MessageMapping("/hello") 注释的方法.
  }

  @Override
  public void registerStompEndpoints(StompEndpointRegistry registry) {
      registry.addEndpoint("/hello").withSockJS();
      // 在网页上我们就可以通过这个链接 /server/hello 来和服务器的WebSocket连接
  }
}

package com.spring.spittr.web;

import java.io.IOException;

import org.springframework.context.MessageSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.support.ResourceBundleMessageSource;
import org.springframework.core.io.FileSystemResource;
import org.springframework.web.multipart.MultipartResolver;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
import org.springframework.web.servlet.view.tiles3.TilesConfigurer;
import org.springframework.web.servlet.view.tiles3.TilesViewResolver;

@Configuration
@ComponentScan(basePackages = { "com.spring.spittr.web" })
@EnableWebMvc
@Import({WebSocketConfig.class})
public class WebConfig extends WebMvcConfigurerAdapter {

	@Bean
	public TilesConfigurer tilesConfigurer() {
		TilesConfigurer tiles = new TilesConfigurer();
		tiles.setDefinitions(new String[] { "/WEB-INF/layout/tiles.xml" });
		tiles.setCheckRefresh(true);
		return tiles;
	}
	
	// config processing for static resources.
	@Override
	public void configureDefaultServletHandling(
			DefaultServletHandlerConfigurer configurer) {
		configurer.enable();
	}
	
	// InternalResourceViewResolver 
	@Bean
	public ViewResolver viewResolver1() {
		TilesViewResolver resolver = new TilesViewResolver();
		return resolver;
	}
		
	@Bean
	public ViewResolver viewResolver2() {
		InternalResourceViewResolver resolver = new InternalResourceViewResolver();
		resolver.setPrefix("/WEB-INF/views/");
		resolver.setSuffix(".jsp");
		resolver.setExposeContextBeansAsAttributes(true);
		resolver.setViewClass(org.springframework.web.servlet.view.JstlView.class);
		return resolver;
	}

	@Bean
	public MessageSource messageSource() {
		ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
		messageSource.setBasename("messages"); 
		return messageSource;
	}

	@Bean
	public MultipartResolver multipartResolver() throws IOException {
		CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
		multipartResolver.setUploadTempDir(new FileSystemResource("/WEB-INF/tmp/spittr/uploads"));
		multipartResolver.setMaxUploadSize(2097152);
		multipartResolver.setMaxInMemorySize(0);
		return multipartResolver;
	}
}

@MessageMapping("/hello")
	@SendTo("/topic/greetings") //highlight line.
	public Greeting greeting(HelloMessage message) throws Exception {
		System.out.println("receiving " + message.getName());
		System.out.println("connecting successfully.");
		return new Greeting("Hello, " + message.getName() + "!");
	}

@SubscribeMapping("/macro") // defined in Controller. attention for addr '/macro' in server.
	public Greeting handleSubscription() {
		System.out.println("this is the @SubscribeMapping('/marco')");
		Greeting greeting = new Greeting("i am a msg from SubscribeMapping('/macro').");
		return greeting;
	}

function connect() {
            var socket = new SockJS("<c:url value='/hello'/>");
            stompClient = Stomp.over(socket);
            stompClient.connect({}, function(frame) {
                setConnected(true);
                console.log('Connected: ' + frame);
                stompClient.subscribe('/topic/greetings', function(greeting){
                    showGreeting(JSON.parse(greeting.body).content);
                });
                // starting line.
                stompClient.subscribe('/app/macro',function(greeting){
                	alert(JSON.parse(greeting.body).content);
                	showGreeting(JSON.parse(greeting.body).content);
                }); // ending line. attention for addr '/app/macro' in client.
            });
        } 

<script>
var sock = new SockJS('spittr');
var stomp = Stomp.over(sock);
stomp.connect('guest', 'guest', function(frame) {
console.log('Connected');
stomp.subscribe("/topic/spittlefeed", handleSpittle); // highlight.
});
function handleSpittle(incoming) {
var spittle = JSON.parse(incoming.body);
console.log('Received: ', spittle);
var source = $("#spittle-template").html();
var template = Handlebars.compile(source);
var spittleHtml = template(spittle);
$('.spittleList').prepend(spittleHtml);
}
</script>

@Service
public class SpittleFeedServiceImpl implements SpittleFeedService {
private SimpMessageSendingOperations messaging;
@Autowired
public SpittleFeedServiceImpl(
SimpMessageSendingOperations messaging) { // 注入消息模板.
this.messaging = messaging;
}
public void broadcastSpittle(Spittle spittle) {
messaging.convertAndSend("/topic/spittlefeed", spittle); // 发送消息.
}
}

@Service
public class SpittleFeedServiceImpl implements SpittleFeedService {
private SimpMessagingTemplate messaging;
// 实现用户提及功能的正则表达式
private Pattern pattern = Pattern.compile("\\@(\\S+)"); 

@Autowired
public SpittleFeedServiceImpl(SimpMessagingTemplate messaging) {
this.messaging = messaging;
}
public void broadcastSpittle(Spittle spittle) {
messaging.convertAndSend("/topic/spittlefeed", spittle);
Matcher matcher = pattern.matcher(spittle.getMessage());
if (matcher.find()) {
String username = matcher.group(1);
// 发送提醒给用户.
messaging.convertAndSendToUser(  
username, "/queue/notifications",
new Notification("You just got mentioned!"));
}
}
}

@MessageExceptionHandler
public void handleExceptions(Throwable t) {
logger.error("Error handling message: " + t.getMessage());
}

@MessageExceptionHandler(SpittleException.class) // highlight line.
public void handleExceptions(Throwable t) {
logger.error("Error handling message: " + t.getMessage());
}
// 或者：
@MessageExceptionHandler( {SpittleException.class, DatabaseException.class})  // highlight line.
public void handleExceptions(Throwable t) {
logger.error("Error handling message: " + t.getMessage());
}

@MessageExceptionHandler(SpittleException.class)
@SendToUser("/queue/errors")
public SpittleException handleExceptions(SpittleException e) {
logger.error("Error handling message: " + e.getMessage());
return e;
}
// 如果抛出 SpittleException 的话，将会记录这个异常，并将其返回.
// 而 UserDestinationMessageHandler 会重新路由这个消息到特定用户所对应的 唯一路径；