XML与Json解析

目录

XML解析 

一、DOM4J解析XML文件（非重点）:

二、Dom4J之XPATH解析XML（非重点）

 三、生成XML

 Json解析(重点）

---

XML解析 

解析网络xml文件：这里我们提供一个网址：

在浏览器中粘贴此网址，将“+phone+”换成手机号即可得到一个xml文件。"http://apis.juhe.cn/mobile/get%20phone="+phone+"&dtype=xml&key=9f3923e8f87f1ea50ed4ec8c39cc9253"

一、DOM4J解析XML文件（非重点）:

一:步骤：

 1. 引入jar文件 dom4j.jar
 2. 创建一个指向XML文件的输入流
     FileInputStream fis = new FileInputStream("xml文件的地址");
 3. 创建一个XML读取工具对象
     SAXReader sr = new SAXReader();
 4. 使用读取工具对象, 读取XML文档的输入流 , 并得到文档对象
     Document doc = sr.read(fis);  
 5. 通过文档对象, 获取XML文档中的根元素对象
     Element root = doc.getRootElement();

示例：

我随意输入一个手机号，粘贴到浏览器：

http://apis.juhe.cn/mobile/getphone=13384995237&dtype=xml&key=9f3923e8f87f1ea50ed4ec8c39cc9253

可以得到此xml文件： 

 

 下面我们来解析这个xml文件（请认真看详细注释）

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
public class Demo2 {
    public static void main(String[] args) throws IOException, DocumentException {
        String phone = "13384995237";
        //URL是网络地址，全球通用
        URL url = new URL("http://apis.juhe.cn/mobile/get?%20phone="+phone+"&dtype=xml&key=9f3923e8f87f1ea50ed4ec8c39cc9253");
        //打开网址连接
        URLConnection connection = url.openConnection();
        //获取流
        InputStream is = connection.getInputStream();
        //创建一个XML对象用来读取流
        SAXReader rs = new SAXReader();
        //通过读取对象，读取XML数据，并返回文档对象
        Document doc = rs.read(is);
        //用文件获取根节点
        Element root = doc.getRootElement();
        //用根节点获取子节点
        Element resultcode = root.element("resultcode");
        Element result = root.element("result");
        System.out.println("输出的result的内容为："+result.getText());
        /**
         * 这里输出为空，因为result下面只有子节点，并没有自身内容
          */
        //用result获取子节点province
        Element province = result.element("province");
        //获取province内容
        System.out.println("手机号所属省份："+province.getText());
        //用result获取子节点city并获取内容
        System.out.println("手机号所属市区："+result.element("city").getText());
        }
    }

运行结果 ： 

 以上和以下大家可以参考元素对象的常用方法：

//解析所有子节点
        List<Element> es = root.elements();
        for (int i=0;i<es.size();i++){
            System.out.println("节点名称："+es.get(i).getName());
            System.out.println("节点内容："+es.get(i).getText());
            System.out.println("--------------------------------");
        }

result节点是root的子节点，内容依然为空。 

 

 我们解析以下子节点result下面的子节点：

List<Element> es1 = result.elements();
        for (int i=0;i<es1.size();i++)
        {
            System.out.println("result的子节点名称："+es1.get(i).getName());
            System.out.println("result的子节点内容："+es1.get(i).getText());
        }

 结果：

 结合最开始的xml文件：我们可以知道橘色标记为root的子节点，而绿色标记为result子节点 

二、Dom4J之XPATH解析XML（非重点）

XPATH是用路径表达式来解析文件。

 books
        book id=1
                name
                info
        book id=2
                name
                info

通过路径快速的查找一个或一组元素
路径表达式:
 1. /  :  从根节点开始查找
 2. // :  从发起查找的节点位置 查找后代节点 ***  （最常使用）
 3. .  :  查找当前节点
 4. .. :  查找父节点
 5. @  :  选择属性. * 
       属性使用方式:
       [@属性名='值']
       [@属性名>'值']
       [@属性名<'值']
       [@属性名!='值']

eg:查询id＝1的book的name：
 books:  路径： //book[@id='1']//name
 

常用方法是路径表达式2

eg：拿到文档对象，即可操作。

结果： 

 三、生成XML

一、步骤：

1. 通过文档帮助器 (DocumentHelper) , 创建空的文档对象
     Document doc = DocumentHelper.createDocument();
 2. 通过文档对象, 向其中添加根节点
     Element root = doc.addElement("根节点名称");
 3. 通过根节点对象root , 丰富我们的子节点
     Element e = root.addElement("元素名称");
 4. 创建一个文件输出流 ,用于存储XML文件
     FileOutputStream fos = new FileOutputStream("要存储的位置");
 5. 将文件输出流, 转换为XML文档输出流
     XMLWriter xw = new XMLWriter(fos); 
 6. 写出文档
     xw.write(doc);
 7. 释放资源
     xw.close();

eg：我们现在写一个book类：

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.XMLWriter;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo4 {
    public static void main(String[] args) throws IOException {
        //通过文档帮助器，创建一个文档对象
        Document doc = DocumentHelper.createDocument();
        //给文档添加一个根节点
        Element books = doc.addElement("books");
        //给根节点添加子节点
        for (int i=0;i<100;i++){
            Element book = books.addElement("book");
            //给子节点添加内容
            Element name = book.addElement("name");
            name.setName("第"+i+"本书");
            Element info = book.addElement("info");
            info.setText("第"+i+"个内容");
            //创建一个属性
            book.addAttribute("id",100+i+"");
        }
        //创建一个文件输出流，将文件存入d盘
        FileOutputStream os = new FileOutputStream("d://books.xml");
        /*可以存入c盘，我的c盘有权限无法存入，于是选择d
        * */
        XMLWriter xm = new XMLWriter(os);
        xm.write(doc);
        xm.close();
    }
}

结果：d盘中

 打开后：生成的xml文件

 但其实我们一般都不是自己创建节点，自己去创建一个XML文件。

一般情况下我们都是获得一个对象，再将对象封装为XML文档。而这里，我们也提供了一个工具---xstream

eg：写一个Person类

static class Person{
       private String name;
       private int age;
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Person person = (Person) o;
            return age == person.age && Objects.equals(name, person.name);
        }
        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public Person() {
        }
    }

main方法里转换xml文件：

public static void main(String[] args) {
        Person p = new Person();
        p.setAge(18);
        p.setName("白日梦想家");
        //创建XStream对象
        XStream xs = new XStream();
        //修改某个类型生成的节点（可选的，默认为包名.类名）
        xs.alias("Person",Person.class); //把Person类更改为Person节点，也就是说，创建一个Person类对象，根节点就是Person
        //传入对象，开始生成
        String xml = xs.toXML(p);
        System.out.println(xml);
    }

结果：

 Json解析(重点）

一、Json格式：

一个对象, 由一个大括号表示.
   括号中 描述对象的属性 . 通过键值对来描述对象的属性
   (可以理解为, 大括号中, 包含的是一个个的键值对.)
   格式:
键与值之间使用冒号连接, 多个键值对之间使用逗号分隔.
键值对的键 应使用引号引住 (通常Java解析时, 键不使用引号会报错. 而JS能正确解
析.)
键值对的值, 可以是JS中的任意类型的数据

eg：

{
        "name":"白日梦想家",
        "age":19,
        "book":["语文","数学","英语"{
              "name":"好好学习",
              "info":"天天向上"
           }],
        "heihei":{
          "zuoji":"摩托车",
          "method":"油"
       }
     }

这段话的意思就是：{}里是一个对象，对象名字“白日梦想家”，年龄19，对象的书籍：是一个数组，有语数英和一个新对象{名字“好好学习”，内容“天天向上”}。总对象还有“heihei”属性，里面又是一个对象。。。

所以由此可以看出来，Json没有什么层级格式，对象包含对象，包含数组，里面又有对象等等。。

解析Json

共有两种方式：1、谷歌的Gson

                         2、阿里的FastJson

这两个都可以在网上直接搜到，点入Github开源地址，可以直接下载jar文件。

Gson解析Json

转换JSON字符串的步骤:
  1.  引入JAR包
  2.  在需要转换JSON字符串的位置编写如下代码即可:
    String json = new Gson().toJSON(要转换的对象);

3.Json转文件的关键字：fromJson

eg：将对象转换成Json模式

现创建一个Book类，后面要用对象

import java.util.Objects;
public class Book {
    int id;
    String name;
    String info;
    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", info='" + info + '\'' +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Book book = (Book) o;
        return id == book.id && Objects.equals(name, book.name) && Objects.equals(info, book.info);
    }
    @Override
    public int hashCode() {
        return Objects.hash(id, name, info);
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getInfo() {
        return info;
    }
    public void setInfo(String info) {
        this.info = info;
    }
    public Book(int id, String name, String info) {
        this.id = id;
        this.name = name;
        this.info = info;
    }
    public Book() {
    }
}

转换： 

public class Demo1 {
    public static void main(String[] args) {
        //创建Json对象
        Gson g = new Gson();
        //将对象转化成Json格式
        Book b= new Book(100,"摩托车","毕业后买摩托车");
        String s = g.toJson(b);
        System.out.println(s);
    }
}

结果： 

eg2:将Json再转换为对象（或数组）：

{"id":100,"name":"摩托车","info":"毕业后买摩托车",page:["锄禾日当午","汗滴禾下土","谁知盘中餐"]}

格式：fromJson（“Json”，转化后的对象类型）

转对象：

        Gson g = new Gson();
        //将json格式转换成对象
        g.fromJson("{\"id\":100,\"name\":\"摩托车\",\"info\":\"毕业后买摩托车\"}",Book.class);
        System.out.println(b.getId());
    }

 

转数组：

public static void main(String[] args) {
        Gson g = new Gson();
        //将Json转化为数组
        HashMap hashMap = g.fromJson("{\"id\":100,\"name\":\"摩托车\",\"info\":\"毕业后买摩托车\",page:[\"锄禾日当午\",\"汗滴禾下土\",\"谁知盘中餐\"]}", HashMap.class);
        System.out.println(hashMap.get("id"));
        System.out.println(hashMap.get("name"));
        System.out.println(hashMap.get("info"));
        System.out.println(hashMap.get("page").getClass()); //输出class发现，属于ArrayList集合
        List page = (List) hashMap.get("page");
        System.out.println(page.get(0));
        System.out.println(page.get(1));
        System.out.println(page.get(2));
    }

 

结果：

 

 FastJson解析Json

转换JSON字符串的步骤:
  1.  引入JAR包
  2.  在需要转换JSON字符串的位置编写如下代码即可:
    String json=JSON.toJSONString(要转换的对象);

eg：将对象转换成Json模式

public static void main(String[] args) {
        Book b= new Book(102,"小汽车","毕业后买小汽车");
        //只需要一步：转换
        String json = JSON.toJSONString(b);
        System.out.println(json);
    }

结果：

 将Json转化为对象（或数组）

转对象：

 public static void main(String[] args) {
        //{"id":102,"info":"毕业后买小汽车","name":"小汽车"}
        //转对象：
        Book book = JSON.parseObject("{\"id\":102,\"info\":\"毕业后买小汽车\",\"name\":\"小汽车\"}",Book.class);
        System.out.println(book.getId());
        System.out.println(book.getInfo());
    }

结果：

转数组：

public static void main(String[] args) {
        //转换成数组(String类型的集合）
        //["123","456","789"]
        List<String> strings = JSON.parseArray("[\"123\",\"456\",\"789\"]", String.class);
        System.out.println(strings.get(1));
    }

 结果：

到这里呢，全部内容就结束了。有什么问题，欢迎留言~