【JAVASE学习笔记之网络编程】

第一章 UDP通信程序

1.1 UDP协议概述

UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另
外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向
发送端反馈是否收到数据。
由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用
UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响

1.1.1 UDP协议特点 

面向无连接的协议。
只管发送，不确认对方是否接收到。
基于数据包传输数据：将数据及源和目的封装成数据包中进行发送
每个数据包的大小限制在64K之内。
因为无需连接，速度快且是不可靠协议

1.1.2 UDP协议使用场景

即时通信（feiQ聊天 对数据准确性和丢包要求比较低，但速度必须快）。
在线视频（rtsp 速度一定要快，保证视频连续，但是偶尔花了一个图像帧，人们还是能接受的）。
网络语音电话（VoIP 语音数据包一般比较小，需要高速发送，偶尔断音或串音也没有问题）

1.2.1 DatagramPacket类

概述：数据包对象
作用：用来封装发送端或接收端的数据。类似于“集装箱”。
常用构造方法

DatagramPacket(byte[] buf, int length, InetAddress address, int port)
     用于创建发送端数据包对象
    buf 要发送的内容
    length 要发送的内容长度，单位字节
    address 接收端的ip地址
port 接收端口号
    DatagramPacket(byte buf[], int length) 用于创建接收端数据包对象
    buf 用于接收数据的数组
    length buf数组的长度

常用成员方法

int getLength() 获得发送端实际发送的字节数或接收端实际接收到的字节数。
int getPort(); 获得发送端或接收端端口号

1.2.2 DatagramSocket类

概述：数据发送对象
作用：用来发送和接收数据。类似于“码头”。使用这个类的实例对象就可以发送和接收DatagramPacket数据
包。
常用构造方法

DatagramSocket() 创建发送端的发送对象
DatagramSocket(int port) 创建接收端的发送对象

常用成员方法

void send(DatagramPacket p) 发送数据包
void receive(DatagramPacket p) 接收数据包
void close() 关闭资源，释放端口号

1.3 UDP通信案例

1.3.1 UDP发送端代码实现

/**
 * UDP发送端
 */
public class UDPSender {
    public static void main(String[] args) throws Exception {
// 准备要发送的数据
        String content = "你好 UDP接收端";
// 创建数据包对象
        DatagramPacket dp = new DatagramPacket(content.getBytes(), content.getBytes().length,
                InetAddress.getLocalHost(), 6666);
// 创建发送对象
        DatagramSocket ds = new DatagramSocket();
// 发送数据包
        ds.send(dp);
// 关闭资源
        ds.close();
    }
}

1.3.2 UDP接收端代码实现

/*
* UDP接收端
*/
public static void main(String[] args) throws Exception {
// 创建接收对象：码头
DatagramSocket ds = new DatagramSocket(6666);
// 创建字节数组，用来存储接收到的数据
byte[] buf = new byte[1024];
// 创建数据包对象用来存储发送端发送过来的数据
DatagramPacket dp = new DatagramPacket(buf, buf.length);
// 接收数据报:同步方法
ds.receive(dp);
// 获得实际接收到的字节个数
int len = dp.getLength();
System.out.println("len = " + len);
System.out.println("接收到内容：" + new String(buf,0,len));
// 获得发送端的ip地址和端口号
String ip = dp.getAddress().getHostAddress();
int port = dp.getPort();
System.out.println("发送端IP地址：" + ip);
System.out.println("发送端端口号：" + port);
// 关闭资源
ds.close();
}

第二章 TCP通信程序

2.1 TCP协议概述

TCP协议是面向连接的通信协议，即在传输数据前先在客户端和服务器端建立逻辑连接，然后再传输数据。它
提供了两台计算机之间可靠无差错的数据传输。TCP通信过程如下图所示：

2.1.1 TCP协议特点

面向连接的协议。
建立连接，形成传输数据的通道。

传输数据大小不受限制
通过三次握手完成连接。
TCP是基于IO流传输数据。
因为需要建立连接，效率会稍低但是可靠协议

2.1.2 TCP协议使用场景

文件传输（ftp http对数据准确性要求高，速度可以相对慢）。
发送或接收邮件（pop imap smtp 对数据准确性要求高，非紧急应用）。
远程登录（telnet ssh 对数据准确性有一定要求，有连接的概念）。

2.2 TCP相关的两个类

2.2.1 Socket类

Socket 类：该类实现客户端套接字，套接字指的是两台设备之间通讯的端点

构造方法

public Socket(String host, int port) :创建套接字对象并将其连接到指定主机上的指定端口号

构造举例，代码如下

Socket client = new Socket("localhost", 6666)

成员方法

public InputStream getInputStream() ： 返回此套接字的输入流。
如果此Scoket具有相关联的通道，则生成的InputStream 的所有操作也关联该通道。
关闭生成的InputStream也将关闭相关的Socket。
public OutputStream getOutputStream() ： 返回此套接字的输出流。
如果此Scoket具有相关联的通道，则生成的OutputStream 的所有操作也关联该通道。
关闭生成的OutputStream也将关闭相关的Socket。
public void close() ：关闭此套接字。
一旦一个socket被关闭，它不可再使用。
关闭此socket也将关闭相关的InputStream和OutputStream 。
public void shutdownOutput() ： 禁用此套接字的输出流。
任何先前写出的数据将被发送，随后终止输出流

2.2.2 ServerSocket类

ServerSocket 类：这个类实现了服务器套接字，该对象等待通过网络的请求。

构造方法

public ServerSocket(int port) ：使用该构造方法在创建ServerSocket对象时，就可以将其绑定到一个指
定的端口号上，参数port就是端口号。

构造举例，代码如下：

ServerSocket server = new ServerSocket(6666)

成员方法

public Socket accept() ：侦听并接受连接，返回一个新的Socket对象，用于和客户端实现通信。该方法
会一直阻塞直到建立连接

2.3 TCP通信案例

2.3.1 TCP通信分析图解

1. 【服务端】启动,创建ServerSocket对象，等待连接。
2. 【客户端】启动,创建Socket对象，请求连接。
3. 【服务端】接收连接,调用accept方法，并返回一个Socket对象。
4. 【客户端】Socket对象，获取OutputStream，向服务端写出数据。
5. 【服务端】Scoket对象，获取InputStream，读取客户端发送的数据

到此，客户端向服务端发送数据成功 

自此，服务端向客户端回写数据

6. 【服务端】Socket对象，获取OutputStream，向客户端回写数据。
7. 【客户端】Scoket对象，获取InputStream，解析回写数据。
8. 【客户端】释放资源，断开连接。

2.3.2 客户端向服务器发送数据

服务端实现：

public class ServerTCP {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动 , 等待连接 .... ");
// 1.创建 ServerSocket对象，绑定端口，开始等待连接
        ServerSocket ss = new ServerSocket(6666);
// 2.接收连接 accept 方法, 返回 socket 对象.
        Socket server = ss.accept();
// 3.通过socket 获取输入流
        InputStream is = server.getInputStream();
// 4.一次性读取数据
// 4.1 创建字节数组
        byte[] b = new byte[1024];
// 4.2 据读取到字节数组中.
        int len = is.read(b)；
// 4.3 解析数组,打印字符串信息
        String msg = new String(b, 0, len);
        System.out.println(msg);
//5.关闭资源.
        is.close();
        server.close();
    }
}

客户端实现：

public class ClientTCP {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端 发送数据");
// 1.创建 Socket ( ip , port ) , 确定连接到哪里.
        Socket client = new Socket("localhost", 6666);
// 2.获取流对象 . 输出流
        OutputStream os = client.getOutputStream();
// 3.写出数据.
        os.write("你好么? tcp ,我来了".getBytes());
// 4. 关闭资源 .
        os.close();
        client.close();
    }
}

2.3.3 服务器向客户端回写数据

服务端实现：

public class ServerTCP {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动 , 等待连接 .... ");
// 1.创建 ServerSocket对象，绑定端口，开始等待连接
        ServerSocket ss = new ServerSocket(6666);
// 2.接收连接 accept 方法, 返回 socket 对象.
        Socket server = ss.accept();
// 3.通过socket 获取输入流
        InputStream is = server.getInputStream();
// 4.一次性读取数据
// 4.1 创建字节数组
        byte[] b = new byte[1024];
// 4.2 据读取到字节数组中.
        int len = is.read(b)；
// 4.3 解析数组,打印字符串信息
        String msg = new String(b, 0, len);
        System.out.println(msg);
// =================回写数据=======================
// 5. 通过 socket 获取输出流
        OutputStream out = server.getOutputStream();
// 6. 回写数据
        out.write("我很好,谢谢你".getBytes());
// 7.关闭资源.
        out.close();
        is.close();
        server.close();
    }
}

客户端实现

public class ClientTCP {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端 发送数据");
// 1.创建 Socket ( ip , port ) , 确定连接到哪里.
        Socket client = new Socket("localhost", 6666);
// 2.通过Scoket,获取输出流对象
        OutputStream os = client.getOutputStream();
// 3.写出数据.
        os.write("你好么? tcp ,我来了".getBytes());
// ==============解析回写=========================
// 4. 通过Scoket,获取 输入流对象
        InputStream in = client.getInputStream();
// 5. 读取数据数据
        byte[] b = new byte[100];
        int len = in.read(b);
        System.out.println(new String(b, 0, len));
// 6. 关闭资源 .
        in.close();
        os.close();
        client.close();
    }
}

第三章 综合案例

文件上传分析图解

1. 【客户端】输入流，从硬盘读取文件数据到程序中。
2. 【客户端】输出流，写出文件数据到服务端。
3. 【服务端】输入流，读取文件数据到服务端程序。
4. 【服务端】输出流，写出文件数据到服务器硬盘中。

基本实现

服务端实现：

public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器 启动..... ");
// 1. 创建服务端ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
// 2. 建立连接
        Socket accept = serverSocket.accept();
// 3. 创建流对象
// 3.1 获取输入流,读取文件数据
        BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
// 3.2 创建输出流,保存到本地 .
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.jpg"));
// 4. 读写数据
        byte[] b = new byte[1024 * 8];
        int len;
        while ((len = bis.read(b)) != ‐1) {
            bos.write(b, 0, len);
        }
//5. 关闭 资源
        bos.close();
        bis.close();
        accept.close();
        System.out.println("文件上传已保存");
    }
}

客户端实现：

public class FileUPload_Client {
    public static void main(String[] args) throws IOException {
// 1.创建流对象
// 1.1 创建输入流,读取本地文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.jpg"));
// 1.2 创建输出流,写到服务端
        Socket socket = new Socket("localhost", 6666);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
//2.写出数据.
        byte[] b = new byte[1024 * 8 ];
        int len ;
        while (( len = bis.read(b))!=‐1) {
            bos.write(b, 0, len);
            bos.flush();
        }
        System.out.println("文件发送完毕");
// 3.释放资源
        bos.close();
        socket.close();
        bis.close();
        System.out.println("文件上传完毕 ");
    }
}

文件上传优化分析

1. 文件名称写死的问题

服务端，保存文件的名称如果写死，那么最终导致服务器硬盘，只会保留一个文件，建议使用系统时间优
化，保证文件名称唯一，代码如下：

FileOutputStream fis = new FileOutputStream(System.currentTimeMillis()+".jpg") // 文件名称
BufferedOutputStream bos = new BufferedOutputStream(fis);

2. 循环接收的问题

服务端，指保存一个文件就关闭了，之后的用户无法再上传，这是不符合实际的，使用循环改进，可以不断
的接收不同用户的文件，代码如下

// 每次接收新的连接,创建一个Socket
while（true）{
Socket accept = serverSocket.accept();
......
}

3. 效率问题

服务端，在接收大文件时，可能耗费几秒钟的时间，此时不能接收其他用户上传，所以，使用多线程技术优
化，代码如下：

while（true）{
Socket accept = serverSocket.accept();
// accept 交给子线程处理.
new Thread(() ‐> {
......
InputStream bis = accept.getInputStream();
......
}).start();
}

优化实现

public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器 启动..... ");
// 1. 创建服务端ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
// 2. 循环接收,建立连接
        while (true) {
            Socket accept = serverSocket.accept();
/*
3. socket对象交给子线程处理,进行读写操作
Runnable接口中,只有一个run方法,使用lambda表达式简化格式
*/
            new Thread(() ‐> {
            try (
//3.1 获取输入流对象
                    BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
//3.2 创建输出流对象, 保存到本地 .
                    FileOutputStream fis = new FileOutputStream(System.currentTimeMillis() + ".jpg");
                    BufferedOutputStream bos = new BufferedOutputStream(fis);) {
// 3.3 读写数据
                byte[] b = new byte[1024 * 8];
                int len;
                while ((len = bis.read(b)) != ‐1) {
                    bos.write(b, 0, len);
                }
//4. 关闭 资源
                bos.close();
                bis.close();
                accept.close();
                System.out.println("文件上传已保存");
            } catch (IOException e) {
                e.printStackTrace();
            }
}).start();
        }
    }
}

前四步与基本文件上传一致

 5. 【服务端】获取输出流，回写数据。
6. 【客户端】获取输入流，解析回写数据。

回写实现

public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器 启动..... ");
// 1. 创建服务端ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
// 2. 循环接收,建立连接
        while (true) {
            Socket accept = serverSocket.accept();
/*
3. socket对象交给子线程处理,进行读写操作
Runnable接口中,只有一个run方法,使用lambda表达式简化格式
*/
            new Thread(() ‐> {
            try (
//3.1 获取输入流对象
                    BufferedInputStream bis = new
                            BufferedInputStream(accept.getInputStream());
//3.2 创建输出流对象, 保存到本地 .
                    FileOutputStream fis = new FileOutputStream(System.currentTimeMillis() +
                            ".jpg");
                    BufferedOutputStream bos = new BufferedOutputStream(fis);) {
// 3.3 读写数据
                byte[] b = new byte[1024 * 8];
                int len;
                while ((len = bis.read(b)) != ‐1) {
                    bos.write(b, 0, len);
                }
// 4.=======信息回写===========================
                System.out.println("back ........");
                OutputStream out = accept.getOutputStream();
                out.write("上传成功".getBytes());
                out.close();
//================================
//5. 关闭 资源
                bos.close();
                bis.close();
                accept.close();
                System.out.println("文件上传已保存");
            } catch (IOException e) {
                e.printStackTrace();
            }
}).start();
        }
    }
}  

客户端实现：

public class FileUpload_Client {
    public static void main(String[] args) throws IOException {
// 1.创建流对象
// 1.1 创建输入流,读取本地文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.jpg"));
// 1.2 创建输出流,写到服务端
        Socket socket = new Socket("localhost", 6666);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
//2.写出数据.
        byte[] b = new byte[1024 * 8 ];
        int len ;
        while (( len = bis.read(b))!=‐1) {
            bos.write(b, 0, len);
        }
// 关闭输出流,通知服务端,写出数据完毕
        socket.shutdownOutput();
        System.out.println("文件发送完毕");
// 3. =====解析回写============
        InputStream in = socket.getInputStream();
        byte[] back = new byte[20];
        in.read(back);
        System.out.println(new String(back));
        in.close();
// ============================
// 4.释放资源
        socket.close();
        bis.close();
    }
}