Java使用网络字节序进行数据传输

一、消息格式

采用udp协议，协议数据有 长度、设备名称、命令编号、消息体4个字段组成

字段

长度

设备名称

命令编号

消息体

长度

4字节

2字节

1字节

变长

而消息体又包含长度、命令编号和内容

字段

长度

命令编号

内容

长度

2字节

1字节

变长

这样一个消息就包含了固定长度为7的基本消息和可变长度的消息体组成

消息体又有固定长度3和可变长度内容组成

一个基本消息可以包含多个消息体

经过分析之后开始创建Java实体类

二、创建实体类

1、创建BaseSocket(用户管理socket地址)

public class BaseSocket {

private SocketAddress socketAddress;

public SocketAddress getSocketAddress() {

return socketAddress;

}

public InetSocketAddress getInetSocketAddress(){

return (InetSocketAddress)socketAddress;

}

public void setSocketAddress(SocketAddress socketAddress) {

this.socketAddress = socketAddress;

}

public void setSocketAddress(String ip,int port){

try {

socketAddress = new InetSocketAddress( InetAddress.getByName(ip),port);

} catch (UnknownHostException e) {

}

}

public String getRemoteAddr(){

return getInetSocketAddress().getAddress().getHostAddress();

}

public int getRemotePort(){

return getInetSocketAddress().getPort();

}

}

2、创建基本消息BaseMessage

public class BaseMessage extends BaseSocket implements Serializable{

private final static Logger log = LoggerFactory.getLogger(BaseMessage .class);

private int length;//长度

private short name;//设备名称

private byte code;//命令编号

List

body;//消息体

private byte[] data;//用于存放接收的字节数组

//省略setter getter方法

}

3、创建消息体Body

public class Body {

private short length;//长度

private byte code;//命令编号

private String content;//内容 接收字符串内容

private Integer con;//内容 接收整形数据

private int conLenth;//消息体字节长度

private byte[] data;//用于接收该消息体的字节数组

//省略setter getter方法

}

三、创建工具类

1、创建大小端转换工具类PacketUtil

public class PacketUtil {

/**

* 将int转为低字节在前，高字节在后的byte数组

*/

public static byte[] toLH(int n) {

byte[] b = new byte[4];

b[0] = (byte) (n & 0xff);

b[1] = (byte) (n >> 8 & 0xff);

b[2] = (byte) (n >> 16 & 0xff);

b[3] = (byte) (n >> 24 & 0xff);

return b;

}

/**

* 将float转为低字节在前，高字节在后的byte数组

*/

public static byte[] toLH(float f) {

return toLH(Float.floatToRawIntBits(f));

}

}

2、创建对象转字节数组工具类BodyToByteUtils

public class BodyToByteUtils {

private final static int baseMessageLength = 7;//基本消息的固定长度7

private final static int bodyLength = 3;//消息体固定长度3

/**

* 对象转字节数组

* @param baseMessage

* @return

*/

public byte[] getBytes(BaseMessage baseMessage){

int len = getChildrenLength( baseMessage);

byte[] b = new byte[baseMessageLength +len];

byte[] temp;

temp = PacketUtil.toLH( baseMessageLength +len );//获取长度对应的字节数组

System.arraycopy( temp,0,b,0,4 );//拷贝长度字节数组到b 4个字节长度

temp = PacketUtil.toLH( baseMessage.getName() );//获取设备名称对应的字节数组

System.arraycopy( temp,0,b,4,2 );//拷贝设备名称字节数组到b 2个字节长度

temp = PacketUtil.toLH( baseMessage.getCode() );//获取命令编号对应的字节数组

System.arraycopy( temp,0,b,6,1 );//拷贝命令编号字节数组到b 1个字节长度

b = getChildrenBytes(temp,b,baseMessage,baseMessageLength );

return b;

}

/**

* 获取对象子消息体列表节数组

* @param temp

* @param b

* @param baseMessage

* @param start

* @return

*/

private byte[] getChildrenBytes(byte[] temp, byte[] b, BaseMessage baseMessage, int start) {

if(baseMessage.getBody()!=null && baseMessage.getBody().size()>0){

for (Body body:baseMessage.getBody()){

temp = PacketUtil.toLH( bodyLength+body.getConLenth() );//获取消息体长度对应的字节数组

System.arraycopy( temp,0,b,start,2 );//拷贝长度字节数组到b 2个字节长度

start = start +2 ;//长度+2

temp = PacketUtil.toLH( body.getCode() );//获取命令编号对应的字节数组

System.arraycopy( temp,0,b,start,1 );//拷贝命令编号字节数组到b 1个字节长度

start = start +1 ;//长度+1

if(body.getCon()!=null){

//消息体内容是整形数据时

temp = PacketUtil.toLH( body.getCon() );//获取消息体内容对应的字节数组

System.arraycopy( temp,0,b,start,body.getConLenth() );//拷贝消息体内容字节数组到b getConLenth()个字节长度

}else {

//消息体内容是字符串时

byte[] bytes = new byte[body.getConLenth()];

temp = body.getContent().getBytes();//消息体内容转字节数组

System.arraycopy(temp ,0,bytes,0,temp.length );//获取temp.length长度的消息体内容字节数组

System.arraycopy(bytes ,0,b,start,body.getConLenth() );//拷贝消息体内容字节数组到b getConLenth()个字节长度

}

start = start +body.getConLenth() ;//累加start的长度

}

}

return b;

}

/**

* 获取消息体长度

* @param baseMessage

* @return

*/

private int getChildrenLength(BaseMessage baseMessage) {

int len = 0;

if(baseMessage.getBody()!=null && baseMessage.getBody().size()>0){

for (Body body : baseMessage.getBody()){

len += body.getConLenth()+bodyLength ;

}

}

return len;

}

}

3、创建字节数组转对象工具类ByteToBodyUtils

public class ByteToBodyUtils {

private static int baseMessageLength = 7;//基本消息的固定长度7

private final static int bodyLength = 3;//消息体固定长度3

/**

* 网络字节逆序

* @param b

* @param count

* @param big

* @return

*/

public static byte[] ReversEndian(byte b[],int count, boolean big)

{

byte by;

byte data[] = new byte[count];

for(int i=0;i

{

data[i] = b[i];

}

if(big==false)

{

for(int i=0;i

{

by = b[i];

data[count-i-1] = by;

}

}

return data;

}

/**

* 字节数组转对象

* @param data

* @return

*/

public BaseMessage getBaseMessage(byte[] data){

BaseMessage baseMessage = new BaseMessage();

baseMessage.setData( data );

byte[] bytes = ReversEndian( data, 7, true );//获取 截取7个长度 并进行大小端转换后的字节数组

ByteBuffer wrap = ByteBuffer.wrap( data,6,1 );//将下标从6开始 1个长度的字节数组转成ByteBuffer 即命令编号对应的字节数组

baseMessage.setCode( wrap.get() );//获取基本消息的命令编号

baseMessage.setLength( getIntegerContent( bytes,0,4 ) );

baseMessage.setName( (short) getIntegerContent(bytes,4,2) );

List

bodyList = getBodyList( baseMessage );

baseMessage.setBody( bodyList );

return baseMessage;

}

/**

* 获取子对象列表

* @param baseMessage

* @return

*/

public List

getBodyList(BaseMessage baseMessage){

List

list = new ArrayList( );

byte[] data = baseMessage.getData();

data = ByteUtils.ReversEndian( data, data.length, true );//大小端转换

int totalLen = IpcellMessage.getLenth( data, 0, 4 );

while (baseMessageLength < totalLen){

int l = getIntegerContent( data, baseMessageLength, 2 );//返回指定位置的消息体对应的长度

byte[] aByte = getByte( data, baseMessageLength, l );//获取指定位置的消息体字节数组

byte[] bByte = getByte( aByte, 2, 1 );//返回消息体对应的消息编号字节数组

byte[] cByte = getByte( aByte, bodyLength, l-bodyLength );//返回消息体内容对应的字节数组

int code = getInt( bByte );//获取消息体对应的编号

Body body = new Body();

if(CodeUtils.contentIsStr( code )){

//如果消息编号对应的内容是字符串

String content = getContent( cByte).replace( "\u0000","" );//如果是字符串

body.setContent( content );

}else {

//如果消息编号对应的内容是整形数

int content = getBodyContent(cByte);

body.setCon( content );

}

body.setCode( (byte) code );

body.setLength( (short) l );

body.setData( cByte );

list.add( body );

baseMessageLength += l;

}

return getBodyList( baseMessage );

}

/**

* 返回消息体内容(字符串)

* @param data

* @return

*/

public static String getContent(byte[] data){

String str = "";

if(data!=null && data.length>0){

for (int i = 0;i

str += convertHexToString(ByteUtils.byteToHex( data[i] ));

}

}

return str;

}

/**

* 返回消息体内容(整形)

* @param data

* @return

*/

public static int getBodyContent(byte[] data){

ByteBuffer wrap = ByteBuffer.wrap( data,0,data.length );

return wrap.get();

}

/**

* 十六进制转ASCII

* @param hex

* @return

*/

public static String convertHexToString(String hex){

StringBuilder sb = new StringBuilder();

StringBuilder sb2 = new StringBuilder();

for( int i=0; i

String s = hex.substring(i, (i + 2));

int decimal = Integer.parseInt(s, 16);

sb.append((char)decimal);

sb2.append(decimal);

}

return sb.toString();

}

/**

* 返回十进制数

* @param data

* @param

* @param

* @return

*/

public static int getInt(byte[] data){

String hex = "";

if(data!=null && data.length>0){

for (int i = data.length-1;i>=0;i--){

hex += ByteUtils.byteToHex( data[i] );

}

}

if(StringUtils.isNotBlank( hex )){

return Integer.parseInt( hex,16 );

}

return 0;

}

/**

* 返回指定位置的字节数组

* @param data

* @param offset

* @param length

* @return

*/

public static byte[] getByte(byte[] data,int offset,int length){

byte[] bs = new byte[length];

System.arraycopy(data, offset, bs, 0, length);

return bs;

}

/**

* 返回基本信息长度

* @param data

* @param offset

* @param length

* @return

*/

public static int getIntegerContent(byte[] data,int offset,int length){

ByteBuffer wrap = ByteBuffer.wrap( data,offset,length );

return wrap.get();

}

}