XML

Extensible Market Language 可擴展標記語言

1. XML是特殊文件形式嗜浮，結(jié)構(gòu)化文件
2. 做數(shù)據(jù)保存
3. 做信息交互和共享的（重點，數(shù)據(jù)傳輸）
4. 做系統(tǒng)的配置文件數(shù)據(jù)

XML作用

1. 數(shù)據(jù)交換：不同的計算機語言之間舒萎，不同的操作系統(tǒng)之間致燥，不同的數(shù)據(jù)庫之間，進行數(shù)據(jù)交換

01_XML數(shù)據(jù)交換.png

2. 配置文件：在后期我們主要用于各種框架的配置文件

   <?xml version="1.0" encoding="utf-8" ?>
   <server-config>
       <default-config>
           <property name = "driverClass">com.zimo.jdbc.Driver</property>
           <property name = "jdbcUrl">jdbc:mysql://localhost:3306/test</property>
           <property name = "user">root</property>
           <property name = "password">123456</property>
       </default-config>
   </server-config>
   

XML的特點

• 用于數(shù)據(jù)交互赂韵，用于數(shù)據(jù)的存儲娱节，用于做系統(tǒng)的配置文件
• 區(qū)分大小寫
• 非常嚴謹，只要有錯誤祭示，解析器就不能解析
• 可以擴展的肄满，所有的標簽都是程序員自己創(chuàng)建出來
• XML文件的后綴為.xml

注意：XML以后通過Java來進行解析，很少直接在瀏覽器上顯示

XML由七種組成元素構(gòu)成：

1. 聲明（抬頭）：必須在第一行

   version:指定XML文件使用的版本，取值是1.0

   encoding:當前xml使用的編碼(字符集)

   standalone:指定當前這個XML文件是否是一個獨立的文件稠歉，省略的讥电，默認是獨立文件

2. 元素（標簽）

   語法：<a>開頭 內(nèi)容 </a>結(jié)尾

   主體部分：標簽分為有主體和沒有主體的兩種，如果沒有主題轧抗，標簽一定要結(jié)束

   大小寫：區(qū)分大小寫

   命名：不能由空格恩敌，不能有冒號

   根元素：有且只有一個根元素

3. 屬性

   例如：<person id = "10086">

4. 注釋

5. 實體字符

02_實體字符.png

6. CDATA字符數(shù)據(jù)區(qū)

7. 處理指令

<?xml version="1.0" encoding="UTF-8" ?>     <!-- 1.聲明 抬頭 -->
<!-- 2.注釋 這就是注釋 -->
<!-- 3.標簽(元素) 一個XML文件只能有一個根標簽 -->

<!-- 7.實體字符 導(dǎo)入外部css樣式，控制xml效果横媚，沒用纠炮，xml不是為了展示 -->
<?xml-stylesheet type="text/css" href="student.css" ?>
<Student>
    <!-- 4.屬性信息 id，desc -->
    <name id = "1" desc = "高富帥">zimo</name>
    <age>18</age>
    <!-- 5.實體字符 不能使用特殊字符灯蝴，必須使用轉(zhuǎn)義實體字符 -->
    <sql><!-- select * from student where age > 18 && age < 30; -->
        select * from student where age &gt; 18 &amp;&amp; age &lt; 30;
    </sql>
    
    <!-- 6.實體字符 -->
    <sql>
        <![CDATA[
            select * from student where age > 18 && age < 30;
       ]]>
    </sql>
</Student>

版本說明

w3c在1988年2月發(fā)布1.0版本恢口，2004年2月發(fā)布1.1版本，因為1.1不能向下兼容1.0版本穷躁，所以1.1沒有人用耕肩，在2004年2月w3c又發(fā)布了1.0版本的第三版

• 小結(jié)：

  1. 聲明有哪兩個常用屬性？

     version问潭、encoding

  2. 一個XML有幾個根元素猿诸？

     一個

  3. XML標簽命名不能有什么符號？

     空格狡忙、冒號

• 一個良好的XML有以下特點

  1. 必須以XML聲明開頭
  2. 必須擁有唯一的根元素
  3. 開始標簽必須與結(jié)束標簽相匹配
  4. 元素對大小寫敏感
  5. 所有的元素必須關(guān)閉
  6. 所有的元素必須正確地嵌套
  7. 特殊字符必須使用實體字符或使用字符數(shù)據(jù)區(qū)

XML約束：

XML文件的標簽和屬性可以隨意擴展梳虽，有時我們必須要限制每個文檔有哪些元素，每個元素都有哪些子元素灾茁，每個元素有哪些屬性等，從而保證XML文檔格式和數(shù)據(jù)的正確性和規(guī)范性

DTD約束

1. DTD：Document Type Definiation 文檔類型定義
2. 作用：純文本文件禀挫，指定了XML約束規(guī)則

如：hibernate框架的導(dǎo)入方式

<!DOCTYPE hibernate-configuration PUBLIC                          <!-- hibernate-configuration 根元素 -->
"-//Hibernate/Hibrenate Configuration DTD 3.0//EN"                 <!-- DTD文件描述 -->
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">     <!-- DTD文件 -->

<hibernate-configuration>

</hibernate-configuration>

自定義books.dtd文件

<!ELEMENT   書架  (書+) >                  // 書架
<!ELEMENT   書   (書名, 作者, 售價) >        // 至少一本書
<!ELEMENT   書名  (#PCDATA) >              // 書名
<!ELEMENT   作者  (#PCDATA) >              // 作者
<!ELEMENT   售價  (#PCDATA) >              // 售價

使用books.dtd文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE 書架 SYSTEM "books.dtd">
<書架>
    <書>
        <書名></書名>
        <作者></作者>
        <售價></售價>
    </書>
</書架>

DTD約束：只能約束標簽腻格，無法約束類型

Schema約束

• DTD的不足：
  1. 不能驗證數(shù)據(jù)類型
  2. 因為DTD是一個文本文件，本身不能驗證是否正確

Schema特點

1. 約束文件本身也是一個XML文件啥繁，它本身也會被其它xsd文檔約束
2. 內(nèi)置多種數(shù)據(jù)類型，可以檢查數(shù)據(jù)類型是否正確
3. 支持命名空間旗闽，一個XML文件可以同時引入多個xsd的約束文件，讓約束規(guī)則重用
4. 擴展名為xsd：XML Schema Definition

約束文件擴展名XML模式定義：xsd

約束文件本身也是XML文件嫡意，所以也有根元素捣辆，根元素名字叫：Schema

模式文檔和實力文檔

• 模式文檔：指定約束的XML文檔（類似：類）
• 實例文檔：被約束的XML文檔（類似：對象）

<?xml version="1.0" encoding="UTF-8" ?>
<schema xmlns="http://www.w2.org/2001/XMLSchema"
        targetNamespace="http://www.zimo.cn"
        elementFormDefault="qualified">
<!-- targetNamespace:聲明約束文檔的地址（命名空間） -->
    <element name = "書架">
        <!-- 寫子元素 -->
        <complexType>
            <!-- maxOccurs='unbounded':書架下的子元素可以有任意多個 -->
            <sequence maxOccurs='unbounded'>
                <element name="書">
                    <!-- 寫子元素 -->
                    <complexType>
                        <!-- 子元素必須有序 -->
                        <sequence>
                            <element name="書名" type='string' />
                            <element name="作者" type='string' />
                            <element name="售價" type='double' />
                        </sequence>
                    </complexType>
                </element>
            </sequence>
        </complexType>
    </element>
</schema>

<?xml version="1.0" encoding="UTF-8" ?>
<書架 xmlns="http://www.zimo.cn"
     xmlns:xsi="http://www.w2.org/2001/XMLSchema"
     xsi:schemaLocation="http://www.zimo.cn books.xsd">
    <書>
        <書名>11</書名>
        <作者>aa</作者>
        <售價>99.8</售價>
    </書>
    <書>
        <書名>22</書名>
        <作者>bb</作者>
        <售價>88.8</售價>
    </書>
</書架>

XML的解析方式

1. DOM解析：文檔對象模型（面向?qū)ο蠼馕龇绞剑?
   • 優(yōu)點：將整個XML文件加載到內(nèi)存中旧巾，生成DOM樹忍些，可以隨意訪問任意節(jié)點
   • 缺點：占內(nèi)存罢坝，XML過大可能會內(nèi)存溢出
2. SAX解析：
   • 事件驅(qū)動型解析方式，讀取一行就解析一行隙券，釋放內(nèi)存是尔】觯可以解析任意大小的XML文件
   • 缺點：使用過不能再次訪問，不能修改恩溅，只能查詢

Java中的DOM解析開發(fā)包

1. JAXP：Oracle官方提供API脚乡，同時支持DOM和SAX
2. JDOM：開源項目滨达，基于樹形結(jié)構(gòu)捡遍，利用純Java的技術(shù)對XML文檔實現(xiàn)解析画株、生成啦辐、序列化及多種操作
3. ：是JDOM升級版芹关，性能優(yōu)異紧卒，功能強大跑芳，使用簡單聋亡，性能超過sun公司的dom技術(shù)，Habrenate也是用它讀寫配置
4. Jsoup：是一款Java和HTML和XML解析器漂佩，可以解析URL地址投蝉、HTML文本內(nèi)容征堪。

DOM4j中DOM樹的API

Dom4j安裝步驟

1. 下載dom4j框架谐算，jar包
2. 把dom4j核心jar包導(dǎo)入項目
3. 項目中創(chuàng)建文件夾：lib
4. 將dom4j.jar復(fù)制到lib中
5. 在jar文件夾上右鍵洲脂，Add As Library
6. 類中導(dǎo)包使用

• Java提供了Class下的一個方法：public InputStream getResourceAsStream(String path)

  | -- 用于加載文件稱為一個字節(jié)輸入流返回？纸酢！

• Document文檔：

  • Element getRootElement()：獲取根元素
  • String getName()：取元素名稱
  • List<Element> elements()：獲取當前元素下的全部子元素（一級）
  • List<Element> elements(String name)：獲取當前元素下指定名稱的全部子元素（一級）
  • Element element(String name)：獲取當前元素下的指定名稱的某個子元素，默認取第一個

• Element元素的API：

  • List<Attribute> attributes()：獲取元素的全部屬性對象
  • Attribute attribute(String name)：根據(jù)名稱獲取某個元素的屬性對象
  • String attributeValue(String var1)：直接獲取某個元素的某個屬性名稱的值

• Attribute對象的API：

  • String getName()：獲取屬性名稱
  • String getValue()：獲取屬性值

• Element：

  • String elementText(String name)：可以直接獲取當前元素的子元素的文本內(nèi)容
  • String elementTextTrim(String name)：去前后空格飘蚯，直接獲取當前元素的子元素的文本內(nèi)容
  • String getText()：直接獲取當前文本內(nèi)容
  • String getTextTrim()：去前后空格局骤，直接獲取當前文本內(nèi)容

案例：

/* Contact類 */
/**
 *  <contact id = "1" vip = "true">
 *  <name>潘金蓮</name>
 *  <sex>女</sex>
 *  <email>panpan@zimo.com</email>
 *  </contact>
 */
public class Contact{
    private int id;
    private boolean vip;
    private String name;
    private char sex;
    private String email;
    public Contact(){
    }
    public Contact(int id, boolean vip, String name, char sex, String email){
        this.id = id;
        this.vip = vip;
        this.name = name;
        this.sex = sex;
        this.email = email;
    }
    // 各個屬性的get,set方法.....
}

package com.zimo.Dom4j案例解析;
/**
 *  Dom4j解析XML文件：Contacts.xml成為一個Java對象（集合對象）
 *  Contacts.xml 解析成 ===>>> List<Contact>
 *  分析：
 *      1.定義一個聯(lián)系人封裝聯(lián)系人數(shù)據(jù)
 *      2.解析成List集合
 */

public class Dom4JDemo{
    public static void main(String args[]) throws Exception{
        // 1.創(chuàng)建一個dom4j的解析器對象：代表整個dom4j框架
        SAXReader sa = new SAXReader();
        
        // 2.通過解析器對象去加載xml文件數(shù)據(jù)峦甩，成為一個document文檔樹對象
        Document d = sa.read(new File("zimo/src/Contacts.xml"));
        
        // 3.獲取根元素
        Element eRoot = d.getRootElement();
        
        // 4.獲取根元素下的全部子元素
        List<Element> eSon = eRoot.elements();
        
        // 5.遍歷子元素 封裝成list集合對象
        List<Contact> conList = new ArrayList();
        if(eSon != null && eSon.size() > 0){
            for(Element e : eSon){
                int id = Integer.valueOf(e.attributeValue("id"));
                boolean vip = Boolean.valueOf(e.attributeValue("vip"));
                String name = String.valueOf(e.elementText("name"));
                char sex = e.elementText("sex").charAt(0);
                String email = String.valueOf(e.elementText("email"));
                Contact contact = new Contact(id,vip,name,sex,email);
                conList.add(contact);
            }
        }
    }
}

Dom4j中的XPath

作用：一種用于快速查找XML元素的路徑表達式凯傲，是用于方便的檢索XML文件中的信息

• XPath使用步驟

  1. 導(dǎo)入dom4j框架（XPath依賴dom4j技術(shù)）
  2. 導(dǎo)入XPath獨有的框架包冰单。jaxen.jar

• XPath常用的API：

  • List<Node> selectNodes(String var1)：檢索出一批節(jié)點集合
  • Node selectSingleNode(String var1)：檢索出一個節(jié)點返回

• XPath提供四種檢索數(shù)據(jù)的寫法

  1. 絕對路徑：/根元素/子元素/子元素

  2. 相對路徑：./子元素/子元素（.代表了當前元素）

  3. 全文搜索：

     //元素 在全文查找這個元素

     //元素1/元素2 在全文招元素1下面一級元素2

     //元素1//元素2 在全文找元素1下面的全部元素2

  4. 屬性查找：

     //@屬性名稱 在全文檢索屬性對象

     //元素[@屬性名稱] 在全文檢索包含該屬性的元素對象

     //元素[@屬性名稱=值] 在全文檢索包含該屬性的元素且屬性值為該值的元素對象

public class Dom4JDemo{
    public static void main(String args[]) throws Exception{
        // 1.創(chuàng)建一個dom4j的解析器對象
        SAXReader sa = new SAXReader();
        // 2.通過解析器對象去加載xml文件數(shù)據(jù)诫欠，成為一個document文檔樹對象
        InputStream is = Dom4JDemo.class.getResourceAsStream("/Contacts.xml")
        Document d = sa.read(is);
        
        // 3.1 使用絕對路徑定位全部的name名稱
        List<Node> nameNodes = d.selectNodes("/contact/name");  // 從文檔根路徑開始
        for(Node n : nameNode){
            System.out.println(n.getText());
        }
        --------------------------------------------------------------------------
        // 3.2 使用相對路徑定位
        // 得到根元素對象
        Element root = document.getRootElement();
        // 從根元素開始檢索
        List<Node> nameNodes = root.selectNodes("./name");
        --------------------------------------------------------------------------
        // 3.3全文檢索
        List<Node> nameNodes = document.selectNodes("http://name");      // 全文所有name節(jié)點
        List<Node> nameNodes = document.selectNodes("http://contact/name");      // 全文所有contact/name節(jié)點
        List<Node> nameNodes = document.selectNodes("http://contact//name");     // 全文contact下所有name節(jié)點
        --------------------------------------------------------------------------
        // 3.3全文檢索-所有屬性
        List<Node> attr = document.sattelectNodes("http://@id");         // 全文所有id屬性對象
        for(Node att : attr){
            Attribute a = (Attribute) att;
            System.out.println(n.getText());
        }
        List<Node> nodeEles = document.selectNodes("http://contact[@id]");       // 全文所有contact下包含id屬性的
        for(Node nodeEles : nodeEles){
            System.out.println(nodeEles.getName());
        }
        Node nodeEle = document.selectSingleNode("http://contact[@id = 1]");     // 全文所有contact下包含id = 1屬性的
        Element ele = (Element) nodeEle;
        System.out.println(ele.elementTextTrim("name"));
}

解析MyBatis配置文件

03_sqlMapConfig.png

public class ParseXMLConfig{
    public void parseXML() throws Exception{
        // 1.創(chuàng)建一個解析器對象
        SAXReader sr = new SAXReader();
        // 2.加載類路徑下的xml文件成為一個document文檔對象
        Document d = sr.read(ParseXMLConfig.class.getResourceAsStream("/sqlMapConfig.xml"));
        // 3.得到根元素對象
        Element root = d.getRootElement();
        // 4.獲取子元素environments
        Element env = root.element("environments");
        // 5.獲取子元素environment
        Element en = env.element("environment");
        // 6.獲取子元素dataSource
        Element data = en.element("dataSource");
        // 7.獲取dataSource下的全部子元素
        List<Element> properties = data.elements();
        // 8.遍歷屬性
        for(Element p : properties){
            System.out.println(p.attributeValue("name") + "===" + p.attributeValue("value"))
        }
    }
}

工廠模式

• 工廠模式（Factory Pattern）是Java中最常用的設(shè)計模式之一
• 這種類型的設(shè)計模式屬于創(chuàng)建型模式典鸡，它提供了一種創(chuàng)建對象的方式
• 之前我們創(chuàng)建類對象時萝玷，都是new對象的形式創(chuàng)建球碉，除了new以外工廠模式也可以創(chuàng)建

工廠模式的作用

1. 對象通過工廠的方法創(chuàng)建返回，工廠的方法可以為該對象進行加工和數(shù)據(jù)注入
2. 可以實現(xiàn)類與類之間的解耦合操作（核心思想）

小結(jié)：

• 優(yōu)點：工廠模式的存在可以改變創(chuàng)建對象的方式法精，解決類與類之間的耦合性
• 缺點：工廠設(shè)計模式多了一個工廠類

public abstract class Animal{
    public abstract void run();
}

public class Car extends Animal{
    @Override
    public void run(){
        System.out.println("能抓魚");
    }
}

public class Dog extends Animal{
    @Override
    public void run(){
        System.out.println("看門");
    }
}

• 工廠設(shè)計模式

public class FactoryPattern{
    // 不用動其他模塊的代碼搂蜓，統(tǒng)一由工廠調(diào)控
    public static Animal createAnimal(){
        return new Dog();
    }
    public static Animal createAnimal1(){
        return new Cat();
    }
}

public static void main(String args[]){
    // 舊方式
    Animal a = new Cat();
    a.run();
    // 工廠模式
    Animal a = FactoryPattern.createAnimal();
    a.run();
}

裝飾模式

在不改變原來類帮碰，不適用繼承的基礎(chǔ)上殉挽，動態(tài)地擴展一個類的功能

思想：創(chuàng)建要給新類，包裝原始類一死，從而在新類中提升原來的功能

小結(jié)：裝飾類可以在不改變原類的基礎(chǔ)上對類中的方法進行擴展增強投慈，實現(xiàn)原則為：

1. 定義父類
2. 定義原始類冠骄，繼承父類凛辣，定義功能
3. 定義裝飾類扁誓，繼承父類，包裝原始類择克，增強功能

Commons-io包的使用

Commons-io是apache開源基金組織提供的一組有關(guān)IO操作的類庫肚邢，可以提高IO功能開發(fā)的效率

• org.apache.commons.io ：有關(guān)Streams拭卿、Readers峻厚、Writes惠桃、Files的工具類
• org.apache.commons.io.input ：輸入流相關(guān)的實現(xiàn)類，包含Reader和InputStream
• org.apache.commons.io.output ：輸出流相關(guān)的實現(xiàn)類劈狐，包含Writer和OutputStream
• org.apache.commons.io.serialization ：序列化相關(guān)的類

步驟：

1. 下載Commons-io相關(guān)的jar包
2. 復(fù)制到指定的Module的lib目錄中
3. 加入到classpath中

public static void main(String args[]){
    // 使用框架復(fù)制文件
    IOUtils.copy(new FileInputStream("01_Demo/1.txt"), new FileOutputStream("01_Demo/2.txt"));
    // 使用框架文件復(fù)制到文件夾
    FileUtils.copyFileToDirectiry(new File("01_Demo/1.txt"), new File("D:/JavaTest"));
    // 使用框架文件夾復(fù)制到文件夾
    FileUtils.copyFileToDirectiry(new File("D:/zimo"), new File("D:/JavaTest"));
}

小結(jié)：IOUtils和FileUtils可以方便的復(fù)制文件和文件夾

• JDK1.7開始sun公司自己實現(xiàn)了copy技術(shù)

public static void main(String args[]){
   File.copy(Paths.get("01_Demo/1.txt"), new FileOutputStream("01_Demo/2.txt"))
}

Base64

Base64是網(wǎng)絡(luò)上最常見的用于傳輸8Bit字節(jié)碼的編碼方式之一，Base64就是一種基于64哥可打印字符來標識二進制數(shù)據(jù)的方法汹来。

在Java 8中Base64編碼已經(jīng)成為Java類庫的標準，Java 8 內(nèi)置了Base64 編碼的編碼器和解碼器

Base64工具類提供了一套靜態(tài)方法獲取下面三種Base64編解碼器：

• 基本：輸出被映射到一組字符A-Za-z0-9+/谒兄，編碼不添加任何行標舵变，輸出的解碼僅支持A-Za-z0-9+/瘦穆。
• URL：輸出映射到一組字符A-Za-z0-9+/扛或，輸出是URL和文件
• MIME：輸出映射到MIME友好格式熙兔。輸出每行不超過76字符艾恼，并且使用'\r'并跟隨'\n'作為分割钠绍。編碼輸出最后沒有行分割

/**
 *  目標：https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&tn=baidu&
 *  wd=%E9%BB%91%E9%A9%AC%E7%A8%8B%E5%BA%8F%E5%91%98&rsv_pq=adb2aafb0004cea1&rsv_t=bd4
 *
 *  Base64可以實現(xiàn)編碼和解碼
 *  Java 8 內(nèi)置了Base64編碼的解碼器和編碼器
 *  
 *  encode：編碼柳爽。
 *  decode：解碼磷脯。
 */
public class Base64Demo{
    public static void main(String args[]){
        try{
            // 1-1. 基本編碼后結(jié)果。普通文本
            String rs = Base64.getEncoder().encodeToString("哈哈".getByte());     // 5ZOI5ZOI
            // 1-2. 基本解碼后結(jié)果
            byte[] decode = Base64.getDecoder().decode(rs);
            System.out.println(new String(decode));     // 哈哈
            
            // 2-1. URL編碼
            String url = Base64.getUrlEncoder().encodeToString("?login=zimo&pass=12345".getBytes());
            System.out.println(url);    // P2xvZ2luPXppbW8mcGFzcz0xMjM0NQ==
            // 2-2. URL解碼
            byte[] url1 = Base64.getUrlDecoder().decode(url);
            System.out.println(new String(url1));   // ?login=zimo&pass=12345
            
            // 3-1. MIME編碼（大文件，郵箱等）
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < 10; i++) {
                sb.append(UUID.randomUUID().toString());
            }
            String mime = Base64.getMimeEncoder().encodeToString(sb.toString().getBytes());
            System.out.println(mime); // M2FmMDM0ZmItM2QyMy00Y2YwLWEwMzEtMWUzNmI3ZDQ1OTgwNjAzMDk0ZjQtOTI0Yy00ZTM3LWI0
                                      // NTMtZWQ5NWQzYTdiN2FkYzg2N2YyYzctOGY1NC00ZmFjLWI2MzctOTk1NDM3YzMxYTQyMTJlZDZk
                                      // MTctYWJkMS00MTgxLWJmYjktNzg2NjM0YzkwZDIwZDMxMjcyNDItYjM2My00YjVjLWEwOGUtMzMz
                                      // ODk3Y2M5NWViZWY3NWFmYjctZmUwZC00YjNlLTk1MWItNjMzOGYwZTI2NmVlMzAzN2MxMTYtZDA3
                                      // OC00M2U0LWJkNGUtMTI2OWJkOGU1NmE1YWYyZmFhMWQtNDA0OS00MjI0LWI2MGItMGRkOTVkYjAz
                                      // NDZjODc1ZmU1OWMtODY5My00NTE4LTkwNmItOGQ2YmM0NzNhZDE2YjJiMTAyNWUtZjc4MC00MTY3
                                      // LWE3ZTEtNDNlMmFiNTFhNmQ0
            // 3-2. MIME解碼
            byte[] mime1 = Base64.getMimeDecoder().decode(mime);
            System.out.println(new String(mime1));
            // 252b9219-fdfa-4151-811a-884970a9295f
            // 7e60291f-d03b-4f13-8839-9254f681a7d2
            // c5c2fe56-6e89-4eb2-80a5-c95d4ab3899f
            // ebb3651b-e3f4-4861-b9eb-0efedf00b413
            // db6b06a4-e3d4-4e9a-a67b-6aecd7435613
            // 5200e404-e0e8-4c8a-b297-55a8430c33ed
            // c06da559-eb6b-41c8-9ff7-4d9a7f431ca4
            // cda1d55b-6df3-4f61-8289-723b24c20795
            // 10f59318-571e-4bd1-a45b-cb1cd9c34bcf
            // cac21ea5-bf28-45e0-977b-cd18365363fc
        }catch(Exception e){
            
        }
    }
}