同端口实现Socket和webSocket

已于 2024-10-18 11:20:37 修改
阅读量368 收藏 4
点赞数 8
文章标签： JAVA websocket 网络协议
于 2024-10-17 11:16:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43561677/article/details/142957423
版权

踩坑日记

同端口实现Socket和webSocket

之前有个需求是网页控制设备，这个时候就发现了个问题 网页（web socket）需要握手才能连接，而硬件端无需握手。中间也踩了很多坑，这里记录一下

代码如下：

  1. websocket访问 http://127.0.0.1:8895/ws
    socket访问 http://127.0.0.1:8895

实现代码：

package com.netty.tcptest.deviceManage;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.net.InetSocketAddress;

@Component
@Slf4j
public class ControlHttpServer {
    /**
     * boss 线程组用于处理连接工作
     */
    private static EventLoopGroup boss = new NioEventLoopGroup();
    /**
     * work 线程组用于数据处理
     */
    private static EventLoopGroup work = new NioEventLoopGroup();

    private final static Integer port=8895;

    /**
     * 启动Netty Server
     *
     * @throws InterruptedException
     */
    public static void start() throws InterruptedException {
        ServerBootstrap bootstrap = new ServerBootstrap();
        bootstrap.group(boss, work)
          // 指定Channel
          .channel(NioServerSocketChannel.class)
          //使用指定的端口设置套接字地址
          .localAddress(new InetSocketAddress(port))
          //服务端可连接队列数,对应TCP/IP协议listen函数中backlog参数
          .option(ChannelOption.SO_BACKLOG, 1024)
//                .option(ChannelOption.SO_REUSEADDR, true)
          //设置TCP长连接,一般如果两个小时内没有数据的通信时,TCP会自动发送一个活动探测数据报文
          .childOption(ChannelOption.SO_KEEPALIVE, true)

          //将小的数据包包装成更大的帧进行传送，提高网络的负载
          .childOption(ChannelOption.TCP_NODELAY, true)

          .childHandler(new ControlNettyServerChannelInitializer());
        ChannelFuture future = bootstrap.bind().sync();
        if (future.isSuccess()) {
            log.info("启动 Netty Server");
        }
    }

    @PreDestroy
    public void destory() throws InterruptedException {
        boss.shutdownGracefully().sync();
        work.shutdownGracefully().sync();
        ControlWebSocketHandler.map.clear();
        log.info("关闭Netty");
    }

}


package com.netty.tcptest.deviceManage;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;
import org.springframework.stereotype.Component;

@Component
public class ControlNettyServerChannelInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel channel) throws Exception {
        channel.pipeline().addLast("socketChoose",new ControlSocketChooseHandle());
        channel.pipeline().addLast(new StringDecoder(CharsetUtil.UTF_8));
        channel.pipeline().addLast(new StringEncoder(CharsetUtil.UTF_8));
        channel.pipeline().addLast("commonhandler",new ControlWebSocketHandler());
    }
}

package com.netty.tcptest.deviceManage;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.WebSocketFrameAggregator;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.stream.ChunkedWriteHandler;
import io.netty.handler.timeout.IdleStateHandler;
import io.netty.util.CharsetUtil;

import javax.xml.bind.DatatypeConverter;
import java.util.List;

public class ControlSocketChooseHandle extends ByteToMessageDecoder {
    /**
     * WebSocket握手的协议前缀
     */
    private static final String WEBSOCKET_PREFIX = "GET /";
    /**
     * 默认暗号长度为23
     */
    private static final int MAX_LENGTH = 23;

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        //创建字节数组,buffer.readableBytes可读字节长度
        byte[] b = new byte[in.readableBytes()];
        //复制内容到字节数组b
        in.readBytes(b);
        byte[] bytes = DatatypeConverter.parseHexBinary(toHexString1(b));
        String result = new String(bytes);
        System.out.println("protocol---------");
        if (result.contains(WEBSOCKET_PREFIX)) {
            System.out.println("websoket-----------------");
            ctx.pipeline().addBefore("commonhandler", "http-codec", new HttpServerCodec());
            // HttpObjectAggregator：将HTTP消息的多个部分合成一条完整的HTTP消息
            ctx.pipeline().addBefore("commonhandler", "aggregator", new HttpObjectAggregator(65535));
            // ChunkedWriteHandler：向客户端发送HTML5文件,文件过大会将内存撑爆
            ctx.pipeline().addBefore("commonhandler", "http-chunked", new ChunkedWriteHandler());
            ctx.pipeline().addBefore("commonhandler", "WebSocketAggregator", new WebSocketFrameAggregator(65535));
            //用于处理websocket, /ws为访问websocket时的uri
            ctx.pipeline().addBefore("commonhandler", "ProtocolHandler", new WebSocketServerProtocolHandler("/ws"));
            // 此次要移除socket 相关的编码
            ctx.pipeline().remove(StringDecoder.class);
            ctx.pipeline().remove(StringEncoder.class);
            in.resetReaderIndex();
            ctx.pipeline().remove(this.getClass());
        }
        else {
            System.out.println("socket-----------------");
            //  常规TCP连接时，执行以下处理
            ctx.pipeline().addLast(new IdleStateHandler(60, 0, 0));
            ctx.pipeline().addLast(new LengthFieldBasedFrameDecoder(1024 * 1024, 2, 2, 6, 10, false));
            ctx.pipeline().addLast(new StringDecoder(CharsetUtil.UTF_8));

            out.add(bytesToHexString(b));
        }

    }

    public static String toHexString1(byte[] b) {
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < b.length; ++i) {
            buffer.append(toHexString1(b[i]));
        }
        return buffer.toString();
    }

    public static String toHexString1(byte b) {
        String s = Integer.toHexString(b & 0xFF);
        if (s.length() == 1) {
            return "0" + s.toUpperCase();
        } else {
            return s.toUpperCase();
        }
    }

        public String bytesToHexString(byte[] bArray) {
        StringBuffer sb = new StringBuffer(bArray.length);
        String sTemp;
        for (int i = 0; i < bArray.length; i++) {
            sTemp = Integer.toHexString(0xFF & bArray[i]);
            if (sTemp.length() < 2)
                sb.append(0);
            sb.append(sTemp.toUpperCase());
        }
        return sb.toString();
    }
}

package com.netty.tcptest.deviceManage;

import com.alibaba.fastjson.JSON;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.net.InetSocketAddress;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Component
@Slf4j
@ChannelHandler.Sharable
public class ControlWebSocketHandler extends SimpleChannelInboundHandler<Object> {
    public static ControlWebSocketHandler controlWebSocketHandler;


    public static Map<String, Channel> map = new ConcurrentHashMap<>();


    //2.初始化构造方法一定要有
    public ControlWebSocketHandler() {

    }

    @PostConstruct
    public void init() {
        controlWebSocketHandler = this;
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object object) throws Exception {
        String msg = "";
        try {
            if (object instanceof TextWebSocketFrame) {
                //WebSocket(网页)客户端来消息
                TextWebSocketFrame textWebSocketFrame = (TextWebSocketFrame) object;
                msg = textWebSocketFrame.text().toUpperCase();
                log.info("web端来消息: {}", msg);
                //如果是握手请求
                if (msg.contains("websocket")) {
                    ChannelFuture channelFuture = ctx.writeAndFlush(msg);
                    if (!channelFuture.isSuccess()) {
                        ctx.writeAndFlush(new TextWebSocketFrame(msg));
                    }
                    //其他命令
                } else {
                    System.out.println("其他命令-----------");
                    Map<String, Object> orderMap = (Map) JSON.parse(msg);
                }
            } else {
                //Socket(设备)客户端来消息
                msg = String.valueOf(object);
                System.out.println("socket-----------------");
                System.out.println(msg);
                //设备发送的数据一般都为16进制数据,所以要进行转换
                String[] data = new String[msg.length() / 2];
                for (int k = 2; k <= msg.length(); k += 2) {
                    data[k / 2 - 1] = msg.substring(k - 2, k);
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
            sendCmd(ctx, "error");
        }
    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        System.out.println("handlerAdded::" + ctx.channel().id().asLongText());
        InetSocketAddress socketAddress = (InetSocketAddress) ctx.channel().remoteAddress();
        String hostAddress = socketAddress.getAddress().getHostAddress();
        log.info("IP:{}", hostAddress);
        String clientId = ctx.channel().id().toString();
        map.put(clientId, ctx.channel());
        log.info("map:{}", map.toString());
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        System.out.println("handlerRemoved::" + ctx.channel().id().asLongText());
        String clientId = ctx.channel().id().toString();
        map.remove(clientId);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("exceptionCaught::" + cause.getMessage());
        String clientId = ctx.channel().id().toString();
        map.remove(clientId);
        ctx.close();
    }

    public void sendCmd(ChannelHandlerContext ctx, String cmd) throws Exception {
        log.info("返回数据会触发Channel active......:" + ctx.name() + "---" + cmd);
        ctx.writeAndFlush(Unpooled.copiedBuffer(cmd.getBytes()));
    }

    public static String getIPString(ChannelHandlerContext ctx) {
        String ipString = "";
        String socketString = ctx.channel().remoteAddress().toString();
        int colonAt = socketString.indexOf(":");
        ipString = socketString.substring(1, colonAt);
        return ipString;
    }


    //将16进制的字符串转成字符数组
    public static byte[] getHexBytes(String str) {
        str = str.replaceAll(" ", "");
        byte[] bytes = new byte[str.length() / 2];
        for (int i = 0; i < str.length() / 2; i++) {
            String subStr = str.substring(i * 2, i * 2 + 2);
            bytes[i] = (byte) Integer.parseInt(subStr, 16);
        }
        return bytes;
    }

/*
  obj：byte数组
*/

    private void writeMessage(ChannelHandlerContext ctx, byte[] obj) {

        ByteBuf bufff = Unpooled.buffer();//netty需要用ByteBuf传输
        bufff.writeBytes(obj);//对接需要16进制

        ctx.writeAndFlush(bufff).addListener(new ChannelFutureListener() { //获取当前的handle
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                StringBuilder sb = new StringBuilder("");

                if (future.isSuccess()) {
                    log.info(sb.toString() + "回写成功.");
                } else {
                    log.error(sb.toString() + "回写失败.");
                }
            }
        });
    }
}

package com.netty.tcptest;

import com.netty.tcptest.deviceManage.ControlHttpServer;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class TcpTestApplication {

    public static void main(String[] args) throws InterruptedException {
        SpringApplication.run(TcpTestApplication.class, args);
        ControlHttpServer.start();
    }
}

CRC16校验代码（用于设备传输数据完整性校验）

package com.netty.tcptest.util;

public class CRC16 {
        static byte[] crc16_h = {
          (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
          (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
          (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
          (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
          (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
          (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
          (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
          (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
          (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
          (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
          (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
          (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
          (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
          (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
          (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
          (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40
        };

        static  byte[] crc16_l = {
          (byte) 0x00, (byte) 0xC0, (byte) 0xC1, (byte) 0x01, (byte) 0xC3, (byte) 0x03, (byte) 0x02, (byte) 0xC2, (byte) 0xC6, (byte) 0x06, (byte) 0x07, (byte) 0xC7, (byte) 0x05, (byte) 0xC5, (byte) 0xC4, (byte) 0x04,
          (byte) 0xCC, (byte) 0x0C, (byte) 0x0D, (byte) 0xCD, (byte) 0x0F, (byte) 0xCF, (byte) 0xCE, (byte) 0x0E, (byte) 0x0A, (byte) 0xCA, (byte) 0xCB, (byte) 0x0B, (byte) 0xC9, (byte) 0x09, (byte) 0x08, (byte) 0xC8,
          (byte) 0xD8, (byte) 0x18, (byte) 0x19, (byte) 0xD9, (byte) 0x1B, (byte) 0xDB, (byte) 0xDA, (byte) 0x1A, (byte) 0x1E, (byte) 0xDE, (byte) 0xDF, (byte) 0x1F, (byte) 0xDD, (byte) 0x1D, (byte) 0x1C, (byte) 0xDC,
          (byte) 0x14, (byte) 0xD4, (byte) 0xD5, (byte) 0x15, (byte) 0xD7, (byte) 0x17, (byte) 0x16, (byte) 0xD6, (byte) 0xD2, (byte) 0x12, (byte) 0x13, (byte) 0xD3, (byte) 0x11, (byte) 0xD1, (byte) 0xD0, (byte) 0x10,
          (byte) 0xF0, (byte) 0x30, (byte) 0x31, (byte) 0xF1, (byte) 0x33, (byte) 0xF3, (byte) 0xF2, (byte) 0x32, (byte) 0x36, (byte) 0xF6, (byte) 0xF7, (byte) 0x37, (byte) 0xF5, (byte) 0x35, (byte) 0x34, (byte) 0xF4,
          (byte) 0x3C, (byte) 0xFC, (byte) 0xFD, (byte) 0x3D, (byte) 0xFF, (byte) 0x3F, (byte) 0x3E, (byte) 0xFE, (byte) 0xFA, (byte) 0x3A, (byte) 0x3B, (byte) 0xFB, (byte) 0x39, (byte) 0xF9, (byte) 0xF8, (byte) 0x38,
          (byte) 0x28, (byte) 0xE8, (byte) 0xE9, (byte) 0x29, (byte) 0xEB, (byte) 0x2B, (byte) 0x2A, (byte) 0xEA, (byte) 0xEE, (byte) 0x2E, (byte) 0x2F, (byte) 0xEF, (byte) 0x2D, (byte) 0xED, (byte) 0xEC, (byte) 0x2C,
          (byte) 0xE4, (byte) 0x24, (byte) 0x25, (byte) 0xE5, (byte) 0x27, (byte) 0xE7, (byte) 0xE6, (byte) 0x26, (byte) 0x22, (byte) 0xE2, (byte) 0xE3, (byte) 0x23, (byte) 0xE1, (byte) 0x21, (byte) 0x20, (byte) 0xE0,
          (byte) 0xA0, (byte) 0x60, (byte) 0x61, (byte) 0xA1, (byte) 0x63, (byte) 0xA3, (byte) 0xA2, (byte) 0x62, (byte) 0x66, (byte) 0xA6, (byte) 0xA7, (byte) 0x67, (byte) 0xA5, (byte) 0x65, (byte) 0x64, (byte) 0xA4,
          (byte) 0x6C, (byte) 0xAC, (byte) 0xAD, (byte) 0x6D, (byte) 0xAF, (byte) 0x6F, (byte) 0x6E, (byte) 0xAE, (byte) 0xAA, (byte) 0x6A, (byte) 0x6B, (byte) 0xAB, (byte) 0x69, (byte) 0xA9, (byte) 0xA8, (byte) 0x68,
          (byte) 0x78, (byte) 0xB8, (byte) 0xB9, (byte) 0x79, (byte) 0xBB, (byte) 0x7B, (byte) 0x7A, (byte) 0xBA, (byte) 0xBE, (byte) 0x7E, (byte) 0x7F, (byte) 0xBF, (byte) 0x7D, (byte) 0xBD, (byte) 0xBC, (byte) 0x7C,
          (byte) 0xB4, (byte) 0x74, (byte) 0x75, (byte) 0xB5, (byte) 0x77, (byte) 0xB7, (byte) 0xB6, (byte) 0x76, (byte) 0x72, (byte) 0xB2, (byte) 0xB3, (byte) 0x73, (byte) 0xB1, (byte) 0x71, (byte) 0x70, (byte) 0xB0,
          (byte) 0x50, (byte) 0x90, (byte) 0x91, (byte) 0x51, (byte) 0x93, (byte) 0x53, (byte) 0x52, (byte) 0x92, (byte) 0x96, (byte) 0x56, (byte) 0x57, (byte) 0x97, (byte) 0x55, (byte) 0x95, (byte) 0x94, (byte) 0x54,
          (byte) 0x9C, (byte) 0x5C, (byte) 0x5D, (byte) 0x9D, (byte) 0x5F, (byte) 0x9F, (byte) 0x9E, (byte) 0x5E, (byte) 0x5A, (byte) 0x9A, (byte) 0x9B, (byte) 0x5B, (byte) 0x99, (byte) 0x59, (byte) 0x58, (byte) 0x98,
          (byte) 0x88, (byte) 0x48, (byte) 0x49, (byte) 0x89, (byte) 0x4B, (byte) 0x8B, (byte) 0x8A, (byte) 0x4A, (byte) 0x4E, (byte) 0x8E, (byte) 0x8F, (byte) 0x4F, (byte) 0x8D, (byte) 0x4D, (byte) 0x4C, (byte) 0x8C,
          (byte) 0x44, (byte) 0x84, (byte) 0x85, (byte) 0x45, (byte) 0x87, (byte) 0x47, (byte) 0x46, (byte) 0x86, (byte) 0x82, (byte) 0x42, (byte) 0x43, (byte) 0x83, (byte) 0x41, (byte) 0x81, (byte) 0x80, (byte) 0x40
        };

        /**
         * 查表法计算CRC16校验
         * @param data 需要计算的字节数组
         */
        public static String getCRC16(byte[] data) {
            int crc = 0xff;
            int ucCRCHi = 0xff;
            int ucCRCLo = 0xff;
            int iIndex;
            for (int i = 0; i < data.length; ++i) {
                iIndex = (ucCRCLo ^ data[i]) & 0x00ff;
                ucCRCLo = ucCRCHi ^ crc16_h[iIndex];
                ucCRCHi = crc16_l[iIndex];
            }

            crc = ((ucCRCHi & 0x00ff) << 8) | (ucCRCLo & 0x00ff) & 0xffff;
            //高低位互换，输出符合相关工具对Modbus CRC16的运算
            crc = ( (crc & 0xFF00) >> 8) | ( (crc & 0x00FF ) << 8);
            return String.format("%04X", crc);
        }


        /**
         * 查表法计算CRC16校验
         *00 64 FF FF 30 14 00 BB B6 D3 AD B9 E2 C1 D9 2C C7 EB C8 EB B3 A1 CD A3 B3 B
         * @param strHex16 需要计算的字节数组
         */
        public static String getCRC16(String strHex16) {
            String[] bytes = new String[strHex16.length() / 2];

            for (int k = 2; k <= strHex16.length(); k += 2) {
                bytes[k / 2 - 1] = strHex16.substring(k - 2, k);
            }
            byte[] data = new byte[bytes.length];
            for (int i = 0; i < bytes.length; i++) {
                data[i] = (byte) (Integer.parseInt(bytes[i], 16));
            }
            int crc = 0xff;
            int ucCRCHi = 0xff;
            int ucCRCLo = 0xff;
            int iIndex;
            for (int i = 0; i < data.length; ++i) {
                iIndex = (ucCRCLo ^ data[i]) & 0x00ff;
                ucCRCLo = ucCRCHi ^ crc16_h[iIndex];
                ucCRCHi = crc16_l[iIndex];
            }
            crc = ((ucCRCHi & 0x00ff) << 8) | (ucCRCLo & 0x00ff) & 0xffff;
            //高低位互换，输出符合相关工具对Modbus CRC16的运算
            crc = ( (crc & 0xFF00) >> 8) | ( (crc & 0x00FF ) << 8);
            return String.format("%04X", crc);
        }




        public static void main(String[] args) {
            //字符串转16进制byte数组
            String str16 = "00 64 FF FF 02 06 38 38 38 38 38 38";
//        String[] avs = str16.split(" ");
//        byte[] bbb = new byte[avs.length];
//        for (int i = 0; i < avs.length; i++) {
//            bbb[i] = (byte)Integer.parseInt(avs[i],16);
//        }
//        System.out.println(getCRC16(bbb));
            System.out.println(getCRC16(str16));

        }

}

自己写的工具类

package com.netty.tcptest.util;

public class StringHexUtil {
    /**
     * 将字符串转为16进制
     * @param str
     * @return
     */
    public static String str2HexStr(String str) {
        char[] chars = "0123456789ABCDEF".toCharArray();
        StringBuilder sb = new StringBuilder("");
        byte[] bs = str.getBytes();
        int bit;
        for (int i = 0; i < bs.length; i++) {
            bit = (bs[i] & 0x0f0) >> 4;
            sb.append(chars[bit]);
            bit = bs[i] & 0x0f;
            sb.append(chars[bit]);
            // sb.append(' ');
        }
        return sb.toString().trim();
    }
    /**
     * 将16进制转为字符串
     * @param str
     * @return
     */
    public static String hexStr2Str(String hexStr) {
        String str = "0123456789ABCDEF";
        char[] hexs = hexStr.toCharArray();
        byte[] bytes = new byte[hexStr.length() / 2];
        int n;
        for (int i = 0; i < bytes.length; i++) {
            n = str.indexOf(hexs[2 * i]) * 16;
            n += str.indexOf(hexs[2 * i + 1]);
            bytes[i] = (byte) (n & 0xff);
        }
        return new String(bytes);
    }


    /**
     * Hex转byte,hex只能含两个字符，如果是一个字符byte高位会是0
     */
    public static byte hexStrTobyte(String hex) {
        return (byte) Integer.parseInt(hex, 16);
    }

    /**
     * 将byte转换为一个长度为8的byte数组，数组每个值代表bit
     */
    public static byte[] getBooleanArray(byte b) {
        byte[] array = new byte[8];
        for (int i = 7; i >= 0; i--) {
            array[i] = (byte)(b & 1);
            b = (byte) (b >> 1);
        }
        return array;
    }

}

相关依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.netty</groupId>
    <artifactId>tcp-test</artifactId>
    <name>tcp-test</name>
    <description>tcp-test</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

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

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.13</version>
        </dependency>

        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.45.Final</version>
        </dependency>

        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.5</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        <dependency>
            <groupId>org.java-websocket</groupId>
            <artifactId>Java-WebSocket</artifactId>
            <version>1.5.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                            <goal>build-info</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

相关代码查阅了很多文章，如有侵权请联系删除。。。

Netty 实现socket 连接和WebSocket 同时连接，并相互通信
XCG123456789的专栏
07-20 3145
1、maven 依赖 <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.65.Final</version> </dependency> 2、Server 端 public class HttpServer { private int port;
Netty 同一个端口支持Tcp和 websocket
huaye2007的专栏
09-29 6577
在Netty 实战群里讨论了下能否一个端口支持tcp和websocket . 既然websocket是从http升级到websocket的 Netty能判断http的话 理论上能判断出是http的话，那就应该可以的。服务器监听端口，在最开始添加一个decode 这里判断是tcp还是http 来选择添加对应的编解码器。既然理论上行的通 ，那现在就开始验证下吧。 服务器端添加一个SelectDeco...
websocket 占用 端口_是否可以使用同一端口启用tcp，http和websocket？
weixin_39989384的博客
12-19 2245
我正在尝试在同一端口上启用tcp，http和websocket.io通信。我开始使用tcp服务器(在////行上方)，它可以正常工作。然后，我运行了在websocket.io(位于////行下方的部分)上找到的echo服务器示例，它也可以正常工作。但是当我尝试将它们合并在一起时，tcp不再起作用。因此，是否可以使用同一端口启用tcp，http和websockets？还是我必须在另一个端口上监听tc...
Socket 与 WebSocket
朱.MFの博客
02-13 269
Socket 与 WebSocket
同时支持websocket和socket的框架
try_mistake的博客
09-22 2387
##前言： 通过之前的几篇文章我们详细的介绍到了一个socket框架应该怎么架构，需要些什么模块，可是美中不足的就是它只支持最简单的socket协议，不能够满足实际生产情况，于是我便对此框架进行了改造，让它能够同时支持websocket 和 socket ，而且插件式 注册，当需要别的长连接协议的时，完全可以自己定制。已经把所有代码整合了，希望给个星星支持一下 microSocket。 ##实现基...
Netty实现同端口接收 TCP 和 WebSocket 连接
zsj777的专栏
06-22 2062
1、实现原理是基于websocket的连接握手协议是以GET /开头的，利用netty对handler的热插拔实现同一端口tcp和websocket双协议共存。实现代码如下server启动类 协议选择类 websocket消息接收处理类 Websocket在线测试-Websocket接口测试-Websocket模拟请求工具...
Netty一个端口支持tcp和websocket
09-29
在本文中，我们将深入探讨如何利用 Netty 实现一个端口同时支持 TCP 和 WebSocket，从而减少资源消耗并简化服务器配置。 TCP（传输控制协议）是一种面向连接的、可靠的传输层协议，它保证了数据的顺序传输和错误...
Socket 和 WebSocket 的应用
最新发布
weixin_48591974的博客
11-07 1259
在互联网中，套接字通常基于 TCP（传输控制协议）或 UDP（用户数据报协议）来实现数据的可靠传输或快速传输。它是一组用于网络通信的API，包括了一系列的函数和数据结构，它提供了一种标准的网络编程接口，使得应用程序可以在网络中进行数据传输。UDP（User Data Protocol，用户数据报协议）是无连接的，即发送数据之前不需要建立连接，类似于发短信，我只管发，能不能接收到跟我关系不大。WebSocket 是一种网络通信协议，它实现了客户端与服务器之间的全双工通信，是 HTML5 一种新的协议。
springboot-netty框架搭建socket-websocket同端口服务端
u011001843的博客
03-26 6035
项目需求：搭建服务与设备进行socket通信；与api服务端进行http请求(或websocket)通信传递消息； 项目环境：IDEA+Maven ;springboot；mybatis；netty； 1.服务端DiscardServer /** * 丢弃任何进入的数据 启动服务端的DiscardServerHandler */ @Component public class Dis...
WebSocket和Socket Client连共同Sever端并实现相互通信（C#、JS、C++）
刘朋
09-15 6159
分析websocket client传过来的http header中包含“Upgrade: websocket”，只需要在socket server端，检测到客户端连上来之后，马上接收一次信息，并判断本次接收到的信息是否包含websocket就可以了。3、开启C#实现的socket server，再用websocket连接下，server端检测到有客户端连上来了，客户端也没有报错，说明websocket已连到socket server。
WebSocket 协议以及 Socket 接口
青蛙king的博客
05-14 3318
在项目开发时，我们经常需要与服务器进行持续的通讯以保持双方信息的同步。通常这种持久通讯在不刷新页面的情况下进行，消耗一定的内存资源常驻后台，并且对于用户不可见。轮询：定时轮询：通过 Ajax 轮询请求，每隔一秒或者一段时间请求一次服务器查看是否有未读消息。长轮询：每一个请求发送到服务器时，服务器将请求卡主，直到有消息时才返回。使用 WebSocket 协议（推荐）由于轮询存在明显的弊端：占用服务端地资源, 增大服务端压力，会产生很多无效请求，而且消息存在延时性。
Netty 单端口支持 TCP 和 WebSocket
gitblog_09757的博客
10-21 319
Netty 单端口支持 TCP 和 WebSocket 【下载地址】Netty单端口支持TCP和WebSocket 本资源文件提供了一个基于 Netty 框架的实现，能够在同一个端口上同时支持 TCP 和 WebSocket 协议。通过这种方式，您无需为不同的协议开启多个端口，从而简化了网络配置和管理 ...
Netty 实现 一个端口同时接收 socket 和 webSocket 连接
qq_42855293的博客
10-28 3915
项目是在 Springboot 集成 Netty 的基础上开发。 参考文章： 1、SpringBoot 整合 Netty 实现Socket：https://www.cnblogs.com/guoyuchuan/p/9581283.html 2、Netty 实现 webSocket：https://www.cnblogs.com/miller-zou/p/7002070.html 3、同时实现 Socket && WebScoket：https://cloud.tencent.com/dev
webSocket connection to ‘ws://127.0.0.1:3000/websocket/15/‘ failed:
m0_74163986的博客
11-22 2811
今天写一个ws发起请求小demo，结果一直报错，总以为是前端有问题，以为sockerUrl的字符串写错了，结果到后来才发现是后端没写WebSocket的配置类。1.就是socketUrl那个字符串，完完全全盯着看不知道看了多久，结果他根本没错，2.如果使用了jwt或者security，一定要在配置类里面放行，比如重写这个方法。符号这个键，要英文输入，且不加shift），不能用双引号或者单引号，符号包起来（就是esc键下面那个键，有。简单说一下这个问题检查了哪些东西，简直太蠢了，希望少犯低价错误。
Socket通信与WebSocket协议
qq_55648724的博客
08-24 1617
目录文章目录前言一、Socket通信1.1 BIO1.2 NIO1.3 AIO二、WebSocket协议总结 Socket是一种用于网络通信的编程接口（API），它提供了一种机制，使不同主机之间可以通过网络进行数据传输和通信。Socket是支持TCP/IP协议栈的应用层与传输层之间的接口。在Socket编程中，有两种常见的角色：客户端和服务器端。客户端负责发起连接请求，服务器端负责接收并处理连接请求。Socket通信的基本流程如下：通过Socket编程，可以实现不同设备之间的网络通信。例如，可以使用Soc
websocket 与 socket
随风飘雁
11-03 1332
websocket 与 socket
[使用WebSocket连接socket.io服务器] - 实现实时通信
.
03-28 1341
在使用socket.io时，我们需要通过WebSocket连接到socket.io服务器上，这就需要使用WebSocket来进行通信。函数用于创建一个socket对象，第一个参数是socket.io服务器的地址，第二个参数是一个选项对象，用于指定使用的传输方式，这里我们指定使用WebSocket传输。总的来说，使用WebSocket连接socket.io服务器是实现实时通信的关键步骤之一，掌握了这个技巧，就可以方便地进行实时通信开发。传输方式，socket.io还支持其他多种传输方式，包括。
Java-WebSocket连接socket
m0_46294211的博客
09-01 1158
java链接socket 　
Socket和Websocket
zy010101博客
12-08 2160
**Socket是端到端的通信。** **Websocket客户端到服务器通信**
C#实现Socket与WebSocket聊天功能源码解析
Socket是网络编程的基础，通过IP地址和端口号实现不同虚拟机或不同计算机之间的通信，主要使用的协议是TCP和UDP。本文主要涉及到TCP协议的Socket通信，详细讲解了TCP/IP的三次握手和四次挥手的过程，以及socket的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值