JAVA第二阶段第十二天 XML & HTTP

XML

HTML 概述

html：是超文本标记语言，预定的一些标签，不需要编译，直接是由浏览器进行解析，标签不能自己随便定义

XML 概述

可扩展标记语言(标签)，官方没有给标签定义好规范，就是自定义标签

XML 的作用

1.配置文件
2.存储数据(数据库)
3.前后端传递数据(json)

XML 的书写规范

1.名称不能以数字或者标点符号开始
2.名称不能包含空格
3.文档必须有根元素，而且仅有一对根元素
4.标签区分大小写

XML 的组成部分

1.xml 的声明：<?xml version='1.0' encoding='UTF-8'?>
==>>xml 的版本：version=‘1.0’ (最新版本是1.1)
==>>xml 编码格式：encoding=‘UTF-8’
2.元素：html中的标签 例如：
3.属性： 比如id属性
4. <![CDATA ]：表示忽略特殊符号
5.注释：和 html 中的注释一样

XML 的特点

1.不会编译，有浏览器直接解析
2.只能存在一个根标签
3.元素一般都是成对的，也有单个的
4.区别大小写
5.后缀名是.xml

XML 解析

1.通常的解析：dom、dom4j 一般用于后台，把整个xml 加载到内存里，然后再进行解析，数据量大会导致内存溢出
2.sax 移动端：加载一行解析一行，移动端的内存比较小 ,解析比较麻烦
3.xpath：:是依赖于dom4j进行操作，dom 解析

dom 解析的步骤

XML在浏览器会加载成一个dom树，获取这个对象：

获取dom对象的步骤

1.创建getDom方法，DocumentBuilderFactory 调用 newInstance()方法 返回本身对象
2.再调用 newDocumentBuilder() 方法获取到解析器
3.调用其parse()方法读取文件转换为dom对象

private Document document;
    //把文件转化为dom对象
    public void getDom(){
        try {
            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
            DocumentBuilder db = dbf.newDocumentBuilder();
            document = db.parse(new File("收藏信息.xml"));
            System.out.println(document);
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

显示数据

1.创建show方法，根据document.getElementsByTagName(“标签”)对象获取标签元素，返回得到的是NodeList
2.标签进行遍历，.item()得到每一个Node标签
3.再强行转化成属性节点Element
4.根据键来获取值 getAttribute(“name”)返回String类型
==>> 获取这个节点下的子节点：
5.getChildNodes()返回NodeList
6.进行遍历获取其子节点
7.判断是否是元素节点：Element.ELEMENT_NODE
8.再进行遍历
9.强行转换
10.根据键来获取值 getAttribute(“name”) 返回String类型

public void show(){
        //根据对象获取标签元素
        NodeList nodebrandList = document.getElementsByTagName("Brand");
        //把标签元素进行遍历
        for (int i = 0;i < nodebrandList.getLength();i++){
            //获取到每一个节点对象
            Node nodeBrand = nodebrandList.item(i);
            //把节点对象转换为元素属性
            Element elementBrand = (Element)nodeBrand;
            //通过键来获取其值
            String brandName = elementBrand.getAttribute("name");
            System.out.println(brandName);

            //获取其子节点
            NodeList nodeListType = elementBrand.getChildNodes();
            //进行遍历
            for (int j = 0;j < nodeListType.getLength();j++){
                //获取到每一个子节点
                Node nodeType = nodeListType.item(j);
                //判断是否是元素节点
                if (nodeType.getNodeType() == Element.ELEMENT_NODE){
                    //转换为属性节点
                    Element elementType = (Element)nodeType;
                    //通过键来获取其值
                    String typeName = elementType.getAttribute("name");
                    System.out.println(typeName);
                }
            }
        }

增加一个节点

1.创建节点document.createElement(“Brand”) 返回Element
2.设置其属性 setAttribute(“name”, “opop”)
3.创建其子节点document.createElement(“Brand”) 返回Element
4.设置其属性 setAttribute(“name”, “r9”)
5.添加标签和属性的父子关系:appendChild(type)
6.获取根节点添加根标签和属性的父子关系

//增加一个节点
    public void add(){
        //创建属性节点
        Element brand = document.createElement("Brand");
        //设置其属性的值
        brand.setAttribute("name","oppo");
        //创建其子节点
        Element type = document.createElement("Type");
        //设置其子节点的值
        type.setAttribute("name","r19");
        //添加父子关系
        brand.appendChild(type);
        //type.getParentNode().appendChild(type);

        //获取根节点 添加父子关系
        document.getElementsByTagName("PhoneInfo").item(0).appendChild(brand);

    }

把dom对象保存到xml

1.先创建一个解析器格式化工厂 ：TransformerFactory 调用 newTransformer() ，返回自身对象
2.获取得到格式的类Transformer
3.创建DOMSource的对象，把document作为参数
4.new StreamResult(new OutputStreamWriter(new FileOutputStream(path),“utf-8”));
5.transform(ds, sr); 把dom 对象写入到文件里

//把创建的doc对象保存到xml文件里
    public void save(String path){
        try {
            //先创建一个格式化的解析工厂
            TransformerFactory tff = TransformerFactory.newInstance();
            //得到格式的类
            Transformer tf = tff.newTransformer();
            //把dom对象写到文件
            DOMSource ds = new DOMSource(document);
            StreamResult sr = new StreamResult(new OutputStreamWriter(new FileOutputStream(path)));
            tf.transform(ds,sr);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (TransformerException e) {
            e.printStackTrace();
        }
    }

修改

1获取节点:document.getElementsByTagName(“Brand”)返回的是NodeList
2.进行遍历,得到Node
3.获取每一个节点
4.强行转换为(Element)属性
5.设置其值:setAttribute

//修改
    public void update(){
        NodeList nodeBrandList = document.getElementsByTagName("Brand");
        for (int a = 0;a < nodeBrandList.getLength();a++){
            Node nodeBrand = nodeBrandList.item(a);
            Element elementBrand = (Element)nodeBrand;
            elementBrand.setAttribute("id",(a+1)+"");
        }
    }

删除节点:

1.通过 document.getElementsByTagName(“Brand”) 获取到所有的节点，返回NodeList
2.进行遍历
3.获取到每一个节点
4.强行转换为(Element)属性节点
5.通过键获取其值：getAttribute() 返回String
6.判断其值是否相等
7.相等就根据父节点删除子节点：getParentNode().removeChild()

 //删除节点
    public void delete(){
        //获取所有的Brand节点对象
        NodeList nodeBrandList = document.getElementsByTagName("Brand");
        //进行遍历
        for(int i = 0;i < nodeBrandList.getLength();i++){
            //得到每一个节点对象
            Node nodeBrand = nodeBrandList.item(i);
            //转化为属性节点
            Element elementbrand = (Element)nodeBrand;
            //通过键来获取其值
            String content = elementbrand.getAttribute("name");
            //判断其值是否相等
            if ("华为".equals(content)){
                //删除属性  根据父节点删除子节点
                elementbrand.getParentNode().removeChild(elementbrand);
            }
        }
    }

调用获取dom对象的方法

public static void main(String[] args) {
        Test test = new Test();
        test.getDoc();
        //test.add();
        //test.show();
        //test.update();
        test.delete();
        test.save("4.xml");
    }

dom4j 解析

对dom解析的一个封装，使得代码量变少，需要导入第三方的 jardom4j-1.6.1.jar

XML 文件转换成一个dom对象(dom4j jar 提供的)

1.实例化：SAXReader
2.read(new File(“传递是一个文件对象”))

private Document document;
    //把xml文件转化为一个dom对象
    public void getDom(){
        try {
            //作用：类似于解析器工厂
            SAXReader sr = new SAXReader();
            //调用其方法 读取文件
            document = sr.read(new File("收藏信息.xml"));
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }

XML 中的数据展示

1.获取其跟节点：getRootElement() 返回 Element
2.获取到根节点下所有的元素 elementIterator() 返回Iterator
3.进行遍历
4.根据键获取其值：attributeValue() 返回String，进行打印
==>>获取其子节点的显示：
5.获取属性节点下所有的元素 elementIterator() 返回Iterator
6.进行遍历
7.根据键获取其值：attributeValue() 返回String，进行打印

//展示xml文件中的手机品牌和型号
    public void show(){
        //获取根节点的方法
        Element elementRoot = document.getRootElement();
        //获取其下面的子节点
        //Iterator<Element> iterator = elementRoot.elementIterator();
        //遍历迭代器
        for (Iterator<Element> iterator = elementRoot.elementIterator();iterator.hasNext();){
            //获取到某一个节点
            Element elementbrand = iterator.next();
            //根据键获取其值
            System.out.println(elementbrand.attributeValue("name"));

            /*for (Iterator<Element> it = elementbrand.elementIterator();it.hasNext();){
                Element elementtype = it.next();
                System.out.println(elementtype.attributeValue("name"));
            }*/
            Iterator<Element> it = elementbrand.elementIterator();
            while (it.hasNext()){
                Element elementtype = it.next();
                System.out.println(elementtype.attributeValue("name"));
            }
        }

增加节点

1.获取跟节点：getRootElement() 返回 Element
2.添加一个子节点：addElement(“Brand”);
3. 设置其属性：addAttribute
4. 添加属性的子节点：addElement(“Type”)；
5. 设置其属性：addAttribute

//增加一个节点
    public void add(){
        //获取根节点
        Element element = document.getRootElement();
        //添加一个子节点
        Element elementBrand = element.addElement("Brand");
        //设置其属性
        elementBrand.addAttribute("name","oppo");
        //创建Brand 的子节点
        Element elementType = elementBrand.addElement("Type");
        //设置其属性
        elementType.addAttribute("name","r19");
        //不需要再额外的添加父子关系了
    }

修改节点

1.获取根节点：getRootElement()
2.获取到根节点下所有的元素 elementIterator() 返回Iterator
3.进行遍历
4.进行修改键值对：addAttribute()
5.注意点：没有该属性就增加

//修改
    public void update(){
        //获取根节点
        Element element = document.getRootElement();
        //进行遍历
        int id = 0;
        for (Iterator<Element> iterator = element.elementIterator();iterator.hasNext();){
            id++;
            Element elementBrand = iterator.next();
            elementBrand.addAttribute("id",id+"");
        }
    }

删除节点

1.获取根节点：getRootElement()
2.获取到根节点下所有的元素 elementIterator() 返回Iterator
3.进行遍历
4.进行判断其值是否相等
5.根据父节点进行删除子节点

//删除 name为 华为 的节点
    public void delete(){
        //获取根节点
        Element element = document.getRootElement();
        for (Iterator<Element> iterator = element.elementIterator();iterator.hasNext();){
            Element elementbrand = iterator.next();
            if (elementbrand.attributeValue("name").equals("华为")){
                elementbrand.getParent().remove(elementbrand);
            }
        }
    }

dom对象写入到文件

1.创建输出流对象：FileWriter(path)
2.添加的格式：OutputFormat.createPrettyPrint()
3.设置其编码格式：setEncoding(“utf-8”);
4.实例化写入的对象：XMLWriter(fw,of);
5.调用其写的方法 写到对象中：write()

HTTP

http协议

1.http 是一个超文本传输协议
2.http 协议主要是用于传输文本，使文本传输更加高效
3.协议其实就是一种传输的规范

http 协议版本

1.0版本：传输的时候，只能请求一个web资源，连接完成就断开
1.1 版本：可以请求多个web资源（不是同时），最新版本

协议的概述

1.http 协议：称为一次性协议(不安全)
2.https：http+ssl证书(保护数据的安全性)
3.socket ：就是长连接，只要连接成功，是不会断开的，socket中的心跳包来检测是否连接成功，即时通讯 xmpp+udp+tcp 结合使用
4.UDP：面向无连接，效率高、安全性低
5.TCP：面向连接，效率低、安全性高

http 的请求协议和响应协议

请求协议

1.也就是浏览器给服务器发送请求所遵循的规则

2.分为三个部分：
==>>1.请求行
==>>2.请求体
==>>3.请求头：都是键值对来进行表示 ,这个键都是预定义，也就是浏览器给其响应的含义

响应协议

1.也就是服务器给客户端响应所遵循的规则

2.分为三个部分：
==>>1.响应头 (关注)
==>>2.响应行
==>>3.响应体

3.响应的状态码：
==>>1.404 页面找不到
==>>2.302 重定向
==>>3.500 服务器发生了异常(代码出错了)
==>>4.200 请求成功
==>>5.304(表示缓存)

反射

1.框架的灵魂，所有的框架的技术都依赖于反射
2.框架：是一个半成品，使得开发更加简单
3.反射中的热修复：动态来修复bug，腾讯的bugly
4.反射：将类的各个部分组成一个新类 Class

java代码运行的三个阶段

1.源代码阶段
2.class阶段
3.运行阶段