java对象转成byte数组，在使用netty进行通信协议传输的场景中是非常常见的。比如，协议有一些定好的协议头、classid，messageid等等信息，还有一个关键的内容是payload。不同的协议内容都会放到payload中，而这个payload往往就是一个byte数组。
那么，如何方便的将一个java对象构造成一个byte数组呢？
1 bytebuf填充
我们以下面这个对象举例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
public class ugvdata implements serializible{ private static final long serialversionuid = -219988432063763456l; //状态码 byte status; //当前gps经度 float longitude; //当前gps纬度 float latitude; //行驶速度 单位是 m/s，带一个小数点 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出一个上面的对象，调用其tobytearray方法，即可将这个对象转成byte数组。
2 巧用json
我们都知道，字符串是可以转成byte数组的。将一个对象转成json字符串也很容易，直接使用fastjson就可以了。如果对fastjson使用有问题的，可以看我的另一篇博客json.parseobject 和 json.tojsonstring 实例
|
1
|
json.tojsonstring(ugvdata).getbytes() |
3 反射的方式
第一种方法的缺点在于，每一个类都要这么写一个tobytearray方法。如果类多了是非常麻烦的。有什么方便的方法吗？当然是有的，利用反射的方式（只会在第一次反射，后面会做本地缓存，所以性能开销不大）。需要在一个文件夹下添加下面五个类
1.codecable
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
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;@datapublic 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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
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(); /** * 数据长度。解码时用，除了简单数据类型之外才起作用（如：string）。 * @return */ int length() default 0;} |
3.fieldwrapper
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
import lombok.allargsconstructor;import lombok.data;import java.lang.reflect.field;@data@allargsconstructorpublic class fieldwrapper { /** * 上下行数据属性 */ private field field; /** * 上下行数据属性上的注解 */ private codecproprety codecproprety;} |
4.payloaddecoder
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
|
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(); } /** * 数据写入到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转成byte数组。
|
1
|
payloadencoder.getpayload(drivestartdata) |
4 总结
可能会有人问了，上面三种，明显第二种转json最简单，为什么还要用另外两种呢？
其实，第一种和第三种可以归为一类，都是把对象直接转成byte数组，下一层做解析的话，可以一个一个元素取；
第二种情况是把对象的json字符串转成byte数组，问题就在于，json字符串最开头是”{“，也就是转成的byte数组的第一位是”{“对应的数值
在使用中应该根据情况来，如果下一层做解析是直接取元素，对象少的话用第一种；对象多的话用第三种；
如果下一层做了排除掉json的一些格式的解析，就用第二种。
以上全部为本篇文章的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：https://blog.csdn.net/antony9118/article/details/80713348
