Android-原生态、Goson、FastJson解析Json

什么是Json

1).json是一种取代XML的数据结构，和xml相比，它更小巧但描述能力却不差，由于他的小巧所以网络传输数据将减少更多流量从而加快速度。

2).在Json中，{ }双括号表示对象，[ ]中括号表示数组，" " 双引号内是属性值，：冒号表示后者是前者的值

3).{"name" : "March"} 可以理解为是一个包含name为March的对象

[{ "name" : "March"} , {"name" : "Judy"}] 就表示包含两个对象的数组

当然了，也可以使用 {"name" :["Michael" , "Judy"]}来简化上面一步，这是一个拥有一个name数组的对象

一.用原生态的方法解析json

同样的要记得先配置好网络环境,然后添加联网权限

<uses-permission android:name="android.permission.INTERNET"></uses-permission>

布局文件只是一个简单的Button

<Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="解析Json"
        android:onClick="parserJson"
        />

Activity

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }


    public void parserJson(View view){
        new MyTask().execute();
    }

    class MyTask extends AsyncTask{

        @Override
        protected Object doInBackground(Object[] params) {
            try {
                URL url=new URL(getString(R.string.service_name)+"person.json");
                HttpURLConnection connection= (HttpURLConnection) url.openConnection();
                //设置请求方式
                connection.setRequestMethod("GET");
                connection.setConnectTimeout(5000);

                //获取结果码
                int code=connection.getResponseCode();
                if(code==200){
                    InputStream is=connection.getInputStream();

                    BufferedReader br=new BufferedReader(new InputStreamReader(is));
                    String str=null;
                    StringBuffer stringBuffer=new StringBuffer();
                    while((str=br.readLine())!=null){
                        stringBuffer.append(str);
                    }
                    Log.i("test",stringBuffer.toString());

                    //01使用原生态的方式解析
                    JSONObject jsonObject=new JSONObject(stringBuffer.toString());
                    int list=jsonObject.getInt("list");
                    Log.i("test","长度"+list);

                    JSONArray jsonArray=jsonObject.getJSONArray("person");
                    for (int i = 0; i < jsonArray.length(); i++) {
                        JSONObject object=jsonArray.getJSONObject(i);
                        int pid=object.getInt("pid");
                        String pname=object.getString("pname");
                        int page=object.getInt("page");
                        Log.i("test",pid+"--"+pname+"--"+page);
                    }
                }

            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (JSONException e) {
                e.printStackTrace();
            }
            return null;
        }

        @Override
        protected void onPostExecute(Object o) {
            super.onPostExecute(o);
        }
    }

}

二.使用Gson解析Json

在写代码之前，我们先把Gson依赖弄好

1).右击项目，找到Open Moudle Settings

2).然后点击上面一条最后一个Dependencies，再点击右边的一个加号，选择Library dependency

搜索gson,选择第一个，然后添加，确定就好了

然后我们需要写两个实体类，符合我的Json文件，这是一个大的对象，大的对象里面有包含了两个属性，一个集合，一个对象数组

{"list":2,"persons":[{"pid":1,"pname":"张三","page":10},{"pid":2,"pname":"李四","page":40}]}

我们要写的一个实体类是最外面的这个大对象，为了好理解，所以我的命名也就直接翻译了

public class BigObject {
    private int list;
    private List<SmallObject> person;

    public BigObject() {
    }

    public BigObject(int list, List<SmallObject> person) {
        this.list = list;
        this.person = person;
    }

    public int getList() {
        return list;
    }

    public void setList(int list) {
        this.list = list;
    }

    public List<SmallObject> getPerson() {
        return person;
    }

    public void setPerson(List<SmallObject> person) {
        this.person = person;
    }
}

一个是对象里面的对象数组属性，在这个类里面，做了序列化的操作，重写两个方法describeContents、writeToParcel,然后定义一个常量

public class SmallObject implements Parcelable{
    private int pid;
    private String pname;
    private int page;

    public SmallObject() {
    }

    public SmallObject(int pid, String pname, int page) {
        this.pid = pid;
        this.pname = pname;
        this.page = page;
    }

    public int getPid() {
        return pid;
    }

    public void setPid(int pid) {
        this.pid = pid;
    }

    public String getPname() {
        return pname;
    }

    public void setPname(String pname) {
        this.pname = pname;
    }

    public int getPage() {
        return page;
    }

    public void setPage(int page) {
        this.page = page;
    }


    @Override
    public int describeContents() {
        return 0;
    }

    @Override// 序列化过程：必须按成员变量声明的顺序进行封装
    public void writeToParcel(Parcel parcel, int i) {
        parcel.writeInt(pid);
        parcel.writeString(pname);
        parcel.writeInt(page);
    }


    // 反序列过程：必须实现Parcelable.Creator接口，并且对象名必须为CREATOR
    // 读取Parcel里面数据时必须按照成员变量声明的顺序，Parcel数据来源上面writeToParcel方法，读出来的数据供逻辑层使用
    public static final Parcelable.Creator<SmallObject> CREATOR=new Parcelable.Creator<SmallObject>(){

        @Override
        public SmallObject createFromParcel(Parcel paecel) {
            SmallObject smallObject=new SmallObject();
            smallObject.setPid(paecel.readInt());
            smallObject.setPname(paecel.readString());
            smallObject.setPage(paecel.readInt());
            return smallObject;
        }

        @Override
        public SmallObject[] newArray(int size) {
            return new SmallObject[0];
        }
    };
}

在Activity里面，使用Gson方式解析Json，代码非常简单

//02.使用Gson解析Json
                    Gson gson=new Gson();
                    BigObject bigObject=gson.fromJson(stringBuffer.toString(),BigObject.class);
                    Log.i("test",bigObject.getList()+"");

                    List<SmallObject> objects=bigObject.getPerson();
                    for (SmallObject object: objects) {
                        Log.i("test",object.toString());
                    }

三.FastJson解析Json

首先我们要把fastjson.jar复制到我们的项目中去,先把jar包下载到自己本地，然后复制，添加到我们的项目的libs中，再右击AddAsLibrary就可以了

//03.FastJson
                    BigObject bigObject= JSON.parseObject(stringBuffer.toString(),BigObject.class);
                    Log.i("test",bigObject.getList()+"");
                    List<SmallObject> persons=bigObject.getPerson();
                    for (SmallObject person : persons) {
                        Log.i("test",person.toString());
                    }

相对而言，肯定是后面这两者解析Json的方式更简单快捷，但是，我们也还是需要了解底层的实现原理的

Android-原生态、Goson、FastJson解析Json

猜你喜欢