XML与JSON

最新推荐文章于 2024-06-18 16:23:25 发布
最新推荐文章于 2024-06-18 16:23:25 发布
阅读量346 收藏
点赞数
文章标签： java xml json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45045934/article/details/112975320
版权
本文详细介绍了XML的介绍、语法、DOM4J解析及生成，以及JSON的简介、格式和Java中的Gson与FastJson库的使用。重点讨论了XML的DOM4J解析，并通过实例展示了XML和JSON之间的转换。
摘要由CSDN通过智能技术生成

XML与JSON

XML

XML介绍

  • 简介
    可扩展标记语言
  • 特性
    1. xml具有平台无关性，是一门独立的标记语言 。
    2. xml 具有自我描述性。
  • 为什么学习XML？
    1. 网络数据传输
    2. 数据存储
    3. 配置文件
  • XML文件
    .XML文件是保存XML数据的一种方式。
    XML数据也可以以其他的方式存在（如在内存中构建xml数据）。
    不要将XML语言狭隘的理解成XML文件。

XML语法

1.XML文档说明

<?xml version="1.0" encoding="UTF-8"?>

2.标记（元素/标签/节点）
XML文档，由一个个的标记组成
语法：

开始标记（开放标记）：<标记名称>
结束标记（闭合标记）：</标记名称>
标记名称：自定义名称，必须遵循以下命名规则：
				1. 名称可以含字母，数字以及其他字符
				2. 名称不能以数字或者标点开始
				3. 名称不能以字符"xml"（或者XML、Xml）开始
				4. 名称不能包括空格，不能包含冒号（:）
				5. 名称区分大小写
            标记内容：开始标记与结束标记之间，是标记的内容
            例如，我们通过标记，描述一个人名：
                        <name>TuiGe</name>

3.一个XML文档中，必须有且且仅允许有一个根标记。

        正例：
                    <names>
                        <name>寒冰</name>
                        <name>卡莎</name>
                    </names>
        反例：
                    <name>潘森</name>
                    <name>龙龟</name>

4.标记可以嵌套，但是不允许交叉

        正例：
                <person>
                    <name>霞</name>
                    <age>18</age>
                </person>
        反例：
                <person>
                    <name>劫<age></name>
                    22</age>
                </person>

5.标记的层级称呼（子标记，父标记，兄弟标记，后代标记，祖先标记）

     例如：
                <persons>
                    <person>
                        <name>提莫</name>
                        <length>5cm</length>
                    </person>
                    <person>
                        <name>亚索</name>
                        <length>180cm</length>
                    </person>
                </persons>
            name是person的子标记，也是person的后代标记。
            name是persons的后代标记。
            name是length的兄弟标记。
            person是name的父标记。
            persons是name的祖先标记。

6.标记名称允许重复。
7.标记除了开始和结束，还有属性。

  • 标记中的属性，在标记开始时描述，由属性名和属性值组成。
  • 格式：
    在开始标记中，描述属性。
    可以包含0-n个属性，每一个属性是一个键值对！
    属性名不允许重复，键与值之间使用等号连接，多个属性之间使用空格分隔。
    属性值，必须被引号引住。
        案例：
                <persons>
                    <person id="10001" groupid="1">
                        <name>小炮</name>
                        <age>18</age>
                    </person>
                    <person id="10002" groupid="1">
                        <name>露露</name>
                        <age>18</age>
                    </person>
                </persons>

8.注释

  • 注释不能写在文档声明前
  • 注释不能嵌套注释
            格式：
                    注释开始：<!--
                    注释结束：-->

语法进阶CDATA （了解）

  • CDATA
    CDATA 是不应该由 XML 解析器解析的文本数据。
    像 “<” 和 “&” 字符在 XML 元素中都是非法的。
    “<” 会产生错误，因为解析器会把该字符解释为新元素的开始。
    “&” 会产生错误，因为解析器会把该字符解释为字符实体的开始。
    某些文本，比如 JavaScript 代码，包含大量 “<” 或 “&” 字符。为了避免错误，可以将脚本代码定义为 CDATA。
    CDATA 部分中的所有内容都会被解析器忽略。
    CDATA 部分由 “<![CDATA[" 开始，由 "]]>” 结束。

Java解析XML（掌握）

问: Java中有几种XML解析方式 ? 分别是什么 ? 有什么样的优缺点 ?
答: 四种.

  1. SAX解析
    解析方式是事件驱动机制 !
    SAX解析器, 逐行读取XML文件解析 , 每当解析到一个标签的开始/结束/内容/属性时,触发事件.
    我们可以编写程序在这些事件发生时, 进行相应的处理.
    优点:
    分析能够立即开始，而不是等待所有的数据被处理
    逐行加载,节省内存.有助于解析大于系统内存的文档
    有时不必解析整个文档,它可以在某个条件得到满足时停止解析.
    缺点:
    1. 单向解析，无法定位文档层次，无法同时访问同一文档的不同部分数据(因为逐行解析, 当解析第n行是, 第n-1行已经被释放了, 无法在进行操作了).
    2. 无法得知事件发生时元素的层次, 只能自己维护节点的父/子关系.
    3. 只读解析方式, 无法修改XML文档的内容.
  2. DOM解析
    是用与平台和语言无关的方式表示XML文档的官方W3C标准，分析该结构通常需要加载整个文档和内存中建立文档树模型.程序员可以通过操作文档树, 来完成数据的获取 修改 删除等.
    优点:
    文档在内存中加载, 允许对数据和结构做出更改.
    访问是双向的，可以在任何时候在树中双向解析数据。
    缺点:
    文档全部加载在内存中 , 消耗资源大.
  3. JDOM解析
    目的是成为Java特定文档模型，它简化与XML的交互并且比使用DOM实现更快。由于是第一个Java特定模型，JDOM一直得到大力推广和促进。
    JDOM文档声明其目的是“使用20%（或更少）的精力解决80%（或更多Java/XML问题”（根据学习曲线假定为20%）
    优点:
    使用具体类而不是接口，简化了DOM的API。
    大量使用了Java集合类，方便了Java开发人员。
    缺点:
    没有较好的灵活性。
    性能不是那么优异。
  4. DOM4J解析
    它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能，包括集成的XPath支持、XML Schema支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项，DOM4J是一个非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML。
    目前许多开源项目中大量采用DOM4J , 例如:Hibernate

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();

文档对象 Document

  • 指的是加载到内存的 整个XML文档.
    常用方法:
    1. 通过文档对象, 获取XML文档中的根元素对象
    Element root = doc.getRootElement();
    2. 添加根节点
    Element root = doc.addElement(“根节点名称”);

元素对象 Element

  • 指的是XML文档中的单个节点.
    常用方法:
    1. 获取节点名称
    String getName();
    2. 获取节点内容
    String getText();
    3. 设置节点内容
    String setText();
    4. 根据子节点的名称 , 获取匹配名称的第一个子节点对象.
    Element element(String 子节点名称);
    5. 获取所有的子节点对象
    List elements();
    6. 获取节点的属性值
    String attributeValue(String 属性名称);
    7. 获取子节点的内容
    String elementText(String 子节点名称);
    8. 添加子节点
    Element addElement(String 子节点名称);
    9. 添加属性
    void addAttribute(String 属性名,String 属性值);

解析本地文件案例

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;


import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.List;


/**
* @Author: TuiGe
* @Description: XML解析
* @Date Created in 2021-01-20 22:07
* @Modified By:
*/
public class Demo1 {
    public static void main(String[] args) throws IOException, DocumentException {
        //1.获取输入流
        FileInputStream fis = new FileInputStream("C://Demo1.xml");
        //2.创建XML对象
        SAXReader sr = new SAXReader();
        //3.读取并得到文档对象
        Document doc = sr.read(fis);
        //4.通过文档获取根元素
        Element rootElement = doc.getRootElement();
        //5.开始解析元素
        System.out.println(rootElement.getName());




       /* Element book = rootElement.element("book");
        Element name = book.element("name");
        System.out.println(name.getText());*/
        List<Element> elements = rootElement.elements();
        for (int i = 0; i <elements.size(); i++){
            Element book = elements.get(i);
            //属性值
            System.out.println(book.attributeValue("id"));
            //直接获取子元素的内容
            System.out.println(book.elementText("name"));
            System.out.println(book.elementText("info"));
            System.out.println("----------------------------");
        }
        fis.close();
    }
}

解析网络文件案例

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.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;


/**
* @Author: TuiGe
* @Description: 网络文件解析
* @Date Created in 2021-01-20 22:32
* @Modified By:
*/
public class Demo2 {
    public static void main(String[] args) throws IOException, DocumentException {
        //String phone="13364024936";
        String phone="13584024936";
        //1.获取XML资源的输入流
        URL url = new URL("http://apis.juhe.cn/mobile/get?phone="+phone+"&dtype=xml&key=9f3923e8f87f1ea50ed4ec8c39cc9253");
        URLConnection conn = url.openConnection();
        InputStream is = conn.getInputStream();
        //2.创建一个XML读取对象
        SAXReader sr = new SAXReader();
        //3.通过读取对象，读取XML数据，并返回文档对象
        Document doc = sr.read(is);
        //4.获取根结点
        Element rootElement = doc.getRootElement();
        //5.解析内容
        String code = rootElement.elementText("resultcode");
        if ("200".equals(code)){
            Element result = rootElement.element("result");
            String province=result.elementText("province");
            String city=result.elementText("city");
            if(province.equals(city)){
                System.out.println("手机归属地为："+city);
            }else{
                System.out.println("手机归属地为"+province+" "+city);
            }
        }else {
            System.out.println("请输入正确手机号！");
        }
    }
}

DOM4J - XPATH解析

路径表达式

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

使用步骤

  • 通过Node类的两个方法, 来完成查找:
    (Node是 Document 与 Element 的父接口)
    方法1.
    //根据路径表达式, 查找匹配的单个节点
    Element e = selectSingleNode(“路径表达式”);
    方法2.
    List es = selectNodes(“路径表达式”);

解析本地案例

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;


import java.io.FileInputStream;
import java.io.IOException;
import java.util.List;


/**
* @Author: TuiGe
* @Description: XPATH解析本地文件
* @Date Created in 2021-01-20 22:07
* @Modified By:
*/
public class Demo3 {
    public static void main(String[] args) throws IOException, DocumentException {
        //1.获取输入流
        FileInputStream fis = new FileInputStream("C://Demo1.xml");
        //2.创建XML对象
        SAXReader sr = new SAXReader();
        //3.读取并得到文档对象
        Document doc = sr.read(fis);
        //4.通过文档对象+xpth，查找所有的name节点
/*        List<Node> names = doc.selectNodes("//book[@id='1001']//name");
        for (int i = 0; i < names.size(); i++) {
            System.out.println(names.get(i).getName());
            System.out.println(names.get(i).getText());
        }*/
        Node n = doc.selectSingleNode("//book[@id='1001']//name");
        System.out.println(n.getName()+":"+n.getText());


        fis.close();
    }
}

解析网络文件案例

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;


import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;


/**
* @Author: TuiGe
* @Description: XPATH网络文件解析
* @Date Created in 2021-01-20 22:32
* @Modified By:
*/
public class Demo4 {
    public static void main(String[] args) throws IOException, DocumentException {
        //String phone="13364024936";
        String phone="13584024936";
        //1.获取XML资源的输入流
        URL url = new URL("http://apis.juhe.cn/mobile/get?phone="+phone+"&dtype=xml&key=9f3923e8f87f1ea50ed4ec8c39cc9253");
        URLConnection conn = url.openConnection();
        InputStream is = conn.getInputStream();
        //2.创建一个XML读取对象
        SAXReader sr = new SAXReader();
        //3.通过读取对象，读取XML数据，并返回文档对象
        Document doc = sr.read(is);
        Node n = doc.selectSingleNode("//company");
        System.out.println("运营商为："+n.getText());
    }
}

Java生成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();

XML生成案例

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.XMLWriter;


import java.io.*;


/**
* @Author: TuiGe
* @Description: XML生成
* @Date Created in 2021-01-21 0:05
* @Modified By:
*/
public class Demo5 {
    public static void main(String[] args) throws IOException {
        //1.通过文档帮助器，创建一个文档对象
        Document doc = DocumentHelper.createDocument();
        //2.给文档添加第一个节点（根结点）
        Element books = doc.addElement("books");
        //3.通过根结点，丰富子节点
        for (int i = 0; i <100;i++){
            Element book = books.addElement("book");
            Element name = book.addElement("name");
            name.setText("种苹果的小姑娘");
            Element info = book.addElement("info");
            info.setText("辛勤种苹果的故事");
            book.addAttribute("id",100+i+"");
        }
        //4.创建文件的输出流
        FileOutputStream os = new FileOutputStream("D://books.xml");
        //5.将输出流转换为XML流
        XMLWriter xw = new XMLWriter(os);
        //6.写出文档
        xw.write(doc);
        //7.释放资源
        xw.close();
        System.out.println("执行完毕!");
    }
}

XStream 的使用（了解）

快速的将Java中的对象, 转换为 XML字符串.
使用步骤:

//1. 创建XStream 对象
XStream x = new XStream();
//2.修改类生成的节点名称 (默认节点名称为 包名.类名)
x.alias("节点名称",类名.class);
//3. 传入对象 , 生成XML字符串
String xml字符串 = x.toXML(对象);

XML对象生成案例

import com.thoughtworks.xstream.XStream;


import java.util.Objects;


/**
* @Author: TuiGe
* @Description: XML对象生成
* @Date Created in 2021-01-21 0:27
* @Modified By:
*/
public class Demo6 {
    public static void main(String[] args) {
        Person p=new Person();
        p.setName("寒冰");
        p.setAge(18);


        //XStream 使用
        //1.创建XStream
        XStream x=new XStream();
        //2.修改某个类型生成的节点（可选的，默认为包名、类名）
        x.alias("person",Person.class);
        //3.传入对象，开始生成
        String xml = x.toXML(p);
        System.out.println(xml);


    }
    static class Person{
        private String name;
        private int 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() {
        }


        @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;


            if (age != person.age) return false;
            return Objects.equals(name, person.name);
        }


        @Override
        public int hashCode() {
            int result = name != null ? name.hashCode() : 0;
            result = 31 * result + age;
            return result;
        }
    }
}

JSON

简介

JSON: JavaScript Object Notation JS对象简谱 , 是一种轻量级的数据交换格式.

对象格式

一本书
    书名
    简介
java
    class Book{
        private String name;
        private String info;
        get/set...
}
        Book b = new Book();
        b.setName(“金苹果”);
        b.setInfo(“种苹果”);
        ...
js:
        var b = new Object();
        b.name = "金苹果";
        b.info = "种苹果";
XML:
    <book>
        <name>金苹果</name>
        <info>种苹果</info>
    </book>
JSON:
    {
        "name":"金苹果",
        "info":"种苹果"
    }

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

数组格式

  • 在JSON格式中可以与对象互相嵌套
    [元素1,元素2…]

案例

{
    "name":"小炮"，
    "age":12,
    "pengyou":["提莫","小法","兰博","大头",{
                "name":"憨憨露露",
                "info":"一个快乐的约德尔人"
    }],
    "waihao":{
        "name":"锤形态波比",
        "wuqi":"大铁锤"
    }   
}

Java与JSON

  • 做什么?
    将Java中的对象 快速的转换为 JSON格式的字符串.
    将JSON格式的字符串, 转换为Java的对象

Gson

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

案例：

package com.java.json;


import com.google.gson.Gson;


/**
* @Author: TuiGe
* @Description: 谷歌json
* @Date Created in 2021-01-21 1:53
* @Modified By:
*/
public class Demo1 {
    public static void main(String[] args) {
/*        //1. 创建Gson对象
        Gson g=new Gson();
        //2. 转换
        Book book = new Book("100","金苹果","苹果种植真辛苦");
        String s= g.toJson(book);
        System.out.println(s);*/


        //1. 创建Gson对象
        //2. 转换
        Book book = new Book("100","金苹果","苹果种植真辛苦");
        String s= new Gson().toJson(book);
        System.out.println(s);
    }
}
  • 将JSON字符串转换为对象
    1. 引入JAR包
    2. 在需要转换Java对象的位置, 编写如下代码:
      对象 = new Gson().fromJson(JSON字符串,对象类型.class);

案例：

package com.java.json;


import com.google.gson.Gson;


import java.util.HashMap;
import java.util.List;


/**
* @Author: TuiGe
* @Description: 谷歌json
* @Date Created in 2021-01-21 1:53
* @Modified By:
*/
public class Demo2 {
    public static void main(String[] args) {
        //1. 创建Gson对象
        Gson g=new Gson();
        //2. 转换:{"id":"100","name":"金苹果","info":"苹果种植真辛苦","page":["苹果真红","苹果真大","苹果真好"]}
/*        Book book = g.fromJson("{\"id\":\"100\",\"name\":\"金苹果\",\"info\":\"苹果种植真辛苦\"}", Book.class);
        System.out.println(book.getId());*/


/*        HashMap data = g.fromJson("{\"id\":\"100\",\"name\":\"金苹果\",\"info\":\"苹果种植真辛苦\"}", HashMap.class);
        System.out.println(data.get("id"));*/


        HashMap data = g.fromJson("{\"id\":\"100\",\"name\":\"金苹果\",\"info\":\"苹果种植真辛苦\",\"page\":[\"苹果真红\",\"苹果真大\",\"苹果真好\"]}", HashMap.class);
        List page = (List)data.get("page");
        System.out.println(page.get(1));
    }
}

FastJson

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

案例：

package com.java.json;


import com.alibaba.fastjson.JSON;


/**
* @Author: TuiGe
* @Description: 阿里json
* @Date Created in 2021-01-21 2:17
* @Modified By:
*/
public class Demo3 {
    public static void main(String[] args) {
        Book book=new Book("1001","唐诗三百首","窗前明月光，疑是地上霜，举头望明月，低头思故乡。");
        //1.转换
        String json = JSON.toJSONString(book);
        System.out.println(json);
    }
}
  • 将JSON字符串转换为对象
    1. 引入JAR包
    2. 在需要转换Java对象的位置, 编写如下代码:
    类型 对象名=JSON.parseObject(JSON字符串, 类型.class);
    或
    List<类型> list=JSON.parseArray(JSON字符串,类型.class);

案例：

package com.java.json;


import com.alibaba.fastjson.JSON;

import java.util.List;


/**
* @Author: TuiGe
* @Description: 阿里json
* @Date Created in 2021-01-21 2:22
* @Modified By:
*/
public class Demo4 {
    public static void main(String[] args) {
        //1.转换 ：{"id":"1001","info":"窗前明月光，疑是地上霜，举头望明月，低头思故乡。","name":"唐诗三百首"}
/*        Book book = JSON.parseObject("{\"id\":\"1001\",\"info\":\"窗前明月光，疑是地上霜，举头望明月，低头思故乡。\",\"name\":\"唐诗三百首\"}", Book.class);
        System.out.println(book.getId());*/


        //1.转换 ：["一二三","二三四","三四五"]
        List<String> strings = JSON.parseArray("[\"一二三\",\"二三四\",\"三四五\"]", String.class);
        System.out.println(strings.get(1));
    }
}
温暖的光丶
关注
Linux设备树（device tree）
04-25
设备树（device tree）机制是Linux内核从linux-3.x版本开始引进的一种机制，目的是解决内核源码的arch/arm目录下代码混乱的问题：随着ARM生态的快速发展，在内核源码的arch/arm目录下，存放着几十种arm芯片和几百个开发板相关的源文件，很多开发板和处理器的中断、寄存器等相关硬件资源都在这个目录下以.c或.h的文件格式定义。而对于内核来说，与这些硬件耦合，会导致内核代码混乱不堪，每个开发板上运行的内核镜像都必须单独编译配置，无法通用。什么时候Linux内核能像Windows镜像那样，无论你的电脑什么配置，一个Windows安装包，都可以直接下载安装运行呢？设备树机制，实现了Linux内核和硬件平台的解耦：每个硬件平台的硬件资源使用一个设备树文件（xxx.dts）来描述，而不是在arch/arm下以.c 或 .h 文件来定义。Linux内核是一个通用的内核，在启动过程中，在通过解析设备树中的硬件资源来初始化某个具体的平台。 引入设备树后，很多和内核驱动开发的工作也发生了变化：以往驱动工程师关注的头文件宏定义、寄存器定义，现在这些基本上不用关注，关注的重点则转向了如何根据硬件平台去配置和修改设备树文件。很多驱动的编程接口也发生了变化，开始慢慢使用device tree提供的编程接口去开发驱动。本期课程主要面向嵌入式开发人员，分享Linux下驱动开发所需要的设备树知识和必备技能
dts 和 dtsi
weixin_43295247的博客
02-18 2634
dtsi的使用方法，类似于C语言的头文件，在dts文件中需要进行include *.dtsi文件。当然，dtsi本身也支持include 另一个dtsi文件。.dts文件是一种ASCII文本对Device Tree的描述，放置在内核的/arch/arm/boot/dts目录。这些dts势必会存在许多共同部分，为了减少代码的冗余，设备树将这些共同部分提炼保存在。.dtsi文件作用：由于一个SOC可能有多个不同的电路板，而每个电路板拥有一个。.dtsi文件中，供不同的dts共同使用。
从零开始理解 XML 和 JSON 的区别
最新发布
py0007的博客
06-18 1030
在这篇文章中，我们将深入探讨XML和JSON这两种数据格式的关键异同点，以便读者可以根据项目需求做出明智的技术选择。
XML与JSON，java解析和生成XML，java解析和生成json
qq_43206800的博客
09-09 555
XML 特性: xml具有平台无关性, 是一门独立的标记语言. xml具有自我描述性 为什么学习XML 网络数据传输. 数据存储 配置文件 XML语法格式 XML文档声明 <?xml version="1.0" encoding="UTF-8"?> 标记 ( 元素 / 标签 / 节点) XML文档,由一个个的标记组成. 语法: 开始标记(开放标记): <标记名称> 结束标记(闭合标记): </标记名称> 标记名称: 自定义名称，必须遵循以下命名规则： 1.名
设备树源码dts的格式讲解：dtsi的 i 就是include，其在dts文件中被include包含
二进制模----细微行动改变影响世界
08-11 3669
设备树源码dts的格式讲解：dtsi的 i 就是include，其在dts文件中被include包含
设备树源码（即xxx.dts或xxx.dtsi文件）的格式
主要记录嵌入式学习与开发过程。
10-21 1799
以下内容源于朱有鹏嵌入式课程的学习与整理，如有侵权请告知删除。
XML与JSON文件代码例子
06-07
在软件开发中，XML常用于配置文件、SOAP协议、数据存储等场景，而JSON则常用于RESTful API的数据交换、前端与后端的数据传递等。选择XML还是JSON，通常取决于具体需求，如数据的复杂性、文件大小、解析速度和开发...
xml与json互转的源码
04-11
XML以其丰富的结构化特性适用于复杂的数据表示，而JSON因其简洁、易于阅读和解析的特性，常用于前端与后端的数据交互。 XML到JSON的转换通常涉及到以下几个关键知识点： 1. **XML解析**：首先，我们需要解析XML...
C# XML与Json之间相互转换实例详解
12-26
对于这转换其实很简单，其中最重要的就是先要引用类库。...XML转换为Json字符串　 代码如下: string xml = @”<?xml version=””1.0″” standalone=””no””?>    ””1″”>  <name>Alan  
Xstream操作Xml与Json.doc
05-05
**Xstream 操作 Xml 与 Json** Xstream 是一个 Java 库，用于处理 XML 文件的序列化和反序列化，同时也支持将 JavaBean 转换为 JSON 格式。它的核心理念是通过简单的 API 设计，使得 XML 序列化过程变得简洁，无需...
java实现Xml与json之间的相互转换操作示例
10-16
Java实现Xml与json之间相互转换操作的知识点主要包括以下几个方面： 1. Xml与json的定义与区别：Xml是一种标记语言，用来描述和存储数据，具有自我描述性，而json是一种轻量级的数据交换格式，它易于人阅读和编写，...
设备树（DTS）简介
The simple, The best.
03-20 1684
设备树（DTS）简介 文章目录设备树（DTS）简介前言1. 设备树的基本知识1.1 dts1.2 dtsi1.3 dtc1.4 dtb2. DTS语法2.1 设备树的结构2.2 节点和属性2.2.1 节点2.2.2属性2.3 特殊节点3. DTS 常用of函数3.1 查找节点的of函数3.1.1 of_parse_phandle函数3.1.2 of_find_node_by_name 函数3.1.3 of_find_node_by_type函数3.1.4 of_find_compatible_node函数3
设备树学习系列 2 ——设备树文件 DTS
qq_33249042的博客
05-16 1502
文章目录前言一、pandas是什么？二、使用步骤总结 前言 一、pandas是什么？ 二、使用步骤 总结
Device Tree中的.dts和.dtsi文件
weixin_38428439的博客
12-19 1459
1、DeviceTree概念 DeviceTree由一系列被命名的结点（node）和属性（property）组成，而结点本身可包含子结点。所谓属性，其实就是成对出现的name和value。在DeviceTree中，可描述的信息包括（原先这些信息大多被hardcode到kernel中）： CPU的数量和类别 内存基地址和大小 总线和桥 外设连接 中断控制器和中断使用情况 ...
【Linux设备树】设备树基础 DTS,DTSI,DTC及DTB之间的关系
Tschome的博客
12-08 4439
设备树是一种描述硬件的数据结构,它起源于。在Linux 2.6中,ARM架构的板极硬件细节过多地被硬编码在和中,采用设备树后,许多硬件的细节可以直接通过它传递给Linux,而不再需要在内核中进行大量的冗余编码。设备树由一系列被命名的节点()和属性()组成,而节点本身可包含子节点。所谓属性,其实就是成对出现的名称和值。在设备树中,可描述的信息包括(原先这些信息大多被硬编码在内核中):它基本上就是画一棵电路板上CPU、总线、设备组成的树,会将这棵树传递给内核,然后内核可以识别这棵树,并根据它展开出Linux内核
dts设备树 基础语法
u011995183的博客
11-09 316
此外，还有一些Linux内核定义好的，一类设备通用的有默认意义的属性，这些属性一般不能被内核自动解析生成相应的设备信息，但是内核已经编写的相应的解析提取函数，常见的有 “mac_addr”，“gpio”，“clock”，“power”。驱动可以通过相应的函数从中提取信息。设备树是一个描述硬件的数据结构，甚至你可以将其看成一个大结构体（这个结构体就是平台，成员就是具体的设备），需要注意的是设备树并不能解决所有的硬件配置问题（例如：机器识别），它只是提供一种语言，将硬件的配置从linux内核的源码中提取出来。
【Linux】设备树详解dts
houxiaoni01的博客
06-30 3511
在Linux3.x版本后，arch/arm/plat-xxx和arch/arm/mach-xxx中，描述板级细节的代码（比如platform_device、i2c_board_info等）被大量取消，取而代之的是设备树，其目录位于arch/arm/boot/dts 1. 设备树的组成 1个dts文件+n个dtsi文件，它们编译而成的dtb文件就是真正的设备树。 soc厂商会把soc公共的特性和多块开发板公用的特性提炼为dtsi，而dts则负责描述某个具体的产品（开发板）的特性。dts直接或间接的包含多个dt
DTS学习
qq_41507111的博客
04-27 1303
DTS基础格式 1.后缀名一般为dts和dtsi，可以被include，甚至可以include那些C语言的头文件，dtsi文件可以理解为dts的头文件，dtsi的 i 就是include，其在dts文件中被include包含。 2. 注释用/* */，#开头的不是注释 3. 分号是段落块之间的分隔符，{}和[]和<>是段落块的封装符号 4. /{}是根节点root node，理论上只应该有一个根节点，根节点的名称必须是"/" 5. dts是树状的多节点组织，基本单元是node，除root外其他n
Linux驱动——设备树
Linux驱动开发工程师，熟悉Linux/Android底层驱动、TP、显示、IIC、网络等通用外设调试适配，Linux上层应用开发，主要集中在瑞芯微和全志平台。
04-10 3353
设备树是用于描述一个机器或平台上所有设备信息的独立文件（一个结构体变量）例如：一块开发板有SOC、CPU、CLOCK，SOC中又存在外设IIC、UART等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值