软件架构
- C/S架构:全称为Client/Server结构,是指客户端和服务器端结构。常见程序有QQ,迅雷软件。
- B/S架构:全称为Brower/Server结构,是指浏览器和服务器结构。常见浏览器有谷歌,火狐等。
网络编程,就是在一定的协议下,实现两台计算机的通信的程序。
网络通信协议
- 网络通信协议:通信协议是对计算机必须遵守的规则,只有遵守这些规则,计算机之间才能进行通信。协议中对数据的传输格式,传输速率,传输步骤等做了同一规定,通信双方必须同时遵守,最终完成数据交换
- TCP/IP协议:传输控制协议/因特网互联协议,是internet最基本,最广泛的协议。它定义了计算机如何连入因特网,以及数据如何在他们之间传输的标准。它的内部包含一系列的用于处理数据的通信协议,并采用分层模型。每一层依赖它下一层所提供的协议来完成自己的需求。
协议分类
通信的协议十分复杂,java.net
包中包含的类和接口,提供了低层次的通信细节。通过直接使用这些类和接口,可以专注于网络程序的开发,而不需要考虑通信的细节。
java.net
包中提供了两种常见的网络协议的支持:
- TCP:传输控制协议。TCP是面向连接的通信协议,即传输数据之前,在发送端和接收端建立逻辑链接,然后在传输数据,提供了两台计算机之间可靠误差错的数据传输
- 三次握手:TCP协议中,在发送数据的准备阶段,客户端于服务器端之间的三次交互,以保证链接的可靠
- 第一次握手,客户端向服务器端发出链接请求,等待服务器确认
- 第二次握手,服务器向客户端回送一个相应,通知客户端收到了链接请求
- 第三次握手,客户端再次向服务器端发送确认信息,确认链接。
- 三次握手:TCP协议中,在发送数据的准备阶段,客户端于服务器端之间的三次交互,以保证链接的可靠
完成三次握手,建立连接后,客户端和服务器端就可以进行数据传输了。由于这种面向链接的特性,TCP协议可以保证数据传输的安全,应用十分广泛,例如下载文件,浏览网页等。
- UDP:用户数据报协议。UDP协议是一个面向无连接的协议。传输数据时,不需要建立连接,不管对方端服务是否启动,直接将数据,数据源和目的都封装在数据包中,直接发送。每个数据包的大小限制在64k以内。它是不可靠协议,因为无连接,所以传输速度快,但荣以丢失数据。日常应用中,例如视频会议,qq聊天
网络编程三要素
- 协议:计算机网络通信遵守的规则
- IP地址:指定互联网协议,俗称IP。IP地址用来给一个网络中的计算机设备做唯一的编号。
- IP地址分类:
- IPv4:是一个32位的二进制数,通常被分为4个字节,表示为
a.b.c.d
的形式,例如192.168.0.1
.其中a,b,c,d都是0~255之间的十进制整数,最多可以表示42亿个 - IPv6:由于互联网的蓬勃发展,IP地址的需求量越来越大,但是网络地址资源有限,是的IP的分配愈发紧张。为了扩展地址空间,拟通过IPv6重新定义地址空间,采用128位地址长度,每16个字节一组,分成8组十六进制数,表示成
ABCD:EF01:2345:6789:ABCD:EF01:2345:6789
,号称可以为全世界的每一粒沙子编上一个网址,这样就解决了网络地址资源数量不够的问题。
- IPv4:是一个32位的二进制数,通常被分为4个字节,表示为
常用的命令
-
查看本机IP地址
ipconfig //windows ifconfig //mac linux
-
检查网络是否连通
ping IP地址 ping 220.181.57.216
-
特殊的IP地址:127.0.0.1,localhost
端口号
网络的通信,本质上是两个进程之间的通信。每台计算机都有很多的进程。IP地址可以唯一标识网络中的设备,端口号可以唯一标识设备中的进程了。
- 端口号:用两个字节表示的整数,取值范围065535.其中,01023之间的端口号用于一些知名的网络服务和应用,普通的应用程序需要使用1024以上的端口号。如果端口号被另一个服务或应用所占用,会导致当前程序启动失败
- 利用
协议+IP地址+端口号
三元组合,就可以标识网络中的进程了,进程之间的通信就可以利用这个标识与其他进程进行交互
TCP通信程序
TCP通信能实现两台计算机之间的数据交互,通信的两端,要严格区分为客户端与服务器端
-
两端通信的步骤:
- 服务器端程序,需要事先启动,等待客户端的连接
- 客户端主动连接服务器,连接成功才能通信。服务端不可以主动连接客户端
-
java中提供了两个类用于实现TCP通信程序:
- 客户端:
java.net.Socket
类表示。创建Socket
对象,向服务端发送连接请求,服务端相应请求,两者建立连接开始通信 - 服务端:
java.net.ServerSocket
类表示。创建ServerSocket
对象,相当于开启一个服务,并等待客户端的连接
- 客户端:
Socket类
Socket
类:该类实现客户端套接字,套接字指的是两台设备之间通信的端点。
构造方法:
public Socket(String host,int port)
:创建套接字对象并将其连接到指定主机上的指定端口。如果指定的host是null,则相当于指定地址为回送地址。
回送地址是本机回送地址,主要用于网路软件测试以及本地机进程间通信,无论是什么程序,一旦使用回送地址发送数据,立即返回,不进行任何网络传输。
构造举例,代码如下:
Socket client = new Socket("127.0.0.1",6666);
成员方法:
public InputStream getInputStream()
:返回此套接字的输入流- 如果此Socket具有相关的通信,则生成的InputStream所有的操作也做关联该通道
- 关闭生成的InputStream也将关闭相应的Socket
public OutputStream getOutputStream()
:返回此套接字的输出流- 如果此Socket具有相关联的通道,则生成的OutputStream的所有操作也关联该通道
- 关闭生成的OutputStream也将关闭相关的Socket
public void close()
:关闭套接字- 一旦一个socket被关闭,它不可在被使用
- 关闭此Socket也将关闭InputStream和OutputStream
public void shutdownOutput()
:禁止此套接字的输出流- 任何先前写出的数据将被发送,随后终止输出流
ServerSocket类
ServerSocket
类:这个类实现了服务器套接字,该对象等待通过网络的请求。
-
构造方法
-
public ServerSocket(int port)
:使用该构造方法在创建ServerSocket对象时,就可以将其绑定到一个指定的端口号上,参数port就是端口号。构造举例,代码如下:
ServerSocket server = new ServerSocket(6666);
-
-
成员方法
public Socket accept()
:侦听并接收连接,返回一个新的Socket对象,用于和客户端实现通信。该方法会一直阻塞直到建立连接。
简单地TCP网络程序
TCP通信分析:
- 服务端启动,创建ServerSocket对象,等待连接。
- 客户端启动,创建Socket对象,请求连接
- 服务端接收连接,调用accept方法,并返回一个Socket对象
- 客户端Socket对象,获取OutputStream,向服务端写出数据
- 服务端Socket对象,获取InputStream,读取客户端发送的数据
到此,客户端向服务器端发送数据成功
自此,服务端向客户端写回数据
- 服务端Socket对象,获取OutputStream,向客户端写回数据
- 客户端Socket对象,获取InputStream,解析写回的数据
- 客户端释放资源,断开连接
客户端向服务器端发送数据
服务器端实现:
package demo.socket;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServer {
public static void main(String[] args) throws IOException {
System.out.println("server started!");
//创建ServerSocket对象,绑定端口,等待连接
ServerSocket serverSocket = new ServerSocket(6666);
//接收连接,返回一个Socket对象
Socket accept = serverSocket.accept();
//通过Socket获取输入流
InputStream inputStream = accept.getInputStream();
//一次性读字机数组
//创建字节数组
byte[] bytes = new byte[1024];
//具读取字节到数组中
int read = inputStream.read(bytes);
//解析数组,打印字符串信息
String msg = new String(bytes, 0, read);
System.out.println(msg);
inputStream.close();
serverSocket.close();
}
}
客户端实现:
package demo.socket;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
public class ClientTCP {
public static void main(String[] args) throws IOException {
System.out.println("send message!");
//创建socket
Socket localhost = new Socket("localhost", 6666);
//获取输出流对象
OutputStream outputStream = localhost.getOutputStream();
//写入数据
outputStream.write("are you ok?TCP,I am Coming!".getBytes());
outputStream.close();
localhost.close();
}
}
服务器端向客户端回写数据
服务器端实现:
package demo.socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServer {
public static void main(String[] args) throws IOException {
System.out.println("server started!");
//创建ServerSocket对象,绑定端口,等待连接
ServerSocket serverSocket = new ServerSocket(6666);
//接收连接,返回一个Socket对象
Socket accept = serverSocket.accept();
//通过Socket获取输入流
InputStream inputStream = accept.getInputStream();
//一次性读字机数组
//创建字节数组
byte[] bytes = new byte[1024];
//具读取字节到数组中
int read = inputStream.read(bytes);
//解析数组,打印字符串信息
String msg = new String(bytes, 0, read);
System.out.println(msg);
//回写数据
OutputStream outputStream = accept.getOutputStream();
outputStream.write("I am fine,Thanks".getBytes());
// outputStream.close();
// inputStream.close();
// serverSocket.close();
}
}
客户端实现:
package demo.socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class ClientTCP {
public static void main(String[] args) throws IOException {
System.out.println("send message!");
//创建socket
Socket localhost = new Socket("localhost", 6666);
//获取输出流对象
OutputStream outputStream = localhost.getOutputStream();
//写入数据
outputStream.write("are you ok?TCP,I am Coming!".getBytes());
//解析回显
InputStream inputStream = localhost.getInputStream();
//定义读写数组
byte[] bytes = new byte[1024];
int len = inputStream.read(bytes);
System.out.println(new String(bytes,0,len));
// inputStream.close();
// outputStream.close();
// localhost.close();
}
}
综合案例
文件上传案例
- 客户端输入流,从硬盘读取文件数据到程序中
- 客户端输出流,写出文件到服务器端
- 服务端输入流,读取文件数据到服务器端程序
- 服务器输出流,写出文件到服务器硬盘中
服务端实现
package demo.socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class UploadServer {
public static void main(String[] args) throws IOException {
System.out.println("server started!");
//创建ServerSocket
ServerSocket serverSocket = new ServerSocket(6666);
//建立连接
Socket accept = serverSocket.accept();
//创建流对象
//获取输入流,读取文件
BufferedInputStream inputStream = new BufferedInputStream(accept.getInputStream());
//获取输出流,保存文件到本地
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("copy.jpeg"));
//读写数据
byte[] bytes = new byte[1024 * 8];
int len;
while((len = inputStream.read(bytes))!= -1){
bufferedOutputStream.write(bytes,0, len);
}
//关闭资源
// bufferedOutputStream.close();
// inputStream.close();
// serverSocket.close();
System.out.println("File is Upload!");
}
}
客户端:
package demo.socket;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.Socket;
public class UploadClient {
public static void main(String[] args) throws IOException {
Socket localhost = new Socket("localhost", 6666);
//创建流对象
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("test.jpeg"));
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(localhost.getOutputStream());
//写出数据
byte[] bytes = new byte[1024 * 8];
int len;
while((len = bufferedInputStream.read(bytes)) != -1){
bufferedOutputStream.write(bytes, 0,len);
bufferedOutputStream.flush();
}
System.out.println("File Upload");
// bufferedOutputStream.close();
// bufferedInputStream.close();
// localhost.close();
}
}
文件上传优化
-
文件名称写死问题
-
服务端,保存文件的名称如果血丝,将导致服务器硬盘,只会保存一个文件,可以使用系统时间优化,保证文件名称唯一
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(System.currentTimeMillis()+".jpeg"));
-
-
服务器循环接收问题
服务器端,保存一个文件就关闭了,之后的用户无法在上传,不符合实际,使用循环改进,可以不断的接收不同用户的文件,代码如下:
package demo.socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class UploadServer {
public static void main(String[] args) throws IOException {
System.out.println("server started!");
//创建ServerSocket
ServerSocket serverSocket = new ServerSocket(6666);
while(true){
//建立连接
Socket accept = serverSocket.accept();
//创建流对象
//获取输入流,读取文件
BufferedInputStream inputStream = new BufferedInputStream(accept.getInputStream());
//获取输出流,保存文件到本地
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(System.currentTimeMillis()+".jpeg"));
//读写数据
byte[] bytes = new byte[1024 * 8];
int len;
while((len = inputStream.read(bytes))!= -1){
bufferedOutputStream.write(bytes,0, len);
}
System.out.println("File is Upload!");
}
//关闭资源
// bufferedOutputStream.close();
// inputStream.close();
// serverSocket.close();
}
}
- 效率问题
服务器端,在接收大文件时,可能消耗几分钟的时间,此时不能接收其他用户上传,所以,使用多进程技术优化。
package demo.socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class UploadServer {
public static void main(String[] args) throws IOException {
System.out.println("server started!");
//创建ServerSocket
ServerSocket serverSocket = new ServerSocket(6666);
while(true){
//建立连接
Socket accept = serverSocket.accept();
//创建流对象
//获取输入流,读取文件
new Thread(() -> {
BufferedInputStream inputStream = null;
try {
inputStream = new BufferedInputStream(accept.getInputStream());
} catch (IOException e) {
e.printStackTrace();
}
//获取输出流,保存文件到本地
BufferedOutputStream bufferedOutputStream = null;
try {
bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(System.currentTimeMillis()+".pdf"));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
//读写数据
byte[] bytes = new byte[1024 * 8];
int len = 0;
while(true){
try {
if (!((len = inputStream.read(bytes))!= -1)) break;
} catch (IOException e) {
e.printStackTrace();
}
try {
bufferedOutputStream.write(bytes,0, len);
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("File is Upload!");
}).start();
}
//关闭资源
// bufferedOutputStream.close();
// inputStream.close();
// serverSocket.close();
}
}
信息回写
前四步与基本文件上传一致。
- 服务端获取输出流,写回数据
- 客户端获取输入流,解析回写数据
回写实现:
服务器端:
package demo.socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class UploadServer {
public static void main(String[] args) throws IOException {
System.out.println("server started!");
//创建ServerSocket
ServerSocket serverSocket = new ServerSocket(6666);
while(true){
//建立连接
Socket accept = serverSocket.accept();
//创建流对象
//获取输入流,读取文件
new Thread(() -> {
try {
BufferedInputStream bufferedInputStream = new BufferedInputStream(accept.getInputStream());
FileOutputStream fileOutputStream = new FileOutputStream(System.currentTimeMillis() + ".jpeg");
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
//读写数据
byte[] bytes = new byte[1024 * 8];
int len;
while ((len = bufferedInputStream.read(bytes))!=-1){
bufferedOutputStream.write(bytes,0,len);
}
//信息回写
System.out.println("back.......");
OutputStream outputStream = accept.getOutputStream();
outputStream.write("上传成功!".getBytes());
// outputStream.close();
// bufferedOutputStream.close();
// bufferedInputStream.close();
// accept.close();
} catch (IOException e) {
e.printStackTrace();
}
}).start();
}
}
}
客户端:
package demo.socket;
import java.io.*;
import java.net.Socket;
public class UploadClient {
public static void main(String[] args) throws IOException {
Socket localhost = new Socket("localhost", 6666);
//创建流对象
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("1.jpeg"));
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(localhost.getOutputStream());
//写出数据
byte[] bytes = new byte[1024 * 8];
int len;
while((len = bufferedInputStream.read(bytes)) != -1){
bufferedOutputStream.write(bytes, 0,len);
// bufferedOutputStream.flush();
}
//关闭输出流,通知服务端,写出数据完毕
localhost.shutdownOutput();
System.out.println("File Upload");
//解析回写
InputStream inputStream = localhost.getInputStream();
byte[] b = new byte[20];
inputStream.read(b);
System.out.println(new String(b));
// inputStream.close();
// bufferedOutputStream.close();
// bufferedInputStream.close();
// localhost.close();
}
}