前面被json，jsonArray，jsonObject，jsonString 搞得很頭疼，現在來總結下：

這是兩個基礎的實體類：
public class Student {
 
  private int id;
  private String name;
  private int age;
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public Student(int id, String name, int age) {
    super();
    this.id = id;
    this.name = name;
    this.age = age;
  }
  public Student() {
    super();
  }
  @Override
  public String toString() {
    return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
  }
}
public class Grade {
 
  private int id;
  private String name;
  private ArrayList<Student> stus;
  public Grade(int id, String name, ArrayList<Student> stus) {
    super();
    this.id = id;
    this.name = name;
    this.stus = stus;
  }
  public Grade() {
    super();
  }
  @Override
  public String toString() {
    return "Grade [id=" + id + ", name=" + name + ", stus=" + stus + "]";
  }
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public ArrayList<Student> getStus() {
    return stus;
  }
  public void setStus(ArrayList<Student> stus) {
    this.stus = stus;
  }
 
}

下面是一個測試類總結很到位

public class JSONTest {
 
  //解析JSON
  @Test
  public void test1() throws JSONException{
    //對象嵌套數組嵌套對象
    String json1="{'id':1,'name':'JAVAEE-1703','stus':[{'id':101,'name':'劉一','age':16}]}";
    //數組
    String json2="['北京','天津','杭州']";
 
    //1、
    //解析第一層---對象
    JSONObject jObject1=new JSONObject(json1);
    Grade grade=new Grade();
    grade.setId(jObject1.getInt("id"));
    grade.setName(jObject1.getString("name"));
    ArrayList<Student> stus=new ArrayList<>();
    grade.setStus(stus);
    //解析第二層----數組
    JSONArray jsonArray2=jObject1.getJSONArray("stus");
    //遍歷數組獲取元素----對象
    for(int i=0;i<jsonArray2.length();i++){
      //解析第三層----對象
      JSONObject jObject3=jsonArray2.getJSONObject(i);
      Student student=new Student(jObject3.getInt("id"), jObject3.getString("name"), jObject3.getInt("age"));
      grade.getStus().add(student);
    }
 
    System.out.println(grade);
 
    //獲取當前對象的所有屬性的迭代器對象
//   Iterator<String> iterator=jObject1.keys();
//   while (iterator.hasNext()) {
//     String key = iterator.next();
//     System.out.println("屬性："+key);
//   }
 
    //2、
    //獲取數組對象
    JSONArray jArray=new JSONArray(json2);
    ArrayList<String> list=new ArrayList<>();
    //遍歷獲取元素
    for(int i=0;i<jArray.length();i++){
      //jArray.optString(i);//等價於getXXX
      list.add(jArray.getString(i));
    }
    System.out.println("解析結果："+list);
  }
  //生成JSON
  @Test
  public void test2() throws JSONException{
    JSONObject jo1=new JSONObject();
    jo1.put("id", 1001);
    jo1.put("name", "範老");
    jo1.put("age", 20);
    JSONObject jo2=new JSONObject();
    jo2.put("id", 1002);
    jo2.put("name", "平平");
    jo2.put("age", 19);
    JSONArray ja2=new JSONArray();
    ja2.put(jo1);
    ja2.put(jo2);
    JSONObject jo3=new JSONObject();
    jo3.put("id", 11);
    jo3.put("name", "JAVAEE-1704");
    jo3.put("stus",ja2);    
    String json=jo3.toString();
    System.out.println(json);
 
  }
 
}

下面說說 fastJson的實現方法

public class FASTJson {
 
  //解析
  @Test
  public void test1() {
    // 對象嵌套數組嵌套對象
    String json1 = "{'id':1,'name':'JAVAEE-1703','stus':[{'id':101,'name':'劉銘','age':16}]}";
    // 數組
    String json2 = "['北京','天津','杭州']";
    //1、
    //靜態方法
    Grade grade=JSON.parseObject(json1, Grade.class);
    System.out.println(grade);
    //2、
    List<String> list=JSON.parseArray(json2, String.class);
    System.out.println(list);
  }
  //生成
  @Test
  public void test2(){
    ArrayList<Student> list=new ArrayList<>();
    for(int i=1;i<3;i++){
      list.add(new Student(101+i, "碼子", 20+i));
    }
    Grade grade=new Grade(100001,"張三", list);
    String json=JSON.toJSONString(grade);
    System.out.println(json);
  }
}

最後學習下Gson：

GSON是Google提供的用來在Java對象和JSON數據之間進行映射的Java類庫。可以將一個Json字符轉成一個Java對象，或者將一個Java轉化爲Json字符串。

特點： a、快速、高效

　　b、代碼量少、簡潔

　　c、面向對象

　d、數據傳遞和解析方便

Gson的pom依賴：

        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.0</version>
        </dependency>

Gson的創建方式：

　　方式一：

Gson gson = new gson();

　　方式二：通過GsonBuilder()，可以配置多種配置。

轉存失敗重新上傳取消

Gson gson = new GsonBuilder()
                        .setLenient()// json寬鬆  
                        .enableComplexMapKeySerialization()//支持Map的key爲複雜對象的形式  
                        .serializeNulls() //智能null  
                        .setPrettyPrinting()// 調教格式  
                        .disableHtmlEscaping() //默認是GSON把HTML 轉義的
                        .create();

Gson的基本用法：

注：JavaBean：

轉存失敗重新上傳取消

@NoArgsConstructor
@AllArgsConstructor
@Setter
@Getter
@ToString
@Builder
public class PersonJson {
    private String name;
    private Integer age;
    private String hobby;
}
//hobby是在後面的例子中添加的。要麼就name,age兩個屬性，要麼就三個。
//上面的註解是lombok的註解，起到簡化Bean類的作用。

Gson提供了public String toJson(Objcet obj)方法，可以將對象轉化爲json字符串。

JavaBean轉化爲json字符串

public class IndexTest {
    PersonJson person;
    @Before
    public void prepare() {
        person = new PersonJson("慄霖",18);
    }

    @Test
    public void index() {
        Gson gson = new Gson();
        System.out.println(gson.toJson(person));
        System.out.println("---------------");
        Gson gson1 = new GsonBuilder().create();
        System.out.println(gson1.toJson(person));
    }
}

結果：

轉存失敗重新上傳取消

List Map 轉化爲json字符串

public class IndexTest {
    PersonJson person;
    List<PersonJson> list = new ArrayList<>();
    Map<String,PersonJson> map = new HashMap<>();
    @Before
    public void prepare() {
        person = new PersonJson("慄霖",18);
        list.add(person);
        map.put(person.getName(),person);
    }

    @Test
    public void index() {
        Gson gson = new Gson();
        System.out.println("---->List convert json" + gson.toJson(list));
        System.out.println("------------------------");
        System.out.println("---->map convert json" + gson.toJson(map));
    }
}

結果：

轉存失敗重新上傳取消

Gson提供了public T fromJson(String jsonStr,T.class)方法，可以將json字符串轉化爲Java對象

json字符串轉化爲JavaBean

public class SecondTest {
    @Test
    public void index() {
        String jsonStr = "{\"name\":\"慄霖\",\"age\":\"18\"}";
        Gson gson = new GsonBuilder().create();
        PersonJson p = gson.fromJson(jsonStr,PersonJson.class);
        System.out.println("---->jsonStr convert javaBean " + p.getName() + " " + p.getAge());
    }
}

結果：

json字符串轉化爲list集合

public class SecondTest {
    @Test
    public void index() {
        String listJsonStr = "[{\"name\":\"慄霖\",\"age\":\"18\"},{\"name\":\"慄霖之雨\",\"age\":\"18\"}]";
        Gson gson = new GsonBuilder().create();
        List<PersonJson> list = gson.fromJson(listJsonStr,new TypeToken<ArrayList<PersonJson>>(){}.getType());
        System.out.println("---->listJsonStr convert List " + list);
    }
}

結果：

json的抽象基類JsonElemetn:

JsonNull其實就是Null字段

public class SecondTest {
    @Test
    public void index() {
        //JsonNull jsonNull = new JsonNull();該方法已經過時
        JsonNull jsonNull = JsonNull.INSTANCE;
        System.out.println("---->jsonNull  " + jsonNull);
    }
}

結果：

jsonPrimitive可以幫助我們獲取帶轉義字符的字符串。這個就不寫了。感覺沒啥用到。

創建JsonObject：

　　可以通過addProperty(String,Object)向JsonObject添加屬性，跟hashmap類似。

public class SecondTest {
    @Test
    public void index() {
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("name","慄霖");
        jsonObject.addProperty("age",18);
        System.out.println("---->create jsonObject  " + jsonObject);
    }
}

結果：

創建JsonArray

public class SecondTest {
    @Test
    public void index() {
        JsonArray jsonArray = new JsonArray();
        jsonArray.add("a");
        jsonArray.add("b");
        jsonArray.add("c");
        jsonArray.add("d");
        System.out.println("---->create jsonArray: " + jsonArray);
    }
}

結果：

JsonObject嵌套數組或者說JsonObject嵌套JsonArray

public class SecondTest {
    @Test
    public void index() {
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("name","慄霖");
        jsonObject.addProperty("age",18);
        JsonArray jsonArray = new JsonArray();
        jsonArray.add("是碼農");
        jsonArray.add("以前喜歡玩遊戲");
        jsonArray.add("現在只敢小心積累");
        jsonArray.add("只怕突然白了頭");
        jsonObject.add("status",jsonArray);
        System.out.println("---->create jsonArray: " + jsonObject);
    }
}

結果：

Gson註解

重命名註解：@SerializedName

當你調用其他服務時，他們返回的json KEY值與你的Bean屬性名稱不對應怎麼辦？

這時候就需要@SerializedName啦。他可以幫助你解決這個問題！

實體類：

@NoArgsConstructor
@AllArgsConstructor
@Setter
@Getter
@ToString
@Builder
public class PersonJson {
    private String name;
    private Integer age;
    //這裏只是隨便舉個例子，千萬不要用中文！！！
    @SerializedName(value = "愛好")
    private String hobby;
}

示例：

public class SecondTest {
    JsonObject jsonObject;
    JsonArray jsonArray;

    @Before
    public void index() {
        jsonObject = new JsonObject();
        jsonObject.addProperty("name","慄霖");
        jsonObject.addProperty("age",18);
        jsonArray = new JsonArray();
        jsonArray.add("是碼農");
        jsonArray.add("以前喜歡玩遊戲");
        jsonArray.add("現在只敢小心積累");
        jsonArray.add("只怕突然白了頭");
        jsonObject.addProperty("愛好",jsonArray.toString());
    }

    @Test
    public void formal() {
        Gson gson = new GsonBuilder().create();
        PersonJson personJson = gson.fromJson(jsonObject.toString(),PersonJson.class);
        System.out.println("---->String: " + personJson);
    }
}

結果：

@serializedName

除了value屬性外，還可以使用alternate屬性，這個值可以替換前面的值，將傳入的json進行修改。

注：value的值不能出現在alternate中，alternate是備選字段。

@SerializedName(value = "hobby", alternate = {"interest","be fond of"})

過濾註解@Expose

注：默認是既可以序列化，也可以反序列化。一定要配合GsonBuilder一起使用

　　該註解是加在JavaBean的屬性上使用的。

　　配合這個使用哦Gson gson = new GsonBuilder().excludeFieldWithoutExposeAnnotation().create();

有四種使用方式：

　　1）不使用@Expose註解等同於@Expose(deserialize = false, serialize = false)不做任何解析

　　2）@Expose(deserialize = true, serialize = false)只解析使用，可以反序列化，不可以序列化。

　　3）@Expose(deserialize = false, serialize = true)可以序列化，不可以反序列化。

　　4）@Expose(deserialize = false, serialize = true)既可以序列化，也可以反序列化。

注：這裏的序列化指：將對象轉化爲json字符串。反序列化指：將json字符串轉化成對象。

版本控制註解@Since(float v)

結合GsonBuilder().serVersion(n)使用。當n>=v時，纔會解析。

注：也是加在JavaBean屬性上使用的。

版本控制註解@Util(float v)

與@Since相反，這次是n<v時才能夠解析。

使用TypeAdapter來實現序列化與反序列化。

使用TypeAdapter來序列化和反序列化

代碼：

public class FiveTest {
    @Test
    public void index() {
        Gson gson = new GsonBuilder().create();
        TypeAdapter<PersonJson> typeAdapter = gson.getAdapter(PersonJson.class);
        String json = "{\"name\":\"慄霖\",\"age\":\"18\",\"hobby\":\"我很是很喜歡FromSoftWare的。大愛宮崎英高，讚美太陽\"}";
        PersonJson p = new PersonJson("慄霖",18,"混系列忠實粉絲");

        System.out.println("---->序列化:是將對象轉化爲字符串 : " + typeAdapter.toJson(p));
        try {
            System.out.println("---->反序列化：是將字符串轉化爲對象 : "+ typeAdapter.fromJson(json));
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

結果：

Gson的容錯機制

爲什麼容錯：

　　如果Bean中定義的是int，但是返回的json對應的是一個""空字串怎麼辦？這就依賴到了Gson的容錯機制。

1）創建寬鬆Gson

遇到問題，停止解析，以防止報錯，功能相對較弱。

Gson gson = new GsonBuilder()
                        .setLenient()//寬鬆
                        .create();

2)自定義TypeAdapter

該方法更傾向於整體防止出現異常。

public class ThirdTest {

    public static class PersonTypeAdapter extends TypeAdapter<PersonJson> {
        @Override
        public void write(JsonWriter jsonWriter, PersonJson personJson) throws IOException {
            jsonWriter.beginObject();
            jsonWriter.name("name").value(personJson.getName());
            jsonWriter.name("age").value(personJson.getAge());
            jsonWriter.name("hobby").value(personJson.getHobby());
            jsonWriter.endObject();
        }

        @Override
        public PersonJson read(JsonReader jsonReader) throws IOException {
            PersonJson personJson = new PersonJson();
            jsonReader.beginObject();
            while (jsonReader.hasNext()) {
                switch (jsonReader.nextName()) {
                    case "name":
                        personJson.setName(jsonReader.nextString());
                        break;
                    case "age":
                        try {
                            personJson.setAge(Integer.valueOf(jsonReader.nextString()));
                        } catch (Exception e) {
                        }
                        break;
                    case "hobby":
                        personJson.setHobby(jsonReader.nextString());
                }
            }
            jsonReader.endObject();
            return personJson;
        }
    }

    @Test
    public void index() {
        Gson gson = new Gson();

        String json = "{\"name\":\"慄霖\",\"age\":\"\",\"hobby\":\"籃球吧，讀書吧，steam吧\"}";

        System.out.println("----> " + json );

        try {
            PersonJson p1 = gson.fromJson(json,PersonJson.class);
            System.out.println("---->默認解析 " + p1);
        }catch (Exception e) {
            System.out.println("---->異常解析，這裏json字符串缺失了age的值，真的是怕一轉眼就白了頭啊" +e);
        }

        Gson gson1 = new GsonBuilder().registerTypeAdapter(PersonJson.class,new PersonTypeAdapter()).create();

        try {
            PersonJson p2 = gson1.fromJson(json,PersonJson.class);
            System.out.println("---->自定義Adapter 默認解析 "+p2);
        }catch (Exception e) {
            System.out.println("---->自定義adapter 異常解析" + e);
        }

        try {
            PersonTypeAdapter personTypeAdapter = new PersonTypeAdapter();
            PersonJson p3 = personTypeAdapter.fromJson(json);
            System.out.println("---->自定義Adapter 默認解析 " + p3);
        }catch (Exception e){
            System.out.println("---->自定義Adapter 異常解析 " +e);
        }
    }
}

結果：

3）使用註解jsonAdapter，其實質也是自定義Adapter

　　該方法更傾向於某一個屬性的保護。

實體類:

public class PersonJson {
    private String name;
    @JsonAdapter(IntegerTypeAdapter.class)
    private Integer age;
    private String hobby;
}

Adapter：

public class IntegerTypeAdapter extends TypeAdapter<Integer>{
    @Override
    public void write(JsonWriter jsonWriter, Integer integer) throws IOException {
        jsonWriter.value(integer);
    }

    @Override
    public Integer read(JsonReader jsonReader) throws IOException {
        int i = 0;
        try {
            i = Integer.valueOf(jsonReader.nextString());
        }catch (Exception e){}
        return i;
    }
}

測試類：

public class FourTest {

    @Test
    public void index() {
        Gson gson = new Gson();
        String json = "{\"name\":\"慄霖\",\"age\":\"\",\"hobby\":\"籃球吧，讀書吧，steam吧\"}";

        try {
            PersonJson p1 = gson.fromJson(json,PersonJson.class);
            System.out.println("---->默認解析 " + p1);
        }catch (Exception e) {
            System.out.println("---->異常解析，這裏json字符串缺失了age的值，真的是怕一轉眼就白了頭啊" +e);
        }

        try {
            PersonJson p2 = gson.fromJson(json,PersonJson.class);
            System.out.println("---->默認解析 " + p2);
        }catch (Exception e) {
            System.out.println("---->異常解析" + e);
        }
    }
}

Json ，Gson，FASTJson的簡單用法

前面被json，jsonArray，jsonObject，jsonString 搞得很頭疼，現在來總結下：

最後學習下Gson：

Gson的創建方式：

Gson的基本用法：

Gson提供了public String toJson(Objcet obj)方法，可以將對象轉化爲json字符串。

JavaBean轉化爲json字符串

List Map 轉化爲json字符串

Gson提供了public T fromJson(String jsonStr,T.class)方法，可以將json字符串轉化爲Java對象

json字符串轉化爲JavaBean

json字符串轉化爲list集合

創建JsonObject：

創建JsonArray

Gson註解

重命名註解：@SerializedName

過濾註解@Expose

版本控制註解@Since(float v)

版本控制註解@Util(float v)

使用TypeAdapter來序列化和反序列化

Gson的容錯機制

RedisCache 小記

ActiveMQ 配置實現

Json ，Gson，FASTJson的簡單用法

計算之BigDecimal

ActiveMQ之發佈/訂閱實現（監聽模式MessageListener）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結