【第三方JSON库】org.json.simple用法初探—Java编程【Eclipse平台】【不使用项目管理工具】【不添加依赖解析】

本文将重点介绍，在不使用项目管理工具，不添加依赖解析情况下，【第三方库】JSON.simple库在Java编程的应用。

JSON.simple是一种由纯java开发的开源JSON库，包含在JSON.simple.jar中。它提供了一种简单的方式来处理JSON数据和以JSON格式输出数据。使用JSON.simple，你可以轻松地将JSON数据转换为Java对象或将Java对象转换为JSON格式。

JSON.simple库中包含的主要类有JSONObject和JSONArray。JSONObject类表示JSON对象，JSONArray类表示JSON数组。它们提供了一系列方法来操作JSON数据。

JSON.simple的功能:

完全兼容JSON的标准(RFC4627）
提供了多个功能，如编码和解码JSON格式数据；
使用轻量级的库来解码/解析和转换JSON数据信息
灵活，简单，而且容易被Map和List接口重用；
支持流式的JSON文本输出；
提供了对于JSON文本流式输入的可停止的SAX-like接口基于解析器的头；
高性能，而且还不依赖其它的库；
所有的代码和执行文件都可和JDK兼容

在这里插入图片描述
说明：
JSONObject是Java.util.HashMap的子类，不提供排序。
如果你需要强制对元素进行排序，可以使用JSONValue.toJSONString(map)方法来实现。

在解码或解析时，JSON.simple的映射是从中间映射到右边；
在编码时，映射关系是从右边到中间。

在解码时，
默认具体的java.util.List类对应的是 org.json.simple.JSONArray;
默认具体的java.util.Map类对应的是 org.json.simple.JSONObject;

在编码时，没有列在表右边的类需要实现JSONAware（相当于Java中自定义的类）或JSONStreamAware（相当于自定义Java中序列化的流）来实现定制化的JSON输出；在这种情况下，JSON.simple调用JSONAware.toJSONString()或 JSONStreamAware.writeJSONString() 来进行序列化，生成确定JSON文本的结果。

JSON.simple-自定义输出
有时候，我们需要以特定的方式输出JSON数据。JSON.simple提供了一种简单的方式来自定义JSON输出。
使用JSONObject.toJSONString方法，我们可以将JSON数据转换为字符串；也可以使用一个实现了JSONAware接口的自定义JSONValue实例对输出进行自定义。

Java使用【第三方JSON库】org.json.simple环境配置。
JSON.simple是一种由纯java开发的开源JSON库，包含在JSON.simple.jar中。因此需要下载一个JSON.simple.jar的JAR文件包，并在【Eclipse平台】配置构建路径。如下是我的开发环境中的配置：
在这里插入图片描述

JSON程序，例程一：
解析JSON字符串。例程演示了解析下面这个JSON字符串。
JSON字符串: { “姓名”: “雷锋”, “年龄”: 30, “是否党员”: true }
Java程序，使用Java解析JSON数据的步骤如下：
在这里插入图片描述
JSON例程一：JSONParsingExample01.java源码如下：

package json;
import java.util.Map;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
public class JSONParsingExample01 { //基本数据类型测试
	//定义一个JSON字符串
	static final String json = "{\"姓名\":\"雷锋\",\"年龄\":30,\"是否党员\": true}";
	public static void JSONParse() {
	    //创建JSON解析器
	    JSONParser parser = new JSONParser();
	    try {  //解析JSON字符串
	        Object obj = parser.parse(json); 
	        //将解析结果转换为JSONObject
	        JSONObject jsonObject = (JSONObject) obj;
	        
	        //提取JSON字段值
	        String name = (String) jsonObject.get("姓名");
	        Number age = (Number) jsonObject.get("年龄");
	        Boolean flag = (Boolean) jsonObject.get("是否党员");
	        System.out.println("姓名: " + name);
	        System.out.println("年龄: " + age);
	        System.out.println("是否党员: " + flag);
	    } catch (ParseException e) {
	        e.printStackTrace();
	    }
	}
	
	/***JSONObject与Java中的Map***/
	public static void JSONToMap() {
	    //创建JSON解析器
	    JSONParser parser = new JSONParser();
	    try {
	        Object obj = parser.parse(json); 
	        //将解析结果转换为JSONObject
	        JSONObject jsonObject = (JSONObject) obj;
	        System.out.println(jsonObject);
	        System.out.println("*****************************");
	        // 将JSONObject转换为Map<String, Object>
	        Map<String, Object> resultMap = (Map<String, Object>)jsonObject;
	        // 输出转换后的Map
	        System.out.println(resultMap);
		} catch (ParseException e) {
	        e.printStackTrace();
		}

	}
	
	public static void main(String[] args) {
		JSONParse();
		JSONToMap();
	}
}

例程测试结果：
在这里插入图片描述
JSONParsingExample源码及所需JSON.simple.jar的JAR文件包

JSON程序，例程二：
解析 JSON 字符串并从中提取 JSONArray；向JSON数组中添加一个新的JSONObject。例程演示从下面这个JSON字符串中提取数组JSONArray；然后再往数组中增加数据，并展示更新结果。
{“姓名”: “雷锋”, “年龄”: 30, “是否党员”: true, “爱好”: [“阅读”, “音乐”, “运动”]}

例程源代码如下：

package json;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
/***解析 JSON 字符串并从中提取 JSONArray***/
public class JSONParsingExample02 {
	//定义一个JSON字符串
	static final String json =  "{\"姓名\":\"雷锋\",\"年龄\":30,\"是否党员\": true,\"爱好\": [\"阅读\", \"音乐\", \"运动\"]}";

	public static void getJSONArray() {
	    //创建JSON解析器
	    JSONParser parser = new JSONParser();
	    try {    //解析JSON字符串
	        Object obj = parser.parse(json); 
	        //将解析结果转换为JSONObject
	        JSONObject jsonObj = (JSONObject) obj;
	        // 获取JSONArray，如果不存在，则返回一个新的空JSONArray
	        JSONArray hobAry = jsonObj.containsKey("爱好") ? (JSONArray)jsonObj.get("爱好") : new JSONArray();
	        // 输出获取到的JSONArray
	        System.out.println(hobAry);
		} catch (ParseException e) {
	        e.printStackTrace();
		}
	}
	
	public static void addObjToJSONArray() {
	    //创建JSON解析器
	    JSONParser parser = new JSONParser();
	    try {    //解析JSON字符串
	        Object obj = parser.parse(json); 
	        //将解析结果转换为JSONObject
	        JSONObject jsonObj = (JSONObject) obj;
	        // 获取JSONArray，如果不存在，则返回一个新的空JSONArray
	        JSONArray hobAry = (JSONArray)jsonObj.get("爱好");
	        System.out.println("初始状态：");
	        System.out.println(jsonObj);
	        System.out.println(hobAry);
	        
	        hobAry.add("足球");
	        System.out.println("更新数组后：");
	        // 输出获取到的JSONArray
	        System.out.println(jsonObj);
	        System.out.println(hobAry);
		} catch (ParseException e) {
	        e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		getJSONArray();
		addObjToJSONArray();
	}
}

例程测试结果：
在这里插入图片描述
下面是一些程序示例，演示用程序编码JSON数据，和用程序展示 JSON 对象流：

使用JSONObject编码JSON数据，

	/***使用JSONObject编码JSON数据***/
	@SuppressWarnings("unchecked")
	public static void encodeJSONobject() {
		JSONObject obj = new JSONObject();
		obj.put("姓名","张三丰");
		obj.put("年龄",new Integer(68));
		obj.put("账户余额",new Double(1056.21));
		obj.put("是否VIP用户",new Boolean(true));
		obj.put("昵称","一生何求");
		System.out.println(obj); //直接打印
		
		//JSON转换为字符串流
		StringWriter out = new StringWriter();
		try {
			obj.writeJSONString(out);
		} catch (Exception e) {
			// TODO: handle exception
		}
		String jsonText = out.toString();
		System.out.println(jsonText);
	}

使用Map集合类编码JSON数据，JSON数据利用JSONValue以默认方式输出

	/***使用Map编码JSON数据***/
	public static void encodeJSONobjectMap() {	  
		Map<String, Object> obj = new LinkedHashMap<>();
		obj.put("姓名","张三丰");
		obj.put("年龄",new Integer(68));
		obj.put("账户余额",new Double(1000.21));
		obj.put("是否VIP用户",new Boolean(true));
		obj.put("昵称",null);
		
		System.out.println(obj); //直接打印格式不一样
		
		String jsonText = JSONValue.toJSONString(obj);
		System.out.println(jsonText);
	}

合并两个JSON对象

package json;
import org.json.simple.JSONObject;
public class MergeJSONobjects {
	public static void main(String[] args) {
		  JSONObject obj1 = new JSONObject();
		  obj1.put("姓名","姜建国");
		  obj1.put("卡号","62231600000100286");
		  obj1.put("余额",new Double(106288.58));
		                
		  JSONObject obj2 = new JSONObject();
		  obj2.put("是否vip客户",new Boolean(true));
		  obj2.put("昵称",null);

		  obj2.putAll(obj1);

		  System.out.print(obj2);
	}
}

合并两个JSON数组

package json;

import org.json.simple.JSONArray;

public class MergeJSONarray {

	public static void main(String[] args) {
		  JSONArray list1 = new JSONArray();
		  list1.add("土狗");
		  list1.add(new Integer(780));
		  list1.add(new Double(560.89));
		  
		  JSONArray list2 = new JSONArray();
		  list2.add(new Boolean(true));
		  list2.add(null);
		  list2.add("猫和老鼠");

		  list2.addAll(list1);

		  System.out.print(list2);
	}

}

编码带有数组的JSON数据对象

package json;
import java.io.StringWriter;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
public class EncodeJSONarray {
	static String name = "雷锋";
	static String[] hobby = {"阅读", "音乐", "运动"};
	
	public static void encodeJSONarray() {
		/***编码数组信息***/
		JSONArray list = new JSONArray();
		for (int i = 0; i < hobby.length; i++) {
			list.add(hobby[i]);
		}
		
		System.out.println(list);//默认输出
		
		/**JSON数组序列化数据流输出，效果同默认输出**/
		StringWriter out = new StringWriter();
		try {	
			list.writeJSONString(out);
		} catch (Exception e) {
			// TODO: handle exception
		}

		String jsonText = out.toString();
		System.out.println(jsonText);
	}
	
	public static void encodeJSONobj() {
		JSONObject obj = new JSONObject();
		obj.put("姓名",name);
		obj.put("年龄",new Integer(30));
		obj.put("是否党员",new Boolean(true));
		
		/***编码数组信息***/
		JSONArray list = new JSONArray();
		for (int i = 0; i < hobby.length; i++) {
			list.add(hobby[i]);
		}
		obj.put("爱好", list);
		
		System.out.println(obj);
	}

	public static void main(String[] args) {
		encodeJSONarray();
		encodeJSONobj();
	}
}

程序输出结果：
在这里插入图片描述

利用JSONAware，定制JSON数组的数据输出
说明：例程中的代码使用了转义字符。

package json;
import org.json.simple.JSONArray;
import org.json.simple.JSONAware;
import org.json.simple.JSONObject;
/***定制JSON输出***/
public class CustomizeJSONoutput {
	private JSONArray users;
	
	@SuppressWarnings("unchecked")
	public CustomizeJSONoutput() {
		users = new JSONArray();
		users.add(new User(1001,"张明", "passwd@6"));
		users.add(new User(2003,"王五", "psword$!"));
		users.add(new User(3001,"李四", "newsky&"));
	}
	
	public void jsonOutput() {
		System.out.println(users);
	}
	  
	public static void main(String[] args) {
		CustomizeJSONoutput output = new CustomizeJSONoutput();
		output.jsonOutput();
	}

	private class User implements JSONAware {
        private int id;
        private String name;
        private String password;
        
        public User(int id, String name, String password){
                this.id = id;
                this.name = name;
                this.password = password;
        }
        
        @Override
        public String toJSONString(){
            StringBuffer sbuf = new StringBuffer();
            
            sbuf.append("{");
            
            sbuf.append(JSONObject.escape("用户名"));
            sbuf.append(":");
            sbuf.append("\"" + JSONObject.escape(name) + "\"");
            
            sbuf.append(",");
            
            sbuf.append(JSONObject.escape("用户ID"));
            sbuf.append(":");
            sbuf.append(id);
            
            sbuf.append("}");
            
            return sbuf.toString();
        }
	}
}

利用JSONStreamAware，定制JSON数组的数据输出

package json;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.util.LinkedHashMap;
import org.json.simple.JSONArray;
import org.json.simple.JSONStreamAware;
import org.json.simple.JSONValue;
public class CustomJSONStreamValueExample {
    public static void main(String[] args) {
    	JSONArray students = new JSONArray();
    	students.add(new Student(1201,"雷锋", "newPswd"));
    	students.add(new Student(1202,"王继光", "ps@wd"));
    	students.add(new Student(1203,"罗盛教", "sup&wd"));
    	StringWriter out = new StringWriter();
    	try {
    		  students.writeJSONString(out);
		} catch (Exception e) {
			// TODO: handle exception
		}
    	  
    	System.out.println(out.toString());
    }
}

class Student implements JSONStreamAware {
    private int id;
    private String name;
    private String password;
    
    public Student(int id, String name, String password){
            this.id = id;
            this.name = name;
            this.password = password;
    }
    
   @Override
   public void writeJSONString(Writer out) throws IOException {
       LinkedHashMap<String, Object> obj = new LinkedHashMap<>();
       obj.put("姓名", name);
       obj.put("ID号", new Integer(id));
       JSONValue.writeJSONString(obj, out);
   } 
}

在这里插入图片描述

JSON数据输出到文件
示例程序1：JSON数据输出保存到文件，从文件读入JSON数据，并打印输出。JSONtoFileTest.java

/****把JSON格式数据输出到文件之一****/
package json;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Iterator;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
public class JSONtoFileTest {
	public static final String[] messages = {
		"民族英雄，左宗堂收复新疆，功成名就，永垂青史！",
		"民族英雄，岳飞精忠保国，壮志难酬，受陷害而死。作品《满江红 怒发冲冠》意难平，千古传诵。"	
	};
	public static final String[] names = {
		"左宗堂","岳飞"
	};
	public static final int[] ages = {100,60};
	public static void writeToFile(String file) {
		String path = "d:\\Temp\\"+file;
		JSONArray list = new JSONArray();
		for (int i = 0; i < 2; i++) {
			JSONObject obj = new JSONObject();
			obj.put("姓名", names[i]);
			obj.put("年龄", ages[i]);
			obj.put("信息", messages[i]);
			list.add(obj);
		}

		try { //"d:\\Temp\\test.json"
			FileWriter fileWriter = new FileWriter(path);
			fileWriter.write(list.toJSONString());
			fileWriter.flush();
			fileWriter.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println(list);		
	}


	public static void readFromFile(String file) {
		String path = "d:\\Temp\\"+file;
		JSONParser parser = new JSONParser();
		try {  //"d:\\Temp\\test.json"
			JSONArray list = (JSONArray)parser.parse(new FileReader(path));
			Iterator<JSONObject> iterator = list.iterator();
			JSONObject obj;
			String name;
			String message;
			long age;
			while (iterator.hasNext()) {
				obj = (JSONObject)(iterator.next());
				name = (String) obj.get("姓名");
				message = (String) obj.get("信息");
				age = (Long) obj.get("年龄");
				System.out.println("姓名:"+name+"  年龄:"+age);
				System.out.println("信息内容："+message);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}
	
	
	public static void main(String[] args) {
		String file = "test.json";
		writeToFile(file);
		System.out.println("******从文件中读入的信息内容：");
		readFromFile(file);
	}

}

程序测试结果：
在这里插入图片描述

示例程序2：JSON数据输出保存到文件，从文件读入JSON数据，并打印输出。JSONtoFile2.java

/****把JSON格式数据输出到文件之二****/
package json;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Iterator;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;

public class JSONtoFile2 {
	public static final String[] 爱好 = {
			"阅读", "音乐", "运动"
		};
		
	public static void writeToFile(String file) {
		String path = "d:\\Temp\\"+file;
		JSONObject object = new JSONObject();
		object.put("姓名", "雷锋");
		object.put("年龄", 30);
		object.put("是否党员", true);
		
		JSONArray list = new JSONArray();
		for (int i = 0; i < 爱好.length; i++) {
			list.add( 爱好[i] );
		}
		object.put("爱好", list);

		try { 
			FileWriter fileWriter = new FileWriter(path);
			fileWriter.write(object.toJSONString());
			fileWriter.flush();
			fileWriter.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println(object);
	}
	
	public static void readFromFile(String file) {
		String path = "d:\\Temp\\"+file;
		JSONParser parser = new JSONParser();
		try {  
			JSONObject object = (JSONObject)parser.parse(new FileReader(path));
			String name;
			boolean flag;
			long age;
			JSONArray list;
			
			name = (String) object.get("姓名");
			flag = (Boolean) object.get("是否党员");
			age = (Long) object.get("年龄");
			list = (JSONArray)object.get("爱好");
			
			String message = "爱好：";
			Iterator<String> iterator = list.iterator();
			while (iterator.hasNext()) {
				message += iterator.next()+'\t';
			}
			System.out.print("姓名:"+name+'\t');
			System.out.print("年龄:"+age+'\t');
			System.out.println("是否党员:"+flag);
			System.out.println(message);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		String file = "testB.json";
		writeToFile(file);
		System.out.println("******从文件中读入的信息内容：");
		readFromFile(file);
	}

}

程序测试结果：
在这里插入图片描述

容器工厂用法演示。使用容器来解码JSON数据。

package json;
//容器工厂用法演示
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.json.simple.JSONValue;
import org.json.simple.parser.ContainerFactory;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
//容器工厂用法演示
public class ContainerFactoryTest {

	public static void main(String[] args) {
		String jsonText = "{\"姓名\": \"雷锋\", \"年龄\": 30, \"是否党员\": true, \"爱好\": [\"阅读\", \"音乐\", \"运动\"]}";
		JSONParser parser = new JSONParser();
		ContainerFactory container = new ContainerFactory(){
		    public List<Object> creatArrayContainer() {
		        return new LinkedList<>();
		    }
		    
			public Map<Object, Object> createObjectContainer() {
			    return new LinkedHashMap<>();
			}
	  };
	  
	  try{
		   Map<Object, Object> map = (Map<Object, Object>)parser.parse(jsonText, container);
		   Iterator iter = map.entrySet().iterator();
		   System.out.println("==迭代结果==");

		   while(iter.hasNext()){
		      Map.Entry entry = (Map.Entry)iter.next();
		      System.out.println(entry.getKey() + "=>" + entry.getValue());
		   }
		                        
		   System.out.println("==toJSONString()==");
		   System.out.println(JSONValue.toJSONString(map));
		 }
	  catch(ParseException pe){
		    System.out.println(pe);
	  }
	}
}

程序测试结果：
在这里插入图片描述

类似SAX的解析器中的事件内容处理器演示

package json;
/***类似SAX的解析器中的事件内容处理器演示***/
import java.io.IOException;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.ContentHandler;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
public class ContentHandlerSAX implements ContentHandler {
	private Object value;
	private boolean found = false;
	private boolean end = false;
	private String key;
	private String matchKey;
	
	public void setMatchKey(String matchKey){
		this.matchKey = matchKey;
	}
	
	public Object getValue(){
		return value;
	}
	
	public boolean isEnd(){
		return end;
	}

	public void setFound(boolean found){
		 this.found = found;
	}
     
	public boolean isFound(){
		 return found;
	}
	  
	/***以下是重载方法***/
	@Override
	public boolean endArray() throws ParseException, IOException {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void endJSON() throws ParseException, IOException {
		end = true;
	}

	@Override
	public boolean endObject() throws ParseException, IOException {
		return true; 
	}

	@Override
	public boolean endObjectEntry() throws ParseException, IOException {
		return true;
	}

	@Override
	public boolean primitive(Object value) throws ParseException, IOException {
	    if(key != null){
	    	if(key.equals(matchKey)){
		        found = true;
		        this.value = value;
		        key = null;
		        return false;
	    	}
	    }
		return true;
	}

	@Override
	public boolean startArray() throws ParseException, IOException {
		return true;
	}

	@Override
	public void startJSON() throws ParseException, IOException {
	    found = false;
	    end = false;
	}

	@Override
	public boolean startObject() throws ParseException, IOException {
		return true;
	}

	@Override
	public boolean startObjectEntry(String key) throws ParseException, IOException {
	    this.key = key;
	    return true;
	}

	public static void main(String[] args) {
		String[] iDStrings = {"2001","2002","2003"}; 
		String[] names = {"雷锋","王继光","罗盛教"};
		
		JSONArray list = new JSONArray();
		JSONObject obj ;
		for (int i = 0; i < names.length; i++) {
			obj = new JSONObject();
			obj.put("编号", iDStrings[i]);
			obj.put("姓名", names[i]);
			list.add(obj);
		}
		System.out.println(list);

		/***分析JSON数据***/
		JSONParser parser = new JSONParser();
		ContentHandlerSAX finder = new ContentHandlerSAX();
		finder.setMatchKey("编号");
		try{
		    while(!finder.isEnd()){
		        parser.parse(list.toJSONString(), finder, true);
		        if(finder.isFound()){
		        	finder.setFound(false);
			        System.out.println("找到编号:");
			        System.out.println(finder.getValue());
		        }
		    }           
		}
		catch(ParseException pe){
		    pe.printStackTrace();
		}
	}
}