网络编程通讯的第二要素--网络通信协议（TCP UDP）

最新推荐文章于 2024-03-08 22:23:13 发布
最新推荐文章于 2024-03-08 22:23:13 发布
阅读量173 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40230179/article/details/90138549
版权

网络通信协议

计算机网络中实现通信必须有一些约定，即通信协议。

TCP 和 UDP

TCP
1）使用TCP协议前，须先建立TCP连接，形成传输数据通道
2）传输前，采用“三次握手”方式，是可靠的
3）TCP协议进行通信的两个应用进程：客户端、服务端
4）在连接中可进行大数据量的传输
5）传输完毕，需释放已建立的连接，效率低
UDP
1）将数据、源、目的封装成数据包，不需要建立连接
2）每个数据报的大小限制在64K内
3）因无需连接，故是不可靠的
4）发送数据结束时无需释放资源，速度快

网络套接字(Socket)

1）网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。
2）利用套接字(Socket)开发网络应用程序.
3）通信的两端都要有Socket，是两台机器间通信的端点
4）网络通信其实就是Socket间的通信
5）Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输.也可以说网络编程是IO的扩展，因为在网络传输中也是靠5IO流的操作来完成的。
6）一般主动发起通信的应用程序属客户端，等待通信请求的为服务端
7）启动的时候先启动服务端，在启动客户端

基于Socket的TCP编程

客户端Socket的工作过程包含以下四个基本的步骤：
1）创建 Socket：根据指定服务端的 IP 地址或端口号构造 Socket 类对象。
2）打开连接到 Socket 的输入/出流： 使用 getInputStream()方法获得输入流，使用 getOutputStream()方法获得输出流，进行数据传输
3）按照一定的协议对 Socket 进行读/写操作：
4）关闭 Socket：断开客户端到服务器的连接，释放线路
服务端程序的工作过程包含以下四个基本的步骤：
调用 ServerSocket(int port) ：创建一个服务器端套接字，并绑定到指定端口上。用于监听客户端的请求。
调用 accept()：监听连接请求，如果客户端请求连接，则接受连接，返回通信套接字对象。
调用 该Socket类对象的 getOutputStream() 和 getInputStream ()：获取输出流和输入流，开始网络数据的发送和接收。
关闭ServerSocket和Socket对象：客户端访问结束，关闭通信套接字。

客户端给服务端发送数据 （亲测可用）

package com.ghl.demo;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;

import org.junit.Test;

/**
 * 网络编程也叫基于Sokect的编程：分为客户端和服务端 
 * 客户端发送数据的步骤：
 * 第一步：创建一个Socket对象，通过构造器指明对方服务器的ip地址和端口号
 *  第二步：通过getOutputStream()方法来发送数据
 * 第三步：具体的输出过程write()
 * 第四步：关闭相应的流
 */
public class TestTCP {
	// 客户端发送数据
	@Test
	public void testClient() {
		Socket socket = null;
		OutputStream os = null;
		try {
			socket = new Socket("127.0.0.1", 8181);// 第一步
			os = socket.getOutputStream();// 第二步
			os.write("我是客户端，我要给服务端的8181端口发送数据".getBytes());// 第三步
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (socket != null && os != null) {
				try {
					socket.close();
					os.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}

	}

	// 服务端：接收数据
	/**
	 * 服务端接收数据的步骤：
	 * 第一步：创建一个ServerSocket对象，通过构造器指明自身的对象（在服务端是ServerSocket）
	 * 第二步：调用accept()的方法，返回一个Socket对象
	 * 第三步：调用Socket对象的getInputStream()获取一个从客户端接收过来的数据
	 * 第四步：对获取的输入流进行操作
	 * 第五步：关闭相应的流
	 */
	@Test
	public void testServer() {
		ServerSocket server = null;
		Socket socket =null;
		InputStream is =null;
		try {
			 server = new ServerSocket(8181);
			 socket = server.accept();
			 is = socket.getInputStream();
			byte[] b=new byte[1024];
			int len;
			while((len=is.read(b))!=-1) {
				String str=new String(b, 0, len);
				System.out.println(str);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(server!=null) {
				try {
					server.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(socket!=null) {
				try {
					socket.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(is!=null) {
				try {
					is.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

}

客户端给服务端发送数据，服务端给客户但一个响应，（亲测可用）

package com.ghl.demo;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

import org.junit.Test;

/**
 * 实现功能：客户端给服务端发送数据，服务端告诉客户端我已收到你发的信息
 *
 */
public class TestTCP1 {
	// 客户端发送数据
		@Test
		public void testClient() {
			Socket socket = null;
			OutputStream os = null;
			InputStream is=null;
			try {
				//1.客户端先给服务端发送数据
				socket = new Socket("127.0.0.1", 8181);// 第一步
				os = socket.getOutputStream();// 第二步
				os.write("我是客户端，我要给服务端的8181端口发送数据".getBytes());// 第三步
				//2.客户端告诉服务端我的数据已发送完毕
				socket.shutdownOutput();
			 is=	socket.getInputStream();
			byte[] b=new byte[1024];
			int len;
			while((len=is.read(b))!=-1) {
				String str=new String(b, 0, len);
				System.out.println(str);
			}
			} catch (IOException e) {
				e.printStackTrace();
			} finally {
				if (socket != null && os != null) {
					try {
						socket.close();
						os.close();
						is.close();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}

		}

		// 服务端：接收数据
		@Test
		public void testServer() {
			ServerSocket server = null;
			Socket socket =null;
			InputStream is =null;
			OutputStream os = null;
			try {
				 server = new ServerSocket(8181);
				 socket = server.accept();
				 is = socket.getInputStream();
				byte[] b=new byte[1024];
				int len;
				while((len=is.read(b))!=-1) {
					String str=new String(b, 0, len);
					System.out.println(str);
				}
				
				os=socket.getOutputStream();
				os.write("我是服务端，我已接收到客户端发送的数据".getBytes());
			} catch (IOException e) {
				e.printStackTrace();
			}finally {
				if(server!=null) {
					try {
						server.close();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				if(socket!=null) {
					try {
						socket.close();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				if(os!=null) {
					try {
						os.close();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				if(is!=null) {
					try {
						is.close();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}
}

客户端发一个文件（图片）给服务端，服务端接收存在本地，并返回接收成功给客户端（亲测可用）

package com.ghl.demo;

import static org.hamcrest.CoreMatchers.instanceOf;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

import org.junit.Test;

/**
 * 客户端发一个文件（图片）给服务端，服务端接收存在本地，并返回接收成功给客户端
 *
 */
public class TestTCP2 {
	@Test
	public void testClient() {
		Socket socket = null;
		OutputStream os = null;
		InputStream is = null;
		FileInputStream fis=null;
		try {
			// 1.客户端先给服务端发送数据
			socket = new Socket("127.0.0.1", 8181);
			os = socket.getOutputStream();
			 fis = new FileInputStream(new File("1.jpg"));
			byte[] b1 = new byte[1024];
			int len1;
			while ((len1 = fis.read(b1)) != -1) {
				os.write(b1, 0, len1);
			}
			// 2.客户端告诉服务端我的数据已发送完毕
			socket.shutdownOutput();
			is = socket.getInputStream();
			byte[] b = new byte[1024];
			int len;
			while ((len = is.read(b)) != -1) {
				String str = new String(b, 0, len);
				System.out.println(str);
			}

		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (socket != null && os != null) {
				try {
					socket.close();
					os.close();
					is.close();
					fis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}

	}

	// 服务端：接收数据
	@Test
	public void testServer() {
		ServerSocket server = null;
		Socket socket = null;
		InputStream is = null;
		OutputStream os = null;
		FileOutputStream fos = null;
		try {
			server = new ServerSocket(8181);
			socket = server.accept();
			is = socket.getInputStream();
			fos = new FileOutputStream(new File("2.jpg"));
			byte[] b = new byte[1024];
			int len;
			while ((len = is.read(b)) != -1) {
			fos.write(b, 0, len);
			}

			os = socket.getOutputStream();
			os.write("我已接收到你发送的数据".getBytes());
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (server != null) {
				try {
					server.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (socket != null) {
				try {
					socket.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (os != null) {
				try {
					os.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (is != null) {
				try {
					is.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

UDP网络通信

1）类 DatagramSocket 和 DatagramPacket 实现了基于 UDP 协议网络程序
2）UDP数据报通过数据报套接字 DatagramSocket 发送和接收
3）DatagramPacket 对象封装了UDP数据报，
4）UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接
通信 流 程：
1）DatagramSocket与DatagramPacket
2）建立发送端，接收端
3）建立数据包
4）调用Socket的发送、接收方法
5）关闭Socket

package com.ghl.demo;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

import org.junit.Test;

/**
 * UDP如和以数据报的形式发送数据
 */
public class TestUDP {
	//发送端
	@Test
	public void send() {
		DatagramSocket datagramSocket=null;
		try {
			datagramSocket = new DatagramSocket();
			byte[] buf="我是发送端".getBytes();
			//创建一个数据报，每一个数据报不能大于64k发送ip和端口号，以及要发送的数据
			DatagramPacket pack=new DatagramPacket(buf, 0, buf.length,InetAddress.getByName("127.0.0.1"),8090);
			datagramSocket.send(pack);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		datagramSocket.close();
	}
	//接收端
	@Test
	public void recive() {
		DatagramSocket ds=null;
		DatagramPacket dp=null;
		try {
			ds = new DatagramSocket(8090);
			byte[] b=new byte[1024];
			dp = new DatagramPacket(b, 0, b.length);
			ds.receive(dp);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		String str=new String(dp.getData(),0,dp.getLength());
		System.out.println(str);
		ds.close();	
	}
}
红亮1014
关注
专栏目录
14-4 网络编程 ---- 通信要素2： 网络通信协议
wp_886的博客
02-21 115
14-4 网络编程 ---- 通信要素2： 网络通信协议 一、概述 1.网络通信协议 计算机网络中实现通信必须有一些约定，即通信协议，对速率、传输代码、代码结构、传输控制步骤、出错控制等制定标准。 2.问题：网络协议太复杂 计算机网络通信涉及内容很多，比如指定源地址和目标地址，加密解密，压缩解压缩，差错控制，流量控制，路由控制，如何实现如此复杂的网络协议呢？ 3.通信协议分层的思想 在制定协议时，把复杂成份分解成一些简单的成份，再将它们复合起来。最常用的复合方式是层次方式，即**同层间可以通信、上一层可以调
socket通信 tcp/ip协议的拆包解包
xiang3306的博客
12-28 4456
byte []surplusPack; private void getCount() { // 监听消息 new Thread(new Runnable() { @Override public void run() { while (true) { try { //socket通信的输
通信协议包
It_sharp的博客
02-25 744
Packet分为 Head 和 Body Head为12个字节，前8个字节是重要信息，包括标志、是否压缩、服务器ID、是否升级等字段，后4个字节是Body的长度 Body有9Byte，命令ID是4Byte，参数选项1Byte、表数量4Byte 然后是所有的表 表 字段类型有Byte、Int、Float、Double、Uint、String、Image、DateTime 1、先写行数和列数，再写所有...
分析IP协议数据包格式
热门推荐
林洋洋博客
10-17 1万+
通过wireshark软件的使用加深对此的了解（报头长度,版本，总长度）。通过浏览网页产生大量数据包。应该多捕捉多一些包，并去了解每个字段的含义。校验和运算既可选择在数据被转换成网络字节序前，也可选择在之后，只要保证被校验的字段和填写的校验和字段的字节序保持一致就可以了。
java-网络编程-UDP通信-TCP通信
LXMXHJ的博客
03-11 3630
网络编程：基础（计算机网络、网络编程三要素 = ip地址、端口、协议） UDP通信：DatagramSocket、DatagramPacket 发送（send）接收（receive、getData、getLength）； TCP通信：（发送端）Socket（InetAddress ip，int port）（String host,int port）；getOutputStream（）；（接收端）ServerSocket（int port）；accept（）；getInputStream（）；........
网络编程详解-UDP-TCP
无限进步
03-01 1055
网络编程的三要素是IP地址、端口和协议。具体分析如下：
网络编程---网络编程入门、UDP通信程序、TCP通信程序
最新发布
weixin_61611746的博客
03-08 979
在网络通信协议下，实现网络互连的不同计算机上运行的程序间可以进行数据传输是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。
网络通信编程（UDP和TCP协议的实现）
floyer的博客
10-25 2906
网络通信1.网络编程入门1.1网络编程概述1.2网络编程三要素第一要素第二要素第三要素1.3IP地址（网络中设备的唯一标识）常用命令特殊IP地址1.4InetAddress的使用二级目录三级目录 1.网络编程入门 1.1网络编程概述 网络编程：在网络通信协议下，实现网络互连的不同计算机上运行的程序间可以进行数据交换。（可以通过访问他人计算机上的内容进行资源共享和信息传递） 1.2网络编程三要素 第一要素 IP地址（设备的标识） 第二要素 端口（应用程序的标识） 第三要素 协议（连接和通信的规则被称为网络通信
网络编程网络通信的介绍,UDP通信程序,TCP通信程序
weixin_46589095的博客
12-03 1579
网络编程,UDP通信程序,TCP通信程序
（一)Java网络编程之计网基础、TCP-IP协议簇、TCP、UDP协议及腾讯QQ通信原理综述
m0_71563599的博客
05-31 1360
引言 就目前而言，多数网络编程的系列的文章都在围绕着计算机网络体系进行阐述，但其中太多理论概念，对于大部分开发者而言，用途甚微。因此，在本系列中则会以实际开发者的工作为核心，从Java程序员的角度出发，详细解读Java的网络编程核心内容。 一、计算机网络的“前世今生”与基础概念 先来看看维基百科对于计算机网络这个名词的解释： 计算机网络是指将位于不同地理位置，但具有独立功能的多台设备，通过通信设备和线路连接起来，在网络操作系统，网络管理软件、网络通信协议的协调管理下，实现资源共享和信息传递的计算..
网络编程（tcp和udp）
Cocobuhui的博客
11-03 301
网络编程（tcp和udp）
网络编程-概述、网络模型、三要素：IP.端口号.传输协议、Socket、UDP协议、TCP协议
qq_39497997的博客
02-03 816
网络编程-概述、网络模型、三要素：IP.端口号.传输协议、Socket、UDP协议、TCP协议
【JavaEE基础与高级 第57章】Java中的网络编程、UDP通信程序、TCP通信程序的使用
KJ.JK
11-04 1万+
实现不同计算机上进行 "数据传输" 的程序* "IP地址" : 指互联网协议地址（ Internet Protocol Address ），俗称IP * IP地址是设备在网络中的地址，是唯一的标识 * 假如我们把“个人电脑”比作“一台电话”的话，那么“IP地址”就相当于“电话号码”
Java IO流（FileInputStream，FileOutputStream及File）讲解
高度不够看到的都是问题，格局太小纠结的都是鸡毛蒜皮。
04-21 5573
File类的使用 在介绍流的概念之前，我们需要知道并且明确File和IO流是什么关系。 java.io.File类：文件和目录路径名的抽象表示形式 File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。 File对象可以作为参数传递给流的构造函数 File的构造函数 参考在线的jdk文档：https://blog.fondm...
java集合遍历 List套Map
高度不够看到的都是问题，格局太小纠结的都是鸡毛蒜皮。
05-15 2818
List<Map<String,Object>> 的遍历 取出所有的key 根据指定key取值 package com.ghl.demo; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class Tes...
java文件和字节数组之间得转换
高度不够看到的都是问题，格局太小纠结的都是鸡毛蒜皮。
05-05 2736
package com.ghl.demo; import java.io.BufferedOutputStream; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.I...
Java IO流之缓冲流（BufferedInputStream ，BufferedOutputStream）讲解
高度不够看到的都是问题，格局太小纠结的都是鸡毛蒜皮。
04-29 1723
回顾流的分类 1）按照数据单位的不同流可分为：字节流和字符流 2）按照数据流的流向可分为：输入流和输出流 3) 按流的角色的不同分为：节点流，处理流 抽象基类 节点流（字节流/字符流） 缓冲流 (处理流的一种) InputStream ...
java文件下载时如何解决中文名称不显示的问题
高度不够看到的都是问题，格局太小纠结的都是鸡毛蒜皮。
07-29 1639
所下载文件包含中文字符时需要进行编码: 第一种方法: String filename = new String(file.getName().getBytes(),"ISO-8859-1"); response.getHttpResponse().setHeader("Content-Disposition", "attachment;filename=" + filename); 第二种方...
网络编程基础：TCP通信协议与Socket套接字
本篇笔记主要介绍了网络编程的基础知识，包括软件架构、网络通信三要素、TCP通信、Socket套接字和ServerSocket等。 第一章 网络编程入门 软件架构是指计算机系统的结构设计，分为两种：C/S结构（Client/Server结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值