Gson,FASTjson 解析字符串为数组，日期等方式

混淆打包

.1 java 是既需要 解释 也需要编译 执行  
.2 变量名 不是给 机器看的(在字节码文件中可以找到哦)，这些方法名变量名对执行完全无用是程序员看的，class 中行号，把java语句编程字节码文件，这些发生语句在哪一行都会标出，混淆就是将这些删掉，类名等全删掉， jvm 解释型 直接用内存地址引用的话可读性太差
class 中对执行 完全无用 :方法名　变量名　类名　在class　中可见到这些
但是有一个行号　，可以对应找到一些东西，　混淆　就是把这些东西全删掉

json 解析当类名与字段名不一致时 如何解析

fastjson 中 与 gson 中不同解决方案

是什么？

① 当遇到字符串，一行两个img，目的：利用注解等方式解析成一个数组

② 当所建属性名，与接口属性名不一致时 目的：利用 注解方式使它进行解析

③ 当一个long 类型的数据，需要转换为 Date 类型时

fastJson gson 将数据转换对比：

fastjson 如果只是在当前类中使用，则比较简单，Gson 适合很多类的对象都需要进行这个实力转换，只要工程当中使用到这个类型的时候，都会自动帮我们转换。
(需要一个转换器，这个转换器是一个接口)gson 还可以进行版本管理
一个音频文件 会有多个时间 ，用 fastJson 的话 相对麻烦.可进行版本管理区间为前闭后开，[since,until)

怎么用 ？

用法a) gson 方式

解析 字符串为数组：

gson 不是静态方法，gson 需要有个对象，这个对象在创建的时候你需要给他设置一些值，可以自动帮我们转换一些东西 转换版本等。
images 网站中是 以 "," 形式进行隔开的
步骤：
类中 属性 改为字符串数组类型  
① 在异步类中：定义 Gson 类型的静态全局变量
② 静态代码块中 初始化gson 
③ return gson.fromJson(bos.toString("UTF-8"),Response.class)

package com.bitch.tools.network;

import android.os.AsyncTask;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Type;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Date;

/**
 * Created by ly on 16-4-1.
 */
public class NetworkTask<T> extends AsyncTask<NetworkTask.Callback<T>, Void, Object> {
    private static Gson gson;
    static {
        gson = new GsonBuilder().setVersion(1).registerTypeAdapter(String[].class, new TypeAdapter<String[]>() {
            @Override
            public void write(JsonWriter out, String[] value) throws IOException {
                if (value != null && value.length > 0 ) {
                    StringBuilder builder = new StringBuilder();
                    for (String s : value) {
                        builder.append(s).append(',');
                    }
                    builder.deleteCharAt(builder.length() - 1);
                    out.value(builder.toString());
                } else {
                    out.nullValue();
                }
            }

            @Override
            public String[] read(JsonReader in) throws IOException {
                String s = in.nextString();
                String[] result = null;
                if (s != null) {
                    result = s.split(",");
                }
                return result;
            }
        }).registerTypeAdapter(Date.class, new TypeAdapter<Date>() {
            @Override
            public void write(JsonWriter out, Date value) throws IOException {
                out.value(value.getTime());
            }

            @Override
            public Date read(JsonReader in) throws IOException {
                long l = in.nextLong();
                return new Date(l);
            }
        }).create();
    }

    public Callback<T> callback;
    public String url;
    public Type type;
    public NetworkTask(String url, Type type) {
        this.url = url;
        this.type = type;
    }

    @Override
    protected Object doInBackground(NetworkTask.Callback<T>... params) {
        try {
            callback = params[0];
            HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
            connection.setRequestMethod("GET");
            connection.setDoInput(true);
            connection.connect();
            int responseCode = connection.getResponseCode();
            if (responseCode == 200) {
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                InputStream is = connection.getInputStream();
                byte[] buffer = new byte[10 << 10];
                int length;
                while ((length = is.read(buffer)) != -1){
                    bos.write(buffer, 0, length);
                }
                return gson.fromJson(bos.toString("UTF-8"), type);
            } else {
                return new Exception("ResponseCode:" + responseCode);
            }
        } catch (IOException e) {
            return e;
        }
    }

    @Override
    protected void onPostExecute(Object response) {
        if (response instanceof Exception) {
            callback.onFailure((Exception) response);
        } else {
            callback.onResponse((T) response);
        }
    }
    public interface Callback<T>{
        void onResponse(T t);
        void onFailure(Exception e);
    }
}

*使用gson 的话  只要解析碰到 数组类型的字符串就会自动帮我们转成数
registerTypeAdapter : 注册一个类型为.. 的adapter  String 数组的适配器，
适配器是 以内部类的形式加上的

用法b) fastJson 方式

解析 字符串为数组：

异步下载json 字符串 fastjson 进行解析
实体类中，将需要转成数组的属性 改属性为数组
三使用注解：

JSON.parseObject(bos.toString("UTF-8"),Response.class);

@JSONfield(name="images")
public void setImg(String json){
    return json.split(",");
}