erlang的简单模拟半包的产生

 gen_tcp:linsten()/2使用的是{packet,2/4/8},则gen_tcp模块在接受或者发送时自动除去包头或者自动加上包头。

本例中使用的是{packet,0}。

-module(mod_tcp_server_listener)%%监听端口，收到新的socket就启动 mod_client_reader进程

%%监听端口，收到新的socket就启动 mod_client_reader进程
-module(mod_tcp_server_listener).
-include("common.hrl").
%% ====================================================================
%% API functions
%% ====================================================================
-export([start/1,stop_listen/1]).

%% ====================================================================
%% Internal functions
%% ====================================================================

start(Port)->
	io:format("hello tcp_server~n"),
	spawn(fun()-> start_listen(Port) end).

start_listen(Port)->
	{ok,LSocket}=	gen_tcp:listen(Port, [binary,{active,true},{packet,4}]),
	socket_accept(LSocket),
	{ok,LSocket}.

socket_accept(LSocket)->

	{ok,Socket}=gen_tcp:accept(LSocket),

	Pid=mod_client_reader:start(Socket),
	ok = gen_tcp:controlling_process(Socket, Pid),
	socket_accept(LSocket).

%%tcp_accept(Socket)->
%%	io:format("hello one accept~n"),
%%	receive
%%			{tcp,Socket,Bin}
%%			  	->
			%%	<<Length:32/integer,OneFloat:32/float,OneInt:1/big-unsigned-integer-unit:32,StrLength:2/big-unsigned-integer-unit:8,Left:9/binary>> = Bin,
			%%		io:format("receive data length: ~w,float:~w,int:~w,str size:~w~n",[Length,OneFloat,OneInt,StrLength]),
				%%	io:format("receive data: ~w~n",[byte_size(Bin)]),
			%%		io:format("receive data: ~ts~n",[Left]),
%%					NewData= <<Bin/binary,Bin/binary>>,
	%%				gen_tcp:send(Socket, NewData)
		%%			end,
			%%{tcp,Socket,?FL_POLICY_REQ}
%%	tcp_accept(Socket).

stop_listen(LSocket)->
	gen_tcp:close(LSocket).

module(mod_client_reader):%收到新的socket链接即启动一个该进程

%%收到新的socket链接即启动一个该进程
%%该进程负责玩家打开socket后正式进入游戏前的操作，负责登录验证等
%%该进程代表这客户端的socket,并将客户端到发送来的转给user进程
-module(mod_client_reader).

%% ====================================================================
%% API functions
%% ====================================================================
-export([start/1,start_io/0]).

%% 记录客户端进程
-record(client, {
			  	player_pid = undefined,%玩家的player的进程
				player_id = 0, %玩家的id
			   	login  = 0,
			   	accid  = 0,
			   	accname = undefined,
			   	timeout = 0,				% 超时次数
				sn = 0,						% 服务器号
				socketN = 0
				}
	   ).

%% ====================================================================
%% Internal functions
%% ====================================================================

start(Socket)->
	io:format("client start:~n",[]),
	spawn(fun()-> start_accept(Socket) end ).

start_accept(Socket)->
	receive
			{tcp,Socket,<<Packet_Length:32,Cmd:32,Str_Length:32,Bin:Str_Length/binary>>}->

			%%	io:format(" Data:~w,Bin:~w~n",[byte_size(Data),byte_size(Bin)] ), 

				 io:format("receive length:~w,cmd:~w,str_length:~w~n",[Packet_Length,Cmd,Str_Length] ),
				 io:format("Bin:~ts~n",[Bin]),
				io:format("============one==========================~n",[])		;
			{tcp,Socket,<<Packet_Length:32,Cmd:32,Str_Length:32,Bin:10/binary,Bin2/binary>>}->

			%%	io:format(" Data:~w,Bin:~w~n",[byte_size(Data),byte_size(Bin)] ), 

				 io:format("receive length:~w,cmd:~w,str_length:~w,bin2_length:~w~n",[Packet_Length,Cmd,Str_Length,byte_size(Bin2)] ),
				 io:format("Bin:~ts~n",[Bin]),
				 io:format("Bin2:~ts~n",[Bin2]),
				io:format("============two==========================~n",[])
		end,

	start_accept(Socket).

%%接收来自客户端的数据 - 登陆后进入游戏逻辑
%%Socket：socket id
%%Client: client记录
do_parse_packet(Socket, Client) ->
	.

start_io()->
	io:format("client start:~n",[]).

以下是java代码:

package tcp;

/**
 * @author 908204694@qq.com
 *
 */
public class Door {

	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		// TODO Auto-generated method stub

		Tcp_Client tcp_client=new Tcp_Client(0);
		tcp_client.start();

	}

}

----------------------------------------------------------------------

package tcp;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import java.net.Socket;
import java.net.UnknownHostException;

/**
 * @author 908204694@qq.com
 *
 */
public class Tcp_Client extends Thread
{
	private int id;
	private int port=5000;

	public Tcp_Client(int new_id)
	{
		this.id=new_id;
	}

	public  void run()
	{
		// TODO Auto-generated method stub

		Socket socket=null;
		try
		{
			socket=new Socket("192.168.1.113",port);
			System.out.println("连接成功-----");
		}
		catch (UnknownHostException e)
		{
			System.out.println("UnknownHostException:"+e.getLocalizedMessage());
		}
		catch (IOException e)
		{
			System.out.println("IOException:"+e.getLocalizedMessage());
		}

		InputStream input=null;

		OutputStream output=null;

		Packet packet=new Packet();
		packet.writeInt(100);
		packet.writeString("你好啊1");
		byte[] out_bytes=packet.send();;

		Packet packet1=new Packet();
		packet1.writeInt(101);
		packet1.writeString("你好啊2");
		byte[] out_bytes1=packet1.send(9);//此值不是固定的值,与位置①的长度一致

		Packet packet2=new Packet();
		packet2.writeInt(102);
		packet2.writeString("你好啊3");
		byte[] out_bytes2=packet2.send();;

		byte[] in_bytes=new byte[100];

		try
		{
			 input=socket.getInputStream();

			 output=socket.getOutputStream();

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		try
		{

			output.write(out_bytes);
			output.flush();

			output.write(out_bytes1);
			output.flush();
			output.write("你好吗".getBytes("UTF-8"));//位置①
			output.flush();

			output.write(out_bytes2);
			output.flush();

			System.out.println("发送成功--");

		} catch (IOException e1)
		{
			// TODO Auto-generated catch block
			e1.printStackTrace();
			}

		try
		{

		int read_length=	input.read(in_bytes);

			System.out.println(new String(in_bytes,0,read_length,"utf8"));
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

----------------------------------------------------------------------

package tcp;

import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;

/**
 * @author 908204694@qq.com
 *
 */
public class Packet
{

    private ByteBuffer buff;
    private int length;

    public Packet()
	{
        this(1024);
    }

    public Packet(int size)
	{
        length = size;
        buff = ByteBuffer.allocate(length);
    }

    public Packet(ByteBuffer buffer)
	{
        buff = buffer;
        length = buffer.limit();
    }

    public static Packet wrap(ByteBuffer buffer)
	{
        return new Packet(buffer);
    }

   //写入数据
    public void writeChar(char value)
	{
        buff.putChar(value);
    }

    public void writeByte(byte value)
	{
        buff.put(value);
    }

    public void writeFloat(float value)
	{
        buff.putFloat(value);
    }

    public void writeLong(long value)
	{
        buff.putLong(value);
    }

    public void writeDouble(double value)
	{
        buff.putDouble(value);
    }

    public void writeInt(int value)
	{
        buff.putInt(value);
    }

    public void writeShort(short value)
	{
        buff.putShort(value);
    }

    public void writeBytes(byte[] bytes)
	{
        buff.put(bytes);
    }

    /**
     *
     * @param str
     * 采用UTF-8的编码方式和client端保持一致，utf-8汉字占3位
     */
    public void writeString(String str)
	{

		try
		{
			  byte[] str_bytes= str.getBytes("UTF-8");
			  int len = str_bytes.length;
		        writeInt(len);
		        writeBytes(str_bytes);
		}
		catch (UnsupportedEncodingException e)
		{
			System.out.println("writeString出现异常");
            System.exit(0);
		}

    }

    public void writeString(String str, String charset)
	{

        try
		{
            byte[] str_bytes = str.getBytes(charset);
            short len = (short) (str_bytes.length);
            writeShort(len);
            writeBytes(str_bytes);
        }
		catch (UnsupportedEncodingException e)
		{
            System.out.println("writeString出现异常");
            System.exit(0);
        }
    }

    //取出数据
    public char readChar()
	{
        return buff.getChar();
    }

    public byte readByte()
	{
        return buff.get();
    }

    public float readFloat()
	{
        return buff.getFloat();
    }

    public long readLong()
	{
        return buff.getLong();
    }

    public double readDouble()
	{
        return buff.getFloat();
    }

    public int readInt()
	{
        return buff.getInt();
    }

    public short readShort()
	{
        return buff.getShort();
    }

    public String readString()
	{
        short len = buff.getShort();
        byte[] _bytes = new byte[len];
        buff.get(_bytes, 0, len);

        try
        {
			return new String(_bytes,"UTF-8");
		}
        catch (UnsupportedEncodingException e)
		{
			// TODO Auto-generated catch block
        	System.out.println("readString出现异常");
		}
        return null;
    }

    public String readString(String charset)
	{
        short len = buff.getShort();
        byte[] _bytes = new byte[len];
        buff.get(_bytes, 0, len);
        try
		{
            return new String(_bytes, charset);
        }
		catch (UnsupportedEncodingException e)
		{
            System.out.println("readString出现异常");
            e.printStackTrace();
            System.exit(0);
        }
        return new String(_bytes);
    }

    public ByteBuffer byteBuffer()
	{
        return buff;
    }

    public ByteBuffer pack()
	{
        int l = length();
        ByteBuffer buffer = ByteBuffer.allocate(l);
        if (position() > 0)
		{
            flip();
        }
        buffer.put(array(), 0, l);
        buffer.flip();
        return buffer;
    }

    public byte[] array()
	{
        return buff.array();
    }

    public int position()
	{
        return buff.position();
    }

    public void flip()
	{
        if (buff.position() > 0)
		{
            buff.flip();
        }
    }

    public void clear()
	{
        buff.clear();
        length = 0;
    }

    public int length()
	{
        return length - buff.remaining();
    }

    public int totalSize()
	{
        return length;
    }

    public void outInfo(byte[] bytes)
	{
        for (int i = 0; i < bytes.length; i++)
		{
            System.out.println("---------" + bytes[i]);
        }
    }

    //发送
    public byte[] send()
	{
	        //发送数据的实际长度
    	int dataLen = buff.limit() - buff.remaining();

        if (buff.position() > 0)
		{
        	buff.flip();
        }

        //发送的bytes，4为数据包的长度信息，为int型，占用4个字节
        ByteBuffer bts = ByteBuffer.allocate(dataLen + 8);
        //写入数据包的长度
        System.out.print("发送的数据长度:"+dataLen);
     //   bts.putInt(dataLen+4);
        bts.putInt(dataLen+4);//在erlang的socket的{packet,2}中头部的数值的大小是包体的长度，因为此次多输个int型的，所以多加了个4，不要误解了
        bts.putInt(dataLen+4);
        //写入数据内容
        bts.put(buff);

        if (bts.position() > 0)
		{
            bts.flip();
        }

        System.out.println("发送给服务端的长度:"+bts.limit() +",告诉服务器的长度"+ (dataLen+4));

       return bts.array();
    }

    //发送
    public byte[] send(int length)
	{
	        //发送数据的实际长度
    	int dataLen = buff.limit() - buff.remaining();

        if (buff.position() > 0)
		{
        	buff.flip();
        }

        //发送的bytes，4为数据包的长度信息，为int型，占用4个字节
        ByteBuffer bts = ByteBuffer.allocate(dataLen + 8);
        //写入数据包的长度
        System.out.print("原始数据的长度:"+dataLen);

        bts.putInt(dataLen+4+length);//在erlang的socket的{packet,2}中头部的数值的大小是包体的长度，因为此次多输个int型的，所以多加了个4，不要误解了
        bts.putInt(dataLen+4+length);
        //写入数据内容
        bts.put(buff);

        if (bts.position() > 0)
		{
            bts.flip();
        }

        System.out.println("发送给服务端的长度:"+bts.remaining()+",告诉服务端的长度:"+ (dataLen+4+length));

       return bts.array();
    }

}