我家自动化

这个屌丝很懒，什么也没留下！

热门标签

一文搞懂Google Gson使用_com.google.gson.gson

作者：我家自动化 | 2024-07-16 12:56:54

踩

com.google.gson.gson

一.基本使用

1.1 Gson实例化方法

在进行序列化与反序列操作前，需要先实例化一个 com .google.gson.Gson 对象，获取 Gson 对象的方法有两种

        //通过构造函数来获取
        Gson gson = new Gson();
        //通过 GsonBuilder 来获取，可以进行多项特殊配置
        Gson gson = new GsonBuilder().create();
1
2
3
4

1.2 生成json

通过使用 addProperty 的四个重载方法

public static void main(String[] args) {
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("String", "leavesC");
        jsonObject.addProperty("Number_Integer", 23);
        jsonObject.addProperty("Number_Double", 22.9);
        jsonObject.addProperty("Boolean", true);
        jsonObject.addProperty("Char", 'c');
        System.out.println();
        System.out.println(jsonObject);
    }

1
2
3
4
5
6
7
8
9
10
11

打印结果：

{“String”:“leavesC”, “Number_Integer”:23, “Number_Double”:22.9, “Boolean”:true, “Char”:“c”}

addProperty 方法底层调用的是 add(String property, JsonElement value) 方法，即将基本数据类型转化为了 JsonElement 对象，JsonElement 是一个抽象类，而 JsonObject 继承了 JsonElement ，因此我们可以通过 JsonObject 自己来构建一个 JsonElement

public static void main(String[] args) {
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("String", "leavesC");
        jsonObject.addProperty("Number", 23);
        jsonObject.addProperty("Number", 22.9);
        jsonObject.addProperty("Boolean", true);
        jsonObject.addProperty("Char", 'c');

        JsonObject jsonElement = new JsonObject();
        jsonElement.addProperty("Boolean", false);
        jsonElement.addProperty("Double", 25.9);
        jsonElement.addProperty("Char", 'c');
        jsonObject.add("JsonElement", jsonElement);

        System.out.println();
        System.out.println(jsonObject);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

打印结果：

{"String":"leavesC", "Number":22.9, "Boolean":true, "Char":"c",
"JsonElement":{"Boolean":false, "Double":25.9, "Char":"c"}}
1
2

1.3 Json与数组、List的转化

Json数组与字符串数组

public static void main(String[] args) {
        //Json数组 转为 字符串数组
        Gson gson = new Gson();
        String jsonArray = "[\"https://github.com/leavesC\",\"https://www.jianshu.com/u/9df45b87cfdf\",\"Java\",\"Kotlin\",\"Git\",\"GitHub\"]";
        String[] strings = gson.fromJson(jsonArray, String[].class);
        System.out.println("Json数组 转为 字符串数组: ");
        for (String string : strings) {
            System.out.println(string);
        }
        //字符串数组 转为 Json数组
        jsonArray = gson.toJson(strings, String[].class);
        System.out.println("\n字符串数组 转为 Json数组: ");
        System.out.println(jsonArray);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

打印结果：

Json数组 转为 字符串数组: 
https://github.com/leavesC
https://www.jianshu.com/u/9df45b87cfdf
Java
Kotlin
Git
GitHub

字符串数组 转为 Json数组: 
["https://github.com/leavesC","https://www.jianshu.com/u/9df45b87cfdf","Java","Kotlin","Git","GitHub"]
1
2
3
4
5
6
7
8
9
10

1.4 序列化与反序列化

Gson 也提供了 toJson() 和 fromJson() 两个方法用于转化 Model 与 Json，前者实现了序列化，后者实现了反序列化

首先，声明一个 User 类

public class User {

    private String name;

    private int age;

    private boolean sex;

    public User(String name, int age, boolean sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }

}

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

序列化的方法很简单，调用 gson 对象的 toJson 方法，传入要序列化的对象

        //序列化
        User user = new User("leavesC", 24, true);
        Gson gson = new Gson();
        System.out.println();
        String usrJson = gson.toJson(user);
        System.out.println(usrJson);

        //反序列化
        User userBean = gson.fromJson(usrJson, User.class);
        System.out.println();
        System.out.println(userBean);
1
2
3
4
5
6
7
8
9
10
11

打印结果：

{"name":"leavesC","age":24,"sex":true}

User{name='leavesC', age=24, sex=true}

1
2
3
4

二. 属性重命名

继续使用上一节声明的 User 类，根据 User 类声明的各个属性名，移动端的开发者希望接口返回的数据格式即是如下这样的

{"name":"leavesC","age":24,"sex":true}
1

如果没有和服务器端沟通好或者是 API 改版了，接口返回的数据格式可能是这样的

{"Name":"leavesC","age":24,"sex":true}
1

{"userName":"leavesC","age":24,"sex":true}
1

此时为了兼顾多种格式的数据，就需要使用 SerializedName 注解
根据 SerializedName 的声明来看，SerializedName 包含两个属性值，一个是字符串，一个是字符串数组，而字符串数组含有默认值

//应对多种情况下属性名不一致的问题
@SerializedName(value = "userName", alternate = {"user_name", "Name"})
    private String name;
1
2
3

这样在服务器返回的属性名和本地申明的属性名不一致的情况下均能正确解析

        //多种情况下属性不一致问题
        String userJson = "{\"userName\":\"leavesC\",\"age\":24,\"sex\":true}";
        user = gson.fromJson(userJson, User.class);
        System.out.println();
        System.out.println(user);

        userJson = "{\"user_name\":\"leavesC\",\"age\":24,\"sex\":true}";
        user = gson.fromJson(userJson, User.class);
        System.out.println();
        System.out.println(user);

        userJson = "{\"Name\":\"leavesC\",\"age\":24,\"sex\":true}";
        user = gson.fromJson(userJson, User.class);
        System.out.println();
        System.out.println(user);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

打印结果：

User{name='leavesC', age=24, sex=true}

User{name='leavesC', age=24, sex=true}

User{name='leavesC', age=24, sex=true}
1
2
3
4
5

三. 字段过滤

有时候并不是所有的字段都需要进行系列化和反序列化，因此需要对某些字段进行排除，有四种方法可以来实现这种需求。

3.1 基于@Expose注解

Expose 注解包含两个属性值，且均声明了默认值。Expose 的含义即为“暴露”，即用于对外暴露字段，serialize 用于指定是否进行序列化，deserialize 用于指定是否进行反序列化。如果字段不声明 Expose 注解，则意味着不进行序列化和反序列化操作，相当于两个属性值均为 false 。此外，Expose 注解需要和 GsonBuilder 构建的 Gson 对象一起使用才能生效。

修改User类如下

public class User {

    @Expose(serialize = true, deserialize = true)   //序列化和反序列化都生效
    private String a;

    @Expose(serialize = false, deserialize = true)  //序列化时不生效，反序列化时生效
    private String b;

    @Expose(serialize = true, deserialize = false)  //序列化时生效，反序列化时不生效
    private String c;

    @Expose(serialize = false, deserialize = false) //序列化和反序列化都不生效，和不写注解一样
    private String d;

    private String e;

    public User(String a, String b, String c, String d, String e) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
        this.e = e;
    }

    @Override
    public String toString() {
        return "User{" +
                "a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                ", e='" + e + '\'' +
                '}';
    }

}

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

测试代码如下：

Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();
        User user = new User("A", "B", "C", "D", "E");
        System.out.println();
        System.out.println(gson.toJson(user));

        String json = "{\"a\":\"A\",\"b\":\"B\",\"c\":\"C\",\"d\":\"D\",\"e\":\"E\"}";
        user = gson.fromJson(json, User.class);
        System.out.println();
        System.out.println(user.toString());

1
2
3
4
5
6
7
8
9
10

3.2 基于版本

Gson 提供了 @Since 和 @Until 两个注解基于版本对字段进行过滤，@Since 和 @Until 都包含一个 Double 属性值，用于设置版本号。Since 的意思是“自……开始”，Until 的意思是“到……为止”，一样要和 GsonBuilder 配合使用。

当版本( GsonBuilder 设置的版本) 大于或等于 Since 属性值或小于 Until 属性值时字段会进行序列化和反序列化操作，而没有声明注解的字段都会加入序列化和反序列操作

修改User类

public class User {

    @Since(1.4)
    private String a;

    @Since(1.6)
    private String b;

    @Since(1.8)
    private String c;

    @Until(1.6)
    private String d;

    @Until(2.0)
    private String e;

    public User(String a, String b, String c, String d, String e) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
        this.e = e;
    }

    @Override
    public String toString() {
        return "User{" +
                "a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                ", e='" + e + '\'' +
                '}';
    }

}

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

测试代码

Gson gson = new GsonBuilder().setVersion(1.6).create();
        User user = new User("A", "B", "C", "D", "E");
        System.out.println();
        System.out.println(gson.toJson(user));

        String json = "{\"a\":\"A\",\"b\":\"B\",\"c\":\"C\",\"d\":\"D\",\"e\":\"E\"}";
        user = gson.fromJson(json, User.class);
        System.out.println();
        System.out.println(user.toString());

1
2
3
4
5
6
7
8
9
10

3.3 基于访问修饰符

访问修饰符由 java.lang.reflect.Modifier 提供 int 类型的定义，而 GsonBuilder 对象的 excludeFieldsWithModifiers 方法接收一个 int 类型可变参数，指定不进行序列化和反序列化操作的访问修饰符字段
看个例子

public class ModifierSample {

    public String publicField = "public";

    protected String protectedField = "protected";

    private String privateField = "private";

    String defaultField = "default";

    final String finalField = "final";

    static String staticField = "static";

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

测试代码：

Gson gson = new GsonBuilder().excludeFieldsWithModifiers(Modifier.PRIVATE, Modifier.STATIC).create();
        ModifierSample modifierSample = new ModifierSample();
        System.out.println(gson.toJson(modifierSample));

1
2
3
4

运行结果：

{"publicField":"public","protectedField":"protected","defaultField":"default","finalField":"final"}
1

3.4 基于策略

GsonBuilder 类包含 setExclusionStrategies(ExclusionStrategy… strategies)方法用于传入不定长参数的策略方法，用于直接排除指定字段名或者指定字段类型
看个例子

public class Strategies {

    private String stringField;

    private int intField;

    private double doubleField;

    public Strategies(String stringField, int intField, double doubleField) {
        this.stringField = stringField;
        this.intField = intField;
        this.doubleField = doubleField;
    }

    @Override
    public String toString() {
        return "Strategies{" +
                "stringField='" + stringField + '\'' +
                ", intField=" + intField +
                ", doubleField=" + doubleField +
                '}';
    }

}

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

测试代码：

public static void main(String[] args) {
        Gson gson = new GsonBuilder().setExclusionStrategies(new ExclusionStrategy() {
            @Override
            public boolean shouldSkipField(FieldAttributes fieldAttributes) {
                //排除指定字段名
                return fieldAttributes.getName().equals("intField");
            }

            @Override
            public boolean shouldSkipClass(Class<?> aClass) {
                //排除指定字段类型
                return aClass.getName().equals(double.class.getName());
            }
        }).create();

        Strategies strategies = new Strategies("stringField", 111, 11.22);
        System.out.println();
        System.out.println(gson.toJson(strategies));

        String json = "{\"stringField\":\"stringField\",\"intField\":111,\"doubleField\":11.22}";
        strategies = gson.fromJson(json, Strategies.class);
        System.out.println();
        System.out.println(strategies);
    }

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

字段名为 “intField” 和字段类型为 double 的字段都会被排除掉。

打印结果：

{"stringField":"stringField"}

Strategies{stringField='stringField', intField=0, doubleField=0.0}

1
2
3
4

四. 个性化配置

4.1 输出 null

对于 Gson 而言，在序列化时如果某个属性值为 null 的话，那么在序列化时该字段不会参与进来，如果想要显示输出该字段的话，可以通过 GsonBuilder 进行配置。

测试代码：

Gson gson = new GsonBuilder()
                .serializeNulls() //输出null
                .create();
        Strategies strategies = new Strategies(null, 24, 22.333);
        System.out.println();
        System.out.println(gson.toJson(strategies));

1
2
3
4
5
6
7

打印结果：

{"stringField":null,"intField":24,"doubleField":22.333}
1

4.2 格式化输出Json

默认的序列化后的 Josn 字符串并不太直观，可以选择格式化输出

Gson gson = new GsonBuilder()
                .serializeNulls() //输出null
                .setPrettyPrinting()//格式化输出
                .create();
        Strategies strategies = new Strategies(null, 24, 22.333);
        System.out.println();
        System.out.println(gson.toJson(strategies));

1
2
3
4
5
6
7
8

打印结果：

{
  "stringField": null,
  "intField": 24,
  "doubleField": 22.333
}

1
2
3
4
5
6

4.3 格式化时间

Gson 也可以对时间值进行格式化

首先定义一个DateFormat类

public class DateFormat {


        private Date date;

        private Date date2;

        public DateFormat(Date date, Date date2) {
            this.date = date;
            this.date2 = date2;
        }

        @Override
        public String toString() {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS", Locale.CHINA);
            return "Strategies{" +
                    "date=" + simpleDateFormat.format(date) +
                    ", date2=" + simpleDateFormat.format(date2) +
                    '}';
        }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

测试代码：

//时间格式化输出
    @Test
    public void DateFormatPrint() throws Exception{
        Gson gson = new GsonBuilder()
                .setPrettyPrinting()//格式化输出
                .setDateFormat("yyyy-MM-dd HH:mm:ss:SSS")//格式化时间
                .create();
        Date date = new Date();
        DateFormat strategies = new DateFormat(date, new Date(date.getTime() + 1000000));
        System.out.println();
        System.out.println(gson.toJson(strategies));

        String json = "{\n" +
                "  \"date\": \"2018-03-17 19:38:50:033\",\n" +
                "  \"date2\": \"2018-03-17 19:55:30:033\"\n" +
                "}";
        System.out.println();
        System.out.println(gson.fromJson(json, DateFormat.class));

    }
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

打印结果：

{
  "date": "2018-07-02 14:01:10:430",
  "date2": "2018-07-02 14:17:50:430"
}

DateFormat{date=2018-03-17 19:38:50:033, date2=2018-03-17 19:55:30:033}
1
2
3
4
5
6

五. TypeAdapter

TypeAdapter 是一个泛型抽象类，用于接管某种类型的序列化和反序列化过程，包含两个抽象方法，分别用于自定义序列化和反序列化过程。

public abstract void write(JsonWriter var1, T var2) throws IOException;

public abstract T read(JsonReader var1) throws IOException;
1
2
3

定义 TypeAdapter 的子类 UserTypeAdapter 来接管 User 类的序列化和反序列化过程
这里设定当 User 类序列化时 Json 中的Key值都是大写字母开头，反序列化时支持“name”和“Name”两种不同的 Json 风格

public class UserTypeAdapter extends TypeAdapter<User> {

    @Override
    public void write(JsonWriter jsonWriter, User user) throws IOException {
        //流式序列化成对象开始
        jsonWriter.beginObject();
        //将Json的Key值都指定为大写字母开头
        jsonWriter.name("Name").value(user.getName());
        jsonWriter.name("Age").value(user.getAge());
        jsonWriter.name("Sex").value(user.isSex());
        //流式序列化结束
        jsonWriter.endObject();
    }

    @Override
    public User read(JsonReader jsonReader) throws IOException {
        User user = new User();
        //流式反序列化开始
        jsonReader.beginObject();
        while (jsonReader.hasNext()) {
            switch (jsonReader.nextName()) {
                //首字母大小写均合法
                case "name":
                case "Name":
                    user.setName(jsonReader.nextString());
                    break;
                case "age":
                    user.setAge(jsonReader.nextInt());
                    break;
                case "sex":
                    user.setSex(jsonReader.nextBoolean());
                    break;
            }

        }
        //流式反序列化结束
        jsonReader.endObject();
        return user;
    }

}

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

测试代码：

Gson gson = new GsonBuilder().registerTypeAdapter(User.class, new UserTypeAdapter()).create();
        User user = new User("leavesC", 24, true);
        System.out.println();
        System.out.println(gson.toJson(user));

        String json = "{\"Name\":\"leavesC\",\"age\":24,\"sex\":true}";
        user = gson.fromJson(json, User.class);
        System.out.println();
        System.out.println(user);

1
2
3
4
5
6
7
8
9
10

打印结果：

{"Name":"leavesC","Age":24,"Sex":true}

User{name='leavesC', age=24, sex=true}

1
2
3
4

六. JsonSerializer 和 JsonDeserializer

TypeAdapter 将序列化和反序列操作都接管了过来，其实 Gson 还提供了只接管序列化过程的接口，即 JsonSerializer，还提供了只反序列化过程的接口，即为JsonDeSerializer

//JsonSerializer 测试

@Test
    public void testForJsonSerializer() throws Exception{
        Gson gson = new GsonBuilder().registerTypeAdapter(User.class, new JsonSerializer<User>() {
            @Override
            public JsonElement serialize(User user, Type type, JsonSerializationContext jsonSerializationContext) {
                JsonObject jsonObject = new JsonObject();
                jsonObject.addProperty("NameHi", user.getName());
                jsonObject.addProperty("Sex", user.isSex());
                jsonObject.addProperty("Age", user.getAge());
                return jsonObject;
            }
        }).create();
        User user = new User("leavesC", 24, true);
        System.out.println();
        System.out.println(gson.toJson(user));
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

打印结果：

{"NameHi":"leavesC","Sex":true,"Age":24}
1

//JsonDeserializer 测试

    @Test void testForJsonDeserializer() throws Exception{
        Gson gson = new GsonBuilder().registerTypeAdapter(User.class, new JsonDeserializer<User>() {
            @Override
            public User deserialize(JsonElement jsonElement, Type type, JsonDeserializationContext jsonDeserializationContext) throws JsonParseException {
                JsonObject jsonObject = jsonElement.getAsJsonObject();
                String name = null;
                //同时支持 userName 和 name 两种情况
                if (jsonObject.has("userName")) {
                    name = jsonObject.get("userName").getAsString();
                } else if (jsonObject.has("name")) {
                    name = jsonObject.get("name").getAsString();
                }
                int age = jsonObject.get("age").getAsInt();
                boolean sex = jsonObject.get("sex").getAsBoolean();
                return new User(name, age, sex);
            }
        }).create();
        String json = "{\"userName\":\"leavesC\",\"sex\":true,\"age\":24}";
        User user = gson.fromJson(json, User.class);
        System.out.println();
        System.out.println(user);

        json = "{\"name\":\"leavesC\",\"sex\":true,\"age\":24}";
        user = gson.fromJson(json, User.class);
        System.out.println();
        System.out.println(user);
    }
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

打印结果：

User{name='leavesC', age=24, sex=true}

User{name='leavesC', age=24, sex=true}
1
2
3

这里有个比较麻烦的地方，那就是在使用 TypeAdapter 、JsonSerializer 和 JsonDeserializer 时，总需要调用 registerTypeAdapter 方法进行注册，那有没有更简单的注册方法呢？
有的，Gosn 还提供了另一个注解 @JsonAdapter 用于进行简单的声明

类似于这样，声明了 User 类的序列化或反序列化操作由 UserTypeAdapter 完成，注解的优先级高于 registerTypeAdapter 方法

@JsonAdapter(UserTypeAdapter.class)
public class User {

}

1
2
3
4
5

测试代码：

 @Test
    public void testForJsonAdapter() throws Exception{
        Gson gson = new Gson();
        String json = "{\"name\":\"leavesC\",\"sex\":true,\"age\":24}";
        User user = gson.fromJson(json, User.class);
        System.out.println();
        System.out.println(user);
    }
1
2
3
4
5
6
7
8

七. TypeAdapterFactory

TypeAdapterFactory 是用于创建 TypeAdapter 的工厂类，通过参数 TypeToken 来查找确定对应的 TypeAdapter，如果没有就返回 null 并由 Gson 默认的处理方法来进行序列化和反序列化操作，否则就由用户预定义的 TypeAdapter 来进行处理

测试相关代码：

//test For JsonAdapterFactory

    @Test
    public void testForJsonAdapterFactory() throws Exception{
        Gson gson = new GsonBuilder().registerTypeAdapterFactory(new TypeAdapterFactory() {
            @Override
            public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
                //如果 Gson 需要与 User 类相关的 TypeAdapter ，则返回我们自己定义的 TypeAdapter 对象
                if (typeToken.getRawType().getTypeName().equals(User.class.getTypeName())) {
                    return (TypeAdapter<T>) new UserTypeAdapter();
                }
                //找不到则返回null
                return null;
            }
        }).create();

        String json = "{\"name\":\"leavesC\",\"sex\":true,\"age\":24}";
        User user = gson.fromJson(json, User.class);
        System.out.println();
        System.out.println(user);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

测试结果：

User{name='leavesC', age=24, sex=true}

1
2

八. Json插件 ——GsonFormat以及RoboPOJOGenerator

这两个插件均能在网上插件中心获取

在这里插入图片描述

GsonFormat
快速将json字符串转换成一个Java Bean，免去我们根据json字符串手写对应Java Bean的过程。
使用方法：快捷键Alt+S也可以使用Alt+Insert选择GsonFormat
RoboPOJOGenerator

项目地址：
https://github.com/robohorse/RoboPOJOGenerator

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/834194

一文搞懂Google Gson使用_com.google.gson.gson

文章目录

一.基本使用

1.1 Gson实例化方法

1.2 生成json

1.3 Json与数组、List的转化

1.4 序列化与反序列化

二. 属性重命名

三. 字段过滤

3.1 基于@Expose注解

3.2 基于版本

3.3 基于访问修饰符

3.4 基于策略

四. 个性化配置

4.1 输出 null

4.2 格式化输出Json

4.3 格式化时间

五. TypeAdapter

六. JsonSerializer 和 JsonDeserializer

七. TypeAdapterFactory

八. Json插件 ——GsonFormat以及RoboPOJOGenerator