TCP通信程序
TCP通信程序
2.1 概述
TCP通信能实现两台计算机之间的数据交互,通信的两端,要严格区分为客户端(Client)与服务端(Server)。
客户端(Client)与服务端(Server)其实都是一台计算机,配置存在差异而已
比如:
自己电脑通过浏览器访问淘宝网站,自己的电脑就是客服端 打开淘宝 访问淘宝 就是访问淘宝的服务器端
自己电脑上安装游戏LOL,自己的电脑就是客服端,输入用户名和密码就会连接服务器,打完游戏数据就会上传服务器端,下次登录数据还会存在
两端通信时步骤:
- 服务端程序,需要事
- 先启动,等待客户端的连接。
- 客户端主动连接服务器端,连接成功才能通信。服务端不可以主动连接客户端。
在Java中,提供了两个类用于实现TCP通信程序:
- 客户端:
java.net.Socket
类表示。创建Socket
对象,向服务端发出连接请求,服务端响应请求,两者建立连接开始通信。 - 服务端:
java.net.ServerSocket
类表示。创建ServerSocket
对象,相当于开启一个服务,并等待客户端的连接。
2.2 Socket类 (客户端)
TCP通信的客户端:向服务器发送请求,给服务器发送数据,读取服务器回写的数据
表示客户端的类:
java.nat.Socket:该类实现客户端套接字,套接字指的是两台设备之间通讯的端点。
套接字:包含了IP地址和端口号的网络单位
构造方法
Sockrt(String host,int port ) 创建一个流套接字并将其连接到指定主机上的指定端口号
参数
- String host:服务器主机的名称/服务器的IP地址
- int port:服务器的端口号
成员方法
OutputStream getOutputStream() 返回此套接字的输出流
InputStream getInputStream() 返回此套接字的输入流
void close() 关闭此套接字
实现步骤
- 创建一个客户端对象Socket,构造方法绑定服务器的IP地址和端口号
- 使用socket对象中的方法getOutputStream() 获取网络字节输出流OutputStream对象
- 使用网络字节输出流中OutputStream对象中的方法write,给服务器发送数据
- 使用Socket对象中的方法getInputStream() 获取网络字节输入流InputStream对象
- 使用网络字节输入流InputStream对象中的方法read,读取服务器回写的数据
- 释放资源(socket)
注意
- 客户端和服务器端进行交互,必须使用Socket中提供的网络流,不能使用自己创建的流对象
- 当我们创建客户端对象Socket的时候,就会去请求服务器和服务器进行3次握手建立连接通路
- 这时候如果服务器没有启动,那么就会抛出异常
- 如果服务器启动,就可以进行正常的交互
2.3 ServerSocket类
ServerSocket
类:这个类实现了服务器套接字,该对象等待通过网络的请求。
TCP通信的服务器端:接收客户端的请求,读取客户端发送的数据,给客户端回写数据
表示服务器的类
java.net.ServerSocket:此类实现服务器的套接字
构造方法
public ServerSocket(int port):使用该构造方法在创建ServerSocket对象时,就可以将其绑定到一个指定的端口号上,参数port就是端口号。
服务器端必须明确的一件事,必须知道是哪个客户端请求的服务器
所以可以使用accept方法获取到请求的客户端对象Socket
成员方法
Socket accept() 侦听并接受此套接字的连接
服务器的实现步骤
- 创建服务器ServerSocket对象和系统要指定的端口号
- 使用ServerSocket对象中的方法accept,获取到请求的客户端对象Socket
- 使用Socket对象中的方法getInputStream() 获取网络字节输入流InputStream对象
- 使用网络字节输入流InputStream对象中的方法read,读取客户端发送的数据
- 使用Socket对象中的方法getOutputStream() 获取网络字节输入流OuputStream对象
- 使用网络字节输出流OutputStream对象中的方法write,给客户端回写数据
- 释放资源(socket,severSocket)
示例代码
客户端
public static void main(String[] args){
//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();
}
服务器端
public static void main(String[] args) throws IOException {
//1.创建服务器ServerSocket对象和系统要指定的端口号
ServerSocket server = new ServerSocket(8888);
//2.使用ServerSocket对象中的方法accept,获取到请求的客户端对象Socket
Socket socket = server.accept();
//3.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
InputStream is = socket.getInputStream();
//4.使用网络字节输入流InputStream对象中的方法read,读取客户端发送的数据
byte[] bytes = new byte[1024];
int len = is.read(bytes);
System.out.println(new String(bytes,0,len));
//5.使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
OutputStream os = socket.getOutputStream();
//6.使用网络字节输出流OutputStream对象中的方法write,给客户端回写数据
os.write("收到谢谢".getBytes());
//7.释放资源(Socket,ServerSocket)
socket.close();
server.close();
}
}
第三章 综合案例
3.1 文件上传案例
TCP通信的文件上传案例
原理
客户端读取本地的文件,把文件上传到服务器,服务器再把上传的文件保存到服务器硬盘上
步骤
- 客户端使用 本地的字节输入流,读取要上传的文件。
- 客户端换使用 网络字节输出流,把读取到的文建上传到服务器
- 服务器使用 网络字节输入流,读取客户端上传的文件
- 服务器使用 本地字节输出流,把读取到的文件,保存到服务器的硬盘上
- 服务器使用 网络字节输出流,给客户端回复上“传成功”
- 客户端使用 网络字节输入流,读取服务器回写的数据
- 释放资源
注意
- 客户端和服务器和本地硬盘进行读写,需要使用自己创建的字节流对象(本地流)
- 客户端和服务器之间进行读写,必须使用Socket中提供的字节流对象(网络流)
文件上传的原理,就是文件的复制
明确
- 数据源
- 数据目的地
文件上传分析图解
3.2 文件上传案例 客户端
文件上传案例的客户端:读取本地文件,上传到服务器,读取服务器回写的数据
明确
- 数据源:c:\Test\1.jpg
- 目的地:服务器
实现步骤
- 创建一个本地字节输入流FileInputStream对象,构造方法中绑定要读取的数据源
- 创建一个客户端Socket对象,构造方法中绑定服务器的IP地址和端口号
- 使用Socket中的方法getOutputStream,获取网络字节输出流OutputStream对象
- 使用本地字节输入流FileInputStream对象中的方法read,读取本地文件
- 使用字节网络输出流OutputStream对象中的方法write,把读取的文件上传到服务器
- 使用Socket中的方法getInputStream,获取网络字节输入流InputStream对象
- 使用网络字节输入流InputStream对象中的方法read读取服务器回写的数据
- 释放资源(getInputStream,socket)
示例代码
public static void main(String[] args) throws IOException {
// 1. 创建一个本地字节输入流FileInputStream对象,构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("c:\\Test\\1.jpg");
// * 2. 创建一个客户端Socket对象,构造方法中绑定服务器的IP地址和端口号
Socket socket = new Socket("127.0.0.1",8888);
// * 3. 使用Socket中的方法getOutputStream,获取网络字节输出流OutputStream对象
OutputStream os = socket.getOutputStream();
// * 4. 使用本地字节输入流FileInputStream对象中的方法read,读取本地文件
byte[] bytes = new byte[1024];
int len = 0;
while ((len = fis.read())!=-1){
// * 5. 使用字节网络输出流OutputStream对象中的方法write,把读取的文件上传到服务器
os.write(bytes,0,len);
}
// * 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. 释放资源(getInputStream,socket)
fis.close();
socket.close();
}
3.3 文件上传案例 服务器端
文件上传案例 服务器端:读取及客户端上传的文件,保存到服务器的硬盘,给客户回写“上传成功”
明确
- 数据源:客户端上传的文件
- 目的地:服务器的硬盘 d:\Test\upload\1.jpg
实现步骤
- 创建一个服务器ServerSocket对象,和系统要指定的端口号
- 使用ServerSocket对象中的方法accept,获取到请求的客户端Socket对象
- 使用Socket对象中的方法getInputStream,获取到网络字节输入流InputStream对象
- 判断d:\Test\upload\1.jpg文件夹是否存在,不存在则创建
- 创建一个本地字节输出流FileOutputStream对象,构造方法中绑定要输出的目的地
- 使用网络字节输入流InputStream对象中的方法read,读取客户端上传的文件
- 使用本地字节输出流FileOutputStream对象中的方法write,把读取到的数据保存到服务器的硬盘上
- 使用Socket对象中的方法getOutputStream,获取到网络字节输出流OutputStream对象
- 使用网络字节输出流OutputStream对象中的方法write,给客户端回写“上传成功”
- 释放资源(FileOutputStream,socket,serversocket)
示例代码
public static void main(String[] args) throws IOException {
// 1. 创建一个服务器ServerSocket对象,和系统要指定的端口号
ServerSocket server = new ServerSocket(888);
// 2. 使用ServerSocket对象中的方法accept,获取到请求的客户端Socket对象
Socket socket = server.accept();
// 3. 使用Socket对象中的方法getInputStream,获取到网络字节输入流InputStream对象
InputStream is = socket.getInputStream();
// 4. 判断d:\\Test\\upload\\1.jpg文件夹是否存在,不存在则创建
File file = new File("d:\\Test\\upload\\1.jpg");
if (!file.exists()){
file.mkdirs();
}
// 5. 创建一个本地字节输出流FileOutputStream对象,构造方法中绑定要输出的目的地
FileOutputStream fos = new FileOutputStream(file+"1.jpg");
// 6. 使用网络字节输入流InputStream对象中的方法read,读取客户端上传的文件
int len = 0;
byte[] bytes = new byte[1024];
while ((len = is.read(bytes))!= -1){
// 7. 使用本地字节输出流FileOutputStream对象中的方法write,把读取到的数据保存到服务器的硬盘上
fos.write(bytes,0,len);
}
// 8. 使用Socket对象中的方法getOutputStream,获取到网络字节输出流OutputStream对象
// 9. 使用网络字节输出流OutputStream对象中的方法write,给客户端回写“上传成功”
socket.getOutputStream().write("上传成功".getBytes());
// 10. 释放资源(FileOutputStream,socket,serversocket)
fos.close();
socket.close();
server.close();
}
文件上传优化分析
-
文件名称写死的问题
服务端,保存文件的名称如果写死,那么最终导致服务器硬盘,只会保留一个文件,建议使用系统时间优化,保证文件名称唯一,代码如下:
FileOutputStream fis = new FileOutputStream(System.currentTimeMillis()+".jpg") // 文件名称
BufferedOutputStream bos = new BufferedOutputStream(fis);
-
循环接收的问题
服务端,指保存一个文件就关闭了,之后的用户无法再上传,这是不符合实际的,使用循环改进,可以不断的接收不同用户的文件,代码如下:
// 每次接收新的连接,创建一个Socket
while(true){
Socket accept = serverSocket.accept();
......
}
-
效率问题
服务端,在接收大文件时,可能耗费几秒钟的时间,此时不能接收其他用户上传,所以,使用多线程技术优化,代码如下:
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();
}
}
}
信息回写分析图解
前四步与基本文件上传一致.
- 【服务端】获取输出流,回写数据。
- 【客户端】获取输入流,解析回写数据。
回写实现
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();
}
}
3.2 模拟B\S服务器(扩展知识点)
模拟网站服务器,使用浏览器访问自己编写的服务端程序,查看网页效果。
案例分析
-
准备页面数据,web文件夹。
复制到我们Module中,比如复制到day08中
- 我们模拟服务器端,ServerSocket类监听端口,使用浏览器访问
public static void main(String[] args) throws IOException {
ServerSocket server = new ServerSocket(8000);
Socket socket = server.accept();
InputStream in = socket.getInputStream();
byte[] bytes = new byte[1024];
int len = in.read(bytes);
System.out.println(new String(bytes,0,len));
socket.close();
server.close();
}
- 服务器程序中字节输入流可以读取到浏览器发来的请求信息
GET/web/index.html HTTP/1.1是浏览器的请求消息。/web/index.html为浏览器想要请求的服务器端的资源,使用字符串切割方式获取到请求的资源。
//转换流,读取浏览器请求第一行
BufferedReader readWb = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String requst = readWb.readLine();
//取出请求资源的路径
String[] strArr = requst.split(" ");
//去掉web前面的/
String path = strArr[1].substring(1);
System.out.println(path);
案例实现
服务端实现:
public class SerDemo {
public static void main(String[] args) throws IOException {
System.out.println("服务端 启动 , 等待连接 .... ");
// 创建ServerSocket 对象
ServerSocket server = new ServerSocket(8888);
Socket socket = server.accept();
// 转换流读取浏览器的请求消息
BufferedReader readWb = new
BufferedReader(new InputStreamReader(socket.getInputStream()));
String requst = readWb.readLine();
// 取出请求资源的路径
String[] strArr = requst.split(" ");
// 去掉web前面的/
String path = strArr[1].substring(1);
// 读取客户端请求的资源文件
FileInputStream fis = new FileInputStream(path);
byte[] bytes= new byte[1024];
int len = 0 ;
// 字节输出流,将文件写会客户端
OutputStream out = socket.getOutputStream();
// 写入HTTP协议响应头,固定写法
out.write("HTTP/1.1 200 OK\r\n".getBytes());
out.write("Content-Type:text/html\r\n".getBytes());
// 必须要写入空行,否则浏览器不解析
out.write("\r\n".getBytes());
while((len = fis.read(bytes))!=-1){
out.write(bytes,0,len);
}
fis.close();
out.close();
readWb.close();
socket.close();
server.close();
}
}
访问效果
- 火狐
小贴士:不同的浏览器,内核不一样,解析效果有可能不一样。
发现浏览器中出现很多的叉子,说明浏览器没有读取到图片信息导致。
浏览器工作原理是遇到图片会开启一个线程进行单独的访问,因此在服务器端加入线程技术。
public class ServerDemo {
public static void main(String[] args) throws IOException {
ServerSocket server = new ServerSocket(8888);
while(true){
Socket socket = server.accept();
new Thread(new Web(socket)).start();
}
}
static class Web implements Runnable{
private Socket socket;
public Web(Socket socket){
this.socket=socket;
}
public void run() {
try{
//转换流,读取浏览器请求第一行
BufferedReader readWb = new
BufferedReader(new InputStreamReader(socket.getInputStream()));
String requst = readWb.readLine();
//取出请求资源的路径
String[] strArr = requst.split(" ");
System.out.println(Arrays.toString(strArr));
String path = strArr[1].substring(1);
System.out.println(path);
FileInputStream fis = new FileInputStream(path);
System.out.println(fis);
byte[] bytes= new byte[1024];
int len = 0 ;
//向浏览器 回写数据
OutputStream out = socket.getOutputStream();
out.write("HTTP/1.1 200 OK\r\n".getBytes());
out.write("Content-Type:text/html\r\n".getBytes());
out.write("\r\n".getBytes());
while((len = fis.read(bytes))!=-1){
out.write(bytes,0,len);
}
fis.close();
out.close();
readWb.close();
socket.close();
}catch(Exception ex){
}
}
}
}
访问效果: