一代小雄
一代小雄

JackSon fasterxml学习

概述

Jackson框架是基于Java平台的一套数据处理工具，被称为“最好的Java Json解析器”。 
Jackson框架包含了3个核心库：streaming,databind,annotations.Jackson还包含了其它数据处理类库，此外不作说明。
Jackson版本： 1.x (目前版本从1.1~1.9)与2.x。1.x与2.x从包的命名上可以看出来，1.x的类库中，包命名以：org.codehaus.jackson.xxx开头，而2.x类库中包命令：com.fastxml.jackson.xxx开头

Jackson Home Page：https://github.com/FasterXML/jackson
Jackson Wiki：http://wiki.fasterxml.com/JacksonHome
Jackson doc: https://github.com/FasterXML/jackson-docs
Jackson Download Page：http://wiki.fasterxml.com/JacksonDownload


准备工作

本文所有程序都基于JDK1.7,依赖jackon的三个核心类库：
jackson-core-2.5.3.jar
jackson-annotations-2.5.3.jar
jackson-databind-2.5.3.jar


Jackson处理Json

Jackson提供了三种可选的Json处理方法：流式API(Streaming API) 、树模型(Tree Model)、数据绑定(Data Binding)。从使用角度来看，比较一下这三种处理Json的方式的特性：

Streaming API：是效率最高的处理方式(开销低、读写速度快，但程序编写复杂度高)
Tree Model：是最灵活的处理方式
Data Binding：是最常用的处理方式

下面我们通过例子程序分别使用DataBinding,TreeModel,Streaming的方式来创建和解析Json字符串

1.DataBinding处理Json

Jackson支持Java对象与Json之间的相互转化。java对象序列化为json字符串，json字符串也可以反序列化为相同的java对象。

(1)java对象转化成json:
Province.java
[java] view plain copy
print ?
  1. package com.jackson.json.databinding;  
  2.   
  3. public class Province {  
  4.     public String name;  
  5.     public int population;  
  6.     public String[] city;     
  7. }  
package com.jackson.json.databinding;

public class Province {
    public String name;
    public int population;
    public String[] city;   
}
Country.java
[java] view plain copy
print ?
  1. package com.jackson.json.databinding;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Arrays;  
  5. import java.util.Date;  
  6. import java.util.HashMap;  
  7. import java.util.List;  
  8. import java.util.Map;  
  9.   
  10. public class Country {  
  11.     // 注意：被序列化的bean的private属性字段需要创建getter方法或者属性字段应该为public  
  12.     private String country_id;  
  13.     private Date birthDate;  
  14.     private List nation = new ArrayList();  
  15.     private String[] lakes;  
  16.     private List provinces = new ArrayList();  
  17.     private Map traffic = new HashMap();  
  18.   
  19.     public Country() {  
  20.         // TODO Auto-generated constructor stub  
  21.     }  
  22.   
  23.     public Country(String countryId) {  
  24.         this.country_id = countryId;  
  25.     }  
  26.   
  27.     public String getCountry_id() {  
  28.         return country_id;  
  29.     }  
  30.   
  31.     public void setCountry_id(String country_id) {  
  32.         this.country_id = country_id;  
  33.     }  
  34.   
  35.     public Date getBirthDate() {  
  36.         return birthDate;  
  37.     }  
  38.   
  39.     public void setBirthDate(Date birthDate) {  
  40.         this.birthDate = birthDate;  
  41.     }  
  42.   
  43.     public List getNation() {  
  44.         return nation;  
  45.     }  
  46.   
  47.     public void setNation(List nation) {  
  48.         this.nation = nation;  
  49.     }  
  50.   
  51.     public String[] getLakes() {  
  52.         return lakes;  
  53.     }  
  54.   
  55.     public void setLakes(String[] lakes) {  
  56.         this.lakes = lakes;  
  57.     }  
  58.   
  59.     public Integer get(String key) {  
  60.         return traffic.get(key);  
  61.     }  
  62.   
  63.     public Map getTraffic() {  
  64.         return traffic;  
  65.     }  
  66.   
  67.     public void setTraffic(Map traffic) {  
  68.         this.traffic = traffic;  
  69.     }  
  70.   
  71.     public void addTraffic(String key, Integer value) {  
  72.         traffic.put(key, value);  
  73.     }  
  74.   
  75.     public List getProvinces() {  
  76.         return provinces;  
  77.     }  
  78.   
  79.     public void setProvinces(List provinces) {  
  80.         this.provinces = provinces;  
  81.     }  
  82.   
  83.     @Override  
  84.     public String toString() {  
  85.         return “Country [country_id=” + country_id + “, birthDate=” + birthDate  
  86.                 + ”, nation=” + nation + “, lakes=” + Arrays.toString(lakes)  
  87.                 + ”, province=” + provinces + “, traffic=” + traffic + “]”;  
  88.     }  
  89.   
  90. }  
package com.jackson.json.databinding;

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

public class Country {
    // 注意：被序列化的bean的private属性字段需要创建getter方法或者属性字段应该为public
    private String country_id;
    private Date birthDate;
    private List nation = new ArrayList();
    private String[] lakes;
    private List provinces = new ArrayList();
    private Map traffic = new HashMap();

    public Country() {
        // TODO Auto-generated constructor stub
    }

    public Country(String countryId) {
        this.country_id = countryId;
    }

    public String getCountry_id() {
        return country_id;
    }

    public void setCountry_id(String country_id) {
        this.country_id = country_id;
    }

    public Date getBirthDate() {
        return birthDate;
    }

    public void setBirthDate(Date birthDate) {
        this.birthDate = birthDate;
    }

    public List getNation() {
        return nation;
    }

    public void setNation(List nation) {
        this.nation = nation;
    }

    public String[] getLakes() {
        return lakes;
    }

    public void setLakes(String[] lakes) {
        this.lakes = lakes;
    }

    public Integer get(String key) {
        return traffic.get(key);
    }

    public Map getTraffic() {
        return traffic;
    }

    public void setTraffic(Map traffic) {
        this.traffic = traffic;
    }

    public void addTraffic(String key, Integer value) {
        traffic.put(key, value);
    }

    public List getProvinces() {
        return provinces;
    }

    public void setProvinces(List provinces) {
        this.provinces = provinces;
    }

    @Override
    public String toString() {
        return "Country [country_id=" + country_id + ", birthDate=" + birthDate
                + ", nation=" + nation + ", lakes=" + Arrays.toString(lakes)
                + ", province=" + provinces + ", traffic=" + traffic + "]";
    }

}
JavaBeanSerializeToJson.java
[java] view plain copy
print ?
  1. package com.jackson.json.databinding;  
  2.   
  3. import java.io.File;  
  4. import java.text.SimpleDateFormat;  
  5. import java.util.ArrayList;  
  6. import java.util.List;  
  7.   
  8. import com.fasterxml.jackson.annotation.JsonInclude.Include;  
  9. import com.fasterxml.jackson.databind.ObjectMapper;  
  10. import com.fasterxml.jackson.databind.SerializationFeature;  
  11.   
  12. public class JavaBeanSerializeToJson {  
  13.   
  14.     public static void convert() throws Exception {  
  15.         // 使用ObjectMapper来转化对象为Json  
  16.         ObjectMapper mapper = new ObjectMapper();  
  17.         // 添加功能，让时间格式更具有可读性  
  18.         SimpleDateFormat dateFormat = new SimpleDateFormat(“yyyy-MM-dd”);  
  19.         mapper.setDateFormat(dateFormat);  
  20.   
  21.         Country country = new Country(“China”);  
  22.         country.setBirthDate(dateFormat.parse(”1949-10-01”));  
  23.         country.setLakes(new String[] { “Qinghai Lake”, “Poyang Lake”,  
  24.                 ”Dongting Lake”, “Taihu Lake” });  
  25.   
  26.         List nation = new ArrayList();  
  27.         nation.add(”Han”);  
  28.         nation.add(”Meng”);  
  29.         nation.add(”Hui”);  
  30.         nation.add(”WeiWuEr”);  
  31.         nation.add(”Zang”);  
  32.         country.setNation(nation);  
  33.   
  34.         Province province = new Province();  
  35.         province.name = ”Shanxi”;  
  36.         province.population = 37751200;  
  37.         Province province2 = new Province();  
  38.         province2.name = ”ZheJiang”;  
  39.         province2.population = 55080000;  
  40.         List provinces = new ArrayList();  
  41.         provinces.add(province);  
  42.         provinces.add(province2);  
  43.         country.setProvinces(provinces);  
  44.           
  45.         country.addTraffic(”Train(KM)”, 112000);  
  46.         country.addTraffic(”HighWay(KM)”, 4240000);  
  47.         // 为了使JSON视觉上的可读性，增加一行如下代码，注意，在生产中不需要这样，因为这样会增大Json的内容  
  48.         mapper.configure(SerializationFeature.INDENT_OUTPUT, true);  
  49.         // 配置mapper忽略空属性  
  50.         mapper.setSerializationInclusion(Include.NON_EMPTY);  
  51.         // 默认情况，Jackson使用Java属性字段名称作为 Json的属性名称,也可以使用Jackson annotations(注解)改变Json属性名称  
  52.         mapper.writeValue(new File(“country.json”), country);  
  53.     }  
  54.   
  55.     public static void main(String[] args) throws Exception {  
  56.         convert();  
  57.     }  
  58.   
  59. }  
package com.jackson.json.databinding;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;

import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

public class JavaBeanSerializeToJson {

    public static void convert() throws Exception {
        // 使用ObjectMapper来转化对象为Json
        ObjectMapper mapper = new ObjectMapper();
        // 添加功能，让时间格式更具有可读性
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        mapper.setDateFormat(dateFormat);

        Country country = new Country("China");
        country.setBirthDate(dateFormat.parse("1949-10-01"));
        country.setLakes(new String[] { "Qinghai Lake", "Poyang Lake",
                "Dongting Lake", "Taihu Lake" });

        List nation = new ArrayList();
        nation.add("Han");
        nation.add("Meng");
        nation.add("Hui");
        nation.add("WeiWuEr");
        nation.add("Zang");
        country.setNation(nation);

        Province province = new Province();
        province.name = "Shanxi";
        province.population = 37751200;
        Province province2 = new Province();
        province2.name = "ZheJiang";
        province2.population = 55080000;
        List provinces = new ArrayList();
        provinces.add(province);
        provinces.add(province2);
        country.setProvinces(provinces);

        country.addTraffic("Train(KM)", 112000);
        country.addTraffic("HighWay(KM)", 4240000);
        // 为了使JSON视觉上的可读性，增加一行如下代码，注意，在生产中不需要这样，因为这样会增大Json的内容
        mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
        // 配置mapper忽略空属性
        mapper.setSerializationInclusion(Include.NON_EMPTY);
        // 默认情况，Jackson使用Java属性字段名称作为 Json的属性名称,也可以使用Jackson annotations(注解)改变Json属性名称
        mapper.writeValue(new File("country.json"), country);
    }

    public static void main(String[] args) throws Exception {
        convert();
    }

}
程序运行后生成country.json，内容如下：
[html] view plain copy
print ?
  1. {  
  2.   “country_id” : “China”,  
  3.   “birthDate” : “1949-10-01”,  
  4.   “nation” : [ “Han”, “Meng”, “Hui”, “WeiWuEr”, “Zang” ],  
  5.   “lakes” : [ “Qinghai Lake”, “Poyang Lake”, “Dongting Lake”, “Taihu Lake” ],  
  6.   “provinces” : [ {  
  7.     “name” : “Shanxi”,  
  8.     “population” : 37751200  
  9.   }, {  
  10.     “name” : “ZheJiang”,  
  11.     “population” : 55080000  
  12.   } ],  
  13.   “traffic” : {  
  14.     “HighWay(KM)” : 4240000,  
  15.     “Train(KM)” : 112000  
  16.   }  
  17. }  
{
  "country_id" : "China",
  "birthDate" : "1949-10-01",
  "nation" : [ "Han", "Meng", "Hui", "WeiWuEr", "Zang" ],
  "lakes" : [ "Qinghai Lake", "Poyang Lake", "Dongting Lake", "Taihu Lake" ],
  "provinces" : [ {
    "name" : "Shanxi",
    "population" : 37751200
  }, {
    "name" : "ZheJiang",
    "population" : 55080000
  } ],
  "traffic" : {
    "HighWay(KM)" : 4240000,
    "Train(KM)" : 112000
  }
}

(2)Json字符串反序列化为java对象：
[java] view plain copy
print ?
  1. package com.jackson.json.databinding;  
  2.   
  3. import java.io.File;  
  4. import java.io.IOException;  
  5. import java.text.SimpleDateFormat;  
  6. import java.util.Iterator;  
  7. import java.util.List;  
  8.   
  9. import com.fasterxml.jackson.core.JsonParseException;  
  10. import com.fasterxml.jackson.databind.DeserializationFeature;  
  11. import com.fasterxml.jackson.databind.JsonMappingException;  
  12. import com.fasterxml.jackson.databind.ObjectMapper;  
  13.   
  14. /** 
  15.  * 将Json字符串反序列化为Java对象 
  16.  */  
  17. public class JsonDeserializeToJava {  
  18.       
  19.     public static void main(String[] args) throws Exception {  
  20.         //ObjectMapper类用序列化与反序列化映射器  
  21.         ObjectMapper mapper = new ObjectMapper();  
  22.         File json = new File(“country.json”);  
  23.         //当反序列化json时，未知属性会引起的反序列化被打断，这里我们禁用未知属性打断反序列化功能，  
  24.         //因为，例如json里有10个属性，而我们的bean中只定义了2个属性，其它8个属性将被忽略  
  25.         mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);  
  26.           
  27.         //从json映射到java对象，得到country对象后就可以遍历查找,下面遍历部分内容，能说明问题就可以了  
  28.         Country country = mapper.readValue(json, Country.class);  
  29.         System.out.println(”country_id:”+country.getCountry_id());  
  30.         //设置时间格式，便于阅读  
  31.         SimpleDateFormat dateformat = new SimpleDateFormat(“yyyy-MM-dd”);  
  32.         String birthDate = dateformat.format(country.getBirthDate());  
  33.         System.out.println(”birthDate:”+birthDate);  
  34.           
  35.         List provinces = country.getProvinces();  
  36.         for (Province province : provinces) {  
  37.             System.out.println(”province:”+province.name + “\n” + “population:”+province.population);  
  38.         }  
  39.     }  
  40. }  
package com.jackson.json.databinding;

import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Iterator;
import java.util.List;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * 将Json字符串反序列化为Java对象
 */
public class JsonDeserializeToJava {

    public static void main(String[] args) throws Exception {
        //ObjectMapper类用序列化与反序列化映射器
        ObjectMapper mapper = new ObjectMapper();
        File json = new File("country.json");
        //当反序列化json时，未知属性会引起的反序列化被打断，这里我们禁用未知属性打断反序列化功能，
        //因为，例如json里有10个属性，而我们的bean中只定义了2个属性，其它8个属性将被忽略
        mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

        //从json映射到java对象，得到country对象后就可以遍历查找,下面遍历部分内容，能说明问题就可以了
        Country country = mapper.readValue(json, Country.class);
        System.out.println("country_id:"+country.getCountry_id());
        //设置时间格式，便于阅读
        SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd");
        String birthDate = dateformat.format(country.getBirthDate());
        System.out.println("birthDate:"+birthDate);

        List provinces = country.getProvinces();
        for (Province province : provinces) {
            System.out.println("province:"+province.name + "\n" + "population:"+province.population);
        }
    }
}
程序运行结果：
[html] view plain copy
print ?
  1. country_id:China  
  2. birthDate:1949-10-01  
  3. province:Shanxi  
  4. population:37751200  
  5. province:ZheJiang  
  6. population:55080000  
country_id:China
birthDate:1949-10-01
province:Shanxi
population:37751200
province:ZheJiang
population:55080000

2.Tree Model处理Json

(1)tree model生成json:

[java] view plain copy
print ?
  1. package com.jackson.json.treemodel;  
  2.   
  3. import java.io.File;  
  4. import java.io.FileWriter;  
  5.   
  6. import com.fasterxml.jackson.core.JsonFactory;  
  7. import com.fasterxml.jackson.core.JsonGenerator;  
  8. import com.fasterxml.jackson.databind.ObjectMapper;  
  9. import com.fasterxml.jackson.databind.SerializationFeature;  
  10. import com.fasterxml.jackson.databind.node.ArrayNode;  
  11. import com.fasterxml.jackson.databind.node.JsonNodeFactory;  
  12. import com.fasterxml.jackson.databind.node.ObjectNode;  
  13.   
  14. public class SerializationExampleTreeModel {  
  15.       
  16.     public static void main(String[] args) throws Exception {  
  17.         //创建一个节点工厂,为我们提供所有节点  
  18.         JsonNodeFactory factory = new JsonNodeFactory(false);  
  19.         //创建一个json factory来写tree modle为json  
  20.         JsonFactory jsonFactory = new JsonFactory();  
  21.         //创建一个json生成器  
  22.         JsonGenerator generator = jsonFactory.createGenerator(new FileWriter(new File(“country2.json”)));  
  23.         //注意，默认情况下对象映射器不会指定根节点，下面设根节点为country  
  24.         ObjectMapper mapper = new ObjectMapper();  
  25.         ObjectNode country = factory.objectNode();  
  26.           
  27.         country.put(”country_id”, “China”);  
  28.         country.put(”birthDate”, “1949-10-01”);  
  29.           
  30.         //在Java中，List和Array转化为json后对应的格式符号都是”obj:[]”  
  31.         ArrayNode nation = factory.arrayNode();  
  32.         nation.add(”Han”).add(“Meng”).add(“Hui”).add(“WeiWuEr”).add(“Zang”);  
  33.         country.set(”nation”, nation);  
  34.           
  35.         ArrayNode lakes = factory.arrayNode();  
  36.         lakes.add(”QingHai Lake”).add(“Poyang Lake”).add(“Dongting Lake”).add(“Taihu Lake”);  
  37.         country.set(”lakes”, lakes);  
  38.           
  39.         ArrayNode provinces = factory.arrayNode();  
  40.         ObjectNode province = factory.objectNode();  
  41.         ObjectNode province2 = factory.objectNode();  
  42.         province.put(”name”,“Shanxi”);  
  43.         province.put(”population”, 37751200);  
  44.         province2.put(”name”,“ZheJiang”);  
  45.         province2.put(”population”, 55080000);  
  46.         provinces.add(province).add(province2);  
  47.         country.set(”provinces”, provinces);  
  48.           
  49.         ObjectNode traffic = factory.objectNode();  
  50.         traffic.put(”HighWay(KM)”, 4240000);  
  51.         traffic.put(”Train(KM)”, 112000);  
  52.         country.set(”traffic”, traffic);  
  53.           
  54.         mapper.configure(SerializationFeature.INDENT_OUTPUT, true);  
  55.         mapper.writeTree(generator, country);  
  56.     }  
  57.   
  58. }  
package com.jackson.json.treemodel;

import java.io.File;
import java.io.FileWriter;

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.ObjectNode;

public class SerializationExampleTreeModel {

    public static void main(String[] args) throws Exception {
        //创建一个节点工厂,为我们提供所有节点
        JsonNodeFactory factory = new JsonNodeFactory(false);
        //创建一个json factory来写tree modle为json
        JsonFactory jsonFactory = new JsonFactory();
        //创建一个json生成器
        JsonGenerator generator = jsonFactory.createGenerator(new FileWriter(new File("country2.json")));
        //注意，默认情况下对象映射器不会指定根节点，下面设根节点为country
        ObjectMapper mapper = new ObjectMapper();
        ObjectNode country = factory.objectNode();

        country.put("country_id", "China");
        country.put("birthDate", "1949-10-01");

        //在Java中，List和Array转化为json后对应的格式符号都是"obj:[]"
        ArrayNode nation = factory.arrayNode();
        nation.add("Han").add("Meng").add("Hui").add("WeiWuEr").add("Zang");
        country.set("nation", nation);

        ArrayNode lakes = factory.arrayNode();
        lakes.add("QingHai Lake").add("Poyang Lake").add("Dongting Lake").add("Taihu Lake");
        country.set("lakes", lakes);

        ArrayNode provinces = factory.arrayNode();
        ObjectNode province = factory.objectNode();
        ObjectNode province2 = factory.objectNode();
        province.put("name","Shanxi");
        province.put("population", 37751200);
        province2.put("name","ZheJiang");
        province2.put("population", 55080000);
        provinces.add(province).add(province2);
        country.set("provinces", provinces);

        ObjectNode traffic = factory.objectNode();
        traffic.put("HighWay(KM)", 4240000);
        traffic.put("Train(KM)", 112000);
        country.set("traffic", traffic);

        mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
        mapper.writeTree(generator, country);
    }

}

程序运行生成country2.json,内容如下：

[html] view plain copy
print ?
  1. {“country_id”:”China”,”birthDate”:”1949-10-01”,”nation”:[“Han”,”Meng”,”Hui”,”WeiWuEr”,”Zang”],”lakes”:[“QingHai Lake”,”Poyang Lake”,”Dongting Lake”,”Taihu Lake”],”provinces”:[{“name”:”Shanxi”,”population”:37751200},{“name”:”ZheJiang”,”population”:55080000}],”traffic”:{“HighWay(KM)”:4240000,”Train(KM)”:112000}}  
{"country_id":"China","birthDate":"1949-10-01","nation":["Han","Meng","Hui","WeiWuEr","Zang"],"lakes":["QingHai Lake","Poyang Lake","Dongting Lake","Taihu Lake"],"provinces":[{"name":"Shanxi","population":37751200},{"name":"ZheJiang","population":55080000}],"traffic":{"HighWay(KM)":4240000,"Train(KM)":112000}}

(2) json字符串反序列化为tree mode

DeserializationExampleTreeModel1.java,请注意观察程序中不同的JsonNode的类型变化

[java] view plain copy
print ?
  1. package com.jackson.json.treemodel;  
  2.   
  3. import java.io.File;  
  4. import java.util.Iterator;  
  5.   
  6. import com.fasterxml.jackson.databind.JsonNode;  
  7. import com.fasterxml.jackson.databind.ObjectMapper;  
  8.   
  9. public class DeserializationExampleTreeModel1 {  
  10.   
  11.     public static void main(String[] args) throws Exception {  
  12.         ObjectMapper mapper = new ObjectMapper();  
  13.         // Jackson提供一个树节点被称为”JsonNode”,ObjectMapper提供方法来读json作为树的JsonNode根节点  
  14.         JsonNode node = mapper.readTree(new File(“country2.json”));  
  15.         // 看看根节点的类型  
  16.         System.out.println(”node JsonNodeType:”+node.getNodeType());  
  17.         // 是不是一个容器  
  18.         System.out.println(”node is container Node ? ”+node.isContainerNode());  
  19.         // 得到所有node节点的子节点名称  
  20.         System.out.println(”———得到所有node节点的子节点名称————————-“);  
  21.         Iterator fieldNames = node.fieldNames();  
  22.         while (fieldNames.hasNext()) {  
  23.             String fieldName = fieldNames.next();  
  24.             System.out.print(fieldName+” ”);  
  25.         }  
  26.         System.out.println(”\n—————————————————–”);  
  27.         // as.Text的作用是有值返回值，无值返回空字符串  
  28.         JsonNode country_id = node.get(”country_id”);  
  29.         System.out.println(”country_id:”+country_id.asText() + “ JsonNodeType:”+country_id.getNodeType());  
  30.           
  31.         JsonNode birthDate = node.get(”birthDate”);  
  32.         System.out.println(”birthDate:”+birthDate.asText()+“ JsonNodeType:”+birthDate.getNodeType());  
  33.           
  34.         JsonNode nation = node.get(”nation”);  
  35.         System.out.println(”nation:”+ nation+ “ JsonNodeType:”+nation.getNodeType());  
  36.           
  37.         JsonNode lakes = node.get(”lakes”);  
  38.         System.out.println(”lakes:”+lakes+“ JsonNodeType:”+lakes.getNodeType());  
  39.   
  40.         JsonNode provinces = node.get(”provinces”);  
  41.         System.out.println(”provinces JsonNodeType:”+provinces.getNodeType());  
  42.   
  43.         boolean flag = true;  
  44.         for (JsonNode provinceElements : provinces) {  
  45.             //为了避免provinceElements多次打印，用flag控制打印，能体现provinceElements的JsonNodeType就可以了  
  46.             if(flag){  
  47.                 System.out.println(”provinceElements JsonNodeType:”+provinceElements.getNodeType());  
  48.                 System.out.println(”provinceElements is container node? ”+provinceElements.isContainerNode());  
  49.                 flag = false;  
  50.             }  
  51.             Iterator provinceElementFields = provinceElements.fieldNames();  
  52.             while (provinceElementFields.hasNext()) {  
  53.                 String fieldName = (String) provinceElementFields.next();  
  54.                 String province;  
  55.                 if (“population”.equals(fieldName)) {  
  56.                     province = fieldName + ”:” + provinceElements.get(fieldName).asInt();  
  57.                 }else{  
  58.                     province = fieldName + ”:” + provinceElements.get(fieldName).asText();  
  59.                 }  
  60.                 System.out.println(province);  
  61.             }  
  62.         }  
  63.     }  
  64. }  
package com.jackson.json.treemodel;

import java.io.File;
import java.util.Iterator;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class DeserializationExampleTreeModel1 {

    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        // Jackson提供一个树节点被称为"JsonNode",ObjectMapper提供方法来读json作为树的JsonNode根节点
        JsonNode node = mapper.readTree(new File("country2.json"));
        // 看看根节点的类型
        System.out.println("node JsonNodeType:"+node.getNodeType());
        // 是不是一个容器
        System.out.println("node is container Node ? "+node.isContainerNode());
        // 得到所有node节点的子节点名称
        System.out.println("---------得到所有node节点的子节点名称-------------------------");
        Iterator fieldNames = node.fieldNames();
        while (fieldNames.hasNext()) {
            String fieldName = fieldNames.next();
            System.out.print(fieldName+" ");
        }
        System.out.println("\n-----------------------------------------------------");
        // as.Text的作用是有值返回值，无值返回空字符串
        JsonNode country_id = node.get("country_id");
        System.out.println("country_id:"+country_id.asText() + " JsonNodeType:"+country_id.getNodeType());

        JsonNode birthDate = node.get("birthDate");
        System.out.println("birthDate:"+birthDate.asText()+" JsonNodeType:"+birthDate.getNodeType());

        JsonNode nation = node.get("nation");
        System.out.println("nation:"+ nation+ " JsonNodeType:"+nation.getNodeType());

        JsonNode lakes = node.get("lakes");
        System.out.println("lakes:"+lakes+" JsonNodeType:"+lakes.getNodeType());

        JsonNode provinces = node.get("provinces");
        System.out.println("provinces JsonNodeType:"+provinces.getNodeType());

        boolean flag = true;
        for (JsonNode provinceElements : provinces) {
            //为了避免provinceElements多次打印，用flag控制打印，能体现provinceElements的JsonNodeType就可以了
            if(flag){
                System.out.println("provinceElements JsonNodeType:"+provinceElements.getNodeType());
                System.out.println("provinceElements is container node? "+provinceElements.isContainerNode());
                flag = false;
            }
            Iterator provinceElementFields = provinceElements.fieldNames();
            while (provinceElementFields.hasNext()) {
                String fieldName = (String) provinceElementFields.next();
                String province;
                if ("population".equals(fieldName)) {
                    province = fieldName + ":" + provinceElements.get(fieldName).asInt();
                }else{
                    province = fieldName + ":" + provinceElements.get(fieldName).asText();
                }
                System.out.println(province);
            }
        }
    }
}

程序运行后打印结果如下：

[html] view plain copy
print ?
  1. node JsonNodeType:OBJECT  
  2. node is container Node ? true  
  3. ———得到所有node节点的子节点名称————————-  
  4. country_id birthDate nation lakes provinces traffic   
  5. —————————————————–  
  6. country_id:China JsonNodeType:STRING  
  7. birthDate:1949-10-01 JsonNodeType:STRING  
  8. nation:[“Han”,”Meng”,”Hui”,”WeiWuEr”,”Zang”] JsonNodeType:ARRAY  
  9. lakes:[“QingHai Lake”,”Poyang Lake”,”Dongting Lake”,”Taihu Lake”] JsonNodeType:ARRAY  
  10. provinces JsonNodeType:ARRAY  
  11. provinceElements JsonNodeType:OBJECT  
  12. provinceElements is container node? true  
  13. name:Shanxi  
  14. population:37751200  
  15. name:ZheJiang  
  16. population:55080000  
node JsonNodeType:OBJECT
node is container Node ? true
---------得到所有node节点的子节点名称-------------------------
country_id birthDate nation lakes provinces traffic ----------------------------------------------------- country_id:China JsonNodeType:STRING birthDate:1949-10-01 JsonNodeType:STRING nation:["Han","Meng","Hui","WeiWuEr","Zang"] JsonNodeType:ARRAY lakes:["QingHai Lake","Poyang Lake","Dongting Lake","Taihu Lake"] JsonNodeType:ARRAY provinces JsonNodeType:ARRAY provinceElements JsonNodeType:OBJECT provinceElements is container node? true name:Shanxi population:37751200 name:ZheJiang population:55080000


在来看一下DeserializationExampleTreeModel2.java,本例中使用JsonNode.path的方法，path方法类似于DeserializationExampleTreeModel1.java中使用的get方法，

但当node不存在时,get方法返回null,而path返回MISSING类型的JsonNode

[java] view plain copy
print ?
  1. package com.jackson.json.treemodel;  
  2.   
  3. import java.io.File;  
  4. import java.io.IOException;  
  5. import java.util.Iterator;  
  6.   
  7. import com.fasterxml.jackson.core.JsonProcessingException;  
  8. import com.fasterxml.jackson.databind.JsonNode;  
  9. import com.fasterxml.jackson.databind.ObjectMapper;  
  10.   
  11. public class DeserializationExampleTreeModle2 {  
  12.       
  13.     public static void main(String[] args) throws JsonProcessingException, IOException{  
  14.         ObjectMapper mapper = new ObjectMapper();  
  15.         JsonNode node = mapper.readTree(new File(“country2.json”));  
  16.         //path方法获取JsonNode时，当对象不存在时，返回MISSING类型的JsonNode  
  17.         JsonNode missingNode = node.path(”test”);  
  18.         if(missingNode.isMissingNode()){  
  19.             System.out.println(”JsonNodeType : ” + missingNode.getNodeType());  
  20.         }  
  21.   
  22.         System.out.println(”country_id:”+node.path(“country_id”).asText());  
  23.           
  24.         JsonNode provinces = node.path(”provinces”);  
  25.         for (JsonNode provinceElements : provinces) {  
  26.             Iterator provincesFields = provinceElements.fieldNames();  
  27.             while (provincesFields.hasNext()) {  
  28.                 String fieldName = (String) provincesFields.next();  
  29.                 String province;  
  30.                 if(“name”.equals(fieldName)){  
  31.                     province = fieldName +”:”+ provinceElements.path(fieldName).asText();  
  32.                 }else{  
  33.                     province = fieldName +”:”+ provinceElements.path(fieldName).asInt();  
  34.                 }  
  35.                 System.out.println(province);  
  36.             }  
  37.         }  
  38.     }  
  39.   
  40. }  
package com.jackson.json.treemodel;

import java.io.File;
import java.io.IOException;
import java.util.Iterator;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class DeserializationExampleTreeModle2 {

    public static void main(String[] args) throws JsonProcessingException, IOException{
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = mapper.readTree(new File("country2.json"));
        //path方法获取JsonNode时，当对象不存在时，返回MISSING类型的JsonNode
        JsonNode missingNode = node.path("test");
        if(missingNode.isMissingNode()){
            System.out.println("JsonNodeType : " + missingNode.getNodeType());
        }

        System.out.println("country_id:"+node.path("country_id").asText());

        JsonNode provinces = node.path("provinces");
        for (JsonNode provinceElements : provinces) {
            Iterator provincesFields = provinceElements.fieldNames();
            while (provincesFields.hasNext()) {
                String fieldName = (String) provincesFields.next();
                String province;
                if("name".equals(fieldName)){
                    province = fieldName +":"+ provinceElements.path(fieldName).asText();
                }else{
                    province = fieldName +":"+ provinceElements.path(fieldName).asInt();
                }
                System.out.println(province);
            }
        }
    }

}
程序运行打印结果：
[html] view plain copy
print ?
  1. JsonNodeType : MISSING  
  2. country_id:China  
  3. name:Shanxi  
  4. population:37751200  
  5. name:ZheJiang  
  6. population:55080000  
JsonNodeType : MISSING
country_id:China
name:Shanxi
population:37751200
name:ZheJiang
population:55080000

3.Stream处理Json

(1)stream生成json

[java] view plain copy
print ?
  1. package com.jackson.json.streaming;  
  2.   
  3. import java.io.File;  
  4. import java.io.FileWriter;  
  5. import java.io.Exception;  
  6.   
  7. import com.fasterxml.jackson.core.JsonFactory;  
  8. import com.fasterxml.jackson.core.JsonGenerator;  
  9.   
  10. public class StreamGeneratorJson {  
  11.       
  12.     public static void main(String[] args) throws Exception {  
  13.         JsonFactory factory = new JsonFactory();  
  14.         //从JsonFactory创建一个JsonGenerator生成器的实例  
  15.         JsonGenerator generator = factory.createGenerator(new FileWriter(new File(“country3.json”)));  
  16.           
  17.         generator.writeStartObject();  
  18.         generator.writeFieldName(”country_id”);  
  19.         generator.writeString(”China”);  
  20.         generator.writeFieldName(”provinces”);  
  21.         generator.writeStartArray();  
  22.         generator.writeStartObject();  
  23.         generator.writeStringField(”name”, “Shanxi”);  
  24.         generator.writeNumberField(”population”, 33750000);  
  25.         generator.writeEndObject();  
  26.         generator.writeEndArray();  
  27.         generator.writeEndObject();  
  28.           
  29.         generator.close();  
  30.     }  
  31.   
  32. }  
package com.jackson.json.streaming;

import java.io.File;
import java.io.FileWriter;
import java.io.Exception;

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;

public class StreamGeneratorJson {

    public static void main(String[] args) throws Exception {
        JsonFactory factory = new JsonFactory();
        //从JsonFactory创建一个JsonGenerator生成器的实例
        JsonGenerator generator = factory.createGenerator(new FileWriter(new File("country3.json")));

        generator.writeStartObject();
        generator.writeFieldName("country_id");
        generator.writeString("China");
        generator.writeFieldName("provinces");
        generator.writeStartArray();
        generator.writeStartObject();
        generator.writeStringField("name", "Shanxi");
        generator.writeNumberField("population", 33750000);
        generator.writeEndObject();
        generator.writeEndArray();
        generator.writeEndObject();

        generator.close();
    }

}
程序运行后生成country3.json文件内容：
[html] view plain copy
print ?
  1. {“country_id”:”China”,”provinces”:[{“name”:”Shanxi”,”population”:33750000}]}  
{"country_id":"China","provinces":[{"name":"Shanxi","population":33750000}]}

(2)stream解析json:
现在adgcountry3.json，我们用Streaming API的方式来解析上面的Json,并查找json中population的值。
[java] view plain copy
print ?
  1. package com.jackson.json.streaming;  
  2.   
  3. import java.io.File;  
  4. import java.io.IOException;  
  5.   
  6. import com.fasterxml.jackson.core.JsonFactory;  
  7. import com.fasterxml.jackson.core.JsonParseException;  
  8. import com.fasterxml.jackson.core.JsonParser;  
  9. import com.fasterxml.jackson.core.JsonToken;  
  10.   
  11. /*Jackson API提供了token对每个Json对象，例如，Json开始符号“{”是token指向的第一个解析的对象， 
  12.  key:value键值对是另一个单独的对象。这个API很强大，但也需要编写大量代码。不推荐使用，平时更多的是使用DataBinding和TreeModel来处理json 
  13.  */  
  14. public class StreamParserJson {  
  15.     public static void main(String[] args) throws JsonParseException,  
  16.             IOException {  
  17.         JsonFactory factory = new JsonFactory();  
  18.         // 从JsonFactory创建JsonParser解析器的实例  
  19.         JsonParser parser = factory.createParser(new File(“country3.json”));  
  20.   
  21.         while (!parser.isClosed()) {  
  22.             // 得到一个token,第一次遍历时，token指向json文件中第一个符号”{“  
  23.             JsonToken token = parser.nextToken();  
  24.             if (token == null) {  
  25.                 break;  
  26.             }  
  27.             // 我们只查找 country3.json中的”population”字段的值，能体现解析的流程就可以了  
  28.             // 当key是provinces时，我们进入provinces,查找population  
  29.             if (JsonToken.FIELD_NAME.equals(token)  
  30.                     && ”provinces”.equals(parser.getCurrentName())) {  
  31.                 token = parser.nextToken();  
  32.                 if (!JsonToken.START_ARRAY.equals(token)) {  
  33.                     break;  
  34.                 }  
  35.                 // 此时，token指向的应该是”{“  
  36.                 token = parser.nextToken();  
  37.                 if (!JsonToken.START_OBJECT.equals(token)) {  
  38.                     break;  
  39.                 }  
  40.                 while (true) {  
  41.                     token = parser.nextToken();  
  42.                     if (token == null) {  
  43.                         break;  
  44.                     }  
  45.                     if (JsonToken.FIELD_NAME.equals(token)  
  46.                             && ”population”.equals(parser.getCurrentName())) {  
  47.                         token = parser.nextToken();  
  48.                         System.out.println(parser.getCurrentName() + ” : ”  
  49.                                 + parser.getIntValue());  
  50.                     }  
  51.                 }  
  52.             }  
  53.         }  
  54.     }  
  55.   
  56. }  
package com.jackson.json.streaming;

import java.io.File;
import java.io.IOException;

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;

/*Jackson API提供了token对每个Json对象，例如，Json开始符号“{”是token指向的第一个解析的对象，
 key:value键值对是另一个单独的对象。这个API很强大，但也需要编写大量代码。不推荐使用，平时更多的是使用DataBinding和TreeModel来处理json
 */
public class StreamParserJson {
    public static void main(String[] args) throws JsonParseException,
            IOException {
        JsonFactory factory = new JsonFactory();
        // 从JsonFactory创建JsonParser解析器的实例
        JsonParser parser = factory.createParser(new File("country3.json"));

        while (!parser.isClosed()) {
            // 得到一个token,第一次遍历时，token指向json文件中第一个符号"{"
            JsonToken token = parser.nextToken();
            if (token == null) {
                break;
            }
            // 我们只查找 country3.json中的"population"字段的值，能体现解析的流程就可以了
            // 当key是provinces时，我们进入provinces,查找population
            if (JsonToken.FIELD_NAME.equals(token)
                    && "provinces".equals(parser.getCurrentName())) {
                token = parser.nextToken();
                if (!JsonToken.START_ARRAY.equals(token)) {
                    break;
                }
                // 此时，token指向的应该是"{"
                token = parser.nextToken();
                if (!JsonToken.START_OBJECT.equals(token)) {
                    break;
                }
                while (true) {
                    token = parser.nextToken();
                    if (token == null) {
                        break;
                    }
                    if (JsonToken.FIELD_NAME.equals(token)
                            && "population".equals(parser.getCurrentName())) {
                        token = parser.nextToken();
                        System.out.println(parser.getCurrentName() + " : "
                                + parser.getIntValue());
                    }
                }
            }
        }
    }

}
程序运行后，在控制台打印结果如下：
[html] view plain copy
print ?
  1. population : 33750000  
population : 33750000

总结

上面的例子中，分别用3种方式处理Json，我的体会大致如下：

Stream API方式是开销最低、效率最高，但编写代码复杂度也最高，在生成Json时，需要逐步编写符号和字段拼接json,在解析Json时，需要根据token指向也查找json值，生成和解析json都不是很方便，代码可读性也很低。
Databinding处理Json是最常用的json处理方式，生成json时，创建相关的java对象，并根据json内容结构把java对象组装起来，最后调用writeValue方法即可生成json,
解析时，就更简单了，直接把json映射到相关的java对象，然后就可以遍历java对象来获取值了。
TreeModel处理Json，是以树型结构来生成和解析json，生成json时，根据json内容结构，我们创建不同类型的节点对象，组装这些节点生成json。解析json时，它不需要绑定json到java bean，根据json结构，使用path或get方法轻松查找内容。

学习参考： http://www.cnblogs.com/lee0oo0/articles/2652528.html

你可能感兴趣的:(json,token,json)

  • docker igotyback eureka云原生
    Docker容器的文件系统是隔离的，但是可以通过挂载卷（Volumes）或绑定挂载（BindMounts）将宿主机的文件系统目录映射到容器内部。要查看Docker容器的映射路径，可以使用以下方法：查看容器配置：使用dockerinspect命令可以查看容器的详细配置信息，包括挂载的卷。例如：bashdockerinspect在输出的JSON格式中，查找"Mounts"部分，这里会列出所有的挂载信息
  • 在Ubuntu中编译含有JSON的文件出现报错 芝麻糊76 Linuxkill_buglinuxubuntujson
    在ubuntu中进行JSON相关学习的时候，我发现了一些小问题，决定与大家进行分享，减少踩坑时候出现不必要的时间耗费截取部分含有JSON部分的代码进行展示char*str="{\"title\":\"JSONExample\",\"author\":{\"name\":\"JohnDoe\",\"age\":35,\"isVerified\":true},\"tags\":[\"json\",\"
  • Xinference如何注册自定义模型 玩人工智能的辣条哥 人工智能AI大模型Xinference
    环境：Xinference问题描述：Xinference如何注册自定义模型解决方案：1.写个model_config.json，内容如下{"version":1,"context_length":2048,"model_name":"custom-llama-3","model_lang":["en","ch"],"model_ability":["generate","chat"],"model
  • 更改npm镜像源为淘宝镜像 骆小骆 基于node.js
    npm常用指令后缀*最近复习了一下node.js整理了一下跟node.js相关的指令后缀*--save、-S参数意思是把模块的版本信息保存到dependencies（生产环境依赖）中，即你的package.json文件的dependencies字段中；–--save-dev、-D参数意思是把模块版本信息保存到devDependencies（开发环境依赖）中，即你的package.json文件的de
  • COCO 格式的数据集转化为 YOLO 格式的数据集 QYQY77 YOLOpython
    """--json_path输入的json文件路径--save_path保存的文件夹名字，默认为当前目录下的labels。"""importosimportjsonfromtqdmimporttqdmimportargparseparser=argparse.ArgumentParser()parser.add_argument('--json_path',default='./instances
  • 02-Cesium聚合分析EntityCluster完整代码 fxshy htmlcssjavascript
    1.完整代码Document-->-->Cesium.Ion.defaultAccessToken='eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJhZjZkZDAwZC1mNTFhLTRhOTEtOGExNi00MzRhNGIzMDdlNDQiLCJpZCI6MTA1MTUzLCJpYXQiOjE2NjA4MDg0Njd9.qajeJtc4-kp
  • 03-Cesium自定义着色器完整代码以及注释 fxshy 着色器javascript
    1.效果展示2.完整代码自定义着色器完整代码#map{position:absolute;width:100%;height:100%;top:0;left:0;right:0;bottom:0;}Cesium.Ion.defaultAccessToken='eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJhZjZkZDAwZC1mNTFhLTRhO
  • golang获取用户输入的几种方式 余生逆风飞翔 golang开发语言后端
    一、定义结构体typeUserInfostruct{Namestring`json:"name"`Ageint`json:"age"`Addstring`json:"add"`}typeReturnDatastruct{Messagestring`json:"message"`Statusstring`json:"status"`DataUserInfo`json:"data"`}二、get请求的
  • spring mvc @RequestBody String类型参数 zoyation spring-mvcspringmvc
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
  • 接口测试如何设计测试用例 李蕴Ronnie
    接口测试用例设计方式针对每个必填参数，都设计一条参数为空的测试用例必填参数不存在传的参数值在数据库中不存在添加数据接口，传入已有的数据重复添加编辑数据接口，各个字段分别编辑，合并编辑参数数据类型限制，针对每个参数设计一条参数值类型不符合的逆向用例参数自身取值范围，针对所有参数，设计一条每个参数值在取值范围内最大值的正向测试用例是否满足前提条件（token、headers），几个前提条件几条用例针对
  • UI 自动化的页面对象管理神器 PO-Manager TesterHome
    原文由alex发表于TesterHome社区网站，点击原文链接可于作者直接交流。做UI自动化的同学都知道，UI自动化一个难点就是页面元素的变化，让自动化维护成为一个痛点。在此，为了减轻这个痛点，我在基于Page-Object模式的基础上开发了页面对象维护的工具。该工具为vscode的一个插件，可以通过vscode插件市场搜索PO-Manager来下载安装本文中的页面对象库文件基于json.一个元素
  • 白嫖Gitee实现远程公告功能和小型文件上传下载 xu-jssy Python自动化脚本gitee
    备注：20240527更新：新增私人令牌下载模式一、准备工作1、打开Gitee网站：Gitee.comhttps://gitee.com/2、获取access_token，用于身份验证登录后点击右上角头像，在下拉菜单中进入个人主页点击左边的个人设置点击左边菜单中的安全设置->私人令牌点击右上角生成新令牌根据提示填写信息，点击提交在弹出的页面复制令牌，注意备份保存3、创建一个仓库用来存放文件可以把远
  • python的request请求401_Python模拟HTTPS请求返回HTTP 401 unauthorized错误 weixin_39599372
    Python模拟HTTPS请求返回HTTP401unauthorized错误开始是使用的httplib模块，代码如下：header={"Content-type":"application/json","Accept":"*/*"}params={‘source‘:‘en‘,‘target‘:‘es‘,‘text‘:match.group(1)}data=urllib.urlencode(para
  • 上传文件到钉盘流程详解 jspyth 开发场景案例分析开发语言java后端
    文章目录前言准备工作实现过程Maven依赖封装一个工具类获取文件上传信息unionId获取钉盘目录spaceId创建上传到钉盘前言  本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。准备工作1、在钉钉开发者后台创建一个钉钉企业内部应用；2、创建并保存好应用的appKey和appSecret，后面用于获取调用API的请求token；3、应用中配置好所需权限：企业存储文件上传
  • uniapp实现IM即时通讯仿微信聊天功能 即构开发者
    本文介绍如何基于UNIAPP使用即时通讯SDKZIMSDK快速实现基本的消息收发功能。1uniappim即时通讯功能方案介绍即时通讯SDKZIMSDK提供了如下接入方案：image.png在此方案中，您需要通过您自己的业务系统实现以下业务逻辑：搭建客户端的用户管理逻辑，并下发用户ID用于客户端登录。鉴权Token，建议由您的业务后台自行实现，保证鉴权数据安全。uni-appSDK是一个基于原生iO
  • shp转geojson、kml转geojson 是乔木 地图javascript前端
    导入效果：用到的npm库pnpmaddshpjs//或者npmishpjs5.0.2pnpmaddjszip//或者npmijszip版本3.10.1pnpmadd@tmcw/togeojson//或者npmi@tmcw/togeojson版本5.8.1创建方法用来区分导入的文件1.这里只是做了一个文件的区分其中的kmlToGeoJson和readShp、dealZip具体方法会写明//处理文件e
  • shp文件解析转换为geojson/wkt格式字符串 自律_平庸 前端数据库大数据
    此函数用于处理上传的ZIP文件并将其转换为GeoJSON格式的字符串。具体步骤如下：验证上传文件是否为ZIP格式。创建临时目录以解压ZIP文件。解压缩ZIP文件至临时目录。查找解压后的.shp文件。如果缺少.shx或.dbf辅助文件，则创建空文件。读取Shapefile数据。将特征集合转换为GeoJSON格式。清理临时文件和资源。函数返回转换后的GeoJSON字符串。publicStringshp
  • php 实现JWT 每天瞎忙的农民工 phpphp
    在PHP中，JSONWebToken(JWT)是一种开放标准(RFC7519)用于在各方之间作为JSON对象安全地传输信息。JWT通常用于身份验证系统，如OAuth2或基于令牌的身份验证。以下是一个基本的PHP实现JWT生成和验证的代码示例。JWT的组成部分JWT包含三个部分：Header（头部）：说明算法和令牌类型。Payload（有效载荷）：包含声明（如用户数据、过期时间等）。Signatur
  • 终于搞懂TS中的泛型啦! | typescript 入门指南 04 程序员王天 TypeScript实践指南前端javascripttypescript
    大家好，我是王天~今天分享的是《ts入门指南》系列中第四篇，主要讲解ts中的泛型应用泛型在ts中是比较重要的概念，我花挺长时间才搞明白，整理输出这篇文章，希望能帮助到大家~《ts入门指南》系列，点击下方蓝色字体即可访问TsvsJs谁适合前端开发？|TypeScript入门指南01详解tsconfig.json配置文件|TypeScript入门指南02必学！TypeScript语法类型基础|Type
  • 深度解析：如何使用输出解析器将大型语言模型（LLM）的响应解析为结构化JSON格式 m0_57781768 语言模型json人工智能
    深度解析：如何使用输出解析器将大型语言模型（LLM）的响应解析为结构化JSON格式在现代自然语言处理（NLP）的应用中，大型语言模型（LLM）已经成为了重要的工具。这些模型能够生成丰富的自然语言文本，适用于各种应用场景。然而，在某些应用中，开发者不仅仅需要生成文本，还需要将这些生成的文本转换为结构化的数据格式，例如JSON。这种结构化的数据格式在数据传输、存储以及进一步处理时具有显著优势。本文将深
  • 深入探讨：如何在Python中通过LangChain技术精准追踪大型语言模型（LLM）的Token使用情况 m0_57781768 pythonlangchain语言模型
    深入探讨：如何在Python中通过LangChain技术精准追踪大型语言模型（LLM）的Token使用情况在现代的人工智能开发中，大型语言模型（LLM）已经成为了不可或缺的工具，无论是用于自然语言处理、对话生成，还是其他复杂的文本生成任务。然而，随着这些模型的广泛应用，开发者面临的一个重要挑战是如何有效地追踪和管理Token的使用情况，特别是在生产环境中，Token的使用直接影响着API调用的成本
  • GEE 将本地 GeoJSON 文件上传到谷歌资产 ThsPool GISjavaandroid前端envigis
    在地理信息系统（GIS）领域，GoogleEarthEngine（GEE）是一个强大的平台，它允许用户处理和分析大规模地理空间数据。本文将介绍如何使用Python脚本批量上传本地GeoJSON文件到GEE资产存储，这对于需要将地理数据上传到GEE进行进一步分析的用户来说非常有用。应用场景数据集成：将本地GeoJSON数据集成到GEE中，以便进行更复杂的地理空间分析。数据共享：与团队成员共享GeoJ
  • 深度学习-13-小语言模型之SmolLM的使用 皮皮冰燃 深度学习深度学习
    文章附录1SmolLM概述1.1SmolLM简介1.2下载模型2运行2.1在CPU/GPU/多GPU上运行模型2.2使用torch.bfloat162.3通过位和字节的量化版本3应用示例4问题及解决4.1attention_mask和pad_token_id报错4.2max_new_tokens=205参考附录1SmolLM概述1.1SmolLM简介SmolLM是一系列尖端小型语言模型，提供三种规
  • 数据格式：什么是JSON和XML isNotNullX jsonxml
    JSON和XML都是数据交换的一种格式，用于在不同的系统和应用程序之间传输和存储数据。本文将解释JSON和XML的基础内容，并探讨两者的不同。一·什么是JSON？1.JSON（JavaScriptObjectNotation）即JavaScript对象标记法：-JSON是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。-JSON基于JavaScript的一个子集，但JSON是
  • JavaScript 基础 - 第15天 +码农快讯+ JavaScript学习笔记javascript前端开发语言
    文章目录JavaScript基础-第15天深浅拷贝浅拷贝深拷贝通过JSON序列化实现js库lodash实现深拷贝通过递归实现深拷贝异常处理throwtry...catchdebugger处理this改变thiscallapplybindthis指向性能优化防抖（debounce）手写防抖函数节流（throttle）手写节流函数JavaScript基础-第15天深浅拷贝浅拷贝浅拷贝：把对象拷贝给一个
  • PostgreSQL | 生成UUID 报错：HINT: No function matches the given name and argument types 慌途L PostgreSQLpostgresqluuiduuid_generategen_random_uuid
    在PG数据库上新建表结构：CREATETABLE"public"."t_test"("guid"uuidNOTNULLDEFAULTuuid_generate_v4(),"data"jsonb,"create_time"timestamptz(6)DEFAULTnow(),CONSTRAINT"test_pkey"PRIMARYKEY("guid"));报错：ERROR:functionuuid_
  • 网上商城项目总结 续 猫只i javaweb电子商城结构
    前台1.用户登录注册邮箱验证校验用户名是否存在验证码自动登录2.导航条自定义标签库采用异步读取数据（使用gson将集合转换json数据）Redis服务器3.首页热门商品查询展示4.分类列表分页查询5.商品详情用cookie实现浏览记录6.购物车实现商品添加到购物车商品的查询，添加，修改，删除清空购物车7.提交订单添加订单（订单详情）确认订单（易宝支付）8.我的订单9.Fliter定义权限拦截（提交
  • 使用WAF防御网络上的隐蔽威胁之反序列化攻击 baiolkdnhjaio 网络安全
    什么是反序列化反序列化是将数据结构或对象状态从某种格式转换回对象的过程。这种格式通常是二进制流或者字符串（如JSON、XML），它是对象序列化（即对象转换为可存储或可传输格式）的逆过程。反序列化的安全风险反序列化的安全风险主要来自于处理不受信任的数据源时的不当反序列化。如果应用程序反序列化了恶意构造的数据，攻击者可能能够执行代码、访问敏感数据、进行拒绝服务攻击等。这是因为反序列化过程中可能会自动触
  • Spring Boot项目自动生成OpenAPI3.0规范的接口描述文档yaml [email protected] springbootjavaopenapi
    首先在pom.xml文件中添加springdoc-openapi的依赖：org.springdocspringdoc-openapi-core1.1.45启动SpringBoot程序，通过项目的ip和端口/v3/api-docs访问自动生成的OpenAPI3.0文档(JSON)/v3/api-docs.yaml下载yaml格式的文件如果想要自定义路径，可在application.propertie
  • Protobuf3语言指南 R-QWERT 数据结构化与序列化protobuf
    定义一个消息类型指定字段类型分配标识号指定字段规则添加更多消息类型添加注释保留标识符（Reserved）从.proto文件生成了什么？标量数值类型默认值枚举使用其他消息类型导入定义使用proto2消息类型嵌套类型更新一个消息类型AnyOneof使用OneofOneof特性向后兼容性问题映射（Maps）向后兼容性问题包（Packages）包及名称的解析定义服务JSON映射选项自定义选项生成你的类英文
  • java类加载顺序 3213213333332132 java
    package com.demo; /** * @Description 类加载顺序 * @author FuJianyong * 2015-2-6上午11:21:37 */ public class ClassLoaderSequence { String s1 = "成员属性"; static String s2 = "
  • Hibernate与mybitas的比较 BlueSkator sqlHibernate框架ibatisorm
    第一章     Hibernate与MyBatis Hibernate 是当前最流行的O/R mapping框架，它出身于sf.net，现在已经成为Jboss的一部分。 Mybatis 是另外一种优秀的O/R mapping框架。目前属于apache的一个子项目。 MyBatis 参考资料官网：http:
  • php多维数组排序以及实际工作中的应用 dcj3sjt126com PHPusortuasort
    自定义排序函数返回false或负数意味着第一个参数应该排在第二个参数的前面, 正数或true反之, 0相等usort不保存键名uasort 键名会保存下来uksort 排序是对键名进行的 <!doctype html> <html lang="en"> <head> <meta charset="utf-8&q
  • DOM改变字体大小 周华华 前端
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
  • c3p0的配置 g21121 c3p0
    c3p0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。c3p0的下载地址是：http://sourceforge.net/projects/c3p0/这里可以下载到c3p0最新版本。 以在spring中配置dataSource为例： <!-- spring加载资源文件 --> <bean name="prope
  • Java获取工程路径的几种方法 510888780 java
    第一种： File f = new File(this.getClass().getResource("/").getPath()); System.out.println(f); 结果: C:\Documents%20and%20Settings\Administrator\workspace\projectName\bin 获取当前类的所在工程路径; 如果不加“
  • 在类Unix系统下实现SSH免密码登录服务器 Harry642 免密ssh
    1.客户机     (1)执行ssh-keygen -t rsa -C "[email protected]"生成公钥，xxx为自定义大email地址     (2)执行scp ~/.ssh/id_rsa.pub root@xxxxxxxxx:/tmp将公钥拷贝到服务器上，xxx为服务器地址     (3)执行cat
  • Java新手入门的30个基本概念一 aijuans javajava 入门新手
    在我们学习Java的过程中,掌握其中的基本概念对我们的学习无论是J2SE,J2EE,J2ME都是很重要的,J2SE是Java的基础,所以有必要对其中的基本概念做以归纳,以便大家在以后的学习过程中更好的理解java的精髓,在此我总结了30条基本的概念。　　Java概述:　　目前Java主要应用于中间件的开发(middleware)---处理客户机于服务器之间的通信技术,早期的实践证明,Java不适合
  • Memcached for windows 简单介绍 antlove javaWebwindowscachememcached
    1. 安装memcached server a. 下载memcached-1.2.6-win32-bin.zip b. 解压缩，dos 窗口切换到 memcached.exe所在目录，运行memcached.exe -d install c.启动memcached Server,直接在dos窗口键入 net start "memcached Server&quo
  • 数据库对象的视图和索引 百合不是茶 索引oeacle数据库视图
      视图     视图是从一个表或视图导出的表，也可以是从多个表或视图导出的表。视图是一个虚表，数据库不对视图所对应的数据进行实际存储，只存储视图的定义，对视图的数据进行操作时,只能将字段定义为视图,不能将具体的数据定义为视图       为什么oracle需要视图;    &
  • Mockito(一) --入门篇 bijian1013 持续集成mockito单元测试
            Mockito是一个针对Java的mocking框架，它与EasyMock和jMock很相似，但是通过在执行后校验什么已经被调用，它消除了对期望 行为（expectations）的需要。其它的mocking库需要你在执行前记录期望行为（expectations），而这导致了丑陋的初始化代码。  &nb
  • 精通Oracle10编程SQL(5)SQL函数 bijian1013 oracle数据库plsql
    /* * SQL函数 */ --数字函数 --ABS(n):返回数字n的绝对值 declare v_abs number(6,2); begin v_abs:=abs(&no); dbms_output.put_line('绝对值：'||v_abs); end; --ACOS(n):返回数字n的反余弦值，输入值的范围是-1~1，输出值的单位为弧度
  • 【Log4j一】Log4j总体介绍 bit1129 log4j
    Log4j组件：Logger、Appender、Layout   Log4j核心包含三个组件：logger、appender和layout。这三个组件协作提供日志功能： 日志的输出目标 日志的输出格式 日志的输出级别(是否抑制日志的输出)  logger继承特性 A logger is said to be an ancestor of anothe
  • Java IO笔记 白糖_ java
    public static void main(String[] args) throws IOException { //输入流 InputStream in = Test.class.getResourceAsStream("/test"); InputStreamReader isr = new InputStreamReader(in); Bu
  • Docker 监控 ronin47 docker监控
             目前项目内部署了docker，于是涉及到关于监控的事情，参考一些经典实例以及一些自己的想法，总结一下思路。 1、关于监控的内容 监控宿主机本身 监控宿主机本身还是比较简单的，同其他服务器监控类似，对cpu、network、io、disk等做通用的检查，这里不再细说。 额外的，因为是docker的
  • java-顺时针打印图形 bylijinnan java
    一个画图程序 要求打印出： 1.int i=5; 2.1 2 3 4 5 3.16 17 18 19 6 4.15 24 25 20 7 5.14 23 22 21 8 6.13 12 11 10 9 7. 8.int i=6 9.1 2 3 4 5 6 10.20 21 22 23 24 7 11.19
  • 关于iReport汉化版强制使用英文的配置方法 Kai_Ge iReport汉化英文版
    对于那些具有强迫症的工程师来说，软件汉化固然好用，但是汉化不完整却极为头疼，本方法针对iReport汉化不完整的情况，强制使用英文版，方法如下： 在 iReport 安装路径下的 etc/ireport.conf 里增加红色部分启动参数，即可变为英文版。   # ${HOME} will be replaced by user home directory accordin
  • [并行计算]论宇宙的可计算性 comsci 并行计算
          现在我们知道,一个涡旋系统具有并行计算能力.按照自然运动理论,这个系统也同时具有存储能力,同时具备计算和存储能力的系统,在某种条件下一般都会产生意识......       那么,这种概念让我们推论出一个结论     &nb
  • 用OpenGL实现无限循环的coverflow dai_lm androidcoverflow
    网上找了很久，都是用Gallery实现的，效果不是很满意，结果发现这个用OpenGL实现的，稍微修改了一下源码，实现了无限循环功能 源码地址： https://github.com/jackfengji/glcoverflow public class CoverFlowOpenGL extends GLSurfaceView implements GLSurfaceV
  • JAVA数据计算的几个解决方案1 datamachine javaHibernate计算
    老大丢过来的软件跑了10天，摸到点门道，正好跟以前攒的私房有关联，整理存档。 -----------------------------华丽的分割线-------------------------------------     数据计算层是指介于数据存储和应用程序之间，负责计算数据存储层的数据，并将计算结果返回应用程序的层次。J  &nbs
  • 简单的用户授权系统,利用给user表添加一个字段标识管理员的方式 dcj3sjt126com yii
    怎么创建一个简单的(非 RBAC)用户授权系统 通过查看论坛，我发现这是一个常见的问题，所以我决定写这篇文章。 本文只包括授权系统.假设你已经知道怎么创建身份验证系统(登录)。 数据库 首先在 user 表创建一个新的字段(integer 类型),字段名 'accessLevel',它定义了用户的访问权限 扩展 CWebUser 类 在配置文件(一般为 protecte
  • 未选之路 dcj3sjt126com 诗
    作者:罗伯特*费罗斯特   黄色的树林里分出两条路, 可惜我不能同时去涉足, 我在那路口久久伫立, 我向着一条路极目望去, 直到它消失在丛林深处.   但我却选了另外一条路, 它荒草萋萋,十分幽寂; 显得更诱人,更美丽, 虽然在这两条小路上, 都很少留下旅人的足迹.   那天清晨落叶满地, 两条路都未见脚印痕迹. 呵,留下一条路等改日再
  • Java处理15位身份证变18位 蕃薯耀 18位身份证变15位15位身份证变18位身份证转换
      15位身份证变18位，18位身份证变15位 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 201
  • SpringMVC4零配置--应用上下文配置【AppConfig】 hanqunfeng springmvc4
    从spring3.0开始，Spring将JavaConfig整合到核心模块，普通的POJO只需要标注@Configuration注解，就可以成为spring配置类，并通过在方法上标注@Bean注解的方式注入bean。   Xml配置和Java类配置对比如下： applicationContext-AppConfig.xml   <!-- 激活自动代理功能 参看：
  • Android中webview跟JAVASCRIPT中的交互 jackyrong JavaScripthtmlandroid脚本
      在android的应用程序中,可以直接调用webview中的javascript代码,而webview中的javascript代码,也可以去调用ANDROID应用程序(也就是JAVA部分的代码).下面举例说明之: 1 JAVASCRIPT脚本调用android程序    要在webview中,调用addJavascriptInterface(OBJ,int
  • 8个最佳Web开发资源推荐 lampcy 编程Web程序员
    Web开发对程序员来说是一项较为复杂的工作，程序员需要快速地满足用户需求。如今很多的在线资源可以给程序员提供帮助，比如指导手册、在线课程和一些参考资料，而且这些资源基本都是免费和适合初学者的。无论你是需要选择一门新的编程语言，或是了解最新的标准，还是需要从其他地方找到一些灵感，我们这里为你整理了一些很好的Web开发资源，帮助你更成功地进行Web开发。 这里列出10个最佳Web开发资源，它们都是受
  • 架构师之面试------jdk的hashMap实现 nannan408 HashMap
    1.前言。   如题。 2.详述。   (1)hashMap算法就是数组链表。数组存放的元素是键值对。jdk通过移位算法（其实也就是简单的加乘算法），如下代码来生成数组下标(生成后indexFor一下就成下标了）。 static int hash(int h) { h ^= (h >>> 20) ^ (h >>>
  • html禁止清除input文本输入缓存 Rainbow702 html缓存input输入框change
    多数浏览器默认会缓存input的值，只有使用ctl+F5强制刷新的才可以清除缓存记录。 如果不想让浏览器缓存input的值，有2种方法： 方法一： 在不想使用缓存的input中添加 autocomplete="off";  <input type="text" autocomplete="off" n
  • POJO和JavaBean的区别和联系 tjmljw POJOjava beans
    POJO 和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Pure Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比 POJO复杂很多， Java Bean 是可复用的组件，对 Java Bean 并没有严格的规
  • java中单例的五种写法 liuxiaoling java单例
    /** * 单例模式的五种写法： * 1、懒汉 * 2、恶汉 * 3、静态内部类 * 4、枚举 * 5、双重校验锁 */ /** * 五、 双重校验锁，在当前的内存模型中无效 */ class LockSingleton { private volatile static LockSingleton singleton; pri
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他