Mina实现自定义协议的通信

最新推荐文章于 2021-03-18 02:14:11 发布
最新推荐文章于 2021-03-18 02:14:11 发布
阅读量1k 收藏
点赞数 1
分类专栏： java socket
java 同时被 2 个专栏收录
152 篇文章 1 订阅
订阅专栏
socket
18 篇文章 0 订阅
订阅专栏

转http://www.open-open.com/lib/view/open1351557171910.html


网络的传输使用需要遵循一定的规则，这些规则我们称为协议。如在互联网请求HTML页面的时候，我们要遵循HTTP协议，HTTP头的格式就是我们要遵守的规则：

01Request Headers
02Accept:
03text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
04Accept-Charset:
05GBK,utf-8;q=0.7,*;q=0.3
06Accept-Encoding:
07gzip,deflate,sdch
08Accept-Language:
09zh-CN,zh;q=0.8
10Cache-Control:
11max-age=0

比如我们在做一些第三方开发的时候，经常会按照固定的格式向服务器端发送请求，服务器验证消息后，返回相应的结果。在Mina的开发中，我们也会用到这种模式。首先我们先来描述下这种方式的使用情形：

这样的方式，目前，我所在的项目组中主要用于通信和传输。为了将文件从客户端传到云端，我们先在客户端将数据根据一定的规则切片，然后通过一种特定的格式传输到服务器端。Mina，作为这中间的桥梁，秉承了框架很好的优点，快速开发。由于我们的服务器端采用的是C写的，所以我只给出客户端的编码过程，解码过程原理和开发都一样。

 用Mina执行一定协议的传输，主要有以下几个步骤：

1.         设计通信协议；

2.         编写请求（返回）对象和业务对象；

3.         编写解码（编码）器；

4.         编写客户端、服务器端。

Mina实现自定义协议的通信

下面根据代码，一步步介绍这个过程，由于是前提的测试代码，所以没有考虑线程安全等问题，只是一个思路：

首先是通信的协议，根据mina的构建规则，将协议设计成抽象类，由请求对象和返回对象分别去继承，协议格式如下：

01package com.a2.desktop.example5.mina.potocol;
02 
03 
04import org.apache.mina.core.buffer.IoBuffer;
05 
06/**
07 * 通信协议
08 * @author Chen.Hui
09 *
10 */
11public abstract class AbsMessage {
12     
13    /**
14     * 协议格式：
15     *
16     * tag | header length | Filename | File length | offset | checksum | temps | data
17     *
18     */
19 
20    /** 请求或访问类型 请求Tag：0x00 返回Tag:0x01 共 8 bit */
21    public abstract byte getTag();
22 
23    /** 头文件长度 共 2^16 可表示 65535 */
24    public abstract short getHeaderlen();
25 
26    /** 根据UUID生成文件唯一标识，共 8*36=288 bit */
27    public abstract byte[] getFilename();//需要設計一個算法
28 
29    /** 获取文件长度 2^32=4GB 共 32 bit */
30    public abstract int getFileLen();
31 
32    /** 获取文件的偏移量offset 共 32 bit */
33    public abstract int getOffset();
34 
35    /** 获取文件的MD5校验码 共 32 bit */
36    public abstract byte[] getChecksum();
37 
38    /** 预留字段 长度不超过 128 bit */
39    public abstract byte[] getTmp();
40     
41    /**data 方式传输内容 不超过1024bit*/
42    public abstract IoBuffer getData();
43 
44}

下面是请求对象（返回）和业务对象，这里的业务对象主要功能是将文件切片：

01package com.a2.desktop.example5.mina.potocol;
02 
03import java.io.IOException;
04import java.nio.charset.Charset;
05 
06import org.apache.mina.core.buffer.IoBuffer;
07import org.slf4j.Logger;
08import org.slf4j.LoggerFactory;
09 
10/**
11 * 请求对象
12 *
13 * @author Chen.Hui
14 *
15 */
16public class InfoRequest extends AbsMessage {
17 
18    Logger logger = LoggerFactory.getLogger(InfoRequest.class);
19 
20    FilePiece piece;
21 
22    Charset charset;
23 
24    public InfoRequest(FilePiece piece) {
25        this.piece = piece;
26    }
27     
28    public InfoRequest(){
29        //empty
30    }
31 
32    @Override
33    public byte getTag() {// 0x01 请求包
34        return (byte) 0x01;
35    }
36 
37    @Override
38    public short getHeaderlen() {
39        if (getTmp() == null) {
40            short len = (short) (1 + 2 + 36 + 4 + 4 + 4 );
41            return len;
42        } else {
43            short len = (short) (1 + 2 + 36 + 4 + 4 + 4 + (short) getTmp().length);
44            return len;
45        }
46    }
47 
48    @Override
49    public int getFileLen() {// 文件总长度
50 
51        try {
52            return (int) piece.getFc().size();
53 
54        } catch (IOException e) {
55            e.printStackTrace();
56        }
57        return 0;
58    }
59 
60    @Override
61    public int getOffset() {// 传输 偏移量
62 
63        return piece.getOffset();
64 
65    }
66 
67    @Override
68    public byte[] getFilename() {// 文件名称
69 
70        /** check the bits of name */
71        byte[] name = new byte[36];
72        name = piece.getFilename().getBytes();
73 
74        return name;
75 
76    }
77 
78    @Override
79    public byte[] getChecksum() {// checksum
80 
81        byte[] checksum = new byte[4];
82        checksum = piece.getChecksum().getBytes(); 
83        return checksum;
84    }
85 
86    @Override
87    public byte[] getTmp() {
88        byte[] b=new byte[5];
89        return b;
90    }
91 
92    @Override
93    public IoBuffer getData() {
94        return piece.getBuf();
95    }
96}
业务对象代码，RandomAccessFile可用于随机读写，用于文件的切片，这里还用了管道，主要目的是为了加开读写速度：



01package com.a2.desktop.example5.mina.potocol;
02 
03import java.io.File;
04import java.io.RandomAccessFile;
05import java.nio.ByteBuffer;
06import java.nio.channels.FileChannel;
07import java.util.UUID;
08 
09import org.apache.mina.core.buffer.IoBuffer;
10import org.slf4j.Logger;
11import org.slf4j.LoggerFactory;
12 
13/**
14 * 分片文件操作类
15 *
16 * @author Chen.Hui
17 *
18 */
19public class FilePiece {
20 
21    Logger logger = LoggerFactory.getLogger(FilePiece.class);
22 
23    private ByteBuffer[] dsts;
24     
25    private IoBuffer buf;
26 
27    private String filename;
28 
29    private FileChannel fc;
30 
31    private RandomAccessFile raf;
32 
33    private int offset;
34 
35    private String checksum;
36 
37    /** 构建文件的基本信息 */
38    public FilePiece(String path, int offset) throws Exception {
39 
40        raf = new RandomAccessFile(new File(path), "rw");
41        fc = raf.getChannel();
42 
43        this.offset = offset;
44 
45        dsts = new ByteBuffer[1024];
46 
47        for (int i = 0; i < dsts.length; i++) {
48            dsts[i] = ByteBuffer.allocate(1024);
49        }
50 
51        fc.read(dsts, offset, 1024);
52         
53         
54        buf=IoBuffer.allocate(1024);
55 
56        filename = UUID.randomUUID().toString();
57        logger.info("has built:" + filename + " filename size"
58                + filename.length());
59 
60    }
61    /**这个方法还有点儿问题，数据取的不对*/
62    public IoBuffer getBuf(){
63        dsts[0].flip();
64        while(dsts[0].hasRemaining()){
65            buf.putChar(dsts[0].getChar());
66        }
67        buf.flip();
68        return buf;
69    }
70 
71    public String getFilename() {
72        return filename;
73    }
74 
75    public FileChannel getFc() {
76        return fc;
77    }
78 
79    public RandomAccessFile getRaf() {
80        return raf;
81    }
82 
83    public int getOffset() {
84        return offset;
85    }
86 
87    public String getChecksum() {
88        // TODO checksum algorithems
89        return "aaaa";
90    }
91}
再接下来是编码器 ，编码器的作用就是讲数据装换成用于传输的流，在Mina中这种流就是IoBuffer：
01package com.a2.desktop.example5.mina.potocol;
02 
03import java.nio.charset.Charset;
04 
05import org.apache.mina.core.buffer.IoBuffer;
06import org.apache.mina.core.session.IoSession;
07import org.apache.mina.filter.codec.ProtocolEncoderOutput;
08import org.apache.mina.filter.codec.demux.MessageEncoder;
09 
10/**
11 * 编码器
12 * @author Chen.Hui
13 *
14 */
15public class InfoEncoder implements MessageEncoder<absmessage>{
16 
17    private Charset charset;
18     
19    public InfoEncoder(Charset charset){
20        this.charset=charset;
21    }
22     
23    @Override
24    public void encode(IoSession session, AbsMessage message,
25            ProtocolEncoderOutput out) throws Exception {
26         
27        IoBuffer buf=IoBuffer.allocate(1024).setAutoExpand(true);
28         
29        if(message instanceof InfoRequest){
30             
31            InfoRequest req=(InfoRequest) message;
32            buf.put(req.getTag());
33            buf.putShort((short)req.getHeaderlen());
34            buf.put(req.getFilename());
35            buf.putInt(req.getFileLen());
36            buf.putInt(req.getOffset());
37            buf.put(req.getChecksum());
38            buf.put(req.getTmp());
39            buf.put(req.getData());
40             
41        }else if(message instanceof InfoResponse){
42            //TODO
43        }
44                 
45        buf.flip();
46         
47        out.write(buf);
48    }
49}</absmessage>

解码器与之类似，解码器在这里的作用主要用户服务器端解码：

01package com.a2.desktop.example5.mina.potocol;
02 
03import java.nio.charset.Charset;
04 
05import org.apache.mina.core.buffer.IoBuffer;
06import org.apache.mina.core.session.IoSession;
07import org.apache.mina.filter.codec.ProtocolDecoderOutput;
08import org.apache.mina.filter.codec.demux.MessageDecoder;
09import org.apache.mina.filter.codec.demux.MessageDecoderResult;
10/**
11 * 解码器
12 * @author ChenHui
13 *
14 */
15public class InfoDecoder implements MessageDecoder {
16 
17    private Charset charset;
18 
19    public InfoDecoder(Charset charset) {
20        this.charset = charset;
21    }
22 
23    @Override
24    public MessageDecoderResult decodable(IoSession session, IoBuffer in) {
25 
26        //System.out.println("package size:"+in.remaining());
27        // 报头长度<56
28        if (in.remaining() < 56) {
29            return MessageDecoderResult.NEED_DATA;
30        }
31 
32        byte tag = in.get();
33        short head_len=in.getShort();
34 
35        if (tag == (short) 0x01) {
36            System.out.println("请求标识符："+tag+" head length:"+head_len);
37        }else{
38            //System.out.println("未知标识符...");
39            return MessageDecoderResult.NOT_OK;
40        }
41 
42        return MessageDecoderResult.OK;
43    }
44 
45    @Override
46    public MessageDecoderResult decode(IoSession session, IoBuffer in,
47            ProtocolDecoderOutput out) throws Exception {
48        byte tag=in.get();
49     
50        if(tag==0x01){
51            InfoReqContainer irc=new InfoReqContainer();
52            irc.setTag(tag);
53            irc.setHeadlen(in.getShort());
54            irc.setFilename(in.getString(36, charset.newDecoder()));
55            irc.setFilelen(in.getInt());
56            irc.setOffset(in.getInt());
57            irc.setChecksum(in.getString(4, charset.newDecoder()));
58            irc.setTemp(in.getString(5, charset.newDecoder()));//应该用head len-53
59            irc.setData(in);
60             
61            out.write(irc);
62        }
63             
64        return MessageDecoderResult.OK;
65    }
66 
67    @Override
68    public void finishDecode(IoSession session, ProtocolDecoderOutput out)
69            throws Exception {
70        // TODO Auto-generated method stub
71 
72    }
73 
74}
为了解码方便，我这里设计了一个辅助类InfoReqContainer，主要用户辅助操作：
01package com.a2.desktop.example5.mina.potocol;
02 
03import org.apache.mina.core.buffer.IoBuffer;
04 
05/**
06 * 请求对象解析类
07 *
08 * @author Chen.Hui
09 *
10 */
11public class InfoReqContainer {
12    private byte tag;
13    private short headlen;
14    private String filename;
15    private int filelen;
16    private int offset;
17    private String temp;
18    private String checksum;
19    private IoBuffer data;
20 
21    public byte getTag() {
22        return tag;
23    }
24 
25    public void setTag(byte tag) {
26        this.tag = tag;
27    }
28 
29    public short getHeadlen() {
30        return headlen;
31    }
32 
33    public void setHeadlen(short headlen) {
34        this.headlen = headlen;
35    }
36 
37    public String getFilename() {
38        return filename;
39    }
40 
41    public void setFilename(String filename) {
42        this.filename = filename;
43    }
44 
45    public int getFilelen() {
46        return filelen;
47    }
48 
49    public void setFilelen(int filelen) {
50        this.filelen = filelen;
51    }
52 
53    public int getOffset() {
54        return offset;
55    }
56 
57    public void setOffset(int offset) {
58        this.offset = offset;
59    }
60 
61    public String getTemp() {
62        return temp;
63    }
64 
65    public void setTemp(String temp) {
66        this.temp = temp;
67    }
68 
69    public String getChecksum() {
70        return checksum;
71    }
72 
73    public void setChecksum(String checksum) {
74        this.checksum = checksum;
75    }
76 
77    public IoBuffer getData() {
78        return data;
79    }
80 
81    public void setData(IoBuffer data) {
82        this.data = data;
83    }
84 
85}

在mina中，要将解码器和编码器绑定到协议工厂类中，才能被过滤器使用：

01package com.a2.desktop.example5.mina.potocol;
02 
03import org.apache.mina.filter.codec.demux.DemuxingProtocolCodecFactory;
04import org.apache.mina.filter.codec.demux.MessageDecoder;
05import org.apache.mina.filter.codec.demux.MessageEncoder;
06 
07public class InfoCodecFactory extends DemuxingProtocolCodecFactory {
08    private MessageDecoder decoder;
09 
10    private MessageEncoder<absmessage> encoder;
11 
12    public InfoCodecFactory(MessageDecoder decoder,
13            MessageEncoder<absmessage> encoder) {
14        this.decoder = decoder;
15        this.encoder = encoder;
16        addMessageDecoder(this.decoder);
17        addMessageEncoder(AbsMessage.class, this.encoder);
18    }
19}</absmessage></absmessage>

做完了这些，编码解码的工作都完成了，最后就是写客户端和服务器端进行测试，注意文件位置，这里没有做提示：

01package com.a2.desktop.example5.mina.potocol;
02 
03import java.net.InetSocketAddress;
04import java.nio.charset.Charset;
05 
06import org.apache.mina.core.future.ConnectFuture;
07import org.apache.mina.core.service.IoConnector;
08import org.apache.mina.core.session.IoSession;
09import org.apache.mina.filter.codec.ProtocolCodecFilter;
10import org.apache.mina.transport.socket.nio.NioSocketConnector;
11 
12public class TestClient {
13     
14    private static String HOST = "127.0.0.1";
15 
16    private static int PORT = 8082;
17 
18    public static void main(String[] args) {
19        // 创建一个非阻塞的客户端程序
20        IoConnector connector = new NioSocketConnector();
21        // 设置链接超时时间
22        connector.setConnectTimeout(30000);
23        // 添加过滤器
24        connector.getFilterChain().addLast(
25                "codec",
26                new ProtocolCodecFilter(new InfoCodecFactory(
27                        new InfoDecoder(Charset.forName("utf-8")),
28                        new InfoEncoder(Charset.forName("utf-8")))));
29        // 添加业务逻辑处理器类
30        connector.setHandler(new ClientHandler());
31        IoSession session = null;
32        try {
33            ConnectFuture future = connector.connect(new InetSocketAddress(
34                    HOST, PORT));// 创建连接
35            future.awaitUninterruptibly();// 等待连接创建完成
36            session = future.getSession();// 获得session
37 
38            FilePiece piece = new FilePiece(
39                    "D:\\Develop Libs Tar\\apache-mina-2.0.7-bin.zip", 0);
40 
41            InfoRequest ir = new InfoRequest(piece);
42                 
43            session.write(ir);// 发送消息
44             
45             
46        } catch (Exception e) {
47e.printStackTrace();
48            System.out.println("客户端链接异常...");
49        }
50 
51        session.getCloseFuture().awaitUninterruptibly();// 等待连接断开
52        connector.dispose();
53    }
54 
55}

客户端的Handler没有做任何处理：

01package com.a2.desktop.example5.mina.potocol;
02 
03import org.apache.mina.core.service.IoHandler;
04import org.apache.mina.core.session.IdleStatus;
05import org.apache.mina.core.session.IoSession;
06 
07public class ClientHandler implements IoHandler {
08 
09    @Override
10    public void sessionCreated(IoSession session) throws Exception {
11        // TODO Auto-generated method stub
12 
13    }
14 
15    @Override
16    public void sessionOpened(IoSession session) throws Exception {
17        // TODO Auto-generated method stub
18 
19    }
20 
21    @Override
22    public void sessionClosed(IoSession session) throws Exception {
23        // TODO Auto-generated method stub
24 
25    }
26 
27    @Override
28    public void sessionIdle(IoSession session, IdleStatus status)
29            throws Exception {
30        // TODO Auto-generated method stub
31 
32    }
33 
34    @Override
35    public void exceptionCaught(IoSession session, Throwable cause)
36            throws Exception {
37        // TODO Auto-generated method stub
38 
39    }
40 
41    @Override
42    public void messageReceived(IoSession session, Object message)
43            throws Exception {
44        //System.out.println(message.toString());
45    }
46 
47    @Override
48    public void messageSent(IoSession session, Object message) throws Exception {
49        // TODO Auto-generated method stub
50 
51    }
52 
53}
服务器端：
01package com.a2.desktop.example5.mina.potocol;
02 
03import java.net.InetSocketAddress;
04import java.nio.charset.Charset;
05 
06import org.apache.mina.core.service.IoAcceptor;
07import org.apache.mina.core.session.IdleStatus;
08import org.apache.mina.core.session.IoSessionConfig;
09import org.apache.mina.filter.codec.ProtocolCodecFilter;
10import org.apache.mina.filter.logging.LogLevel;
11import org.apache.mina.filter.logging.LoggingFilter;
12import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
13 
14 
15 
16public class TestServer{
17 
18    private static int PORT = 8082;
19 
20    public static void main(String[] args) {
21        IoAcceptor acceptor = null;
22        try {
23            // 创建一个非阻塞的server端的Socket
24            acceptor = new NioSocketAcceptor();
25 
26            // 设置过滤器（添加自带的编解码器）
27            acceptor.getFilterChain().addLast(
28                    "codec",
29                    new ProtocolCodecFilter(new InfoCodecFactory(
30                            new InfoDecoder(Charset.forName("utf-8")),
31                            new InfoEncoder(Charset.forName("utf-8")))));
32            // 设置日志过滤器
33            LoggingFilter lf = new LoggingFilter();
34            lf.setMessageReceivedLogLevel(LogLevel.DEBUG);
35            acceptor.getFilterChain().addLast("logger", lf);
36            // 获得IoSessionConfig对象
37            IoSessionConfig cfg = acceptor.getSessionConfig();
38            // 读写通道10秒内无操作进入空闲状态
39            cfg.setIdleTime(IdleStatus.BOTH_IDLE, 100);
40 
41            // 绑定逻辑处理器
42            acceptor.setHandler(new ServerHandler());
43            // 绑定端口
44            acceptor.bind(new InetSocketAddress(PORT));
45            System.out.println("成功开启服务器端...");
46             
47        } catch (Exception e) {
48             
49            e.printStackTrace();
50        }
51    }
52}        

服务器端的Handler：

查看源码 打印 ?
01package com.a2.desktop.example5.mina.potocol;
02 
03import org.apache.mina.core.service.IoHandler;
04import org.apache.mina.core.session.IdleStatus;
05import org.apache.mina.core.session.IoSession;
06 
07public class ServerHandler implements IoHandler {
08 
09    @Override
10    public void sessionCreated(IoSession session) throws Exception {
11        // TODO Auto-generated method stub
12 
13    }
14 
15    @Override
16    public void sessionOpened(IoSession session) throws Exception {
17        // TODO Auto-generated method stub
18 
19    }
20 
21    @Override
22    public void sessionClosed(IoSession session) throws Exception {
23        // TODO Auto-generated method stub
24 
25    }
26 
27    @Override
28    public void sessionIdle(IoSession session, IdleStatus status)
29            throws Exception {
30        // TODO Auto-generated method stub
31 
32    }
33 
34    @Override
35    public void exceptionCaught(IoSession session, Throwable cause)
36            throws Exception {
37        // TODO Auto-generated method stub
38 
39    }
40 
41    @Override
42    public void messageReceived(IoSession session, Object message)
43            throws Exception {
44        if (message instanceof InfoReqContainer) {
45            InfoReqContainer irc = (InfoReqContainer) message;
46            System.out.println("服务器端 获取成功 Tag:" + irc.getTag() + "\r\n " + "head len:"
47                    + irc.getHeadlen() + "\r\nfilename: " + irc.getFilename()
48                    + "\r\nfile len:"+irc.getFilelen()+"\r\noffset:"+irc.getOffset()+"\r\nchecksum:"+irc.getChecksum()+"\r\ndata:"+irc.getData().toString());
49             
50            session.write("success rescive");
51             
52        } else {
53            System.out.println("获取失败");
54        }
55 
56    }
57 
58    @Override
59    public void messageSent(IoSession session, Object message) throws Exception {
60        // TODO Auto-generated method stub
61 
62    }
63 
64}

fendou4533
关注
专栏目录
Mina学习（3）：实现简单自定义协议包（报文）
Liao Tuo
10-08 4078
一、自定义协议包：本次简单的协议包中， 封装了报文的长度，协议版本，以及需要传输的文本内容。二、实现代码：package protocal; /*** * 一个简单的协议包类 * @author liaot * */ public class ProtocalPackage { private int length; //长度 private byte flag; //协议版
Java - Apache Mina 自定义协议通信
袭冷
06-30 4312
一、定义协议实体 import java.nio.charset.Charset; /** * 自定义协议的消息体 */ public class MyMsg { /** * 消息长度 */ private Integer lenth; /** * 发送人 */ private Long sender; /** * 接收人 */ p
Mina自定义协议简单实现
12-02
公司需求，做的简单的Demo，可以拓展，Mina自定义协议简单实现，象征性得收取2积分
Mina自定义协议
Simple、
01-06 261
请求协议格式 req{ short tag;// 16位，0x0001 int length;//  32位，从下一字节开始至末尾的数据长度即数据区长度(后面会提到数据区) short channelId;// 16位，频道id byte  channelDes;// 8位，频道信息说明(类似说明信息的长度) for(i=0;i&lt;challelDes;i+...
十-Mina学习之自定义协议介绍
学而不思则罔，思而不学则怠
03-14 435
1.自定义的编解码工厂    要实现编解码工厂就要实现ProtocolCodecFactory这个接口2.自定义的编解码器    1.实现自定义的解码器：实现ProtocolDecoder接口    2.实现自定义的编码器：实现ProtocolEncoder接口步骤：先获得工厂，再获得编解码器。 3.为什么要使用自定义的编解码器    在实际工作中不是一个字符串就可以传输所有数据，我们传输的是自定...
Mina自定义协议通信的示例
06-30
总的来说，Mina自定义协议通信示例是一个很好的学习资源，它涵盖了网络编程的核心概念，如事件驱动模型、非阻塞I/O和自定义编解码。通过深入理解并实践这个示例，开发者能更好地掌握Mina框架，并有能力解决复杂网络...
mina 实现简单通讯
11-30
在这个“mina 实现简单通讯”的项目中，我们看到了一个基于MINA的基本通信实现，涵盖了服务端和客户端的交互。 首先，MINA的核心组件包括`IoSession`，它是网络连接的抽象，包含了与特定连接相关的所有信息，如输入...
mina框架自定义解编码器
05-17
在实践中，我们需要充分理解协议格式，合理设计解编码流程，以实现高效且可靠的网络通信。简单_mina项目的实例为初学者提供了良好的学习起点，通过研究和实践，可以更深入地掌握MINA自定义解编码器的使用技巧。
Mina自定义协议-实现数据交互
电量不足zZ
06-20 1863
本文主要现实mina的自定义协议，并且实现服务器和客户端的简单数据交互。   "mina协议的自定义"可参考本博Mina相关文章。   正题，所需要的基础类： 抽象协议类 请求协议 响应协议 (需要定制自己的协议格式)   协议编码解码工厂 协议编码 协议解码   客户端 客户端Handler  
mina仿qq聊天功能,自定义协议,协议的编码和解码详解,发送xml对象json,mina开发大全,详细api,mina心跳
06-12
mina仿qq聊天功能,自定义协议,协议的编码和解码详解,发送xml对象json,mina开发大全,详细api mina聊天 mina解码编码 mina协议开发 mina仿qq mina消息xml mina开发的在线聊天工具，mina仿qq功能，mina自定义协议，可以仿http请求，mina心跳等技术大全，mina功能大揭密
TCP协议 TCP 文件传输 大文件传输
08-06
服务器：设置IP 端口，监听，连接，传输文件名字（转2进制），传输文件（2进制），结束，关闭tcpListener 客户端：设置IP 端口，连接，接受文件名字，接受文件，写文件，结束，关闭tcpListener
TCP/IP协议的文件传输 支持断点续传，大文件传输
01-07
TCP/IP协议下的文件传输（包括超过4G的文件） 支持断点续传
mina 协议 php,Mina学习（三）：实现简单自定义协议包（报文）
weixin_39905500的博客
03-18 129
一、自定义协议包：本次简单的协议包中， 封装了报文的长度，协议版本，以及需要传输的文本内容。二、实现代码：package protocal;/**** 一个简单的协议包类* @author liaot**/public class ProtocalPackage {private int length; //报头 显示整个报文长度private String content; //报文内容//构...
Apache Mina 自定义协议
BraveHeart专栏
08-27 8127
上一篇中，我们介绍了如何在mina中编写自己的日志过滤器，这一篇我们自己实现一个编解器。实际应用当，很多应用系统应用的都不是标准的web service或XML等，比如象中国移动/联通/电信的短信网关程序，都有自己不同的协议实现，并且都是基于TCP/IP的字节流。Mina自带的编解码器实现了TextLineEncoder和TextLineDecoder，可以进行按行的字符串处理，对于象短信
mina的编码和解码以及断包的处理,发送自定义协议,仿qq聊天,发送xml或json
xmt1139057136的专栏
06-12 9692
最近一段时间以来，mina很火，和移动开发一样，异常的火爆。前面写了几篇移动开发的文章，都还不错，你们的鼓励就是我最大的动力。好了，废话少说。我们来看下tcp通讯吧。 tcp通讯对于java来说是很简单的。就是socket，也就是大家常说的套接字。大家不要把它看的很难。说白了tcp通讯其实就是数据流的读写。一条输入流，一条输出流。分别复杂发消息和接收消息。 明白了这些，ok，我们来看看我写的例子吧。先看服务器段的源码：
Mina学习 -- 自定义协议包的传输
Chook_lxk的博客
04-11 780
Protocol mina实战Demo – c/s自定义协议传输 Github项目源码 为什么要进行自定义协议传输? 因为传输过程往往不是一个字符串就可以传输全部信息，并且应用程序和网络通信之间存在对象与二进制之间的转换关系。所以需要结合业务编写自定义协议包进行传输。 编写自定义协议的基本步骤 通过mina文档可以看到，要实现自定义协议传输需要实现ProtocolCodecFactory接口，而P...
mina通讯框架详述（IoBuffer）
leng1987021的博客
06-05 455
IoBuffer 1.获取IoBuffer对象：（IoBuffer是一个抽象类，因此不能直接实例化）     // 使用指定大小实例化一个新的Buffer, 并且可以定义他的类型 (direct 或 heap) public static IoBuffer allocate(int capacity, boolean direct) // 使用指定大小实例化一个新的Bu...
Apache Mina Server网络通信框架视频教程
4. **协议处理**：学习如何使用Mina来编码和解码不同网络协议，如HTTP、FTP、SMTP等，或者自定义的二进制或文本协议。 5. **Filter Chain**：掌握过滤器链的概念，如何通过定义和组合过滤器来实现功能，如数据验证...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值