Netty，Tcp，socket的java框架，netty学习

最新更新，报文发送，机器终端（车）与服务端

先学习一下基本内容，以下是基于基本内容

互相转换：byte（字节，字节是数字单位，他的数组是十进制内容），bit（二进制内容，不用操心这部分），十六进制0x(0-9-a-f)，String（字符的数组，引用类型）

框架与语言：socket(tcp)，java，netty

java代码

终端发给服务端，16进制字符串 转换 10进制的字节数组（数字数组）。通过outStream流发送。

服务端下发给终端，与上句原理一样。

String sourceStrs="AB AA";//AA是170，AB是171//有多个用空格隔开

//因为bytes[]不能追加，所以用字节流写入，写入后在转换
ByteArrayOutputStream output = new ByteArrayOutputStream();

String[] sourceStrArr = sourceStrs.split(" ");
for (int i = 0; i < sourceStrArr.length; i++) {
	String sourceStr = sourceStrArr[i];
	String byteNum = Tools.trans16t10(sourceStr);//将16进制字符串转换 得到字节
	output.write(Integer.parseInt(byteNum));//将单个字节追加
}
byte[] sendBytes = output.toByteArray();//将字节流转换为字节数组
//写一个字节数组过去
outputStream.write(sendBytes);

服务端解析终端，二进制转换为byte[]数组，数组转为16进制。就能解析出16进制内容

我用的netty，他的事件部分，decode执行的部分

//创建一个字节数组

byte[] bufs2=new byte[in.readableBytes()];
//将接收的字节存放到字节数组中
in.readBytes(bufs2);//in是ByteBuf in重写的内容，终端传来的数据
//将字节数组，他转成16进制的内容,这样就能和协议匹配了
String jiqiStr = TuLiTcpTools.bytes2hex(bufs2);

方法补充:

trans16t10

 public static String trans16t10(String str){

        String myStr[] = { "a", "b", "c", "d", "e", "f" };
        int result = 0;
        int n = 1;
        for (int i = str.length() - 1; i >= 0; i--) {
            String param = str.substring(i, i + 1);
            for (int j = 0; j < myStr.length; j++) {
                if (param.equalsIgnoreCase(myStr[j])) {
                    param = "1" + String.valueOf(j);
                }
            }
            result += Integer.parseInt(param) * n;
            n *= 16;
        }
//        System.out.println(result);
//        System.out.println(Integer.parseInt(str, 16));
        return String.valueOf(result);
    }

bytes2hex，10进制转16进制

public static String bytes2hex(byte[] bytes) {
    StringBuilder sb = new StringBuilder();
    String tmp;
    sb.append("[");
    for (byte b : bytes) {
        // 将每个字节与0xFF进行与运算，然后转化为10进制，然后借助于Integer再转化为16进制
        tmp = Integer.toHexString(0xFF & b);
        if (tmp.length() == 1) {
            tmp = "0" + tmp;//只有一位的前面补个0
        }
        sb.append(tmp).append(" ");//每个字节用空格断开
    }
    sb.delete(sb.length() - 1, sb.length());//删除最后一个字节后面对于的空格
    sb.append("]");
    return sb.toString();
}

---

netty程序

一个netty程序，分3个内容，前2个必须要，第3个依据业务可选

1.netty服务端的server，包含netty的配置和启动

2.handler处理端，对客户端（终端）发来的数据进行处理

3.编解码器，它其实是两部分，编码和解码，一般把他定义在handler之前

一个完整的netty服务端（JAVA版）

导入netty依赖

		
			io.netty
			netty-all
			4.1.36.Final
		

编写server

package nettyServer;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

public class nServer {
    public static void main(String[] args) throws InterruptedException {
        //创建bossGroup，接受连接请求，用evnetLoopGroup接受
        //创建workGroup，执行工作，业务处理
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workGroup = new NioEventLoopGroup();
        //上面2个是线程组，loop循环，这2个都是无限循环

        //创建配置参数
        ServerBootstrap bootstrap = new ServerBootstrap();

        //使用链式编程，设置
        bootstrap.group(bossGroup,workGroup)//设置2个线程组
                .channel(NioServerSocketChannel.class)//指定服务通道为nio模型
                .option(ChannelOption.SO_BACKLOG,128)//设置线程得到的连接个数
                .childOption(ChannelOption.SO_KEEPALIVE,true)//设置保持长连接状态
                .childHandler(new ChannelInitializer() {
                    @Override//给pipline设置处理器
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        ChannelPipeline pipeline = socketChannel.pipeline();

                        pipeline.addLast("decoder",new nDecode());
                        pipeline.addLast(new nHandler());//增加处理器,handler

                    }
                });//设置work的EventLoop对应管道设置处理器
        System.out.println("服务器准备完成");

        //绑定端口，并且同步处理，future对象
        ChannelFuture channelFuture = bootstrap.bind(12306).sync();
        //当监听到后，处理完，在关闭，没有监听到则不会调用
        channelFuture.channel().closeFuture().sync();

    }
}

编写handler

注意：尽量用try catch，如果像我这样Exception，在springBoot中，异常状况下，客户端可能收不到数据，并且不会出现打印异常，让你错以为是卡死的情况。

package nettyServer;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

//自定义一个handler，需要继承netty定义好的handler适配器，否则无效
public class nHandler extends ChannelInboundHandlerAdapter{
    @Override
    //ChannelHandlerContext管道，通道，地址，他都能拿到
    //msg是客户端发送来的数据
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("server ctx="+ctx);
        //将msg 转成一个ByteBuf
        //ByteBuf 是 Netty 提供的，注意不要使用nio的byteBuffer
        System.out.println(msg);
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("客户端发送的消息是"+buf.toString(CharsetUtil.UTF_8));

    }

    @Override
    //读完了客户端的消息后，执行的内容
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //要写完，之后在flush，flush是发送（刷新，到通道)
        //对发送的数据进行编码
        ctx.channel().writeAndFlush(Unpooled.copiedBuffer("我收到了\r\n",CharsetUtil.UTF_8));
    }

    //处理异常，一般是关闭通道
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }
}

编写解码器（业务不需要可以删除）

注:可以复制重写的方法，但是不能直接复制，我的代码内容，我引入了自己业务中的工具类。

package com.dt.tuli.springBoot_netty;

import com.dt.tuli.tools.TuLiTcpTools;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.util.CharsetUtil;
import nettyServer.nServerAccept;

import java.util.List;

public class nDecodeSpringBoot extends ByteToMessageDecoder {

    //ctx上下文，比如地址ip，端口等，从这拿
    //in,客户端发来的数据
    //rs经过解码器，最后保留的数据，输出的数据
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List