当前位置:天才代写 > tutorial > 安卓教程 > Android学习笔记之Fast Json的使用

Android学习笔记之Fast Json的使用

2021-02-24 12:07 星期三 所属: 安卓教程 浏览:7

PS:近期这几天发觉了Fast Json 觉得确实是强劲..

 

学习内容:

1.什么叫Fast Json

2.怎么使用Fast Json

3.Fast Json的有关基本原理

4.Fast Json的优点,及其为何强烈推荐应用Fast Json

 

1.Fast Json的有关详细介绍

  讲到Json想来大家都不生疏,传输数据的二种方式之一,另一种便是大家的xml了.但是如今大量的還是应用根据Json的文件格式来开展传输数据,Java的api接口为大家出示了有关的api接口用以对Json数据信息开展解决,如何把数据信息装包成Json的文件格式,及其如何把Json数据信息分析成JavaBean.可是Java內部的api接口尽管能够考虑大家的规定,可是通常可以符合要求的不一定便是最好是的.

  就而言说Fast Json吧.Fast Json是阿里巴巴建立的一款api接口,用以对Json的解决,Fast Json的特性是十分的优良的,分析的速率要超出别的的插口殊不知他的有点儿远远地不仅这种,大家来例举一下他的有关优势吧.

  i.最先便是速率上.Fast Json的分析速率是十分高效率的,速度更快的缘故便是应用了蚁群算法,因而他的速率要远远地好于别的的api接口.

  ii.沒有依赖感,在JDK 5.0逐渐被宣布的开启,适用Android,适用的基本数据类型也是十分的多.

  多的空话因为我就很少讲了,写本文的关键目地是强烈推荐大伙儿去应用Fast Json。

2.怎么使用Fast Json

  讲到怎么使用只不过便是怎样把目前的数据信息转换成Json的文件格式,及其如何把目前的Json文件格式的数据信息分析成大家要想的数据信息.简言之便是将数据信息封裝和分析.

  大家如今应用Java出示的目前的api接口还可以进行将数据信息封裝成Json文件格式的数据信息,还可以将目前的Json文件格式数据信息分析成JsonObject和JsonArray,随后在大家的应用软件中去应用这种数据信息.可是有关这章我只说一说怎么使用Fast Json对数据信息开展封裝,及其如何把目前的Json文件格式的数据信息开展有关的分析.

  還是看来一下Fast Json怎样在运用之中去应用才算是关键的.先说应用方法,随后在说有关的內部基本原理.

package com.example.FastJson;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

public class Fastjson {

    //将List结合中储存的数据信息转换成Json种类数据信息.
    public void ListToJson(List<User> list){
      String text = JSON.toJSONString(list, true);
      System.out.println(text);
    }
    //将List结合中储存的数据信息转化成多级别Json数据信息..
    public void ListToMutiJson(List<User> list){
       String text = JSON.toJSONString(list,true);
      System.out.println(text);
    }    

    //将数据信息封裝成Json.
    public String toJsonString(){
        User user = new User("1", "a", 18);
        String text = JSON.toJSONString(user);
        System.out.println("toJsonString:将JavaBean转换成Json数据信息" text);
        return text;
    }
    //将目前的Json数据信息分析成JavaObject目标
    public void toParseJson(String text){
        JSONObject object = JSON.parseObject(text);
        System.out.println("toParseJson:将目前的Json分析成JavaObject" object);
    }
    //将JavaBean转换成Json目标.
    public void JavaBeanToJson(User user){
        JSONObject jsonObject = (JSONObject) JSON.toJSON(user);
        System.out.println("将JavaBean转换成Json目标" jsonObject);
    }
    //将Json目标转换成JavaBean
    public void JsonToJavaBean(String text){
        User user = (User) JSON.parseObject(text, User.class);
        System.out.println("将Json目标转换成JavaBean后的数据获取" user.getId() " " user.getName() " " user.getAge());
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Fastjson fastjson = new Fastjson();
        String test = fastjson.toJsonString();
        fastjson.toParseJson(test);
        User user_1 = new User("2","b",19);
        fastjson.JavaBeanToJson(user_1);
        fastjson.JsonToJavaBean(test);   
        List<User>lists = new ArrayList<User>();
        User user = new User("1", "a", 18);
        lists.add(user);
        fastjson.ListToJson(lists);
        lists.clear();
        User user2 = new User("2", "b", 19, new From("我国", "山东", "淄博市", "张店区"));
        lists.add(user2);
        fastjson.ListToMutiJson(lists);
    }
} 

  User.java和From.java便是2个简易的Java Bean.在这儿我不开展黏贴了..没什么必需..最终这种数据信息都是会被封裝成Json文件格式的数据信息.封裝实际上并并不是大家要想的..一般而言,大家关键還是对于Json的分析,根据服务器发送来的Json数据信息,手机客户端对其开展分析,随后获得到网络服务器的数据信息,才算是最重要的..分析Json数据信息的方法一般便是根据应用出示的涵数,将Json分析成JsonObject或是是JsonArray..随后再将其转换成JavaBean就可以了

  讲了这么多,大家就开展下一个全过程,Fast Json分析Json的基本原理..

3.Fast Json分析Json的基本原理

  说到基本原理就迫不得已看源代码了,Fast Json的分析Json的方法源代码有很多种多样,我也对于将数据信息分析成Java Bean而言吧.也是十分常见的一个涵数..大家看来这一涵数.

package com.example.parser;

import org.json.JSONException;
import org.json.JSONObject;

import android.text.TextUtils;

import com.alibaba.fastjson.JSON;
import com.example.vo.Version;

/**
 * @author 编码似风
 * 版本号在线解析
 * 
 * */
public class VersionParser extends BaseParser<Version>{

    //分析URL中的JSON数据信息,将JSON分析成Object
    /**
     *  1. parseObject 启用 --> public static final <T> T parseObject()
     *  
     *  @param String           JSON数据信息 
     *  @param Class            class属性
     *  @param ParserConfig     分析主要参数目标实例化
     *  @param int              变量值
     *  @param Feature          ???
     *
     * */
    @Override
    public Version parseJSON(String paramString) throws JSONException {
        // TODO Auto-generated method stub
        if(!TextUtils.isEmpty(paramString)){
            JSONObject j = new JSONObject(paramString);
            String version = j.getString("version");
                        //调用函数,将目前的Json数据信息分析转化成Java Bean
            return JSON.parseObject(version, Version.class);
        }
        return null;
    }
}

  那麼我也对于JSON.parseObject(version, Version.class)这一涵数做一下有关的分析,别的涵数大伙儿有兴趣爱好的能够去研究,基本原理大部分全是类似的.

public abstract class JSON implements JSONStreamAware, JSONAware{
       public static final int DEFAULT_PARSER_FEATURE;
       public static final int DEFAULT_GENERATE_FEATURE;
       public static CharsetDecoder UTF8_CharsetEncoder;
       static  {
//默认设置分析方法,将Feature的一些有关特性开展累加..
int features = 0; features |= Feature.AutoCloseSource.getMask(); features |= Feature.InternFieldNames.getMask(); features |= Feature.UseBigDecimal.getMask(); features |= Feature.AllowUnQuotedFieldNames.getMask(); features |= Feature.AllowSingleQuotes.getMask(); features |= Feature.AllowArbitraryCommas.getMask(); features |= Feature.SortFeidFastMatch.getMask(); features |= Feature.IgnoreNotMatch.getMask(); DEFAULT_PARSER_FEATURE = features;
//默认设置转化成的一些特性.
int features = 0; features |= SerializerFeature.QuoteFieldNames.getMask(); features |= SerializerFeature.SkipTransientField.getMask(); features |= SerializerFeature.SortField.getMask(); DEFAULT_GENERATE_FEATURE = features; UTF8_CharsetEncoder = new UTF8Decoder(); }
/** 正中间一堆 .....*/ //源代码中启用的方式... public static final <T> T parseObject(String text, Class<T> clazz) { //加上了一个Feature特性 return parseObject(text, clazz, new Feature[0]); } //进一步的封裝 public static final <T> T parseObject(String text, Class<T> clazz, Feature[] features){ //加上分析的有关配备,分析的方法,及其Feature的附加特性信息内容 return parseObject(text, clazz, ParserConfig.getGlobalInstance(), DEFAULT_PARSER_FEATURE, features); } public static final <T> T parseObject(String input, Type clazz, ParserConfig config, int featureValues, Feature[] features){ //假如分析的数据信息为空,那麼回到空. if (input == null) { return null; } //解析xmlFeature二维数组,将这种值开展累加..最终转化成一个FeatureValue. for (Feature featrue : features) { featureValues = Feature.config(featureValues, featrue, true); } //设定Json的分析方法.实例化DefaultExtJSONParser DefaultExtJSONParser parser = new DefaultExtJSONParser(input, config, featureValues); //真实的分析全过程. Object value = parser.parseObject(clazz); //假如clazz != JSONArray的字节码文档..关掉分析 if (clazz != JSONArray.class) { parser.close(); } return value; }
  }

  之上便是将Json数据信息转换成Java Bean的源代码启用全过程.大家再说实际的剖析一下..由于里边還是涉及到到许多的內容..我们可以见到在分析的情况下并并不是一步就立即进行的..正中间全过程必须封裝有关的数据信息才可以对Json开展分析.最先便是Feature的封裝.

 Feature是一个枚举类型..它承继了Enum类..也就代表着这一枚举类型不可以被承继,一样,枚举类型自变量也是比较有限且固定不动的.而且建立一个枚举类型是线程安全的.更关键的一点便是枚举类型在开展实例化实际操作的情况下可以维持列项方式..简言之便是在实例化和反序列化实际操作的情况下确保实际操作的是同一个目标,也就不会在实例化的情况下对于的是当今这一目标,而在反序列化的情况下必须再次new一个新的目标..

/*    */ package com.alibaba.fastjson.parser;
/*    */ 
/*    */ public enum Feature
/*    */ {
/* 22 */   AutoCloseSource, 
/*    */ 
/* 26 */   AllowComment, 
/*    */ 
/* 30 */   AllowUnQuotedFieldNames, 
/*    */ 
/* 34 */   AllowSingleQuotes, 
/*    */ 
/* 38 */   InternFieldNames, 
/*    */ 
/* 42 */   AllowISO8601DateFormat, 
/*    */ 
/* 47 */   AllowArbitraryCommas, 
/*    */ 
/* 52 */   UseBigDecimal, 
/*    */ 
/* 57 */   IgnoreNotMatch, 
/*    */ 
/* 62 */   SortFeidFastMatch, 
/*    */ 
/* 67 */   DisableASM;
/*    */ 
/*    */   private final int mask;
/*    */   
             //将枚举类型变量定义的序数偏移一位.
/*    */   private Feature()
/*    */   {
/* 74 */     this.mask = (1 << ordinal());
/*    */   }
/*    */   //回到mask..
/*    */   public final int getMask()
/*    */   {
/* 80 */     return this.mask;
/*    */   }
/*    */ 
/*    */   public static boolean isEnabled(int features, Feature feature) {
/* 84 */     return (features & feature.getMask()) != 0;
/*    */   }
/*    */   
           //JSON源码中启用的方式.将默认设置的特性与Feature的附加特性开展封裝.
/*    */   public static int config(int features, Feature feature, boolean state) {
/* 88 */     if (state)
/* 89 */       features |= feature.getMask();
/*    */     else {
/* 91 */       features &= (feature.getMask() ^ 0xFFFFFFFF);
/*    */     }
/*    */ 
/* 94 */     return features;
/*    */   }
/*    */ }

   这就是Feature的源码..內部封裝了一些枚举类型的自变量..关键对于于Json的数据信息分析,Feature依照自己的了解实际上便是在分析Json或是是封裝成Json时的特配备,我们可以见到在Json类中加上了Feature特性特点..最终将默认设置的一些特点与Feature的别的附加特点开展封裝..最终开展分析或是装包..也要说一点便是还有一个是SerializerFeature特性..实例化特性,也是一个枚举类型..它实际上也是对于Json的一些附加特点配备(例如在Json中适用以双引号的方式将数据信息括起來这些)..

  分析便是根据实例化DefaultExtJSONParser目标逐渐,随后根据启用有关的方式对Json开展分析..根据应用parseObject方式来进行分析..分析的全过程也是Fast Json提升的较大 的地区..也就造成了他的分析速率要超出别的api接口对Json数据信息分析的速率.

public <T> T parseObject(Type type){
    if (this.lexer.token() == 8) {
       this.lexer.nextToken();
      return null;
    }
    ObjectDeserializer derializer = this.config.getDeserializer(type);
    try{
        return derializer.deserialze(this, type);
    }catch (JSONException e) {
        throw e;
    }catch (Throwable e) {
        throw new JSONException(e.getMessage(), e);
    }
}

  这就是分析的源码..实际上看起来十分的简易..事实上Fast Json在这个地方提升的地区十分的多,也就造成了其分析Json的速率是十分高效率的.那麼大家就讨论一下Fast Json为什么较为高效率。。

4.Fast Json高效率的缘故,为何强烈推荐应用Fast Json

 Fast json高效率顺理成章是有它的缘故的..我关键对于几个方面而言说..由于我并沒有彻底的看了Fast Json的源代码..仅仅自身的一些看法,说的也就并不是十分的全方位..

 1. 应用SerializeWriter

    将数据信息封裝成Json的情况下应用SerializerWriter来进行,根据对字符串数组的增加将数据交换成Json字符串.而且其內部出示了一些提升对于降低数组越界的分辨.(降低了越境的分辨的确可以提升一部分高效率)

    ThreadLocal来缓存文件buf,载入数据信息必定必须应用缓存文件来储放字符串数组的内存地址,可是每一次实例化的情况下都必须分配buf的存储空间,为了更好地防止数次申请办理存储空间及其gc的启用,因而将运行内存储存到ThreadLocal中,当再度开展实例化的情况下只必须从ThreadLocal中取下运行内存就可以了.

    而且ThreadLocal不仅能够缓存文件内存地址,在我们对Json数据信息开展分析的情况下也会应用到它出示的缓存文件..在我们在分析Json的情况下,大家载入到的key值能够被储存在一个叫sbuf的缓冲区域中,只需这一缓冲区域不被释放出来掉,那麼再度载入的情况下只必须从缓存中载入到有关的字符串数组编码序列就可以,没必要去new一个新的字符串数组目标,进而造成存储空间的开拓及其多余的gc调用..

 2.应用asm来防止反射机制的应用

    asm并不是一个优化算法,它是字节码架构技术性,它能够防止应用Java中的反射机制进而获得到一个类中的全部成员函数和方式,反射机制一样还可以完成,可是反射机制的一大弊端便是消耗時间.应用反射面正中间会转化成很多的临时性自变量进而造成gc的经常启用.(防止了反射面的应用,当然特性上也拥有一定的提升)  对于asm技术性也没有开展完全的科学研究..很有可能之后会写..有兴趣爱好的大伙儿能够自身去研究..

 3.应用IdentityHashMap去提升特性.

  由于Fast Json每个种类都相匹配一种分析方法,也就出現了<class,JavaBeanSerializer>的投射关联,那麼投射当然就必须应用有投射关联的结合,也就是HashMap<K,V>,可是HashMap并并不是线程安全的,也就是在高并发自然环境下能造成无限循环的出現.因而在高并发状况下大家就必须ConcurrentHashMap,可是比HashMap的特性要差,由于必须应用lock()等方式操纵线程同步的安全隐患.安全性就失去高效率,因而IndentityHashMap结合就在Fast Json中开发设计.他的內部去除开transfer方式,促使它可以在高并发的状况下也可以确保安全系数.一样高效率也就不容易遭受危害。

 4.Deserializer的关键蚁群算法..

  Deserializer也变成反序列化全过程,也就是将Json数据信息转换成Java Bean方式.也是提升活力数最多的地区.

  根据token的预测分析剖析:

  分析Json 必须应用到句法解决,Fast Json应用了根据预测分析的词法分析方法,例如:例如key以后,较大 的可能是灶具”:”,value以后,可能是有两个,分号”,”或是右括弧”}” 那样的预测分析剖析。

public void nextToken(int expect) {
/*      */     while (true) {
/*  297 */       switch (expect)
/*      */       {
/*      */       case 12:
/*  299 */         if (this.ch == '{') {
/*  300 */           this.token = 12;
/*  301 */           this.ch = this.buf[(  this.bp)];
/*  302 */           return;
/*      */         }
/*  304 */         if (this.ch == '[') {
/*  305 */           this.token = 14;
/*  306 */           this.ch = this.buf[(  this.bp)];
/*  307 */           return;
/*      */         }
/*      */       case 16:
/*  311 */         if (this.ch == ',') {
/*  312 */           this.token = 16;
/*  313 */           this.ch = this.buf[(  this.bp)];
/*  314 */           return;
/*      */         }
                      /** 正中间一堆....*/
                      if ((this.ch != ' ') && (this.ch != '\n') && (this.ch != '\r') && (this.ch != '\t') && (this.ch != '\f') && (this.ch != '\b')) break;
/*  419 */       this.ch = this.buf[(  this.bp)];
/*      */     }
/*      */ 
/*  423 */     nextToken();
/*      */   }

  预测分析剖析的源码便是上边黏贴的,仅仅黏贴了一部分,实际上便是对下一个token的预测分析分辨,那样能够协助大家尽最短的时间取得token..简易的说一下token的定义..

//这是一个Json字符串..在其中token单引号造成的一部分每一个单引号造成的一部分便是一个token这儿一共有13个token..
{ "id" : 123, "name" : "aa", "salary" : 56789}  //json字符串  
'{'       ' "id" '     ':'   '123'    ','    ' "name" '   ':'  ' "aa" '   ','   ' "salary" '  ':'   '56789'  '}' 

 那样token的定义就没那麼难了解了..

 5.Sort field fast match优化算法

   Fast Json在封裝和分析的情况下全是默认设置应用这一优化算法的,便是以井然有序的方法将Json 字符串数组开展储存,假如数据信息储存的方式是井然有序的,那麼就应用蚁群算法,无需对每一个token开展解决..只必须解决一部分的token就可以了..也恰好是由于这一缘故,促使Fast Json在分析Json的情况下能够降低50%的token…那样高效率上就拥有前所未有的转变 …要不是井然有序的大家就必须一个一个开展剖析了,随后从这当中取下key相匹配的value值.

  就那上边哪条Json数据信息而言吧,假如key值是井然有序的,那麼只必须解决6个token就可以了,可是如果是混乱的,就必须解决13个token..解决13个token不难理解..便是对扫描仪全部字符串数组,随后解决每一个token不就完了了..可是如果是井然有序的,那麼为何只必须解决6个token呢?我看了很多人的blog也没有对这方面开展解读..也就促使因为我十分的茫然..

  自己的理解是那样的:实际上对吗自己也不是十分的明确..(如果不对,大伙儿请强调)

  往往只必须解决6个token便是只必须对key和value值开展解决,三对key,value相匹配的也是6个token,由于大家应用了预测分析剖析,那麼顺理成章就知道Json的数据类型,拥有这一数据类型,那麼这些标记类的token就可以立即超越以往,大家早已配对到key那麼当然就预测分析到key后边有一个”,”那麼这一”,”大家就不用解决了,只必须解决”,”后边的value了..因而标记类的token是没必要解决的,可是为何要井然有序,由于我们都是将每一条的Json数据信息转换成字符数组的方式,在配对key值的情况下我们都是依照字符数组开展配对,假如每一条的次序都不一样,那麼就不可以应用一条标准去特使好几条数据信息遵照这一个标准开展分析..因而才开展排列,能够降低对token的载入和解决..(本人了解..不对得话,请强调..)

  这也就是Fast Json快速的缘故..当然有很多地区的物品没说到..Fast Json说成更快..是否更快大家讲了算不上,可是Fast Json的确融进了许多的观念..還是很非常好的一个分析Json的api接口..

  对于用无需在于大伙儿..也没必要去争吵谁分析Json更快..没有什么实际意义..

  本来实际上想深层次的科学研究一下,小结一下全部的缘故和观念..可是见到很多人写的物品全是九牛一毛..抄来抄去的..没写成关键的物品..等自身真实有时间的情况下再去讲解一下源代码再深层次的写吧..

 

  PS:最终仅仅调侃一下..假如有些人看见难受..请不要喷我..感谢!

  最终说一下自身学这方面的感受:说真话往往在Sort Field Fast match优化算法并不是很搞清楚的缘故便是沒有见到有关这方面写的十分优秀的文章,看过挺多的人的文章内容,看见是很厉害,可是写出去的物品绝大多数全是不明不白,不清不楚,我能了解应用很多的专业名词(实际上便是不说实话)..有的呢便是立即把别人写的物品立即黏贴以往,可能自身都没了解到底是如何一回事儿..搬他人的物品不是不能,仅仅在搬的情况下大家也去想一想,最终融合我们自己的观念写到blog上,那才叫自身真实的学了,博闻里才有自身的观念..立即抄来抄去,连改也不修改一下…确实很索然无味..

  觉得确实挺乏力的,Sort这方面担心了很长期究竟需不需要写出去,就怕不懂装懂…许多博闻写的物品仅仅写一个开始,就拿这一优化算法为何只解决了6个token,没什么太多的表述,什么叫asm也没什么太多的表述..(一开始还以为asm是优化算法,結果查了一下asm优化算法和图象处理相关,很显著就弄错了,之后才搞清楚asm是字节码架构技术性)..尽管自己很菜..可是我可以确保每一篇文章全是用非常大的思绪去写,自身安心就可以了…

 

 

 

 

 

 

 

    关键字:

天才代写-代写联系方式