19、网络编程：-优快云博客

本文链接：https://blog.youkuaiyun.com/jiangxianfengge/article/details/144333319

19、网络编程：

网络的相关概念：

网络通讯：

概念：两台设备之间通过网络实现数据传输；
网络通讯：将数据通过网络从一台设备传输到另一台设备；
java.net包下提供了一系列的类或接口，供程序员使用，完成通讯。

网络：

概念：两台或多台设备，通过一定的物理设备连接起来，构成了网络；
根据网络的覆盖范围不同，对网络进行分类：
- 局域网：覆盖范围小，可以覆盖一个学校，一个公司等；
- 城域网：覆盖范围较大，可以覆盖一个城市；
- 广域网：覆盖范围最大，可以覆盖全国，甚至全球，万维网是广域网的代表。

ip地址：

概念：用于唯一地标识网络中的每台计算机/主机（类似于我们地身份证）；
参看 ip 地址：在命令行（cmd）中输入ipconfig
ip 地址表示(对于ipv4)：点分十进制——xx.xx.xx.xx；

0~255 0~255 0~255 0~255
每一个十进制数地范围：0~255;
ip 地址地组成 = 网络地址 + 主机地址，比如192.168.16.69，那么192.168.16可以表示网络地址（xx市xx区xx小区），69表示主机地址（x幢x单元xxx房）；
ipv6是互联网工程任务组设计地用于替代 IPV4 的下一代 IP协议，其地址数量号称可以为全世界的每一粒沙子边上一个地址；其使用128位表示地址（IPV4是32位）；
由于 IPV4 最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPV6 的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备炼乳互联网的障碍。

IPV4地址分类：

A类：1个字节表示网络地址（0-固定的 + 7位网络号），3个字节表示主机地址；
- 0.0.0.0~127.255.255.255
- 特殊：127.0.0.1表示本机地址
B类：2个字节表示网络地址（10-固定 + 14位网络号），2个字节表示主机地址；
- 128.0.0.0~191.255.255.255
C类：3个字节表示网络地址（110-固定 + 21位网路号），1个字节表示主机地址；
- 192.0.0.0~223.255.255.255
D类：1110-固定 + 28位多播组号；类似广播。
- 224.0.0.0~239.255.255.255
E类：11110-固定 + 27位留待后用。
- 240.0.0.0~247.255.255.255

域名：

如www.baidu.com；
好处：为了方便记忆，解决记 ip 的困难；（就像你想要访问百度的主机，对于用户来讲，你能记住百度的ip吗？我们记住的是百度的域名，www.baidu.com）
概念：将 ip 地址映射成域名。（如何映射上，使用http协议——于JavaWeb中）

端口号：

概念：用于标识计算机上某个特定的网络程序（网络服务）；（一个网络服务需要监听一个端口，我们想要去访问网站服务的时候，我们请求的是端口——ip+端口才能访问到网络服务，怎么理解，就像你去办理身份证，在公安局只有特定的柜台才可以吧！公安局相当于ip，柜台相当于端口，你只有去了公安局再去特定端口才能得到办理身份证服务！）
1. 一个端口只能被一个网络服务监听（当被网络服务监听时，该端口被占用）
表示形式：以整数形式，范围 0~65535[2个字节，0 ~ 2¹⁶-1]；
0~1024 已经被占用，比如 ssh 22，ftp 21， smtp 25， http 80；
1. 在我们做开发的时候尽量避免使用0~1024的端口。
常见的网络程序端口号：
1. tomcat：8080
2. mysql：3306
3. oracle：1521
4. sqlserver：1433

网络通信协议：

协议（tcp/ip）:

通俗理解：数据在网络编程中的组织形式，就是协议。（每个字段表示什么含义）

TCP/IP(Transmission Control Protocol/Internet Protocol)的简写，中文译名为传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是Internet最基本的协议、Internet国际互联网络的基础，简单来说，就是由网络层的IP协议和传输层的TCP协议组成的。

TCP/IP模型：

应用层：Http、ftp、telnet、…
传输层（TCP层）：TCP、UDP、…
网络层（IP层）：协议——IP、ICMP、ARP、…
物理+数据链路层：协议——Link

开发中主要关注TCP层和IP层。

TCP 和 UDP：

TCP协议：传输控制协议

使用TCP协议前，必须建立TCP连接，形成数据传输通道；
传输前，采用“三次握手”方式，是可靠的；
TCP协议进行通信的两个应用进程：客户端、服务端；
在连接中可进行大数据量的传输；
传输完毕，需释放已建立的连接，效率低。

UDP协议：用户数据协议

将数据、源、目的封装成数据包，不需要建立连接；
每个数据报的大小限制在64K内，不适合传输大量数据；
因无需连接，故不可靠；
发送数据结束时，无需释放资源（因为不是面向连接的），速度块；

InetAddress类：

应用案例：

package com.jiangxian.inetaddress;

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

/**
 * @author JiangXian~
 * @version 1.0
 */
public class InetAddress_ {
    public static void main(String[] args) throws UnknownHostException {
        // 1.获取本机的InetAdress 对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println("localHost = " + localHost);

        // 2.根据指定主机名，获取 InetAddress 对象：
        InetAddress host1 = InetAddress.getByName("江弦");
        System.out.println("host1 = " + host1);

        // 3.根据域名返回InetAddress 对象
        InetAddress host2 = InetAddress.getByName("www.baidu.com");
        System.out.println("host2 = " + host2);

        // 4.通过 InetAddress 对象，获取相应的地址
        String hostAddress = host2.getHostAddress();
        System.out.println("hostAddress = " + hostAddress);
    }
}

Socket：

基本介绍：

套接字（Socket）开发网络应用程序背广泛采用，以至于成为事实上的标准；
通信的两端都需要Socket，是两台机器间通信的端点；
网络通信实际上就是Socket间的通信；
Socket 允许程序把网络连接当成一个流，数据在两个Socket 间通过IO传输；
一般主动发起通信的应用程序属客户端，等待通信请求的为服务端（监听）。

TCP网络编程：

应用案例：

使用字节流1：

编写一个服务器端，和一个客户端；
服务器端在9999端口监听（仅能监听一次）；
客户端连接到服务器端，发送"hello, server"，然后退出；
服务器端接收到客户端发送的信息，输出，并退出。

客户端思路分析：

连接服务端（ip，端口）；
连接上后，生成Socket，通过socket.getOutputStream()；
通过输出流，写入数据到数据通道。

package com.jiangxian.socket;

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

/**
 * @author JiangXian~
 * @version 1.0
 * 客户端发送 “Hello Server”
 */
public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
        // 1. 连接服务端（ip，端口）；由于是本机所以不用ip地址或者域名，若是远程服务器，可以使用ip地址或者域名
        //      解释：连接本机的9999端口，连接成功会返回socket
        Socket socket = new Socket(InetAddress.getLocalHost(),9999);
        System.out.println("客户端 socket返回 = " + socket.getClass());

        //2. 连接上后，生成Socket，通过socket.getOutputStream()；
        //      得到和socket对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();

        //3. 通过输出流，写入数据到数据通道。
        outputStream.write("Hello, server!".getBytes());
        outputStream.close();
        socket.close();
        System.out.println("客户端退出了。");
    }
}

服务器思路分析：

在本机的9999端口监听，等待连接；
当没有客户端连接9999端口时，程序会被阻塞在此处，等待连接；
通过socket.getInputStream()读取客户端写入到数据通道的数据，然后显示。

package com.jiangxian.socket;

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

/**
 * @author JiangXian~
 * @version 1.0
 */
public class SocketTCP01Server {
    public static void main(String[] args) throws IOException {
        // 1. 在本机的9999端口监听，等待连接；
        //      细节：要求本机没有其它服务在监听（占用）9999
        //      细节：ServerSocket可以通过accept()方法返回多个Socket对象[多个客户端来连接服务器导致的多并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务器，在9999号端口监听，等待连接...");

        // 2. 当没有客户端连接9999端口时，程序会被阻塞在此处，等待连接；
        //      若有客户端连接，会返回一个Socket对象
        Socket socket = serverSocket.accept(); // 未连接时阻塞在此处，即客户端未运行时会在此处等待
        System.out.println("服务器 socket = " + socket.getClass()); // 未连接时，这句话输出不出来

        // 3. 通过socket.getInputStream()读取客户端写入到数据通道的数据，然后显示。
        InputStream inputStream = socket.getInputStream();
        byte[] buffer = new byte[8];
        int len = 0;
        while ((len = inputStream.read(buffer)) != -1) {
            System.out.print(new String(buffer, 0, len));
        }
        inputStream.close();
        socket.close();
        serverSocket.close(); // 这个也要关闭
        System.out.println("服务器退出！");


    }
}

使用字节流2：（引入结束标记）

编写一个服务器端，和一个客户端；
服务器端在9999端口监听（仅能监听一次）；
客户端连接到服务器端，发送"hello, server，设置一个结束标记"，然后退出；
服务器端接收到客户端发送的信息，输出，并发送"hello, client"并退出。

客户端思路：

连接服务器(ip, 端口号)；
通过getOutputStream发送数据；
使用getInputStream来接收数据。

package com.jiangxian.socket;

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

/**
 * @author JiangXian~
 * @version 1.0
 */
public class SocketTCP02Client {
    public static void main(String[] args) throws IOException {
        //1. 连接服务器(ip, 端口号)；
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回 = " + socket.getClass());

        //2. 通过getOutputStream发送数据；
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("Hello, Server!".getBytes());
        // 设置一个结束标记，否则socket不知道到底结束了没有，导致程序一直等待，形成死锁
        socket.shutdownOutput();
        // outputStream.close()会导致socket背提前关闭


        //3. 使用getInputStream来接收数据。
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int readlen = 0;
        while((readlen = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, readlen));
        }

        // 一定要记住，退出要写在一起，不然会导致socket提前关闭
        outputStream.close();
        inputStream.close();
        socket.close();
        System.out.println("客户端退出！");
    }
}

服务器思路：

在本机的9999端口创建监听，等待连接；
当没有客户端请求连接时，程序阻塞；
收到请求连接后，创建Socket对象，使用getInputStream来接收数据；
使用getOutputStream发送数据。

package com.jiangxian.socket;

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

/**
 * @author JiangXian~
 * @version 1.0
 */
public class SocketTCP02Server {
    public static void main(String[] args) throws IOException {
        //1. 在本机的9999端口创建监听，等待连接；
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务器，在9999号端口监听，等待连接...");

        //2. 当没有客户端请求连接时，程序阻塞；
        Socket socket = serverSocket.accept(); // 等待连接
        System.out.println("服务器的 socket = " + socket.getClass().getName());

        //3. 收到请求连接后，创建Socket对象，使用getInputStream来接收数据；
        InputStream inputStream = socket.getInputStream();
        byte[] buffer = new byte[1024];
        int readlen = 0;
        while((readlen = inputStream.read(buffer)) != -1){
            System.out.println(new String(buffer, 0 ,readlen));
        }


        //4. 使用getOutputStream发送数据。
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("Hello, Client!".getBytes());
        // 设置一个结束标记，否则socket不知道到底结束了没有
        socket.shutdownOutput();

        // 一定要记住，退出要写在一起，不然会导致socket提前关闭
        inputStream.close();
        outputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务器退出！");

    }
}

使用字符流：

客户端：

创建连接，连接服务器（ip，端口）；
使用socket.getOutputStream获得输出流，使用OutputStreamWriter转换流，写入（加入结束标记，可以是socket.shutdownOutput(); 也可以是 BufferedWriter对象的newline()函数，但是要求对面是用readline()接收）；
使用socket.getInputStream获得输入流，将字节型转换为字符型，使用InputStreamReader转换流，读取文件；

package com.jiangxian.socket;

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

/**
 * @author JiangXian~
 * @version 1.0
 */
public class SocketTCP03Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(),9999);

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write("Hello, Server!\n");
        bw.newLine();
        bw.flush();

        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String line = br.readLine();
        System.out.println(line);

        // close
        bw.close();
        br.close();
        socket.close();
    }
}

服务器：

创建ServerSocket对象，监听本机的9999端口；
当没有连接请求，程序将堵塞在此处，等待连接；
当收到连接请求，创建Socket对象，使用socket.getInputStream获得输入流，将字节型转换为字符型，使用InputStreamReader转换流，读取文件；
使用socket.getOutputStream获得输出流，使用OutputStreamWriter转换流，写入（加入结束标记，可以是socket.shutdownOutput(); 也可以是 BufferedWriter对象的newline()函数，但是要求对面是用readline()接收）。

package com.jiangxian.socket;

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

/**
 * @author JiangXian~
 * @version 1.0
 */

public class SocketTCP03Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);

        Socket socket = serverSocket.accept();

        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String line = br.readLine(); // 这里不能使用循环。
        System.out.println(line);

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write("Hello, Client!");
        bw.newLine();
        bw.flush();

        // close
        br.close();
        bw.close();
        socket.close();
        serverSocket.close();
    }
}

在使用字符流时，使用while((line = br.readline()) != null){sout(line);}时会发生死锁，我还并不理解为什么会发生这样的情况。

上传文件：

编写一个服务端和一个客户端；
服务端在 8888 端口监听；
客户端连接到服务端，发送一张图片；
服务器接收到客户端发送的图片，保存到 src 下，发送"收到图片"再退出；
客户端接收到服务端发送的"收到图片"再退出。

客户端：

package com.jiangxian.sendfiles;

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

/**
 * @author JiangXian~
 * @version 1.0
 */

public class TCPFileCopyClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(),8888);
        System.out.println("客户端连接到本机8888端口的服务端");

        // 需要先将文件写入一个二进制数组中
        String filePath = "E:\\self_study\\NoteBook\\Java\\mg.png";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        byte[] buf = new byte[1024];
        int len;
        while((len = bis.read(buf)) != -1){
            bos.write(buf, 0, len);
        }
        bos.flush();
        socket.shutdownOutput();

        // 接收服务端回送信号：
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String line;
        while((line = br.readLine()) != null){
            System.out.println(line);
        }

        // close
        bis.close();
        bos.close();
        br.close();
        socket.close();
        System.out.println("客户端结束工作退出");
    }
}

服务端：

package com.jiangxian.sendfiles;

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

/**
 * @author JiangXian~
 * @version 1.0
 */

public class TCPFileCopyServer {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(8888);
        System.out.println("服务端在监听8888端口");

        Socket s = ss.accept();
        System.out.println("等待客户端连接...");

        // 开始读取客户端传入的文件，并将其写入 src
        String dstFilePath = "src\\txt.png";
        BufferedInputStream bis = new BufferedInputStream(s.getInputStream());
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dstFilePath));
        byte[] buf = new byte[1024];
        int len;
        while ((len = bis.read(buf)) != -1) {
            bos.write(buf, 0, len);
        }
        bos.flush();

        // 回送信息：
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        bw.write("收到图片");
        bw.flush();
        s.shutdownOutput();

        // close
        bis.close();
        bos.close();
        s.close();
        ss.close();

    }
}