这里写目录标题
1. 网络编程入门
1.1 什么是计算机网络？
包packet
什么是TCP连接？ 打电话
什么是UDP连接？ 发邮件
什么是计算机网络？指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。
网络编程的目的？数据交换，通信，
想要达到这个效果需要什么？
- 如何准确定位到网络上的一台主机 ？192.168.16.124：端口，定位到这个计算机上的某个资源
- 找到了这个主机，如何传输数据呢？
javaWeb：网页编程 B/S架构
网络编程： TCP/IP C/S架构
1.2 网络通信的两大要素
如何实现网络的通信？
通信双方的地址：
- ip
- 端口号
- 192.168.16.124：5900
规则：网络通信的协议http（超文本传输协议）,ftp,smtp,tcp,udp等
TCP/IP参考模型:OSI七层参考
1.3. IP地址
IP地址：InetAddress
-
唯一定位一台网络上的计算机
-
127.0.0.1 代表的是本机 localhost
-
IP地址的分类
- 公网(互联网)/私网（局域网）
- 192.168.xx.xx 局域网
- IP地址的ABCD类
- IPV4 / IPV6
- ipv4： 127.0.0.1 ，4个字节组成， 0~255，42亿
- ipv6：
2001:0bb2:aaaa:0000:0000:abad:1312:1245， 128位，8个无符号整数
- 公网(互联网)/私网（局域网）
-
域名:记忆IP问题
package javanet.lesson;
import java.net.InetAddress;
import java.net.UnknownHostException;
//测试IP
public class TestInetAddress {
public static void main(String[] args) {
try {
// 查询本机地址
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);
// 查询网络ip地址
InetAddress inetAddress4 = InetAddress.getByName("www.baidu.com");
System.out.println(inetAddress4);
// 常用方法
System.out.println(inetAddress4.getAddress());
System.out.println(inetAddress4.getCanonicalHostName()); // 规范的名字
System.out.println(inetAddress4.getHostAddress()); // ip
System.out.println(inetAddress4.getHostName()); // 域名， 或者自己的名字
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
}
1.4. 端口号
端口表示计算机上的一个程序的进程
- 不同的进程有不同的端口号！用来区分软件
- 被规定0~65535
- 分为TCP端口和UDP端口 ： 65535 * 2， TCP80, UDP80 。单个协议下，端口号不能冲突
- 端口分类
- 公有端口0~1023
- HTTP ：80
- HTTPS：443
- FTP：21
- Telent： 23
- 程序注册端口： 1024~49151，分配用户或者程序
- Tomcat： 8080
- MySQL： 3306
- Oracle： 1521
- 公有端口0~1023
- 动态端口，私有端口:49152 ~ 65535
netstat -ano # 查看所有端口
netstat -ano|findstr "5900" # 查看指定的端口
tasklist|findstr "8696" # 查看指定的端口的进程
package javanet.lesson;
import java.net.InetSocketAddress;
public class TestInetSocketAddress {
public static void main(String[] args) {
InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1",8080);
InetSocketAddress inetSocketAddress1 = new InetSocketAddress("localhost",8080);
System.out.println(inetSocketAddress);
System.out.println(inetSocketAddress1);
System.out.println(inetSocketAddress.getAddress());
System.out.println(inetSocketAddress.getHostName()); // 地址
System.out.println(inetSocketAddress.getPort()); // 端口
}
}
1.5. 通信协议
协议：约定，就好比普通话。
网络通信协议：速率、传输码率、代码结构、传输控制
大事化小的原则： 分层的概念
TCP/IP协议簇： 实际上是一组协议
重要的：
TCP： 用户传输协议
UDP： 用户数据报协议
出名的协议:
IP：网络互连协议
TCP
TCP UDP 对比
TCP: 打电话
- 连接，稳定
- 三次握手，四次挥手
（发起回应，然后回应，连接）最少需要三次，保证稳定连接
（A:我要断开了 B: 我知道你要断开了 A:你真的要断开了 B:我真的要断开了）- 客户端，服务端
- 传输完成，释放连接，效率低
UDP：发短信
- 不连接，不稳定
- 客户端、服务端：没有明确的界限
- 不管有没有准备，都可以发给你
- DDOS：洪水攻击 饱和攻击
1.1 软件结构
C/S结构:全称为Client/Server结构，是指客户端和服务器结构。常见程序有QQ、迅雷等软件。
B/S结构：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。
两种架构各有优势，但是无论哪种架构，都离不开网络的支持。网络编程，就是在一定的协议下，实现两台计算机的通信的程序。
1.2 网络通信协议
网络通信协议：通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。
TCP/IP协议：传输控制协议/因特网互联协议（Transmission Control Protocol/Internet Protocol),是Internet最基本、最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议，并采用了4层的分层模型，每一层都呼叫它的下一层所提供的协议来完成自己的需求。
1.3 网络通信协议分类
通信的协议还是比较复杂的，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协议可以保证传输数据的安全，所以应用十分广泛，例如下载文件、浏览网页等。
- 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。
2. TCP通信协议
2.1 概述
TCP通信能实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端（Client）与服务端（Server）。
两端通信时步骤：
1.服务端程序，需要事先启动，等待客户端的连接。
2.客户端主动连接服务器端，连接成功才能通信。服务端不可以主动连接客户端。
在Java中，提供了两个类用于实现TCP通信程序：
- 客户端：
java.net.Socket类表示。创建Socket对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。 - 服务端：
java.net.ServerSocket类表示。创建ServerSocket对象，相当于开启一个服务，并等待客户端的连接。
2.2 TCP通信客户端代码实现
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次握手建立连接通路
这时如果服务器没有启动，那么就会抛出异常 java.net.ConnectException
如果服务器已经启动，那么就可以进行交互了
package javanet.lesson;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
/*
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次握手建立连接通路
这时如果服务器没有启动，那么就会抛出异常 java.net.ConnectException
如果服务器已经启动，那么就可以进行交互了
*/
public class TCPClient {
public static void main(String[] args) throws Exception{
// 1.创建一个客户端对象Socket，构造方法绑定服务器的IP地址和端口号
Socket socket = new Socket("127.0.0.1", 8888);
// 2.使用socket对象中的万法getoutputstream()状取网络字节输山流outputstream对象
OutputStream outputStream = socket.getOutputStream();
// 3.使用网络字节输出流outputstream对象中的方法write,给服务器发送数据
outputStream.write("你好服务器".getBytes(StandardCharsets.UTF_8));
// 4.使用Socket对象中的方法getInputstream()获取网络字节输入流Inputstream对象
InputStream inputStream = socket.getInputStream();
// 5.使用网络字节输入流Inputstream对象中的方法read,读取服务器回写的数据
byte[] bytes = new byte[1024];
int len = inputStream.read(bytes);
System.out.println(new String(bytes,0, len));
// 6.释放资源（Socket)
socket.close();
}
}
2.3 TCP通信服务端代码实现
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，ServetSocket)
package javanet.lesson;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
/**
* 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，ServetSocket)
*/
public class TCPServer {
public static void main(String[] args) throws IOException {
//1. 创建服务器ServerSocket对象和系统要指定的端口号
ServerSocket serverSocket = new ServerSocket(8888);
// 2. 使用ServerSocket对象中的方法accept，获取到请求的客户端对象Socket
Socket socket = serverSocket.accept();
//3. 使用Socket对象中的方法getInputstream()获取网络字节输入流Inputstream对象
InputStream inputStream = socket.getInputStream();
//4. 使用网络字节输入流Inputstream对象中的方法read,读取客户端发送的数据
byte[] bytes = new byte[1024];
int len = inputStream.read(bytes);
System.out.println(new String(bytes,0, len));
//5. 使用socket对象中的万法getoutputstream()状取网络字节输出流outputstream对象
OutputStream outputStream = socket.getOutputStream();
//6. 使用网络字节输出流outputstream对象中的方法write,给客户端回写数据
outputStream.write("收到谢谢".getBytes(StandardCharsets.UTF_8));
//7. 释放资源（Socket，ServetSocket)
socket.close();
serverSocket.close();
}
}
3. 综合案例：文件上传案例
3.1 需求分析
3.2 文件上传案例的客户端
package javanet.lesson;
import java.io.*;
import java.net.Socket;
/*
文件上传案例的客户端: 读取本地文件， 上传到服务器， 读取服务器回写的数据
明确:
数据源： c:\\1.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 TCPUPload {
public static void main(String[] args) throws IOException {
//1. 创建本地字节输入流 FileInputStream对象，构造方法中绑定要读取的数据源
FileInputStream fileInputStream = new FileInputStream("d:\\1.jpg");
//2. 创建一个客户端Socket对象，构造方法中绑定服务器的ip地址和端口号
Socket socket = new Socket("127.0.0.1", 8888);
//3. 使用Socket的方法中的getOutputStream，获取网络字节输出流OutputStream对象
OutputStream outputStream = socket.getOutputStream();
//4. 使用本地的字节输入流FileInputStream对象中的方法read，读取本地文件
int len = 0;
byte[] bytes = new byte[1024];
while ((len = fileInputStream.read(bytes)) != -1){
//5. 使用网络字节输出流OutputStream对象方法中的write，把读到的文件上传到服务器
outputStream.write(bytes,0,len);
}
/*
解决：解决方案： 上传完成文件，给服务器写一个结束标记
void shutdownoutput()禁用此套接字的输出流。
对于TCP套接字，任何以前写入的数据都将被发送，并且后跟TCP的正常连接终止序列。
*/
socket.shutdownOutput();
//6. 使用Socket中的方法getInputStream,狭取网络字节输入流InputStream对象
InputStream inputStream = socket.getInputStream();
//7. 使用网络字节输入流Inputstream对象中的方法read读取服务回写的数据
while ((len = inputStream.read(bytes)) != -1){
System.out.println(new String(bytes,0,len));
}
//8. 释放资源（FileInputstream,Socket)
fileInputStream.close();
socket.close();
}
}
3.2 文件上传案例的服务端
package javanet.lesson;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
/*
文件上传案例的服务器端： 读取客户端上传的文件，保存到服务器的硬盘上，给客户回写”上传成功“
明确：
数据源: 客户端上传的文件
目的地： 服务器的硬盘 d:\\upload\\1.jpg
实现步骤:
1. 创建一个服务器ServerSocket对象，和系统要指定的端口号
2. 使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
3. 使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
4. 判断d:\\upload文件夹是否存在， 不存在则创建
5. 创建一个本地字节输出流FileOutputStream对象，构造方法中要绑定要输出的目的地
6. 使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
7. 使用本地字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器的硬盘上
8. 使用Socket对象中的方法getOutputStream，取到网络字节输出流OutputStream对象
9. 使用网络字节输入流OutputStream对象中的方法write，给客户端回写”上传成功“
10. 释放资源（ServerSocket，Socket，FileOutputStream）
*/
public class TCPUpServer {
public static void main(String[] args) throws IOException {
//1. 创建一个服务器ServerSocket对象，和系统要指定的端口号
ServerSocket serverSocket = new ServerSocket(8888);
//2. 使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
Socket socket = serverSocket.accept();
//3. 使用socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
InputStream inputStream = socket.getInputStream();
//4. 判断d:\\upload文件夹是否存在， 不存在则创建
File file = new File("d:\\upload");
if(!file.exists()){
file.mkdir();
}
//5. 创建一个本地字节输出流FileOutputStream对象，构造方法中要绑定要输出的目的地
FileOutputStream fileOutputStream = new FileOutputStream(file+"\\1.jpg");
//6. 使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
System.out.println("111111111111111111111111111111111");
int count = 0;
byte[] bytes = new byte[1024];
while ((count = inputStream.read(bytes))!= -1){
//7. 使用本地字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器的硬盘上
fileOutputStream.write(bytes,0,count);
}
System.out.println("222222222222222 while死循环");
//8. 使用Socket对象中的方法getOutputStream，取到网络字节输出流OutputStream对象
OutputStream outputStream = socket.getOutputStream();
//9. 使用网络字节输入流OutputStream对象中的方法write，给客户端回写”上传成功“
outputStream.write("上传成功".getBytes(StandardCharsets.UTF_8));
//10. 释放资源（ServerSocket，Socket，FileOutputStream）
serverSocket.close();
socket.close();
fileOutputStream.close();
}
}
3.3 文件上传阻塞问题
我没有遇到这个问题
因为在客户端第一个while判断时 为-1就直接停止循环了 -1从一开始就没有写给服务器
解决方案： 上传完成文件，给服务器写一个结束标记
3.4 文件上传案例优化
- 自定义一个文件的命名规则：防止同名的文件被覆盖
- 让服务器一直处于监听状态（）
- 使用多线程技术，提高程序的效率， 有一个客户端上传文件，就开启线程，完成文件的上传
package javanet.lesson;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Random;
/*
文件上传案例的服务器端： 读取客户端上传的文件，保存到服务器的硬盘上，给客户回写”上传成功“
明确：
数据源: 客户端上传的文件
目的地： 服务器的硬盘 d:\\upload\\1.jpg
实现步骤:
1. 创建一个服务器ServerSocket对象，和系统要指定的端口号
2. 使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
3. 使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
4. 判断d:\\upload文件夹是否存在， 不存在则创建
5. 创建一个本地字节输出流FileOutputStream对象，构造方法中要绑定要输出的目的地
6. 使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
7. 使用本地字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器的硬盘上
8. 使用Socket对象中的方法getOutputStream，取到网络字节输出流OutputStream对象
9. 使用网络字节输入流OutputStream对象中的方法write，给客户端回写”上传成功“
10. 释放资源（ServerSocket，Socket，FileOutputStream）
*/
public class TCPUpServer {
public static void main(String[] args) throws IOException {
//1. 创建一个服务器ServerSocket对象，和系统要指定的端口号
ServerSocket serverSocket = new ServerSocket(8888);
//2. 使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
/*
让服务器一直处于监听状态(死循环accept方法)
有一个客户端上传文件，就保存一个文件
*/
while (true){
Socket socket = serverSocket.accept();
/*
使用多线程技术，提高程序的效率
有一个客户端上传文件，就开启线程，完成文件的上传
*/
new Thread(new Runnable() {
// 完成文件的上传
@Override
public void run() {
try{
//3. 使用socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
InputStream inputStream = socket.getInputStream();
//4. 判断d:\\upload文件夹是否存在， 不存在则创建
File file = new File("d:\\upload");
if(!file.exists()){
file.mkdir();
}
/*
自定义一个文件的命名规则：防止同名的文件被覆盖
规则： 域名 + 毫秒值 + 随机数
*/
String filename = "iscast" + System.currentTimeMillis() + new Random().nextInt(999999) + ".jpg";
//5. 创建一个本地字节输出流FileOutputStream对象，构造方法中要绑定要输出的目的地
//FileOutputStream fileOutputStream = new FileOutputStream(file+"\\1.jpg");
FileOutputStream fileOutputStream = new FileOutputStream(file+"\\"+filename);
//6. 使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
int count = 0;
byte[] bytes = new byte[1024];
while ((count = inputStream.read(bytes))!= -1){
//7. 使用本地字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器的硬盘上
fileOutputStream.write(bytes,0,count);
}
//8. 使用Socket对象中的方法getOutputStream，取到网络字节输出流OutputStream对象
OutputStream outputStream = socket.getOutputStream();
//9. 使用网络字节输入流OutputStream对象中的方法write，给客户端回写”上传成功“
outputStream.write("上传成功".getBytes(StandardCharsets.UTF_8));
//10. 释放资源（ServerSocket，Socket，FileOutputStream）
socket.close();
fileOutputStream.close();
}catch (IOException e){
System.out.println(e);
}
}
}).start();
}
//serverSocket.close();
}
}
package javanet.lesson;
import java.io.*;
import java.net.Socket;
/*
文件上传案例的客户端: 读取本地文件， 上传到服务器， 读取服务器回写的数据
明确:
数据源： c:\\1.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 TCPUPload {
public static void main(String[] args) throws IOException {
//1. 创建本地字节输入流 FileInputStream对象，构造方法中绑定要读取的数据源
FileInputStream fileInputStream = new FileInputStream("d:\\1.jpg");
//2. 创建一个客户端Socket对象，构造方法中绑定服务器的ip地址和端口号
Socket socket = new Socket("127.0.0.1", 8888);
//3. 使用Socket的方法中的getOutputStream，获取网络字节输出流OutputStream对象
OutputStream outputStream = socket.getOutputStream();
//4. 使用本地的字节输入流FileInputStream对象中的方法read，读取本地文件
int len = 0;
byte[] bytes = new byte[1024];
while ((len = fileInputStream.read(bytes)) != -1){
//5. 使用网络字节输出流OutputStream对象方法中的write，把读到的文件上传到服务器
outputStream.write(bytes,0,len);
}
/*
解决：解决方案： 上传完成文件，给服务器写一个结束标记
void shutdownoutput()禁用此套接字的输出流。
对于TCP套接字，任何以前写入的数据都将被发送，并且后跟TCP的正常连接终止序列。
*/
socket.shutdownOutput();
//6. 使用Socket中的方法getInputStream,狭取网络字节输入流InputStream对象
InputStream inputStream = socket.getInputStream();
//7. 使用网络字节输入流Inputstream对象中的方法read读取服务回写的数据
while ((len = inputStream.read(bytes)) != -1){
System.out.println(new String(bytes,0,len));
}
//8. 释放资源（FileInputstream,Socket)
fileInputStream.close();
socket.close();
}
}
4. 模拟BS服务器
思考总结：
1. 三次握手，四次挥手是什么意思？
深刻理解
视频
三次握手：
为什么要三次握手而不是两次握手？
服务端回复完AYN+ACK之后就建立连接，这是为了防止因为已失效的请求报文突然又传到服务器引起错误
解决网络信道不可靠的问题
如何解决丢包问题？
如何解决乱序问题？
四次挥手
77
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
