0 運(yùn)行環(huán)境及主要工具類簡(jiǎn)要說明

• 基于Spring Boot環(huán)境

• 由于@ServerEndPoint的實(shí)現(xiàn)方式中無(wú)法直接使用@Autowired之類的注解直接注入業(yè)務(wù)相關(guān)的Bean宣决，所有實(shí)現(xiàn)了一個(gè)甚至WebApplicationContext獲取Bean的一個(gè)工具類蘸劈，具體代碼如下

  package cn.xue.common;
  import org.springframework.beans.BeansException;
  import org.springframework.context.ApplicationContext;
  
  public class SpringContextUtil {
  
      private static ApplicationContext applicationContext = null;
  
      public static void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
          if(SpringContextUtil.applicationContext == null){
              SpringContextUtil.applicationContext  = applicationContext;
          }
      }
  
      //獲取applicationContext
      public static ApplicationContext getApplicationContext() {
          return applicationContext;
      }
  
      //通過name獲取 Bean.
      public static Object getBean(String name){
          return getApplicationContext().getBean(name);
  
      }
  
      //通過class獲取Bean.
      public static <T> T getBean(Class<T> clazz){
          return getApplicationContext().getBean(clazz);
      }
  
      //通過name,以及Clazz返回指定的Bean
      public static <T> T getBean(String name,Class<T> clazz){
          return getApplicationContext().getBean(name, clazz);
      }
  
  }
  

  并在主函數(shù)中將ApplicationContext傳給上述的工具類中，代碼如下 ：

  @SpringBootApplication
  public class MainApplication {
      public static void main(String[] args) {
          ApplicationContext app = SpringApplication.run(MainApplication.class, args);
          SpringContextUtil.setApplicationContext(app);
      }
  }
  
  

1 基于@ServerEndPoint注解的實(shí)現(xiàn)

• 需要在@Configuration注解的類中注入ServerEndpointExporter

    @Bean
      public ServerEndpointExporter serverEndpointExporter() {
          return new ServerEndpointExporter();
      }
  

• Configurator類實(shí)現(xiàn)

  package cn.xue.config;
  
  import cn.xue.common.Constants;
  import cn.xue.common.SpringContextUtil;
  import cn.xue.model.user.User;
  import cn.xue.service.user.UserService;
  
  import javax.servlet.annotation.WebListener;
  import javax.websocket.HandshakeResponse;
  import javax.websocket.server.HandshakeRequest;
  import javax.websocket.server.ServerEndpointConfig;
  
  @WebListener
  public class WebSocketSessionConfigurator extends ServerEndpointConfig.Configurator {
      @SuppressWarnings("unchecked")
      @Override
      public void modifyHandshake(ServerEndpointConfig config, HandshakeRequest request, HandshakeResponse response) {
          Long userId = Long.parseLong(request.getParameterMap().get("userId").get(0).toString());
          String password = request.getParameterMap().get("password").get(0);
          UserService userService = (UserService) SpringContextUtil.getBean(UserService.class);
          User user = userService.getUserById(userId);
          if(null != user && user.getPassword().equals(password)){
              config.getUserProperties().put(Constants.WEBSOCKET_USER, user);
          }else{
              return;
          }
      }
  }
  
  

  簡(jiǎn)述：上述代碼中主要作用是為了截取Socket連接請(qǐng)求中的請(qǐng)求參數(shù)疲扎，用以進(jìn)行簡(jiǎn)單的身份校驗(yàn)昵时，如果校驗(yàn)通過將用戶信息存放于Session的UserProperties中，這樣在Socket連接后可以從Session中獲取到用戶信息

• 具體實(shí)現(xiàn)椒丧，代碼如下：

  package cn.xue.controller.socket;
  
  import cn.xue.common.Constants;
  import cn.xue.common.SpringContextUtil;
  import cn.xue.model.socket.Message;
  import cn.xue.model.user.User;
  import cn.xue.service.user.UserService;
  import com.alibaba.fastjson.JSONObject;
  import org.apache.log4j.Logger;
  
  import javax.websocket.*;
  import javax.websocket.server.ServerEndpoint;
  import java.io.IOException;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  @Component
  @ServerEndpoint(value = "/ChatEndPoint", configurator = WebSocketSessionConfigurator.class)
  public class WebSocketHandler {
      private final static Logger logger = Logger.getLogger(WebSocketHandler.class);
      @Autowired
      private RedisService redisService;
  
      private static final Map<Long, Session> users;
      static {
         users = new ConcurrentHashMap<Long, Session>();
      }
      @OnOpen
      public void onOpen(EndpointConfig conf, Session session) {
          User user = (User) conf.getUserProperties().get(Constants.WEBSOCKET_USER);
          if(user != null) {
              logger.info(user.getNickName() + "連接成功");
              users.put(user.getId(), session);
          } else {
              try {
                  session.close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      }
      @OnMessage
      public void handleMessage(Session session, String message) {
          sendMessage(JSONObject.parseObject(message, Message.class));
      }
  
      public static boolean sendMessage(Message message) {
          Session session = users.get(message.getDesUserId());
          if (session == null) {
              return false;
          }
          session.getAsyncRemote().sendText(JSONObject.toJSONString(message), new SendHandler() {
              @Override
              public void onResult(SendResult result) {
                  if (!result.isOK()) {
                      users.remove(message.getDesUserId());
                      try {
                          session.close();
                      } catch (IOException e) {
                      }
                  }
              }
          });
          return true;
      }
  
      @OnError
      public void error(Session session, java.lang.Throwable throwable) {
          if (throwable.getMessage() != null) {
              onClose(session);
          }
      }
      @OnClose
      public void onClose(Session session) {
          try {
              session.close();
              User user = (User) session.getUserProperties().get(Constants.WEBSOCKET_USER);
              users.remove(user.getId());
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  
  }
  
  

  代碼內(nèi)容簡(jiǎn)述：

  • 請(qǐng)關(guān)注@ServerEndPoint的configurator配置壹甥，其作用即在于在發(fā)起socket連接請(qǐng)求時(shí)，請(qǐng)求會(huì)首先經(jīng)由WebSocketSessionConfigurator類中的modifyHandshake處理壶熏，并將用戶身份校驗(yàn)的結(jié)果置于session的UserProperties中
  • 在本類中@OnOpen中句柠，即可根據(jù)前一步處理結(jié)果查看是否能拿到用戶信息，如果不能則表示連接非法棒假，直接關(guān)閉連接
  • 其他像@OnMessage @OnClose等具體功能這里就略過
  • 另外代碼中Message是一個(gè)自定義實(shí)體

2 基于Spring WebSocket的實(shí)現(xiàn)

• 定義WebSocket握手?jǐn)r截器溯职，用以進(jìn)行用戶連接過程中的身份校驗(yàn)，代碼如下：

  package cn.xue.interceptor.socket;
  
  import cn.xue.common.Constants;
  import cn.xue.model.user.User;
  import cn.xue.service.user.UserService;
  import org.apache.log4j.Logger;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.http.server.ServerHttpRequest;
  import org.springframework.http.server.ServerHttpResponse;
  import org.springframework.http.server.ServletServerHttpRequest;
  import org.springframework.stereotype.Component;
  import org.springframework.web.socket.WebSocketHandler;
  import org.springframework.web.socket.server.HandshakeInterceptor;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpSession;
  import java.util.Map;
  
  @Component
  public class WebSocketInterceptor implements HandshakeInterceptor {
      private final Logger logger = Logger.getLogger(getClass());
      @Autowired
      private UserService userService;
  
      @Override
      public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Map<String, Object> attributes) throws Exception {
          if (request instanceof ServletServerHttpRequest) {
              HttpServletRequest httpServletRequest = ((ServletServerHttpRequest) request).getServletRequest();
              HttpSession session = httpServletRequest.getSession();
              Long userId = Long.parseLong(httpServletRequest.getParameter("userId").toString());
              String password = httpServletRequest.getParameter("password");
              User user = userService.getUserById(userId);
              if(null != user && user.getPassword().equals(password)) {
                  attributes.put(Constants.WEBSOCKET_USER, user);
                  logger.info(user.getNickName() + "連接并驗(yàn)證成功");
                  return true;
              }
          }
          return false;
      }
      @Override
      public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {
  
      }
  }
  
  

  代碼簡(jiǎn)述：在上述代碼中beforeHandshake方法中截取soket連接請(qǐng)求參數(shù)并進(jìn)行身份校驗(yàn)帽哑，如果校對(duì)失敗返回false谜酒，也即意味著無(wú)法繼續(xù)握手過程，從而連接失敗

• 定義Socket處理類

  package cn.xue.service.socket;
  
  import cn.xue.common.Constants;
  import cn.xue.model.socket.Message;
  import cn.xue.model.user.User;
  import cn.xue.service.redis.RedisService;
  import com.alibaba.fastjson.JSONObject;
  import com.gexin.fastjson.JSON;
  import org.apache.log4j.Logger;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Service;
  import org.springframework.web.socket.*;
  
  import java.io.IOException;
  import java.nio.ByteBuffer;
  import java.nio.CharBuffer;
  import java.nio.charset.Charset;
  import java.nio.charset.CharsetDecoder;
  import java.util.Map;
  import java.util.Set;
  import java.util.concurrent.ConcurrentHashMap;
  
  
  @Service
  public class SocketService implements WebSocketHandler {
      private static final Logger logger = Logger.getLogger(SocketService.class);
      //在線用戶列表
      private static final Map<Long, WebSocketSession> users;
      static {
          users = new ConcurrentHashMap<>();
      }
      @Override
      public void afterConnectionEstablished(WebSocketSession session) throws Exception {
          User user = (User) session.getAttributes().get(Constants.WEBSOCKET_USER);
          if (user != null) {
              users.put(user.getId(), session);
              session.sendMessage(new TextMessage("成功建立socket連接"));
              logger.info(user + "成功連接妻枕！");
          }
          logger.info("當(dāng)前在線人數(shù)："+users.size());
      }
  
      //接收socket信息
      @Override
      public void handleMessage(WebSocketSession webSocketSession, WebSocketMessage<?> webSocketMessage) throws Exception {
          try{
              if(webSocketMessage instanceof TextMessage) {
                  Message object = JSONObject.parseObject(((TextMessage) webSocketMessage).getPayload(), Message.class);
                  sendMessageToUser(object);
              } else if(webSocketMessage instanceof BinaryMessage) {
                  Charset charset = null;
                  CharsetDecoder decoder = null;
                  CharBuffer charBuffer = null;
                  try {
                      charset = Charset.forName("UTF-8");
                      decoder = charset.newDecoder();                    
                      charBuffer = decoder.decode((ByteBuffer) webSocketMessage.getPayload());
                      System.out.println(charBuffer.toString());
                  } catch (Exception ex) {
                      ex.printStackTrace();
                  }
              }
          }catch(Exception e){
              e.printStackTrace();
          }
  
      }
  
      /**
       * 發(fā)送信息給指定用戶n
       */
      public boolean sendMessageToUser(Message message) {
          Long userId = message.getSrcUserId();
          if (users.get(userId) == null) {
              //消息接收者不在線
  
              return false;
          }
          //消息接收者在線 直接發(fā)送
          WebSocketSession session = users.get(userId);
          if (!session.isOpen()) return false;
          try {
              session.sendMessage(new TextMessage(JSON.toJSONString(message)));
          } catch (IOException e) {
              e.printStackTrace();
              return false;
          }
          return true;
      }
  
      /**
       * 廣播信息
       * @param message
       * @return
       */
      public boolean sendMessageToAllUsers(TextMessage message) {
          boolean allSendSuccess = true;
          Set<Long> clientIds = users.keySet();
          WebSocketSession session = null;
          for (Long clientId : clientIds) {
              try {
                  session = users.get(clientId);
                  if (session.isOpen()) {
                      session.sendMessage(message);
                  }
              } catch (IOException e) {
                  e.printStackTrace();
                  allSendSuccess = false;
              }
          }
          return allSendSuccess;
      }
  
  
      @Override
      public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
          if (session.isOpen()) {
              session.close();
          }
          System.out.println("連接出錯(cuò)");
          users.remove(getUserId(session));
      }
  
      @Override
      public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
          System.out.println("連接已關(guān)閉：" + status);
          users.remove(getUserId(session));
      }
  
      @Override
      public boolean supportsPartialMessages() {
          return false;
      }
  
      /**
       * 獲取用戶標(biāo)識(shí)
       * @param session
       * @return
       */
      private Long getUserId(WebSocketSession session) {
          try {
              User user = (User) session.getAttributes().get(Constants.WEBSOCKET_USER);
              return user != null ? user.getId() : null;
          } catch (Exception e) {
              return null;
          }
      }
  }
  

  代碼簡(jiǎn)述：

  • 上述實(shí)現(xiàn)類是直接實(shí)現(xiàn)了spring-websocket的提供的接口
  • afterConnectionEstablished方法功能在于將前一步攔截器處理驗(yàn)證后將用戶和用戶所使用的連接存入緩存僻族，其功能和@ServerEndPoint實(shí)現(xiàn)類中的onOpen()完成的內(nèi)容基本一致
  • handleMessage方法作用在于接收用戶發(fā)來(lái)的消息，其功能與@ServerEndPoint實(shí)現(xiàn)類中的onMessage()完成的內(nèi)容基本一致

• WebSocket配置屡谐，代碼如下：

  package cn.xue.config;
  
  import cn.xue.interceptor.socket.WebSocketInterceptor;
  import cn.xue.service.socket.SocketService;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.web.socket.config.annotation.*;
  
  import javax.annotation.Resource;
  
  @Configuration
  @EnableWebSocket
  public class WebSocketConfig implements WebSocketConfigurer {
      @Resource
      private SocketService socketService;
      @Autowired
      private WebSocketInterceptor webSocketInterceptor;
  
      @Override
      public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
          registry.addHandler(socketService, "/ChatServer").setAllowedOrigins("*").addInterceptors(webSocketInterceptor);
      }
  }
  

  代碼簡(jiǎn)述：上述代碼實(shí)現(xiàn)spring-websocket中的WebSocketConfigurer方法述么，為指定的WebSocket連接路徑添加處理器和攔截器

3 總結(jié)

綜合以上內(nèi)容，可以認(rèn)為2種實(shí)現(xiàn)方式是完全可以相互對(duì)比愕掏，可以相互替代度秘，而且在實(shí)現(xiàn)思想上也基本一致。如：

• @ServerEndPoint的作用可以類比于WebSocketConfigurer的使用饵撑，都是指定了Socket的處理器和前置處理器
• Spring-WebSocket中的攔截器的作用可以類比于@ServerEndPoint實(shí)現(xiàn)方式中的EndPointConfigurer
• 2個(gè)種實(shí)現(xiàn)方式的處理器就更不用多說了剑梳，形不同唆貌，但質(zhì)相同。