混淆打包

.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(",");
}