java实现websocket server/client

最新推荐文章于 2024-08-09 07:01:47 发布
最新推荐文章于 2024-08-09 07:01:47 发布
阅读量3.4k 收藏 12
点赞数
分类专栏： websocket 文章标签： java实现websocket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangchaox123/article/details/98882840
版权

最近在项目中有一个场景，在内网的应用需要接受外网应用的指令。有两种解决方案：

1.内网应用轮询外网应用，http请求指令

2.内网应用与外网应用之间建立websocket长连接

记录一下websocket server/client的java实现

一、websocket server

@Configuration
public class WebSocketConfig extends Configurator
{
    /**
     * 日志
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(WebSocketConfig.class);

    /**
     * 首先要注入ServerEndpointExporter，这个bean会自动注册使用了@ServerEndpoint注解声明的Websocket endpoint。
     * 要注意，如果使用独立的servlet容器，而不是直接使用springboot的内置容器，就不要注入ServerEndpointExporter，因为它将由容器自己提供和管理。
     *
     * @return ServerEndpointExporter
     */
    @Bean
    public ServerEndpointExporter serverEndpointExporter()
    {
        return new ServerEndpointExporter();
    }

    @Override
    public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request,
                                HandshakeResponse response)
    {
        /* 如果没有监听器,那么这里获取到的HttpSession是null */
        StandardSessionFacade ssf = (StandardSessionFacade)request.getHttpSession();
        if (ssf != null)
        {
            HttpSession httpSession = (HttpSession)request.getHttpSession();
            // 关键操作
            sec.getUserProperties().put("sessionId", httpSession.getId());
            LOGGER.debug("获取到的SessionID：" + httpSession.getId());
        }
    }

}
@Component
@ServerEndpoint(value = "/ws/{userId}")
public class WebSocketServer
{
    /**
     * 日志
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(WebSocketServer.class);

    // 静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
    private static int onlineCount = 0;

    // concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
    private static ConcurrentHashMap<String, WebSocketServer> webSocketMap = new ConcurrentHashMap<>();

    // 保存允许建立连接的id
    private static List<String> idList = Lists.newArrayList();

    private String id = "";

    // 与某个客户端的连接会话，需要通过它来给客户端发送数据
    private Session session;

    /**
     * <关闭连接>
     *
     * @param userId userId
     * @throws
     */
    public void closeConn(String userId)
    {
        // 关闭连接
        try
        {
            WebSocketServer socket = webSocketMap.get(userId);
            if (null != socket)
            {
                if (socket.session.isOpen())
                {
                    socket.session.close();
                }
            }
        }
        catch (IOException e)
        {
            LOGGER.error("error, cause: ", e);
        }
        webSocketMap.remove(userId);
        idList.remove(userId);
    }

    /**
     * <连接/注册时去重>
     *
     * @param userId userId
     * @throws
     */
    public void conn(String userId)
    {
        // 去重
        if (!idList.contains(userId))
        {
            idList.add(userId);
        }
    }

    /**
     * <获取注册在websocket进行连接的id>
     *
     * @return 结果
     * @throws
     */
    public static List<String> getIdList()
    {
        return idList;
    }

    /**
     * <初始化方法>
     *
     * @throws
     */
    @PostConstruct
    public void init()
    {
        try
        {
            /**
             * TODO 这里的设计是在项目启动时从DB或者缓存中获取注册了允许建立连接的id
             */
            // TODO 初始化时将刚注入的对象进行静态保存

        }
        catch (Exception e)
        {
            // TODO 项目启动错误信息
            LOGGER.error("error, cause: ", e);
        }
    }

//    /**
//     * 连接启动时查询是否有滞留的新邮件提醒
//     *
//     * @param id
//     * @throws IOException
//     * @author caoting
//     * @date 2019年2月28日
//     */
//    private void selectOfflineMail(String id)
//        throws IOException
//    {
//        // 查询缓存中是否存在离线邮件消息
//        RedisProperties.Jedis jedis = redis.getConnection();
//        try
//        {
//            List<String> mails = jedis.lrange(Constant.MAIL_OFFLINE + id, 0, -1);
//            if (!StringUtils.isEmpty(mails))
//            {
//                for (String mailuuid : mails)
//                {
//                    String mail = jedis.get(mailuuid);
//                    if (!StringUtils.isEmpty(mail))
//                    {
//                        sendToUser(Constant.MESSAGE_MAIL + mail, id);
//                    }
//                    Thread.sleep(1000);
//                }
//                // 发送完成从缓存中移除
//                jedis.del(Constant.MAIL_OFFLINE + id);
//            }
//        }
//        catch (InterruptedException e)
//        {
//            e.printStackTrace();
//        }
//        finally
//        {
//            jedis.close();
//        }
//    }

    /**
     * <连接建立成功调用的方法>
     *
     * @param userId  userId
     * @param session session
     * @throws
     */
    @OnOpen
    public void onOpen(@PathParam(value = "userId") String userId, Session session)
    {
        try
        {
            // 注：admin是管理员内部使用通道  不受监控  谨慎使用
//            if (!id.contains("admin"))
//            {
//                this.session = session;
//                this.id = id;//接收到发送消息的人员编号
//                // 验证id是否在允许
//                if (idList.contains(id))
//                {
//                    // 判断是否已存在相同id
//                    WebSocketServer socket = webSocketSet.get(id);
//                    if (socket == null)
//                    {
//                        webSocketSet.put(id, this);     //加入set中
//                        addOnlineCount(); // 在线数加1
//
//                        this.sendMessage("Hello:::" + id);
//                        System.out.println("用户" + id + "加入！当前在线人数为" + getOnlineCount());
//
//                        // 检查是否存在离线推送消息
//                        selectOfflineMail(id);
//                    }
//                    else
//                    {
//                        this.sendMessage("连接id重复--连接即将关闭");
//                        this.session.close();
//                    }
//                }
//                else
//                {
//                    // 查询数据库中是否存在数据
//                    WsIds wsIds = wsIdsService.selectByAppId(id);
//                    if (null != wsIds)
//                    {
//                        idList.add(id);
//                        webSocketSet.put(id, this);     //加入set中
//
//                        addOnlineCount(); // 在线数加1
//                        this.sendMessage("Hello:::" + id);
//                        LOGGER.debug("用户" + id + "加入！当前在线人数为" + getOnlineCount());
//
//                        // 检查是否存在离线推送消息
//                        selectOfflineMail(id);
//
//                    }
//                    else
//                    {
//                        // 关闭
//                        this.sendMessage("暂无连接权限,连接即将关闭,请确认连接申请是否过期！");
//                        this.session.close();
//                        LOGGER.warn("有异常应用尝试与服务器进行长连接  使用id为：" + id);
//                    }
//                }
//            }
//            else
//            {
            this.session = session;
            this.id = userId;//接收到发送消息的人员编号

            webSocketMap.put(userId, this);     //加入set中
            addOnlineCount(); // 在线数加1

            this.sendMessage("Hello:::" + userId);
            LOGGER.debug("用户" + userId + "加入！当前在线人数为" + getOnlineCount());
//            }
        }
        catch (IOException e)
        {
            LOGGER.error("error, cause: ", e);
        }
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose()
    {
        webSocketMap.remove(this.id); // 从set中删除
        idList.remove(this.id);
        subOnlineCount(); // 在线数减1
        LOGGER.debug("有一连接关闭！当前在线人数为" + getOnlineCount());
    }

    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息
     */
    @OnMessage
    public void onMessage(String message, Session session)
    {
        LOGGER.debug("来自客户端的消息:" + message);
        // TODO 收到客户端消息后的操作
    }

    /**
     * 发生错误时调用
     */
    @OnError
    public void onError(Session session, Throwable error)
    {
        LOGGER.debug("发生错误");
        LOGGER.error("error, cause: ", error);
    }

    /**
     * <发送message>
     *
     * @param message message
     * @throws
     */
    public synchronized void sendMessage(String message)
        throws IOException
    {
        this.session.getBasicRemote().sendText(message);
    }

    /**
     * 发送信息给指定ID用户，如果用户不在线则返回不在线信息给自己
     *
     * @param message
     * @param sendUserId
     * @throws IOException
     */
    public Boolean sendToUser(String message, String sendUserId)
        throws IOException
    {
        Boolean flag = true;
        WebSocketServer socket = webSocketMap.get(sendUserId);
        if (socket != null)
        {
            try
            {
                if (socket.session.isOpen())
                {
                    socket.sendMessage(message);
                }
                else
                {
                    flag = false;
                }
            }
            catch (Exception e)
            {
                flag = false;
                LOGGER.error("error, cause: ", e);
            }
        }
        else
        {
            flag = false;
            LOGGER.warn("【" + sendUserId + "】 该用户不在线");
        }
        return flag;
    }

    /**
     * <群发自定义消息>
     *
     * @param message message
     * @throws
     */
    public void sendToAll(String message)
    {
        List<String> userIdList = new ArrayList<>(webSocketMap.keySet());
        for (int i = 0; i < userIdList.size(); i++)
        {
            try
            {
                WebSocketServer socket = webSocketMap.get(userIdList.get(i));
                if (socket.session.isOpen())
                {
                    socket.sendMessage(message);
                }
            }
            catch (Exception e)
            {
                LOGGER.error("sendToAll error. cause: ", e);
                //异常重传
                i--;
                continue;
            }
        }
    }

    /**
     * <获取在线人数>
     *
     * @return 在线人数
     * @throws
     */
    public static synchronized int getOnlineCount()
    {
        return onlineCount;
    }

    /**
     * <增加在线人数>
     *
     * @throws
     */
    public static synchronized void addOnlineCount()
    {
        WebSocketServer.onlineCount++;
    }

    /**
     * <减少在线人数>
     *
     * @throws
     */
    public static synchronized void subOnlineCount()
    {
        if (WebSocketServer.onlineCount > 0)
        {
            WebSocketServer.onlineCount--;
        }
    }
}
@Component
public class RequestListener implements ServletRequestListener
{
    /**
     * 日志
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(WebSocketConfig.class);

    @Override
    public void requestInitialized(ServletRequestEvent sre)
    {
        // 将所有request请求都携带上httpSession
        HttpSession httpSession = ((HttpServletRequest)sre.getServletRequest()).getSession();
        LOGGER.debug("将所有request请求都携带上httpSession " + httpSession.getId());
    }

    public RequestListener()
    {
    }

    @Override
    public void requestDestroyed(ServletRequestEvent arg0)
    {
    }

}
@Component
public class WebSocketTask
{
    private static final Logger LOGGER = LoggerFactory.getLogger(WebSocketTask.class);

    @Autowired
    private WebSocketServer webSocketServer;

    /**
     * 服务器主动向客户端推送消息
     */
    @Scheduled(cron = "0/30 * * * * ?")
    public void initiativeSendMsg()
    {
        LOGGER.info("服务器主动向客户端推送消息.");
        webSocketServer.sendToAll("test");
    }
}

二、websocket client

@Configuration
@Order(1)
public class WebSocketConfig implements ApplicationRunner
{
    /**
     * 日志
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(WebSocketConfig.class);

    private static Boolean isOk;

    private static WebSocketContainer container = ContainerProvider.getWebSocketContainer();

    private WebSocketClient client;

    /**
     * 定义定时任务线程
     */
    private ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(
        1);

    @Value("${springboot.websocket.uri}")
    private String uri;

    @Value("${springboot.websocket.ip}")
    private String ip;

    @Autowired
    public void setMessageService(RedisUtils redisUtils)
    {
        WebSocketClient.redisUtils = redisUtils;
    }

    /**
     * <run>
     *
     * @param args args
     * @throws
     */
    @Override
    public void run(ApplicationArguments args)
        throws Exception
    {
        LOGGER.info("[WebSocketConfig] web socket init start.");

        // websocket客户端初始化
        wsClientInit();
    }

    /**
     * <websocket客户端初始化>
     *
     * @throws
     */
    public void wsClientInit()
    {
        LOGGER.info("[WebSocketConfig] start to wsClientInit");
        try
        {
            client = new WebSocketClient();
            WebSocketClient.beforeInit();
            container.connectToServer(client,
                new URI(uri + UUID.randomUUID().toString().replaceAll("-", "")));

            isOk = true;
        }
        catch (Exception e)
        {
            isOk = false;
            LOGGER.error("error, cause: ", e);
        }

        // 参数：1、任务体 2、首次执行的延时时间
        //      3、任务执行间隔 4、间隔时间单位
        scheduledExecutorService.scheduleAtFixedRate(new Runnable()
        {
            @Override
            public void run()
            {
                //心跳检测 断线重连
                heartbeatCheck();
            }
        }, 1, 30, TimeUnit.SECONDS);

        LOGGER.info("[WebSocketConfig] end to wsClientInit");
    }

    /**
     * <心跳检测 断线重连>
     *
     * @throws
     */
    private void heartbeatCheck()
    {
        LOGGER.info("[WebSocketConfig] start to heartbeatCheck");
        if (isOk != null && isOk)
        {
            try
            {
                client.send("ping " + ip);
            }
            catch (Exception e)
            {
                isOk = false;
            }
        }
        else
        {
            // 系统连接失败进行重试
            LOGGER.warn("系统连接失败，正在重连...");
            try
            {
                client.send("ping " + ip);
                LOGGER.warn("系统重连成功！");
                isOk = true;
            }
            catch (Exception e)
            {
                try
                {
                    client = new WebSocketClient();
                    container.connectToServer(client,
                        new URI(uri + UUID.randomUUID().toString().replaceAll("-", "")));

                    isOk = true;
                }
                catch (Exception e1)
                {
                    isOk = false;
                }

                if (isOk != null && isOk)
                {
                    LOGGER.warn("系统重连成功！");
                }
            }
        }
    }
}
@ClientEndpoint
public class WebSocketClient
{
    /**
     * 日志
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(WebSocketClient.class);

    /**
     * 这里使用静态，让 RedisUtils 属于类
     */
    public static RedisUtils redisUtils;

    /**
     * session
     */
    private Session session;

    /**
     * <beforeInit>
     *
     * @throws
     */
    public static void beforeInit()
    {
        // 在socket配置类中调用此方法可以完成一些需要初始化注入的操作
    }

    @OnOpen
    public void onOpen(Session session)
    {
        LOGGER.info("连接开启...");
        this.session = session;
    }

    @OnMessage
    public void onMessage(String message, Session session)
    {
        redisUtils.set(UUID.randomUUID().toString().replaceAll("-", ""), message);
        LOGGER.info(message);
    }

    @OnClose
    public void onClose()
    {
        LOGGER.info("长连接关闭...");
    }

    @OnError
    public void onError(Session session, Throwable t)
    {
        LOGGER.error("error, cause: ", t);
    }

    /**
     * <异步发送message>
     *
     * @param message message
     * @throws
     */
    public void send(String message)
    {
        this.session.getAsyncRemote().sendText(message);
    }

    /**
     * <发送message>
     *
     * @param message message
     * @throws
     */
    public void sendMessage(String message)
    {
        try
        {
            session.getBasicRemote().sendText(message);
        }
        catch (IOException ex)
        {
            LOGGER.error("error, cause: ", ex);
        }
    }

    /**
     * <关闭连接>
     *
     * @throws
     */
    public void close()
        throws IOException
    {
        if (this.session.isOpen())
        {
            this.session.close();
        }
    }
}
#websocket对应地址
springboot.websocket.uri=ws://localhost:81/ws/
springboot.websocket.ip=localhost:81

三、对应依赖

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-websocket</artifactId>
		</dependency>

 

Eddie-Wang
关注
专栏目录
websocketclient java_websocket通信 实现java模拟一个client与webclient通信
weixin_30847063的博客
02-13 1121
环境：tomcat 7maven项目IDE是IDEA2017项目功能描述：启动项目，会启动一个web端的websocket-client和一个java模拟的websocket-server。项目中另外还有一个Main类，单独启动，会模拟启动一个java端的websocket-client。java-client可以发消息，通过server即时将消息推送到web端。先看web端的js代码，非常简单：...
java websocket客户端_java 实现WebSocketClient客户端
weixin_31315567的博客
02-12 2228
java 实现WebSocketClient客户端案例，向websocket服务端发送消息监听消息，并实现发送马上接受返回值即时调用的方式1.java 代码public class MyWebSocket extends WebSocketClient {private int code;private String message;private boolean isPagefinished;p...
java实现websocket client
11-08
java_websocket.jar最新jar包 可用java实现websocket客户端，使用demo: https://github.com/TooTallNate/Java-WebSocket/blob/master/src/main/example/ExampleClient.java
探秘WebSocket客户端库：websocket-client
最新发布
gitblog_00163的博客
08-09 335
探秘WebSocket客户端库：websocket-client websocket-clientWebSocket client for Python项目地址:https://gitcode.com/gh_mirrors/we/websocket-client 在当今的Web开发中，实时通信已经成为不可或缺的一部分。为了实现这一点，WebSocket协议扮演了关键角色，它提供了双向通信通道，允...
Java WebSocket客户端java WebSocketClient
热门推荐
OceanSky的专栏
01-09 5万+
一、java客户端实现代码   package ggmes.websocket.client; import java.net.URI; import java.net.URISyntaxException; import java.util.Iterator; import org.java_websocket.client.WebSocketClient; import org.ja...
java的websocketclient_websocket_client
weixin_31342203的博客
02-28 646
代码如下：#!/usr/bin/python3# -*- coding: UTF-8 -*-"""运行环境：win7_x86 python3.7.3_x86运行命令："""import asyncioimport pathlibimport sslimport websocketsimport websocketimport osssl_context = ssl.SSLContext(ssl.P...
java 后端源码包websocket client 四种创建方式websocket server 创建方式
07-07
- java 后端源码包 - websocket client 四种创建方式 1. 第一种方式 WebSocketClient 注入方式 2. 第二种方式 @ClientEndpoint 注解方式 ...- websocket server 创建方式 @ServerEndpoint 注解方式
java webSocket Client集成
lanse_huanxiang的专栏
08-27 1816
webSocket client 封装测试
java实现webSocket
04-22
在服务器端，可能有一个名为`WebSocketServer.java`的文件，客户端可能有一个HTML页面和JavaScript代码来建立连接并发送/接收消息。 总结来说，Java实现WebSocket提供了强大的功能，使得开发者可以轻松地在Web应用...
基于JAVA的websocket实现（含java后端）
05-08
public class MyWebSocketServer { // ... } ``` 3. 实现消息处理： - `@OnOpen`方法会在客户端连接打开时调用，可以在这里进行初始化操作。 - `@OnMessage`方法处理接收到的消息，支持文本和二进制数据。 -...
java websocket client
az44yao的专栏
08-25 2970
websocket是H5新推出的协议，一般用于前端，但是在实际项目中我们需要用java代码来获取一些设备的实时运行数据，在后台处理后推送的前台界面，为了保证实时性，我们需要用到websocket协议，而刚好有一个叫java-websocket的开源项目，我们可以利用它来实现java版的websocket client。 　　1、需要引入的依赖： <dependency> ...
java-websocket-client:一个简单的java websocket客户端
07-11
java-websocket-客户端 一个简单的 java websocket 客户端。
java的websocketclient_Java WebSocket客户端java WebSocketClient
weixin_32564229的博客
02-28 1403
一、java客户端实现代码package ggmes.websocket.client;import java.net.URI;import java.net.URISyntaxException;import java.util.Iterator;import org.java_websocket.client.WebSocketClient;import org.java_websocket....
Java实现websocket客户端
qq_38783304的博客
10-20 1万+
Java实现websocket客户端
Java-WebSocket 项目的研究(三) WebSocketClient 类 详解
编程爱好者
09-06 1万+
通过之前两篇文章 Java-WebSocket 项目的研究(一) Java-WebSocket类图描述 Java-WebSocket 项目的研究(二) 小试身手：客户端连接服务器并发送消息实例 的介绍我们大概了解到了整个项目的类结构，其中有一个重要的类：WebSocketClient，下面就让我们详细了解一下这个类 首先看一下我们之前的类图关于W
java-websocketclient
whuyi的专栏
07-30 1万+
最近用websocketclient测试服务端能承受的最大长连接数，
java websocket client （转载）
FZBL1的博客
02-27 988
原文地址：https://www.cnblogs.com/hhhshct/p/9507446.html websocket是H5新推出的协议，一般用于前端，但是在实际项目中我们需要用java代码来获取一些设备的实时运行数据，在后台处理后推送的前台界面，为了保证实时性，我们需要用到websocket协议，而刚好有一个叫java-websocket的开源项目，我们可以利用它来实现java版的webs...
Java 实现WebSocketClient客户端
09-16
你可以使用 Java 的 WebSocketClient 类来实现 WebSocket 客户端。下面是一个简单的示例代码： ```java import java.net.URI; import java.net.http.HttpClient; import java.net.http.WebSocket; import java.util...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值