前言
才发现学校的校医院竟然能报销85%的费用，可惜额度不大
正文
1、网络编程
网络通信协议
网络通信协议：通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。
通信的协议还是比较复杂的，
java.net包中包含的类和接口，它们提供低层次的通信细节。我们可以直接使用这些类和接口，来专注于网络程序开发，而不用考虑通信的细节。java.net包中提供了两种常见的网络协议的支持：
- UDP：用户数据报协议(User Datagram Protocol)。UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。
由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输。例如视频会议都使用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议。UDP的交换过程如下图所示。
特点:数据被限制在64kb以内，超出这个范围就不能发送了。
数据报(Datagram):网络传输的基本单位- TCP：传输控制协议 (Transmission Control Protocol)。TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。
在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”。- 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。
- 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
- 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
- 第三次握手，客户端再次向服务器端发送确认信息，确认连接。整个交互过程如下图所示。
完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛，例如下载文件、浏览网页等。
网络编程三要素（协议+IP地址+端口号）
协议
- 协议：计算机网络通信必须遵守的规则。
IP地址
- IP地址：指互联网协议地址（Internet Protocol Address），俗称IP。IP地址用来给一个网络中的计算机设备做唯一的编号。假如我们把“个人电脑”比作“一台电话”的话，那么“IP地址”就相当于“电话号码”。
IP地址分类
- IPv4：是一个32位的二进制数，通常被分为4个字节，表示成
a.b.c.d的形式，例如192.168.65.100。其中a、b、c、d都是0~255之间的十进制整数，那么最多可以表示42亿个。- IPv6：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。为了扩大地址空间，拟通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，表示成
ABCD:EF01:2345:6789:ABCD:EF01:2345:6789，号称可以为全世界的每一粒沙子编上一个网址，这样就解决了网络地址资源数量不够的问题。
端口号
网络的通信，本质上是两个进程（应用程序）的通信。每台计算机都有很多的进程，那么在网络通信时，如何区分这些进程呢？
如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的进程（应用程序）了。
端口号:用两个字节表示的整数，它的取值范围是0~65535。其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。利用
协议+IP地址+端口号三元组合，就可以标识网络中的进程了，那么进程间的通信就可以利用这个标识与其它进程进行交互。
【端口号】
2、TCP通信
TCP通信能实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端（Client）与服务端（Server）。
两端通信时步骤：
- 服务端程序，需要事先启动，等待客户端的连接。
- 客户端主动连接服务器端，连接成功才能通信。服务端不可以主动连接客户端。
在Java中，提供了两个类用于实现TCP通信程序：
- 客户端：
java.net.Socket类表示。创建Socket对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。- 服务端：
java.net.ServerSocket类表示。创建ServerSocket对象，相当于开启一个服务，并等待客户端的连接。
Socket类：该类实现客户端套接字，套接字指的是两台设备之间通讯的端点。
构造方法:
public Socket(String host, int port):创建套接字对象并将其连接到指定主机上的指定端口号。如果指定的host是null ，则相当于指定地址为回送地址。注意：回送地址(127.x.x.x) 是本机回送地址（Loopback Address），主要用于网络软件测试以及本地机进程间通信，无论什么程序，一旦使用回送地址发送数据，立即返回，不进行任何网络传输。成员方法：
public InputStream getInputStream()： 返回此套接字的输入流。
- 如果此Scoket具有相关联的通道，则生成的InputStream 的所有操作也关联该通道。
- 关闭生成的InputStream也将关闭相关的Socket。
public OutputStream getOutputStream()： 返回此套接字的输出流。
- 如果此Scoket具有相关联的通道，则生成的OutputStream 的所有操作也关联该通道。
- 关闭生成的OutputStream也将关闭相关的Socket。
public void close()：关闭此套接字。
- 一旦一个socket被关闭，它不可再使用。
- 关闭此socket也将关闭相关的InputStream和OutputStream 。
public void shutdownOutput()： 禁用此套接字的输出流。
- 任何先前写出的数据将被发送，随后终止输出流。
ServerSocket类：这个类实现了服务器套接字，该对象等待通过网络的请求。
构造方法：
public ServerSocket(int port)：使用该构造方法在创建ServerSocket对象时，就可以将其绑定到一个指定的端口号上，参数port就是端口号。成员方法
public Socket accept()：侦听并接受连接，返回一个新的Socket对象，用于和客户端实现通信。该方法会一直阻塞直到建立连接。【TCP通信原理】
【测试Demo】
/*** TCP通信的客户端：向服务器发送连接请求，给服务器发送数据，读取服务器回写的数据
* 表示客户端的类：
* java.net.Socket：此类实现客户端套接字（也可以就叫“套接字”），套接字是两台机器间通信的端点。
* 套接字：包含了IP地址和端口号的网络单位
* 构造方法：
* Socket(String host,int port)：创建一个流套接字并将其连接到指定主机上的指定端口号
* 参数：
* String host：服务器主机的名称/服务器的IP地址
* int port：服务器的端口号
* 成员方法：
* OutputStream getOutputStream()：返回此套接字的输出流
* InputStream getInputStream()：返回此套接字的输入流
* void close()：关闭套接字
* 客户端实现步骤：
* 1.创建一个客户端对象Socket，构造方法绑定服务器的IP地址和端口号
* 2.使用Socket对象中的getOutputStream()获取网络字节输出流OutputStream对象
* 3.使用网络字节输出流OutputStream对象中的write方法，给服务器发送数据
* 4.使用Socket对象中的getInputStream()获取网络字节输入流InputStream对象
* 5.使用网络字节输入流InputStream对象中的read方法，读取服务器回写的数据
* 6.释放资源(Socket)
* 注意：
* 1.客户端和服务器进行交互，必须使用Socket中提供的网络流，不能使用自己创建的流对象
* 2.当我们创建客户端对象Socket的时候，就会去请求服务器并且和服务器经过3次握手建立连接通路
* 这时如果服务器没有启动，那么就会抛出异常
* 如果服务器已经启动，那么就可以进行交互了
*/
public class TCPClient {
public static void main(String[] args) throws IOException {
//1.创建一个客户端对象Socket，构造方法绑定服务器的IP地址和端口号
Socket socket = new Socket("127.0.0.1", 8888);
//2.使用Socket对象中的getOutputStream()获取网络字节输出流OutputStream对象
OutputStream os = socket.getOutputStream();
//3.使用网络字节输出流OutputStream对象中的write方法，给服务器发送数据
os.write("你好，服务器".getBytes());
//4.使用Socket对象中的getInputStream()获取网络字节输入流InputStream对象
InputStream is = socket.getInputStream();
//5.使用网络字节输入流InputStream对象中的read方法，读取服务器回写的数据
byte[] bytes = new byte[1024];
int len = is.read(bytes);
System.out.println(new String(bytes,0,len));
//6.释放资源(Socket)
socket.close();
}
}/*** TCP通信的服务器端：接收客户端的请求，读取客户端发送的数据，给客户端回写数据
* 表示服务器的类：
* java.net.ServerSocket：此类实现服务器套接字
* 构造方法：
* ServerSocket(int port)：创建绑定到特定端口的服务器套接字
* 服务器必须明确一件事，必须要知道是哪个客户端发送的请求，所以
* 可以使用accept方法来获取到发送请求的客户端对象Socket
*
* 成员方法：
* Socket accept()：侦听并接受此套接字的连接
* 服务器实现步骤：
* 1.创建服务器ServerSocket对象和系统要指定的端口号
* 2.使用ServerSocket对象中的accept方法，获取到发送请求的客户端对象Socket
* 3.使用Socket对象中的getInputStream()获取网络字节输入流InputStream对象
* 4.使用网络字节输入流InputStream对象中的read方法，读取客户端发送过来的数据
* 5.使用Socket对象中的getOutputStream()获取网络字节输出流OutputStream对象
* 6.使用网络字节输出流OutputStream对象中的write方法，给客户端回写数据
* 7.释放资源（Socket，ServerSocket）
*
*/
public class TCPServer {
public static void main(String[] args) throws IOException {
ServerSocket server = new ServerSocket(8888);
Socket socket = server.accept();
InputStream is = socket.getInputStream();
byte[] bytes = new byte[1024];
int len = is.read(bytes);
System.out.println(new String(bytes,0,len));
OutputStream os = socket.getOutputStream();
os.write("收到，谢谢".getBytes());
socket.close();
server.close();
}
}TCP通信分析
- 【服务端】启动,创建ServerSocket对象，等待连接。
- 【客户端】启动,创建Socket对象，请求连接。
- 【服务端】接收连接,调用accept方法，并返回一个Socket对象。
- 【客户端】Socket对象，获取OutputStream，向服务端写出数据。
- 【服务端】Scoket对象，获取InputStream，读取客户端发送的数据。
到此，客户端向服务端发送数据成功。
自此，服务端向客户端开始回写数据。- 【服务端】Socket对象，获取OutputStream，向客户端回写数据。
- 【客户端】Scoket对象，获取InputStream，解析回写数据。
- 【客户端】释放资源，断开连接。
3、文件上传
【文件上传的原理】
【文件上传——基本实现版本Demo】
/**
* 文件上传的客户端：读取本地文件，上传到服务器，读取服务器回写的数据
* 明确：
* 数据源：C:\\001.jpg
* 目的地：服务器
* 实现步骤：
* 1.创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
* 2.创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
* 3.使用Socket中的getOutputStream，获取网络字节输出流OutputStream对象
* 4.使用本地字节输入流FileInputStream对象中的read方法读取本地文件
* 5.使用网络字节输出流OutputStream对象中的write方法，将读取到的文件上传到服务器
* 6.使用Socket中的getInputStream方法，获取网络字节输入流InputStream对象
* 7.使用网络字节输入流InputStream对象中的read方法读取服务回写的数据
* 8.释放资源（FileInputStream，Socket）
*/
public class TCPClient {
public static void main(String[] args) throws IOException {
//1.创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("c:\\001.jpg");
//2.创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
Socket socket = new Socket("127.0.0.1", 8888);
//3.使用Socket中的getOutputStream，获取网络字节输出流OutputStream对象
OutputStream os = socket.getOutputStream();
//4.使用本地字节输入流FileInputStream对象中的read方法读取本地文件
//5.使用网络字节输出流OutputStream对象中的write方法，将读取到的文件上传到服务器
int len;
byte[] bytes = new byte[1024];
while ((len = fis.read(bytes)) != -1) {
os.write(bytes, 0, len);
}
/**
* 【重点】
* 解决文件上传阻塞的问题：上传完文件，给服务器写一个结束标记
* void shutdownOutput() 禁用此套接字的输出流。
* 对于TCP套接字，将发送任何先前写入的数据，然后发送TCP的常规连接终止序列。
*/
socket.shutdownOutput();
//6.使用Socket中的getInputStream方法，获取网络字节输入流InputStream对象
InputStream is = socket.getInputStream();
//7.使用网络字节输入流InputStream对象中的read方法读取服务回写的数据
while ((len = is.read(bytes)) != -1) {
System.out.println(new String(bytes, 0, len));
}
//8.释放资源（FileInputStream，Socket）
fis.close();
socket.close();
}
}/**
* 文件上传的服务器端：读取客户端上传的文件，保存到服务器的硬盘，给客户端回写“上传成功”
* 明确：
* 数据源：客户端上查的文件
* 目的地：服务器的硬盘（c:\\upload\\001.jpg）
* 实现步骤：
* 1.创建一个服务器ServerSocket对象和系统要指定的端口
* 2.使用ServerSocket对象中的accept方法，获取到发送请求的客户端Socket对象
* 3.使用Socket对象中的getInputStream方法，获取到网络字节输入流InputStream
* 4.判断c:\\upload\\文件夹是否存在，不存在则创建
* 5.创建一个本地字节输出流FileOutputStream对象，构造方法中绑定要输出的目的地
* 6.使用网络字节输入流InputStream对象的read方法，读取客户端上传的文件
* 7.使用本地字节输出流FileOutputStream对象的write方法，把读取到的文件保存到服务器的硬盘上
* 8.使用Socket对象的getOutputStream方法，获取到网络字节输出流OutputStream对象
* 9.使用网络字节输出流OutputStream对象中的write方法，给客户端回写“上传成功”
* 10.释放资源（FileOutputStream，Socket，ServerSocket）
*/
public class TCPServer {
public static void main(String[] args) throws IOException {
//1.创建一个服务器ServerSocket对象和系统要指定的端口
ServerSocket sc = new ServerSocket(8888);
//2.使用ServerSocket对象中的accept方法，获取到发送请求的客户端Socket对象
Socket socket = sc.accept();
//3.使用Socket对象中的getInputStream方法，获取到网络字节输入流InputStream
InputStream is = socket.getInputStream();
//4.判断c:\\upload\\文件夹是否存在，不存在则创建
File file = new File("c:\\upload");
if (!file.exists()) {
file.mkdirs();
}
//5.创建一个本地字节输出流FileOutputStream对象，构造方法中绑定要输出的目的地
FileOutputStream fos=new FileOutputStream(file+"\\001.jpg");
//6.使用网络字节输入流InputStream对象的read方法，读取客户端上传的文件
//7.使用本地字节输出流FileOutputStream对象的write方法，把读取到的文件保存到服务器的硬盘上
int len;
byte[] bytes = new byte[1024];
while ((len = is.read(bytes)) != -1) {
fos.write(bytes,0,len);
}
//8.使用Socket对象的getOutputStream方法，获取到网络字节输出流OutputStream对象
OutputStream os = socket.getOutputStream();
//9.使用网络字节输出流OutputStream对象中的write方法，给客户端回写“上传成功”
os.write("上传成功".getBytes());
//10.释放资源（FileOutputStream，Socket，ServerSocket）
fos.close();
socket.close();
sc.close();
}
}【文件上传案例中的阻塞问题】
【文件上传优化分析】
- 文件名称写死的问题
服务端，保存文件的名称如果写死，那么最终导致服务器硬盘，只会保留一个文件，建议使用系统时间优化，保证文件名称唯一，代码如下：
String fileName = "nzc" + System.currentTimeMillis() + new Random().nextInt(666666) + ".jpg";
FileOutputStream fos = new FileOutputStream(file + "\\" + fileName);
- 循环接收的问题
服务端，只保存完一个文件就关闭了，之后的用户无法再上传，这是不符合实际的，使用循环改进，可以不断的接收不同用户的文件，代码如下：
// 每次接收新的连接,创建一个Socket
while（true）{
Socket accept = serverSocket.accept();
......
}
- 效率问题
服务端，在接收大文件时，可能耗费几秒钟的时间，此时不能接收其他用户上传，所以，使用多线程技术优化，代码如下：
while（true）{ Socket accept = serverSocket.accept(); // accept 交给子线程处理. new Thread(() -> { ...... InputStream bis = accept.getInputStream(); ...... }).start(); }
【文件上传——优化实现版本Demo】
客户端代码不变、服务器端优化代码如下
public class TCPServer {
public static void main(String[] args) throws IOException {
//1.创建一个服务器ServerSocket对象和系统要指定的端口
ServerSocket sc = new ServerSocket(8888);
/**
* 【优化2：优化循环接收的问题】
* 让服务器一直处于监听状态（死循环accept方法）
* 有一个客户端上传文件，就保存一个文件
*/
while (true) {
//2.使用ServerSocket对象中的accept方法，获取到发送请求的客户端Socket对象
Socket socket = sc.accept();
/**
* 【优化3：效率问题】
* 使用多线程提高程序的效率
* 有一个客户端上传文件，就开启一个线程，完成文件的上传
*/
new Thread(()->{
try {
//3.使用Socket对象中的getInputStream方法，获取到网络字节输入流InputStream
InputStream is = socket.getInputStream();
//4.判断c:\\upload\\文件夹是否存在，不存在则创建
File file = new File("c:\\upload");
if (!file.exists()) {
file.mkdirs();
}
/**
* 【优化:1：优化文件名称写死的问题】
* 自定义一个文件的命名规则：防止同名的文件被覆盖
* 规则：域名+毫秒值+随机数
*/
String fileName = "nzc" + System.currentTimeMillis() + new Random().nextInt(666666) + ".jpg";
//5.创建一个本地字节输出流FileOutputStream对象，构造方法中绑定要输出的目的地
//FileOutputStream fos=new FileOutputStream(file+"\\001.jpg");
FileOutputStream fos = new FileOutputStream(file + "\\" + fileName);
//6.使用网络字节输入流InputStream对象的read方法，读取客户端上传的文件
//7.使用本地字节输出流FileOutputStream对象的write方法，把读取到的文件保存到服务器的硬盘上
int len;
byte[] bytes = new byte[1024];
while ((len = is.read(bytes)) != -1) {
fos.write(bytes, 0, len);
}
//8.使用Socket对象的getOutputStream方法，获取到网络字节输出流OutputStream对象
OutputStream os = socket.getOutputStream();
//9.使用网络字节输出流OutputStream对象中的write方法，给客户端回写“上传成功”
os.write("上传成功".getBytes());
//10.释放资源（FileOutputStream，Socket，ServerSocket）
fos.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}).start();
}
//服务器就不用关闭了
//sc.close();
}
}4、模拟B\S服务器
模拟网站服务器，使用浏览器访问自己编写的服务端程序，查看网页效果。
【模拟B\S服务器原理】
【模拟B/S服务器Demo】
/*** 创建BS版本的TCP服务器
*/
public class TCPServer {
public static void main(String[] args) throws IOException {
//创建一个服务器ServerSocket，和系统要指定的端口号
ServerSocket server = new ServerSocket(8888);
//使用Socket对象的accept方法获取到请求的客户端对象（浏览器）
Socket socket = server.accept();
//使用Socket对象中的getInputStream方法，获取到网络字节输入流InputStream对象
InputStream is = socket.getInputStream();
//使用网络字节输入流InputStream对象中的read方法读取客户端的请求信息
/*byte[] bytes = new byte[1024];
int len;
while ((len = is.read(bytes)) != -1) {
System.out.println(new String(bytes,0,len));
}*/
//把is网络字节输入流对象，转换为字符缓冲输入流
BufferedReader br = new BufferedReader(new InputStreamReader(is));
//把客户端请求信息的第一行读取出来 GET /day11_Net/index.html HTTP/1.1
String line = br.readLine();
//把读取的信息进行切割，只要中间部分 /day11_Net/index.html
String[] arr = line.split(" ");
//把路径前面的'/'去掉，进行截取后 day11_Net/index.html
String htmlPath = arr[1].substring(1);
//创建一个本地字节输入流，构造方法中绑定要读取的html路径
FileInputStream fis = new FileInputStream(htmlPath);
//使用Socket中的getOutputStream方法获取网络字节输出流OutputStream对象
OutputStream os = socket.getOutputStream();
//固定写法，写入HTTP协议响应头
os.write("HTTP/1.1 200 OK\r\n".getBytes());
os.write("Content-Type:text/html\r\n".getBytes());
//必须写入空行 否则浏览器不解析
os.write("\r\n".getBytes());
//一读一写复制文件，把服务器读取的html文件回写到客户端
int len;
byte[] bytes = new byte[1024];
while ((len = fis.read(bytes)) != -1) {
os.write(bytes, 0, len);
}
fis.close();
socket.close();
server.close();
}
}/*** 创建BS版本的TCP服务器
*/
public class TCPServerThread {
public static void main(String[] args) throws IOException {
//创建一个服务器ServerSocket，和系统要指定的端口号
ServerSocket server = new ServerSocket(8888);
/**
* 浏览器工作原理是遇到图片会开启一个线程进行单独的访问,因此在服务器端加入线程技术。
* 浏览器解析服务器回写的html页面，页面中如果有图片，那么浏览器就会单独的开启一个线
程，读取服务器的图片
* 我们就得让服务器一直处于监听状态，客户端请求一次，服务器就回写一次
*/
while (true) {
//使用Socket对象的accept方法获取到请求的客户端对象（浏览器）
Socket socket = server.accept();
new Thread(()->{
try {
//使用Socket对象中的getInputStream方法，获取到网络字节输入流InputStream对象
InputStream is = socket.getInputStream();
//使用网络字节输入流InputStream对象中的read方法读取客户端的请求信息
/*byte[] bytes = new byte[1024];
int len;
while ((len = is.read(bytes)) != -1) {
System.out.println(new String(bytes,0,len));
}*/
//把is网络字节输入流对象，转换为字符缓冲输入流
BufferedReader br = new BufferedReader(new InputStreamReader(is));
//把客户端请求信息的第一行读取出来 GET /day11_Net/index.html HTTP/1.1
String line = br.readLine();
System.out.println(line);
//把读取的信息进行切割，只要中间部分 /day11_Net/index.html
String[] arr = line.split(" ");
//把路径前面的'/'去掉，进行截取后 day11_Net/index.html
String htmlPath = arr[1].substring(1);
//创建一个本地字节输入流，构造方法中绑定要读取的html路径
FileInputStream fis = new FileInputStream(htmlPath);
//使用Socket中的getOutputStream方法获取网络字节输出流OutputStream对象
OutputStream os = socket.getOutputStream();
//固定写法，写入HTTP协议响应头
os.write("HTTP/1.1 200 OK\r\n".getBytes());
os.write("Content-Type:text/html\r\n".getBytes());
//必须写入空行 否则浏览器不解析
os.write("\r\n".getBytes());
//一读一写复制文件，把服务器读取的html文件回写到客户端
int len;
byte[] bytes = new byte[1024];
while ((len = fis.read(bytes)) != -1) {
os.write(bytes, 0, len);
}
fis.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}).start();
}
//server.close();
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
