zoukankan      html  css  js  c++  java
  • Java后台使用Websocket教程

    在开发一个项目的时候使用到了WebSocket协议

    1. 什么是WebSocket?  

          WebSocket使得客户端和服务器之间的数据交换变得更加简单,允许服务端主动向客户端推送数据。在WebSocket API中,浏览器和服务器只需要完成一次握手,两者之间就直接可以创建持久性的连接,并进行双向数据传输。

       2.使用

        • 工具类 
            1 package com.mz.usps.common.component;
            2 
            3 import org.apache.log4j.Logger;
            4 import org.springframework.stereotype.Component;
            5 
            6 import javax.websocket.*;
            7 import javax.websocket.server.PathParam;
            8 import javax.websocket.server.ServerEndpoint;
            9 import java.io.IOException;
           10 import java.util.concurrent.ConcurrentHashMap;
           11 import java.util.concurrent.ConcurrentMap;
           12 
           13 //该注解用来指定一个URI,客户端可以通过这个URI来连接到WebSocket。类似Servlet的注解mapping。无需在web.xml中配置。
           14 @ServerEndpoint("/webSocket/{id}")
           15 @Component("webSocket")
           16 public class WebSocket {
           17 
           18     private static Logger logger = Logger.getLogger(WebSocket.class);
           19     //静态变量,用来记录当前在线连接数。应该把它设计成线程安全的。
           20     private static int onlineCount = 0;
           21     //与某个客户端的连接会话,需要通过它来给客户端发送数据
           22     private Session session;
           23     //concurrent包的线程安全Map,用来存放每个客户端对应的MyWebSocket对象。若要实现服务端与单一客户端通信的话,可以使用Map来存放,其中Key可以为用户标识
           24     private static ConcurrentMap<String, WebSocket> webSocketMap = new ConcurrentHashMap<>();
           25     private static ConcurrentMap<String, WebSocket> webSocketMapAdmin = new ConcurrentHashMap<>();
           26 
           27     public Session getSession() {
           28         return session;
           29     }
           30 
           31     public static WebSocket getWebSocket(String id) {
           32         return webSocketMap.get(id);
           33     }
           34 
           35     /**
           36      * 连接建立成功调用的方法
           37      *
           38      * @param session 可选的参数。session为与某个客户端的连接会话,需要通过它来给客户端发送数据
           39      */
           40     @OnOpen
           41     public void onOpen(Session session, @PathParam("id") String id) {
           42         this.session = session;
           43         //String sessionId = session.getId();
           44         webSocketMap.put(id, this);     //加入map中
           45         if (id.contains("admin")) {// 后台登陆用户,加入list
           46             webSocketMapAdmin.put(id, this);
           47         }
           48         addOnlineCount();           //在线数加1
           49         System.out.println("有新连接加入!当前在线人数为" + getOnlineCount());
           50     }
           51 
           52     /**
           53      * 连接关闭调用的方法
           54      */
           55     @OnClose
           56     public void onClose(@PathParam("id") String id) {
           57         webSocketMap.remove(id);  //从map中删除
           58         webSocketMapAdmin.remove(id);
           59         subOnlineCount();           //在线数减1
           60         System.out.println("有一连接关闭!当前在线人数为" + getOnlineCount());
           61     }
           62 
           63     /**
           64      * 收到客户端消息后调用的方法
           65      *
           66      * @param message 客户端发送过来的消息
           67      * @param session 可选的参数
           68      */
           69     @OnMessage
           70     public static void onMessage(String message, Session session) {
           71         //群发消息
           72         if (webSocketMapAdmin.size() > 0) {
           73             for (WebSocket item : webSocketMapAdmin.values()) {
           74                 try {
           75                     //System.out.println(item.session.getId());
           76                     item.session.getBasicRemote().sendText(message);
           77                 } catch (IOException e) {
           78                     logger.error("IO异常");
           79                     continue;
           80                 }
           81             }
           82         }
           83 
           84     }
           85 
           86     /**
           87      * 发生错误时调用
           88      *
           89      * @param session
           90      * @param error
           91      */
           92     @OnError
           93     public void onError(Session session, Throwable error) {
           94         //System.out.println("发生错误");
           95         logger.error("发生错误");
           96     }
           97 
           98     /**
           99      * 这个方法与上面几个方法不一样。没有用注解,是根据自己需要添加的方法。
          100      *
          101      * @param message
          102      * @throws IOException
          103      */
          104     public void sendMessage(String message) throws IOException {
          105         this.session.getBasicRemote().sendText(message);
          106         //this.session.getAsyncRemote().sendText(message);
          107     }
          108 
          109     public static synchronized int getOnlineCount() {
          110         return onlineCount;
          111     }
          112 
          113     public static synchronized void addOnlineCount() {
          114         WebSocket.onlineCount++;
          115     }
          116 
          117     public static synchronized void subOnlineCount() {
          118         WebSocket.onlineCount--;
          119     }
          120 
          121     public static void main(String[] args) {
          122         /*WebSocket webSocket = new WebSocket();
          123         System.out.println(webSocket);
          124         webSocketMap.put("1", webSocket);
          125         webSocketMap.put("1", webSocket);
          126         System.out.println(webSocketMap.get("12"));*/
          127         onMessage("123465",null);
          128     }
          129 }
        • 微信登录成功时将用户信息发送给前端
        •   1 /**
            2      * 手机端微信登陆
            3      *
            4      * @return
            5      */
            6     @RequestMapping(value = "/wxLogin", method = RequestMethod.GET)
            7     @ResponseBody
            8     public R wxLogin(String userResult, String state, @RequestParam(required = false, value = "userId") String userId) throws Exception {
            9         //System.out.println(userResult+"
          "+state+"
          "+userId);
           10         WxUser wxUser = JSON.parseObject(userResult, WxUser.class);
           11         UserInfo userInfo = new UserInfo();
           12         userInfo.setUnionId(wxUser.getUnionid());
           13         userInfo.setOpenid(wxUser.getOpenid());
           14         userInfo.setSex((long) wxUser.getSex());
           15         userInfo.setHeadImgUrl(wxUser.getHeadimgurl());
           16         if (EmojiUtil.containsEmoji(wxUser.getNickName())) {
           17             logger.info(wxUser.getNickName());
           18             userInfo.setNickName(EmojiUtil.emojiConverterToAlias(wxUser.getNickName()));
           19         } else {
           20             userInfo.setNickName(wxUser.getNickName());
           21         }
           22         System.out.println(userInfo.getUnionId());
           23         UserInfo userInfo1;
           24         WebSocket webSocket = WebSocket.getWebSocket(state);
           25         Map<String, Object> m = new HashMap<>();
           26         //登录
           27         if (userId == null || "".equals(userId)) {
           28             if ((userInfo1 = userInfoService.selectWx(userInfo)) != null) {
           29                 //判定账号是否被禁用
           30                 if (userInfo1.getUserState() != 1) {
           31                     R r = new R();
           32                     r.put("code", 500);
           33                     r.put("msg", "此账号因为特殊原因已被禁用,若想重新启用,请联系管理员");
           34                     webSocket.sendMessage(JSON.toJSONString(r));
           35                     return null;
           36                 }
           37 
           38                 userInfo.setUserId(userInfo1.getUserId());
           39                 //System.out.println(userInfo1.getHeadImgUrl()+"你好呀");
           40                 if (userInfo1.getHeadImgUrl() != null) {
           41                     userInfo.setHeadImgUrl(null);
           42                 }
           43                 //System.out.println(userInfo.getHeadImgUrl()+"你好");
           44                 userInfoService.updateByPrimaryKeySelective(userInfo);
           45                 UserInfo userInfo2 = userInfoService.selectWx(userInfo);
           46                 if (EmojiUtil.containsEmoji(userInfo2.getNickName())) {
           47                     userInfo2.setNickName(EmojiUtil.emojiConverterUnicodeStr(userInfo2.getNickName()));
           48                 }
           49                 m.put("openId", userInfo2.getOpenid());
           50                 m.put("userId", userInfo2.getUserId());
           51                 m.put("createTime", new Date());
           52                 String javaWebToken = WebTokenUtil.createJavaWebToken(m);
           53                 userInfo2.setToken(javaWebToken);
           54                 redisCache.setValue(javaWebToken, "1", 1, TimeUnit.DAYS);
           55                 webSocket.sendMessage(JSON.toJSONString(userInfo2));//登录用户信息发送给web
           56                 return R.ok("登录成功");
           57             } else {
           58                 userInfo.setUserName(userInfo.getNickName());
           59                 userInfoService.insertSelective(userInfo);
           60                 UserInfo userInfo3 = userInfoService.selectWx(userInfo);
           61                 if (EmojiUtil.containsEmoji(userInfo3.getNickName())) {
           62                     userInfo3.setNickName(EmojiUtil.emojiConverterUnicodeStr(userInfo3.getNickName()));
           63                 }
           64                 //判定账号是否被禁用
           65                 if (userInfo3.getUserState() != 1) {
           66                     R r = new R();
           67                     r.put("code", 500);
           68                     r.put("msg", "此账号因为特殊原因已被禁用,若想启用,请联系管理员");
           69                     webSocket.sendMessage(JSON.toJSONString(r));
           70                     return null;
           71                 }
           72 
           73                 System.out.println(userInfo.getOpenid());
           74                 m.put("openId", userInfo3.getOpenid());
           75                 m.put("userId", userInfo3.getUserId());
           76                 m.put("createTime", new Date());
           77                 String javaWebToken = WebTokenUtil.createJavaWebToken(m);
           78                 userInfo3.setToken(javaWebToken);
           79                 redisCache.setValue(javaWebToken, "1", 1, TimeUnit.DAYS);
           80                 webSocket.sendMessage(JSON.toJSONString(userInfo3));//登录用户信息发送给web
           81                 return R.ok("登录成功");
           82             }
           83         } else {
           84             userInfo.setUserId(Long.valueOf(userId));
           85             //绑定微信前先判断数据库中是否有头像,如果有,不更改头像
           86             List<UserInfo> selectmemberlist = userInfoService.selectmemberlist(userInfo);
           87             if (selectmemberlist.get(0).getHeadImgUrl() != null) {
           88                 userInfo.setHeadImgUrl(null);
           89             }
           90 
           91             UserInfo userInfo2 = userInfoService.selectWx(userInfo);
           92             if (userInfo2 != null) {
           93                 R r = new R();
           94                 r.put("code", 500);
           95                 r.put("msg", "此微信已被注册,若确认是你本人微信,请联系管理员帮你更改");
           96                 webSocket.sendMessage(JSON.toJSONString(r));
           97                 return R.error("");
           98             }
           99             if (EmojiUtil.containsEmoji(wxUser.getNickName())) {
          100                 userInfo.setNickName( EmojiUtil.emojiConverterToAlias(wxUser.getNickName()));
          101             }
          102             R r = userInfoService.updateByPrimaryKeySelective(userInfo);
          103             if (r.get("code").equals(200)) {
          104                 R r1 = new R();
          105                 r1.put("code", 200);
          106                 r1.put("msg", "更改成功");
          107                 webSocket.sendMessage(JSON.toJSONString(r1));
          108             } else {
          109                 R r2 = new R();
          110                 r2.put("code", 500);
          111                 r2.put("msg", "更改失败");
          112                 webSocket.sendMessage(JSON.toJSONString(r2));
          113             }
          114             return r;
          115         }
          116     }
          117 
          118 }
  • 相关阅读:
    .NET互操作性入门系列(一):.NET平台下互操作性介绍
    .NET互操作性入门系列(三):平台调用中的数据封送处理
    .NET互操作性入门系列(二):使用平台调用调用Win32 函数
    [C# 基础知识系列]专题十四:深入理解Lambda表达式
    [C#基础知识]专题十三:全面解析对象集合初始化器、匿名类型和隐式类型
    [C#基础知识系列]专题十二:迭代器
    [C# 基础知识系列]专题十一:匿名方法解析
    [C# 基础知识系列]专题十六:Linq介绍
    [C#基础知识系列]专题十七:深入理解动态类型
    网页时钟 当前时间 备留
  • 原文地址:https://www.cnblogs.com/shijl/p/10592688.html
Copyright © 2011-2022 走看看