일반적인 JSON 구문 분석이 네이티브 된 JSONObject 및 JSONArray 방법을 가지고, 구글의 GSON 도서관, 알리 fastjson,이 잭슨, JSON-lib 디렉토리.
- GSON (프로젝트 주소 : HTTPS : //github.com/google/gson). GSON은 JSON 파싱 이슈 다목적 가장이다, GSON은 초기에는 구글의 자신의 R & D 구글에서 진화하면서 국내 수요에 대처하기 위해,하지만 공개적으로 2008 년 5 월 첫 번째 버전을 발표 이후이 회사는 사용자 나 응용 프로그램을 많이하고있다. 이 개 변환 기능, 종속성, 추가 JAR 예외와 GSON 응용 프로그램을 중심으로 fromJson toJson는 JDK에서 직접 실행할 수 있습니다. 그러나 객체 변환의이 유형을 사용하기 전에 먼저 좋은 객체를 생성해야하며, 회원은 성공적으로 해당 JSON 문자열 객체로 변환 성공합니다. 만큼의 JSON JSON 변환 콩에 GSON 복합 형 또는 콩은 JSON이 유물을 구문 분석 할 수 및 set 메소드를 얻을 클래스, 등.
- FastJson (프로젝트 주소 : HTTPS : //github.com/alibaba/fastjson). Fastjson 자바 언어는 알리바바가 개발 한 고성능 JSON 프로세서로 작성되었습니다. 더 의존, 추가 항아리 예외가 직접 JDK에서 실행할 수 없습니다. FastJson는 JSON 변환 오류, 참조에 대한 필요성을 결과, 문제의 일부는, 참조의 종류가 발생할 수 있습니다 JSON 변환 콩의 복합 형식에 나타납니다. 원래의 알고리즘을 사용하여 FastJson는 극단적 인 더 모든보다 JSON 라이브러리를 속도를 구문 분석합니다.
- 잭슨 (프로젝트 주소 : HTTPS : //github.com/FasterXML/jackson). 비교 JSON-lib 디렉토리 프레임은 잭슨 항아리 패키지는 사용하기 쉽지 의존하고 성능이 상대적으로 높아야한다. 그리고 잭슨 커뮤니티는 속도가 빠르고, 상대적으로 활성화됩니다. 복잡한 JSON 변환의 유형,지도, 변환 문제의 목록을 수집 잭슨 콩 원인 문제. 잭슨 대신에 표준의 콩 변환 JSON, JSON 형식으로 변환 JSON 형식의 복잡한 유형하십시오.
JSON-lib 디렉토리 (프로젝트 주소 : HTTP : //json-lib.sourceforge.net/index.html). JSON-lib 디렉토리의 시작은 가장 널리 사용되는 분석 도구 JSON, JSON-lib에는 나쁜 장소가 정말 공유지 - beanutils.jar, 평민 - 컬렉션 - 3.2.jar, 등 많은 타사 패키지에 의존 평민 - lang-입니다 복잡한 형식의 변환 2.6.jar, 가공 로깅-1.1.1.jar, ezmorph-1.0.6.jar, JSON-LIB는 JSON 빈 그러한 다른 클래스의 클래스 내에 발생 등이 결함을, 변환 목록이나지도 세트, JSON-lib 디렉토리 문제는 콩에서 JSON 변환에 발생한다. 기능과 위의 성능 JSON-lib 디렉토리는 이제 인터넷의 요구를 충족시킬 수 없다.
1 자바 분석적
- 된 JSONObject 구문 분석 JSON 객체
- 분석 JSON 배열 JSONArray
예컨대 JSON 문자열 :
{
"personData": [
{
"age": 12,
"name": "nate",
"schoolInfo": [
{
"School_name": "清华"
},
{
"School_name": "北大"
}
],
"url": "http://pic.yesky.com/uploadImages/2014/345/36/E8C039MU0180.jpg"
},
{
"age": 24,
"name": "jack",
···
}
],
"result": 1
}이러한 데이터 JSON 분석
- 제 1 층은 브레이스 괄호, 즉 jsonObect 오브젝트 및 personData JSONArray 어레이를 갖는 객체, 그 결과 특성 인
- 속성 외에 JSONArray의 schoolInfo 어레이가 personData JSONArray 어레이의 제 2 층,
- 세 번째는 내부 된 JSONObject 객체 schoolInfo JSONArray 배열이었다
해상도 :
public class Httpjson extends Thread {
private String url;
private Context context;
private ListView listView;
private JsonAdapter adapter;
private Handler handler;
public Httpjson(String url, ListView listView, JsonAdapter adapter, Handler handler) {
super();
this.url = url;
this.listView = listView;
this.adapter = adapter;
this.handler = handler;
}
@Override
public void run() {
URL httpUrl;
try {
httpUrl = new URL(url);
···
}
/**
* 从网络中获取JSON字符串，然后解析
* @param json
* @return
*/
private List<Person> jsonParse(String json) {
try {
List<Person> personlist = new ArrayList<Person>();
JSONObject jsonObject = new JSONObject(json);
int result = jsonObject.getInt("result");
if (result == 1) {
JSONArray jsonArray = jsonObject.getJSONArray("personData");
for (int i = 0; i < jsonArray.length(); i++) {
Person person = new Person();
JSONObject personData = jsonArray.getJSONObject(i);
int age = personData.getInt("age");
String url = personData.getString("url");
String name = personData.getString("name");
···
JSONArray schoolInfoArray = personData.getJSONArray("schoolInfo");
for (int j = 0; j < schoolInfoArray.length(); j++) {
JSONObject schoolInfojson = schoolInfoArray.getJSONObject(j);
String schoolName = schoolInfojson.getString("School_name");
···
}
···
}
return personlist;
} else {
Toast.makeText(context, "erro", Toast.LENGTH_SHORT).show();
}
} catch (JSONException e) {
e.printStackTrace();
Log.e("JsonParseActivity", "json解析出现了问题");
}
return null;
}
}2, GSON 해결
(1) 개요
GSON는 자바 객체와 JSON 데이터를 자바 클래스 라이브러리 사이의 매핑에 구글에 의해 제공됩니다. JSON 문자는 자바 객체로 변환, 또는 Java JSON 문자열로 할 수있다.
(2) 기능
- 빠르고 효율적인
- 적은 코드, 간결
- 객체 지향
- 분석 데이터 전송과 편리함
(3) 빈 클래스의 준비
같은 날짜로 키 이름, 안전이 필수의 대응에 함께 인의 빈 클래스 GSON 메이크 사용을 작성합니다. 두 번째는 클래스 클래스, 경험 대괄호는 ArrayList를 배열을 쓰기 작성하는 빈 클래스가 발생 중괄호입니다. 다음은 주요 규칙입니다! 클래스 클래스는 내부에 내부의 형태로 작성.
public class GsonParseMoGuBean {
public String data;
public String name;
public String packageName;
···
public ArrayList<SafeInfo> safe;
public class SafeInfo {
public String safeDes;
···
}
public ArrayList<String> screen;
}(4)의 형식 문자열은 JSON} {Java 오브젝트로 파싱
Java对象
/**
* //将json格式的字符窜{}转换为java对象
*/
private void jsonToJavaObjectByGson() {
//1获取或创建json数据
String json ="{\n" +
"\t\"id\":2, \"name\":\"大虾\", \n" +
"\t\"price\":12.3, \n" +
"\t\"imagePath\":\"http://192.168.10.165:8080/L05_Server/images/f1.jpg\"\n" +
"}\n";
//2解析json数据
Gson gson =new Gson();
//第一个参数是要解析的数据，第二个参数是解析生成的java对象的类
ShopInfo shopInfo = gson.fromJson(json, ShopInfo.class);
}(5)} {JSON 형식 문자열은 Java 오브젝트리스트로 파싱
private void jsonToJavaListByGson() {
//1获取或创建json数据
String json = "[\n" +
" {\n" +
" \"id\": 1,\n" +
" \"imagePath\": \"http://192.168.10.165:8080/f1.jpg\",\n" +
" \"name\": \"大虾 1\",\n" +
" \"price\": 12.3\n" + " },\n" + " {\n" +
" \"id\": 2,\n" +
" \"imagePath\": \"http://192.168.10.165:8080/f2.jpg\",\n" +
" \"name\": \"大虾 2\",\n" +
" \"price\": 12.5\n" + " }\n" +
"]";
//2解析json数据
Gson gson =new Gson();
//List<ShopInfo>：是要返回数据的集合
List<ShopInfo> shops = gson.fromJson(json,new TypeToken<List<ShopInfo>>(){}.getType());
//3显示数据
tv_gson_orignal.setText(json);
tv_gson_last.setText(shops.toString());
}(6) 자바 객체의 문자열 JSON 변환하는
private void javaToJSONByGson() {
//1获取或创建java数据
ShopInfo shopInfo = new ShopInfo(1,"鲍鱼",250.0,"baoyu");
//2生成json数据
Gson gson = new Gson();
String json = gson.toJson(shopInfo);
//3显示数据
tv_gson_orignal.setText(shopInfo.toString());
tv_gson_last.setText(json);
}(7)] [오브젝트리스트 자바 JSON 문자열로 변환되고
/**
* //将java对象的list转换为json字符窜
*/
private void javaToJSONArrayByGson() {
//1获取或创建java数据
List<ShopInfo> shops =new ArrayList<ShopInfo>();
ShopInfo baoyu = new ShopInfo(1,"鲍鱼",250.0,"baoyu");
ShopInfo longxia = new ShopInfo(1,"龙虾",250.0,"longxia");
shops.add(baoyu);
shops.add(longxia);
//2生成json数据
Gson gson = new Gson();
String json = gson.toJson(shops);
//3显示数据
tv_gson_orignal.setText(shops.toString());
tv_gson_last.setText(json);
}3 fastjson
(1) 개요
일상 자바 프로젝트 개발에서, JSON은 JSON 처리 도구 많은가보다 더 자주 사용된다. 그럼 당신은 알리 오픈 소스 JSON 프레임 워크 FastJson에 대해 지금 점점 개발자가 선호하는 고성능, 표준 JSON 라이브러리에 대한 완전한 기능을 완벽하게 지원, 알려주십시오.
(2) 기능
Fastjson는 자바 언어로 잘 쓰여진 고성능 JSON 라이브러리를 제공합니다. 그것은는 "가정 신속하고 질서에 맞게"알고리즘, 극도로 JSONParse 성능을 사용하는 가장 빠른 JSON 자바 라이브러리입니다.
자바 객체로 (4) {} 문자열 JSON 형식
private void jsonToJavaObjectByFastJson() {
// 1 获取或创建 JSON 数据
String json = "{\n" +
"\t\"id\":2, \"name\":\"大虾\", \n" +
"\t\"price\":12.3, \n" +
"\t\"imagePath\":\"http://192.168.10.165:8080/L05_Server/images/f1.jpg\ "\n" +
"}\n";
// 2 解析 JSON 数据
ShopInfo shopInfo = JSON.parseObject(json, ShopInfo.class);
}(4) 형식 문자열 JSON [] 자바 개체 목록에
private void jsonToJavaListByFastJson() {
// 1 获取或创建 JSON 数据
String json = "[\n" +
" {\n"+
" \"id\": 1,\n" +
" \"imagePath\":
\"http://192.168.10.165:8080/f1.jpg\",\n" +
" " " " " "
\"name\": \"大虾 1\",\n" +
\"price\": 12.3\n" + },\n" +
{\n"+
\"id\": 2,\n" + \"imagePath\":
\"http://192.168.10.165:8080/f2.jpg\",\n" +
" \"name\": \"大虾 2\",\n" +
" \"price\": 12.5\n" + " }\n"+
"]";
// 2 解析 JSON 数据
List<ShopInfo> shopInfos = JSON.parseArray(json, ShopInfo.class);
}(5) 변환 자바는 JSON 문자열을 객체
private void javaToJsonObjectByFastJson() {
// 1 获取 Java 对象
ShopInfo shopInfo = new ShopInfo(1, "鲍鱼", 250.0, "baoyu");
// 2 生成 JSON 数据
String json = JSON.toJSONString(shopInfo);
// 3 数据显示 tv_fastjson_orignal.setText(shopInfo.toString()); tv_fastjson_last.setText(json);
}(7)에서 자바 문자열 JSON 대상물 변환 []
private void javaToJsonArrayByFastJson() {
// 1 获取 Java 集合
List<ShopInfo> shops = new ArrayList<>();
ShopInfo baoyu = new ShopInfo(1, "鲍鱼", 250.0, "baoyu");
ShopInfo longxia = new ShopInfo(2, "龙虾", 251.0, "longxia"); shops.add(baoyu);
shops.add(longxia);
// 2 生成 JSON 数据
String json = JSON.toJSONString(shops);
// 3 数据显示 tv_fastjson_orignal.setText(shops.toString()); tv_fastjson_last.setText(json);
}4, 성능 비교
고려해야 할 여러 측면에서 적절한 JSON 라이브러리를 선택합니다 :
- 구문 분석 성능 JSON을 문자열
- 구문 분석 성능 자바 빈즈에 문자열
- JSON 구조 자바 빈즈 속성
- 성능의 설정을 구성 JSON
- 의 용이성
쓰기 성능 테스트는
다음 네 가지 성능 테스트 코드 라이브러리를 쓰기 시작합니다.
(1) 의존성을 추가 받는다는
먼저 공평하게, 나는 그들 모두 최신 버전을 사용, 물론 네 개의 추가 받는다는 저장소에 따라 달라집니다 :
<!-- Json libs-->
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>2.4</version>
<classifier>jdk15</classifier>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.2</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.46</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.4</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.4</version>
</dependency>(2) 네 개의 라이브러리 도구
자바 FastJsonUtil.java
public class FastJsonUtil { public static String bean2Json(Object obj) { return JSON.toJSONString(obj); }
public static <T> T json2Bean(String jsonStr, Class<T> objClass) {
return JSON.parseObject(jsonStr, objClass);
}
}자바 GsonUtil.java
public class GsonUtil {
private static Gson gson = new GsonBuilder().create();
public static String bean2Json(Object obj) {
return gson.toJson(obj);
}
public static <T> T json2Bean(String jsonStr, Class<T> objClass) {
return gson.fromJson(jsonStr, objClass);
}
public static String jsonFormatter(String uglyJsonStr) {
Gson gson = new GsonBuilder().setPrettyPrinting().create();
JsonParser jp = new JsonParser();
JsonElement je = jp.parse(uglyJsonStr);
return gson.toJson(je);
}
}자바 JacksonUtil.java
public class JacksonUtil { private static ObjectMapper mapper = new ObjectMapper();
public static String bean2Json(Object obj) {
try {
return mapper.writeValueAsString(obj);
} catch (JsonProcessingException e) {
e.printStackTrace();
return null;
}
}
public static <T> T json2Bean(String jsonStr, Class<T> objClass) {
try {
return mapper.readValue(jsonStr, objClass);
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
}
자바 JsonLibUtil.java
public class JsonLibUtil {
public static String bean2Json(Object obj) {
JSONObject jsonObject = JSONObject.fromObject(obj);
return jsonObject.toString();
}
@SuppressWarnings("unchecked")
public static <T> T json2Bean(String jsonStr, Class<T> objClass) {
return (T) JSONObject.toBean(JSONObject.fromObject(jsonStr), objClass);
}
}(3) 제조 모델 클래스
클래스가하면 FullName 날짜, 목록,지도 및 사용자 정의 최대 범위의 시뮬레이션 실제 시나리오를 속성 동안 나는 여기, 간단한 Person 클래스를 썼다.
public class Person {
private String name;
private FullName fullName;
private int age;
private Date birthday;
private List<String> hobbies;
private Map<String, String> clothes;
private List<Person> friends;
// getter/setter省略
@Override
public String toString() {
StringBuilder str = new StringBuilder("Person [name=" + name + ", fullName=" + fullName + ", age="
+ age + ", birthday=" + birthday + ", hobbies=" + hobbies
+ ", clothes=" + clothes + "]\n");
if (friends != null) {
str.append("Friends:\n");
for (Person f : friends) {
str.append("\t").append(f);
}
}
return str.toString();
}
}public class FullName {
private String firstName;
private String middleName;
private String lastName;
public FullName() {
}
public FullName(String firstName, String middleName, String lastName) {
this.firstName = firstName;
this.middleName = middleName;
this.lastName = lastName;
}
// 省略getter和setter
@Override
public String toString() {
return "[firstName=" + firstName + ", middleName="
+ middleName + ", lastName=" + lastName + "]";
}
}(4) 기준 JSON 직렬화
@BenchmarkMode(Mode.SingleShotTime)
@OutputTimeUnit(TimeUnit.SECONDS)
@State(Scope.Benchmark)
public class JsonSerializeBenchmark {
/**
* 序列化次数参数
*/
@Param({"1000", "10000", "100000"})
private int count;
private Person p;
public static void main(String[] args) throws Exception {
Options opt = new OptionsBuilder()
.include(JsonSerializeBenchmark.class.getSimpleName())
.forks(1)
.warmupIterations(0)
.build();
Collection<RunResult> results = new Runner(opt).run();
ResultExporter.exportResult("JSON序列化性能", results, "count", "秒");
}
@Benchmark
public void JsonLib() {
for (int i = 0; i < count; i++) {
JsonLibUtil.bean2Json(p);
}
}
@Benchmark
public void Gson() {
for (int i = 0; i < count; i++) {
GsonUtil.bean2Json(p);
}
}
@Benchmark
public void FastJson() {
for (int i = 0; i < count; i++) {
FastJsonUtil.bean2Json(p);
}
}
@Benchmark
public void Jackson() {
for (int i = 0; i < count; i++) {
JacksonUtil.bean2Json(p);
}
}
@Setup
public void prepare() {
List<Person> friends=new ArrayList<Person>();
friends.add(createAPerson("小明",null));
friends.add(createAPerson("Tony",null));
friends.add(createAPerson("陈小二",null));
p=createAPerson("邵同学",friends);
}
@TearDown
public void shutdown() {
}
private Person createAPerson(String name,List<Person> friends) {
Person newPerson=new Person();
newPerson.setName(name);
newPerson.setFullName(new FullName("zjj_first", "zjj_middle", "zjj_last"));
newPerson.setAge(24);
List<String> hobbies=new ArrayList<String>();
hobbies.add("篮球");
hobbies.add("游泳");
hobbies.add("coding");
newPerson.setHobbies(hobbies);
Map<String,String> clothes=new HashMap<String, String>();
clothes.put("coat", "Nike");
clothes.put("trousers", "adidas");
clothes.put("shoes", "安踏");
newPerson.setClothes(clothes);
newPerson.setFriends(friends);
return newPerson;
}
}위의 코드 설명
ResultExporter.exportResult("JSON序列化性能", results, "count", "秒");이것은 내가 다음 Echarts에게지도를 작성하여 성능 테스트 보고서 데이터의 PNG 이미지를 내보낼 쓴 방법입니다, 내가 특정 코드를 넣어하지 않을 것이다, 내 github의 소스를 참조하십시오.
구현 차트의 결과 후 :
위의 테스트 결과에서 볼 수 있듯이 100000, GSON 잭슨과 FASTJSON 세부 사항보다 약한로 시간을 증가 할 때, GSON 최고의 성능,이 속성에 해당하는 경우, 시퀀스의 수는 적은 경우 FASTJSON 가축도 할 수있다 에 관계없이 수의 이하 등을 참조 잭슨은 뛰어난 성능이었다. 그리고 그 재미 JSON-lib 디렉토리하는 것입니다. ^ _ ^
(5) JSON 직렬화 성능 벤치 마크
@BenchmarkMode(Mode.SingleShotTime)
@OutputTimeUnit(TimeUnit.SECONDS)
@State(Scope.Benchmark)
public class JsonDeserializeBenchmark {
/**
* 反序列化次数参数
*/
@Param({"1000", "10000", "100000"})
private int count;
private String jsonStr;
public static void main(String[] args) throws Exception {
Options opt = new OptionsBuilder()
.include(JsonDeserializeBenchmark.class.getSimpleName())
.forks(1)
.warmupIterations(0)
.build();
Collection<RunResult> results = new Runner(opt).run();
ResultExporter.exportResult("JSON反序列化性能", results, "count", "秒");
}
@Benchmark
public void JsonLib() {
for (int i = 0; i < count; i++) {
JsonLibUtil.json2Bean(jsonStr, Person.class);
}
}
@Benchmark
public void Gson() {
for (int i = 0; i < count; i++) {
GsonUtil.json2Bean(jsonStr, Person.class);
}
}
@Benchmark
public void FastJson() {
for (int i = 0; i < count; i++) {
FastJsonUtil.json2Bean(jsonStr, Person.class);
}
}
@Benchmark
public void Jackson() {
for (int i = 0; i < count; i++) {
JacksonUtil.json2Bean(jsonStr, Person.class);
}
}
@Setup
public void prepare() {
jsonStr="{\"name\":\"邵同学\",\"fullName\":{\"firstName\":\"zjj_first\",\"middleName\":\"zjj_middle\",\"lastName\":\"zjj_last\"},\"age\":24,\"birthday\":null,\"hobbies\":[\"篮球\",\"游泳\",\"coding\"],\"clothes\":{\"shoes\":\"安踏\",\"trousers\":\"adidas\",\"coat\":\"Nike\"},\"friends\":[{\"name\":\"小明\",\"fullName\":{\"firstName\":\"xxx_first\",\"middleName\":\"xxx_middle\",\"lastName\":\"xxx_last\"},\"age\":24,\"birthday\":null,\"hobbies\":[\"篮球\",\"游泳\",\"coding\"],\"clothes\":{\"shoes\":\"安踏\",\"trousers\":\"adidas\",\"coat\":\"Nike\"},\"friends\":null},{\"name\":\"Tony\",\"fullName\":{\"firstName\":\"xxx_first\",\"middleName\":\"xxx_middle\",\"lastName\":\"xxx_last\"},\"age\":24,\"birthday\":null,\"hobbies\":[\"篮球\",\"游泳\",\"coding\"],\"clothes\":{\"shoes\":\"安踏\",\"trousers\":\"adidas\",\"coat\":\"Nike\"},\"friends\":null},{\"name\":\"陈小二\",\"fullName\":{\"firstName\":\"xxx_first\",\"middleName\":\"xxx_middle\",\"lastName\":\"xxx_last\"},\"age\":24,\"birthday\":null,\"hobbies\":[\"篮球\",\"游泳\",\"coding\"],\"clothes\":{\"shoes\":\"安踏\",\"trousers\":\"adidas\",\"coat\":\"Nike\"},\"friends\":null}]}";
}
@TearDown
public void shutdown() {
}
}구현 차트의 결과 후 :
상기 시험 결과에서 알 수있는 바와 같이, 또는 JSON-lib 디렉토리 재미 계속 직렬화 시간, GSON, 잭슨과 FastJson 매우 다르지 않다, 매우 좋은 성능, 그리고있다.
재판 문 : 성능 비교는 고객이 부분에 곰 © 먼지 곰 블로그 비행을 만들 수 있습니다.