• 网络编程及套接字

    目录

    IP地址

    IP地址介绍

     IP地址的配置和检测

     网络通信协议

     套接字（Socket)

     基于TCP协议的Socket编程

    多线程处理多请求

    UDP数据报

    基于UDP协议的Socket编程 

    相互连接的计算机通过网络进行数据的交换和资源共享

    IP地址

    IP地址介绍

                    计算机之间相互通信，也是需要地址的，即IP地址

            IP地址的组成

            IP地址（Internet Protocol）:唯一标识网络上的每一台计算机

            IP地址：32位，由4个8位二进制组成.IP地址通常用“点分十进制”表示成（a.b.c.d）的形式，其中，a,b,c,d都是0~255之间的十进制整数。例：点分十进IP地址（100.4.5.6），实际上是32位二进制数（01100100.00000100.00000101.00000110）。

            IP地址 = 网络地址 +主机地址

            网络地址：标识计算机或网络设备所在的网段

            主机地址：标识特定主机或网络设备

    分为A,B,C,D,E五类地址

     IP地址的配置和检测

    查看IP地址，检测网络是否畅通

    查看本机的IP地址

    ipconfig

     测试网络是否通畅

    ping  目标IP地址

     网络通信协议

    为了在网络中不同的计算机之间进行通信而建立的规则、标准或约定的集合

     

     套接字（Socket)

            网络通信使用IP地址标识Internet.上的计算机,使用端口号标识服务器上的进程(程序)。也就是说，如果服务器上的一个程序不占用-一个端口号，用户程序就无法找到它，就无法和该程序交互信息。端口号规定为一个16位的0~ -65535之间的整数，其中，0~1023 被预先定义的服务通信占用(如telnet占用端口23，http 占用端口80等)，除非需要访问这些特定服务，否则，就应该使用1024 -65535这些端口中的某一个进行通信，以免发生端口冲突。

            当两个程序需要通信时，它们可以通过使用Socket类建立套接字对象并连接在一起(端口号与IP地址的组合得出一个网络套接字)

            通信链路的端点就被称为“套接字”（英文名Socket） 是提供给应用程序的接口

            进行网络编程的类在java.net包

     基于TCP协议的Socket编程

                    基于TCP协议的Socket网络通信

                            用来实现双向安全连接网络通信

                    Socket通信模型

                            进行网络通信时，Socket需要借助数据流来完成数据的传递工作

    Socket网络编程一般可以分成如下步骤进行 

     

    网络编程模型：客户端/服务器（C/S）

    客户端与服务器端运作过程：

    客户端通过输出流将请求信息发送给服务器端
    服务器端通过输入流读取客户端的请求信息
    服务器端通过输出流将响应信息发送给客户端
    客户端通过输入流读取服务器端的响应信息 

    1. package demo01;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.IOException;
    5. import java.io.InputStream;
    6. import java.io.InputStreamReader;
    7. import java.io.OutputStream;
    8. import java.net.Socket;
    9. import java.net.UnknownHostException;
    10.  
    11. public class Client {
    12.  
    13. 	public static void main(String[] args) {
    14. 		//创建通信链路的端点客户端套接字
    15. 		Socket socket  = null;
    16. 		OutputStream os = null;
    17. 		InputStream is =null;
    18. 		BufferedReader br =null;
    19. 		try {
    20. 			socket  = new Socket("127.0.0.1", 10088);
    21. 			//获取输出流将数据发送出去
    22. 			os =socket.getOutputStream();
    23. 			String str = "用户名：张三，密码：123456";
    24. 			byte[] bytes=str.getBytes();
    25. 			
    26. 			//通过输出流调用方法将信息发送出去
    27. 			os.write(bytes);
    28. 			System.out.println("我是客户端，我将数据发送完毕");
    29. 			//关闭通道
    30. 			socket.shutdownOutput();
    31. 			
    32. 			//客户端需要通过输入流读取服务器端发送过来的消息
    33. 			is =socket.getInputStream();
    34. 			br = new BufferedReader(new InputStreamReader(is));
    35. 			String result =br.readLine();
    36. 			System.out.println("我是客户端，接收到的服务器端响应信息为："+result);
    37. 			
    38. 		} catch (UnknownHostException e) {
    39. 			e.printStackTrace();
    40. 		} catch (IOException e) {
    41. 			e.printStackTrace();
    42. 		}finally{
    43. 			try {
    44. 				br.close();
    45. 				is.close();
    46. 				os.close();
    47. 				socket.close();
    48. 			} catch (IOException e) {
    49. 				e.printStackTrace();
    50. 			}
    51. 		}
    52. 	}
    53.  
    54. }

     

    1. package demo01;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.IOException;
    5. import java.io.InputStream;
    6. import java.io.InputStreamReader;
    7. import java.io.OutputStream;
    8. import java.net.ServerSocket;
    9. import java.net.Socket;
    10.  
    11. public class Server {
    12.  
    13. 	public static void main(String[] args) {
    14. 		//创建服务器端套接字ServerSocket
    15. 		ServerSocket ss = null;
    16. 		Socket socket =null;
    17. 		InputStream is =null;
    18. 		BufferedReader br =null;
    19. 		OutputStream os =null;
    20. 		try {
    21. 			ss = new ServerSocket(10088);
    22. 			//服务器通过调用侦听方法来获取客户端的请求
    23. 			socket =ss.accept();
    24. 			//通过返回的Socket对象调用方法获取一个输入流来读取客户端发送过来的消息
    25. 			is =socket.getInputStream();
    26. 			//通过 输入流读取客户端发送的消息
    27. 			br = new BufferedReader(new InputStreamReader(is));
    28. 			String str =br.readLine();
    29. 			System.out.println("我这边是服务器：客户端发送给我的数据是："+str);
    30. 			socket.shutdownInput();
    31. 			
    32. 			//服务器接收客户端消息后，需要给客户端一个响应信息
    33. 			os =socket.getOutputStream();
    34. 			String result = "用户名和密码正确，可以登录";
    35. 			byte[] bytes = result.getBytes();
    36. 			os.write(bytes);
    37. 			System.out.println("给客户端的响应信息发送成功");
    38. 			
    39. 		} catch (IOException e) {
    40. 			e.printStackTrace();
    41. 		}finally{
    42. 			try {
    43. 				os.close();
    44. 				br.close();
    45. 				is.close();
    46. 				socket.close();
    47. 				ss.close();
    48. 			} catch (IOException e) {
    49. 				
    50. 				e.printStackTrace();
    51. 			}
    52. 		}
    53.  
    54. 	}
    55.  
    56. }

    多线程处理多请求

            实现多客户请求

                    采用多线程的方式

                    一个专门负责监听的应用主服务程序

                    一个专门负责处理请求的线程程序

    客户端和服务端如何做

    客户端跟之前客户端做的事情没有任何改变
    客户端通过输出流发送请求信息
    客户端通过输入流获取服务器端的响应信息


    服务器端做的事情跟之前服务器端做的事情不一样
    服务器端循环去侦听客户端的请求，侦听到一个请求就会获取一个Socket类对象，将这个Socket类对象作为参数传递给服务器线程类的有参构造方法里去
    服务器线程类通过获取到的Socket类对象去执行原来服务器所做的事情
    通过输入流获取客户端的请求信息
    通过输出流发送响应信息给客户端

    服务器端

    1. package demo03;
    2.  
    3. import java.io.IOException;
    4. import java.net.ServerSocket;
    5. import java.net.Socket;
    6.  
    7. public class Server {
    8.  
    9. 	public static void main(String[] args) {
    10. 		
    11. 		//创建ServerSocket类对象
    12. 		ServerSocket ss =null;
    13. 		Socket socket =null;
    14. 		try {
    15. 			ss = new ServerSocket(10088);
    16. 			while(true){
    17. 				socket =ss.accept();
    18. 				//将获取到的socket对象传递到线程类中
    19. 				ServerThread st = new ServerThread(socket);
    20. 				st.start();
    21. 			}
    22. 		} catch (IOException e) {
    23. 			e.printStackTrace();
    24. 		}finally{
    25. 			try {
    26. 				ss.close();
    27. 			} catch (IOException e) {
    28. 				e.printStackTrace();
    29. 			}
    30. 		}
    31.  
    32. 	}
    33.  
    34. }

    多个客户端

    1. package demo03;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.IOException;
    5. import java.io.InputStream;
    6. import java.io.InputStreamReader;
    7. import java.io.ObjectOutputStream;
    8. import java.io.OutputStream;
    9. import java.net.Socket;
    10. import java.net.UnknownHostException;
    11.  
    12. public class Client1 {
    13.  
    14. 	public static void main(String[] args) {
    15.  
    16. 		//创建通信链路的端点客户端套接字
    17. 		Socket socket  = null;
    18. 		OutputStream os = null;
    19. 		ObjectOutputStream oos =null;
    20. 		InputStream is =null;
    21. 		BufferedReader br =null;
    22. 		try {
    23. 			socket  = new Socket("127.0.0.1", 10088);
    24. 			//获取输出流将数据发送出去
    25. 			os =socket.getOutputStream();
    26. 			//准备Student类对象
    27. 			Student stu = new Student("张三",19);
    28. 			
    29. 			oos = new ObjectOutputStream(os);
    30. 			oos.writeObject(stu);
    31. 			
    32. 			System.out.println("我是客户端1，我将数据发送完毕");
    33. 			//关闭通道
    34. 			socket.shutdownOutput();
    35. 			
    36. 			//客户端需要通过输入流读取服务器端发送过来的消息
    37. 			is =socket.getInputStream();
    38. 			br = new BufferedReader(new InputStreamReader(is));
    39. 			String result =br.readLine();
    40. 			System.out.println("我是客户端1，接收到的服务器端响应信息为："+result);
    41. 			
    42. 		} catch (UnknownHostException e) {
    43. 			e.printStackTrace();
    44. 		} catch (IOException e) {
    45. 			e.printStackTrace();
    46. 		}finally{
    47. 			try {
    48. 				br.close();
    49. 				is.close();
    50. 				oos.close();
    51. 				os.close();
    52. 				socket.close();
    53. 			} catch (IOException e) {
    54. 				e.printStackTrace();
    55. 			}
    56. 		}
    57. 	
    58. 	}
    59.  
    60. }
    1. package demo03;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.IOException;
    5. import java.io.InputStream;
    6. import java.io.InputStreamReader;
    7. import java.io.ObjectOutputStream;
    8. import java.io.OutputStream;
    9. import java.net.Socket;
    10. import java.net.UnknownHostException;
    11.  
    12. public class Client2 {
    13.  
    14. 	public static void main(String[] args) {
    15.  
    16. 		//创建通信链路的端点客户端套接字
    17. 		Socket socket  = null;
    18. 		OutputStream os = null;
    19. 		ObjectOutputStream oos =null;
    20. 		InputStream is =null;
    21. 		BufferedReader br =null;
    22. 		try {
    23. 			socket  = new Socket("127.0.0.1", 10088);
    24. 			//获取输出流将数据发送出去
    25. 			os =socket.getOutputStream();
    26. 			//准备Student类对象
    27. 			Student stu = new Student("李四",22);
    28. 			
    29. 			oos = new ObjectOutputStream(os);
    30. 			oos.writeObject(stu);
    31. 			
    32. 			System.out.println("我是客户端2，我将数据发送完毕");
    33. 			//关闭通道
    34. 			socket.shutdownOutput();
    35. 			
    36. 			//客户端需要通过输入流读取服务器端发送过来的消息
    37. 			is =socket.getInputStream();
    38. 			br = new BufferedReader(new InputStreamReader(is));
    39. 			String result =br.readLine();
    40. 			System.out.println("我是客户端2，接收到的服务器端响应信息为："+result);
    41. 			
    42. 		} catch (UnknownHostException e) {
    43. 			e.printStackTrace();
    44. 		} catch (IOException e) {
    45. 			e.printStackTrace();
    46. 		}finally{
    47. 			try {
    48. 				br.close();
    49. 				is.close();
    50. 				oos.close();
    51. 				os.close();
    52. 				socket.close();
    53. 			} catch (IOException e) {
    54. 				e.printStackTrace();
    55. 			}
    56. 		}
    57. 	
    58. 	}
    59.  
    60. }

     

    1. package demo03;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.IOException;
    5. import java.io.InputStream;
    6. import java.io.InputStreamReader;
    7. import java.io.ObjectOutputStream;
    8. import java.io.OutputStream;
    9. import java.net.Socket;
    10. import java.net.UnknownHostException;
    11.  
    12. public class Client3 {
    13.  
    14. 	public static void main(String[] args) {
    15.  
    16. 		//创建通信链路的端点客户端套接字
    17. 		Socket socket  = null;
    18. 		OutputStream os = null;
    19. 		ObjectOutputStream oos =null;
    20. 		InputStream is =null;
    21. 		BufferedReader br =null;
    22. 		try {
    23. 			socket  = new Socket("127.0.0.1", 10088);
    24. 			//获取输出流将数据发送出去
    25. 			os =socket.getOutputStream();
    26. 			//准备Student类对象
    27. 			Student stu = new Student("如花",16);
    28. 			
    29. 			oos = new ObjectOutputStream(os);
    30. 			oos.writeObject(stu);
    31. 			
    32. 			System.out.println("我是客户端3，我将数据发送完毕");
    33. 			//关闭通道
    34. 			socket.shutdownOutput();
    35. 			
    36. 			//客户端需要通过输入流读取服务器端发送过来的消息
    37. 			is =socket.getInputStream();
    38. 			br = new BufferedReader(new InputStreamReader(is));
    39. 			String result =br.readLine();
    40. 			System.out.println("我是客户端3，接收到的服务器端响应信息为："+result);
    41. 			
    42. 		} catch (UnknownHostException e) {
    43. 			e.printStackTrace();
    44. 		} catch (IOException e) {
    45. 			e.printStackTrace();
    46. 		}finally{
    47. 			try {
    48. 				br.close();
    49. 				is.close();
    50. 				oos.close();
    51. 				os.close();
    52. 				socket.close();
    53. 			} catch (IOException e) {
    54. 				e.printStackTrace();
    55. 			}
    56. 		}
    57. 	
    58. 	}
    59.  
    60. }

    UDP数据报

            套接字是基于TCP协议的网络通信，即客户端程序和服务器端程序是有 连接的，双方的信息是通过程序中的输入、输出流来交互的，使得接收方收到信息的顺序和发送方发送信息的顺序完全相同，就像生活中双方使用电话进行信息交互一样。

            本节介绍Java中基于UDP (用户数据报协议)协议的网络信息传输方式。基于UDP的通信和基于TCP的通信不同，基于UDP的信息传递更快，但不提供可靠性保证。也就是说,数据在传输时，用户无法知道数据能否正确到达目的地主机，也不能确定数据到达目的地的顺序是否和发送的顺序相同。可以把UDP通信比作生活中的邮递信件，我们不能肯定所发的信件就一定能够到达目的地，也不能肯定到达的顺序是发出时的顺序，可能因为某种原因导致后发出的先到达。既然UDP是一种不可靠的协议，为什么还要使用它呢?如果要求数据必须绝对准确地到达目的地，显然不能选择UDP协议来通信。但有时候人们需要较快速地传输信息，并能容忍小的错误，就可以考虑使用UDP协议。

            基于UDP通信的基本模式是:

                    将数据打包(好比将信件装入信封一-样)，称为数据包，然后将数据包发往目的地。

                    接收发来的数据包(好比接收信封一样)，然后查看数据包中的内容。

    基于UDP协议的Socket编程 

            基于UDP协议的Socket网络编程步骤

                    利用 DatagramPacket 对象封装数据包

                    利用 DatagramSocket 发送数据包

                    利用 DatagramSocket 接收数据包

                    利用 DatagramPacket 处理数据包

    1. package demo04;
    2.  
    3. import java.io.IOException;
    4. import java.net.DatagramPacket;
    5. import java.net.DatagramSocket;
    6. import java.net.SocketAddress;
    7. import java.net.SocketException;
    8.  
    9. /**
    10.  * 服务器端
    11.  * */
    12. public class LoginServer {
    13. 	public static void main(String[] args) {
    14. 		byte[] infos=new byte[1024];
    15. 		DatagramPacket dp=new DatagramPacket(infos, infos.length);
    16. 		DatagramSocket socket=null;
    17. 		try {
    18. 			socket=new DatagramSocket(5000);
    19. 			//接收客户端的数据包，并将信息封装在dp中
    20. 			socket.receive(dp);
    21. 			
    22. 			//构建一个字符串
    23. 			String info=new String(dp.getData(),0,dp.getData().length);
    24. 			System.out.println("客户端说："+info);
    25. 			
    26. 			//给客户端一个响应
    27. 			String reply="您好，我在，请说！";
    28. 			//客户端的地址
    29. 			SocketAddress sa=dp.getSocketAddress();
    30. 			//打一个包裹
    31. 			DatagramPacket dp1=
    32. 					new DatagramPacket(reply.getBytes(),0,reply.getBytes().length,sa);
    33. 			//将包裹寄走
    34. 			socket.send(dp1);
    35. 		} catch (SocketException e) {
    36. 			e.printStackTrace();
    37. 		} catch (IOException e) {
    38. 			e.printStackTrace();
    39. 		}finally{
    40. 			socket.close();
    41. 		}
    42. 		
    43. 	}
    44. }

     

    1. package demo04;
    2.  
    3. import java.io.IOException;
    4. import java.net.DatagramPacket;
    5. import java.net.DatagramSocket;
    6. import java.net.InetAddress;
    7. import java.net.SocketException;
    8. import java.net.UnknownHostException;
    9.  
    10. /*
    11.  * 客户端
    12.  * */
    13. public class LoginClient {
    14. 	public static void main(String[] args) {
    15. 		String info="您好，我想咨询一个问题！";
    16. 		byte[] infos=info.getBytes();
    17. 		DatagramSocket socket=null;
    18. 		try {
    19. 			InetAddress ia=InetAddress.getByName("localhost");
    20. 			//构建客户端要发送的数据包对象
    21. 			DatagramPacket dp=new DatagramPacket(infos, infos.length,ia,5000);
    22. 			//客户端需要一个DatagramSocket对象
    23. 			socket=new DatagramSocket();
    24. 			//通过DatagramSocket对象发送数据包到服务器
    25. 			socket.send(dp);
    26. 			
    27. 			//接收服务器的响应
    28. 			byte[] replys=new byte[1024];
    29. 			DatagramPacket dp1=new DatagramPacket(replys, replys.length);
    30. 			socket.receive(dp1);
    31. 			String reply=new String(dp1.getData(),0,dp1.getData().length);
    32. 			System.out.println("服务器回应："+reply);
    33. 		} catch (UnknownHostException e) {
    34. 			e.printStackTrace();
    35. 		} catch (SocketException e) {
    36. 			e.printStackTrace();
    37. 		} catch (IOException e) {
    38. 			e.printStackTrace();
    39. 		}finally{
    40. 			//释放资源
    41. 			socket.close();
    42. 		}
    43.  
    44. 	}
    45. }

     TCP与UDP的主要区别：

    TCP

    UDP

    是否连接

    面向连接

    面向非连接

    传输可靠性

    可靠

    不可靠

    速度

    慢

    快

  • 相关阅读:
    [Python]多态、类方法、类属性
    清华陆向谦教授提到的纽约时报的一篇文章-探讨学历贬值
    宝塔上创建站点
    虚函数表和虚函数指针
    使用大数据分析建立电力企业用户画像的一种思路
    【GDB】使用 GDB 自动画红黑树
    8年经验之谈 —— 记一次接口压力测试与性能调优！
    Laravel系列开源Dcat admin礼盒商城后台管理项目
    c语言实现数据结构中的单向链表
    【C语言】动态内存管理
  • 原文地址：https://blog.csdn.net/qq_51810428/article/details/126505039