第一篇博客

目录 FastjsonFastjson是什么Fastjson 干什么,有哪些特质JSON类的常用方法：(都是静态方法)常用类介绍：序列化：JAVA对象转化为Json字符串反序列化：JSON字符串转化为java对象JSON对象JSONArray 遍历 JSONObject对象JSON对象转JSON字符串：JSON字符串转JSON对象归纳六种方式json字符串转mapFastjson 定制序列化@JSONField注解JSONTypeFastjson的SerializeFilterFastjson的ParseProcessFastjson的BeanToArray模式BeanToArray的使用SpringMVC集成FastjsonJUnit4JUnit注解时间测试Unit断言

Fastjson

Fastjson是什么

fastjson是阿里巴巴的开源JSON解析库，它可以解析JSON格式的字符串

支持将Java Bean序列化为JSON字符串，也可以从JSON字符串反序列化到JavaBean。

使用方便

String text = JSON.toJSONString(obj); //序列化
VO vo = JSON.parseObject("{...}", VO.class); //反序列化

maven依赖


com.alibaba
fastjson
x.x.x

Fastjson 干什么,有哪些特质

  • 提供了 toJSONString() 和 parseObject() 方法来将 Java 对象与 JSON 相互转换。
    • 调用toJSONString方 法即可将对象转换成 JSON 字符串，
    • parseObject 方法则反过来将 JSON 字符串转换成对象。
  • 允许转换预先存在的无法修改的对象（只有class、无源代码）。

JSON类的常用方法：(都是静态方法)

方法 说明
public static final Object parse(String text); 把JSON文本转换为JSONObject或者JSONArray
public static final JSONObject parseObject(String text)； 把JSON文本转换成JSONObject
public static final T parseObject(String text, Class clazz); 把JSON文本转换e为JavaBean
public static final JSONArray parseArray(String text); 把JSON文本转换成JSONArray
public static final List parseArray(String text, Class clazz); 把JSON文本转换成JavaBean集合
public static final String toJSONString(Object object); 把JSON文本转换成JavaBean集合
public static final String toJSONString(Object object, boolean prettyFormat); 将JavaBean序列化为带格式的JSON文本
public static final Object toJSON(Object javaObject); 将JavaBean转换为JSONObject或者JSONArray

常用类介绍：

  • JSONObject 和 JSONArray 都继承了 JSON
    • JSONObject（fastJson提供的json对象）
      • 相当于 Map<String,Object> 来看
    • JSONArray（fastJson提供json数组对象)
      • JSONArray顾名思义是由JSONObject构成的数组
      • 相当于 List
      • SerializeWriter：相当于StringBuffer
      • JSON反序列化没有真正数组，本质类型都是List

        下面将用这些函数和类进行序列化和反序列化

        序列化：JAVA对象转化为Json字符串

        public class Utest01 {
        private List list = new ArrayList();
        @Test
        public void Ujson(){
        User user = new User("ldgg1",12);
        User user2 = new User("ldgg2",12);
        list.add(user);list.add(user2); //集合添加

        String jsonU1= JSON.toJSONString(user); //对象转化为json
        String jsonlist= JSON.toJSONString(list); //对象集合转化为json
        String jsonlistb= JSON.toJSONString(list, SerializerFeature.BeanToArray); //BeanToArray模式输出

        System.out.println(jsonU1); //{"age":12,"name":"ldgg1"}
        System.out.println(jsonlist); //[{"age":12,"name":"ldgg1"},{"age":12,"name":"ldgg2"}]
        System.out.println(jsonlistb); //[[12,"ldgg1"],[12,"ldgg2"]]
        }
        }

        反序列化：JSON字符串转化为java对象

        • 使用JSON.parseObject()和JSON.parseArray 将 JSON 字符串转换为 Java 对象或对象集合
        • 注意反序列化时为对象时，必须要有默认无参的构造函数，否则会报异常:
          • com.alibaba.fastjson.JSONException: default constructor not found.

        用上文的那几个JSON字符串转化为java对象

        //将json字符串转换成为对象（反序列化）
        //JSON.parseObject()
        User user3 = (User) JSON.parseObject(jsonU1,User.class);
        System.out.println(user3.toString()); // User{name='ldgg1', age=12}
        //将json字符串转换成为对象集合（反序列化）
        //JSON.parseArray()
        List userList = JSON.parseArray(jsonlist, User.class);
        System.out.println(userList.toString()); // [User{name='ldgg1', age=12}, User{name='ldgg2', age=12}]

        JSON对象

        JSON有两个子对象JSONObject对象和JSONArray对象

        • JSONObject（fastJson提供的json对象）
          • JSONObject jsonObject = new JSONObject (String str);
        • JSONArray（fastJson提供json数组对象）
          • JSONArray jsonArray = new JSONArray(String str);
        • 可以把 JSONArray 看成 JSONObject 对象的一个集合

        JSONArray 遍历 JSONObject对象

        //JSONArray，顾名思义是由JSONObject构成的数组
        JSONArray jsonArray = new JSONArray(paramsStr);

        for (int i = 0; i < jsonArray.length(); i++) {
        //可以把JSONArray当成一般的数组来对待，只是获取的数据内数据的方法不一样
        JSONObject jsonObject = jsonArray.getJSONObject(i);
        //JSONObject jsonObject = (JSONObject)jsonArray.get(i);//这种和上面的效果一样

        //下面两种获取都可，
        String oid = jsonObject.getString("oid");
        // Integer qty = (Integer) jsonObject.get("qty");//这种和上面的效果一样
        }

        JSON对象转JSON字符串：

        json对象.toJSONString()函数

        @Test
        public void Ujson4(){
        JSONArray jsonArray = new JSONArray();
        for (int i = 0; i < 2; i++) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", "ldg1"+i);
        jsonObject.put("age", 10+i);
        //json对象.toJSONString() JSON对象转String字符串
        System.out.println(jsonObject.toJSONString());
        jsonArray.add(jsonObject);
        }
        //json对象.toJSONString() JSON对象转String字符串
        String jsonOutput = jsonArray.toJSONString();
        System.out.println(jsonOutput);
        }
        运行结果如下：
        {"name":"ldg10","age":10}
        {"name":"ldg11","age":11}
        [{"name":"ldg10","age":10},{"name":"ldg11","age":11}]

        JSON字符串转JSON对象

        JSONObject.parseObject(json字符串);

        @Test
        public void Ujson3(){
        JSONArray jsonArray = new JSONArray();
        String str = "{"name":"yao1","age":10}";
        String str2 = "{"name":"yao2","age":11}";
        //把JSON文本转换成JSON对象
        JSONObject json1 = JSONObject.parseObject(str);
        JSONObject json2 = JSONObject.parseObject(str2);
        jsonArray.add(json1);jsonArray.add(json2); //将JSONObject添加到jsonArray中

        //JSON对象转JSON字符串：
        String sjob1 = json1.toJSONString(); // {"name":"yao1","age":10}
        String sjob2 = json2.toJSONString(); // {"name":"yao2","age":11}
        String sjoa = jsonArray.toJSONString(); // [{"name":"yao1","age":10},{"name":"yao2","age":11}]

        //反序列化（JSON字符串转java对象）
        User user = (User) JSON.parseObject(sjob1,User.class);
        List userList = JSON.parseArray(sjoa, User.class);
        }

        归纳六种方式json字符串转map

        public class fmjsTest {
        //补充：map序列化
        @Test
        public void FastJsonT1() {
        Map maps = new HashMap();
        maps.put(0,"zhangsan");
        maps.put(1,"lisi");
        maps.put(2,"wangwu");
        System.out.println(maps);//{0=zhangsan, 1=lisi, 2=wangwu}
        String string = JSON.toJSONString(maps); // {0:"zhangsan",1:"lisi",2:"wangwu"}
        }

        String str = "{"0":"zhangsan","1":"lisi","2":"wangwu","3":"maliu"}";
        //使用的是JSON的方法
        @Test
        public void FastJsonT2(){
        Map maps = (Map)JSON.parse(str);
        System.out.println("这个是用JSON类来解析JSON字符串!!!");
        for (Object map : maps.entrySet()){
        System.out.println(((Map.Entry)map).getKey()+" " + ((Map.Entry)map).getValue());
        }

        Map mapTypes = JSON.parseObject(str);
        System.out.println("这个是用JSON类的parseObject来解析JSON字符串!!!");
        for (Object obj : mapTypes.keySet()){
        System.out.println("key为："+obj+"值为："+mapTypes.get(obj));
        }

        Map mapType = JSON.parseObject(str,Map.class);
        System.out.println("这个是用JSON类,指定解析类型，来解析JSON字符串!!!");
        for (Object obj : mapType.keySet()){
        System.out.println("key为："+obj+"值为："+mapType.get(obj));
        }
        }
        //使用的是JSONObject的方法
        @Test
        public void FastJsonT4(){
        /**
        * JSONObject是Map接口的一个实现类
        */
        Map json = (Map) JSONObject.parse(str);
        System.out.println("这个是用JSONObject类的parse方法来解析JSON字符串!!!");
        for (Object map : json.entrySet()){
        System.out.println(((Map.Entry)map).getKey()+" "+((Map.Entry)map).getValue());
        }

        JSONObject jsonObject = JSONObject.parseObject(str);
        System.out.println("这个是用JSONObject的parseObject方法来解析JSON字符串!!!");
        for (Object map : jsonObject.entrySet()){
        System.out.println(((Map.Entry)map).getKey()+" "+((Map.Entry)map).getValue());
        }

        Map mapObj = JSONObject.parseObject(str,Map.class);
        System.out.println("这个是用JSONObject的parseObject方法并执行返回类型来解析JSON字符串!!!");
        for (Object map: mapObj.entrySet()){
        System.out.println(((Map.Entry)map).getKey()+" "+((Map.Entry)map).getValue());
        }
        }
        }

        Fastjson 定制序列化

        fastjson支持多种方式定制序列化。

        • 通过@JSONField定制序列化
        • 通过@JSONType定制序列化
        • 通过SerializeFilter定制序列化
        • 通过ParseProcess定制反序列化

        @JSONField注解

        用法：

        用在需要转换所实体类的属性/字段上面，也可以用在对应的Setter 和 Getter 方法

        @JSONField(属性=值,属性=值,...)

        注意：

        • FastJson 在进行操作时，是根据 getter 和 setter 的方法进行的，并不是依据 Field 进行。
        • 若属性是私有的，必须有 set 方法。否则无法反序列化。

        常用属性如下：

        • name ：不仅定义了输入key的名称，同时也定义了输出的名称。
          • 当作用在setter方法上时，就相当于根据 name 到 json中寻找对应的值，并调用该setter对象赋值。
          • 当作用在getter上时，在bean转换为json时，其key值为name定义的值。
        • format ：配置日期格式化（格式化 date 属性）
        • serialize ： 指定字段不序列化
        • deserialize ：指定字段不反序列化
        • ordinal ：指定字段的顺序
          • 如果不通过ordinal指定字段的顺序，是根据fieldName的字母序进⾏序列的
        • serializeUsing : 制定属性的序列化类
          • 可以单独对某⼀个类的某个属性定制序列化

        例子如下：

        public class Person {
        @JSONField(name = "AGE", serialize=false, ordinal = 1)
        private int age;

        @JSONField(name = "FULL NAME", ordinal = 2)
        private String fullName;

        @JSONField(name = "DATE OF BIRTH", format="dd/MM/yyyy", ordinal = 3,deserialize=false)
        private Date dateOfBirth;

        private Date datenewt;

        private String lastname;

        private String festname;

        @JSONField(name="date new", format="yyyy/MM/dd", ordinal = 4)
        public Date getDatenewt() {
        return datenewt;
        }
        @JSONField(name="date new", format="yyyy/MM/dd", ordinal = 4)
        public void setDatenewt(Date datenewt) {
        this.datenewt = datenewt;
        }
        @JSONField(name="last name")
        public String getLastname() {
        return lastname;
        }
        @JSONField(name="last name")
        public void setLastname(String lastname) {
        this.lastname = lastname;
        }

        public String getFestname() {
        return festname;
        }

        public void setFestname(String festname) {
        this.festname = festname;
        }
        //其他属性的get/set
        //构造方法
        }

        JSONType

        @JSONType注解和@JSONField注解的作用类似，但@JSONType是配置在类上，而不是字段或者getter/setter方法上。

        //不序列化studentAge和studentGender属性
        @JSONType(ignores = {"studentAge","studentGender"})
        public class Student {

        private String studentName;
        private Integer studentAge;
        private String studentGender;

        //get,set,tostring方法
        }

        Fastjson的SerializeFilter

        通过SerializeFilter可以使用扩展编程的方式实现定制序列化，Fastjson提供了多种SerializeFilter：

        • PropertyPreFilter：根据PropertyName判断是否序列化；
        • PropertyFilter：根据PropertyName和PropertyValue来判断是否序列化；
        • NameFilter：修改Key，如果需要修改Key，process返回值则可；
        • ValueFilter：修改Value；
        • BeforeFilter：序列化时在最前添加内容；
        • AfterFilter：序列化时在最后添加内容。

        案例地址：mavendome\fastjson\src\main\java\Serializef\SerializeFilterTest.java

        http://www.yiidian.com/fastjson/fastjson-serializefilter.html

        Fastjson的ParseProcess

        ParseProcess是编程扩展定制反序列化的接口。Fastjson支持如下ParseProcess：

        • ExtraProcessor：用于处理多余的字段；
        • ExtraTypeProvider：用于处理多余字段时提供类型信息。

        案例地址：mavendome\fastjson\src\main\java\Serializef\SerializeFilterTest.java

        http://www.yiidian.com/fastjson/fastjson-parseprocess.html

        Fastjson的BeanToArray模式

        在fastjson中，支持一种叫BeanToArray的映射模式。

        • 普通模式下，JavaBean映射成json object，
        • BeanToArray模式映射为json array。

        例子如下：2者的区别如下

        • 例子中，BeanToArray模式下，少了Key的输出，节省了空间，json字符串较小，性能也会更好。

        • 普通模式

        • BeanToArray模式

        BeanToArray的使用

        全局使用

        vvvv@Test
        public void whenJavaList_thanConvertToJsonCorrect() {
        //使用 JSON.toJSONString() 将 Java 对象转换换为 JSON 对象（BeanToArray模式）
        String jsonOutput= JSON.toJSONString(listOfPersons, SerializerFeature.BeanToArray);
        System.out.println(jsonOutput);
        }

        BeanToArray可以局部使用：

        • 例子中，如果Company的属性departments元素很多，局部采用BeanToArray就可以获得很好的性能，而整体又能够获得较好的可读性。

          class Company {
          public int code;

          @JSONField(serialzeFeatures=SerializerFeature.BeanToArray, parseFeatures=Feature.SupportArrayToBean)
          public List departments = new ArrayList();
          }
          class Department {
          public int id;
          public Stirng name;
          //构造，set，get...
          }

        上面的案例也可以这样写：

        class Company {
        public int code;
        public List departments = new ArrayList();
        }

        @JSONType(serialzeFeatures=SerializerFeature.BeanToArray, parseFeatures=Feature.SupportArrayToBean)
        class Department {
        public int id;
        public Stirng name;
        public Department() {}
        public Department(int id, String name) {this.id = id; this.name = name;}
        }

        输出：
        Company company = new Company();
        company.code = 100;
        company.departments.add(new Department(1001, "Sales"));
        company.departments.add(new Department(1002, "Financial"));

        // {"code":100,"departments":[[1001,"Sales"],[1002,"Financial"]]}
        String text = JSON.toJSONString(commpany);

        SpringMVC集成Fastjson

        用 Spring MVC 来构建 Web 应用并对性能有较高的要求的话，可以使用 Fastjson 提供的FastJsonHttpMessageConverter 来替换 Spring MVC 默认的 HttpMessageConverter

        以提高 @RestController @ResponseBody @RequestBody 注解的 JSON序列化速度。

        1:如果是使用 XML 的方式配置 Spring MVC 的话，只需在 Spring MVC 的 XML 配置文件中加入下面配置即可：

        mvc:annotation-driven
        mvc:message-converters

        </mvc:message-converters>
        </mvc:annotation-driven>

        通常默认配置已经可以满足大部分使用场景，如果你想对它进行自定义配置的话，你可以添加 FastJsonConfig Bean。如下：
        mvc:annotation-driven
        mvc:message-converters



        </mvc:message-converters>
        </mvc:annotation-driven>



        2: 注解方式（通常是基于 Spring Boot 项目）配置只需继承 WebMvcConfigurerAdapter覆写configureMessageConverters方法即可

        @Configuration
        public class WebMvcConfigurer extends WebMvcConfigurerAdapter {
        @Override
        public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
        //自定义配置...
        //FastJsonConfig config = new FastJsonConfig();
        //config.set ...
        //converter.setFastJsonConfig(config);
        converters.add(0, converter);
        }
        }

        JUnit4

        JUint是Java编程语言的单元测试框架，用于编写和运行可重复的自动化测试。

        JUnit在一个条中显示进度。如果运行良好则是绿色；如果运行失败，则变成红色。

        JUnit注解

        注解 描述
        @Test 测试注解，标记一个方法可以作为一个测试用例 。
        @Before 每一个测试方法执行前自动调用一次,以便执行某些必要的先决条件。
        @BeforeClass 所有测试方法执行前执行一次，在测试类还没有实例化就已经被加载，所以用static修饰
        @After 该方法在每项测试后执行（如执行每一个测试后重置某些变量，删除临时变量等）。
        @AfterClass 所有测试方法执行完后执行一次，在测试类还没有实例化就已经被加载，所以用static修饰
        @Ignore 暂不执行该测试方法
        @Runwith 放在测试类名之前，用来确定这个类怎么运行的。也可以不标注，会使用默认运行器。
        @Parameters 用于使用参数化功能。
        @SuiteClasses 用于套件测试

        案例：地址mavendome\JUnit4\src\main\java\AnnotationTest.java

        时间测试

        JUnit提供了一个暂停的方便选项，如果一个测试用例比起指定的毫秒数花费了更多的时间，那么JUnit将自动将它标记为失败。

        • timeout参数和@Test注解一起使用，例如@Test(timeout=1000)。

          @Test(timeout = 1000)
          public void testCase1() throws InterruptedException {
          TimeUnit.SECONDS.sleep(5000); //延迟5秒
          System.out.println("in test case 1");
          }

        Unit断言

        断言 描述
        void assertEquals([String message],expected value,actual value) 断言两个值相等。值类型可能是int，short，long，byte，char，Object，第一个参数是一个可选字符串消息
        void assertTrue([String message],boolean condition) 断言一个条件为真
        void assertFalse([String message],boolean condition) 断言一个条件为假
        void assertNotNull([String message],java.lang.Object object) 断言一个对象不为空（null）
        void assertNull([String message],java.lang.Object object) 断言一个对象为空（null）
        void assertSame([String message],java.lang.Object expected,java.lang.Object actual) 断言两个对象引用相同的对象
        void assertNotSame([String message],java.lang.Object unexpected,java.lang.Object actual) 断言两个对象不是引用同一个对象
        void assertArrayEquals([String message],expectedArray,resultArray) 断言预期数组和结果数组相等，数组类型可能是int，short，long，byte，char，Object

        @Test
        public void test() {
        String obj1 = "junit";
        String obj2 = "junit";
        String obj3 = "test";
        String obj4 = "test";
        String obj5 = null;

        int var1 = 1;
        int var2 = 2;

        int[] array1 = {1, 2, 3};
        int[] array2 = {1, 2, 3};

        //assertEquals() 如果比较的两个对象是相等的，此方法将正常返回；否则失败显示在JUnit的窗口测试将中止。
        Assert.assertEquals(obj1, obj2);
        //assertSame() 和 assertNotSame() 方法测试两个对象引用指向完全相同的对象。
        Assert.assertSame(obj3, obj4);
        Assert.assertNotSame(obj2, obj4);
        //assertNull() 和 assertNotNull() 方法测试一个变量是否为空或不为空(null)。
        Assert.assertNotNull(obj1);
        Assert.assertNull(obj5);
        //assertTrue() 和 assertFalse() 方法测试if条件或变量是true还是false。
        Assert.assertTrue(var1 < var2);
        Assert.assertFalse(var1 > var2);
        //assertArrayEquals() 将比较两个数组，如果它们相等，则该方法将继续进行不会发出错误。否则失败将显示在JUnit窗口和中止测试。
        Assert.assertArrayEquals(array1, array2);
        }

posted @ 2020-10-07 23:44  ndgwww  阅读(230)  评论(0)    收藏  举报