网络编程 | 数据

1.1、基本概念

首先理清一个概念：网络编程不等于网站编程，网络编程即使用套接字来达到进程间通信，现在一般称为TCP/IP编程。

计算机网络

计算机网络是指将==地理位置不同==的具有独立功能的==多台计算机及其外部设备，通过通信线路连接起来==，在网络操作系统，网络管理软件及==网络通信协议==的管理和协调下，==实现资源共享==和信息传递的计算机系统。

网络编程的目的

无线电台…传播交流信息，数据交换。通信

Javaweb和网络编程的区别

Javaweb：主要用于网页编程开发,采用的b/s架构(网站又称浏览器-服务器应该程序，Browser/Server)。

网络编程：主要是网络通信，实现计算机之间的对话和文件传输。采用的是c/s架构（应用软件，桌面应用程序又称之为客户端-服务器应用程序，Client/Server）。

1.2、网络通信的要素

1.2.1、如何实现网络的通讯？

1.通信双方地址：ip+端口号

2.网络通信协议： UDP，TCP

现在我以QQ这个应用程序为例，来讲解双方互相通信的过程。

比如你正在用QQ正在和你的好朋友通信，你用QQ给它发了句“睡了吗”，那这句睡了吗？是通过怎样的路径到对方的qq中，让对方看到呢？

首先：我们的QQ会以“app+睡了吗”这样的形式先进行第一次封装，这一层是在操作系统内核的用户区进行的第一次封装。即只是进行一个普通的标识。

（2）这个消息被传送到传输层，传输层会以“tcp报头+应用数据”这样的形式进行封装。这个操作是内核做的，所谓内核即就是操作系统。

（3）然后这个消息到达网络层，网络层会以“IP报头+应用层数据”这样的形式进行封装，这个操作当然也是内核做的。

（4）再然后这个消息到达数据链路层，数据链路层会”以太网首部+应用数据+以太网尾部”这样的形式进行最后的封装，现在我们将这个数据已经封装好了。

（5）最后这个数据通过总线到达主机接口，再通过网线被送到主机A的接口，然后通过协议我我们在把报头层层去掉，最后数据到达我们的应用层。即实现了数据传输。

以上就是数据传输的5步，当然这是根据tcp/ip协议来进行传输的。
当我们的数据到达主机接口处时，其实我们的数据以经封装好了，而我们的网线只是负责传输即可。即以下4层都是由我们的内核实现的。

1.2.2、规则：网络通信的协议

TCP/IP参考模型：

1.3、IP地址

ip地址：InetAddress

唯一定位一台网络上计算机
127.0.0.1 ：本机 localhost
ip地址的分类
- ipv4 / ipv6
  - ==IPV4== 127.0.0.1 , 4个字节组成。， 0~255， 42亿~ ； 30亿都在北美，亚洲4亿。2011年就用尽；
  - ==IPV6== :128位。8个无符号整数！
```
2001：0bb2：aaaa：0015:0000:0000:1aaa：1312！
```
- 公网（互联网）- 私网（局域网）
  - ABCDE类地址
  A类IP地址地址范围1.0.0.1-126.255.255.254
  B类IP地址地址范围128.1.0.1-191.254.255.254
  C类IP地址范围192.0.1.1-223.255.254.254
  D类IP地址范围224.0.0.1-239.255.255.254 。
  E类IP地址范围240.0.0.0---255.255.255.254。
  上述IP地址均为IPv4地址
  - 192.168.xx.xx,专门给组织内部使用的
域名：记忆IP问题！
- IP： www.vip.com

案例演示：

package inetdemo;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class TestInetAddress {
    public static void main(String[] args) throws UnknownHostException {
        InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
        System.out.println(inetAddress1);
        InetAddress inetAddress2 = InetAddress.getByName("localhost");
        System.out.println(inetAddress2);
        InetAddress inetAddress3 = InetAddress.getLocalHost();
        System.out.println(inetAddress3);

        InetAddress inetAddress4 = InetAddress.getByName("www.baidu.com");
        System.out.println(inetAddress4);
        System.out.println(inetAddress2.getAddress());
        System.out.println(inetAddress2.getCanonicalHostName()); //规范的名字
        System.out.println(inetAddress2.getHostAddress()); //ip
        System.out.println(inetAddress2.getHostName()); //域名，或者自己电脑的名字
    }
}

1.4、端口

端口表示计算机上的一个程序的进程；

不同的进程有不同的端口号！用来区分软件！
被规定 0~65535
TCP,UDP ： 65535 * 2 tcp：80，udp：80，单个协议下，端口号不能冲突
端口分类
- 公有端口 0~1023
  - HTTP : 80
  - HTTPS : 443
  - FTP : 21
  - Telent : 23
- 程序注册端口：1024~49151, 分配用户或者程序
  - Tomcat ： 8080
  - MySQL ： 3306
  - Oracle ：1521
- 动态、私有：49152~ 65535
```
```java
```
netstat -ano #查看所有的端口
netstat -ano|findstr "5900" # 查看指定的端口
tasklist|findstr "8696" #查看指定端口的进程
Ctrl+ shift + ESC #任务管理器
```

案例演示：

package inetdemo;

import java.net.InetSocketAddress;

public class TestInetSockAdress {
    public static void main(String[] args) {
                InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 8080);
                InetSocketAddress socketAddress2 = new InetSocketAddress("localhost", 8080);
                System.out.println(socketAddress);
                System.out.println(socketAddress2);

                System.out.println(socketAddress.getAddress());
                System.out.println(socketAddress.getHostName()); //地址
                System.out.println(socketAddress.getPort()); //端口
            }
        }

展示图：

例子：QQ和QQ之间传输，两个QQ进程之间要交互，就必须要连接端口，例如两个都是8998，假设msn的端口叫7777，msn就接收不到（产生了丢失）

1.5、通信协议

协议：就是他们之间的共同达成的约定

网络通信协议： 速率，传输码率，代码结构，传输控制…..

TCP/IP协议簇：实际上是一组协议

重要：

TCP ：用户传输协议
UDP : 用户数据报协议

出名的协议：

TCP：
IP ：网络互连协议

TCP udp 对比

TCP : 打电话

连接，稳定
三次握手四次挥手

举例子：

最少需要三次，保证稳定连接！
A：你瞅啥？
B: 瞅你咋地？
A：干一场！


A：我要走了！
B：我真的要走了吗？
B：你真的真的要走了吗？
A：我的真的要走了！

客户端、服务端
传输完成，释放连接，效率低

UDP ：发短信

不连接，不稳定
客户端、服务端：没有明确的界限
不管有没有准备好，都可以发给你..
DDOS ：洪水攻击！（饱和攻击）

1.6、TCP

TCP（Transmission Control Protocol传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。

三次握手

所谓三次握手（Three-Way Handshake）即建立TCP连接，就是指建立一个TCP连接时，需要客户端和服务端总共发送3个包以确认连接的建立。在socket编程中，这一过程由客户端执行connect来触发，整个流程如下图所示：

（1）第一次握手：Client将标志位SYN置为1，随机产生一个值seq=J，并将该数据包发送给Server，Client进入SYN_SENT状态，等待Server确认。
（2）第二次握手：Server收到数据包后由标志位SYN=1知道Client请求建立连接，Server将标志位SYN和ACK都置为1，ack=J+1，随机产生一个值seq=K，并将该数据包发送给Client以确认连接请求，Server进入SYN_RCVD状态。
（3）第三次握手：Client收到确认后，检查ack是否为J+1，ACK是否为1，如果正确则将标志位ACK置为1，ack=K+1，并将该数据包发送给Server，Server检查ack是否为K+1，ACK是否为1，如果正确则连接建立成功，Client和Server进入ESTABLISHED状态，完成三次握手，随后Client与Server之间可以开始传输数据了。

四次挥手

由于TCP连接时全双工的，因此，每个方向都必须要单独进行关闭，这一原则是当一方完成数据发送任务后，发送一个FIN来终止这一方向的连接，收到一个FIN只是意味着这一方向上没有数据流动了，即不会再收到数据了，但是在这个TCP连接上仍然能够发送数据，直到这一方向也发送了FIN。首先进行关闭的一方将执行主动关闭，而另一方则执行被动关闭，上图描述的即是如此。
（1）第一次挥手：Client发送一个FIN，用来关闭Client到Server的数据传送，Client进入FIN_WAIT_1状态。
（2）第二次挥手：Server收到FIN后，发送一个ACK给Client，确认序号为收到序号+1（与SYN相同，一个FIN占用一个序号），Server进入CLOSE_WAIT状态。
（3）第三次挥手：Server发送一个FIN，用来关闭Server到Client的数据传送，Server进入LAST_ACK状态。
（4）第四次挥手：Client收到FIN后，Client进入TIME_WAIT状态，接着发送一个ACK给Server，确认序号为收到序号+1，Server进入CLOSED状态，完成四次挥手。
上面是一方主动关闭，另一方被动关闭的情况，实际中还会出现同时发起主动关闭的情况，具体流程如下图：

传输消息

客户端

连接服务器 Socket
发送消息

package InetDemo01;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

//客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream os = null;

        try {
            //1. 要知道服务器的地址，端口号
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            int port = 8080;
            //2. 创建一个socket连接
            socket = new Socket(serverIP,port);
            //3. 发送消息 IO流
            os = socket.getOutputStream();
            os.write("欢迎来到我的博客".getBytes());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

文件上传

服务器端

建立服务的端口 ServerSocket
等待用户的链接 accept
接收用的消息

package InetDemo01;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

//服务端
public class TcpServerDemo01 {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;

        try {
            //1. 我得有一个地址
            serverSocket = new ServerSocket(8080);

            while (true){
                //2. 等待客户端连接过来
                socket = serverSocket.accept();
                //3. 读取客户端的消息
                is = socket.getInputStream();

                //管道流
                baos = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int len;
                while ((len=is.read(buffer))!=-1){
                    baos.write(buffer,0,len);
                }

                System.out.println(baos.toString());
            }

            /*
                byte[] buffer = new byte[1024];
                int len;
                while ((len=is.read(buffer))!=-1){
                    String msg = new String(buffer, 0, len);
                    System.out.println(msg);
                }
                这个如果字节数组超过了1024会造成乱码 所以不用这种方法
             */


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if (baos!=null){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

文件上传

客户端：

package InetDemo01;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;


public class TcpClientDemo02 {
    public static void main(String[] args) throws Exception {
        //1.创建一个Socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
        //2、 创建一个输出流
        OutputStream os = socket.getOutputStream();

        //3. 读取文件
        FileInputStream fis = new FileInputStream(new File("D:\\Java\\1203\\src\\InetDemo01\\zmx.jpg"));
        //4. 写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len=fis.read(buffer))!=-1){
            os.write(buffer,0,len);
        }

        //通知服务器，我已经结束了
        socket.shutdownOutput(); //我已经传输完了！

        //确定服务器接收完毕，才能够断开连接
        InputStream inputStream = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        byte[] buffer2 = new byte[2014];
        int len2;
        while ((len2=inputStream.read(buffer2))!=-1){
            baos.write(buffer2,0,len2);
        }

        System.out.println(baos.toString());

        //5.关闭资源
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();
        }
    }

服务器端

package InetDemo01;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception {
        //1. 创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2. 监听客户端的连接
        Socket socket = serverSocket.accept(); //阻塞式监听，会一直等待客户端连接
        //3. 获取输入流
        InputStream is = socket.getInputStream();

        //4. 文件输出
        FileOutputStream fos = new FileOutputStream(new File("JJH.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }


        //通知客户端我接收完毕了
        OutputStream os = socket.getOutputStream();
        os.write("我接受完毕了，你可以断开了".getBytes());

        //关闭资源
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();

    }
}

1.7、UDP

UDP 是User Datagram Protocol的简称，中文名是用户数据报协议。

UDP是一个无连接协议，传输数据之前源端和终端不建立连接，当它想传送时就简单地去抓取来自应用程序的数据，并尽可能快地把它扔到网络上。在发送端，UDP传送数据的速度仅仅是受应用程序生成数据的速度、计算机的能力和传输带宽的限制；在接收端，UDP把每个消息段放在队列中，应用程序每次从队列中读一个消息段

由于传输数据不建立连接，因此也就不需要维护连接状态，包括收发状态等，因此一台服务机可同时向多个客户机传输相同的消息。

下面是案例的演示：

客户端：

package InetDemo01;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

//不需要连接服务器
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception {
        //1. 建立一个Socket
        DatagramSocket socket = new DatagramSocket();

        //2. 建个包
        String msg = "你好服务器！";
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;

        // 数据，数据的长度起始，要发送给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);

        //3. 发送包
        socket.send(packet);

        //4. 关闭流
        socket.close();
    }
}

接收端：

package InetDemo01;

import java.net.DatagramPacket;
import java.net.DatagramSocket;


//还是要等待客户端的链接！
public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception {
        //开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        // 接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);

        socket.receive(packet); //阻塞接收

        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(),0,packet.getLength()));


        //关闭连接
        socket.close();
    }
}

咨询

客户端：

package chat;

import sun.security.util.Length;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class UdpSenderDemo01 {
    public static void main(String[] args) throws Exception {

        DatagramSocket socket = new DatagramSocket(5500);
         //准备数据： 控制台读取 System.in
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
       while (true){
           String data = reader.readLine();

           byte[] datas = data.getBytes();

           DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",269));

           socket.send(packet);
           if (data.equals("bye")){
               break;
           }
       }

        socket.close();


    }
}

接收端：

package InetDemo01;

import javax.xml.stream.FactoryConfigurationError;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpReceiveDemo01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(269);

        while (true){
            //准备接收包裹
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container,0,container.length);
            socket.receive(packet); //阻塞式接收包裹

            //断开连接  bye
            byte[] data = packet.getData();
            String receiveData = new String(data, 0, data.length);

            System.out.println(receiveData);

            if (receiveData.equals("bye")){
                break;
            }
        }
        socket.close();
    }
}

在线咨询（两人都可以是发送方和接收方）

发送端：

package chat;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class TalkSend implements Runnable {
    DatagramSocket socket = null;
    BufferedReader reader = null;

    private int fromPort;
    private String toIP;
    private int toPort;

    public TalkSend(int fromPort, String toIP, int toPort) {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;
        try {
            DatagramSocket socket = new DatagramSocket(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Override
    public void run() {

        while (true) {
            try {
                String data = reader.readLine();
                byte[] datas = data.getBytes();
                DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost", 269));
                socket.send(packet);
                if (data.equals("bye")) {
                    break;
                }

            } catch (Exception e) {
                e.printStackTrace();
            }

        }
        socket.close();


    }
}

接收端：

package chat;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class TalkReceive implements Runnable {
    DatagramSocket socket = null;
    private int port;
    private String msgFrom;

    public TalkReceive(int port,String msgFrom) {
        this.port = port;
        this.msgFrom = msgFrom;
        try {
            socket=new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {

        //准备接受包裹
        byte[] bytes = new byte[1024];
        while (true){
            try {
                DatagramPacket packet = new DatagramPacket(bytes,0,bytes.length);
                socket.receive(packet);
                //断开连接
                byte[] data = packet.getData();
                String receviceData = data.toString();
                System.out.println(msgFrom+"："+receviceData);
                if (receviceData.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        socket.close();
    }
}

学生：

package chat;

public class TalkStudent {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new TalkSend(7777,"localhost",9999)).start();
        new Thread(new TalkReceive(8888,"老师")).start();
    }

}

老师：

package chat;

public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkSend(5555,"localhost",8888)).start();
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

实际应用：

UDP和TCP协议的主要区别是两者在如何实现信息的可靠传递方面不同。TCP协议中包含了专门的传递保证机制，当数据接收方收到发送方传来的信息时，会自动向发送方发出确认消息；发送方只有在接收到该确认消息之后才继续传送其它信息，否则将一直等待直到收到确认信息为止。与TCP不同，UDP协议并不提供数据传送的保证机制。如果在从发送方到接收方的传递过程中出现数据包的丢失，协议本身并不能做出任何检测或提示。因此，通常人们把UDP协议称为不可靠的传输协议。

既然UDP是一种不可靠的网络协议，那么还有什么使用价值或必要呢？其实不然，在有些情况下UDP协议可能会变得非常有用。因为UDP具有TCP所望尘莫及的速度优势。虽然TCP协议中植入了各种安全保障功能，但是在实际执行的过程中会占用大量的系统开销，无疑使速度受到严重的影响。反观UDP，由于排除了信息可靠传递机制，将安全和排序等功能移交给上层应用来完成，极大降低了执行时间，使速度得到了保证。

1.8、URL

统一资源定位符：用于定位资源，定位互联网上的某一个资源

DNS的域名解析：相当于把一个域名变成一个IP地址

协议：ip地址：端口/项目名/资源

package InetDemo01;

import java.net.MalformedURLException;
import java.net.URL;

public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/helloworld/JJH.jpg?username=JJH&password=123");
        System.out.println(url.getProtocol()); //协议
        System.out.println(url.getHost()); //主机ip
        System.out.println(url.getPort()); //端口
        System.out.println(url.getPath()); //文件
        System.out.println(url.getFile()); //全路径
        System.out.println(url.getQuery()); //参数

    }
}

下载一首自己唱的歌（嘻嘻☺）

package url;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

public class UrlDown {
    public static void main(String[] args) throws IOException {
        //1.下载地址
        URL url = new URL("http://ws.stream.kg.qq.com/szkge-btfs/5e38d91fd03ad768b016c045f3f1d74b1fcded1a?ftnrkey=7283396c89379347fa3c050a984bae260a6e9c113ed8b2125f58211a6cb05d58cbd3811da8a073ae8572778e57f72926b5e3197b768d20b655761640b7aa1387&vkey=4457C2ABFAC76C315FD8D06B4B8C5CE6D557B492BA4CE2AEE38ACEC0BDB5F7D28483ABBFA0FCC5D08651D301320A2C27F3B642533C0A3696E888BEAFBA401136CEDBD277BB4CD09580DD9CA406E0B63B9AC96A23CBDF51BA&fname=1021_0bc5c5ef5f26f0ba547e47ef80f99bfc6d81fdaf.0.m4a&fromtag=1506&sdtfrom=v1506&ugcid=32979786_1516791901_2714");
        //2.连接到这个资源 http
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("等你下课.m4a");

        byte[] buffer = new byte[1024];
        int len;
        while ((len=inputStream.read(buffer))!=-1){
            fos.write(buffer,0,len);//写出这个数据
        }
        fos.close();
        inputStream.close();
        urlConnection.disconnect();

    }
}