举例讲解Java的Jackson库中ObjectMapper类的使用

ObjectMapper类是Jackson库的主要类。它提供一些功能将转换成Java对象匹配JSON结构,反之亦然。它使用JsonParser和JsonGenerator的实例实现JSON实际的读/写。

类声明
以下是org.codehaus.jackson.map.ObjectMapper类的声明:

public class ObjectMapper
  extends ObjectCodec
   implements Versioned

嵌套类

S.N. 类 & 描述
1 static class ObjectMapper.DefaultTypeResolverBuilder//定制TypeResolverBuilder,提供所谓的“默认输入”使用类型解析构建器(见enableDefaultTyping()了解详细信息)。
2 static class ObjectMapper.DefaultTyping//使用enableDefaultTyping()枚举指定什么样的类型(类)默认输入应该使用。

构造函数

S.N. 构造函数 & 描述
1 ObjectMapper()//默认的构造函数,这将构建默认JsonFactory必要时使用StdSerializerProvider作为其SerializerProvider,并BeanSerializerFactory作为其SerializerFactory。
2 ObjectMapper(JsonFactory jf)//构造使用指定的JsonFactory构建必要的JsonParsers和/或JsonGenerators映射。
3 ObjectMapper(JsonFactory jf, SerializerProvider sp, DeserializerProvider dp)
4 ObjectMapper(JsonFactory jf, SerializerProvider sp, DeserializerProvider dp, SerializationConfig sconfig, DeserializationConfig dconfig)
5 ObjectMapper(SerializerFactory sf) 不推荐使用。使用其他构造来代替; 注意,可以设置序列化工厂setSerializerFactory(org.codehaus.jackson.map.SerializerFactory)

这个类继承了以下类方法:
java.lang.Object

例子
测试类基本代码如下

/*
 * @project java
 * @package
 * @file Jackson.java
 * @version 1.0 

 */ 

public class Jackson {
  /*
   *
   * Class Descripton goes here.
   *
   * @class Jackson
   * @version 1.0
   */
  public static JsonGenerator jsonGenerator = null;
  private static ObjectMapper mapper = new ObjectMapper();
  public static void main(String[] args) {
    Student student = new Student();
    student.setIsstudent(true);
    student.setUid(1000);
    student.setUname("xiao liao");
    student.setUpwd("123");
    student.setNumber(12); 

    Map<String, Student> stuMap = new HashMap<String, Student>();
    stuMap.put("1", student);
    stuMap.put("2", student); 

    List<Object> stuList = new ArrayList<Object>();
    List<Student> stuList1 = new ArrayList<Student>();
    stuList1.add(student);
    student= new Student();
    student.setIsstudent(false);
    student.setUid(200);
    student.setUname("xiao mi");
    stuList1.add(student); 

    stuList.add(student);
    stuList.add("xiao xin");
    stuList.add("xiao er");
    stuList.add(stuMap); 

    //readJson2List();
    try {
      //readJson2Array();
      //writeArray2Json(array);
      //writeJson2List();
      //writeEntity2Json(student);
      writeJson2Entity();
      //writeMap2Json(stuMap);
      //writeList2Json(stuList1); 

    } catch (IOException e) {
      e.printStackTrace();
    }
  }
   /**
   *
   * <code>writeEntity2Json</code>
   * @description: TODO(实体类转换成json)
   * @param object
   * @throws IOException
   */
   public static void writeEntity2Json(Object object) throws IOException {
      mapper.writeValue( new File("D:\\developSoft\\aaadowload\\testjson1\\lib\\aa.txt"),object );
      mapper.writeValue( System.out,object ); 

   }
   /**
   *
   * <code>writeArray2Json</code>
   * @description: TODO(数组转换成json数组)
   * @param object
   * @throws IOException
   */
   public static void writeArray2Json(Object object) throws IOException { 

     // writeValue具有和writeObject相同的功能
     mapper.writeValue( new File("D:\\developSoft\\aaadowload\\testjson1\\lib\\aa.txt"),object );
     mapper.writeValue(System.out,object ); 

   }
   /**
   *
   * <code>writeMap2Json</code>
   * @description: TODO(map对象转换成json对象)
   * @param object
   * @throws IOException
   * @since  2011-11-8   廖益平
   */
   public static void writeMap2Json(Object object) throws IOException { 

     System.out.println("使用ObjectMapper-----------");
     // writeValue具有和writeObject相同的功能
     System.out.println("==>"+mapper.writeValueAsString(object));
     mapper.writeValue( new File("D:\\developSoft\\aaadowload\\testjson1\\lib\\aamap.txt"),object );
     mapper.writeValue( System.out , object );
   }
   /**
   *
   * <code>writeList2Json</code>
   * @description: TODO(list转换成json)
   * @param object
   * @throws IOException
   */
   public static void writeList2Json(Object object) throws IOException {
     System.out.println("==>"+mapper.writeValueAsString(object));
     mapper.writeValue( new File("D:\\developSoft\\aaadowload\\testjson1\\lib\\aamap.txt"),object );
     mapper.writeValue( System.out , object );
   }
   /**
   *
   * <code>writeJson2Entity</code>
   * @description: TODO(json转换成实体)
   * @throws IOException
   */
   public static void writeJson2Entity() throws IOException {
     System.out.println("json串转换成entity-------------");
//    File file = new File("D:\\developSoft\\aaadowload\\testjson1\\lib\\aa.txt");
//    FileInputStream inputStream = new FileInputStream(file);
//    Student student = mapper.readValue(inputStream,Student.class);
//    System.out.println(student.toString());
     //漂亮输出
     //mapper.defaultPrettyPrintingWriter().writeValueAsString(value); 

     String json = "{\"uid\":1000,\"uname\":\"xiao liao\",\"upwd\":\"123\",\"number\":12.0,\"isstudent\":true}";
     Student student1 = mapper.readValue(json,Student.class);
     System.out.println("json2:"+student1.toString());
   }
   /**
   *
   * <code>writeJson2List</code>
   * @description: TODO(json专程list对象)
   * @throws IOException
   */
   public static void writeJson2List() throws IOException {
     System.out.println("json串转换成entity-------------");
     File file = new File("D:\\developSoft\\aaadowload\\testjson1\\lib\\aa.txt");
     FileInputStream inputStream = new FileInputStream(file);
     Student student = mapper.readValue(inputStream,Student.class);
     System.out.println(student.toString()); 

     String json = "[{\"uid\":1000,\"uname\":\"xiao liao\",\"upwd\":\"123\",\"number\":12.0,\"isstudent\":true},{\"uid\":200,\"uname\":\"xiao mi\",\"upwd\":null,\"number\":0.0,\"isstudent\":false}]";
     List<LinkedHashMap<String, Object>> s= mapper.readValue(json,List.class);
     for (int i = 0; i < s.size(); i++) {
       LinkedHashMap<String, Object> link = s.get(i);
       Set<String> key = link.keySet();
       for (Iterator iterator = key.iterator(); iterator.hasNext();) {
        String string = (String) iterator.next();
        System.out.println(string+"==>"+link.get(string)); 

      }
       System.out.println("json:"+i+""+s.get(i).toString()); 

    }
   }
   /**
    * JSON转换为List对象
    */
   public static void readJson2List() {
    String json = "[{\"uid\":1,\"uname\":\"www\",\"number\":234,\"upwd\":\"456\"},"
     + "{\"uid\":5,\"uname\":\"tom\",\"number\":3.44,\"upwd\":\"123\"}]";
    try {
    List<LinkedHashMap<String, Object>> list = mapper.readValue(
     json, List.class);
    System.out.println(list.size());
    for (int i = 0; i < list.size(); i++) {
     Map<String, Object> map = list.get(i);
     Set<String> set = map.keySet();
     for (Iterator<String> it = set.iterator(); it.hasNext();) {
     String key = it.next();
     System.out.println(key + ":" + map.get(key));
     }
    }
    } catch (JsonParseException e) {
    e.printStackTrace();
    } catch (JsonMappingException e) {
    e.printStackTrace();
    } catch (IOException e) {
    e.printStackTrace();
    }
   }
   /**
    * JSON转换为List对象
    */
   public static void readJson2Array() {
     String json = "[{\"uid\":1,\"uname\":\"www\",\"number\":234,\"upwd\":\"456\"},"
       + "{\"uid\":5,\"uname\":\"tom\",\"number\":3.44,\"upwd\":\"123\"}]";
     try {
       Student[] students = mapper.readValue(json, Student[].class);
       for (Student student : students) {
        System.out.println(">"+student.toString());
      }
     } catch (JsonParseException e) {
       e.printStackTrace();
     } catch (JsonMappingException e) {
       e.printStackTrace();
     } catch (IOException e) {
       e.printStackTrace();
     }
   } 

}

打印结果 :

串转换成entity-------------
json2:uid=1000,name=xiao liao,upwd=123,number=12.0,isStudent=true

writeMap2Json -----------
{"2":{"uid":1000,"uname":"xiao liao","upwd":"123","number":12.0,"isstudent":true},"1":{"uid":1000,"uname":"xiao liao","upwd":"123","number":12.0,"isstudent":true}}

readJson2Array------------------
>uid=1,name=www,upwd=456,number=234.0,isStudent=false
>uid=5,name=tom,upwd=123,number=3.44,isStudent=false
writeMap2Json -----------
{"2":{"uid":1000,"uname":"xiao liao","upwd":"123","number":12.0,"isstudent":true},"1":{"uid":1000,"uname":"xiao liao","upwd":"123","number":12.0,"isstudent":true}}

大家逐个自己试试吧  ,上面也是我的测试代码

(0)

相关推荐

  • java反射实现javabean转json实例代码

    ObjectToJson.java 复制代码 代码如下: package com.ObjectToJson; import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.util.ArrayList;import java.util.Iterator; public class ObjectToJson {

  • java中用ObjectMapper类实现Json与bean的转换示例

    前言 ObjectMapper是jackson中的方法,本文主要给大家介绍了关于java中用ObjectMapper类实现Json与bean转换的相关内容,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧. 一.将json字符串转为bean public class JsonToJavaBean { public static void main(String[] args) { String str="{\"student\":[{\"name\&q

  • 详解json string转换为java bean及实例代码

    详解json string转换为java bean及实例代码 pom中添加如下两个库: <dependency> <groupId>org.codehaus.jackson </groupId> <artifactId>jackson-core-asl</artifactId> <version>1.9.2</version> <scope>provided</scope> </depende

  • 举例讲解Java的Jackson库中ObjectMapper类的使用

    ObjectMapper类是Jackson库的主要类.它提供一些功能将转换成Java对象匹配JSON结构,反之亦然.它使用JsonParser和JsonGenerator的实例实现JSON实际的读/写. 类声明 以下是org.codehaus.jackson.map.ObjectMapper类的声明: public class ObjectMapper extends ObjectCodec implements Versioned 嵌套类 S.N. 类 & 描述 1 static class

  • Jackson库中objectMapper的用法

    Jackson库中objectMapper用法 ObjectMapper类是Jackson库的主要类.它提供一些功能将转换成Java对象与SON结构互相转换,在项目中遇到过,故记录一下. 在 pom.xml 加入依赖 <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>

  • 实例解析Java的Jackson库中的数据绑定

    数据绑定API用于JSON转换和使用属性访问或使用注解POJO(普通Java对象).以下是它的两个类型. 简单数据绑定 - 转换JSON,从Java Maps, Lists, Strings, Numbers, Booleans 和 null 对象. 完整数据绑定 - 转换JSON到任何JAVA类型.我们将在下一章分别绑定. ObjectMapper读/写JSON两种类型的数据绑定.数据绑定是最方便的方式是类似XML的JAXB解析器. 简单的数据绑定 简单的数据绑定是指JSON映射到Java核心

  • 解析Java的Jackson库中对象的序列化与数据泛型绑定

    Jackson对象序列化 这里将介绍将Java对象序列化到一个JSON文件,然后再读取JSON文件获取转换为对象.在这个例子中,创建了Student类.创建将有学生对象以JSON表示在一个student.json文件. 创建一个名为JacksonTester在Java类文件在 C:\>Jackson_WORKSPACE. 文件: JacksonTester.java import java.io.File; import java.io.IOException; import org.codeh

  • 解析Java的Jackson库中Streaming API的使用

    流式API读取和写入JSON内容离散事件. JsonParser读取数据,而JsonGenerator写入数据.它是三者中最有效的方法,是最低开销和最快的读/写操作.它类似于XML的Stax解析器. 在本文中,我们将展示的使用Jackson的流式API 读写JSON数据.流式API工作使用JSON为每一个细节的都是要小心处理.下面的例子将使用两个类: JsonGenerator类--写入JSON字符串. sonGenerator是定义公共API编写的Json内容的基类.使用JsonFactory

  • Java的Jackson库中复杂对象集合的几种简单转换

    话不多说,请看代码: package com; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStreamReader; import java.util.List; import com.fasterxml.jackson.core.JsonParseException; import com.fasterxm

  • 举例讲解Java的Hibernate框架中的多对一和一对多映射

    多对一(Many-to-One)映射 多对一(many-to-one)关联是最常见的关联关系,其中一个对象可以与多个对象相关联.例如,一个相同的地址对象可以与多个雇员的对象相关联. 定义RDBMS表: 考虑一个情况,我们需要员工记录存储在EMPLOYEE表,将有以下结构: create table EMPLOYEE ( id INT NOT NULL auto_increment, first_name VARCHAR(20) default NULL, last_name VARCHAR(20

  • 举例讲解Java的Spring框架中AOP程序设计方式的使用

    1.什么是AOP AOP是Aspect Oriented Programming的缩写,意思是面向方面编程,AOP实际是GoF设计模式的延续. 2.关于Spring AOP的一些术语:  A.切面(Aspect):在Spring AOP中,切面可以使用通用类或者在普通类中以@Aspect 注解(@AspectJ风格)来实现 B.连接点(Joinpoint):在Spring AOP中一个连接点代表一个方法的执行 C.通知(Advice):在切面的某个特定的连接点(Joinpoint)上执行的动作.

  • Java Thread多线程开发中Object类详细讲解

    目录 方法概览 Thread wait  notify notifyAll方法详解 作用 阻塞阶段 唤醒阶段 遇到中断 代码展示 特点 通过wait notify方法实现生产者和消费者 sleep方法详解 sleep不会释放锁 sleep响应中断 总结 join方法详解 代码展示 yield方法 方法概览 Thread wait  notify notifyAll方法详解 作用 阻塞阶段 使用了wait方法之后,线程就会进入阻塞阶段,只有发生以下四种情况中的其中一个,线程才会被唤醒 另一个线程调

  • Java的Jackson库的使用及其树模型的入门学习教程

    Jackson第一个程序 在进入学习jackson库的细节之前,让我们来看看应用程序操作功能.在这个例子中,我们创建一个Student类.将创建一个JSON字符串学生的详细信息,并将其反序列化到学生的对象,然后将其序列化到JSON字符串. 创建一个名为JacksonTester在Java类文件 C:\>Jackson_WORKSPACE. 文件: JacksonTester.java import java.io.IOException; import org.codehaus.jackson.

随机推荐