JSON lib

json 的使用 Java对象转json

和自甴很熟 — Tue, 12 Jan 2021 23:17:00 +0000

json 的使用 Java对象转json 和自甴很熟 2021-01-13 07:17:00

1、 jsonlib:个人感觉最麻烦的一个需要导入的包也多，代码也相对多一些。

2、Gson：google的

3、FastJson：阿里巴巴的，个人觉得这个比较好，而且据说这个也是性能最好一个。

下面就贴出三种写法的代码，读者可以任选其一去使用。关于demo里面所使用的jar包，可以自行去下载，也可以加我QQ我给你：1140459171

Jsonlib：package json;


 
import java.util.ArrayList; import java.util.List; import net.sf.json.JSONArray; import user.User; public class Jsonlib { public static void main(String[] args) { User user1 = new User(); user1.setUsername("111"); user1.setPassword("111"); User user2 = new User(); user2.setUsername("222"); user2.setPassword("222"); List<User> lists = new ArrayList<User>(); lists.add(user1); lists.add(user2); JSONArray fromObject1 = JSONArray.fromObject(user1); JSONArray fromObject2 = JSONArray.fromObject(lists); String str1 = fromObject1.toString(); String str2 = fromObject2.toString(); System.out.println(str1); //打印结果 //[{"password":"111","username":"111"}] System.out.println(str2); //打印结果 //[{"password":"111","username":"111"},{"password":"222","username":"222"}] } }

jar：

Gson：

package json;
import java.util.ArrayList; import java.util.List; import com.google.gson.Gson; import user.User; public class Gson_a { public static void main(String[] args) { User user1 = new User(); user1.setUsername("111"); user1.setPassword("111"); User user2 = new User(); user2.setUsername("222"); user2.setPassword("222"); List<User> lists = new ArrayList<User>(); lists.add(user1); lists.add(user2); Gson gson = new Gson(); String json1 = gson.toJson(user1); System.out.println(json1); //打印结果 //{"username":"111","password":"111"} String json2 = gson.toJson(lists); System.out.println(json2); //打印结果 //[{"username":"111","password":"111"},{"username":"222","password":"222"}] } }

jar：

FastJson：

package json;

 

import java.util.ArrayList; import java.util.List; import com.alibaba.fastjson.JSON; import user.User; public class FastJson { public static void main(String[] args) { User user1 = new User(); user1.setUsername("111"); user1.setPassword("111"); //1、单个对象转换成json String jsonString = JSON.toJSONString(user1); System.out.println(jsonString); //打印结果 //{"password":"111","username":"111"} User user2 = new User(); user2.setUsername("222"); user2.setPassword("222"); List<User> lists = new ArrayList<User>(); lists.add(user1); lists.add(user2); String jsonString2 = JSON.toJSONString(lists); System.out.println(jsonString2); //打印结果 //[{"password":"111","username":"111"},{"password":"222","username":"222"}] } }

来源：oschina

链接：https://my.oschina.net/u/4329662/blog/3639765

标签

fastjson

java

gson

JSON lib

请不要在 JDK 7+ 中使用这个 JSON 包了！

白昼怎懂夜的黑 — Mon, 10 Aug 2020 13:07:43 +0000

请不要在 JDK 7+ 中使用这个 JSON 包了！白昼怎懂夜的黑 2020-08-10 21:07:43

来源：大魔王mAysWINd www.cnblogs.com/mayswind/p/9222245.html

Json-lib 介绍

Json-lib 是以前 Java 常用的一个 Json 库，最后的版本是 2.4，分别提供了 JDK 1.3 和 1.5 的支持，最后更新时间是 2010年12月14日。

虽然已经很多年不维护了，但在搜索引擎上搜索 "Java Json**"**等相关的关键词发现好像一直还有人在介绍和使用这个库。

项目官网是：

http://json-lib.sourceforge.net/

一句话结论

Json-lib 在通过字符串解析每一个 Json 对象时，会对当前解析位置到字符串末尾进行 substring 操作。

由于 JDK7 及以上的 substring 会完整拷贝截取后的内容，所以当遇到较大的 Json 数据并且含有较多对象时，会进行大量的字符数组复制操作，导致了大量的 CPU 和内存消耗，甚至严重的 Full GC 问题。

问题分析

某天发现线上生产服务器有不少 Full GC 问题，排查发现产生 Full GC 时某个老接口量会上涨，但这个接口除了解析 Json外就是将解析后的数据存储到了缓存中。

遂怀疑跟接口请求参数大小有关，打日志发现确实有比一般请求大得多的 Json 数据，但也只有 1MB 左右。为了简化这个问题，编写如下的性能测试代码。

package net.mayswind;

import net.sf.json.JSONObject;
import org.apache.commons.io.FileUtils;

import java.io.File;

public class JsonLibBenchmark {
    public static void main(String[] args) throws Exception {
        String data = FileUtils.readFileToString(new File("Z:\\data.json"));
        benchmark(data, 5);
    }

    private static void benchmark(String data, int count) {
        long startTime = System.currentTimeMillis();

        for (int i = 0; i < count; i++) {
            JSONObject root = JSONObject.fromObject(data);
        }

        long elapsedTime = System.currentTimeMillis() - startTime;
        System.out.println(String.format("count=%d, elapsed time=%d ms, avg cost=%f ms", count, elapsedTime, (double) elapsedTime / count));
    }
}

上述代码执行后平均每次解析需要 7秒左右才能完成，如下图所示。

测试用的 Json 文件，“...” 处省略了 34,018 个相同内容，整个 Json 数据中包含了 3万多个 Json 对象，实际测试的数据如下图所示。

{
    "data":
    [
        {
            "foo": 0123456789,
            "bar": 1234567890
        },
        {
            "foo": 0123456789,
            "bar": 1234567890
        },
        ...
    ]
}

使用 Java Mission Control 记录执行的情况，如下图所示，可以看到分配了大量 char[] 数组。

翻看相关源码，其中 JSONObject._fromJSONTokener 方法主要内容如下所示。可以看到其在代码一开始就匹配是否为 "null" 开头。

private static JSONObject _fromJSONTokener(JSONTokener tokener, JsonConfig jsonConfig) {
    try {
        if (tokener.matches("null.*")) {
            fireObjectStartEvent(jsonConfig);
            fireObjectEndEvent(jsonConfig);
            return new JSONObject(true);
        } else if (tokener.nextClean() != '{') {
            throw tokener.syntaxError("A JSONObject text must begin with '{'");
        } else {
            fireObjectStartEvent(jsonConfig);
            Collection exclusions = jsonConfig.getMergedExcludes();
            PropertyFilter jsonPropertyFilter = jsonConfig.getJsonPropertyFilter();
            JSONObject jsonObject = new JSONObject();
...

而 matches 方法更是直接用 substring 截取当前位置到末尾的字符串，然后进行正则匹配。

public boolean matches(String pattern) {
    String str = this.mySource.substring(this.myIndex);
    return RegexpUtils.getMatcher(pattern).matches(str);
}

字符串 substring 会传入字符数组、起始位置和截取长度创建一个新的 String 对象。

public String substring(int beginIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    int subLen = value.length - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}

在 JDK7 及以上，调用该构造方法时在最后一行会复制一遍截取后的数据，这也是导致整个问题的关键所在了。

public String(char value[], int offset, int count) {
    if (offset < 0) {
        throw new StringIndexOutOfBoundsException(offset);
    }
    if (count <= 0) {
        if (count < 0) {
            throw new StringIndexOutOfBoundsException(count);
        }
        if (offset <= value.length) {
            this.value = "".value;
            return;
        }
    }
    // Note: offset or count might be near -1>>>1.
    if (offset > value.length - count) {
        throw new StringIndexOutOfBoundsException(offset + count);
    }
    this.value = Arrays.copyOfRange(value, offset, offset+count);
}

推荐去我的博客阅读更多：

1.Java JVM、集合、多线程、新特性系列教程

2.Spring MVC、Spring Boot、Spring Cloud 系列教程

3.Maven、Git、Eclipse、Intellij IDEA 系列工具教程

4.Java、后端、架构、阿里巴巴等大厂最新面试题

觉得不错，别忘了点赞+转发哦！

来源：oschina

链接：https://my.oschina.net/javaroad/blog/4311804

标签

Json字符串与Object对象相互转换的几种方式

南笙酒味 — Fri, 01 May 2020 08:08:12 +0000

Json字符串与Object对象相互转换的几种方式南笙酒味 2020-05-01 16:08:12

Json-Lib、Org.Json、Jackson、Gson、FastJson五种方式转换json类型

只列举了最省事的方式。不涉及复制情况和速度。

测试用例，一个User类，属性name，age，location。重写toString()。

public class User {
    private String name;
    private Integer age;
    private String location;

    public User() {
    }
    public User(String name) {
        this.name = name;
    }
    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    public User(String name, Integer age, String location) {
        this.name = name;
        this.age = age;
        this.location = location;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getLocation() {
        return location;
    }
    public void setLocation(String location) {
        this.location = location;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", location='" + location + '\'' +
                '}';
    }
}

1、Json-Lib
maven依赖如下，需注意<classifier>jdk15</classifier>，jar包区分jdk1.3和jdk1.5版本

    <dependency>
      <groupId>net.sf.json-lib</groupId>
      <artifactId>json-lib</artifactId>
      <version>2.4</version>
      <classifier>jdk15</classifier>
    </dependency>

测试demo

import net.sf.json.JSONObject;

public class JsonLibDemo {

    public static void main(String[] args) {
        //创建测试object
        User user = new User("李宁",24,"北京");
        System.out.println(user);

        //转成json字符串
        JSONObject jsonObject = JSONObject.fromObject(user);
        String json = jsonObject.toString();
        System.out.println(json);

        //json字符串转成对象
        JSONObject jsonObject1 = JSONObject.fromObject(json);
        User user1 = (User) JSONObject.toBean(jsonObject1,User.class);
        System.out.println(user1);
    }
}

2、org.json
maven依赖如下

    <dependency>
      <groupId>org.json</groupId>
      <artifactId>json</artifactId>
      <version>20170516</version>
    </dependency>

测试demo

import org.json.JSONObject;

public class OrgJsonDemo {
    public static void main(String[] args) {
        //创建测试object
        User user = new User("李宁",24,"北京");
        System.out.println(user);

        //转成json字符串
        String json = new JSONObject(user).toString();
        System.out.println(json);

        //json字符串转成对象
        JSONObject jsonObject = new JSONObject(json);
        String name = jsonObject.getString("name");
        Integer age = jsonObject.getInt("age");
        String location = jsonObject.getString("location");
        User user1 = new User(name,age,location);
        System.out.println(user1);
    }
}

3、Jackson
maven依赖

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>

测试demo

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonDemo {
    public static void main(String[] args) {
        //创建测试object
        User user = new User("李宁",24,"北京");
        System.out.println(user);

        //转成json字符串
        ObjectMapper mapper = new ObjectMapper();
        try {
            String json = mapper.writeValueAsString(user);
            System.out.println(json);

            //json字符串转成对象
            User user1 = mapper.readValue(json,User.class);
            System.out.println(user1);

        } catch (java.io.IOException e) {
            e.printStackTrace();
        }
    }
}

4、Gson
maven依赖

    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.8.1</version>
    </dependency>

测试demo

import com.google.gson.Gson;

public class GsonDemo {
    public static void main(String[] args) {
        //创建测试object
        User user = new User("李宁",24,"北京");
        System.out.println(user);

        //转成json字符串
        Gson gson = new Gson();
        String json = gson.toJson(user);
        System.out.println(json);

        //json字符串转成对象
        User user1 = gson.fromJson(json,User.class);
        System.out.println(user1);
    }
}

5、FastJson
maven依赖

    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.37</version>
    </dependency>

测试demo

import com.alibaba.fastjson.JSON;

public class FastJsonDemo {
    public static void main(String[] args) {
        //创建测试object
        User user = new User("李宁",24,"北京");
        System.out.println(user);

        //转成json字符串
        String json = JSON.toJSON(user).toString();
        System.out.println(json);

        //json字符串转成对象
        User user1 = JSON.parseObject(json,User.class);
        System.out.println(user1);

    }
}

json-lib时间有些久远，jar包只更新到2010年

org.json用起来有些繁琐

Jackson、Gson、FastJson只需一两句话就可以搞定

来源：oschina

链接：https://my.oschina.net/u/4374048/blog/4260927

标签

Json字符串与Object对象相互转换的几种方式

一世执手 — Thu, 16 Apr 2020 18:21:53 +0000

Json字符串与Object对象相互转换的几种方式一世执手 2020-04-17 02:21:53

【推荐阅读】微服务还能火多久？>>>

Json-Lib、Org.Json、Jackson、Gson、FastJson五种方式转换json类型
只列举了最省事的方式。不涉及复制情况和速度。

测试用例，一个User类，属性name，age，location。重写toString()。

public class User {
private String name;
private Integer age;
private String location;

public User() {
}
public User(String name) {
this.name = name;
}
public User(String name, Integer age) {
this.name = name;
this.age = age;
}
public User(String name, Integer age, String location) {
this.name = name;
this.age = age;
this.location = location;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getLocation() {
return location;
}
public void setLocation(String location) {
this.location = location;
}

@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", location='" + location + '\'' +
'}';
}
}
1、Json-Lib
maven依赖如下，需注意<classifier>jdk15</classifier>，jar包区分jdk1.3和jdk1.5版本

<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>2.4</version>
<classifier>jdk15</classifier>
</dependency>

测试demo

import net.sf.json.JSONObject;

public class JsonLibDemo {

public static void main(String[] args) {
//创建测试object
User user = new User("李宁",24,"北京");
System.out.println(user);

//转成json字符串
JSONObject jsonObject = JSONObject.fromObject(user);
String json = jsonObject.toString();
System.out.println(json);

//json字符串转成对象
JSONObject jsonObject1 = JSONObject.fromObject(json);
User user1 = (User) JSONObject.toBean(jsonObject1,User.class);
System.out.println(user1);
}
}

2、org.json
maven依赖如下

<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20170516</version>
</dependency>

测试demo

import org.json.JSONObject;

public class OrgJsonDemo {
public static void main(String[] args) {
//创建测试object
User user = new User("李宁",24,"北京");
System.out.println(user);

//转成json字符串
String json = new JSONObject(user).toString();
System.out.println(json);

//json字符串转成对象
JSONObject jsonObject = new JSONObject(json);
String name = jsonObject.getString("name");
Integer age = jsonObject.getInt("age");
String location = jsonObject.getString("location");
User user1 = new User(name,age,location);
System.out.println(user1);
}
3、Jackson
maven依赖

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>

测试demo

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonDemo {
public static void main(String[] args) {
//创建测试object
User user = new User("李宁",24,"北京");
System.out.println(user);

//转成json字符串
ObjectMapper mapper = new ObjectMapper();
try {
String json = mapper.writeValueAsString(user);
System.out.println(json);

//json字符串转成对象
User user1 = mapper.readValue(json,User.class);
System.out.println(user1);

} catch (java.io.IOException e) {
e.printStackTrace();
}
}
}
4、Gson
maven依赖

<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.1</version>
</dependency>

测试demo

import com.google.gson.Gson;

public class GsonDemo {
public static void main(String[] args) {
//创建测试object
User user = new User("李宁",24,"北京");
System.out.println(user);

//转成json字符串
Gson gson = new Gson();
String json = gson.toJson(user);
System.out.println(json);

//json字符串转成对象
User user1 = gson.fromJson(json,User.class);
System.out.println(user1);
}
}
5、FastJson
maven依赖

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.37</version>
</dependency>

测试demo

import com.alibaba.fastjson.JSON;

public class FastJsonDemo {
public static void main(String[] args) {
//创建测试object
User user = new User("李宁",24,"北京");
System.out.println(user);

//转成json字符串
String json = JSON.toJSON(user).toString();
System.out.println(json);

//json字符串转成对象
User user1 = JSON.parseObject(json,User.class);
System.out.println(user1);

}
}

json-lib时间有些久远，jar包只更新到2010年

org.json用起来有些繁琐

Jackson、Gson、FastJson只需一两句话就可以搞定

来源：oschina

链接：https://my.oschina.net/u/4263597/blog/3236858

标签

Java递归算法构造JSON树形结构

Deadly — Thu, 09 Apr 2020 01:49:30 +0000

Java递归算法构造JSON树形结构 Deadly 2020-04-09 09:49:30

1.前言

最近项目中有一个需求，数据库中的菜单表是一个常见的id-pid结构，需要把它构建成树形的JSON格式发送给第三方，写出来之后感觉也是很简单的，核心代码只有5行，重要的是思路要明确，这里把源码分享给大家。

工程里面使用了json-lib.jar这个包，作用是将List序列化成JSON。

2.前言

package com.agileai.esb.smc.domain;
 
 
 
import java.util.*;
 
import net.sf.json.JSONArray;
 
public class TreeBuilder {
 
        
 
         List<TreeBuilder.Node> nodes = new ArrayList<TreeBuilder.Node>();
 
 
 
         public TreeBuilder(List<Node> nodes) {
 
                   super();
 
                   this.nodes= nodes;
 
         }
 
        
 
         /**
          * 构建JSON树形结构
          * @return
          */
 
         public String buildJSONTree() {
 
                   List<Node> nodeTree = buildTree();
 
                   JSONArray jsonArray = JSONArray.fromObject(nodeTree);
 
                   return jsonArray.toString();
 
         }
 
        
 
         /**
          * 构建树形结构
          * @return
          */
 
         public List<Node> buildTree() {
 
                   List<Node>treeNodes = new ArrayList<Node>();
 
                   List<Node>rootNodes = getRootNodes();
 
                   for (Node rootNode : rootNodes) {
 
                            buildChildNodes(rootNode);
 
                            treeNodes.add(rootNode);
 
                   }
 
                   return treeNodes;
 
         }
 
        
 
         /**
          * 递归子节点
          * @param node
          */
 
         public void buildChildNodes(Node node) {
 
       List<Node> children = getChildNodes(node); 
 
       if (!children.isEmpty()) {
 
            for(Node child : children) {
 
                     buildChildNodes(child);
 
            } 
 
            node.setMenus(children);
 
       }
 
         }
 
 
 
         /**
          * 获取父节点下所有的子节点
          * @param nodes
          * @param pnode
          * @return
          */
 
         public List<Node> getChildNodes(Node pnode) {
 
                   List<Node>childNodes = new ArrayList<Node>();
 
                   for (Node n : nodes){
 
                            if (pnode.getId().equals(n.getPid())) {
 
                                     childNodes.add(n);
 
                            }
 
                   }
 
                   return childNodes;
 
         }
 
        
 
         /**
          * 判断是否为根节点
          * @param nodes
          * @param inNode
          * @return
          */
 
         public boolean rootNode(Node node) {
 
                   boolean isRootNode = true;
 
                   for (Node n : nodes){
 
                            if (node.getPid().equals(n.getId())) {
 
                                     isRootNode= false;
 
                                     break;
 
                            }
 
                   }
 
                   return isRootNode;
 
         }
 
        
 
         /**
          * 获取集合中所有的根节点
          * @param nodes
          * @return
          */
 
         public List<Node> getRootNodes() {
 
                   List<Node>rootNodes = new ArrayList<Node>();
 
                   for (Node n : nodes){
 
                            if (rootNode(n)) {
 
                                     rootNodes.add(n);
 
                            }
 
                   }
 
                   return rootNodes;
 
         }
 
        
 
         public static class Node {
 
                  
 
                   private String id;
 
                   private String pid;
 
                   private String text;
 
                   private String url;
 
                   private List<Node> menus;
 
                  
 
                   public Node() {}
 
 
 
                   public Node(String id, String pid, String text, String url) {
 
                            super();
 
                            this.id =id;
 
                            this.pid =pid;
 
                            this.text =text;
 
                            this.url =url;
 
                   }
 
                  
 
                   public String getId() {
 
                            return id;
 
                   }
 
                   public void setId(String id) {
 
                            this.id =id;
 
                   }
 
                   public String getPid() {
 
                            return pid;
 
                   }
 
                   public void setPid(String pid) {
 
                            this.pid =pid;
 
                   }
 
                   public String getText() {
 
                            return text;
 
                   }
 
                   public void setText(String text) {
 
                            this.text =text;
 
                   }
 
                   public String getUrl() {
 
                            return url;
 
                   }
 
                   public void setUrl(String url) {
 
                            this.url =url;
 
                   }
 
                   public List<Node> getMenus() {
 
                            return menus;
 
                   }
 
                   public void setMenus(List<Node> menus) {
 
                            this.menus= menus;
 
                   }
 
         }
 
        
 
         public static void main(String[] args) {
 
                  
 
                   List<Node>nodes = new ArrayList<Node>();
 
                   Node p1 = new Node("01", "","01", "");
 
                   Node p6 = new Node("02", "","02", "");
 
                   Node p7 = new Node("0201", "02","0201", "");
 
                   Node p2 = new Node("0101", "01","0101", "");
 
                   Node p3 = new Node("0102", "01","0102", "");
 
                   Node p4 = new Node("010101", "0101","010101", "");
 
                   Node p5 = new Node("010102", "0101","010102", "");
 
                   Node p8 = new Node("03", "","03", "");
 
                   nodes.add(p1);
 
                   nodes.add(p2);
 
                   nodes.add(p3);
 
                   nodes.add(p4);
 
                   nodes.add(p5);
 
                   nodes.add(p6);
 
                   nodes.add(p7);
                   
                   nodes.add(p8);
                  
 
                   TreeBuilder treeBuilder = new TreeBuilder(nodes);
 
                   System.out.println(treeBuilder.buildJSONTree());
 
         }
 
}

来源：oschina

链接：https://my.oschina.net/u/3734228/blog/1930215

标签

java

JSON lib

【Java Web_13】Ajax、Json

橙三吉。 — Wed, 26 Feb 2020 11:20:00 +0000

【Java Web_13】Ajax、Json 橙三吉。 2020-02-26 19:20:00

一、Ajax

1. $.ajax()

* 语法：$.ajax({键值对});
    //使用$.ajax()发送异步请求
    $.ajax({
        url:"ajaxServlet1111" , // 请求路径
        type:"POST" , //请求方式
        //data: "username=jack&age=23",//请求参数
        data:{"username":"jack","age":23},
        success:function (data) {
            alert(data);
        },//响应成功后的回调函数
        error:function () {
            alert("出错啦...")
        },//表示如果请求响应出现错误，会执行的回调函数

        dataType:"text"//设置接受到的响应数据的格式
    
    });

2. $.get()：发送get请求

* 语法：$.get(url, [data], [callback], [type])
    * 参数：
        * url：请求路径
        * data：请求参数
        * callback：回调函数
        * type：响应结果的类型

3. $.post()：发送post请求

* 语法：$.post(url, [data], [callback], [type])
    * 参数：
        * url：请求路径
        * data：请求参数
        * callback：回调函数
        * type：响应结果的类型

二、json

1. JSON数据和Java对象的相互转换

① JSON解析器：
    * 常见的解析器：Jsonlib，Gson，fastjson，jackson
② JSON转为Java对象
    * 导入jackson的相关jar包
    * 创建Jackson核心对象 ObjectMapper
    * 调用ObjectMapper的相关方法进行转换
        - readValue(json字符串数据,Class)
③ Java对象转换JSON
    * 导入jackson的相关jar包
    * 创建Jackson核心对象 ObjectMapper
    * 调用ObjectMapper的相关方法进行转换
        - writeValue(参数1，obj):
            参数1：
                File：将obj对象转换为JSON字符串，并保存到指定的文件中
                Writer：将obj对象转换为JSON字符串，并将json数据填充到字符输出流中
                OutputStream：将obj对象转换为JSON字符串，并将json数据填充到字节输出流中
        -  writeValueAsString(obj):将对象转为json字符串
    * 注解：
        - @JsonIgnore：排除属性。
        - @JsonFormat：属性值得格式化
             @JsonFormat(pattern = "yyyy-MM-dd")

2. json获取数据

① 单个数据
    * json对象.键名
    * json对象["键名"]
② 遍历
    for(var key in json对象) {
        //获取单个
    }

来源：oschina

链接：https://my.oschina.net/chinaSoftware/blog/3166227

标签

SpringBoot引入第三方jar包或本地jar包的处理方式

扶醉桌前 — Fri, 20 Dec 2019 06:51:00 +0000

SpringBoot引入第三方jar包或本地jar包的处理方式扶醉桌前 2019-12-20 14:51:00

【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>>

在开发过程中有时会用到maven仓库里没有的jar包或者本地的jar包，这时没办法通过pom直接引入，那么该怎么解决呢

一般有两种方法
- 第一种是将本地jar包安装在本地maven库
- 第二种是将本地jar包放入项目目录中

这篇文章主要讲第二种方式，这又分两种情况，一种是打包jar包，第二种是打包war包

jar包

先看看jar包的结构

用压缩工具打开一个jar包

打包后jar包的路径在BOOT-INF\lib目录下

在项目目录中创建个文件夹用来存放jar包

pom文件中加入如下内容

        <dependency>
            <groupId>com.ckfinder</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.3</version>
            <scope>system</scope>
            <systemPath>${project.basedir}/src/main/resources/jar/json-lib-2.3-jdk15.jar</systemPath>
        </dependency>

groupId，artifactId，version可随便写
这时候在项目中运行是没问题了，但是使用命令mvn clean package打包之后BOOT-INF\lib里面并没有json-lib-2.3-jdk15.jar包，还需要pom文件中做如下配置：

         <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <includeSystemScope>true</includeSystemScope>
                </configuration>
            </plugin>

之后再使用mvn clean package打包就OK了

war包

war包的目录如下:

war包在WEB-INF/lib目录下
使用mvn clean package命令打包时需要在pom文件加入以下内容

              <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>2.4</version>
                    <configuration>
                        <webResources>
                            <resource>
                                <directory>src/main/resources/jar/</directory>
                                <targetPath>WEB-INF/lib/</targetPath>
                                <includes>
                                    <include>**/*.jar</include>
                                </includes>
                            </resource>
                        </webResources>
                    </configuration>
                </plugin>

来源：oschina

链接：https://my.oschina.net/u/854444/blog/3028353

标签

java中常见的JSON操作

三世轮回 — Tue, 03 Dec 2019 22:40:40 +0000

java中常见的JSON操作三世轮回 2019-12-04 06:40:40

一、什么是Json

Json是指JavaScript对象表示法(Java Script Object Notation)
Json是轻量级的文本数据交换格式
Json独立于语言和平台：Json解析器和Json库支持许多不同的编程语言
Json具有自我描述性，更易理解

二、Java中操作Json的几种方式

FastJson 阿里巴巴开发的 JSON 库，性能十分优秀

<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.62</version>
</dependency>

Gson 谷歌开发的 JSON 库，功能十分全面

<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.6</version>
</dependency>

net.sf.json 最常见，使用较多

<!-- https://mvnrepository.com/artifact/net.sf.json-lib/json-lib -->
<dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib</artifactId>
    <version>2.4</version>
	<classifier>jdk15</classifier>
</dependency>

Jackson 社区十分活跃且更新速度很快。

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.10.0</version>
</dependency>

1、FastJson示例

package com.powersi.test;

import java.util.ArrayList;
import java.util.List;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

public class FastJsonTest {

	/**
	 * java对象转Json
	 */
	public static String object2Json(){
		JSONObject json = new JSONObject();
		Student stu = new Student();
		stu.setId(001);
		stu.setName("张三");
		stu.setAge(18);
		json = (JSONObject) JSONObject.toJSON(stu);
		return json.toString();
	}
	
	/**
	 * json转java对象 
	 */
	public static String json2Object(){
		JSONObject json = new JSONObject();
		json.put("id", "001");
		json.put("name", "张三");
		json.put("age", "18");
		Student s = JSONObject.toJavaObject(json, Student.class);
		return s.toString();
	}
	
	/**
	 * json转字符串
	 */
	public static String json2String(){
		JSONObject json = new JSONObject();
		json.put("id", "001");
		json.put("name", "张三");
		json.put("age", "18");
		String s = JSONObject.toJSONString(json);
		return s;
	}
	
	/**
	 * 字符串转json
	 */
	public static String string2Json(){
		JSONObject json = new JSONObject();
		String s = "{\"id\":\"001\", \"name\":\"张三\", \"age\":\"18\"}";
		json = JSONObject.parseObject(s);
	    return json.toString();
	}
	
	/**
	 * 集合转json数组
	 */
	public static String list2JsonArray(){
		Student stu = new Student();
		stu.setId(001);
		stu.setName("张三");
		stu.setAge(18);
		
		Student stu2 = new Student();
		stu2.setId(002);
		stu2.setName("李四");
		stu2.setAge(19);
		
		List<Student> stuList = new ArrayList<Student>();
		stuList.add(stu);
		stuList.add(stu2);
		
		String s = JSONArray.toJSONString(stuList);
		return s;
	}
	
	public static void main(String[] args) {
		System.out.println(FastJsonTest.list2JsonArray());
	}
}

2、Gson示例

package com.powersi.test;

import java.util.ArrayList;
import java.util.List;

import com.google.gson.Gson;

public class GsonTest {

	/**
	 * java对象转Json
	 */
	public static String object2Json(){
		Gson gson = new Gson();
		Student stu = new Student();
		stu.setId(001);
		stu.setName("张三");
		stu.setAge(18);
		String s = gson.toJson(stu);
		return s;
	}
	
	/**
	 * json转java对象 
	 */
	public static String json2Object(){
		Gson gson = new Gson();
		String jsonStr = object2Json();
		Student s = gson.fromJson(jsonStr, Student.class);
		return s.toString();
	}
	
	
	/**
	 * 对象转json数组
	 */
	public static String list2JsonArray(){
		Gson gson = new Gson();
		
		Student stu = new Student();
		stu.setId(001);
		stu.setName("张三");
		stu.setAge(18);
		
		Student stu2 = new Student();
		stu2.setId(002);
		stu2.setName("李四");
		stu2.setAge(19);
		
		List<Student> stuList = new ArrayList<Student>();
		stuList.add(stu);
		stuList.add(stu2);
		
		String s = gson.toJson(stuList);
		return s;
	}
	
	public static void main(String[] args) {
		System.out.println(GsonTest.list2JsonArray());
	}
}

3、net.sf.json示例

package com.powersi.test;

import java.util.ArrayList;
import java.util.List;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

public class NetSFJsonTest {

	/**
	 * java对象转Json
	 */
	public static String object2Json(){
		JSONObject json = new JSONObject();
		Student stu = new Student();
		stu.setId(001);
		stu.setName("张三");
		stu.setAge(18);
		json = JSONObject.fromObject(stu);
		return json.toString();
	}
	
	/**
	 * json转java对象 
	 */
	public static String json2Object(){
		String jsonStr = object2Json();
		Student stu = (Student)JSONObject.toBean(JSONObject.fromObject(jsonStr), Student.class);
		return stu.toString();
	}
	
	
	/**
	 * 对象转json数组
	 */
	public static String list2JsonArray(){
		
		Student stu = new Student();
		stu.setId(001);
		stu.setName("张三");
		stu.setAge(18);
		
		Student stu2 = new Student();
		stu2.setId(002);
		stu2.setName("李四");
		stu2.setAge(19);
		
		List<Student> stuList = new ArrayList<Student>();
		stuList.add(stu);
		stuList.add(stu2);
		
		JSONArray jsonArray = JSONArray.fromObject(stuList);
		return jsonArray.toString();
	}
	
	public static void main(String[] args) {
		System.out.println(NetSFJsonTest.list2JsonArray());
	}
}

来源：https://my.oschina.net/zhang2xiang/blog/3128850

标签

基于Kafka+SparkStreaming+HBase实时点击流案例

百般思念 — Wed, 27 Nov 2019 05:54:48 +0000

基于Kafka+SparkStreaming+HBase实时点击流案例百般思念 2019-11-27 13:54:48

前言

最近在专注Spark开发，记录下自己的工作和学习路程，希望能跟大家互相交流成长
本文章更倾向于实战案例，涉及框架原理及基本应用还请读者自行阅读相关文章，相关在本文章最后参考资料中
关于Zookeeper/Kafka/HBase/Hadoop相关集群环境搭建作者会陆续更新
本文章发布后会及时更新文章中出现的错误及增加内容，欢迎大家订阅
QQ:86608625 微信:guofei1990123

背景

Kafka实时记录从数据采集工具Flume或业务系统实时接口收集数据，并作为消息缓冲组件为上游实时计算框架提供可靠数据支撑，Spark 1.3版本后支持两种整合Kafka机制（Receiver-based Approach 和 Direct Approach），具体细节请参考文章最后官方文档链接，数据存储使用HBase

实现思路

实现Kafka消息生产者模拟器
Spark-Streaming采用Direct Approach方式实时获取Kafka中数据
Spark-Streaming对数据进行业务计算后数据存储到HBase

本地虚拟机集群环境配置

由于笔者机器性能有限，hadoop/zookeeper/kafka集群都搭建在一起主机名分别为hadoop1,hadoop2,hadoop3; hbase为单节点在hadoop1

缺点及不足

由于笔者技术有限，代码设计上有部分缺陷，比如spark-streaming计算后数据保存hbase逻辑性能很低，希望大家多提意见以便小编及时更正

代码实现

Kafka消息模拟器

package clickstream
import java.util.{Properties, Random, UUID}
import kafka.producer.{KeyedMessage, Producer, ProducerConfig}
import org.codehaus.jettison.json.JSONObject

/**  * 
Created by 郭飞 on 2016/5/31.  
*/
object KafkaMessageGenerator {
  private val random = new Random()
  private var pointer = -1
  private val os_type = Array(
    "Android", "IPhone OS",
    "None", "Windows Phone")

  def click() : Double = {
    random.nextInt(10)
  }

  def getOsType() : String = {
    pointer = pointer + 1
    if(pointer >= os_type.length) {
      pointer = 0
      os_type(pointer)
    } else {
      os_type(pointer)
    }
  }

  def main(args: Array[String]): Unit = {
    val topic = "user_events"
    //本地虚拟机ZK地址
    val brokers = "hadoop1:9092,hadoop2:9092,hadoop3:9092"
    val props = new Properties()
    props.put("metadata.broker.list", brokers)
    props.put("serializer.class", "kafka.serializer.StringEncoder")

    val kafkaConfig = new ProducerConfig(props)
    val producer = new Producer[String, String](kafkaConfig)

    while(true) {
      // prepare event data
      val event = new JSONObject()
      event
        .put("uid", UUID.randomUUID())//随机生成用户id
        .put("event_time", System.currentTimeMillis.toString) //记录时间发生时间
        .put("os_type", getOsType) //设备类型
        .put("click_count", click) //点击次数

      // produce event message
      producer.send(new KeyedMessage[String, String](topic, event.toString))
      println("Message sent: " + event)

      Thread.sleep(200)
    }
  }
}

Spark-Streaming主类

package clickstream
import kafka.serializer.StringDecoder
import net.sf.json.JSONObject
import org.apache.hadoop.hbase.client.{HTable, Put}
import org.apache.hadoop.hbase.util.Bytes
import org.apache.hadoop.hbase.{HBaseConfiguration, TableName}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.kafka.KafkaUtils
import org.apache.spark.streaming.{Seconds, StreamingContext}

/**
  * Created by 郭飞 on 2016/5/31.
  */
object PageViewStream {
  def main(args: Array[String]): Unit = {
    var masterUrl = "local[2]"
    if (args.length > 0) {
      masterUrl = args(0)
    }

    // Create a StreamingContext with the given master URL
    val conf = new SparkConf().setMaster(masterUrl).setAppName("PageViewStream")
    val ssc = new StreamingContext(conf, Seconds(5))

    // Kafka configurations
    val topics = Set("PageViewStream")
    //本地虚拟机ZK地址
    val brokers = "hadoop1:9092,hadoop2:9092,hadoop3:9092"
    val kafkaParams = Map[String, String](
      "metadata.broker.list" -> brokers,
      "serializer.class" -> "kafka.serializer.StringEncoder")

    // Create a direct stream
    val kafkaStream = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](ssc, kafkaParams, topics)

    val events = kafkaStream.flatMap(line => {
      val data = JSONObject.fromObject(line._2)
      Some(data)
    })
    // Compute user click times
    val userClicks = events.map(x => (x.getString("uid"), x.getInt("click_count"))).reduceByKey(_ + _)
    userClicks.foreachRDD(rdd => {
      rdd.foreachPartition(partitionOfRecords => {
        partitionOfRecords.foreach(pair => {
          //Hbase配置
          val tableName = "PageViewStream"
          val hbaseConf = HBaseConfiguration.create()
          hbaseConf.set("hbase.zookeeper.quorum", "hadoop1:9092")
          hbaseConf.set("hbase.zookeeper.property.clientPort", "2181")
          hbaseConf.set("hbase.defaults.for.version.skip", "true")
          //用户ID
          val uid = pair._1
          //点击次数
          val click = pair._2
          //组装数据
          val put = new Put(Bytes.toBytes(uid))
          put.add("Stat".getBytes, "ClickStat".getBytes, Bytes.toBytes(click))
          val StatTable = new HTable(hbaseConf, TableName.valueOf(tableName))
          StatTable.setAutoFlush(false, false)
          //写入数据缓存
          StatTable.setWriteBufferSize(3*1024*1024)
          StatTable.put(put)
          //提交
          StatTable.flushCommits()
        })
      })
    })
    ssc.start()
    ssc.awaitTermination()

  }

}

Maven POM文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.guofei.spark</groupId>
  <artifactId>RiskControl</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>RiskControl</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <!--Spark core 及 streaming -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-core_2.10</artifactId>
      <version>1.3.0</version>
    </dependency>
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-streaming_2.10</artifactId>
      <version>1.3.0</version>
    </dependency>
    <!-- Spark整合Kafka-->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-streaming-kafka_2.10</artifactId>
      <version>1.3.0</version>
    </dependency>

    <!-- 整合Hbase-->
    <dependency>
      <groupId>org.apache.hbase</groupId>
      <artifactId>hbase</artifactId>
      <version>0.96.2-hadoop2</version>
      <type>pom</type>
    </dependency>
    <!--Hbase依赖 -->
    <dependency>
      <groupId>org.apache.hbase</groupId>
      <artifactId>hbase-server</artifactId>
      <version>0.96.2-hadoop2</version>
    </dependency>
    <dependency>
      <groupId>org.apache.hbase</groupId>
      <artifactId>hbase-client</artifactId>
      <version>0.96.2-hadoop2</version>
    </dependency>
    <dependency>
      <groupId>org.apache.hbase</groupId>
      <artifactId>hbase-common</artifactId>
      <version>0.96.2-hadoop2</version>
    </dependency>
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>1.3.2</version>
    </dependency>
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.1.3</version>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>

    <dependency>
      <groupId>com.google.protobuf</groupId>
      <artifactId>protobuf-java</artifactId>
      <version>2.5.0</version>
    </dependency>
    <dependency>
      <groupId>io.netty</groupId>
      <artifactId>netty</artifactId>
      <version>3.6.6.Final</version>
    </dependency>
    <dependency>
      <groupId>org.apache.hbase</groupId>
      <artifactId>hbase-protocol</artifactId>
      <version>0.96.2-hadoop2</version>
    </dependency>
    <dependency>
      <groupId>org.apache.zookeeper</groupId>
      <artifactId>zookeeper</artifactId>
      <version>3.4.5</version>
    </dependency>
    <dependency>
      <groupId>org.cloudera.htrace</groupId>
      <artifactId>htrace-core</artifactId>
      <version>2.01</version>
    </dependency>
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-mapper-asl</artifactId>
      <version>1.9.13</version>
    </dependency>
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-core-asl</artifactId>
      <version>1.9.13</version>
    </dependency>
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-jaxrs</artifactId>
      <version>1.9.13</version>
    </dependency>
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-xc</artifactId>
      <version>1.9.13</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.6.4</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.6.4</version>
    </dependency>

    <!-- Hadoop依赖包-->
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-client</artifactId>
      <version>2.6.4</version>
    </dependency>
    <dependency>
      <groupId>commons-configuration</groupId>
      <artifactId>commons-configuration</artifactId>
      <version>1.6</version>
    </dependency>
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-auth</artifactId>
      <version>2.6.4</version>
    </dependency>
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-common</artifactId>
      <version>2.6.4</version>
    </dependency>

    <dependency>
      <groupId>net.sf.json-lib</groupId>
      <artifactId>json-lib</artifactId>
      <version>2.4</version>
      <classifier>jdk15</classifier>
    </dependency>

    <dependency>
      <groupId>org.codehaus.jettison</groupId>
      <artifactId>jettison</artifactId>
      <version>1.1</version>
    </dependency>

    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>2.5.2</version>
    </dependency>
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-pool2</artifactId>
      <version>2.2</version>
    </dependency>
  </dependencies>

  <build>
    <sourceDirectory>src/main/scala</sourceDirectory>
    <testSourceDirectory>src/test/scala</testSourceDirectory>
    <plugins>
      <plugin>
        <groupId>net.alchim31.maven</groupId>
        <artifactId>scala-maven-plugin</artifactId>
        <version>3.2.2</version>
        <executions>
          <execution>
            <goals>
              <goal>compile</goal>
              <goal>testCompile</goal>
            </goals>
            <configuration>
              <args>
                <arg>-make:transitive</arg>
                <arg>-dependencyfile</arg>
                <arg>${project.build.directory}/.scala_dependencies</arg>
              </args>
            </configuration>
          </execution>
        </executions>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-shade-plugin</artifactId>
        <version>2.4.3</version>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>shade</goal>
            </goals>
            <configuration>
              <filters>
                <filter>
                  <artifact>*:*</artifact>
                  <excludes>
                    <exclude>META-INF/*.SF</exclude>
                    <exclude>META-INF/*.DSA</exclude>
                    <exclude>META-INF/*.RSA</exclude>
                  </excludes>
                </filter>
              </filters>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

FAQ

Maven导入json-lib报错
Failure to find net.sf.json-lib:json-lib:jar:2.3 in
http://repo.maven.apache.org/maven2 was cached in the local
repository
解决：
http://stackoverflow.com/questions/4173214/maven-missing-net-sf-json-lib
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>2.4</version>
<classifier>jdk15</classifier>
</dependency>
执行Spark-Streaming程序报错
org.apache.spark.SparkException: Task not serializable

userClicks.foreachRDD(rdd => { 
rdd.foreachPartition(partitionOfRecords => { 
partitionOfRecords.foreach(
这里面的代码中所包含的对象必须是序列化的
这里面的代码中所包含的对象必须是序列化的
这里面的代码中所包含的对象必须是序列化的
}) 
}) 
})

执行Maven打包报错，找不到依赖的jar包
error：not found: object kafka
ERROR import kafka.javaapi.producer.Producer
解决：win10本地系统用户/郭飞/.m2/ 目录含有中文

参考文档

spark-streaming官方文档
http://spark.apache.org/docs/latest/streaming-programming-guide.html
spark-streaming整合kafka官方文档
http://spark.apache.org/docs/latest/streaming-kafka-integration.html
spark-streaming整合flume官方文档
http://spark.apache.org/docs/latest/streaming-flume-integration.html
spark-streaming整合自定义数据源官方文档
http://spark.apache.org/docs/latest/streaming-custom-receivers.html
spark-streaming官方scala案例
https://github.com/apache/spark/tree/master/examples/src/main/scala/org/apache/spark/examples/streaming
简单之美博客
http://shiyanjun.cn/archives/1097.html

作者：MichaelFly
链接：https://www.jianshu.com/p/ccba410462ba
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

来源：oschina

链接：https://my.oschina.net/u/3346994/blog/1847171

标签

Google Gson的使用方法及JSON 技术对比

青春壹個敷衍的年華 — Tue, 26 Nov 2019 22:10:49 +0000

Google Gson的使用方法及JSON 技术对比青春壹個敷衍的年華 2019-11-27 06:10:49

一、各个JSON技术的简介和优劣

1.json-lib

json-lib最开始的也是应用最广泛的json解析工具，json-lib 不好的地方确实是依赖于很多第三方包，
包括commons-beanutils.jar，commons-collections-3.2.jar，commons-lang-2.6.jar，commons-logging-1.1.1.jar，ezmorph-1.0.6.jar，对于复杂类型的转换，json-lib对于json转换成bean还有缺陷，比如一个类里面会出现另一个类的list或者map集合，json-lib从json到bean的转换就会出现问题。json-lib在功能和性能上面都不能满足现在互联网化的需求。

2.开源的Jackson

相比json-lib框架，Jackson所依赖的jar包较少，简单易用并且性能也要相对高些。而且Jackson社区相对比较活跃，更新速度也比较快。Jackson对于复杂类型的json转换bean会出现问题，一些集合Map，List的转换出现问题。Jackson对于复杂类型的bean转换Json，转换的json格式不是标准的Json格式

3.Google的Gson

Gson是目前功能最全的Json解析神器，Gson当初是为因应Google公司内部需求而由Google自行研发而来，
但自从在2008年五月公开发布第一版后已被许多公司或用户应用。Gson的应用主要为toJson与fromJson两个转换函数，无依赖，不需要例外额外的jar，能够直接跑在JDK上。而在使用这种对象转换之前需先创建好对象的类型以及其成员才能成功的将JSON字符串成功转换成相对应的对象。类里面只要有get和set方法，Gson完全可以将复杂类型的json到bean或bean到json的转换，是JSON解析的神器。Gson在功能上面无可挑剔，但是性能上面比FastJson有所差距。

4.阿里巴巴的FastJson

Fastjson是一个Java语言编写的高性能的JSON处理器,由阿里巴巴公司开发。无依赖，不需要例外额外的jar，能够直接跑在JDK上。FastJson在复杂类型的Bean转换Json上会出现一些问题，可能会出现引用的类型，导致Json转换出错，需要制定引用。FastJson采用独创的算法，将parse的速度提升到极致，超过所有json库。

综上4种Json技术的比较，在项目选型的时候可以使用Google的Gson和阿里巴巴的FastJson两种并行使用，如果只是功能要求，没有性能要求，可以使用google的Gson，如果有性能上面的要求可以使用Gson将bean转换json确保数据的正确，使用FastJson将Json转换Bean

二、Google的Gson包的使用简介。

Gson类：解析json的最基础的工具类
JsonParser类：解析器来解析JSON到JsonElements的解析树
JsonElement类：一个类代表的JSON元素
JsonObject类：JSON对象类型
JsonArray类：JsonObject数组
TypeToken类：用于创建type，比如泛型List<?>

maven 依赖：

<dependency>
	<groupId>com.google.code.gson</groupId>
	<artifactId>gson</artifactId>
	<version>2.7</version>
</dependency>

三、Gson的使用

首先定义一个类：

package com.test;

import java.util.Date;

public class User {

	private Integer id;
	private int age;
	private String userName;
	private Date birthday;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	public User(Integer id, int age, String userName, Date birthday) {
		super();
		this.id = id;
		this.age = age;
		this.userName = userName;
		this.birthday = birthday;
	}

	public User() {
		super();
	}

}

测试实例：

package com.test;

import java.util.Date;
import java.util.List;
import java.util.Set;

import org.junit.Test;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.reflect.TypeToken;

public class GsonTest {

	@Test
	public void test1() throws Exception {
		Gson gson = new Gson();
		User user = new User(1, 20, "AA", new Date());

		System.out.println("Bean->转换为JSON字符串:");
		String jsonStr = gson.toJson(user);
		System.out.println(jsonStr);
		System.out.println();
	}

	@Test
	public void test2() throws Exception {
		Gson gson = new Gson();
		String jsonStr = "{\"id\":1,\"age\":20,\"userName\":\"AA\",\"birthday\":\"Nov 14, 2016 4:52:38 PM\"}";
		System.out.println("字符串->转换成Bean对象");
		User user = gson.fromJson(jsonStr, User.class);
		System.out.println(user);
		System.out.println();
	}

	@Test
	public void test3() throws Exception {
		Gson gson = new Gson();
		System.out.println("json转换复杂的bean，比如List，Set,Map:");
		String json = "[{\"id\":\"1\",\"name\":\"Json技术\"},{\"id\":\"2\",\"name\":\"java技术\"}]";
		List list = gson.fromJson(json, new TypeToken<List>() {
		}.getType());
		Set set = gson.fromJson(json, new TypeToken<Set>() {
		}.getType());
		System.out.println();
	}

	@Test
	public void test4() throws Exception {
		Gson gson = new Gson();
		String json = "[{\"id\":\"1\",\"name\":\"Json技术\"},{\"id\":\"2\",\"name\":\"java技术\"}]";
		System.out.println("格式化JSON:");
		gson = new GsonBuilder().setPrettyPrinting().create();
		JsonParser jp = new JsonParser();
		JsonElement je = jp.parse(json);
		json = gson.toJson(je);
		System.out.println(json);
		System.out.println();

	}

	@Test
	public void test5() throws Exception {
		System.out.println("判断字符串是否是json,通过捕捉的异常来判断是否是json");
		String json = "[{\"id\":\"1\",\"name\":\"Json技术\"},{\"id\":\"2\",\"name\":\"java技术\"}]";
		boolean jsonFlag;
		try {
			new JsonParser().parse(json).getAsJsonObject();
			jsonFlag = true;
		} catch (Exception e) {
			jsonFlag = false;
		}
		System.out.println(jsonFlag + ":" + jsonFlag);
		System.out.println();
	}

	@Test
	public void test6() throws Exception {
		System.out.println("从json串中获取属性");
		String json = "{\"id\":\"1\",\"name\":\"Json技术\"}";
		String propertyName = "name";
		String propertyValue = "";
		try {
			JsonParser jsonParser = new JsonParser();
			JsonElement element = jsonParser.parse(json);
			JsonObject jsonObj = element.getAsJsonObject();
			propertyValue = jsonObj.get(propertyName).toString();
			System.out.println("propertyValue:" + propertyValue);
		} catch (Exception e) {
			propertyValue = null;
		}
		System.out.println();
	}

	@Test
	public void test7() throws Exception {
		System.out.println("除去json中的某个属性");
		String json = "{\"id\":\"1\",\"name\":\"Json技术\"}";
		String propertyName = "id";
		JsonParser jsonParser = new JsonParser();
		JsonElement element = jsonParser.parse(json);
		JsonObject jsonObj = element.getAsJsonObject();
		jsonObj.remove(propertyName);
		json = jsonObj.toString();
		System.out.println("json：" + json);
		System.out.println();
	}

	@Test
	public void test8() throws Exception {
		System.out.println("向json中添加属性");
		String json = "{\"id\":\"1\",\"name\":\"Json技术\"}";
		String propertyName = "desc";
		Object propertyValue = "json各种技术的调研";
		JsonParser jsonParser = new JsonParser();
		JsonElement element = jsonParser.parse(json);
		JsonObject jsonObj = element.getAsJsonObject();
		jsonObj.addProperty(propertyName, new Gson().toJson(propertyValue));
		json = jsonObj.toString();
		System.out.println("json:" + json);
		System.out.println();
	}

	@Test
	public void test9() throws Exception {
		System.out.println("修改json中的属性");
		String json = "{\"id\":\"1\",\"name\":\"Json技术\"}";
		String propertyName = "name";
		Object propertyValue = "json各种技术的调研";
		JsonParser jsonParser = new JsonParser();
		JsonElement element = jsonParser.parse(json);
		JsonObject jsonObj = element.getAsJsonObject();
		jsonObj.remove(propertyName);
		jsonObj.addProperty(propertyName, new Gson().toJson(propertyValue));
		json = jsonObj.toString();
		System.out.println("json:" + json);
		System.out.println();
	}

	@Test
	public void test10() throws Exception {
		System.out.println("判断json中是否有属性");
		String json = "{\"id\":\"1\",\"name\":\"Json技术\"}";
		String propertyName = "name";
		boolean isContains = false;
		JsonParser jsonParser = new JsonParser();
		JsonElement element = jsonParser.parse(json);
		JsonObject jsonObj = element.getAsJsonObject();
		isContains = jsonObj.has(propertyName);
		System.out.println("isContains:" + isContains);
		System.out.println();
	}

	@Test
	public void test11() throws Exception {
		System.out.println("json中日期格式的处理");
		GsonBuilder builder = new GsonBuilder();
		builder.setDateFormat("yyyy-MM-dd");
		Gson gson = builder.create();
		User user = new User();
		user.setBirthday(new Date());
		String json = gson.toJson(user);
		System.out.println("json:" + json);
		System.out.println();
	}

	@Test
	public void test12() throws Exception {
		System.out.println("json中对于Html的转义");
		GsonBuilder builder = new GsonBuilder();
		builder.disableHtmlEscaping();
		Gson gson = builder.create();
		System.out.println();
	}
}

运行如下：

判断json中是否有属性
isContains:true

json中日期格式的处理
json:{"age":0,"birthday":"2016-11-14"}

json中对于Html的转义

Bean->转换为JSON字符串:
{"id":1,"age":20,"userName":"AA","birthday":"Nov 14, 2016 5:14:19 PM"}

字符串->转换成Bean对象
User [id=1, age=20, userName=AA, birthday=Mon Nov 14 16:52:38 CST 2016]

json转换复杂的bean，比如List，Set,Map:

格式化JSON:
[
  {
    "id": "1",
    "name": "Json技术"
  },
  {
    "id": "2",
    "name": "java技术"
  }
]

判断字符串是否是json,通过捕捉的异常来判断是否是json
false:false

从json串中获取属性
propertyValue:"Json技术"

除去json中的某个属性
json：{"name":"Json技术"}

向json中添加属性
json:{"id":"1","name":"Json技术","desc":"\"json各种技术的调研\""}

修改json中的属性
json:{"id":"1","name":"\"json各种技术的调研\""}

更多关于GSON的使用方法，请参考【这里面介绍的很详细】：http://www.jianshu.com/p/e740196225a4

来源：oschina

链接：https://my.oschina.net/u/2811721/blog/787565

标签

JSON lib

json 的使用 Java对象转json

Jsonlib：package json;

Gson：

FastJson：

请不要在 JDK 7+ 中使用这个 JSON 包了！

Json字符串与Object对象相互转换的几种方式

Json-Lib、Org.Json、Jackson、Gson、FastJson五种方式转换json类型

Json字符串与Object对象相互转换的几种方式

Java递归算法构造JSON树形结构

1.前言

【Java Web_13】Ajax、Json

一、Ajax

1. $.ajax()

2. $.get()：发送get请求

3. $.post()：发送post请求

二、json

1. JSON数据和Java对象的相互转换

2. json获取数据

SpringBoot引入第三方jar包或本地jar包的处理方式

jar包

war包

java中常见的JSON操作

一、什么是Json

二、Java中操作Json的几种方式

1、FastJson示例

2、Gson示例

3、net.sf.json示例

基于Kafka+SparkStreaming+HBase实时点击流案例

前言

背景

实现思路

本地虚拟机集群环境配置

缺点及不足

代码实现

Maven POM文件

FAQ

参考文档

Google Gson的使用方法及JSON 技术对比

一 、各个JSON技术的简介和优劣

1.json-lib

2.开源的Jackson

3.Google的Gson

4.阿里巴巴的FastJson

二、Google的Gson包的使用简介。

一、各个JSON技术的简介和优劣