netty之编解码

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

1、netty的编码和解码，在数据传输的时候，考虑数据安全，数据完整性都是很有必要的。这里主要是介绍netty3和netty5的编解码方式。其实从StringEncoder和StringDecoder中也可以获取源码的编解码规则。然后改变成自己的编解码规则也是可以的。

2、netty3和netty5的编解码方式还是存在一定差别的。个人感觉netty5来的更加实用和方便。

3、netty3的编解码规则

1）数据编码规则（我这里只是用于显示，数据规则很简单）

包头+模块+数据（请求编解码）

包头+模块+状态+数据（响应编解码）

2）目录

3）请求和相应对象

package com.troy.data.domain;

//请求数据

public class Request {

    //模块类型

    private int model;

    //数据

    private byte[] data;

    public int getModel() {

        return model;

    }

    public void setModel(int model) {

        this.model = model;

    }

    public byte[] getData() {

        return data;

    }

    public void setData(byte[] data) {

        this.data = data;

    }

    @Override

    public String toString() {

        return "Request{" +

                "model=" + model +

                ", data=" + new String(data) +

                '}';

    }

}

package com.troy.data.domain;

import java.util.Arrays;

//响应数据

public class Response {

    //模块类型

    private int model;

    //状态码

    private int status;

    //数据

    private byte[] data;

    public int getModel() {

        return model;

    }

    public void setModel(int model) {

        this.model = model;

    }

    public int getStatus() {

        return status;

    }

    public void setStatus(int status) {

        this.status = status;

    }

    public byte[] getData() {

        return data;

    }

    public void setData(byte[] data) {

        this.data = data;

    }

    @Override

    public String toString() {

        return "Response{" +

                "model=" + model +

                ", status=" + status +

                ", data=" + new String(data) +

                '}';

    }

}

4）常量（这里的包头，因为是固定的就写了一个常量）

package com.troy.data.constant;

//常量

public class ConsantUtil {

    //固定常量用于数据拼接，确认

    public static final int PACKAGE_HEADER = -;

}

5）请求编解码

package com.troy.data.codec;

import com.troy.data.constant.ConsantUtil;

import com.troy.data.domain.Request;

import org.jboss.netty.buffer.ChannelBuffer;

import org.jboss.netty.buffer.ChannelBuffers;

import org.jboss.netty.channel.Channel;

import org.jboss.netty.channel.ChannelHandlerContext;

import org.jboss.netty.handler.codec.oneone.OneToOneEncoder;

public class RequestEncode extends OneToOneEncoder {

    protected Object encode(ChannelHandlerContext channelHandlerContext, Channel channel, Object o) throws Exception {

        Request request = (Request) o;

        ChannelBuffer channelBuffer = ChannelBuffers.dynamicBuffer();

        channelBuffer.writeInt(ConsantUtil.PACKAGE_HEADER);

        channelBuffer.writeInt(ConsantUtil.PACKAGE_HEADER);

        channelBuffer.writeBytes(request.getData());

        return channelBuffer;

    }

}

package com.troy.data.codec;

import com.troy.data.constant.ConsantUtil;

import com.troy.data.domain.Request;

import org.jboss.netty.buffer.ChannelBuffer;

import org.jboss.netty.channel.Channel;

import org.jboss.netty.channel.ChannelHandlerContext;

import org.jboss.netty.handler.codec.oneone.OneToOneDecoder;

//请求数据解码

public class RequestDecode extends OneToOneDecoder {

    protected Object decode(ChannelHandlerContext channelHandlerContext, Channel channel, Object o) throws Exception {

        ChannelBuffer channelBuffer = (ChannelBuffer) o;

        if (ConsantUtil.PACKAGE_HEADER == channelBuffer.readInt()) {

            Request request = new Request();

            request.setModel(channelBuffer.readInt());

            byte[] bytes = new byte[channelBuffer.readableBytes()];

            channelBuffer.readBytes(bytes);

            request.setData(bytes);

            return request;

        }

        return null;

    }

}

6）响应编解码

package com.troy.data.codec;

import com.troy.data.constant.ConsantUtil;

import com.troy.data.domain.Response;

import org.jboss.netty.buffer.ChannelBuffer;

import org.jboss.netty.buffer.ChannelBuffers;

import org.jboss.netty.channel.Channel;

import org.jboss.netty.channel.ChannelHandlerContext;

import org.jboss.netty.handler.codec.oneone.OneToOneEncoder;

//响应编码器

public class ResponseEncode extends OneToOneEncoder {

    protected Object encode(ChannelHandlerContext channelHandlerContext, Channel channel, Object o) throws Exception {

        Response response = (Response) o;

        ChannelBuffer channelBuffer = ChannelBuffers.dynamicBuffer();

        channelBuffer.writeInt(ConsantUtil.PACKAGE_HEADER);

        channelBuffer.writeInt(response.getModel());

        channelBuffer.writeInt(response.getStatus());

        channelBuffer.writeBytes(response.getData());

        return channelBuffer;

    }

}

package com.troy.data.codec;

import com.troy.data.constant.ConsantUtil;

import com.troy.data.domain.Response;

import org.jboss.netty.buffer.ChannelBuffer;

import org.jboss.netty.channel.Channel;

import org.jboss.netty.channel.ChannelHandlerContext;

import org.jboss.netty.handler.codec.oneone.OneToOneDecoder;

//响应解码

public class ResponseDecode extends OneToOneDecoder{

    protected Object decode(ChannelHandlerContext channelHandlerContext, Channel channel, Object o) throws Exception {

            ChannelBuffer channelBuffer = (ChannelBuffer) o;

        if (ConsantUtil.PACKAGE_HEADER == channelBuffer.readInt()) {

            Response response = new Response();

            response.setModel(channelBuffer.readInt());

            response.setStatus(channelBuffer.readInt());

            byte[] bytes = new byte[channelBuffer.readableBytes()];

            channelBuffer.readBytes(bytes);

            response.setData(bytes);

            return response;

        }

        return null;

    }

}

7）设置对应的管道编解码就可以了

a、客户端

　　　　 //设置管道工厂

        clientBootstrap.setPipelineFactory(new ChannelPipelineFactory() {

            public ChannelPipeline getPipeline() throws Exception {

                ChannelPipeline channelPipeline = Channels.pipeline();

                channelPipeline.addLast("decode",new RequestEncode());

                channelPipeline.addLast("encode",new ResponseDecode());

                channelPipeline.addLast("client",new ClientHandler());

                return channelPipeline;

            }

        });

　　@Override

    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {

        Response response = (Response) e.getMessage();

        System.out.println(response.toString());

        super.messageReceived(ctx, e);

    }

b、服务端

        //设置管道流

        serverBootstrap.setPipelineFactory(new ChannelPipelineFactory() {

            public ChannelPipeline getPipeline() throws Exception {

                ChannelPipeline channelPipeline = Channels.pipeline();

                //添加处理方式

                channelPipeline.addLast("idle",new IdleStateHandler(new HashedWheelTimer(),,,));

                channelPipeline.addLast("decode",new RequestDecode());

                channelPipeline.addLast("encode",new ResponseEncode());

                channelPipeline.addLast("server",new ServerHandler());

                return channelPipeline;

            }

        });

　　@Override

    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {

        Request request = (Request) e.getMessage();

        System.out.println("client:"+request.toString());

        Response response = new Response();

        response.setModel();

        response.setStatus();

        response.setData("hello client".getBytes());

        ctx.getChannel().write(response);

        super.messageReceived(ctx, e);

    }

4、netty5的编解码规则

1）数据结构、目录结构、对象、常量都是一样。

2）编解码的编写方式有些不一样

a、请求编解码

package com.troy.data.codec;

import com.troy.data.constant.ConsantUtil;

import com.troy.data.domain.Request;

import io.netty.buffer.ByteBuf;

import io.netty.buffer.Unpooled;

import io.netty.channel.ChannelHandler;

import io.netty.channel.ChannelHandlerContext;

import io.netty.handler.codec.MessageToMessageEncoder;

import java.util.List;

@ChannelHandler.Sharable

public class RequestEncode extends MessageToMessageEncoder<Request> {

    protected void encode(ChannelHandlerContext channelHandlerContext, Request request, List<Object> list) throws Exception {

        ByteBuf byteBuf = Unpooled.buffer();

        byteBuf.writeInt(ConsantUtil.PACKAGE_HEADER);

        byteBuf.writeInt(request.getModel());

        byteBuf.writeBytes(request.getData());

        list.add(byteBuf);

    }

}

package com.troy.data.codec;

import com.troy.data.constant.ConsantUtil;

import com.troy.data.domain.Request;

import io.netty.buffer.ByteBuf;

import io.netty.channel.ChannelHandler;

import io.netty.channel.ChannelHandlerContext;

import io.netty.handler.codec.MessageToMessageDecoder;

import java.util.List;

//请求数据解码

@ChannelHandler.Sharable

public class RequestDecode extends MessageToMessageDecoder<ByteBuf>{

    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) throws Exception {

        if (ConsantUtil.PACKAGE_HEADER == byteBuf.readInt()) {

            //当数据超过指定值的时候跳过这部分数据

            if (byteBuf.readableBytes() > ) {

                byteBuf.skipBytes(byteBuf.readableBytes());

            }

            //一个字节一个字节的读取，知道读取到包头

            while(true) {

                byteBuf.markReaderIndex();

                if (ConsantUtil.PACKAGE_HEADER == byteBuf.readInt()) {

                    break;

                }

                byteBuf.resetReaderIndex();

                byteBuf.readByte();

            }

            Request request = new Request();

            request.setModel(byteBuf.readInt());

            byte[] bytes = new byte[byteBuf.readableBytes()];

            byteBuf.readBytes(bytes);

            request.setData(bytes);

            list.add(request);

        }

    }

}

b、响应编解码

package com.troy.data.codec;

import com.troy.data.constant.ConsantUtil;

import com.troy.data.domain.Response;

import io.netty.buffer.ByteBuf;

import io.netty.buffer.Unpooled;

import io.netty.channel.ChannelHandler;

import io.netty.channel.ChannelHandlerContext;

import io.netty.handler.codec.MessageToMessageEncoder;

import java.util.List;

//响应编码器

@ChannelHandler.Sharable

public class ResponseEncode extends MessageToMessageEncoder<Response> {

    protected void encode(ChannelHandlerContext channelHandlerContext, Response response, List<Object> list) throws Exception {

        ByteBuf byteBuf = Unpooled.buffer();

        byteBuf.writeInt(ConsantUtil.PACKAGE_HEADER);

        byteBuf.writeInt(response.getModel());

        byteBuf.writeInt(response.getStatus());

        byteBuf.writeBytes(response.getData());

        list.add(byteBuf);

    }

}

package com.troy.data.codec;

import com.troy.data.constant.ConsantUtil;

import com.troy.data.domain.Response;

import io.netty.buffer.ByteBuf;

import io.netty.channel.ChannelHandler;

import io.netty.channel.ChannelHandlerContext;

import io.netty.handler.codec.MessageToMessageDecoder;

import java.util.List;

//响应解码

@ChannelHandler.Sharable

public class ResponseDecode extends MessageToMessageDecoder<ByteBuf>{

    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) throws Exception {

        if (ConsantUtil.PACKAGE_HEADER == byteBuf.readInt()) {

            //当数据超过指定值的时候跳过这部分数据

            if (byteBuf.readableBytes() > ) {

                byteBuf.skipBytes(byteBuf.readableBytes());

            }

            //一个字节一个字节的读取，知道读取到包头

            while(true) {

                byteBuf.markReaderIndex();

                if (ConsantUtil.PACKAGE_HEADER == byteBuf.readInt()) {

                    break;

                }

                byteBuf.resetReaderIndex();

                byteBuf.readByte();

            }

            Response response = new Response();

            response.setModel(byteBuf.readInt());

            response.setStatus(byteBuf.readInt());

            byte[] bytes = new byte[byteBuf.readableBytes()];

            byteBuf.readBytes(bytes);

            response.setData(bytes);

            list.add(response);

        }

    }

}