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> 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<count;i++)
{
data[i] = b[i];
}
if(big==false)
{
for(int i=0;i<count;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<Body> bodyList = getBodyList( baseMessage );
baseMessage.setBody( bodyList );
return baseMessage;
}
/**
* 获取子对象列表
* @param baseMessage
* @return
*/
public List<Body> getBodyList(BaseMessage baseMessage){
List<Body> list = new ArrayList<Body>( );
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<data.length;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<hex.length()-1; i+=2 ){
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();
}
}
扫一扫
3134
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
