网络编程java
2020-07-25 08:41
441 查看
软件架构
- C/S架构：全称为Client/Server结构，是指客户端和服务器端结构。常见程序有QQ，迅雷软件。
- B/S架构：全称为Brower/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌，火狐等。
网络编程，就是在一定的协议下，实现两台计算机的通信的程序。
网络通信协议
- 网络通信协议：通信协议是对计算机必须遵守的规则，只有遵守这些规则，计算机之间才能进行通信。协议中对数据的传输格式，传输速率，传输步骤等做了同一规定，通信双方必须同时遵守，最终完成数据交换
- TCP/IP协议：传输控制协议/因特网互联协议，是internet最基本，最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在他们之间传输的标准。它的内部包含一系列的用于处理数据的通信协议，并采用分层模型。每一层依赖它下一层所提供的协议来完成自己的需求。
协议分类
通信的协议十分复杂，
java.net包中包含的类和接口，提供了低层次的通信细节。通过直接使用这些类和接口，可以专注于网络程序的开发，而不需要考虑通信的细节。
java.net包中提供了两种常见的网络协议的支持：
- 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
，号称可以为全世界的每一粒沙子编上一个网址，这样就解决了网络地址资源数量不够的问题。
常用的命令
-
查看本机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的所有操作也关联该通道
public void close()：关闭套接字
-
一旦一个socket被关闭，它不可在被使用
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();
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- JAVA 网络编程（简单的发送端和接受端）
- Java之TCP网络编程
- JAVA 网络编程学习第一篇TCP
- 黑马程序员——Java基础知识——网络编程
- 黑马程序员-Java-网络编程
- Java 网络编程
- bug笔记 - Java --- 网络编程使用BufferedInputStream从缓冲区中读不到数据(浅析BufferedInputStram和BufferedOutputStream的工作机制)
- Java学习笔记（网络编程）
- Java socket网络编程（一） NIO与BIO
- 黑马程序员_JAVA_网络编程
- Java 网络编程（一） 网络基础知识
- Java 网络编程学习笔记（四）NIO
- Java 网络编程（四） InetAddress类
- 黑马程序员——java基础——网络编程
- 尚硅谷java——网络编程
- 黑马程序员--Java基础学习(网络编程)第二十四天
- Java-网络编程（第一天）
- Java-网络编程(IP地址)-(TCP和UDP)-(Socket)-(Udp-发送端)-(Udp-接收端)
- java基础知识——网络编程、IO流
- java网络编程学习java聊天程序代码分享