Java——TCP UDP Socket编程

蔚落 2023-10-11 22:03 110阅读 0赞

目录

一、网络的相关概念

（一）网络通信

（二）网络

（三）ip地址

（四）ipv4地址分类

（五）域名

（六）网络通信协议

（七）TCP和UDP

二、InetAddress类

三、Socket

四、TCP网络编程

（一）案例一——使用字节流

（二）案例二——使用字节流

（三）案例三——使用字符流

（四）案例四——使用字符流

五、UDP网络编程

（一）基本介绍

（二）基本流程

（三）案例

六、案例

（一）案例一

（二）案例二

一、网络的相关概念

（一）网络通信

1.概念:两台设备之间通过网络实现数据传输

2.网络通信:将数据通过网络从一台设备传输到另一台设备

3.java.net包下提供了一系列的类或接口，供程序员使用，完成网络通信

0801677fc7bc48e9b63e8b18c99b6145.png

（二）网络

1.概念:两台或多台设备通过一定物理设备连接起来构成了网络
2.根据网络的覆盖范围不同，对网络进行分类:

  • 局域网: 覆盖范围最小，仅仅覆盖一个教室或一个机房
  • 城域网:覆盖范围较大，可以覆盖一个城市
  • 广域网:覆盖范围最大，可以覆盖全国，甚至全球，万维网是广域网的代表

d3d57999c7a94a8685929f0926951736.png

（三）ip地址

1.概念: 用于唯一标识网络中的每台计算机/主机

2.查看ip地址: ipconfig

3.ip地址的表示形式:点分十进制 xx.xx.xx.xx

4.每一个十进制数的范围: 0~255
5.ip地址的组成=网络地址+主机地址，比如: 192.168.16.69

6.lPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称可以为全世界的每一粒沙子编上一个地址

7.由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联网的障碍

（四）ipv4地址分类

4a23414cd18c4ea28aa0cfc317bcea8e.png

1ad2a809c878418280fde4470b509e9b.png

（五）域名

1.比如www.baidu.com，将ip映射到域名上，访问域名就是访问ip
2.好处:为了方便记忆，解决记ip的困难

端口号

1.概念: 用于标识计算机上某个特定的网络程序

2.表示形式: 以整数形式，端口范围0~65535 [2个字节表示端口 0~2^16-1]

3.0~1024已经被占用, 比如 ssh 22, ftp 21, smtp 25 http 80

4.常见的网络程序端口号:

  • tomcat :8080
  • mysql:3306
  • oracle:1521
  • sqlserver:1433

（六）网络通信协议

e3d174a10c46473e8baba43f1d77f6b3.png

协议(tcp/ip)

TCP/IP (Transmission Control Protocol/Internet Protocol)的简写, 中文译名为传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是Internet最基本的协议、Internet国际互联网络的基础，简单地说，就是由网络层的IP协议和传输层的TCP协议组成的。

29aed2f4e7da45e189843338158c0db6.png

（七）TCP和UDP

TCP协议: 传输控制协议
1.使用TCP协议前，须先建立TCP连接，形成传输数据通道

2.传输前，采用“三次握手“方式，是可靠的

3.TCP协议进行通信的两个应用进程: 客户端、服务端

4.在连接中可进行大数据量的传输

5.传输完毕，需释放已建立的连接，效率低

UDP协议: 用户数据协议
1.将数据、源、目的封装成数据包，不需要建立连接

2.每个数据报的大小限制在64K内,不适合传输大量数据

3.因无需连接，故是不可靠的

4.发送数据结束时无需释放资源(因为不是面向连接的)，速度快

5.举例: 发短信

二、InetAddress类

方法：

  1. 获取本机InetAddress对象 getLocalHost
  2. 根据指定主机名/域名获取ip地址对象 getByName
  3. 获取InetAddress对象的主机名 getHostName

  4. 获取InetAddress对象的地址 getHostAddress

    /*

    • 演示InetAddress类的使用
      */
      public class API_ {
      public static void main(String[] args) throws UnknownHostException {

      1.  // 1.获取本机的InetAddress对象
      2.  InetAddress localHost = InetAddress.getLocalHost();
      3.  System.out.println(localHost); // LAPTOP-RVFFB7FM/192.168.23.1
      5.  // 2.根据机器的名字获取InetAddress对象
      6.  InetAddress inetAddress = InetAddress.getByName("LAPTOP-RVFFB7FM");
      7.  System.out.println(inetAddress);
      9.  // 3.根据域名返回InetAddress对象，比如www.baidu.com
      10.  InetAddress inetAddress1 = InetAddress.getByName("www.baidu.com");
      11.  System.out.println(inetAddress1);
      13.  // 4.根据InetAddress对象，获取对应的ip地址
      14.  String address = inetAddress1.getHostAddress();
      15.  System.out.println(address);
      17.  // 5.通过InetAddress对象，获取对应的主机名
      18.  String hostName = inetAddress1.getHostName();
      19.  System.out.println(hostName);

      }
      }

三、Socket

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

2.通信的两端都要有Socket，是两台机器间通信的端点，网络通信其实就是Socket间的通信

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

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

f03d4c9f9623420ba97aa23601e21199.png

四、TCP网络编程

1.基于客户端一服务端的网络通信， 底层使用的是TCP/IP协议

2.应用场景举例: 客户端发送数据，服务端接受并显示控制台

3.基于Socket的TCP编程

" class="reference-link">7394faf1f6324c589ce194bc9908943c.png

（一）案例一——使用字节流

115f44a7fa3744d2abcb2db4669369c7.png

服务端

  1. public class SocketTCP01Server {
  2.     public static void main(String[] args) throws IOException {
  3.         // 1.在9999端口监听，等待链接
  4.         //  细节：要求该端口没有其他人监听
  5.         ServerSocket serverSocket = new ServerSocket(9999);
  7.         System.out.println("服务端，在9999端口监听，等待连接...");
  8.         // 2.如果没有客户端连接9999端口，该方法会阻塞等待连接
  9.         // 如果有连接，返回一个socket
  10.         Socket socket = serverSocket.accept();
  12.         System.out.println(socket.getClass());
  13.         // 3.通过socket.getInputStream() 读取
  14.         // 客户端写入到数据通道的数据，显示
  15.         InputStream inputStream = socket.getInputStream();
  16.         byte[] bytes = new byte[1024];
  17.         int readLen = 0;
  18.         while((readLen = inputStream.read(bytes)) != -1) {
  19.             System.out.println(new String(bytes, 0, readLen));
  20.         }
  21.         // 4.关闭流
  22.         inputStream.close();
  23.         socket.close();
  24.         serverSocket.close();
  25.         System.out.println("服务端退出...");
  27.     }
  28. }

客户端

  1. public class SocketTCP01Client {
  2.     public static void main(String[] args) throws IOException {
  3.         // 1.连接9999端口，连接成功返回一个socket
  4.         Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
  5.         // 2.连接上后，生成socket，通过socket.getOutputStream()
  6.         OutputStream outputStream = socket.getOutputStream();
  7.         // 3.输出信息
  8.         outputStream.write("hello, socket".getBytes());
  9.         // 4.关闭流和连接，节省资源
  10.         outputStream.close();
  11.         socket.close();
  12.         System.out.println("客户端退出...");
  13.     }
  14. }

（二）案例二——使用字节流

78b5cc2e907c49a8abb96476b3f91c54.png

服务端

  1. public class SocketTCP02Server {
  2.     public static void main(String[] args) throws Exception {
  3.         ServerSocket serverSocket = new ServerSocket(9999);
  4.         Socket socket = serverSocket.accept();
  6.         InputStream inputStream = socket.getInputStream();
  7.         byte[] buf = new byte[1024];
  8.         int readLen = 0;
  9.         while((readLen = inputStream.read(buf)) != -1) {
  10.             System.out.println(new String(buf, 0, readLen));
  11.         }
  13.         OutputStream outputStream = socket.getOutputStream();
  14.         outputStream.write("hello Client".getBytes());
  15.         // 设置结束标记
  16.         socket.shutdownOutput();
  17.         outputStream.close();
  18.         inputStream.close();
  19.         socket.close();
  20.         serverSocket.close();
  21.     }
  22. }

客户端

  1. public class SocketTCP02Client {
  2.     public static void main(String[] args) throws Exception{
  3.         Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
  4.         OutputStream outputStream = socket.getOutputStream();
  5.         outputStream.write("hello Server".getBytes());
  6.         // 设置结束标记, socket.close()也做了同样的事情
  7.         // 但是因为我们下面还有获取数据通道信息，因此不能关闭，只能shutdownOutput()
  8.         socket.shutdownOutput();
  9.         InputStream inputStream = socket.getInputStream();
  10.         byte[] buf = new byte[1024];
  11.         int readLen = 0;
  12.         while((readLen = inputStream.read(buf)) != -1) {
  13.             System.out.println(new String(buf, 0, readLen));
  14.         }
  16.         outputStream.close();
  17.         inputStream.close();
  18.         socket.close();
  19.     }
  20. }

（三）案例三——使用字符流

015bdf5a17ae436eb590cf67280f573a.png

服务端

  1. public class SocketTCP03Server {
  2.     public static void main(String[] args) throws Exception {
  3.         ServerSocket serverSocket = new ServerSocket(9999);
  4.         Socket socket = serverSocket.accept();
  6.         InputStream inputStream = socket.getInputStream();
  7.         // IO读取，使用字符流输入，使用InputStreamReader将InputStream转化为字符流
  8.         BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
  9.         String s = reader.readLine();
  10.         System.out.println(s);
  12.         // 字符流方式的输出
  13.         OutputStream outputStream = socket.getOutputStream();
  14.         BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream));
  15.         writer.write("hello Client 字符流");
  16.         writer.newLine(); // 插入一个换行符，代表写入的内容结束
  17.         writer.flush(); // 字符流需要手动刷新，否则数据不会写入数据通道
  19.         reader.close();
  20.         writer.close();
  21.         socket.close();
  22.         serverSocket.close();
  23.     }
  24. }

客户端

  1. public class SocketTCP03Client {
  2.     public static void main(String[] args) throws Exception{
  3.         Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
  4.         OutputStream outputStream = socket.getOutputStream();
  5.         // 通过输出流，转换为字符流
  6.         BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream));
  7.         writer.write("hello Server 字符流");
  8.         writer.newLine(); // 插入一个换行符，代表写入的内容结束
  9.         writer.flush(); // 字符流需要手动刷新，否则数据不会写入数据通道
  12.         InputStream inputStream = socket.getInputStream();
  13.         BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
  14.         String s = reader.readLine();
  15.         System.out.println(s);
  17.         reader.close();
  18.         writer.close();
  19.         socket.close();
  20.         System.out.println("客户端退出...");
  21.     }
  22. }

（四）案例四——使用字符流

07e3b7d2ac704f16a1d6ab8e0bd38c06.png

StreamUtils

  1. /**
  2.  * 此类用于演示关于流的读写方法
  3.  *
  4.  */
  5. public class StreamUtils {
  6.     /**
  7.      * 功能：将输入流转换成byte[]， 即可以把文件的内容读入到byte[]
  8.      * @param is
  9.      * @return
  10.      * @throws Exception
  11.      */
  12.     public static byte[] streamToByteArray(InputStream is) throws Exception{
  13.         ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
  14.         byte[] b = new byte[1024];//字节数组
  15.         int len;
  16.         while((len=is.read(b))!=-1){//循环读取
  17.             bos.write(b, 0, len);//把读取到的数据，写入bos    
  18.         }
  19.         byte[] array = bos.toByteArray();//然后将bos 转成字节数组
  20.         bos.close();
  21.         return array;
  22.     }
  23.     /**
  24.      * 功能：将InputStream转换成String
  25.      * @param is
  26.      * @return
  27.      * @throws Exception
  28.      */
  30.     public static String streamToString(InputStream is) throws Exception{
  31.         BufferedReader reader = new BufferedReader(new InputStreamReader(is));
  32.         StringBuilder builder= new StringBuilder();
  33.         String line;
  34.         while((line=reader.readLine ())!=null){
  35.             builder.append(line+"\r\n");
  36.         }
  37.         return builder.toString();
  39.     }
  41. }

服务端

  1. public class TCPFileUploadServer {
  2.     public static void main(String[] args) throws Exception {
  3.         ServerSocket serverSocket = new ServerSocket(8888);
  4.         // 等待连接
  5.         Socket socket = serverSocket.accept();
  6.         InputStream inputStream = socket.getInputStream();
  7.         BufferedInputStream bis = new BufferedInputStream(inputStream);
  8.         byte[] bytes = StreamUtils.streamToByteArray(bis);
  9.         String destFilePath = "src\\a.jpg";
  10.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
  11.         bos.write(bytes);
  12.         bos.close();
  13.         // 向客户端回复“收到图片”
  14.         BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
  15.         writer.write("收到图片");
  16.         writer.flush();
  17.         writer.close();
  18.         bis.close();
  19.         socket.close();
  20.     }
  21. }

客户端

  1. public class TCPFileUploadClient {
  2.     public static void main(String[] args) throws  Exception{
  3.         // 客户端连接服务端8888端口，得到socket对象
  4.         Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
  5.         // 读取本地的文件转换为字节数组
  6.         String filePath = "D:\\image\\a.jpg";
  7.         FileInputStream fileInputStream = new FileInputStream(filePath);
  8.         BufferedInputStream bis = new BufferedInputStream(fileInputStream);
  9.         // 该字节数组就是文件
  10.         byte[] bytes = StreamUtils.streamToByteArray(bis);
  11.         OutputStream outputStream = socket.getOutputStream();
  12. //        outputStream.write(bytes);
  13.         BufferedOutputStream bos = new BufferedOutputStream(outputStream);
  14.         bos.write(bytes);
  16.         socket.shutdownOutput(); // 写入数据的结束标记
  17.         BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  18.         String s = reader.readLine();
  19.         System.out.println(s);
  20.         reader.close();
  21.         bos.close();
  22.         bis.close();
  23.         socket.close();
  24.     }
  25. }

五、UDP网络编程

（一）基本介绍

1.类 DatagramSocket 和 DatagramPacket[数据包/数据报]实现了基于 UDP协议网络程序。

2.UDP数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。

3.DatagramPacket 对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。

4.UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接

（二）基本流程

1.核心的两个类/对象 DatagramSocket与DatagramPacket

2.建立发送端，接收端(没有服务端和客户端概念)

3.发送数据前，建立数据包/报 DatagramPacket对象

4.调用DatagramSocket的发送、接收方法

5.关闭DatagramSocket

（三）案例

d61c0496278d4607b98fe4afbbbddada.png

发送端

  1. public class UDPSenderB {
  2.     public static void main(String[] args) throws Exception{
  3.         // 1.创建一个DatagramSocket，监听9998端口
  4.         DatagramSocket socket = new DatagramSocket(9998);
  5.         // 2.创建DatagramPacket，接收数据
  6.         byte[] data = "你好，明天吃火锅".getBytes();
  7.         DatagramPacket packet = new DatagramPacket(data, 0, data.length, InetAddress.getByName("192.168.23.1"), 9999);
  8.         // 3.发送数据
  9.         socket.send(packet);
  11.         // 接收消息
  12.         data = new byte[1024];
  13.         packet = new DatagramPacket(data, data.length);
  14.         socket.receive(packet);
  15.         int length = packet.getLength();
  16.         data = packet.getData();
  17.         String msg = new String(data, 0, length);
  18.         System.out.println(msg);
  19.         // 4.关闭资源
  20.         socket.close();
  21.     }
  22. }

接收端

  1. public class UDPReceiverA {
  2.     public static void main(String[] args) throws Exception{
  3.         // 1.创建一个DatagramSocket对象，监听9999端口
  4.         DatagramSocket socket = new DatagramSocket(9999);
  5.         // 2.构建一个DatagramPacket，准备接受数据
  6.         byte[] data = new byte[1024];
  7.         DatagramPacket packet = new DatagramPacket(data, data.length);
  8.         // 3.接收数据，如果没有数据则堵塞，接收到的数据存放在packet中
  9.         System.out.println("接收端A等待接收数据...");
  10.         socket.receive(packet);
  11.         // 4.接收完数据转化为String并输出
  12.         int length = packet.getLength();
  13.         data = packet.getData();
  14.         String msg = new String(data, 0, length);
  15.         System.out.println(msg);
  17.         // 回复消息
  18.         data = "好的，明天见".getBytes();
  19.         packet = new DatagramPacket(data, 0, data.length, InetAddress.getByName("192.168.23.1"), 9998);
  20.         socket.send(packet);
  21.         // 5.关闭资源
  22.         socket.close();
  24.     }
  25. }

六、案例

（一）案例一

849db202f4eb4f6297241e65faed2f11.png

服务端

  1. public class HomeWork01Server {
  2.     public static void main(String[] args) throws Exception{
  3.         System.out.println("服务器等待接收消息...");
  5.         DatagramSocket socket = new DatagramSocket(9999);
  6.         byte[] data = new byte[1024];
  7.         DatagramPacket packet = new DatagramPacket(data, data.length);
  8.         socket.receive(packet);
  10.         int length = packet.getLength();
  11.         data = packet.getData();
  12.         String msg = new String(data, 0, length);
  13.         System.out.println(msg);
  14.         String returnMsg = "";
  15.         if("name".equals(msg)) {
  16.             returnMsg = "我是nova";
  17.         } else if("hobby".equals(msg)){
  18.             returnMsg = "编写java程序";
  19.         } else {
  20.             returnMsg = "你说啥呢";
  21.         }
  22.         data = returnMsg.getBytes();
  23.         packet = new DatagramPacket(data, 0, data.length, InetAddress.getByName("192.168.23.1"), 9998);
  24.         socket.send(packet);
  26.         socket.close();
  27.     }
  28. }

客户端

  1. public class HomeWork01Client {
  2.     public static void main(String[] args) throws Exception{
  3.         System.out.println("请输入您的消息:");
  5.         Scanner sc = new Scanner(System.in);
  6.         String msg = sc.next();
  7.         DatagramSocket socket = new DatagramSocket(9998);
  8.         byte[] data = msg.getBytes();
  9.         DatagramPacket packet = new DatagramPacket(data, 0, data.length, InetAddress.getByName("192.168.23.1"), 9999);
  10.         socket.send(packet);
  12.         data = new byte[1024];
  13.         packet = new DatagramPacket(data, data.length);
  14.         socket.receive(packet);
  15.         int length = packet.getLength();
  16.         data = packet.getData();
  17.         System.out.println(new String(data, 0, length));
  19.     }
  20. }

（二）案例二

ff4b8b544e3c443395cb164310e4cc56.png

服务端

  1. public class HomeWork03Server {
  2.     public static void main(String[] args) throws Exception{
  3.         System.out.println("服务端监听9999端口，等待接收文件名...");
  4.         // 1.创建一个socket对象
  5.         ServerSocket serverSocket = new ServerSocket(9999);
  6.         // 2.接收传递过来的文件名
  7.         Socket socket = serverSocket.accept();
  8.         InputStream inputStream = socket.getInputStream();
  9.         // 这里使用了while循环，是考虑客户端可能发送的文件名较大的情况
  10.         byte[] buf = new byte[1024];
  11.         int len = 0;
  12.         String downLoadFileName = "";
  13.         while((len = inputStream.read(buf)) != -1) {
  14.             downLoadFileName += new String(buf, 0, len);
  15.         }
  17.         System.out.println("客户端希望下载的文件名: " + downLoadFileName);
  18.         // 3.确定文件名
  19.         // 如果客户端要求下载高山流水，则获取文件流返回，否则，返回无名mp3
  20.         String filePath = "";
  21.         if("高山流水".equals(downLoadFileName)) {
  22.             filePath = "src//高山流水.mp3";
  23.         } else {
  24.             filePath = "src//无名.mp3";
  25.         }
  26.         // 4.获取文件输入流并转化为字节数组
  27.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
  28.         byte[] data = StreamUtils.streamToByteArray(bis);
  29.         // 5.获取socket输出流并写出数据
  30.         BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
  31.         bos.write(data);
  32.         socket.shutdownOutput();
  33.         // 6.关闭资源
  34.         bos.close();
  35.         bis.close();
  36.         socket.close();
  37.         serverSocket.close();
  39.         System.out.println("服务端传输文件完毕，退出");
  40.     }
  41. }

客户端

  1. public class HomeWork03Client {
  2.     public static void main(String[] args) throws Exception{
  3.         System.out.println("请输入下载的文件名：");
  4.         // 1.获取用户输入的文件名
  5.         Scanner sc = new Scanner(System.in);
  6.         String fileName = sc.next();
  7.         // 2.创建连接
  8.         Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
  9.         // 3.获取socket关联的输出流并写出
  10.         OutputStream outputStream = socket.getOutputStream();
  11.         outputStream.write(fileName.getBytes());
  12.         //   设置写入结束的标记
  13.         socket.shutdownOutput();
  14.         // 4.获取输入流并转化为字节数组
  15.         BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
  16.         byte[] data = StreamUtils.streamToByteArray(bis);
  18.         // 5.获取写出流，将文件写入磁盘
  19.         String fileNamePath = "src//com//hspedu/homework//" + fileName + ".mp3";
  20.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(fileNamePath));
  21.         bos.write(data);
  23.         // 6.关闭资源
  24.         outputStream.close();
  25.         bos.close();
  26.         bis.close();
  27.         socket.close();
  29.         System.out.println("文件下载完毕，退出");
  31.     }
  32. }

发表评论

表情：
评论列表 （有 0 条评论，110人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java——TCP UDP Socket编程

    目录 一、网络的相关概念 （一）网络通信 （二）网络 （三）ip地址 （四）ipv4地址分类 （五）域名 （六）网络通信协议 （七）TCP和UDP 二、Ine

    蔚落蔚落/ 0 赞/ 111 阅读

    相关 socket与TCP/UDP编程

    Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编

    野性酷女野性酷女/ 0 赞/ 344 阅读

    相关 Socket编程——UDP编程

    UDP协议（用户数据协议） 是无连接、不可靠的、无序的 特点在于速度比较快 UDP协议以数据报作为数据传输的载体 进行数据传输时，首先需要将要传输的数据定义成数据报（

    冷不防冷不防/ 0 赞/ 327 阅读