2020-08-07
日常总结08-07
（一）TCP/IP协议如何保持可靠性传输
TCP和IP是网络传输中经常使用到的协议
TCP负责数据的传输，IP负责寻找地址
- 会在客户端与服务端之间进行3次握手：
- 数据的传输过程
2.1. 在传输数据时会给每个数据包一个编号
2.2. 在对方收到数据之后必须给一个响应码，如果没有响应码则会进行重传
2.3. 为了防止重复的数据，每个数据包都会有相应的校验码 - 数据传输完成后会通过4次挥手完成断开连接
（二）TCP与UDP的区别和各自的使用场景
TCP：
- 优势：安全可靠，能保证对方一定收到数据
- 劣势：占用资源大
UDP：
- 优势：占用资源少
- 劣势：不可靠，不能保证对方一定能收到数据
使用场景：
综上述优劣势分析得出TPC适用于效率相对低，准确度相对高的场景。UDP适用于效率相对高，准确度相对低的场景。
举例：
TCP可以作用于传送文件（确保准确度不可以丢数据包），收发送邮件（对于效率不需要太高，确保数据不丢失）等场景
UDP可以作用于聊天工具如QQ（准确度要求不高且数据不大，但速度一定要快），在线视频（视频由照片一帧帧组成所以丢失少部分帧数影响不大）等场景
（三）四种线程池的基本用法
线程池
Executors 用来创建线程池类
-
单线线程池（线程中只有一个线程，必须要等待执行完一个任务，才能执行下一个任务）
创建示例：
ExecutorService service=Executors.newFixedThreadPool -
固定大小的线程池（如果任务数少于线程个数，所有任务同时行。如果任务数多于线程数，最多先执行线程个数的任务，其他任务暂时等待。当线程执行完当前任务之后，再去执行正在等待的任务）
创建示例：
ExecutorService service =Executors.newFixedThreadPool(10)
（参数为类型为int类型 10表示10个线程 ） -
可缓冲线程的线程池（可以根据任务的数量去创建线程个数）
ExecutorService service=Executors.newCachedThreadPool(); -
可执行延迟任务的线程池（本质上是一个固定线程的线程池，可以执行延时任务）
ScheduledExecutorService service=Executors.newScheduledThreadPool
执行方法有两种
1、 service.execute(执行的任务);
2、 service.scheduled(执行任务,延迟时间数值, Time.Unit延迟时间的单位)
service.shutdown(); 执行完任务后关闭线程池
List list=Service.shutdown();立刻关闭线程池，并返回在等待的任务列表
（四）XML解析的两种方式比较DOM与SaxXML解析：
XML解析：用来解决数据传输的格式问题
用法：
- 从xml数据中提取需要的内容
- 将数据转换成xml格式
标准：
DOM（w3c官方的标准） Sax（XML社区标准）
DOM： Document Object Model（文件对象模型）
Sax：Simple API for XML（API：Application Program InterFace
简单的XML解析API （应用程序编程接口 已经写好的工具类
DOM的基本思想：
将整个xml数据转换成一个树形对象[Document对象]
优点：由于所有的节点都在内存的Document对象中，支持随机访问
缺点：由于所有的数据是一次性读入到内存中的，对于比较大的xml数据，非常占内存
XML的数据类型：标签 属性 文本
标签是一个Elment对象
属性是一个Attr对象
文本是一个Text对象
Document，Elment，Attr，Text都是将XML中的标签，属性，文本都作为一个节点对象
在解析XML的数据，先将整个XML一次性读入到内存中然后封装成一个树对象，再对树上的节点进行操作[增删改查]
package com.lizhe.Xml;
import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class XmlDemo {
/*
* 使用JAXP工具的DOM方式解析XML
*/
public static void main(String[] args) throws Exception {
String path = "D:\\newer\\我的总结\\stus.xml";
File fi = new File(path);
// 1.创建一个DOM解析器工厂
DocumentBuilderFactory facoty = DocumentBuilderFactory.newInstance();
// 2.通过工厂来生产一个解析器对象
DocumentBuilder builder = facoty.newDocumentBuilder();
// 3.解析指定的XML文件
Document dom = builder.parse(fi);
// 获得文档的根节点
Element root = dom.getDocumentElement();
// 获得元素名称
System.out.println(root.getTagName());
System.out.println("根节点" + root);
// 由于该节点是一个元素节点，可以获得其所有的子节点
NodeList list = root.getChildNodes();
// 遍历list
for (int i = 0; i < list.getLength(); i++) {
// 取得一个子节点
Node node = list.item(i);
// 如果子节点是一个元素节点，才需要处理输出
if (node instanceof Element) {
// 将node强制转换成Element
Element stu = (Element) node;
// 获得stu的属性mun
String num = stu.getAttribute("num");
System.out.println("num:" + num);
// 获得stu的子节点
NodeList childList = stu.getChildNodes();
for (int j = 0; j < childList.getLength(); j++) {
Node n = childList.item(j);
if (n instanceof Element) {
Element element = (Element) n;
// 获得节点名称
String nodeName = element.getNodeName();
// 获得节点内容
String content = element.getTextContent();
System.out.println(nodeName + ":" + content);
}
}
}
}
}
}
常用的DOM代码：
getDocumentElement(); 获得根节点
getChildNodes(); 获得元素节点的所有子节点
item(index); 获得NodeList中指定索引位置的节点
getAttribute(“num”); 获得指定名字的属性值
getNodeName(); 获得节点名称
getTextContent(); 获得元素节点中的文本内容
getElementsByTagName("name") 根据标签名获得节点列表
getElementById("1234") 根据标签的ID获得指定的节点
Sax的基本思想：
顺序解析，事件驱动：
一边读取数据，一边进行解析，在读取数据的时候回触发一定的事件，每触发一次，就可以做一次处理。
优点：由于每次只需要存放触发事件的位置，占用内存少
缺点：不支持随机访问
Sax方式解析XML
继承DefaultHandler
需要重写方法
startDocument 开始文档
endDocument 文档结束
startElement 开始标签
endElement 结束标签
characters 字符处理
无论是DOM解析还是Sax解析，都需要将解析出的数据封装成对象
创建Sax解析
package com.lizhe.Xml;
import java.io.File;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.helpers.DefaultHandler;
public class SaxXMl {
public static void main(String[] args) throws Exception {
String path = "D:\\\\newer\\\\我的总结\\\\stus.xml";
File f = new File(path);
// 1.创建Sax解析器工厂
SAXParserFactory facoty = SAXParserFactory.newInstance();
// 2.通过工厂生产一个Sax解析器对象
SAXParser saxparser = facoty.newSAXParser();
// 3.创建事件处理器对象
DefaultHandler handler = new MyHandler();
// 4.开始解析
saxparser.parse(f, handler);
}
}
创建事件处理器
package com.lizhe.Xml;
import java.util.ArrayList;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
/**
* Sax的事件处理器 要继承默认的事件处理器
* 1.需要重写DEfaultHandler的事件处理方法
* 2.事件处理器中的方法是通过事件触发自动调用的
* @author lizhe
*/
public class MyHandler extends DefaultHandler {
// 创建长度可变数组
ArrayList<Student> list = new ArrayList<Student>();
private String msg;
private int count = 0;
Student student = null;
// 开始解析文档
public void startDocument() throws SAXException {
}
// 解析到开始标签,需要处理标签中的属性
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
if (qName.equals("stu")) {
student = new Student();
String num = attributes.getValue("num");
int i = Integer.parseInt(num);
student.setNum(i);
}
}
// 解析到文本内容
public void characters(char[] ch, int start, int length) throws SAXException {
msg = new String(ch, start, length);
}
// 解析到结束标签
public void endElement(String uri, String localName, String qName) throws SAXException {
switch (qName) {
case "name":
student.setName(msg);
break;
case "age":
int i = Integer.parseInt(msg);
student.setAge(i);
break;
case "sex":
student.setSex(msg.trim().charAt(0));
break;
case "stu":
list.add(student);
}
}
// 解析文档结束
public void endDocument() throws SAXException {
for (Student stu : list) {
System.out.println(stu);
}
}
}