网络编程

最新推荐文章于 2024-10-06 20:16:20 发布

笑笑师弟

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量99

点赞数

文章标签： java 网络编程

本文链接：https://blog.csdn.net/qian_qian_123/article/details/82564314

版权

Java 专栏收录该内容

80 篇文章 1 订阅

订阅专栏

1. 网络通信协议

1.1 协议和七层模型

要使计算机连成的网络能够互通信息，需要对数据传输速率、传输代码、代码结构、传输控制步骤、出错控制等制定一组标准，这一组共同遵守的通信标准就是网络通信协议，不同的计算机之间必须使用相同的通讯协议才能进行通信。

七层模型，也称为OSI（Open System Interconnection）参考模型，是国际标准化组织（ISO）制定的一个用于计算机或通讯系统间互联的标准体系。它是一个七层的、抽象的模型体，不仅包括一系列抽象的术语或概念，也包括具体的协议。
ISO 就是 Internationalization Standard Organization（国际标准组织）。

1.2 TCP/IP协议

在Internet中TCP/IP协议是使用最为广泛的通讯协议。TCP/IP是英文Transmission Control Protocol/Internet Protocol的缩写，意思是“传输控制协议/网际协议”

TCP/IP协议(定义了电子设备（比如计算机）如何连入因特网，以及数据如何在它们之间传输的标准)：

Internet上不同系统之间互联的一组协议

为分散和不同类型的硬件提供通用的编程接口。

TCP/IP协议使Internet尽可能成为一个分散、无序的网络。

TCP是基于(面向)连接的协议，也就是说，在正式收发数据前，必须和对方建立可靠的连接。

TCP协议建立连接需要三次会话(握手)

IP地址：网络中每台计算机的一个标识号

是一个逻辑地址.在实际中可以使用127.0.0.1表示本机，或者直接使用localhost代表本机

IP地址使用32位长度二进制数据表示，一般在实际中看到的大部分IP地址都是以十进制的数据形式表示的，如：192.168.1.3。

IP地址分类：

IP地址分为5类，A类保留给政府机构，B类分配给中等规模的公司，C类分配给任何需要的人，D类用于组播，E类用于实验，各类可容纳的地址数据不同。

NO. 地址分类 地址范围
1 A类地址 1.0.0.1——126.255.255.254
2 B类地址 128.0.0.1——191.255.255.254
3 C类地址 192.0.0.1——223.255.255.254
4 D类地址 224.0.0.1——239.255.255.254
5 E类地址 240.0.0.1——255.255.255.254

端口号：具有网络功能的应用软件的标识号

端口是一个软件结构，被客户程序或服务程序用来发送和接收数据，一台服务器有256*256个端口。

0-1023是公认端口号，即已经公认定义或为将要公认定义的软件保留的

1024-65535是并没有公共定义的端口号，用户可以自己定义这些端口的作用。

端口与协议有关：TCP和UDP的端口互不相干

NO.	地址分类	地址范围
1	A类地址	1.0.0.1——126.255.255.254
2	B类地址	128.0.0.1——191.255.255.254
3	C类地址	192.0.0.1——223.255.255.254
4	D类地址	224.0.0.1——239.255.255.254
5	E类地址	240.0.0.1——255.255.255.254

2. 网络通信的实现

思考网络编程要解决的问题：

1.如何建立两个节点（电脑）之间的网络连接？

2.如何向另外一个节点（电脑）发送信息？

3.如何从外部节点（电脑）接收一个请求并给预响应？

4.如何利用网络协议（TCP,UDP）？

2.1 socket编程

套接字使用TCP提供了两台计算机之间的通信机制。客户端程序创建一个套接字，并尝试连接服务器的套接字。

当连接建立时，服务器会创建一个 Socket 对象。客户端和服务器现在可以通过对 Socket 对象的写入和读取来进行通信。

java.net.Socket 类代表一个套接字，并且 java.net.ServerSocket 类为服务器程序提供了一种来监听客户端，并与他们建立连接的机制。

当然，这里的ServerSocket只是socket通信中的一种，实际上，socket通信有三种模式来让我们实现：

1.流式套接字

提供了一个面向连接，可靠的数据传输服务，数据无差错，无重复的发送，且按发送顺序接收，其实他对应使用的是TCP协议

2.数据报式套接字

面向无连接，数据报以独立包形式发送，不提供无差错保证，数据可能丢失或重复，并且接收顺序无序，其实他对应使用的是UDP协议

3.原始式套接字

该接口允许对较低层次协议，如IP直接访问。可以接收本机网卡上的数据帧或数据包，对监听网络流量和分析很有用

2.2 TCP协议通信

使用TCP协议实现通信，需要使用流式套接字。即客户端采用socket,而服务器端采用ServerSocket来完成通信的方式

此时实现服务器端与客户端通信的思路:

其中，处理服务器端通信的ServerSocket类,其常见构造如下：

构造方法说明
ServerSocket() 创建一个ServerSocket对象
ServerSocket(int port) 创建一个ServerSocket对象，并绑定到指定端口

ServerSocket常用方法如下：

常用方法说明
Socket accept() 侦听并接收到此ServerSocket的连接，此方法在连接传入之前一直阻塞
void close() 使服务器释放占用的资源，并断开所有与客户端的连接
InetAddress getInetAddress() 返回当前服务器绑定的IP地址信息

处理客户端通信的Socket类:

Socket的构造共有9种，这里介绍2种常用的构造方法:

构造方法说明
Socket(String(String localAddr, int localPort) 向host主机的port端口发起连接请求,发起请求的计算机为localAddr,端口为localPort

注意：InetAddress类表示互联网协议地址，包含IP地址，实际上就是java对IP地址的封装。

Socket的常用方法：

常用方法说明
InetAddress getInetAddress() 返回与当前Socket对象关联的InetAddress对象
void shutdownInput() 此套接字的输入流置于“流的末尾”
void shutdownOutput() 禁用此套接字的输出流
InputStream getInputStream() 返回当前Socket对象关联的InputStream对象，它是服务器端向客户端发送回来的数据流.
OutputStream getOutputStream() 返回当前Socket 对象关联的OutputStream对象,它是客户端想服务器端发送的数据流
void close() 关闭该socket建立的连接

构造方法	说明
ServerSocket()	创建一个ServerSocket对象
ServerSocket(int port)	创建一个ServerSocket对象，并绑定到指定端口

常用方法	说明
Socket accept()	侦听并接收到此ServerSocket的连接，此方法在连接传入之前一直阻塞
void close()	使服务器释放占用的资源，并断开所有与客户端的连接
InetAddress getInetAddress()	返回当前服务器绑定的IP地址信息

构造方法	说明
Socket(String(String localAddr, int localPort)	向host主机的port端口发起连接请求,发起请求的计算机为localAddr,端口为localPort

常用方法	说明
InetAddress getInetAddress()	返回与当前Socket对象关联的InetAddress对象
void shutdownInput()	此套接字的输入流置于“流的末尾”
void shutdownOutput()	禁用此套接字的输出流
InputStream getInputStream()	返回当前Socket对象关联的InputStream对象，它是服务器端向客户端发送回来的数据流.
OutputStream getOutputStream()	返回当前Socket 对象关联的OutputStream对象,它是客户端想服务器端发送的数据流
void close()	关闭该socket建立的连接

2.2.1 服务端编程

服务器实现代码如下：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 服务端
 * 
 * @author Administrator
 *
 */
public class Server {
	public static void main(String[] args) {
		ServerSocket server = null;
		Socket socket = null;
		try {
			// 准备服务器端用的通讯对象（套接字）,指明端口号为8888
			server = new ServerSocket(8888);
			// 到指定端口去阻塞监听,一旦有客户端请求发送过来，那么立即自动与客户端建立连接
			socket = server.accept();
			System.out.println("服务器端准备ok");
			// 我要发送到客户端的内容
			String msg = "你好,我是服务器，这是我的第一次通讯,请问你收到了吗";
			OutputStream os = socket.getOutputStream();// 准备输出对象
			BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
			bw.write(msg);
			bw.newLine();
			bw.flush();
			// 接收客户端发送的信息
			InputStream is = socket.getInputStream();
			BufferedReader br = new BufferedReader(new InputStreamReader(is));
			String reply = br.readLine();
			System.out.println("我是服务器，接收到信息：" + reply);
			br.close();
			is.close();
			bw.close();
			os.close();
			socket.close();
			server.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

2.2.2 客户端实现

客户端实现代码如下：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * 客户端
 * 
 * @author Administrator
 *
 */
public class Client {
	public static void main(String[] args) {
		Socket socket = null;
		try {
			socket = new Socket("localhost", 8888);
			System.out.println("客户端准备完成");
			// 客户端开始接受请求
			InputStream is = socket.getInputStream();
			BufferedReader br = new BufferedReader(new InputStreamReader(is));
			String msg = br.readLine();
			System.out.println("我是客户端，接收到信息：" + msg);
			// 客户端接收到服务器端的信息之后，需要反馈信息给服务器
			// 客户端想要反馈给服务器端的信息
			String reply = "我是客户端，收到你的信息，这是我的反馈";
			OutputStream os = socket.getOutputStream();// 准备客户端的输出流
			BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
			bw.write(reply);
			bw.newLine();
			bw.flush();
			bw.close();
			os.close();
			br.close();
			is.close();
			socket.close();
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

2.3 UDP协议通信

需要用到两个类：DatagramSocket,DatagramPacket

DatagramSocket类的作用：发送和接收数据包的套接字，不维护连接状态，不产生输入输出流

DatagramPacket类：数据包，封装了数据，数据长度

DatagramPacket构造方法：

构造方法说明
DatagramPacket(byte [] buf,int length,InetAddress address,int port) Buf是数据的字节数组,length是字节数组的长度，address是目标主机的IP地址,port是目标主机的端口该构造用来构造对象，将长度为length的包发送到指定主机上的指定端口号

DatagramSocket的构造方法：

构造方法说明
DatagramSocket() 创建DatagramSocket对象，并将其与本地主机上任何可用的端口绑定
DatagramSocket(int port) 创建一个DatagramSocket对象，并将其与本地主机上的指定端口绑定

注意：在UDP通信中，通信的双方中，至少有一方需要指定端口号

DatagramSocket的常用方法：

常用方法说明
void send(DatagramPacket p) 发送指定的数据报
void receive(DatagramPacket p) 接收数据报.收到数据以后，存放在指定的DatagramPacket对象中
void close() 关闭当前的DatagramSocket对象

构造方法	说明
DatagramPacket(byte [] buf,int length,InetAddress address,int port)	Buf是数据的字节数组,length是字节数组的长度，address是目标主机的IP地址,port是目标主机的端口该构造用来构造对象，将长度为length的包发送到指定主机上的指定端口号

构造方法	说明
DatagramSocket()	创建DatagramSocket对象，并将其与本地主机上任何可用的端口绑定
DatagramSocket(int port)	创建一个DatagramSocket对象，并将其与本地主机上的指定端口绑定

常用方法	说明
void send(DatagramPacket p)	发送指定的数据报
void receive(DatagramPacket p)	接收数据报.收到数据以后，存放在指定的DatagramPacket对象中
void close()	关闭当前的DatagramSocket对象

2.3.1 服务端实现

UDP通信中并不需要明确的服务器概念，双方几乎是一样的操作，如下见服务器代码实现：

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
public class Client1 {
  public static void main(String[] args) {
      DatagramSocket socket = null;
      try {
          //参与通讯的两方，至少应该有一边指定端口号
          socket = new DatagramSocket();
          String msg = "我要发送的短信内容";
          //dp对象，是用来把要发送的信息打成一个数据包
          //数据长度不能超过64K
          //构造中可以传递四个参数:
          //第一个参数，表示要发送的内容，需要转换成一个byte数组
          byte [] b = msg.getBytes();
          //第二个参数，表示发送内容的字节数
          int len = b.length;
          //第三个参数，表示IP地址封装的一个对象，类型是InetAddress,是接收方的地址
          InetAddress ia = InetAddress.getByName("localhost");
          //第四个参数，表示对方的端口号
          int port = 8888;
          DatagramPacket dp = new DatagramPacket(b, len, ia, port);
          socket.send(dp);
          byte [] bs = new byte[1024];
          int length = bs.length;
          DatagramPacket dpReceive = new DatagramPacket(bs, length);
          socket.receive(dpReceive);
          String reply = new String(bs,0,dpReceive.getLength());
          System.out.println("我是client1,收到信息："+reply);
          socket.close();
      } catch (SocketException e) {
          e.printStackTrace();
      } catch (UnknownHostException e) {
          e.printStackTrace();
      } catch (IOException e) {
          e.printStackTrace();
      }
  }
}

2.3.2 客户端实现

客户端实现代码如下：

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.net.SocketException;
public class Client2 {
  public static void main(String[] args) {
      DatagramSocket socket = null;
      try {
          socket = new DatagramSocket(8888);
          //这里为了接收数据，也需要一个空的数据包
          //两个参数：
          //第一个参数，表示一个空的byte数组,用来接收信息内容
          byte [] b = new byte[1024];
          //第二个参数，表示数组长度
          int len = b.length;
          DatagramPacket dp = new DatagramPacket(b, len);
          //接收信息
          socket.receive(dp);
          String msg = new String(b,0,dp.getLength());
          System.out.println("我是Client2,接收到信息："+msg);
          String reply = "我很好，收到你的信息，很高兴，谢谢";
          byte [] bs = reply.getBytes();
          int length = bs.length;
          InetAddress ia = dp.getAddress();
          /*InetSocketAddress isa = (InetSocketAddress) dp.getSocketAddress();
          System.out.println("isa.getHostName():"+isa.getHostName());
          System.out.println("isa.getHostString():"+isa.getHostString());
          System.out.println("isa.getPort():"+isa.getPort());*/
          int port = dp.getPort();
          DatagramPacket dpReply = new DatagramPacket(bs, length, ia, port);      
          socket.send(dpReply);
          socket.close();
      } catch (SocketException e) {
          e.printStackTrace();
      } catch (IOException e) {
          e.printStackTrace();
      }
  }
}