devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java计算机网络（一）-- url，tcp，udp，socket

作者：羊村懒王 | 2024-04-04 23:55:10

赞

踩

java计算机网络（一）-- url，tcp，udp，socket

网络编程：

计算机网络

计算机网络指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统、网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

网络协议组成三要素：

语义：

规定了通信双方为了完成某种目的，需要发出何种控制信息以及基于这个信息需要做出何种行动。

语法：

是用户数据与控制信息的结构与格式，以及数据出现的先后顺序。

时序：

是对事件发生顺序的详细说明。

语义表示要做什么，语法表示要怎么做，时序表示做的顺序。

网络编程概述

  Java是Internet 上的语言，它从语言级上提供了对网络应用程序的支持，程序员能够很容易开发常见的网络应用程序。

  Java提供的网络类库，可以实现无痛的网络连接，联网的底层细节被隐藏在Java的本机安装系统里，由JVM 进行控制。并且Java 实现了一个跨平台的网络库，程序员面对的是一个统一的网络编程环境。

网络编程的目的：

  •     直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯。

  网络编程中有两个主要的问题：

  •     如何准确地定位网络上一台或多台主机；定位主机上的特定的应用
  •     找到主机后如何可靠高效地进行数据

通信双方地址

  •       IP
  •     端口号

一定的规则（即：网络通信协议。有两套参考模型）

  •  OSI参考模型：模型过于理想化，未能在因特网上进行广泛推广
  •   TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准。

网络通信协议

OSI参考模型

TCP/IP参考模型

TCP/IP参考模型各层对应协议

应用层

应用层

HTTP、FTP、Telnet、DNS…

表示层

会话层

传输层

传输层

TCP、UDP、…

网络层

网络层

IP、ICMP、ARP、RARP…

数据链路层

物理+数据链路层

Link

物理层

  • TCP/IP不是一个协议，而是一个协议族的统称
  • TCP/IP协议族按照层次由上到下，层层包装。第一层都有相应的协议。
  • 数据从上层向下层传输为封装
  • 数据从下层向上层传输为解封

IP地址： InetAddress:

唯一的标识Internet 上的计算机（通信实体）

本地回环地址(hostAddress)：127.0.0.1主机名(hostName)：localhost

IP地址分类方式1：IPV4和IPV6

  •   IPV4：4个字节组成，4个0-255。大概42亿，30亿都在北美，亚洲4亿。2011年初已经用尽。以点分十进制表示，如192.168.0.1
  •   IPV6：128位（16个字节），写成8个无符号整数，每个整数用四个十六进制位表示，数之间用冒号（：）分开，如：    3ffe:3201:1401:1280:c8ff:fe4d:db39:1984

  IP地址分类方式2：公网地址(万维网使用)和私有地址(局域网使用)。     192.168.开头的就是私有址址，范围即为192.168.0.0--192. 168.255.255，专门为组织机构内部使用

  特点：不易记忆

IP地址由两部分组成：

  • 网络号
  • 主机号

IP地址有两种表示方式：

  1. 二进制表示，比如：01110119 10111010 11010011 01011100
  2. 点分十进制表示，比如：119.186.211.92
  3.  
  4. A类地址
  5. 1.0.0.0 到126.0.0.0
  6. 0.0.0.0 和127.0.0.0保留
  7.  
  8. B类地址
  9. 128.1.0.0到191.254.0.0
  10. 128.0.0.0和191.255.0.0保留
  11.  
  12. C类地址
  13. 192.0.1.0 到223.255.254.0
  14. 192.0.0.0和223.255.255.0保留
  15.  
  16. D类地址
  17. 224.0.0.0到239.255.255.255用于多点广播
  18.  
  19. E类地址
  20. 240.0.0.0到255.255.255.254保留
  21. 255.255.255.255用于广播

子网掩码:

  • 解决IP地址不够用的问题
  • 标识子网和主机位

端口号

  • 端口号标识正在计算机上运行的进程（程序）
  •   不同的进程有不同的端口号
  •   被规定为一个16 位的整数0~65535。
  • 端口分类：
  • 公认端口：0~1023。被预先定义的服务通信占用（如：HTTP占用端口80，FTP占用端口21，Telnet占用端口23）
  • 注册端口：1024~49151。分配给用户进程或应用程序。（如：Tomcat占用端口8080，MySQL占用端口3306，Oracle占用端口1521等）。
  • 动态/私有端口：49152~65535。
  • 端口号与IP地址的组合得出一个网络套接字：Socket。

域名

域名（Domain Name），是由一串用点分隔的名字组成的Internet上某一台计算机或计算机组的名称，用于在数据传输时标识计算机的电子方位。

如：www.sohu.com

域名可分为不同级别，包括顶级域名、二级域名等。

顶级域名又分为两类：一是国家和地区顶级域名（country code top-level domains，简称nTLDs），目前200多个国家按照ISO3166国家代码分配了顶级域名，例如中国为cn，日本为jp等；二是国际顶级域名（generic top-level domains，简称gTLDs），例如表示工商企业的.com，表示网络提供商的.net，表示非盈利组织的.org等。

二级域名指顶级域名之下的域名

网络配置:

打开“Internet协议版本4（TCP/IPv4）属性”对话框

常用TCP/IP网络命令

  • ipconfig：查看网络配置信息
  • ping：检查主机的网络连通情况

http://pic.baike.soso.com/p/20130716/20130716152119-1562356107.jpg

http://b.hiphotos.baidu.com/zhidao/pic/item/728da9773912b31b819120558618367adbb4e1c9.jpg

URL类:

        java.net.URL 代表一个统一资源定位符，它是指向互联网“资源”的指针。资源可以是简单的文件或目录，也可以是对更为复杂的对象的引用，例如对数据库或搜索引擎的查询。

分成几个部分：

  1. 协议
  2. 主机
  3. 端口号

      URL(Uniform Resource Locator)：统一资源定位符，它表示Internet 上某一资源的地址。

    它是一种具体的URI，即URL可以用来标识一个资源，而且还指明了如何locate这个资源。

    通过URL 我们可以访问Internet 上的各种网络资源，比如最常见的www，ftp 站点。浏览器通过解析给定的URL 可以在网络上查找相应的文件或其他资源。

URL的基本结构由5部分组成：

      <传输协议>://<主机名>:<端口号>/<文件名>#片段名?参数列表

    例如: http://192.168.1.100:8080/helloworld/index.jsp#a?username=shkstart&password=123

      #片段名：即锚点，例如看小说，直接定位到章节

    参数列表格式：参数名=参数值&参数名=参数值

    为了表示URL，java.net 中实现了类URL。我们可以通过下面的构造器来初始化一个URL 对象：         

  1. public URL (String spec)：
  2.     通过一个表示URL地址的字符串可以构造一个URL对象。
  3.     例如：URL url= new URL ("http://www. atguigu.com/");
  4.  
  5. public URL(URL context, String spec)：
  6.     通过基URL 和相对URL 构造一个URL 对象。
  7.     例如：URL downloadUrl= new URL(url, “download.html")
  9. public URL(String protocol, String host, String file); 
  10.     例如：new URL("http", "www.atguigu.com", “download. html");
  11.  
  12. public URL(String protocol, String host, intport, String file); 
  13.     例如: URL gamelan = new URL("http", "www.atguigu.com", 80, “download.html");

      URL类的构造器都声明抛出非运行时异常，必须要对这一异常进行处理，通常是用try-catch 语句进行捕获。

URL网络编程：URL类常用方法

一个URL对象生成后，其属性是不能被改变的，但可以通过它给定的方法来获取这些属性：     

  1.     public String getProtocol(  )     获取该URL的协议名
  2. 	public String getHost(  )        获取该URL的主机名
  3. 	public String getPort(  )        获取该URL的端口号
  4. 	public String getPath(  )        获取该URL的文件路径
  5. 	public String getFile(  )         获取该URL的文件名
  6. 	public String getQuery(   )      获取该URL的查询名

URL类获取网络上指定资源的信息

输出百度首页html脚本

  1. import java.io.*;
  2. import java.net.URL;
  3.  
  4. public class TestURL{
  5. 	//输出百度首页html脚本
  6. 	public static void main(String args[]){		
  7. 		BufferedReader bufferedReader = null;
  8. 		try {
  9. 			//通过URL字符串创建URL对象
  10. 			URL url = new URL("https://www.baidu.com");
  11. 			//打开URL连接并返回从该连接读入数据的InputStream
  12. 			InputStream inputStream = url.openStream();
  13. 			bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
  14. 			String oneLineData;
  15. 			while ((oneLineData = bufferedReader.readLine()) != null){
  16. 				System.out.println(oneLineData);
  17. 			}
  18. 		}catch(Exception e){
  19. 			e.printStackTrace();
  20. 		}finally{
  21. 			if(bufferedReader!=null){
  22. 				try {
  23. 					bufferedReader.close();
  24. 				} catch (IOException e) {
  25. 					e.printStackTrace();
  26. 				}
  27. 			}
  28. 		}
  29. 	}
  30. }

URLConnection类:

  1. java.net.URLConnection代表的是一种连接。
  2. URLConnection用于读取和写入对应URL 引用的资源。
  3. URLConnection对象操作步骤：
  4. 通过在 URL 上调用 openConnection 方法创建连接对象；
  5. 设置参数和一般请求属性。
  6. 使用 connect 方法建立到远程对象的实际连接；
  7. 远程对象变为可用，其中远程对象的头字段和内容变为可访问。
  8. URL的方法openStream()：能从网络上读取数据
  9. 若希望输出数据，例如向服务器端的CGI （公共网关接口-Common Gateway Interface-的简称，是用户浏览器和服务器端的应用程序进行连接的接口）程序发送一些数据，则必须先与URL建立连接，然后才能对其进行读写，此时需要使用URLConnection。
  10. URLConnection：表示到URL所引用的远程对象的连接。当与一个URL建立连接时，首先要在一个URL 对象上通过方法openConnection() 生成对应的URLConnection对象。如果连接过程失败，将产生IOException.      
  1. 	public Object getContent( ) throws IOException
  2. 	public intgetContentLength( )
  3. 	public String getContentType( )
  4. 	public long getDate( )
  5. 	public long getLastModified( )
  6. 	public InputStreamgetInputStream( )throws IOException
  7. 	public OutputSteramgetOutputStream( )throws IOException 
  8.  
  9.  
  10.  
  11. import java.io.*;
  12. import javax.servlet.ServletException;
  13. import javax.servlet.http.*;
  14.  
  15. public class DataServlet extends HttpServlet {
  16. 	
  17. 	private static final long serialVersionUID = 1L;
  18.  
  19. 	protected void doGet(HttpServletRequest request, HttpServletResponse response)
  20. 		throws ServletException, IOException {
  21. 		System.out.println("doGet方法");
  22. 		dealRequest(request, response);
  23. 	}
  24.  
  25. 	protected void doPost(HttpServletRequest request, HttpServletResponse response)
  26. 		throws ServletException, IOException {
  27. 		System.out.println("doPost方法");
  28. 		dealRequest(request, response);
  29. 	}
  30. 	
  31. 	private void dealRequest(HttpServletRequest request, HttpServletResponse response) 
  32. 		throws ServletException, IOException{
  33. 		String name = request.getParameter("name");
  34. 		name = new String(name.getBytes("ISO-8859-1"), "UTF-8");
  35. //		String message = request.getParameter("message");
  36. //		message = new String(message.getBytes("ISO-8859-1"), "UTF-8");
  37. 		System.out.println(name+":");
  38. 		try {
  39. 			Thread.sleep(1000);
  40. 		} catch (InterruptedException e) {
  41. 			e.printStackTrace();
  42. 		}
  43. 		response.setContentType("text/html;charset=utf-8");
  44. 		PrintWriter printWriter = response.getWriter();
  45. 		printWriter.print("你好客户端");
  46. 		printWriter.flush();
  47. 		printWriter.close();
  48. 	}
  49. }
  50. public class TestURLConnection_1 {
  51.  
  52. 	public static void main(String args[]) {
  53. 		try {
  54. 			URL url = new URL("http://127.0.0.1/URLwangluo/DataServlet");
  55. 			URLConnection urlConnection = url.openConnection();
  56. 			HttpURLConnection httpURLConnection = (HttpURLConnection) urlConnection;
  57. 			httpURLConnection.setConnectTimeout(5000);
  58. 			httpURLConnection.setRequestMethod("POST");
  59. 			httpURLConnection.setDoOutput(true);
  60. 			httpURLConnection.setDoInput(true);
  61. 			httpURLConnection.setUseCaches(false);
  62. 			httpURLConnection.setRequestProperty("accept", "*/*");
  63. 			httpURLConnection.setRequestProperty("connection", "Keep-Alive");
  64. 			httpURLConnection.connect();
  65. 			OutputStream outputStream = httpURLConnection.getOutputStream();
  66. 			outputStream.write("name=你好，服务器".getBytes());
  67. 			outputStream.flush();
  68. 			outputStream.close();
  69. 			int responseCode = httpURLConnection.getResponseCode();
  70. 	        if(responseCode==200){
  71. 	        	InputStream inputStream = httpURLConnection.getInputStream();
  72. 	        	InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
  73. 	        	BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
  74. 				String oneLineData;
  75. 				while ((oneLineData = bufferedReader.readLine()) != null){
  76. 					System.out.println(oneLineData);
  77. 				}
  78. 				bufferedReader.close();
  79. 	        }
  80. 		} catch (Exception e) {
  81. 			e.printStackTrace();
  82. 		}
  83. 	}
  84. }
  85. 中间也可以这样写
  86.  
  87. import java.io.BufferedReader;
  88. import java.io.InputStream;
  89. import java.io.InputStreamReader;
  90. import java.io.OutputStream;
  91. import java.io.PrintWriter;
  92. import java.net.HttpURLConnection;
  93. import java.net.URL;
  94. import java.net.URLConnection;
  95.  
  96. public class TextURLconnection_2 {
  97. 	public static void main(String args[]) {
  98. 		String sendData = "name=你好，客户端";
  99. 		try {
  100. 			// 1、通过在 URL 上调用 openConnection 方法创建连接对象
  101. 			URL url = new URL("http://127.0.0.1/URLwangluo/DataServlet");
  102. 			// 根据URL获取URLConnection对象
  103. 			URLConnection urlConnection = url.openConnection();
  104. 			// 请求协议是HTTP协议，故可转换为HttpURLConnection对象
  105. 			HttpURLConnection httpURLConnection = (HttpURLConnection) urlConnection;
  106. 			// 2、设置参数和一般请求属性
  107. 			// 设置连接超时时间5秒
  108. 			httpURLConnection.setConnectTimeout(5000);
  109. 			// 设定请求的方法为POST，默认是GET
  110. 			httpURLConnection.setRequestMethod("POST");
  111. 			// 请求如果是Post，参数要放在请求体里，所以要向httpURLConnection输出参数
  112. 			httpURLConnection.setDoOutput(true);
  113. 			// 设置是否从httpUrlConnection读入，默认情况下是true;
  114. 			httpURLConnection.setDoInput(true);
  115. 			// 请求如果是Post，不能使用缓存
  116. 			httpURLConnection.setUseCaches(false);
  117. 			// 设置通用的请求属性
  118. 			httpURLConnection.setRequestProperty("accept", "*/*");
  119. 			httpURLConnection.setRequestProperty("connection", "Keep-Alive");
  120. 			// 3、使用 connect 方法建立到远程对象的实际连接
  121. 			httpURLConnection.connect();
  122. 			// 4、远程对象变为可用
  123. 			// 通过HttpURLConnection获取输出输入流:
  124. 			// 向服务器发送数据
  125. 			OutputStream outputStream = httpURLConnection.getOutputStream();
  126. 			PrintWriter printWriter = new PrintWriter(outputStream);
  127.             // 发送请求参数
  128. 			printWriter.print(sendData);
  129.             // flush输出流的缓冲
  130. 			printWriter.flush();
  131. 			printWriter.close();
  132. 			// 响应码 200表示成功
  133. 			int responseCode = httpURLConnection.getResponseCode();
  134. 	        if(responseCode==200){
  135. 	        	// 获取服务器端的响应数据
  136. 	        	InputStream inputStream = httpURLConnection.getInputStream();
  137. 	        	InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
  138. 	        	BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
  139. 				String oneLineData;
  140. 				while ((oneLineData = bufferedReader.readLine()) != null){
  141. 					System.out.println(oneLineData);
  142. 				}
  143. 				bufferedReader.close();
  144. 	        }
  145. 		} catch (Exception e) {
  146. 			e.printStackTrace();
  147. 		}
  148. 	}
  149. }

URI、URL和URN的区别

URI，是uniform resource identifier，统一资源标识符，用来唯一的标识一个资源。而URL是uniform resource locator，统一资源定位符，它是一种具体的URI，即URL可以用来标识一个资源，而且还指明了如何locate这个资源。而URN，uniform resource name，统一资源命名，是通过名字来标识资源，比如mailto:java-net@java.sun.com。也就是说，URI是以一种抽象的，高层次概念定义统一资源标识，而URL和URN则是具体的资源标识的方式。URL和URN都是一种URI。

在Java的URI中，一个URI实例可以代表绝对的，也可以是相对的，只要它符合URI的语法规则。而URL类则不仅符合语义，还包含了定位该资源的信息，因此它不能是相对的。

位于网络中的计算机具有唯一的IP地址，这样不同的主机可以互相区分。

客户端－服务器是一种最常见的网络应用程序模型。服务器是一个为其客户端提供某种特定服务的硬件或软件。客户机是一个用户应用程序，用于访问某台服务器提供的服务。端口号是对一个服务的访问场所，它用于区分同一物理计算机上的多个服务。套接字用于连接客户端和服务器，客户端和服务器之间的每个通信会话使用一个不同的套接字。TCP协议用于实现面向连接的会话。

Java 中有关网络方面的功能都定义在java.net 程序包中。Java 用InetAddress对象表示IP 地址，该对象里有两个字段：主机名(String) 和IP 地址(int)。

类Socket 和ServerSocket实现了基于TCP协议的客户端－服务器程序。Socket是客户端和服务器之间的一个连接，连接创建的细节被隐藏了。这个连接提供了一个安全的数据传输通道，这是因为TCP 协议可以解决数据在传送过程中的丢失、损坏、重复、乱序以及网络拥挤等问题，它保证数据可靠的传送。

类URL 和URLConnection提供了最高级网络应用。URL 的网络资源的位置来同一表示Internet 上各种网络资源。通过URL对象可以创建当前应用程序和URL 表示的网络资源之间的连接，这样当前程序就可以读取网络资源数据，或者把自己的数据传送到网络上去。

端口：

    物理端口：

    逻辑端口：用于标识进程的逻辑地址，不同进程的标识；有效端口：0~65535，其中0~1024系统使用或保留端口。

java 中ip对象：InetAddress.

  1. import java.net.*;
  2. class  IPDemo{
  3. 	public static void main(String[] args) throws UnknownHostException{
  4. 		//通过名称(ip字符串or主机名)来获取一个ip对象。
  5. 		InetAddress ip = InetAddress.getByName ("www.baidu.com"); //java.net.UnknownHostException
  6. 		System.out.println("addr:"+ip.getHostAddress());
  7. 		System.out.println("name:"+ip.getHostName());
  8. 	}
  9. }

java.net. InetAddress类表示互联网协议 (IP) 地址，

该类有如下常用方法：

static InetAddress getLocalHost()：返回本地主机的InetAddress对象。

static InetAddress getByName(String host)：通过主机名（可以是域名，也可以是其 IP 地址的文本表示形式）获得InetAddress对象。

String getHostAddress()：返回字符串类型的IP地址。

  1. import java.net.InetAddress;
  2.  
  3. public class GetIP_0 {
  4. 	public static void main(String args[]) {
  5. 		try {
  6. //获得本地主机的IP地址
  7. 			// 通过InetAddress类的静态方法，返回本地主机对象
  8. 			InetAddress inetAddress = InetAddress.getLocalHost();
  9. 			// 通过InetAddress类的getHostAddress()获得IP地址字符串
  10. 			String hostAddress01 = inetAddress.getHostAddress();
  11. 			System.out.println("本机IP地址为："+hostAddress01);
  12. 			
  13. //获取域名在互联网上的IP地址
  14. 			String domainName = "www.baidu.com";
  15. 			// 通过InetAddress类的静态方法,返回指定域名的IP地址对象
  16. 			InetAddress inetAddress02 = InetAddress.getByName(domainName);
  17. 			// 通过InetAddress类的getHostAddress()获得IP地址字符串
  18. 			String hostAddress02 = inetAddress02.getHostAddress();
  19. 			System.out.println("百度IP地址为："+hostAddress02);
  20. 		} catch (Exception e) {
  21. 			e.printStackTrace();
  22. 		}
  23. 	}
  24. }

Socket：套接字，通信的端点。

就是为网络服务提供的一种机制，通信的两端都有Socket，网络通信其实就是Socket间的通信，数据在两个Socket间通过IO传输。

套接字(Socket)的引入

    为了能够方便的开发网络应用程序,由美国伯克利大学在Unix上实现的一种应用程序访问网络的通信协议Socket，Socket的出现使程序员可以很方便的访问TCP/IP.

网络通信的三要素:

  • IP地址
  • 端口号
  • 通讯协议

    Socket通常也称作“套接字”，应用程序通常通过“套接字”向网络发出请求或者应答网络请求。

    Socket是连接运行在网络上的两个程序间的双向通讯端点

    利用套接字(Socket)开发网络应用程序早已被广泛的采用，以至于成为事实上的标准。

    网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字。

    通信的两端都要有Socket，是两台机器间通信的端点。

    网络通信其实就是Socket间的通信。

      Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。

    一般主动发起通信的应用程序属客户端，等待通信请求的为服务端。

Socket分类：

    流套接字（stream socket）：使用TCP提供可依赖的字节流服务

    数据报套接字（datagram socket）：使用UDP提供“尽力而为”的数据报服务

Socket类的常用构造器：

  1. public Socket(InetAddressaddress,intport)创建一个流套接字并将其连接到指定IP地址的指定端口号。
  2. public Socket(Stringhost,intport)创建一个流套接字并将其连接到指定主机上的指定端口号。

lSocket类的常用方法：

  1. public InputStream getInputStream()返回此套接字的输入流。可以用于接收网络消息
  2. public OutputStream getOutputStream()返回此套接字的输出流。可以用于发送网络消息
  3. public InetAddress getInetAddress()此套接字连接到的远程IP地址；如果套接字是未连接的，则返回null。
  4. public InetAddress getLocalAddress()获取套接字绑定的本地地址。即本端的IP地址
  5. public intgetPort()此套接字连接到的远程端口号；如果尚未连接套接字，则返回0。
  6. public intgetLocalPort()返回此套接字绑定到的本地端口。如果尚未绑定套接字，则返回-1。即本端的端口号。
  7. public void close()关闭此套接字。套接字被关闭后，便不可在以后的网络连接中使用（即无法重新连接或重新绑定）。需要创建新的套接字对象。关闭此套接字也将会关闭该套接字的InputStream和OutputStream。
  8. public void shutdownInput()如果在套接字上调用shutdownInput()后从套接字输入流读取内容，则流将返回EOF（文件结束符）。即不能在从此套接字的输入流中接收任何数据。
  9. public void shutdownOutput()禁用此套接字的输出流。对于TCP套接字，任何以前写入的数据都将被发送，并且后跟TCP的正常连接终止序列。如果在套接字上调用shutdownOutput()后写入套接字输出流，则该流将抛出IOException。即不能通过此套接字的输出流发送任何数据。

UDP传输：

1，只要是网络传输，必须有socket 。

2，数据一定要封装到数据包中，数据包中包括目的地址、端口、数据等信息。

    直接操作udp不可能，对于java语言应该将udp封装成对象，易于我们的使用，这个对象就是DatagramSocket. 封装了udp传输协议的socket对象。

    因为数据包中包含的信息较多，为了操作这些信息方便，也一样会将其封装成对象。这个数据包对象就是：DatagramPacket.通过这个对象中的方法，就可以获取到数据包中的各种信息。

基于UDP的Socket通信过程；

UDP是用户数据报协议

基于UDP的Socket编程是一种非连接的Socket通信，它提供的是无连接、不可靠信息传送服务。

DatagramSocket表示用来发送和接收数据包的套接字

DatagramPacket表示数据包

DatagramSocket具备发送和接受功能，在进行udp传输时，需要明确一个是发送端，一个是接收端。

udp的发送端：客户端

1，建立udp的socket服务，创建对象时如果没有明确端口，系统会自动分配一个未被使用的端口。

2，明确要发送的具体数据。

3，将数据封装成了数据包。

4，用socket服务的send方法将数据包发送出去。

5，关闭资源。

  1. import java.net.*;
  2.  
  3. public class UDPClient {
  4.  
  5. 	public static void main(String args[]){
  6. 		DatagramSocket datagramSocket =  null;
  7. 		try {
  8. 			// 1.创建数据包套接字，端口号9999, 建立udp的socket服务。
  9. 			datagramSocket = new DatagramSocket(9999);
  10. //2，明确要发送的具体数据。
  11. 			byte [] sendData = "你好服务器端".getBytes();
  12. 			// 3.根据主机名和端口号创建套接字地址
  13. 			InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8888);
  14. 			// 4.创建发送的数据包
  15. 			DatagramPacket datagramPacket = new DatagramPacket(sendData, sendData.length, inetSocketAddress);
  16. //5. 发送数据
  17. 			datagramSocket.send(datagramPacket);//
  18. 		} catch (Exception e) {
  19. 			e.printStackTrace();
  20. 		}finally{
  21. 			if(datagramSocket!=null){
  22. //6，关闭资源。
  23. 				datagramSocket.close();// 关闭DatagramSocket
  24. 			}
  25. 		}
  26. 	}
  27. }

udp的接收端：服务端

1，创建udp的socket服务，必须要明确一个端口，作用在于，只有发送到这个端口的数据才是这个接收端可以处理的数据。

2，定义数据包，用于存储接收到数据。

3，通过socket服务的接收方法将收到的数据存储到数据包中。

4，通过数据包的方法获取数据包中的具体数据内容，比如ip、端口、数据等等。

5，关闭资源。

  1. import java.net.*;
  2.  
  3. public class UDPServer {
  4. 	
  5. 	public static void main(String args[]){
  6. 		DatagramSocket datagramSocket = null;
  7. 		try {
  8. 			//1.创建数据报包的套接字，端口号8888
  9. 			datagramSocket = new DatagramSocket(8888);
  10. 			//2，定义数据包，用于存储接收到数据。先定义字节数组，数据包会把数据存储到字节数组中。
  11. 			byte[] bufferArray = new byte[1024];
  12. 			// 创建接收的数据报包
  13. 			DatagramPacket datagramPacket = new DatagramPacket(bufferArray, bufferArray.length);
  14. 			//3，通过socket服务的接收方法将收到的数据存储到数据包中。
  15. 			datagramSocket.receive(datagramPacket);// 接受数据
  16. //		4，通过数据包的方法获取数据包中的具体数据内容，比如ip，端口，数据等等。
  17. 	//	String ip = dp.getAddress().getHostAddress();
  18.  
  19. 			byte [] dataArray = datagramPacket.getData();
  20. 			int validLength = datagramPacket.getLength();
  21. 			String result = new String(dataArray, 0, validLength);// 得到数据
  22. 			System.out.println("服务端："+result);
  23. 		} catch (Exception e) {
  24. 			e.printStackTrace();
  25. 		}finally{
  26. 			if(datagramSocket != null){
  27. //5，关闭资源。
  28. 				datagramSocket.close();// 关闭DatagramSocket
  29. 			}
  30. 		}
  31. 	}
  32. }

TCP传输：

两个端点的建立连接后会有一个传输数据的通道，这通道称为流，而且是建立在网络基础上的流，称之为socket流。该流中既有读取，也有写入。

基于TCP的Socket通信过程

使用TCP/IP的套接字（Socket）进行通信，安全性高。

服务器程序将一个套接字绑定到一个特定的端口，并通过此套接字等待和监听客户端到端口的连接请求。

客户端程序根据服务器程序所在的主机名和端口发出连接请求。

使用ServerSocket和Socket实现服务器端和客户端的Socket通信

tcp的两个端点：一个是客户端，一个是服务端。

客户端：对应的对象，Socket

服务端：对应的对象，ServerSocket

TCP客户端：

1，建立tcp的socket服务，最好明确具体的地址和端口。这个对象在创建时，就已经可以对指定ip和端口进行连接(三次握手)。

2，如果连接成功，就意味着通道建立了，socket流就已经产生了。只要获取到socket流中的读取流和写入流即可，只要通过getInputStream方法获得输入流和getOutputStream方法获得输出流，进行数据传输。

3，按照一定的协议对Socket 进行读/写操作：通过输入流读取服务器放入线路的信息（但不能读取自己放入线路的信息），通过输出流将信息写入线程。

4，关闭Socket：断开客户端到服务器的连接，释放线路

客户端建立socketAtClient对象的过程就是向服务器发出套接字连接请求

  1. import java.io.*;
  2. import java.net.*;
  3.  
  4. public class TcpClient {
  5.  
  6. 	public static void main(String[] args) {
  7. 		try{
  8. 			//连接到服务器端
  9. 			Socket socket = new Socket("localhost",8888);
  10.  
  11. //			//获取Socket连接的输出对象
  12. 			
  13. //			//第一种
  14. 			OutputStream outputStream = socket.getOutputStream();
  15. 			outputStream.write("你好服务器！".getBytes());
  16. 			outputStream.flush();
  17. 			outputStream.close();
  18. 			
  19. 			//第二种		
  20. 			OutputStream outputStream = socket.getOutputStream();
  21. 			DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
  22. 			//客户端向服务器端发送请求的内容
  23. 			dataOutputStream.writeUTF("你好服务器"); 
  24. 			dataOutputStream.close();
  25. 			dataInputStream.close();
  26. 			
  27. 			
  28. 			//获取Socket连接的输入对象
  29. 			//第一种
  30. 			InputStream inputStream = socket.getInputStream();
  31. 			byte[]array=new byte[1024];
  32. 			int arr=0;
  33. 			if((arr=inputStream.read(array))!=-1){
  34. 				System.out.println(new String(array,0,arr));
  35. 			}
  36. 			
  37. 			//第二种		
  38. 			InputStream inputStream = socket.getInputStream();
  39. 			DataInputStream dataInputStream = new DataInputStream(inputStream);
  40. 			String content = null;
  41. 			if((content = dataInputStream.readUTF()) != null){
  42. 				System.err.println(content); 
  43. 			}
  44. 			
  45. 			socket.close();
  46. 		}catch(Exception e){
  47. 			e.printStackTrace();
  48. 		}
  49. 	}
  50. }

TCP服务端：

1，创建服务端socket服务，并监听一个端口。

2，服务端为了给客户端提供服务，获取客户端的内容，可以通过accept方法获取连接过来的客户端对象。

3，可以通过获取到的socket对象中的socket流和具体的客户端进行通讯。

4，如果通讯结束，关闭资源。注意：要先关客户端，再关服务端。

  1. import java.io.*;
  2. import java.net.*;
  3.  
  4. public class TcpServer {
  5.  
  6. 	public static void main(String[] args) {
  7. 		try {
  8. 			//创建服务端套接字
  9. 			ServerSocket serverSocket = new ServerSocket(8888);
  10. 			//监听客户端请求
  11. 			Socket socket = serverSocket.accept();
  12. 			
  13. 			//获取Socket连接的输入对象
  14. 			
  15. 			//第一种
  16. 			InputStream inputStream = socket.getInputStream();
  17. 			byte[]array=new byte[1024];
  18. 			int arr=0;
  19. 			if((arr=inputStream.read(array))!=-1){
  20. 				System.out.println(new String(array,0,arr));
  21. 			}
  22. 			
  23. 			//第二种
  24. 			InputStream inputStream = socket.getInputStream();
  25. 			DataInputStream dataInputStream = new DataInputStream(inputStream);
  26. 			String content = null;
  27. 			//读取来自客户端的数据
  28. 			if ((content = dataInputStream.readUTF()) != null) {
  29. 				System.out.println("客户端输入内容：" + content);
  30. 				System.out.println("客户端IP: "+ socket.getInetAddress().getHostAddress());
  31. 				System.out.println("客户端端口号: " + socket.getPort());
  32. 			}
  33. 			dataInputStream.close();
  34. 			
  35.  
  36. 			//向客户端写入的数据
  37. 			//获取Socket连接的输出对象
  38. 			
  39. 			//第一种
  40. 			OutputStream outputStream = socket.getOutputStream();
  41. 			outputStream.write("你好客户端！".getBytes());
  42. 			outputStream.flush();
  43. 			outputStream.close();
  44. 			
  45. 			//第二种
  46. 			OutputStream outputStream = socket.getOutputStream();
  47. 			DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
  48. 			dataOutputStream.writeUTF("你好客户端！");
  49. 			dataOutputStream.flush();
  50. 			dataOutputStream.close();
  51. 			
  52. 			socket.close();
  53. 		} catch (IOException e) {
  54. 			e.printStackTrace();
  55. 		}
  56. 	}
  57. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/362012
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号