在本文中，我们将为您详细介绍fastjson-1.1.63.android增强对Kotlin的支持，提升性能的相关知识，此外，我们还会提供一些关于Androidjson数据解析之Gson和FastJs

在本文中，我们将为您详细介绍fastjson-1.1.63.android 增强对 Kotlin 的支持，提升性能的相关知识，此外，我们还会提供一些关于Android json数据解析之Gson和FastJson、Android Kotlin RXKotlin Room - 错误 Kotlin.unit、android refrofit kotlin 从 api 获取 json 什么都不做、Android Studio 3.0 Canary 1 发布，支持 Kotlin 语言的有用信息。

• fastjson-1.1.63.android 增强对 Kotlin 的支持，提升性能
• Android json数据解析之Gson和FastJson
• Android Kotlin RXKotlin Room - 错误 Kotlin.unit
• android refrofit kotlin 从 api 获取 json 什么都不做
• Android Studio 3.0 Canary 1 发布，支持 Kotlin 语言

fastjson-1.1.63.android 增强对 Kotlin 的支持，提升性能

fastjson-1.1.63.android已发布，该版本增强了对kotlin的支持，修复了几个Bug，提升Date/int类型的反序列化性能。更新如下：

1. 修复某些场景kotlin支持的bug #1441 #1431

2. 增强对ISO 8601日期格式的支持 #1443

3. 修复特定features组合导致的空指针异常 #1425

4. 提升日期类型的反序列化性能

5. 提升int类型字段值为负数时的parse性能

相关链接

• 下载 http://repo1.maven.org/maven2/com/alibaba/fastjson/1.1.63.android/

• 文档 https://github.com/alibaba/fastjson/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98

• 源码 https://github.com/alibaba/fastjson/tree/1.1.63.android

Downloads

• Source code (zip)

• Source code (tar.gz)

详情请参阅发布说明。

Android json数据解析之Gson和FastJson

Android json数据解析之Gson和FastJson的使用

一：Gson使用

Gson是谷歌提供的一个开源库，可以用来解析JSON数据。
1.什么是json
json就是用来进行网络数据传输的一种格式，目前的使用很广泛，其格式就是一种键值对的形式，很方便进行解析。json有Json对象（JsonObject）和Json数组（JsonArray）两种形式。凡是以{}就是一个Json对象，凡是[]就是一个Json数组。

{//一个Json对象
 "user": "user1",
  "pwd": "123456"
}

{//这个对象有4个字段，其中一个是数组
  "user": "user1",
   "pwd": "123456",
   "jsonArray": [//一个Json数组里面有2个Json对象，每个Json对象有2个字段
             {"user": "user1",
               "pwd": "123456"},
      
              {"user": "user2",
              "pwd": "123456"}
                        ],
   "result": "成功"            
}

2.添加Gson依赖
这是github上19.1kStar项目

在app下build.gradle添加依赖
implementation ''com.google.code.gson:gson:2.8.6''
3.使用GsonFormat工具
Gson是采用对象映射的方式，所有要为JSON数据创建一个Java对象来与之对应。
1.安装GsonFormat插件
2.新建一个类，在类里面按Alt+S键，并将要转换的Json数据复制进去
4.Gson使用

public class User implements Serializable {
    /**
 * user : user1 * pwd : 123456 * jsonArray : [{"user":"user1","pwd":"123456"},{"user":"user2","pwd":"123456"}] * result : 成功
 */
 private String user;
 private String pwd;
 private String result;
 private List<JsonArrayBean> jsonArray;
 public static class JsonArrayBean implements Serializable {
        /**
 * user : user1 * pwd : 123456 */
 private String user;
 private String pwd;
 public String getUser() {
            return user;
 }
        public void setUser(String user) {
            this.user = user;
 }
        public String getPwd() {
            return pwd;
 }
        public void setPwd(String pwd) {
            this.pwd = pwd;
 }
    }
    public String getUser() {
        return user;
 }
    public void setUser(String user) {
        this.user = user;
 }
    public String getPwd() {
        return pwd;
 }
    public void setPwd(String pwd) {
        this.pwd = pwd;
 }
    public String getResult() {
        return result;
 }
    public void setResult(String result) {
        this.result = result;
 }
    public List<JsonArrayBean> getJsonArray() {
        return jsonArray;
 }
    public void setJsonArray(List<JsonArrayBean> jsonArray) {
        this.jsonArray = jsonArray;
 }
}

解析JSON对象

String jsonData="要解析的Json字符串";
Gson gson=new Gson();
User user=gson.fromJson(jsonData, User.class);
String result=user.getResult();
Log.d("aa",result);
===========
aa: 成功

解析Json对象里面的数组

  // 因为jsonArray字段对应的是一个JSON数组，所以要用一个List来对应
List<User.JsonArrayBean> jsonArrayBeans=user.getJsonArray();
//取值
for (int i=0;i<jsonArrayBeans.size();i++){
  User.JsonArrayBean jsonArrayBean=jsonArrayBeans.get(i);
 String u=jsonArrayBean.getUser();
 Log.d("bb",u);
 ================
 取到的值
bb: user1
bb: user2

解析纯数组

[
    {"user": "user8",
      "pwd": "123456"},
      
      {"user": "user9",
      "pwd": "123456"}
]
//使用方式
Gson gson=new Gson();
List<Data> datas=gson.fromJson(jsonData, new TypeToken<ArrayList<Data>>(){}.getType());
for (int i=0;i<datas.size();i++){
  Data data=datas.get(i);
 String u=data.getUser();
 Log.d("cc",u);
}
//打印结果
cc: user8
cc: user9

序列化对象成Json(Teacher对象下4个属性 age,email,isDeveloper,name)

Gson gson=new Gson();
Teacher teacher=new Teacher("Rocky","111@qq.com",22,true);
String teacherJson=gson.toJson(teacher);
Log.d("bb",teacherJson);

打印结果
 bb {"age":22,"email":"111@qq.com","isDeveloper":true,"name":"Rocky"}

如果变量为空值的话序列化和反序列化
1.可见某个变量为null时，Gson在序列化的时候直接把这个变量忽略了
2.对于JSON字符串里没有的变量，Gson在反序列化时会给它一个默认值，int类型默认为0，bool类型默认为false，String类型默认为null

Gson gson=new Gson();
Teacher teacher=new Teacher("Rocky",null,22,true);
String teacherJson=gson.toJson(teacher);
Log.d("bb",teacherJson);

控制序列化/反序列化的变量名称
以Teacher对象为例，假如JSON字符串的变量名name变成fullName,无需紧张，我们也不用把Teacher对象的变量name改成fullName,然后把get,set方法全改了。只需要用Gson提供的注解@SerializedName就行。

public class Teacher{
@SerializedName("fullName")
//@SerializedName(value = "name", alternate = "fullName")
//然而现实远比想象中复杂，这个JSON有时候传的是`fullName`，有时候传的是`name`，这时该怎么办呢？ 不用担心，`@SerializedName` 接受两个参数，`value` 和 `alternate` ，顾名思义，`alternate` 是备选变量名
private String name;
private String email;
private int age;
private boolean isDeveloper;
}
打印Json结果
{"age":22,"isDeveloper":true,"fullName":"Rocky"}

序列化/反序列化过程中忽略某些变量

public class Teacher  {
    @SerializedName("fullName")
    private String name;
 private String email;
 //@Expose()参与序列化和反序列化
 //@Expose(serialize = false)不参与序列化，只参与反序列化
 // @Expose(deserialize = false)只参与序列化，不参与反序列化
 @Expose(serialize = false,deserialize = false)//序列化和反序列化都不参与
 private int age;
 private boolean isDeveloper;
 }

然而：要使用这个注解来控制序列化和反序列化，就不能使用默认的Gson对象

//Gson gson=new Gson();不能通过这种方式构建Gson对象
GsonBuilder builder=new GsonBuilder();
builder.excludeFieldsWithoutExposeAnnotation();
//builder.setPrettyPrinting();
Gson gson=builder.create();
Teacher teacher=new Teacher("Rocky","11@qq.com",22,true);
String teacherJson=gson.toJson(teacher);
Log.d("bb",teacherJson);
打印结果
bb: {}  我不知道为什么这种方式出现的结果是空，按理说我只是限定一个属性的序列化方式按照网上说的方式构建的Gson也不能
我把builder.excludeFieldsWithoutExposeAnnotation();换成builder.setPrettyPrinting();可以打印出来
但是没有限制字段的序列化和反序列化

方式二：transient字段
 通过private transient int age;
 
  Gson gson=new Gson();
 Teacher teacher=new Teacher("Rocky","11@qq.com",22,true);
 String teacherJson=gson.toJson(teacher);
 Log.d("bb",teacherJson);
 打印结果
{"email":"11@qq.com","isDeveloper":true,"fullName":"Rocky"}

二：FastJson使用
FastJson是一个Java语言的编写的高性能的Json处理器，由阿里巴巴公司开发的,github上23kStar

1.添加依赖
implementation ''com.alibaba:fastjson:1.2.73''
2.序列化Json，把对象转成Json串调用JSON.toJSONString

tudent student=new Student("Mike",12);
String studentJson =JSON.toJSONString(student,true);//为true就是要格式化Json,flase就是非格式化Json
//Gson的builder.setPrettyPrinting();格式化Json
Log.d("aa",studentJson);
打印结果：
aa: {
        "age":12,
        "name":"Mike"
    }

3.反序列化Json,把Json串转成对象JSON.parseObject

String json = "{"age":18, "name":"Rocky"}";
Student student=JSON.parseObject(json,Student.class);//要记得Student 添加一个无参的构造方法
Log.d("bb",student.getName());
Log.d("bb",student.getAge()+"");

打印结果
bb: Rocky
bb: 18

如果没有无参的构造方法会报错误

Json转成复杂的Bean,如List ,Set,Map

public class Student {
 private String name;
 private int age;
 ....忽略get,set方法
 }
一：List方式
String json = "[{"age":18, "name":"Rocky"},{"age":19, "name":"jack"}]";
List<Student> lists=JSON.parseObject(json,new TypeReference<ArrayList<Student>>(){});
for (int i=0;i<lists.size();i++){
    Student student=lists.get(i);
 Log.d("cc",student.getName());
 Log.d("cc",student.getAge()+"");
}

二：Set方式
String json = "[{"age":18, "name":"Rocky"},{"age":19, "name":"jack"}]";
Set<Student> lists=JSON.parseObject(json,new TypeReference<HashSet<Student>>(){});
for (Student student:lists){
    Log.d("cc",student.getName());
 Log.d("cc",student.getAge()+"");
}
打印结果
cc: Rocky
cc: 18

cc: jack
cc: 19

@JSONField注解的使用
1.作用于get方法上：当把注解作用于get方法上的时候，在把Java对象转化成Json字符串的时候，Java对象中的字段名会转化为注解中的name指定的字段名。

@JSONField(name = "myAge")
public int getAge() {
    return age;
}

Student student=new Student();
student.setAge(15);
student.setName("Rock");
String studentJson =JSON.toJSONString(student,true);
Log.d("aa",studentJson);

打印结果
aa: {
        "myAge":15,//变成我们注释的属性名
        "name":"Rock"
    }

2 作用于set方法上：在把json字符串转化成java对象的时候，注解中的name指定的字段名会映射为Java对象中的字段名。

@JSONField(name = "myName")
public void setName(String name) {
    this.name = name;
}

 String json = "{"age":2,"myName":"ss"}";//这个Json串的属性换成标记的
Student student= JSON.parseObject(json,Student.class);
 Log.d("cc",student.getName());
 Log.d("cc",student.getAge()+"");
 
 打印结果
 cc: ss
 cc: 2

3 @JSONField作用于java类的字段上

public class Student {
    @JSONField(name = "name", alternateNames = {"myName", "meName"})
    private String name;
 private int age;
 }
 
  String json = "{"age":2,"meName":"ss"}";//这个name字段可以是myName，也可以是meName都可以映射到name字段上
Student student= JSON.parseObject(json,Student.class);
 Log.d("cc",student.getName());
 Log.d("cc",student.getAge()+"");
 
 打印结果
 cc: ss
 cc: 2

Java Bean对象与JSONObject 对象相互转换
Java Bean对象--->JSONObject对象--->json字符串

 student.setAge(15);
 student.setName("Rock");
 JSONObject jsonObject= (JSONObject) JSON.toJSON(student);//JSONObject对象
 String studentJson= jsonObject.toJSONString();//转成Json字符串，toString()也可以
 Log.d("aa",studentJson);

json字符串与JSONObject对象转换
json字符串--->JSONObject对象

String json = "{"age":2,"meName":"ss"}";
JSONObject studentObject= JSON.parseObject(json);

json字符串转成Java集合可以直接使用JSON.parseArray()

String json = "[{"age":18, "name":"Rocky"},{"age":19, "name":"jack"}]";
List<Student> lists=JSON.parseArray(json,Student.class);
for (Student student:lists){
    Log.d("cc",student.getName());
 Log.d("cc",student.getAge()+"");
}

END:所求皆吾愿，所行化坦途

Android Kotlin RXKotlin Room - 错误 Kotlin.unit

fun defaultDataCategory() : ArrayList<CategoryModel>{
        var cat: CategoryModel
        var catArrayList: ArrayList<CategoryModel> = ArrayList(0)
        val date: Int = Calendar.DATE
        val formatedDate = SimpleDateFormat("yyyy-MM-dd").format(Date())
        val formatedTime = SimpleDateFormat("HH:mm").format(Date())
        val DateTime = "$formatedDate  $formatedTime"

        catArrayList.add(
            CategoryModel(
                1,"Personal",true,"Red",Converter.toDate(Calendar.getInstance().timeInMillis),"system","system"
            )
        )

        catArrayList.add(
            CategoryModel(
                2,"Work","Blue","system"
            )
        )

        catArrayList.add(
            CategoryModel(
                3,"Home","Purple","system"
            )
        )

        catArrayList.add(
            CategoryModel(
                4,"Learn","Yellow","system"
            )
        )
       return catArrayList
    }

var catArrayList: ArrayList<CategoryModel> = DefaultData.defaultDataCategory()

        catArrayList.toObservable()
            .subscribeBy(  // named arguments for lambda Subscribers
                onNext = { homeviewmodel.insertCategory(it) },onError = { Log.e("error insert=",it.printstacktrace().toString()) },onComplete = { Log.e("complete insert=","complete insert") }
            )

{
   "flyList":[
      {
         "pgt_id":1198952,"dmlsts":"U","newparkpos":"1","preparkpos":"3","rkgelcag":"PGT82N","rkgelpltar":"2021-07-31 00:00:00.0","rkgelplsaat":"16:55:00","rkgidcag":"PGT2260","rkgidpltar":"2021-07-31 00:00:00.0","rkgidplsaat":"18:00:00","send":1,"delFly":0
      },{
         "pgt_id":1198826,"newparkpos":"204B","preparkpos":"201A","rkgelcag":"PGT14J","rkgelplsaat":"14:30:00","rkgidcag":"PGT59K","rkgidplsaat":"17:35:00","delFly":0
      }
   ]
}

private fun loadData(){
         val retrofit=Retrofit.Builder()
             .baseUrl(BASE_URL)
             .addConverterFactory(GsonConverterFactory.create())
             .build()

         val  service =retrofit.create(FlightAPI::class.java)

         val call=service.getData()

         call.enqueue(object : Callback<Flightmodel> {
             override fun onResponse(call: Call<Flightmodel>,response: Response<Flightmodel>) {

                 if (response != null && response.isSuccessful && response.body() != null) {
                     var data=response.body();
                 }
             }

             override fun onFailure(call: Call<Flightmodel>,t: Throwable) {
                 Todo("Not yet implemented")
             }


         })


    }
    }

data class Flightmodel(
    val flyList: List<Fly>
)


data class Fly(
    val delFly: Int,val dmlsts: String,val newparkpos: String,val pgt_id: Int,val preparkpos: Any,val rkgelcag: String,val rkgelplsaat: String,val rkgelpltar: String,val rkgidcag: String,val rkgidplsaat: String,val rkgidpltar: String,val send: Int
)

     fun getData():Call<FlightModel>

}

call.enqueue(object : Callback<FlightModel>{
             override fun onResponse(call: Call<FlightModel>,response: Response<FlightModel>) {
                var  flightModel =response?.body()
                flightModels = flightModel?.flyList as ArrayList<Fly>?

                 for (fly : Fly in flightModels!!){
                     println("Gel_Ad.........:"+fly.rkgelcag)
                 }


             }