java對象轉(zhuǎn)成byte數(shù)組的3種方法

更新時間：2018年06月17日 14:26:17 作者：橙子wj

這篇文章主要為大家詳細介紹了java對象轉(zhuǎn)成byte數(shù)組的3種方法，具有一定的參考價值，感興趣的朋友可以參考一下

java對象轉(zhuǎn)成byte數(shù)組，在使用netty進行通信協(xié)議傳輸?shù)膱鼍爸惺欠浅３Ｒ姷?。比如，協(xié)議有一些定好的協(xié)議頭、classid，messageid等等信息，還有一個關鍵的內(nèi)容是payload。不同的協(xié)議內(nèi)容都會放到payload中，而這個payload往往就是一個byte數(shù)組。

那么，如何方便的將一個java對象構造成一個byte數(shù)組呢？

1 bytebuf填充

我們以下面這個對象舉例：

public class UgvData implements Serializible{
 private static final long serialVersionUID = -219988432063763456L;

 //狀態(tài)碼
 byte status;
 //當前GPS經(jīng)度
 float longitude;
 //當前GPS緯度
 float latitude;
 //行駛速度 單位是 m/s，帶一個小數(shù)點
 float speed;
 //當前電量百分比
 short batteryPercentage;
 //任務編號
 long quest;

 public byte[] toByteArray() {
  ByteBuf buf = Unpooled.buffer(32);
  buf.writeByte(this.getStatus());
  buf.writeFloat(getLongitude());
  buf.writeFloat(getLatitude());
  buf.writeFloat(getSpeed());
  buf.writeShort(getBatteryPercentage());
  buf.writeLong(getQuest());
  return buf.array();
 }

 //省略get set
}

那么只需要new出一個上面的對象，調(diào)用其toByteArray方法，即可將這個對象轉(zhuǎn)成byte數(shù)組。

2 巧用json

我們都知道，字符串是可以轉(zhuǎn)成byte數(shù)組的。將一個對象轉(zhuǎn)成json字符串也很容易，直接使用fastjson就可以了。如果對fastjson使用有問題的，可以看我的另一篇博客JSON.parseObject 和 JSON.toJSONString 實例

JSON.toJsonString(ugvData).getBytes()

3 反射的方式

第一種方法的缺點在于，每一個類都要這么寫一個toByteArray方法。如果類多了是非常麻煩的。有什么方便的方法嗎？當然是有的，利用反射的方式（只會在第一次反射，后面會做本地緩存，所以性能開銷不大）。需要在一個文件夾下添加下面五個類

1.Codecable

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.google.common.collect.Lists;
import lombok.Data;

import java.lang.reflect.Field;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

@Data
public abstract class Codecable {

 public static List<FieldWrapper> resolveFileldWrapperList(Class clazz){
  Field[] fields = clazz.getDeclaredFields();
  List<FieldWrapper> fieldWrapperList = Lists.newArrayList();
  for (Field field : fields) {
   CodecProprety codecProprety = field.getAnnotation(CodecProprety.class);
   if (codecProprety == null) {
    continue;
   }
   FieldWrapper fw = new FieldWrapper(field, codecProprety);
   fieldWrapperList.add(fw);
  }

  Collections.sort(fieldWrapperList, new Comparator<FieldWrapper>() {
   @Override
   public int compare(FieldWrapper o1, FieldWrapper o2) {
    return o1.getCodecProprety().order() - o2.getCodecProprety().order();
   }
  });

  return fieldWrapperList;
 }

 @JsonIgnore
 public abstract List<FieldWrapper> getFieldWrapperList();
}

2.CodecProprety

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface CodecProprety {
 /**
  * 屬性順序
  * @return
  */
 int order();

 /**
  * 數(shù)據(jù)長度。解碼時用，除了簡單數(shù)據(jù)類型之外才起作用（如：String）。
  * @return
  */
 int length() default 0;
}

3.FieldWrapper

import lombok.AllArgsConstructor;
import lombok.Data;

import java.lang.reflect.Field;
@Data
@AllArgsConstructor
public class FieldWrapper {
 /**
  * 上下行數(shù)據(jù)屬性
  */
 private Field field;
 /**
  * 上下行數(shù)據(jù)屬性上的注解
  */
 private CodecProprety codecProprety;
}

4.PayloadDecoder

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.nio.charset.Charset;
import java.util.List;

public class PayloadDecoder {

 public static <T extends Codecable> T resolve(byte[] src, Class<T> clazz) {
  T instance = null;
  try {
   instance = clazz.newInstance();
  } catch (Exception e) {
   throw new RuntimeException("實例化類失敗", e);
  }

  List<FieldWrapper> fieldWrapperList = instance.getFieldWrapperList();
  ByteBuf buffer = Unpooled.buffer().writeBytes(src);
  for (FieldWrapper fieldWrapper : fieldWrapperList) {
   fillData(fieldWrapper, instance, buffer);
  }

  return instance;
 }

 private static void fillData(FieldWrapper fieldWrapper, Object instance, ByteBuf buffer) {
  Field field = fieldWrapper.getField();
  field.setAccessible(true);
  String typeName = field.getType().getName();
  try {
   switch (typeName) {
    case "java.lang.Boolean":
    case "boolean":
     boolean b = buffer.readBoolean();
     field.set(instance, b);
     break;

    case "java.lang.Character":
    case "char":
     CharSequence charSequence = buffer.readCharSequence(fieldWrapper.getCodecProprety().length(), Charset.forName("UTF-8"));
     field.set(instance, charSequence);
     break;
    case "java.lang.Byte":
    case "byte":
     byte b1 = buffer.readByte();
     field.set(instance, b1);
     break;
    case "java.lang.Short":
    case "short":
     short readShort = buffer.readShort();
     field.set(instance, readShort);
     break;
    case "java.lang.Integer":
    case "int":
     int readInt = buffer.readInt();
     field.set(instance, readInt);
     break;
    case "java.lang.Long":
    case "long":
     long l = buffer.readLong();
     field.set(instance, l);
     break;
    case "java.lang.Float":
    case "float":
     float readFloat = buffer.readFloat();
     field.set(instance, readFloat);
     break;
    case "java.lang.Double":
    case "double":
     double readDouble = buffer.readDouble();
     field.set(instance, readDouble);
     break;
    case "java.lang.String":
     String readString = buffer.readCharSequence(fieldWrapper.getCodecProprety().length(), Charset.forName("UTF-8")).toString();
     field.set(instance, readString);
     break;
    default:
     throw new RuntimeException(typeName + "不支持，bug");
   }
  } catch (Exception e) {
   throw new RuntimeException(typeName + "讀取失敗，field:" + field.getName(), e);
  }
 }


}

5.PayloadEncoder

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.nio.charset.Charset;
import java.util.List;

public class PayloadEncoder {

 public static <T extends Codecable> byte[] getPayload(T command) {
  List<FieldWrapper> fieldWrapperList = command.getFieldWrapperList();
  ByteBuf buffer = Unpooled.buffer();
  fieldWrapperList.forEach(fieldWrapper -> write2ByteBuf(fieldWrapper, command, buffer));
  return buffer.array();
 }

 /**
  * 數(shù)據(jù)寫入到ByteBuf
  *
  * @param fieldWrapper
  * @param instance
  * @param buffer
  */
 private static void write2ByteBuf(FieldWrapper fieldWrapper, Object instance, ByteBuf buffer) {
  Field field = fieldWrapper.getField();
  String typeName = field.getType().getName();
  field.setAccessible(true);
  Object value = null;
  try {
   value = field.get(instance);
  } catch (IllegalAccessException e) {
   new RuntimeException("反射獲取值失敗，filed:" + field.getName(), e);
  }
  switch (typeName) {
   case "java.lang.Boolean":
   case "boolean":
    buffer.writeBoolean((Boolean) value);
    break;
   case "java.lang.Character":
   case "char":
    buffer.writeCharSequence((CharSequence) value, Charset.forName("UTF-8"));
    break;
   case "java.lang.Byte":
   case "byte":
    buffer.writeByte((byte) value);
    break;
   case "java.lang.Short":
   case "short":
    buffer.writeShort((short) value);
    break;
   case "java.lang.Integer":
   case "int":
    buffer.writeInt((int) value);
    break;
   case "java.lang.Long":
   case "long":
    buffer.writeLong((long) value);
    break;
   case "java.lang.Float":
   case "float":
    buffer.writeFloat((float) value);
    break;
   case "java.lang.Double":
   case "double":
    buffer.writeDouble((double) value);
    break;
   case "java.lang.String":
    buffer.writeCharSequence((CharSequence) value, Charset.forName("UTF-8"));
    break;
   default:
    throw new RuntimeException(typeName + "不支持，bug");
  }
 }
}

添加完上面五個類之后，使用也很簡單，只需要如下所示，就可以把driveStartData轉(zhuǎn)成byte數(shù)組。

PayloadEncoder.getPayload(driveStartData)

4 總結

可能會有人問了，上面三種，明顯第二種轉(zhuǎn)json最簡單，為什么還要用另外兩種呢？

其實，第一種和第三種可以歸為一類，都是把對象直接轉(zhuǎn)成byte數(shù)組，下一層做解析的話，可以一個一個元素?。?
第二種情況是把對象的json字符串轉(zhuǎn)成byte數(shù)組，問題就在于，json字符串最開頭是”{“，也就是轉(zhuǎn)成的byte數(shù)組的第一位是”{“對應的數(shù)值

在使用中應該根據(jù)情況來，如果下一層做解析是直接取元素，對象少的話用第一種；對象多的話用第三種；
如果下一層做了排除掉json的一些格式的解析，就用第二種。

以上全部為本篇文章的全部內(nèi)容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章:

springboot Junit 執(zhí)行順序詳解
這篇文章主要介紹了springboot Junit 執(zhí)行順序，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
2021-10-10
Java tomcat中的類加載器和安全機制你了解嗎
這篇文章主要介紹了Tomcat 類加載器的實現(xiàn)方法，本文給大家介紹的非常詳細，具有一定的參考借鑒價值 ,需要的朋友可以參考下，希望能夠給你帶來幫助
2021-09-09
java連接mysql數(shù)據(jù)庫亂碼的解決方法
這篇文章主要介紹通過java連接mysql數(shù)據(jù)庫的時候，頁面出現(xiàn)亂碼，這里簡單分享下解決方法，需要的朋友可以參考下
2013-05-05
Spring中Controller和RestController的區(qū)別詳解
這篇文章主要介紹了Spring中Controller和RestController的區(qū)別詳解,@Controller是標識一個Spring類是Spring MVC controller處理器,@Controller類中的方法可以直接通過返回String跳轉(zhuǎn)到jsp、ftl、html等模版頁面,需要的朋友可以參考下
2023-09-09
idea如何快速查找一個類或類中方法名和變量
這篇文章主要介紹了idea如何快速查找一個類或類中方法名和變量問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教
2023-11-11
解決Spring導出可以運行的jar包問題
最近需要解決Maven項目導入可執(zhí)行的jar包的問題，如果項目不包含Spring，那么使用mvn assembly:assembly即可，這篇文章主要介紹了Spring導出可以運行的jar包,需要的朋友可以參考下
2023-03-03
記錄一個使用Spring?Data?JPA設置默認值的問題
這篇文章主要介紹了使用Spring?Data?JPA設置默認值的問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
2021-11-11
Springboot集成graylog及配置過程解析
這篇文章主要介紹了Springboot集成graylog及配置過程解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
2020-12-12
JVM運行時數(shù)據(jù)區(qū)劃分原理詳解
這篇文章主要介紹了JVM運行時數(shù)據(jù)區(qū)劃分原理詳解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
2020-05-05
java中Javers?比較兩個類的差異
本文主要介紹了Javers?比較兩個類的差異，文中通過示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下
2022-02-02