Java网络编程

网络的相关概念

网络通信

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

网络

1. 概念：两台或多台设备通过一定物理设备连接起来构成了网络

2. 根据网络的覆盖范围不同，对网络进行分类：

3. 1. 局域网：覆盖范围最小，仅仅覆盖一个教室或一个机房
   2. 城域网：覆盖范围较大，可以覆盖一个城市
   3. 广域网：覆盖范围最大，可以覆盖全国，甚至全球，万维网是广域网的代表

ip地址

1. 概念：用于唯一标识网络中的每台计算机/主机，即****唯一标识主机
2. **查看ip地址：**ipconfig
3. ip地址的标识形式：点分****十进制 xx.xx.xx.xx
4. 每一个十进制数的范围 0~255

• IP表示：对于IPv4，有4个字节（32位）

1. ip地址的组成 = 网络地址 + 主机地址**，比如：192.168.16.69**
2. IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称可以为全世界的每一粒沙子编上一个地址(现在IPv4仍在使用)

• IPv6有 128 位，表示一个地址，即 16个字节，是IPv4的四倍，并且IPb6用十六进制表示

1. 由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展，IPv6的使用，不仅能解决网络地址资源数量的问题，而且也****解决了多种接入设备连入互联网的障碍

IPv4地址分类

类型	范围
A	0.0.0.0 到 127.255.255.255
B	128.0.0.0 到 191.255.255.255
C	192.0.0.0 到 223.255.255.255
D	224.0.0.0 到 239.255.255.255
E	240.0.0.0 到 247.255.255.255

• 特殊的：127.0.0.1 表示本机地址
• 用的比较多的是ABC类

域名

1. 如 www.baidu.com
2. 好处：为了方便记忆，解决记ip的困难
3. 概念：将ip地址映射成域名

• 端口号

1. 概念：用于标识计算机上某个特定的网络程序
2. **表示形式：以整数形式，**端口范围 0~65535【2个字节表示端口 0~2^16-1】
3. 0~1024端口已经被占用**，比如 ssh: 22, ftp; 21, smtp: 25, http: 80**

注意：有些端口已经被占用了，要注意。在网络开发中，不要使用0~1024的端口，因为这些端口往往都被占用了

1. 常见的网络程序端口号：

• tomcat：8080

• mysql：3306

• oracle：1521

• sqlserver：1433

• ip + 端口 ==> 访问网站

• 只有服务才需要监听端口，如果只是一个程序什么的，就不需要端口，就能访问

• 多个服务不能监听同一个端口

网络通信协议

• 协议（TCP / IP）

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

• 数据进入协议栈时的封装过程

• 在网络编程中，数据的组织形式就是协议
• 解包过程（拆包）：

• 就是先经过以太网驱动程序，拿到IP，再经过IP，拿到TCP，再通过TCP，拿到应用程序

• 目的：就是为了将数据准确无误的传给别人

OSI模型(理论)	TCP/IP模型	TCP/IP模型各层对应协议
应用层	应用层	HTTP、ftp、telnet、DNS…
表示层
会话层
传输层	传输层（TCP）	TCP、UDP…
网络层	网络层（IP）	IP、ICMP、ARP…
数据链路层	物理+数据链路层	Link
物理层

TCP 和 UDP

TCP协议

TCP协议：传输控制协议

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

• 三次握手，是为了确认对方一定能接受数据

就好比一个中国人和一个英国人交流，两人一人只会中文，一人只会英文，然后中国人说了句：你好。而英国人听不懂。而三次握手就是试验的过程，就是为了确认对方能不能听懂己方

• 三次握手示意图：

• 注意：当三次握手后，就确定了能否接受数据，之后就会进行大量数据的传输
• 另外，传输结束后，必须释放已建立的连接

例子：

UDP协议

UDP协议：用户数据协议

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

• 不可靠：即传输的数据，对方不一定能够接收到

例子：

• 比如：tom对在厕所的kim说，明天上午10:00开会，然后就走了，它可能都不知道kim在哪个坑位，就直接说，说完就走，也不管kim有没有接收到这个信息
• 又比如：UDP发短信给 15566667777，它都不知道这个号码存不存在，就直接发送，可能这个号码已经被注销了，别人都不用了，那自然别人就接收不到这个信息了

InetAddress类

1. 获取本机InetAddress对象：getLocalHost
2. 根据指定主机名 / 域名获取ip地址对象：getByName
3. 获取InetAddress对象的主机名：getHostName
4. 获取InetAddress对象的地址：getHostAddress

package com.zanedu.api;

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

//演示InetAddress类 的使用
public class API_ {
    public static void main(String[] args) throws UnknownHostException {

        //1. 获取本机的InetAddress对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);// LAPTOP-V7NQKUSS/10.171.103.113

        //2. 根据指定的主机名 获取 InetAddress对象
        InetAddress host1 = InetAddress.getByName("LAPTOP-V7NQKUSS");
        System.out.println(host1); // LAPTOP-V7NQKUSS/10.171.103.113

        //3. 根据域名返回 InetAddress对象，比如 www.baidu.com 对应的 InetAddress对象
        InetAddress host2 = InetAddress.getByName("www.baidu.com");
        System.out.println(host2);// 域名 / 对应的ip
        // www.baidu.com/180.101.49.11

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

        //5. 通过 InetAddress对象，获取对应的主机名/域名
        String hostName = host2.getHostName();
        System.out.println(hostName);//www.baidu.com
    }
}

Socket

1. 套接字（Socket）开发网络应用程序被广泛采用，以至于成为事实上的标准
2. 通信的两端都要有Socket，是两台机器间通信的端点

• 有两种编程方式（TCP编程 - 可靠）（UDP编程 - 不可靠）

1. 网络通信其实就是Socket间的通信
2. Socket允许程序把网络连接当成一个流，数据在两个Socket间****通过IO传输
3. 一般主动发起通信的应用程序属客户端，等待通信请求的为****服务端

• 示意图

• 客户端和服务端一般情况下是在不同主机的
• 当我们需要通讯时（读写数据）

使用 : 
socket.getOutputStream
socket.getInputStream

TCP网络通信编程

基本介绍

1. 基于客户端——服务端的网络通信
2. 底层使用的是TCP/IP协议
3. 应用场景距离：客户端发送数据，服务端接受并显示到控制台
4. 基于Socket的TCP编程，是可靠的

• 注意：一定要关闭Socket，因为它的连接数是有限的

应用案例

一（使用字节流）

需求：

1. 编写一个服务端和一个客户端
2. 服务端在9999端口监听
3. 客户端连接到服务端，发送"hello, server"，然后退出
4. 服务端接收到客户端发送的信息，输出并退出

• 思路

• 服务端 - SocketTCP01Server

package com.zanedu.socket;

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

//服务端
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.getClass());

        //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        InputStream inputStream = socket.getInputStream();
        //4. IO读取
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, readLen));//根据读取到的实际长度，显示内容
        }
        //5. 关闭流和socket
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

• 客户端 - SocketTCP01Client

package com.zanedu.socket;

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

//客户端，发送 hello，server 给服务端
public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 连接服务端 (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());
        //4. 关闭流对象和socket，必须关闭
        outputStream.close();
        socket.close();
        System.out.println("客户端退出....");
    }
}

• 如果我们没有在9999端口监听，等待连接，则会抛出连接异常，即error

• 当没有客户端连接9999端口时，程序会堵塞，等待连接

• 只有服务端先进行监听，等待客户端连接，然后客户端连接，这样才不会抛出异常

二（使用字节流）

1. 编写一个服务端和一个客户端
2. 服务端在9999端口进行监听
3. 客户端连接到服务端，发送"hello, server"，并接受服务端回发的"hello, client"，再退出
4. 服务端接收到客户端发送的信息，输出，并发送"hello, client"，再退出

• 这样的话，就需要设置结束标记

socket.shutdownOutput();
//同时也可以使用writer.newLine(); 来设置写入结束标记
//但是需要对方使用readLine() 方式来接受
writer.newLine();

• 服务端 - SocketTCP02Server

package com.zanedu.socket;

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

//服务端
public class SocketTCP02Server {
    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();

        //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        InputStream inputStream = socket.getInputStream();

        //4. IO读取
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, readLen));
        }

        //5. 获取socket相关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello, client".getBytes());

        //设置结束标记
        socket.shutdownOutput();

        //6. 关闭流和socket
        serverSocket.close();
        inputStream.close();
        outputStream.close();
        System.out.println("客户端退出....");
    }
}

• 客户端 - Socket03TCPClient

package com.zanedu.socket;

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

//客户端
public class SocketTCP02Client {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 连接服务端 (ip , 端口）
        //   解读：连接本机的 9999端口，如果连接成功，返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        //2. 连接上后，生成Socket, 通过socket.getOutputStream()
        //得到/返回 和 socket对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //3. 通过输出流，写入数据到 数据通道
        outputStream.write("hello, server".getBytes());

        //设置一个结束标记
        socket.shutdownOutput();

        //4. 获取和socket关联的输入流，读取数据(按字节)并显示
        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));
        }

        //5. 关闭流对象和socket，必须关闭
        inputStream.close();
        socket.close();
        outputStream.close();
        System.out.println("客户端退出....");

    }
}

• 如果没有结束标记，就不知道什么时候结束，会一直卡在那

三（使用字符流）

1. 编写一个服务端和一个客户端
2. 服务端在9999端口进行监听
3. 客户端连接到服务端，发送"hello, server"，并接受服务端回发的"hello, client"，再退出
4. 服务端接收到客户端发送的信息，输出，并发送"hello, client"，再退出

• 使用转换流
• 服务端 - SocketTCP03Server

package com.zanedu.socket;

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

public class SocketTCP03Server {
    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();

        //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        InputStream inputStream = socket.getInputStream();

        //4. IO读取 - 使用字符流，使用 InputStreamReader 将 InputStream 转成字符流
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
        String s = br.readLine();
        System.out.println(s);

        //5. 获取socket相关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        //使用字符输出流的方式回复信息
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
        bw.write("hello, client 字符流");
        bw.newLine();//插入一个换行符，表示回复内容的结束
        bw.flush();//注意：需要手动的刷新flush一下


        //6. 关闭流和socket
        serverSocket.close();
        bw.close();//一般来说，后面的先关闭
        br.close();//关闭外层流
        System.out.println("客户端退出....");
    }
}

• 客户端 - SocketTCP03Client

package com.zanedu.socket;

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

public class SocketTCP03Client {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 连接服务端 (ip , 端口）
        //   解读：连接本机的 9999端口，如果连接成功，返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        //2. 连接上后，生成Socket, 通过socket.getOutputStream()
        //得到/返回 和 socket对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //3. 通过输出流，写入数据到 数据通道，要求写入字符流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
        bw.write("hello, server 字符流");
        bw.newLine();//输入一个换行符，表示写入内容结束 注意：要求对方使用readLine()来读取
        bw.flush();//如果使用的字符流，需要手动刷新，否则数据不会写入到数据通道

        //4. 获取和socket关联的输入流，读取数据(按字符)并显示
        InputStream inputStream = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
        String s = br.readLine();
        System.out.println(s);


        //5. 关闭流对象和socket，必须关闭
        br.close();//关闭外层流
        bw.close();
        socket.close();
        System.out.println("客户端退出....");
    }
}

• 注意：一定要手动flush刷新一下，不然数据不会写入到数据通道
• 使用newLine()，对方就一定要使用readLine()方法来接受

四

1. 编写一个服务端和一个客户端
2. 服务端在8888端口监听
3. 客户端连接到服务端，发送一张图片 F:\qie.png
4. 服务端接受到客户端发送的蹄片，保存到src下，发送"收到图片"再退出
5. 客户端接收到服务端发送的"收到图片"，再退出
6. 该程序要求使用StreamUtils.java（自己定义的方法）

• StreamUtils工具类

package com.zanedu.upload;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * 此类用于演示关于流的读写方法
 *
 */
public class StreamUtils {
	/**
	 * 功能：将输入流转换成byte[]， 即可以把文件的内容读入到byte[]
	 * @param is
	 * @return
	 * @throws Exception
	 */
	public static byte[] streamToByteArray(InputStream is) throws Exception{
		ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
		byte[] b = new byte[1024];//字节数组
		int len;
		while((len=is.read(b))!=-1){//循环读取
			bos.write(b, 0, len);//把读取到的数据，写入bos	
		}
		byte[] array = bos.toByteArray();//然后将bos 转成字节数组
		bos.close();
		return array;
	}
	/**
	 * 功能：将InputStream转换成String
	 * @param is
	 * @return
	 * @throws Exception
	 */
	
	public static String streamToString(InputStream is) throws Exception{
		BufferedReader reader = new BufferedReader(new InputStreamReader(is));
		StringBuilder builder= new StringBuilder();
		String line;
		while((line=reader.readLine())!=null){ //当读取到null时，就表示结束
			builder.append(line+"\r\n");
		}
		return builder.toString();
		
	}

}

• 服务端 - TCPFileUploadServer

package com.zanedu.upload;

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

//文件上传的服务端
public class TCPFileUploadServer {
    public static void main(String[] args) throws Exception {
        //1. 服务端在本机监听 8888端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端在8888端口监听");
        //2. 等待连接（接受连接）
        Socket socket = serverSocket.accept();

        //3. 读取客户端发送的数据
        //   通过socket得到输入流
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        //使用方法
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //4. 将得到的bytes写入到指定的路径，就得到一个文件了
//        String destFile = "src\\bg1.png";
        String destFile = "src\\高山流水1.mp3";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
        bos.write(bytes);
        bos.close();

        //向客户端回复 “收到图片”信息
        //通过socket 获取到输出流（以字符）
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        writer.write("收到图片");
        writer.flush();//把内容刷新到数据通道
        socket.shutdownOutput();//设置结束标记

        //关闭其他流
        writer.close();
        bis.close();
        socket.close();
        serverSocket.close();

    }
}

• 客户端 - TCPFileUploadClient

package com.zanedu.upload;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.Socket;


//文件上传的客户端
public class TCPFileUploadClient {
    public static void main(String[] args) throws Exception {

        //1. 客户端连接服务端，得到Socket
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        //2. 创建读取磁盘文件的输入流
//        String filePath = "F:\\Java\\code\\bg.png";
        String filePath = "F:\\Java\\code\\高山流水.mp3";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
        //3. 使用自己创建的工具库，直接使用
        //   这个bytes就是filePath对应的字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);

        //4. 通过socket获取得到输出流，将bytes数据发送给服务端
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);//将文件对应的字节数组的内容，写入到数据通道
        //   设置结束标志
        bis.close();
        socket.shutdownOutput();//设置写入数据的结束标记

        //====接受从服务端回复的信息
        InputStream inputStream = socket.getInputStream();
        //使用StreamUtils 方法，直接将 inputStream 读取到的内容转成字符串
        String s = StreamUtils.streamToString(inputStream);
        System.out.println(s);


        //5. 关闭相关的流
        inputStream.close();
        bos.close();
        socket.close();

    }
}

netstat指令

1. netstat -an 可以查看当前主机网络情况，包括端口监听情况和网络连接情况
2. nestat -an | more 可以分页显示
3. 要求在dos控制台下执行

说明：

1. Listening表示某个端口在监听
2. 如果有一个外部程序（客户端）连接到该端口，就会显示一条连接信息

• 外部地址就是显示连接到主机的某一个连接

• Listening监听状态

TCP网络编程不为人知的秘密

当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这个端口是TCP/IP来分配的，是不确定的，是随机的

• 客户端端口是随机的

UDP网络通信编程

基本介绍

1. 类DatagramSocket 和 DatagramPacket[数据包/数据报]实现类****基于UDP协议网络程序
2. UDP数据报通过数据报套接字DatagramSocket发送和接受，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达，即是不可靠****的
3. DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号
4. UDP协议中每个数据报都给出了完整的地址信息，因此****无须建立发送方和接收方的连接

基本流程

1. 核心的两个类/对象 DatagramSocket与DatagramPacket
2. 建立发送端、接收端（没有服务端和客户端概念）
3. 发送数据前，建立数据包/报 DatagramPacket对象【即将数据封装到DatagramPacket对象】
4. 调用DatagramSocket的发送、接收方法
5. 关闭DatagramSocket

• 注意：当接收到DatagramPacket对象时，需要进行拆包，从而取出数据

• InetAddress相当于主机，最后的int相当于端口

应用案例

1. 编写一个接收端A和一个发送端B
2. 接收端A在9999端口等待接受数据（receive）
3. 发送端B向接收端A发送数据"hello，明天吃火锅"
4. 接收端A接收到发送端B发送的数据，回复"好的，明天见"，再退出
5. 发送端接受回复的数据，再退出

• UDP接收端A

package com.zanedu.udp;

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

//UDP接收端A
public class UDPReceiveA {
    public static void main(String[] args) throws IOException {
        //1. 创建一个 DatagramSocket对象，准备接受数据，准备在9999端口接受数据
        DatagramSocket socket = new DatagramSocket(9999);
        //2. 构建一个 DatagramPacket对象，准备接受数据
        //   UDP协议，一个数据包最大 64k
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);
        //3. 调用接受方法，将通过网络传输的 DatagramPacket对象 填充到packet对象
        //提示：当有数据包发送到本机的9999端口时，就会接收到数据，如果没有数据包发送到本机的9999端口时，那么就会堵塞等待
        System.out.println("接收端A 等待接收数据");
        socket.receive(packet);

        //4. 可以把packet进行拆包，取出数据并显示
        int length = packet.getLength();//实际接收到的数据字节长度
        byte[] data = packet.getData();//接收到的数据

        String s = new String(data, 0, length);
        System.out.println(s);

        //====回复信息给B端

        //2. 将需要发送的数据，封装到 DatagramPacket对象
        data = "好的，明天见".getBytes();

        //说明：封装的 DatagramPacket 对象的data内容字节数组，data.length, 主机（IP），端口
        DatagramPacket datagramPacket = new DatagramPacket(data, data.length, InetAddress.getByName("10.171.103.113"), 9998);
        //                                                         InetAddress.getLocalHost() 的确可以，但是一般都不会在一个主机上使用

        socket.send(datagramPacket);//发送

        //5. 关闭流
        socket.close();
        System.out.println("A端退出....");
    }
}

• UDP发送端B

package com.zanedu.udp;

import java.io.IOException;
import java.net.*;

//UDP发送端B
public class UDPSenderB {
    public static void main(String[] args) throws IOException {

        //1. 创建DatagramSocket对象，准备发送和接受数据
        //   在9998端口准备接受数据
        DatagramSocket socket = new DatagramSocket(9998);

        //2. 将需要发送的数据，封装到 DatagramPacket对象
        byte[] bytes = "hello, 明天吃火锅".getBytes();

        //说明：封装的 DatagramPacket 对象的data内容字节数组，data.length, 主机（IP），端口
        DatagramPacket packet = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("10.171.103.113"), 9999);
        //                                                         InetAddress.getLocalHost() 的确可以，但是一般都不会在一个主机上使用

        socket.send(packet);

        //3. 接受从A端回复的信息

        //  (1)构建一个 DatagramPacket对象，准备接受数据
        //     UDP协议，一个数据包最大 64k
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        //  (2) 调用接受方法，将通过网络传输的 DatagramPacket对象 填充到packet对象
        //提示：当有数据包发送到本机的9998端口时，就会接收到数据，如果没有数据包发送到本机的9998端口时，那么就会堵塞等待
        socket.receive(packet);

        //  (3)可以把packet进行拆包，取出数据并显示
        int length = packet.getLength();//实际接收到的数据字节长度
        bytes = packet.getData();//接收到的数据

        String s = new String(bytes, 0, length);
        System.out.println(s);


        //关闭资源
        socket.close();
        System.out.println("B端退出....");
    }
}

练习题

题一

• 服务端 - Homework01Server

package com.zanedu.homework.homework01;

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

//服务端
public class Homework01Server {
    public static void main(String[] args) throws Exception{
        //思路
        //1. 在本机 的9999端口监听, 等待连接
        //细节：要求在本机没有其他服务在监听/占用 9999
        //细节：这个 ServerSocket 可以通过accept() 返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);

        //2. 当没有客户端连接9999端口时，程序会阻塞, 等待连接
        //   如果有客户端连接，则会返回 Socket对象，程序继续
        Socket socket = serverSocket.accept();

        //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        InputStream inputStream = socket.getInputStream();

        //4. IO读取 - 使用字符流，使用 InputStreamReader 将 InputStream 转成字符流
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
        String s = br.readLine();
        String answer = "";
        if ("name".equals(s)) {
            answer = "我是Zan";
        } else if ("hobby".equals(s)) {
            answer = "编写Java程序";
        } else {
            answer = "你说什么";
        }

        //5. 获取socket相关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        //使用字符输出流的方式回复信息
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
        bw.write(answer);
        bw.newLine();//插入一个换行符，表示回复内容的结束
        bw.flush();//注意：需要手动的刷新flush一下


        //6. 关闭流和socket
        serverSocket.close();
        bw.close();//一般来说，后面的先关闭
        br.close();//关闭外层流
        System.out.println("客户端退出....");
    }
}

• 客户端 - Homework01Client

package com.zanedu.homework.homework01;

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

//客户端
public class Homework01Client {
    public static void main(String[] args) throws Exception{
        //思路
        //1. 连接服务端 (ip , 端口）
        //   解读：连接本机的 9999端口，如果连接成功，返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        //2. 连接上后，生成Socket, 通过socket.getOutputStream()
        //得到/返回 和 socket对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //3. 通过输出流，写入数据到 数据通道，要求写入字符流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));

        //从键盘读取用户的问题
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的问题");
        String question = scanner.next();

        bw.write(question);
        bw.newLine();//输入一个换行符，表示写入内容结束 注意：要求对方使用readLine()来读取
        bw.flush();//如果使用的字符流，需要手动刷新，否则数据不会写入到数据通道

        //4. 获取和socket关联的输入流，读取数据(按字符)并显示
        InputStream inputStream = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
        String s = br.readLine();
        System.out.println(s);


        //5. 关闭流对象和socket，必须关闭
        br.close();//关闭外层流
        bw.close();
        socket.close();
        System.out.println("客户端退出....");
    }
}

题二

• 接收端 - Homework02Receive

package com.zanedu.homework.homework02;

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

//接收端
public class Homework02Receive {
    public static void main(String[] args) throws Exception{
        //1. 创建一个 DatagramSocket对象，准备接受数据，准备在8888端口接受数据
        DatagramSocket socket = new DatagramSocket(8888);
        //2. 构建一个 DatagramPacket对象，准备接受数据
        //   UDP协议，一个数据包最大 64k
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);
        //3. 调用接受方法，将通过网络传输的 DatagramPacket对象 填充到packet对象
        //提示：当有数据包发送到本机的8888端口时，就会接收到数据，如果没有数据包发送到本机的88889999端口时，那么就会堵塞等待
        System.out.println("接收端等待接受问题");
        socket.receive(packet);

        //4. 可以把packet进行拆包，取出数据并显示
        int length = packet.getLength();//实际接收到的数据字节长度
        byte[] data = packet.getData();//接收到的数据
        String s = new String(data, 0, length);
        String answer = "";
        //判断接收到的信息是什么
        if ("四大名著是哪些".equals(s)) {
            answer = "四大名著=《红楼梦》、《三国演义》、《西游记》、《水浒传》";
        } else {
            answer = "what?";
        }

        //====回复信息给B端
        //2. 将需要发送的数据，封装到 DatagramPacket对象
        data = answer.getBytes();

        //说明：封装的 DatagramPacket 对象的data内容字节数组，data.length, 主机（IP），端口
        DatagramPacket datagramPacket = new DatagramPacket(data, data.length, InetAddress.getByName("10.171.103.113"), 9998);
        //                                                         InetAddress.getLocalHost() 的确可以，但是一般都不会在一个主机上使用

        socket.send(datagramPacket);//发送

        //5. 关闭流
        socket.close();
        System.out.println("A端退出....");
    }
}

• 发送端 - Homework02Sender

package com.zanedu.homework.homework02;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

//发送端
public class Homework02Sender {
    public static void main(String[] args) throws Exception{
        //1. 创建DatagramSocket对象，准备发送和接受数据
        //   在9998端口准备接受数据
        DatagramSocket socket = new DatagramSocket(9998);

        //2. 将需要发送的数据，封装到 DatagramPacket对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的问题");
        String question = scanner.next();
        byte[] bytes = question.getBytes();

        //说明：封装的 DatagramPacket 对象的data内容字节数组，data.length, 主机（IP），端口
        DatagramPacket packet = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("10.171.103.113"), 8888);
        //                                                         InetAddress.getLocalHost() 的确可以，但是一般都不会在一个主机上使用

        socket.send(packet);

        //3. 接受从A端回复的信息

        //  (1)构建一个 DatagramPacket对象，准备接受数据
        //     UDP协议，一个数据包最大 64k
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        //  (2) 调用接受方法，将通过网络传输的 DatagramPacket对象 填充到packet对象
        //提示：当有数据包发送到本机的9998端口时，就会接收到数据，如果没有数据包发送到本机的9998端口时，那么就会堵塞等待
        socket.receive(packet);

        //  (3)可以把packet进行拆包，取出数据并显示
        int length = packet.getLength();//实际接收到的数据字节长度
        bytes = packet.getData();//接收到的数据

        String s = new String(bytes, 0, length);
        System.out.println(s);

        //关闭资源
        socket.close();
        System.out.println("B端退出....");
    }
}

题三

• 客户端 - Homework03Client

package com.zanedu.homework.homework03;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;

//文件下载的客户端
public class Homework03Client {
    public static void main(String[] args) throws Exception {

        //1. 接受用户输入，指定下载文件名
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入下载文件名");
        String downLoadFileName = scanner.next();

        //2. 客户端连接服务端，准备发送
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        //3. 获取和Socket关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write(downLoadFileName.getBytes());
        //设置写入结束标志
        socket.shutdownOutput();

        //4. 读取服务端返回的文件(字节数据)
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        //5. 使用工具类
        byte[] bytes = StreamUtils.streamToByteArray(bis);

        //6. 得到一个输出流，准备将 bytes 内容写入到磁盘
        //如果你下载的是 高山流水 ==> 下载的就是 高山流水.mp3
        //    你下载的是 Zan ==> 下载的就是 无名.mp3，但是文件名是 Zan.mp3
        String filePath = "F:\\" + downLoadFileName + ".mp3";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
        bos.write(bytes);

        //7. 关闭相关资源
        bos.close();
        bis.close();
        outputStream.close();
        socket.close();
        System.out.println("客户端下载完毕，正确退出");
    }
}

• 服务端 - Homework03Server

package com.zanedu.homework.homework03;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

//先写文件下载的服务端
public class Homework03Server {
    public static void main(String[] args) throws Exception {

        //1. 监听 9999端口，等待客户端连接并读取客户端发送的下载文件的名称
        ServerSocket serverSocket = new ServerSocket(9999);
        //2. 等待客户端连接
        System.out.println("服务端在9999端口监听，等待下载文件");
        Socket socket = serverSocket.accept();

        //3. 读取客户端发送要下载的文件名
        //   这里使用了while循环读取文件名，是考虑了将来客户端发送的数据比较大的情况
        InputStream inputStream = socket.getInputStream();
        byte[] b = new byte[1024];
        int readLen = 0;
        String downLoadFileName = "";
        while ((readLen = inputStream.read(b)) != -1)  {
            downLoadFileName += new String(b, 0, readLen);
        }
        System.out.println("客户端希望下载的文件名是=" + downLoadFileName);

        //在服务器上有两个文件，无名.mp3 和 高山流水.mp3
        //如果客户下载的是 高山流水，我们就返回该文件，否则就一律返回 无名.mp3

        String resFileName = "";
        if ("高山流水".equals(downLoadFileName)) {
            resFileName = "src\\高山流水.mp3";
        } else {
            resFileName = "src\\无名.mp3";
        }
        //4. 创建一个输入流，读取文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(resFileName));

        //5. 使用工具类StreamUtils类 读取文件到一个字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //6. 得到Socket关联的输出流
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        //7. 写入到数据通道，返回给客户端
        bos.write(bytes);
        socket.shutdownOutput();

        //8. 关闭相关资源
        bis.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出");
    }
}

• 工具类 - StreamUtils

package com.zanedu.homework.homework03;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * 此类用于演示关于流的读写方法
 *
 */
public class StreamUtils {
	/**
	 * 功能：将输入流转换成byte[]， 即可以把文件的内容读入到byte[]
	 * @param is
	 * @return
	 * @throws Exception
	 */
	public static byte[] streamToByteArray(InputStream is) throws Exception{
		ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
		byte[] b = new byte[1024];//字节数组
		int len;
		while((len=is.read(b))!=-1){//循环读取
			bos.write(b, 0, len);//把读取到的数据，写入bos	
		}
		byte[] array = bos.toByteArray();//然后将bos 转成字节数组
		bos.close();
		return array;
	}
	/**
	 * 功能：将InputStream转换成String
	 * @param is
	 * @return
	 * @throws Exception
	 */
	
	public static String streamToString(InputStream is) throws Exception{
		BufferedReader reader = new BufferedReader(new InputStreamReader(is));
		StringBuilder builder= new StringBuilder();
		String line;
		while((line=reader.readLine())!=null){ //当读取到null时，就表示结束
			builder.append(line+"\r\n");
		}
		return builder.toString();
		
	}

}