tcp 实现 java

已于 2022-08-24 19:36:24 修改
阅读量304 收藏
点赞数
分类专栏： java  SE 总结 文章标签： java tcp/ip
于 2022-08-06 22:22:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45631716/article/details/126202213
版权

socket 网络编程

写在前面

  • socket 是默认阻塞的，可以把他作为 位于网络层和传输层的之间的 一个抽象层

案例一、UDP 通信

  • UDP　是面向无连接的　并且传送的是数据包 利用io 流 传输数据。将其封装成包

1.发送端

  • 创建发送/接受 对象 datagramsocket,用于发送数据 （创建的对象的空参的）

  • 定义要发送的 数据 以字符串的形式给出

  • 将字符串 转成byte 数组 （封包对象的构造方法里面是的参数是byte[]）

  • 将流过来的数据封装成包（datagrampacket）满参构造，指定byte[] 和byte数组的长度，IP地址对象，端口号

  • socket 对象 调用send()方法，传入封装的数据包对象 packet 进行发包

  • 关流

 package com.itheima.demo1udp;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
 ​
 public class Client
 {
     public static void main(String[] args) throws Exception
     {
         // 创建datagramsocket 对象 用发送数据
         DatagramSocket socket = new DatagramSocket();
         // 定义要发生的数据
         String str = "Hello World";
         // 将数据转成byte 数组
         byte[] bys = str.getBytes();
         // 创建数据包对象,进行封包 udp 面向无连接 需要指定端口号
         DatagramPacket packet = new DatagramPacket(bys,bys.length, InetAddress.getLocalHost(),6666);
         // 发送数据包
         socket.send(packet);
         // 关流
         socket.close();
 ​
     }
 }
 ​

接收端：

  • 创建 发送/接受 数据对象 （datagramsocket）作为 udp 的接受端要指定 端口号

  • 创建byte[ ]数组，用于存放的 发送端发发送的数据 （因为封包的构造方法里面是byte[]）

  • 将发送方发来的数据 封装成包（datagrampakcet）构造方法的参数是bys 和bys.length

  • 调用socket方法 接受数据包

  • 打印数据（数据存放在byte[] 中，数组的长度=数据的长度=packet.getlength）

  • new String(bys,0,length)== new一个String类型的对象 取值是从第0个 长度为数组的长度 取的是bys数组

 package com.itheima.demo1udp;
 ​
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 ​
 public class Server
 {
     public static void main(String[] args) throws Exception
     {
         // 创建接受包数据对象,udp 面向无连接 指定端口
         DatagramSocket socket = new DatagramSocket(6666);
         // 创建byte[]数组 用于存放数据
         byte[] bys = new byte[1000];
         // 创建数据包对象 用于将数据流 封装成包
         DatagramPacket packet = new DatagramPacket(bys,bys.length);
         // 接受数据包
         socket.receive(packet);
 ​
         // 打印数据 返回返回将要发送或接收到的数据的长度。
         int length = packet.getLength();
         System.out.println("接受到的资源: " + new String(bys,0,length));
         // 释放资源
         socket.close();
 ​
 ​
     }
 }

案例二、 tcp 协议的使用 发送端 发送数据给 接收端

写在前面

  • tcp 之间的通信 其实就是 两个socket 之间的通信

  • socket类 一个该类的对象就是代表一个发送端

    1. 构造方法： Public socket (String host,int port);

      ==注意 该方法的执行就会连接指定的服务器，若没有异常 则连接成功（三次握手成功）

    2. 常用方法

      1. OutputStream getOutputStream( )

      2. InputStream getInputStream( )

1.发送端

  • 创建socket对象，指定服务器的ip地址和端口号

  • 创建字节输出流对象，关联连接通道

  • 使用字节流对象将 数据写到 连接通道里去

  • 释放资源

 package com.itheima.demo2tcpo1;
 ​
 import java.io.OutputStream;
 import java.net.Socket;
 public class Client
 {
     public static void main(String[] args) throws Exception
     {
         // 创建socket对象，指定服务器的ip地址和端口号
         Socket socket = new Socket("127.0.0.1",6666);
 ​
         System.out.println(socket);
 ​
         String str = "你好吗？";
         // 创建字节输出流对象，关联连接通道
         OutputStream os = socket.getOutputStream();
         // 使用字节流对象将 数据写到 连接通道里去
         os.write(str.getBytes());
         // 释放资源
         socket.close();
     }
 }
 ​

2.接受端

  • 创建ServerSocket对象,指定服务器的端口号

  • 调用ServerSocket对象的 accept 方法 获取到Socket对象

  • 通过接收端的 socket对象 调用输入流方法

  • 使用字节输入流 读取 关联通道里的数据

  • 创建数组 因为关联通道在写的时候 构造方法指定值存在数组中里的

  • 获得 读取的字符长度

  • 打印 将字符强转成字符串

  • 释放资源

 package com.itheima.demo2tcpo1;
 ​
 import java.io.InputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
 ​
 public class Server
 {
     public static void main(String[] args) throws Exception
     {
         // 创建ServerSocket对象,指定服务器的端口号
         ServerSocket serverSocket = new ServerSocket(6666);
         // 调用ServerSocket对象的 accept 方法 获取到Socket对象
         Socket socket = serverSocket.accept();
 ​
         System.out.println(socket);
 ​
         // 通过接收端的 socket对象 调用输入流方法
         InputStream is = socket.getInputStream();
         // 使用字节输入流 读取 关联通道里的数据
           // 创建数组 因为关联通道在写的时候 构造方法指定值存在数组中里的
         byte[] bys = new byte[8192];
           // 获得  读取的字符长度
         int len = is.read(bys);
         // 打印 将字符强转成字符串
         System.out.println(new String(bys,0,len));
         // 释放资源
         socket.close();
 ​
 ​
     }
 }
 ​

案例三、拓展 接受方 回话给发送端

接受端（额外增加的功能）

  • 在关闭之间 搞个输出流

  • 将 要回复的字符串 写到数组中去（已经关联了通道）

   // 回话
         String str = "我很好你呢？";
         socket.getOutputStream().write(str.getBytes());
         // 释放资源
         socket.close();

发送端（额外增加的代码）

  • 在关闭资源之前去 读取 接受端写入在数组中的数据

  • 打印（byte[] 强转成字符串）

  // 从字节输入流中读取
         byte[] bys = new byte[8192];
         // 读取
         int len = socket.getInputStream().read(bys);
         // 打印
         System.out.println(new String(bys,0,len));
         // 释放资源
         socket.close();

案例四：对话内容不限 对话次数不限（但问一次只能回答一次）

发送端和接受端：

  • 在连接建立之后 进入循环

  • 不能释放资源

  • 对话 内容键盘录入

注意，发送方在创建socket　对象时候　回自动进行三次握手

接受方 在调用accept( ) 返回 socket 对象时，服务器回一直处于阻塞状态 直到发送方连接进来

案例四，文件的上传

客服端 借助(输入流) 将文件从 硬盘写道 程序A里 ，程序A 借助文件（输出流）将文件输出 （在借助输入流）将文件 写道到关联通道里

服务器端，从关联通道中 借助（输出流）读取文件到 本地

客服端

  • 创建Socket 对象，指定要连接的服务器的ip地址和端口号

  • 创建文件输入流对象（读），关联数据源文件路径

  • 通过socket获得字节输出流对象，关联连接通道（输出就是要写 在 循环读中 用到写 写就得有容器 存放 byte数组）

  • 定义byte[ ] 数组，用来存储读取到得字节数据 （下一步就是常规的套路，在读循环中 写）

  • 定义int 类型变量，记录读取到 字符对应的 十进制数（字节）

  • 循环读（不为-1）

  • 注意 while ((b=fis.read(bys))!=-1) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中，判断得是，字节数组中是否还有元素

  • 写字节数据到连接通道中去 ==一气呵成write(bys,0,int b);

  • 释放资源

 package com.itheima.demo3fileup;
 ​
 import java.io.FileInputStream;
 import java.io.OutputStream;
 import java.net.InetAddress;
 import java.net.Socket;
 ​
 public class Client
 {
     public static void main(String[] args) throws Exception
     {
         // 创建socket对象,指定要连接服务器的IP地址和端口
         Socket socket = new Socket(InetAddress.getLocalHost().getHostAddress(),6667);
         // 创建文件字节输入流对象,关联数据源文件文件
         FileInputStream fis = new FileInputStream("day12-code\\aaa\\jobs.jpg");
 ​
         // 通过Socket获得文件输出流对象,这样输出流对象就也关联了连接通道
         OutputStream os = socket.getOutputStream();
         
         // 定义byte[] 数组 用来存储读取到的字节数
         byte[] bys = new byte[8192];
         // 创建int 类型的变量 用来记录读出来的字符 对应的
         int b;
         // 对文件输出流循环读
         while ((b=fis.read(bys))!=-1)
         {
             // 将读出来的字节写到 数组中 去实现关联流通道
             os.write(bys,0,b);
         }
         // 释放资源
         socket.close();
 ​
     }
 }
 ​

服务器端

  • 创建ServeSocket 对象，绑定端口号

  • 调用accept 方法 ，让服务器处于阻塞状态，接受客户端的请求，建立连接，得到socket对象

  • （上一步中得到的 socket对象）通过socket对象，会的字节输入流（读），关联连接通道

  • 创建文件输出流对象 关联文件目的路径（下一步就是常规的套路，在读循环中 写）

  • 定义int 类型变量，记录读取到 字符对应的 十进制数（字节）循环读（不为-1）

  • 写字节数据到连接通道中去 ==一气呵成write(bys,0,int b);

  • 释放资源

 package com.itheima.demo3fileup;
 ​
 import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
 ​
 public class Server
 {
     public static void main(String[] args) throws Exception
     {
         // 创建ServersSocket对象，绑定端口号
         ServerSocket ss = new ServerSocket(6667);
         // 调用accept方法,接受请求,建立连接，得到Socket对象
         Socket socket = ss.accept();
         // 通过socket对象 获得字节文件输入流,关联连接通道
         InputStream is = socket.getInputStream();
         
         // 创建文件字节输出流对象，关联目的文件路径
         FileOutputStream fos = new FileOutputStream("day12-code\\bbb\\jobs1.jpg");
         // 定义byte[],用来存放读取到的字节数据
         byte[] bys = new byte[8192];
         // 循环读写数据
         int b;
         while ((b=is.read(bys))!=-1)
         {
             // 写
             fos.write(bys,0,b);
         }
         // 释放资源
         socket.close();
     }
 }
 ​

文件上传的总结

  • 客户端设备

    1. 先创建socket 对象 没话说 确定服务器的ip 和port

    2. cpu 将内存的文件 读到内存中去（用输入流）

    3. 通过socket 对象 获取到 输出流对象（这样输出流就关联了 连接通道）

    4. 定义byte [ ] 、int 变量、实现读循环

    5. 在读循环中 将读出来的数据 写到byte[ ] 中去（这样服务器端 读 byte[ ]的时候j就关联了 连接通道 ）

    6. 释放资源

  • 服务器端

    1. 创建ServeSocket 对象，绑定端口号（没得说）

    2. 调用accept 方法 ，让服务器处于阻塞状态，接受客户端的请求，建立连接，得到socket对象（没得说）

    3. 通过socket对象 获得字节文件输入流（要读byte[ ]）,关联连接通道

    4. 创建文件字节输出流对象，关联目的文件路径

    5. 定义byte [ ] 、int 变量、实现读循环

    6. 在读循环中 将读出来的数据 写到byte[ ] 中去

案例五，文件上传2.0

  • 新增 上传后的 文件名自动生成

  • 服务器可以接受 上传文件

  • 加入线程，可以使多个客户端上传文件

客服端1

 package com.itheima.demo5fileuplusplus;
 ​
 import java.io.FileInputStream;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.InetAddress;
 import java.net.Socket;
 ​
 public class Client1
 {
     public static void main(String[] args) throws Exception
     {
         // 创建socket 对象，指定服务器的 ip 和 port
         Socket socket = new Socket("127.0.0.1",6668);
         // 创建文件字节输入流 管关联数据源路径
         FileInputStream fis = new FileInputStream("day12-code\\aaa\\11.jpg");
         // 获取字节输出流对象，关联连接通道
         OutputStream os = socket.getOutputStream();
         // 定义byte数组
         byte[] bys = new byte[8192];
 ​
         // 定义int 类型变量
         int b;
         /* 循环读 */
         while((b=fis.read(bys))!=-1)
         {
             // 写
             os.write(bys,0,b);
         }
         // 通知服务器 已经读完
         socket.shutdownOutput();
         // 读取 服务器的回话
         // 读取 服务器的回话
         // 再次管关联 连接通道
         InputStream aIs = socket.getInputStream();
         int ab;
         while ((ab = aIs.read(bys))!=-1)
         {
             System.out.println(new String(bys,0,ab));
         }
         socket.close();
 ​
     }
 ​
 }
 ​

客户端2

 package com.itheima.demo5fileuplusplus;
 ​
 import java.io.FileInputStream;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.InetAddress;
 import java.net.Socket;
 ​
 public class Client2
 {
     public static void main(String[] args) throws Exception
     {
         // 创建socket 对象，指定服务器的 ip 和 port
         Socket socket = new Socket("127.0.0.1",6668);
         // 创建文件字节输入流 管关联数据源路径
         FileInputStream fis = new FileInputStream("day12-code\\aaa\\jobs.jpg");
         // 获取字节输出流对象，关联连接通道
         OutputStream os = socket.getOutputStream();
         // 定义byte数组
         byte[] bys = new byte[8192];
 ​
         // 定义int 类型变量
         int b;
         /* 循环读 */
         while((b=fis.read(bys))!=-1)
         {
             // 写
             os.write(bys,0,b);
         }
         // 通知服务器 已经读完
         socket.shutdownOutput();
 ​
         // 读取 服务器的回话
         // 再次管关联 连接通道
         InputStream aIs = socket.getInputStream();
         int ab;
         while ((ab = aIs.read(bys))!=-1)
         {
             System.out.println(new String(bys,0,ab));
         }
 ​
         socket.close();
 ​
     }
 ​
 }
 ​

服务器端

 package com.itheima.demo5fileuplusplus;
 ​
 import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
 ​
 public class Server
 {
     public static void main(String[] args) throws Exception {
         // 创建serversocket 对象
         ServerSocket ss = new ServerSocket(6668);
         // 服务器一直读
         while (true)
         {   // 获取到socket 对象
             Socket socket = ss.accept();
             // 创建文件输入流文件，关联连接通道
             InputStream is = socket.getInputStream();
             // 创建文件文件输出流文件，关联目的路径 (自动生成文件名)
             FileOutputStream fos = new        
                 FileOutputStream("day12code\\bbb\\"+System.currentTimeMillis()+".jpg");
             byte[] bys = new byte[8192];
             int b;
 ​
             System.out.println("服务器开始接受文件数据");
             while ((b = is.read(bys))!=-1)
             {
                 fos.write(bys,0,b);
             }
             System.out.println("服务器准备回写文件数据");
 ​
             // 服务器回话,再次关联连接通路
             OutputStream os = socket.getOutputStream();
             // 回写上传成功的信息给客户端
             os.write("文件上传成功".getBytes());
 ​
              socket.close();
             //ss.close();
             os.close();
 ​
         }
 ​
 ​
     }
 }
 ​

服务器端（线程版）

 package com.itheima.demo5fileuplusplus;
 ​
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
 ​
 /**
  * @author ChenY@itheima.com
  * @date 2022/8/6 21:05
  */
 public class Server
 {
     public static void main(String[] args) throws Exception {
         // 创建serversocket 对象
         ServerSocket ss = new ServerSocket(6668);
 ​
         // 服务器一直读
         while (true)
         {   // 获取到socket 对象
             Socket socket = ss.accept();
 ​
 // 在连接完了 上线程
             // 线程版
             new Thread(new Runnable() {
                 @Override
                 public void run() {
 ​
                     try {
                         // 创建文件输入流文件，关联连接通道
                         InputStream is = socket.getInputStream();
                         // 创建文件文件输出流文件，关联目的路径 (自动生成文件名)
                         FileOutputStream fos = new FileOutputStream("day12-code\\bbb\\"+System.currentTimeMillis()+".jpg");
                         byte[] bys = new byte[8192];
                         int b;
 ​
                         System.out.println("服务器开始接受文件数据");
                         while ((b = is.read(bys))!=-1)
                         {
                             fos.write(bys,0,b);
                         }
                         System.out.println("服务器准备回写文件数据");
 ​
                         // 服务器回话,再次关联连接通路
                         OutputStream os = socket.getOutputStream();
                         // 回写上传成功的信息给客户端
                         os.write("文件上传成功".getBytes());
 ​
                         socket.close();
                         //ss.close();
                         os.close();
                     } catch (IOException e) {
                         e.printStackTrace();
                     } finally { 
                     }
 ​
 ​
                 }
             }).start();
 ​
         }
 ​
     }
 }
 ​

YHCODE_esq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实现TCP传输
01-24
用java代码实现TCP传输协议，在客户端和服务器端实现通信
java基于TCP协议实现聊天程序
08-27
Java 基于 TCP 协议实现聊天程序 本资源详细介绍了使用 Java 实现基于 TCP 协议的聊天程序，涵盖了服务器端和客户端的实现细节。 一、总体架构 本程序主要包括服务器端和客户端两个部分。服务器端负责管理所有...
Java网络编程——TCP
weixin_49137294的博客
07-16 932
在开发网络应用程序的时候，会遇到Socket这个概念。Socket是一个抽象概念，一个应用程序通过一个Socket来建立一个远程连接，而Socket内部通过TCP/IP协议把数据传输到网络。Socket、TCP和部分IP的功能都是由操作系统提供的，不同的编程语言只是提供了对操作系统调用的简单的封装，例如，Java提供的几个Socket相关的类就封装了操作系统提供的接口ServerSocket类，Socket类。......
【Java 基础篇】Java TCP通信详解
最新发布
繁依Fanyi的博客
09-21 6419
本文介绍了Java中如何使用TCP协议进行网络通信，包括TCP的基础知识、TCP编程的基本步骤、创建TCP服务器和客户端、数据传输等内容。通过学习本文，您可以开始使用TCP协议来构建自己的网络应用程序，实现可靠的数据传输。希望本文能够帮助您更好地理解和应用Java中的TCP通信。
基于java实现tcp长链接，自定义消息协议
Mr_Oorange的专栏
08-29 1万+
哈啰出行（哈啰单车），诚招高级/资深前端开发工程师、Java高级/资深开发工程师，地点上海。 有想法的请发简历到我个人邮箱：huangcheng@hellobike.com 现在即时通信在移动领域应用的非常广了，通过TCP长链接实现数据的即时更新，通知，在日常开发中常会用的。今天我就把在在平常开发中的基本实现思路跟大家一起交流下。转载请注明出处：http://blog.csdn.net/m...
Java通过 Socket 实现 TCP服务端
08-30
Java通过Socket实现TCP服务端 Java通过Socket实现TCP服务端是指利用Java语言通过Socket编程来实现TCP服务端的功能。下面是相关的知识点： 1. Socket简介 Socket是指应用程序通过网络发出请求或者应答网络请求的...
Java心跳包功能TCP实现
11-07
Java心跳包功能的实现，tcp协议的，包含客户端和服务端
TCP通信的Java实现
01-20
传输控制协议（TCP，Transmission Control Protocol）是为了在不可靠的互联网络上提供可靠的端到端字节流而专门设计的一个传输协议。 TCP通信是面向连接的通信，通信过程中客户端与服务器端必须经过3次握手，建立...
用scoket发送基于tcp协议的自定义数据包（实现了多线程，支持多个客户端同时访问）
08-08
如题~ 自己写的，希望多多指教~ 解压后先打开一个命令窗口，在命令行中切换到文件所在路劲路径，然后输入java Server，再打开另一个命令窗口输入java Client （连接后输入go或go2分别发送不同的数据包，客户端输入bye断开连接）
Java实现TCP
weixin_51597979的博客
04-23 655
实现的功能是Client向Server发送“你好你好”消息。用Java编写的客户端代码如下；用Java编写的服务端代码如下；从连接通道中获取输入流的数据。从连接通道中获取输出流。
Java实现TCP/IP网络编程
m0_60982956的博客
07-17 2489
其中一个进程必须充当服务器端，它会主动监听某个指定的端口，另一个进程必须充当客户端，它必须主动连接服务器的IP地址和指定端口，如果连接成功，服务器端和客户端就成功地建立了一个TCP连接，双方后续就可以随时发送和接收数据。端口号总是由操作系统分配，它是一个0～65535之间的数字，其中，小于1024的端口属于特权端口，需要管理员权限，大于1024的端口可以由任意用户的应用程序打开。●对客户端来说，它的Socket是它所在计算机的IP地址和一个由操作系统分配的随机端口号。5.接受来自服务器端的反馈。......
Java之TCP编程
m0_59340907的博客
07-17 471
使用Java进行TCP编程时，需要使用Socket模型；服务器用ServerSocket监听指定接口；客户端使用Socket(InetAddress,port)连接服务器；服务器端用accept()接受连接并返回Socket实例；双方通过Socket打开InputStream/OutputStream读写数据；https。...
java实现TCP协议文件传输
我的博客
10-18 2050
java实现TCP协议文件传输
Java实现TCP通信
infatuatED_的博客
07-04 1759
1.服务端： 2.用户端: ​ 3.接受信息的线程： 4.发送信息的线程： 总结：TCP程序需先确定 谁是服务器 谁是用户端。服务器通过serversocket生成一个Socket对象，再将socket传递到两个线程。退出时需将流和socket关闭。...
使用Java建立TCP连接并发送数据
热门推荐
Ann的博客
04-25 3万+
TCP协议：传输控制协议  ，应用于运输层 客户端代码--发送请求： import java.io.IOException; import java.io.OutputStream; import java.net.Socket; import java.net.UnknownHostException; public class TCPClientDemo { public stati
Java TCP编程(实现方式二)
weixin_52629592的博客
04-08 223
实现的另一种方式:使用readUTF()和writeUTF()方法: 我们讲的上一种方法时使用了read()方法和write()方法读取和写入内容,这两种方法使用的时默认的编码格式 而使用readUTF()和writeUTF()方法是将内容转化为utf-8的编码格式 使用此种方法时,readUTF()和writeUTF()方法必须同时使用.即使用readUTF()读取数据,那么写入时就必须使用writeUTF()方法,否则就会报错 代码实现: 客户端 package java...
java tcp实现聊天室
04-29
Java TCP 实现聊天室需要通过网络套接字实现，具体步骤如下： 1. 创建服务器端和客户端的 Socket 连接。服务器端需要绑定一个端口号来监听客户端的连接请求。 2. 服务器端需要开启一个线程来接收客户端的连接请求...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值