概述

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
  1. package com.jackson.json.databinding;
  2.  
  3. public class Province {
  4. public String name;
  5. public int population;
  6. public String[] city;
  7. }

Country.java

  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<String> nation = new ArrayList<String>();
  15. private String[] lakes;
  16. private List<Province> provinces = new ArrayList<Province>();
  17. private Map<String, Integer> traffic = new HashMap<String, Integer>();
  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<String> getNation() {
  44. return nation;
  45. }
  46.  
  47. public void setNation(List<String> 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<String, Integer> getTraffic() {
  64. return traffic;
  65. }
  66.  
  67. public void setTraffic(Map<String, Integer> 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<Province> getProvinces() {
  76. return provinces;
  77. }
  78.  
  79. public void setProvinces(List<Province> 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. }

JavaBeanSerializeToJson.java

  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<String> nation = new ArrayList<String>();
  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<Province> provinces = new ArrayList<Province>();
  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. }

程序运行后生成country.json,内容如下:

  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. }

(2)Json字符串反序列化为java对象:

  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<Province> provinces = country.getProvinces();
  36. for (Province province : provinces) {
  37. System.out.println("province:"+province.name + "\n" + "population:"+province.population);
  38. }
  39. }
  40. }

程序运行结果:

  1. country_id:China
  2. birthDate:1949-10-01
  3. province:Shanxi
  4. population:37751200
  5. province:ZheJiang
  6. population:55080000

2.Tree Model处理Json

(1)tree model生成json:

  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. }

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

  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}}

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

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

  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<String> 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<String> 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. }

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

  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

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

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

 
  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<String> 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. }

程序运行打印结果:

  1. JsonNodeType : MISSING
  2. country_id:China
  3. name:Shanxi
  4. population:37751200
  5. name:ZheJiang
  6. population:55080000

3.Stream处理Json

(1)stream生成json
 
  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. }

程序运行后生成country3.json文件内容:

  1. {"country_id":"China","provinces":[{"name":"Shanxi","population":33750000}]}

(2)stream解析json:
现在adgcountry3.json,我们用Streaming API的方式来解析上面的Json,并查找json中population的值。

 
  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. }

程序运行后,在控制台打印结果如下:

  1. 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://blog.csdn.net/java_huashan/article/details/46375857
 
学习参考:http://www.cnblogs.com/lee0oo0/articles/2652528.html
 
 
 
 
 

JackSon学习笔记(一)的更多相关文章

  1. Jackson学习笔记(详细)

    学习地址:http://tutorials.jenkov.com/java-json/index.html github地址:https://github.com/FasterXML/jackson ...

  2. Jackson学习笔记-对象序列化

    一.用ObjectMapper.readValue(jsonString, Student.class) , ObjectMapper.writeValueAsString(student) impo ...

  3. jackson 学习笔记

    Jackson以优异的解析性能赢得了好评,今天就看看Jackson的一些简单的用法. Jackson使用之前先要下载,这里一共有三个jar包,想要获得完美的Jackson体验,这三个jar包都不可或缺 ...

  4. Jackson学习笔记(三)<转>

    概述 使用jackson annotations简化和增强的json解析与生成. Jackson-2.x通用annotations列表:https://github.com/FasterXML/jac ...

  5. Jackson学习笔记

    老版本的Jackson使用的包名为org.codehaus.jackson,而新版本使用的是com.fasterxml.jackson. Jackson主要包含了3个模块: jackson-core ...

  6. spring学习笔记---Jackson的使用和定制

      前言: JAVA总是把实体对象(数据库/Nosql等)转换为POJO对象再处理, 虽然有各类框架予以强力支持. 但实体对象和POJO, 由于"饮食习惯", "民族特色 ...

  7. springmvc学习笔记--REST API的异常处理

    前言: 最近使用springmvc写了不少rest api, 觉得真是一个好框架. 之前描述的几篇关于rest api的文章, 其实还是不够完善. 比如当遇到参数缺失, 类型不匹配的情况时, 直接抛出 ...

  8. springmvc学习笔记---面向移动端支持REST API

    前言: springmvc对注解的支持非常灵活和飘逸, 也得web编程少了以往很大一坨配置项. 另一方面移动互联网的到来, 使得REST API变得流行, 甚至成为主流. 因此我们来关注下spring ...

  9. <老友记>学习笔记

    这是六个人的故事,从不服输而又有强烈控制欲的monica,未经世事的千金大小姐rachel,正直又专情的ross,幽默风趣的chandle,古怪迷人的phoebe,花心天真的joey——六个好友之间的 ...

随机推荐

  1. 修改sqlserver2008数据库的排序规则 (转)

    修改sqlserver2008数据库的排序规则 (转)      修改SQL server 2008服务器排序规则 SQL Server 2008安装好后,发现服务器排序规则不对,又不想重装SQL S ...

  2. VMware虚拟机中CentOS 7的硬盘空间扩容

    查看centos7系统挂载点信息 扩展VMWare-centos7硬盘空间 对新增加的硬盘进行分区.格式化 添加新LVM到已有的LVM组,实现扩容 1.查看centos7系统挂载点信息 df -h查看 ...

  3. February 1st, 2018 Week 5th Thursday

    The world is a fine place, and worth fighting for. 这世界是个好地方,值得为之奋斗. The world is beautiful, there ar ...

  4. Android 用webService产生java.lang.ClassCastException: org.ksoap2.serialization.SoapPrimitive错误的解决(转)

    在做android  Webservice开发的时候一般情况下大家接受webservice服务器返回值的时候都是使用 SoapObject soapObject = (SoapObject) enve ...

  5. Mac OS 安装Fiddler

    Mono安装 首先,Mac下需要使用.Net编译后的程序,需要用到跨平台的方案Mono(现阶段微软已推出跨平台的方案.Net Core,不过暂时只支持控制台程序).安装程序可以从http://www. ...

  6. luogu P2000 拯救世界

    嘟嘟嘟 题目有点坑,要你求的多少大阵指的是召唤kkk的大阵数 * lzn的大阵数,不是相加. 看到这个限制条件,显然要用生成函数推一推. 比如第一个条件"金神石的块数必须是6的倍数" ...

  7. LabelImg 图像图像标注工具

    https://github.com/tzutalin/labelImg windos版本请不要把存放在中文目录下,否则打不开.

  8. hadoop学习笔记壹 --环境搭建及配置文件的修改

    Hadoop生态和其他生态最大的不同之一就是“单一平台多种应用”的理念了. hadoop能解决是什么问题: 1.HDFS :海量数据存储 MapReduce: 海量数据分析   YARN :资源管理调 ...

  9. Qt+QGIS二次开发:自定义类实现查询矢量数据的属性字段值(图查属性)

    在GIS领域,有两种重要的查询操作,图查属性和属性查图. 本文主要介绍如何在QGIS中通过从QgsMapToolIdentify中派生自定义类实现查询矢量数据的属性字段值(图查属性). 重点参考资料: ...

  10. 浅谈UI自动化测试

    最近一直在学习python,正好部门技术结构调整,就开始了点工向UI自动化测试的转变,我要说瞌睡来了就掉枕头么? 不过还好,可以将python的学习成果在自动化测试中实践... 1.about自动化测 ...