fastjson_fastjson 类名 - CSDN
  • fastjson是阿里的一款对Json处理的工具,使用前需要引入对应的jar包下载地址 本人感觉还是非常强悍的,比Gson使用起来更加的强大 package json; import java.util.ArrayList; import java.util.HashMap; import ...

    fastjson是阿里的一款对Json处理的工具,使用前需要引入对应的jar包下载地址

    本人感觉还是非常强悍的,比Gson使用起来更加的强大

    package json;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import com.alibaba.fastjson.JSON;
    
    public class FastJsonDemo {
    
    	//对象转Json
    	public static String ClassToJson() {
    		User user = new User();
    		user.setId("1");
    		user.setName("王二麻子");
    		String json = JSON.toJSONString(user);
    		return json;
    		
    	}
    	
    	//Json转对象
    	public static User JsonToClass() {
    		String classJson = ClassToJson();
    		User user = JSON.parseObject(classJson,User.class);
    		return user;
    	}
    	
    	//List转Json
    	public static String ListToJson() {
    		List<User> userList = new ArrayList<>();
    		userList.add(new User("1","王一麻子"));
    		userList.add(new User("2","王二麻子"));
    		userList.add(new User("3","王三麻子"));
    		userList.add(new User("4","王四麻子"));
    		userList.add(new User("5","王五麻子"));
    		userList.add(new User("6","王六麻子"));
    		String json = JSON.toJSONString(userList);
    		return json;
    		
    	}
    	
    	//Json转List
    	public static List<User> JsonToList(){
    		String listJson = ListToJson();
    		List<User> userList = JSON.parseArray(listJson,User.class);
    		return userList;
    	}
    	
    	//parse这个方法比较通用,但是无法精确泛型
    	public static List JsonToList2() {
    		String listJson = ListToJson();
    		List userList = (List)JSON.parse(listJson);
    		return userList;
    	}
    	
    	//Map转Json
    	public static String MapToJson() {
    		Map<String,User> map = new HashMap<>();
    		map.put("大哥", new User("1","李狗蛋子"));
    		map.put("二哥", new User("2","李猫蛋子"));
    		map.put("三哥", new User("3","李竹鼠蛋子"));
    		String json = JSON.toJSONString(map);
    		return json;
    	}
    	
    	//Json转Map
    	public static Map JsonToMap() {
    		String mapJson = MapToJson();
    		Map map = (Map)JSON.parseObject(mapJson,Map.class);
    		return map;
    	}
    	
    	//通用的方法,但是无法确定泛型
    	public static Map JsonToMap2() {
    		String mapJson = MapToJson();
    		//这2中写法都非常通用
    		//Map map = (Map)JSON.parse(mapJson);
    		Map map = JSON.parseObject(mapJson);
    		return map;
    	}
    	
    	public static void main(String[] args) {
    		System.out.println(ClassToJson());//对象转Json
    		System.out.println(JsonToClass());//Json转对象
    		System.out.println(ListToJson());//List转Json
    		JsonToList().forEach(x->System.out.println(x));//Json转List集合
    		System.out.println(MapToJson());//Map转Json
    		JsonToMap().forEach((x,y) -> {System.out.println(x+":"+y);});//Json转Map
    	}
    }
    

     

    package json;
    
    public class User {
    
    	private String id;
    	private String name;
    	
    	public User() {
    		super();
    	}
    	public User(String id, String name) {
    		super();
    		this.id = id;
    		this.name = name;
    	}
    	public String getId() {
    		return id;
    	}
    	public void setId(String id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	@Override
    	public String toString() {
    		return "User [id=" + id + ", name=" + name + "]";
    	}
    	
    	
    }
    

     

    展开全文
  • FastJson的介绍与使用(一)

    万次阅读 2018-04-11 18:31:12
    FastJson的介绍与使用(一)1.FastJson背景: FastJson是啊里巴巴的的开源库,用于对JSON格式的数据进行解析和打包。2.FastJson介绍: FastJson特点如下: (1)能够支持将java bean序列化成JSON字符串,也能够将...

    FastJson的介绍与使用(一)

    1.FastJson背景:

          FastJson是啊里巴巴的的开源库,用于对JSON格式的数据进行解析和打包。

    2.FastJson介绍:

           FastJson特点如下:

            (1)能够支持将java bean序列化成JSON字符串,也能够将JSON字符串反序列化成Java bean。

            (2)顾名思义,FastJson操作JSON的速度是非常快的。

            (3)无其他包的依赖。

            (4)使用比较方便。

    3.FastJson的使用

        在Maven项目中使用FastJson库,需要提前在Maven的配置文件中添加此FastJson包的依赖,如pom.xml文件。

    添加下面的依赖:

        

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

    在添加完依赖之后,便可以使用FastJson来解析Json报文和打包Json报文了。

    使用FastJson解析Json报文需要用到:

    public static JSONObject parseObject(String text)

    这个方法支持将JSON报文转换成JSONObect结构体。

    请看下面示例:

    @Test
    public void testParseObject() {
        String json = "{\"name\":\"json\",\"num\":1.02}";
        JSONObject jsonObject = JSONObject.parseObject(json);
    }

    调试输出得到:


    在将JSON转换成JSONObject类之后,便可从这个类中获取每个字段的数据了:

    @Test
    public void testParseObject() {
        String json = "{\"name\":\"json\",\"num\":1.02}";
        JSONObject jsonObject = JSONObject.parseObject(json);
    
        //获取name字段的值
        System.out.println(jsonObject.getString("name"));
        //获取num字段的值
        System.out.println(jsonObject.getDouble("num"));
    }

    结果如下:


    这样操作起来就比较方便。当然FastJson还有许多方法,这个去看API就可以了,都大同小异。

    下面说一下,如何将Java bean转换成Json报文,这个其实比以上使用起来更加简单。

    需要将Java bean转换成Json报文需要使用以下方法:

    public static String toJSONString(Object object, SerializeConfig config, SerializerFeature... features)

    第一个参数是需要传进的java bean类,第二个参数是序列化配置类(具体看API说明),用到序列化配置类的情况最常见的就是浮点型数据格式化的问题,这个下面会有例子进行说明。

    测试用到的java bean类如下:

    class Bean {
        private double num=1.02;
        private String name = "json";
    
        public double getNum() {
            return num;
        }
    
        public void setNum(double num) {
            this.num = num;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }

    转换为Json报文方法如下:

    @Test
    public void testFastJson() {
        Bean bean = new Bean();
        String text = JSON.toJSONString(bean);
    
        System.out.println(text);
    
    }

    主要传进类就可以了,序列化配置可以不传。

    输出结果如下:


    就是这么简单,就可以把Java Bean转换成Json字符串了。

    或许你看到这里,就很想知道SerializeConfig这里类有什么用了。

    下面我们以一个简单的例子来说明一下:

    比如,如果前端传过来的浮点型数据是1,那么在FastJson序列化成java bean的时候,就是1.0了,不信?看下面例子:

    @Test
    public void testParseObject() {
        //这里模拟输入的值是1
        String json = "{\"name\":\"json\",\"num\":1}";
        JSONObject jsonObject = JSONObject.parseObject(json);
    
        //获取name字段的值
        System.out.println(jsonObject.getString("name"));
        
        //获取num字段的值,这里打印出来的是1.0
        System.out.println(jsonObject.getDouble("num"));
    }

    输出结果如下:


    所以,这个时候就需要用到SerializeConfig这个序列化配置类啦。

    使用序列化配置类后,我们就可以对浮点数进行格式化,以保证传回的Json报文字段的格式和接收是一样的。

    我们可以这样写一个配置类:

    @Test
    public void testParseObject() {
        //这里模拟输入的值是1
        String json = "{\"name\":\"json\",\"num\":1}";
        Bean bean = new Bean();
    
        //获取解包后的值
        JSONObject jsonObject = JSONObject.parseObject(json);
        bean.setNum(jsonObject.getDouble("num"));
        bean.setName(jsonObject.getString("name"));
    
        //打印调试
        System.out.println("解包出来后的值:");
        System.out.println(bean.getName());
        System.out.println(bean.getNum());
    
        //构造序列化配置类
        SerializeConfig config = new SerializeConfig();
    
        //配置需要格式化的Double    config.put(Double.class, new DoubleSerializer(new DecimalFormat("#.##")));
    
        //打包Json报文
        String text = JSON.toJSONString(bean, config);
        System.out.println("打包出来后的值:");
        System.out.println(text);
    }

    输出结果如下:

      

    这样就可以保证接收和响应的格式是一致的啦。

    以上的都是FastJson的基本使用,FastJson的背景介绍参考了https://www.w3cschool.cn/fastjson/fastjson-api.html,有需要的,可以到这里查看FastJson Api中文版的说明。

    以上所涉及的说明和技术,如果错误,麻烦各位指出,共同成长,谢谢。

    展开全文
  • Json详解以及fastjson使用教程

    万次阅读 多人点赞 2018-09-10 10:13:47
    Json是一种轻量级的数据交换格式,采用一...下面我们就简单讲一下Json的使用以及fastjson.jar包的使用。 一:JSON形式与语法 1.1:JSON对象 我们先来看以下数据: { "ID": 1001, "name"...

    Json是一种轻量级的数据交换格式,采用一种“键:值”对的文本格式来存储和表示数据,在系统交换数据过程中常常被使用,是一种理想的数据交换语言。在使用Java做Web开发时,不可避免的会遇到Json的使用。下面我们就简单讲一下Json的使用以及fastjson.jar包的使用。

    一:JSON形式与语法

    1.1:JSON对象

    我们先来看以下数据:

    {
    	"ID": 1001,
    	"name": "张三",
    	"age": 24
    }

    第一个数据就是一个Json对象,观察它的数据形式,可以得出以下语法:

    1:数据在花括号中

    2:数据以"键:值"对的形式出现(其中键多以字符串形式出现,值可取字符串,数值,甚至其他json对象)

    3:每两个"键:值"对以逗号分隔(最后一个"键:值"对省略逗号)

    遵守上面3点,便可以形成一个json对象。

    1.2:JSON对象数组

    接下来我们再看第二个数据,观察它的数据形式,可以得出以下语法:

    [
    	{"ID": 1001, "name": "张三", "age": 24},
    	{"ID": 1002, "name": "李四", "age": 25},
    	{"ID": 1003, "name": "王五", "age": 22}
    
    ]

    1:数据在方括号中(可理解为数组)

    2:方括号中每个数据以json对象形式出现

    3:每两个数据以逗号分隔(最后一个无需逗号)

    遵守上面3点,便可形成一个json对象数组(及一个数组中,存储了多个json对象)

    理解了上面两种基本的形式,我们就可以得出其他的数据形式,例如下面这个:

    {
    	"部门名称":"研发部",
    	"部门成员":[
    	{"ID": 1001, "name": "张三", "age": 24},
    	{"ID": 1002, "name": "李四", "age": 25},
    	{"ID": 1003, "name": "王五", "age": 22}],
    	"部门位置":"xx楼21号"
    }

    这是上面两个基本形式结合出来的一种变形,通过这种变形,使得数据的封装具有很大的灵活性,能让开发者自由的发挥想象力。

    1.3:JSON字符串

    JSON字符串也是在平时开发中使用较多的,json字符串应满足以下条件:

    1:它必须是一个字符串,由" "或者' '包裹数据,支持字符串的各种操作

    2:里面的数据格式应该要满足其中一个格式,可以是json对象,也可以是json对象数组或者是两种基本形式的组合变形。

    总结:json可以简单的分为基本形式:json对象,json对象数组。两种基本格式组合变形出其他的形式,但其本质还是json对象或者json对象数组中的一种。json对象或对象数组可以转化为json字符串,使用于不同的场合。

    注意点:在封装json数据的时候,很容易出现错误,比如粗心的在最后一条数据的末尾加上了逗号等等,这里我提供一个在线验证工具,方便大家验证json数据格式的正确性

    http://www.bejson.com/

    二:fastjson介绍与使用

    2.1:fastjson简介与jar下载

    fastjson.jar是阿里爸爸开发的一款专门用于Java开发的包,可以方便的实现json对象与JavaBean对象的转换,实现JavaBean对象与json字符串的转换,实现json对象与json字符串的转换。除了这个fastjson以外,还有Google开发的Gson包,其他形式的如net.sf.json包,都可以实现json的转换。方法名称不同而已,最后的实现结果都是一样的。

    将json字符串转化为json对象
    在net.sf.json中是这么做的
    JSONObject obj = new JSONObject().fromObject(jsonStr);//将json字符串转换为json对象
    
    在fastjson中是这么做的
    JSONObject obj=JSON.parseObject(jsonStr);//将json字符串转换为json对象

    今天我们主要讲fastjson的使用,首先应该在Java工程中导入对应的fastjson.jar包,

    fastjson.jar包原始下载地址:https://github.com/alibaba/fastjson

    点击页面中的download即可下载最新的包

    fastjson.jar包百度云盘下载地址:https://pan.baidu.com/s/1CCGoRCdSjNUDB736cRCDBw

    2.2:fastjson源码分析与使用

    在包中,可以发现主要的3个类,JSON,JSONArray,JSONObject

    三者之间的关系如下,JSONObject和JSONArray继承JSON

    如果你们看不到源代码,请参考另一篇博客,先安装Java反编译工具:

    https://blog.csdn.net/srj1095530512/article/details/81587601

    联系上面讲到的json基础知识并对应这三个类,可以发现,JSONObject代表json对象,JSONArray代表json对象数组,

    JSON代表JSONObject和JSONArray的转化。

    JSONObject类源码分析与使用

    观察该类的继承与实现关系,不难发现,JSONObject实现了Map接口,而json对象中的数据都是以"键:值"对形式出现,可以猜想,      JSONObject底层操作是由Map实现的。

    再来看类中的主要方法:

    类中主要是get()方法。因为JSONObject相当于json对象,所以该类中主要封装了各种get方法,通过"键:值"对中的键来获取其对应的值。且方法的输入参数几乎皆为String类型,这是因为json对象中,"键:值"对的键都是String类型的。来看一下平时用到较多的               getString(String key)方法,该方法输入参数为String key(键),输出为String ,用于获取json对象中的字符串型数据。例如通过该方法获取  "name":"bob"键值对中name这个键所对应的值bob。

    看其源码,可以发现,内部主要是由get(key)方法实现,找到这个方法如下:

    发现内部主要由Map接口中的get()方法实现。

    再去看JSONObject中另一个常用的方法getInteger(String key),该方法获取json对象中的整型数据,例如获取"age:20"键值对中age对应的整型数值20.

    对比getString(String key)方法,两者极为相似,都是通过Map接口的get()方法实现。

    再看几个其他的方法,也是由Map接口中的相应方法实现的,这里不再赘述。

    总结:JSONObject对应json对象,通过各种形式的get()方法可以获取json对象中的数据,也可利用诸如size(),isEmpty()等方法获取"键:值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。

    JSONArray类源码分析与使用

    观察JSONArray的继承与实现,并结合上面对JSONObject的分析,不难发现,其内部是有List接口中的方法来完成操作的。

    同样观察JSONArray类中的方法,由于方法较多,下面分为两部分

    首先来明确一点,因为JSONArray代表json对象数组,json数组对象中存储的是一个个json对象,所以类中的方法主要用于直接操作json对象。比如这其中的add(),remove(),containsAll()方法,对应于json对象的添加,删除与判断。

    其内部主要有List接口中的对应方法来实现。

    跟JSONObject一样,JSONArray里面也有一些get()方法,不过都不常用,最有用的应该是getJSONObject(int index)方法,该方法用于获取json对象数组中指定位置的JSONObject对象,配合size()方法,可用于遍历json对象数组中的各个对象。

    通过以上两个方法,在配合for循环,即可实现json对象数组的遍历,当然JSONArray中也实现了迭代器方法来遍历,这和List的遍历极为相似。

    通过遍历得到JSONObject对象,然后再利用JSONObject类中的get()方法,即可实现最终json数据的获取!!!

    好了,接下来我们看最后一个,也是最重要的一个类JSON类。之所以把这个放在最后,是因为这个类主要是实现转化用的,最后的数据获取,还是要通过上面的JSONObject和JSONArray来实现。

    JSON类源码分析与使用

    先来看一下这个类中的主要方法,方法比较多,也分为两部分:

    仔细观察这些方法,主要是实现json对象,json对象数组,javabean对象,json字符串之间的相互转化。

    JSON类之toJSONString()方法,实现json对象转化为json字符串和javabean对象转化为json 字符串

    该方法经过多次重载,但最终都是实现json对象转化为json字符串和javabean对象转化为json 字符串。其中,有关键字transient修饰的toJSONString()用于json对象序列化过程中,希望某个"键:值"对数据不变的应用中。

    JSON类之parseObject()方法,实现json字符串转换为json对象或javabean对象

    该方法返回JSONObject对象,用于实现json字符串向json对象的转化,其内部调用了parse()方法,调用底层的DefaultJSONParser解析类进行转化,在转化失败时,抛出can not cast to JSONObject异常。

    该方法不仅能实现json字符串向json对象的转化,经过重载之后,还能实现json字符串向javabean对象的转化

    json字符串与javaBean之间的转换可以使用 TypeReference<T> 这个类,也可以使用Class这个类。

    Student stu1=JSON.parseObject(jsonstr,new TypeReference<Student>(){});
    Student stu1=JSON.parseObject(jsonstr,Student.class);

    我推荐使用第二种Class类反射来实现,比较简单。

    JSON类之JSONArray()方法,实现json字符串转化为json对象数组或List<T>

    与parseObject()方法类似,parseArray()将json字符串转化为json对象数组或转化成包含泛型的List

    JSON类之toJSON()方法,实现javabean对象转化为json对象

    该方法用的比较少,主要用于将javabean对象转化为json对象,内部通过Map,LinkedHashMap,HashMap等集合接口实现。

    JSON类之toJavaObject()方法,实现json对象转化为javabean对象

    该方法也经过重载,通过TypeReference类和Class类反射来实现,主要讲json对象转化为javabean对象,用的也比较少。

    至此,JSON类中的方法也讲解的差不多了,下面给出Java实例来实现以上的各种转换。

    测试类:

    package jsonTest;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONArray;
    import com.alibaba.fastjson.JSONObject;
    import com.alibaba.fastjson.TypeReference;
    
    
    public class MyJson {
    	
    	public static void main(String[] args) {
    		
    		List<Student> list=new ArrayList<>();
    		Student student=new Student("bob",24);
    		Student student12=new Student("lily", 23);
    		list.add(student);
    		list.add(student12);
    		System.out.println("*******javaBean  to jsonString*******");
    		String str1=JSON.toJSONString(student);
    		System.out.println(str1);
    		System.out.println(JSON.toJSONString(list));
    		System.out.println();
    		
    		System.out.println("******jsonString to javaBean*******");
    		//Student stu1=JSON.parseObject(str1,new TypeReference<Student>(){});
    		Student stu1=JSON.parseObject(str1,Student.class);
    		System.out.println(stu1);
    		System.out.println();
    		
    		System.out.println("******javaBean to jsonObject******");
    		JSONObject jsonObject1=(JSONObject)JSON.toJSON(student);
    		System.out.println(jsonObject1.getString("name"));
    		System.out.println();
    		
    		System.out.println("******jsonObject to javaBean******");
    		Student student2=JSON.toJavaObject(jsonObject1, Student.class);
    		System.out.println(student2);
    		System.out.println();
    		
    		System.out.println("*******javaBean to jsonArray******");
    		List<Student> stulist=new ArrayList<>();
    		for(int i=0;i<5;i++){
    			stulist.add(new Student("student"+i, i));
    			
    		}
    		JSONArray jsonArrays=(JSONArray)JSON.toJSON(stulist);
    		for(int i=0;i<jsonArrays.size();i++){
    		System.out.println(jsonArrays.getJSONObject(i));
    		}
    		System.out.println();
    		
    		System.out.println("*****jsonArry to javalist******");
    		List<Student> myList=new ArrayList<>();
    		for(int i=0;i<jsonArrays.size();i++){
    			
    		Student student3=JSON.toJavaObject(jsonArrays.getJSONObject(i), Student.class);
    			myList.add(student3);
    		}
    		for(Student stu:myList){
    			System.out.println(stu);
    		}
    		
    	        System.out.println();
    		
    		System.out.println("*****jsonObject to jsonString*****");
    		String str4=JSON.toJSONString(jsonObject1);
    		System.out.println(str4);
    		System.out.println();
    		
    		System.out.println("*******jsonString to jsonObject*****");
    		JSONObject jso1=JSON.parseObject(str1);
    		System.out.println(jso1.getString("name"));
    		System.out.println();
    		
    		System.out.println("*****jsonString to jsonArray*****");
    		JSONArray jArray=JSON.parseArray(JSON.toJSONString(stulist));
    		for(int i=0;i<jArray.size();i++){
    		System.out.println(jArray.getJSONObject(i));
    		}
    		System.out.println();
    	}
    
    }
    

    测试类对应的javabean类:

    package jsonTest;
    
    public class Student {
    	
    	private String name;
    	private int age;
    	
    	public Student() {
    		// TODO Auto-generated constructor stub
    	}
    	
    	public Student(String name,int age){
    		this.name=name;
    		this.age=age;
    	}
    	
    	public void setName(String name){
    		this.name=name;
    		
    	}
    	
    	public String getName(){
    		return name;
    	}
    	
    	public void setAge(int age){
    		this.age=age;
    	}
    	
    	public int getAge(){
    		return age;
    	}
    	
    	@Override
    	public String toString() {
    		// TODO Auto-generated method stub
    		return "student [name="+name+" , "+"age="+age+"]";
    	}
    	
    }
    

    今天就讲到这吧,如果上面有什么地方错误了,请及时指出,避免更多人误解。如果有什么不懂的,欢迎交流!

    展开全文
  • 讲解json的语法格式 讲解ajax技术的实现方法 讲解使用jquery结合ajax在项目中的应用 讲解alibaba的fastJSON的使用
  • [Java]fastJson的简单使用

    万次阅读 2018-06-17 18:42:05
    JSON协议使用方便,越来越流行,JSON的处理器有很多,这里我介绍一下FastJson,FastJson是阿里的开源框架,被不少企业使用,是一个极其优秀的Json框架,Github地址: FastJson 1.2.FastJson的特点: 1.FastJson数度快,无论...

    FastJSON是一个Java语言编写的高性能,功能完善,完全支持http://json.org的标准的JSON库。多了不说了,百度一下一大把。

    在此,简单的总结一下自己用过,测试过的方法。

    如果使用Maven,在pom.xml文件加入以下依赖。

    1 <dependency>
    2     <groupId>com.alibaba</groupId>
    3     <artifactId>fastjson</artifactId>
    4     <version>1.1.23</version>
    5 </dependency>

     

    序列化

    序列化就是指 把JavaBean对象转成JSON格式的字符串。

    com.alibaba.fastjson.JSON提供了许多方法(多态)实现序列化。

    1.基本的序列化

    String objJson = JSON.toJSONString(Object object);

    传入一个对象,将对象转成JSON字符串。

    例1:将Map转成JSON

    1 Map<String, Object> map = new HashMap<String, Object>();
    2 map.put("key1", "One");
    3 map.put("key2", "Two");
    4         
    5 String mapJson = JSON.toJSONString(map);
    

    输出结果:

    {"key1":"One","key2":"Two"}

    例2:将List<Map>转成JSON。

    复制代码
     1 List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
     2         
     3 Map<String, Object> map1 = new HashMap<String, Object>();
     4 map1.put("key1", "One");
     5 map1.put("key2", "Two");
     6         
     7 Map<String, Object> map2 = new HashMap<String, Object>();
     8 map2.put("key1", "Three");
     9 map2.put("key2", "Four");
    10         
    11 list.add(map1);
    12 list.add(map2);
    13         
    14 String listJson = JSON.toJSONString(list);
    复制代码

    输出结果:

    [{"key1":"One","key2":"Two"},{"key3":"Three","key4":"Four"}]

    例3:自定义JavaBean User转成JSON。

    1 User user = new User();
    2 user.setUserName("李四");
    3 user.setAge(24);
    4         
    5 String userJson = JSON.toJSONString(user);

    输出结果:

    {"age":24,"userName":"李四"}

    可以输出格式化后的 JSON 字符串。

    String objJson = JSON.toJSONString(Object object, boolean prettyFormat);

    传入一个对象和一个布尔类型(是否格式化),将对象转成格式化后的JSON字符串。

    例4:以例2代码为例。

    String listJson = JSON.toJSONString(list, true);

    输出结果为:

    复制代码
     1 [
     2     {
     3         "key1":"One",
     4         "key2":"Two"
     5     },
     6     {
     7         "key3":"Three",
     8         "key4":"Four"
     9     }
    10 ]
    复制代码

    FastJSON提供了许多特性支持。

    String objJson = JSON.toJSONString(Object object, SerializerFeature... features) 

    传入一个对象和SerializerFeature类型的可变变量。SerializerFeature是一个枚举。

    com.alibaba.fastjson.serializer.SerializerFeature

    你可以根据自己的情况使用这些特性。

    简单说下几个常用的特性:

    1.日期格式化:

    FastJSON可以直接对日期类型格式化,在缺省的情况下,FastJSON会将Date转成long。

    例5:FastJSON将java.util.Date转成long。

    1 String dateJson = JSON.toJSONString(new Date());
    2         
    3 System.out.println(dateJson);

    输出结果:

    1401370199040

    例6:使用SerializerFeature特性格式化日期。

    1 String dateJson = JSON.toJSONString(new Date(), SerializerFeature.WriteDateUseDateFormat);
    2         
    3 System.out.println(dateJson);

    输出结果:

    "2014-05-29 21:36:24"

    也可以指定输出日期格式。

    例7:指定输出日期格式。

    1 String dateJson = JSON.toJSONStringWithDateFormat(new Date(), "yyyy-MM-dd HH:mm:ss.SSS");
    2         
    3 System.out.println(dateJson);

    输出结果:

    "2014-05-29 21:47:00.154"

    2.使用单引号。

    例8:以例2为例。

    String listJson = JSON.toJSONString(list, SerializerFeature.UseSingleQuotes);

    输出结果:

    [{'key1':'One','key2':'Two'},{'key3':'Three','key4':'Four'}]

    3.JSON格式化。

    例9

    String listJson = JSON.toJSONString(list, SerializerFeature.PrettyFormat);

    输出结果:与例4结果一致。

    4.输出Null字段。

     缺省情况下FastJSON不输入为值Null的字段,可以使用SerializerFeature.WriteMapNullValue使其输出。

    例10

    复制代码
    1 Map<String, Object> map = new HashMap<String,Object>();
    2         
    3 String b = null;
    4 Integer i = 1;
    5         
    6 map.put("a", b);
    7 map.put("b", i);
    8         
    9 String listJson = JSON.toJSONString(map, SerializerFeature.WriteMapNullValue);
    复制代码

    输出结果:

    {"a":null,"b":1}

    5.序列化是写入类型信息。

    例11

    1 User user = new User();
    2         
    3 user.setAge(18);
    4 user.setUserName("李四");
    5         
    6 String listJson = JSON.toJSONString(user, SerializerFeature.WriteClassName);

    输出结果:

    {"@type":"User","age":18,"userName":"李四"}

    由于序列化带了类型信息,使得反序列化时能够自动进行类型识别。

    例12:将例11反序列化。

    1 User user1 = (User) JSON.parse(listJson);
    2         
    3 System.out.println(user1.getAge());

    输出结果:

    18

    如果User序列化是没有加入类型信息(SerializerFeature.WriteClassName),按照例12的做法就会报错(java.lang.ClassCastException)。

     

    反序列化

    反序列化就是把JSON格式的字符串转化为Java Bean对象。

    com.alibaba.fastjson.JSON提供了许多方法(多态)实现反序列化。

     

     简单举几个例子。

    指定Class信息反序列化。

    例13:将例3反序列化。

    1 User user1 = JSON.parseObject(userJson, User.class);
    2 System.out.println(user1.getUserName());

    输出结果:

    李四

    集合反序列化。

    例14:将例2反序列化。

    1 List<Map> list1 = JSON.parseArray(listJson, Map.class);
    2          
    3 for(Map<String, Object> map : list1){
    4     System.out.println(map.get("key1"));
    5     System.out.println(map.get("key2"));         
    6 }

    输出结果:

    1 One
    2 Two
    3 Three
    4 Four

    泛型的反序列化(使用TypeReference传入类型信息)。

    例15:将例1反序列化。

    1 Map<String, Object> map1 = JSON.parseObject(mapJson, new TypeReference<Map<String, Object>>(){});
    2 System.out.println(map1.get("key1"));
    3 System.out.println(map1.get("key2"));

    输出结果:

    1 One
    2 Two

     

    ———————————————————————————————————————————————————

    JSONObject,JSONArray是JSON的两个子类。

    JSONObject相当于Map<String, Object>,

    JSONArray相当于List<Object>。

    简单方法示例:

    例16:将Map转成JSONObject,然后添加元素,输出。

    复制代码
     1 Map<String, Object> map = new HashMap<String, Object>();
     2 map.put("key1", "One");
     3 map.put("key2", "Two");
     4                            
     5 JSONObject j = new JSONObject(map);
     6                    
     7 j.put("key3", "Three");
     8           
     9 System.out.println(j.get("key1"));
    10 System.out.println(j.get("key2"));
    11 System.out.println(j.get("key3"));
    复制代码

    输出结果:

     

    1 One
    2 Two
    3 Three

     

     

    例17:将List对象转成JSONArray,然后输出。

    复制代码
     1 List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
     2         
     3 Map<String, Object> map = new HashMap<String, Object>();
     4 map.put("key1", "One");
     5 map.put("key2", "Two");
     6         
     7 Map<String, Object> map2 = new HashMap<String, Object>();
     8 map2.put("key1", "Three");
     9 map2.put("key2", "Four");
    10         
    11 list.add(map);
    12 list.add(map2);
    13         
    14 JSONArray j = JSONArray.parseArray(JSON.toJSONString(list));
    15          
    16 for(int i=0; i<j.size(); i++){
    17     System.out.println(j.get(i));
    18 }
    复制代码

    输出结果:

    1 {"key1":"One","key2":"Two"}
    2 {"key1":"Three","key2":"Four"}

    更多方法使用请参考API(没有注释的API,让我很头疼啊)。



     

    end


    简单附上自己写的json工具类:

    1. import com.alibaba.fastjson.JSON;  
    2. import com.alibaba.fastjson.serializer.SerializerFeature;  
    3.   
    4. public class MyJsonUtil {  
    5.   
    6.     private static final SerializerFeature[] features = {SerializerFeature.WriteMapNullValue, // 输出空置字段  
    7.                                                          // SerializerFeature.WriteNullListAsEmpty,  
    8.                                                          // // list字段如果为null,输出为[],而不是null  
    9.                                                          // SerializerFeature.WriteNullNumberAsZero,  
    10.                                                          // // 数值字段如果为null,输出为0,而不是null  
    11.                                                          // SerializerFeature.WriteNullBooleanAsFalse,  
    12.                                                          // // Boolean字段如果为null,输出为false,而不是null  
    13.                                                          // SerializerFeature.WriteNullStringAsEmpty,  
    14.                                                          // // 字符类型字段如果为null,输出为”“,而不是null  
    15.                                                          SerializerFeature.WriteDateUseDateFormat // 日期格式化yyyy-MM-dd  
    16.                                                                                                   // HH:mm:ss  
    17.     };  
    18.   
    19.     public static String toJson(Object object) {  
    20.         return JSON.toJSONString(object, features);  
    21.     }  
    22. }  
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    
    public class MyJsonUtil {
    
        private static final SerializerFeature[] features = {SerializerFeature.WriteMapNullValue, // 输出空置字段
                                                             // SerializerFeature.WriteNullListAsEmpty,
                                                             // // list字段如果为null,输出为[],而不是null
                                                             // SerializerFeature.WriteNullNumberAsZero,
                                                             // // 数值字段如果为null,输出为0,而不是null
                                                             // SerializerFeature.WriteNullBooleanAsFalse,
                                                             // // Boolean字段如果为null,输出为false,而不是null
                                                             // SerializerFeature.WriteNullStringAsEmpty,
                                                             // // 字符类型字段如果为null,输出为"",而不是null
                                                             SerializerFeature.WriteDateUseDateFormat // 日期格式化yyyy-MM-dd
                                                                                                      // HH:mm:ss
        };
    
        public static String toJson(Object object) {
            return JSON.toJSONString(object, features);
        }
    }



            </div>
                </div>
    
    展开全文
  • FastJSON实现详解

    千次阅读 2018-11-15 16:16:14
    摘要:“快”作为程序员追逐的终极目标之一,而FastJSON则很好的证明了这一特性。本期《问底》,静行将带大家见证它序列化和反序列化的实现过程,一起领略它的“快”感。 还记得电影《功夫》中火云邪神的一句话:...
  • com.alibaba.fastjson学习笔记

    万次阅读 2019-01-08 20:05:58
    com.alibaba.fastjson 说一下好多人都在用的一款json包。本文是操作一些json,jsonObject序列化各种异常之后写的。由于项目在使用这款json包。特意举一些demo详细记录一下。 首先这款json包是一款性能非常好的json...
  • Json的FastJson与Jackson

    千次阅读 2019-06-06 20:50:49
    FastJson 需要引入 fastjson-1.2.40.jar包 FastJson的介绍 JSON协议使用方便,越来越流行,JSON的处理器有很多,这里我介绍一下FastJson,FastJson是阿里的开源框架,被不少企业使用,是一个极其优秀的Json框架; ...
  • FastJSON 简单使用

    万次阅读 多人点赞 2017-01-24 15:04:42
    FastJSON是一个Java语言编写的高性能,功能完善,完全支持http://json.org的标准的JSON库。多了不说了,百度一下一大把。 在此,简单的总结一下自己用过,测试过的方法。 如果使用Maven,在pom.xml文件加入以下依赖...
  • 最近接到通知,需要进行升级 (阿里)fastjson 的maven 版本号, 最升级到指定的版本,需要测试发布再次验证 ,啊周末需要加班了. 为什么要进行升级呢,一接到这个通知,我就考虑中,以前是有通知了 不过没有这么急啊,...
  • FastJson的pom依赖: <groupId>com.alibaba</groupId> <artifactId>fastjson <version>1.2.33 听闻FastJson使用特别的算法,速度非常快,甚至快过Google的protobuf,所以选择使用FastJso
  • 在使用fastjson解析的时候遇到该错误,网上查找了半天,找到位大神的帖子是说解析的实体A中有实体B,在该条json中A实体只有一个,但B实体却有多个,导致解析出错,解决办法是在A实体中定义B实体时,定义为List,这个...
  • fastjson List转JSONArray以及JSONArray转List

    万次阅读 多人点赞 2018-05-31 11:25:54
    1.fastjson List转JSONArrayList&lt;T&gt; list = new ArrayList&lt;T&gt;();JSONArray array= JSONArray.parseArray(JSON.toJSONString(list));2.fastjson JSONArray转ListJSONArray array = ...
  • maven依赖包: <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson --> <dependency> <groupId>com.alibaba</groupId>...fastjson</artifactId> ...
  • 使用FastJSON,将对象或数组和JSON串互转

    万次阅读 多人点赞 2014-12-25 15:29:33
    Fastjson,是阿里巴巴提供一个Java语言编写的高性能功能完善的JSON库。 http://www.codeproject.com/Articles/159450/fastJSON
  • FastJson的基本使用

    万次阅读 多人点赞 2014-07-09 23:48:41
    如果我们经常与服务器打交道,更新数据等等,那么json必然是个好的数据格式,但是有了json我们要解析它,使用原生的解析也可以,但是很不高效,所以这里介绍两种json数据解析的方式,一种是FastJSon ,这个是阿里巴巴...
  • 当项目中使用了fastjson框架转换json字符串后,默认情况下会有$ref这样的引用方式。 如果不使用此引用,在重复嵌套时,可能会耗尽系统资源。 但是如果启用的话,在页面js中又无法正常使用。 现只需要引入此js文件,...
  • maven中pom.xml对fastjson的依赖

    万次阅读 2018-05-19 15:48:19
    在项目中使用到json,由于数据的频繁转化,考虑到系统的性能使用了阿里巴巴封装的fastjson。项目的环境配置jdk1.7tomcat8maven3.39在pom中引入的依赖 &lt;dependency&gt; &lt;groupId&gt;...
  • Fastjson漏洞修复参考

    2020-06-20 10:27:52
    Fastjson漏洞修复参考 1. 漏洞背景 ​ Fastjson是阿里巴巴的开源JSON解析库,它可以解析JSON格式的字符串,支持将Java Bean序列化为JSON字符串,也可以从JSON字符串反序列化到JavaBean。 Fastjson多处补丁修补出现...
  • fastjson解析结果顺序不确定

    万次阅读 2018-05-04 10:12:38
    fastjsonJSON解析器fastjson(阿里巴巴出品,版本1.1.26),如果定义了JSONObject为{"JACKIE_ZHANG":"张学友","ANDY_LAU":"刘德华","LIMING":"黎明",&...
1 2 3 4 5 ... 20
收藏数 59,537
精华内容 23,814
关键字:

fastjson