【Java 网络编程】TCP 数据传输示例 ( 客户端参数设置 | 服务器端参数设置 | ByteBuffer 存放读取数据类型 )

本文涉及的产品
数据传输服务 DTS,数据迁移 small 3个月
推荐场景:
MySQL数据库上云
数据传输服务 DTS,数据同步 small 3个月
推荐场景:
数据库上云
数据传输服务 DTS,数据同步 1个月
简介: 【Java 网络编程】TCP 数据传输示例 ( 客户端参数设置 | 服务器端参数设置 | ByteBuffer 存放读取数据类型 )

文章目录

I 客户端代码示例

II 服务器端代码示例

III 运行结果



I 客户端代码示例


import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Inet4Address;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
/**
 * TCP 客户端
 */
public class Client {
    public static void main(String[] args) {
        try {
            //I. 创建 Socket 对象并绑定本地端口
            //1. 创建空的 Socket 对象 , 方便之后设置参数
            Socket socket = new Socket();
            //2. 绑定本地端口
            socket.bind(new InetSocketAddress(Inet4Address.getLocalHost(), 8887));
            System.out.println("客户端 Socket 创建完毕");
            //II. 设置 Socket 对象参数 , 注意这些参数只能在客户端没有连接服务器的时候设置 , 连接服务器之后设置是无效的
            //1. 设置从 Socket 对象输入流中读取数据的阻塞等待超时时间
            //      当与 Socket 对象关联的 InputStream 输入流执行 read() 操作时 , 其阻塞时间为这个超时时间
            //      如果超过了该时间还没有收到任何数据 , 就会抛出异常
            socket.setSoTimeout(3000);
            //2. 设置是否可以复用 Socket 绑定的地址和端口号
            //      Socket 连接在建立时 , 会使用之前绑定本地的 IP 地址和端口号
            //      这个端口号在使用之后 , 2 分钟之内不允许再次使用
            //      进行了该设置之后 , 可以在连接关闭之后 , 马上使用该本地 IP 地址和端口号
            socket.setReuseAddress(true);
            //3. 设置是否开启 Nagle 算法 , Nagle 算法会导致多次发送的少量数据合并 , 即沾包情况出现
            //      在需要低延迟传输的情况下是需要关闭该算法的 , 该算法会导致数据沾包情况出现
            socket.setTcpNoDelay(true);
            //4. 在长时间 ( 2 小时 ) 没有数据交互 , 是否需要发送心跳包确认连接
            socket.setKeepAlive(true);
            //5. 调用 Socket 对象的 close 方法之后的处理方式
            //   1> 默认情况 : false , 0
            //      如果 boolean on 设置成false , 不处理连接的缓存数据 , 调用 close 会立刻关闭连接
            //      系统底层会操作输出流发送剩余缓存数据 , 将缓冲区中的数据发送给连接对方
            //      如果设置 false 不会产生阻塞操作
            //   2> setSoLinger( true , 20 ) 情况 :
            //      如果设置 boolean on 参数为 true , int linger 参数设置一个大于等于 0 的参数
            //      那么在关闭的时候 , 阻塞 linger 毫秒 , 之后缓冲区如果还有数据 , 就会被丢弃
            //      直接向连接对方发送结束命令 , 无需经过超时等待
            //   3> setSoLinger( true , 0 ) 情况 :
            //      如果设置成 0 , 那么其后果是不阻塞 , 也不让系统接管输出流
            //      立刻丢弃缓冲区数据 , 向对方发送 RST 命令
            socket.setSoLinger(true, 10);
            //6. 设置紧急数据是否内敛 , 默认情况时 false 关闭的
            //      紧急数据 : 紧急数据是 Socket 对象通过调用 sendUrgentData 发送出去的数据
            //                该方法参数是一个 int 值 , 仅有最低的 8 位是有效的
            socket.setOOBInline(true);
            //7. 设置发送接收缓冲区大小
            socket.setReceiveBufferSize(64 * 1024 * 1024);
            socket.setSendBufferSize(64 * 1024 * 1024);
            //8. 设置性能参数 : ① 连接时长 , ② 最低延迟 , ③ 带宽
            //      设置的值不是具体的参数 , 而是连接的性能权重 , 对哪个性能要求比较高 ;
            //      上面的延迟和带宽的性能是互斥的 , 低延迟新能好 , 带宽性能就差
            socket.setPerformancePreferences(0, 2, 0);
            System.out.println("客户端 Socket 参数设置完毕");
            //III. 连接服务器
            //1. 连接到服务器端的 8888 端口 , 设置连接超时 3000 毫秒
            socket.connect(new InetSocketAddress(Inet4Address.getLocalHost(), 8888), 3000);
            System.out.println("客户端 Socket 连接服务器完毕");
            //IV. 数据发送与接收
            //1. 获取输出流和输入流
            OutputStream outputStream = socket.getOutputStream();
            InputStream inputStream = socket.getInputStream();
            //2. 使用 ByteBuffer 向 byte[] 数组中存储数据
            byte[] buffer = new byte[256];
            ByteBuffer byteBuffer = ByteBuffer.wrap(buffer);
            //3. 向数组写入 byte 类型数据
            byteBuffer.put((byte) 0x01);
            //4. 向数组中写入 short 类型数据
            byteBuffer.putShort((short) 1);
            //5. 向数组中写入 int 类型数据
            byteBuffer.putInt(1);
            //6. 向数组中写入 char 类型数据
            byteBuffer.putChar('a');
            //7. 向数组中写入 boolean 类型数据
            //      此处使用 byte 类型模拟 , true 为 1, false 为 0
            boolean bool = true;
            byteBuffer.put((byte) (bool ? 1 : 0));
            //8. 向数组中写入 long 类型数据
            byteBuffer.putLong((long)1);
            //9. 向数组中写入 float 类型数据
            byteBuffer.putFloat(3.14f);
            //10. 向数组中写入 double 类型数据
            byteBuffer.putDouble(3.14);
            //11. 向数组中写入 String 类型数据
            //      先把 String 字符串转为 byte[] 数组, 在放入 byteBuffer 中
            byteBuffer.put("Hello World".getBytes());
            //12. 将 byte[] 数据发送到服务器端
            outputStream.write(buffer, 0, byteBuffer.position() + 1);
            System.out.println("客户端 Socket 将各种类型数据发送到了服务器端");
            //13. 接收服务器端反馈的数据
            int readLen = inputStream.read(buffer);
            System.out.println("客户端 Socket 接收到服务器端数据 " + readLen + " 字节");
            //V. 释放资源
            //1. 关闭输入输出流
            outputStream.close();
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}




II 服务器端代码示例


import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Inet4Address;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;
/**
 * TCP 服务器端
 */
public class Server {
    public static void main(String[] args) {
        try {
            //I. 设置服务器套接字
            //1. 创建服务器端 , 注意创建一个空的服务器套接字 , 一遍后面设置更详细的参数
            ServerSocket serverSocket = new ServerSocket();
            System.out.println("服务器端端 ServerSocket 创建完毕");
            //2. 设置从 Socket 对象输入流中读取数据的阻塞等待超时时间
            //      当与 Socket 对象关联的 InputStream 输入流执行 read() 操作时 , 其阻塞时间为这个超时时间
            //      如果超过了该时间还没有收到任何数据 , 就会抛出异常
            serverSocket.setSoTimeout(30000);
            //3. 设置是否可以复用 Socket 绑定的地址和端口号
            //      Socket 连接在建立时 , 会使用之前绑定本地的 IP 地址和端口号
            //      这个端口号在使用之后 , 2 分钟之内不允许再次使用
            //      进行了该设置之后 , 可以在连接关闭之后 , 马上使用该本地 IP 地址和端口号
            serverSocket.setReuseAddress(true);
            //4. 设置发送接收缓冲区大小
            serverSocket.setReceiveBufferSize(64 * 1024 * 1024);
            //5. 设置性能参数 : ① 连接时长 , ② 最低延迟 , ③ 带宽
            //      设置的值不是具体的参数 , 而是连接的性能权重 , 对哪个性能要求比较高 ;
            //      上面的延迟和带宽的性能是互斥的 , 低延迟新能好 , 带宽性能就差
            serverSocket.setPerformancePreferences(0, 2, 0);
            System.out.println("服务器端端 ServerSocket 设置完毕");
            //6. 绑定本地端口 , 只有绑定了本地端口 , 服务器端套接字才能正式工作
            //      服务器端才算是正式创建完毕
            //      上面的设置一定要在绑定接口之前设置完毕 , 之后在设置 serverSocket 是无效的
            serverSocket.bind(new InetSocketAddress(Inet4Address.getLocalHost(), 8888), 88);
            System.out.println("服务器端端 ServerSocket 绑定 8888 端口完毕");
            //II. 等待服务器端连接
            //1. 服务器端阻塞 , 等待客户端连接服务器端的 8888 端口号
            Socket clientSocket = serverSocket.accept();
            //2. 创建客户端异步处理线程 , 处理服务器端与该客户端之间的交互 , 创建之后直接启动线程即可
            ClientHandler clientHandler = new ClientHandler(clientSocket);
            clientHandler.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 客户端异步处理线程
     *  每当有客户端连接服务器 , 就开启一个线程处理与该客户端之间的交互
     */
    private static class ClientHandler extends Thread {
        /**
         * 客户端线程
         */
        private Socket clientSocket;
        public ClientHandler(Socket clientSocket) {
            this.clientSocket = clientSocket;
        }
        @Override
        public void run() {
            super.run();
            System.out.println("客户端 : " + clientSocket.getInetAddress() + " 连接到服务器端");
            try {
                //I. 获取数据交互的输入流 , 输出流 , 及缓冲区
                //1. 从客户端 Socket 中获取与客户端进行数据交互的输入输出流
                OutputStream outputStream = clientSocket.getOutputStream();
                InputStream inputStream = clientSocket.getInputStream();
                //2. 从客户端读取数据 , 并使用 ByteBuffer 读取其中各种类型的数据
                byte[] buffer = new byte[256];
                int readCount = inputStream.read(buffer);
                ByteBuffer byteBuffer = ByteBuffer.wrap(buffer, 0, readCount);
                //II. 按照顺序读取存放的数据
                //注意 : 要按照存放的顺序读取
                //1. 读取 byte 类型数据
                byte var_byte = byteBuffer.get();
                System.out.println("① byte 类型数据 : " + var_byte);
                //2. 读取 short 类型数据
                short var_short = byteBuffer.getShort();
                System.out.println("② short 类型数据 : " + var_short);
                //3. 读取 int 类型数据
                int var_int = byteBuffer.getInt();
                System.out.println("③ int 类型数据 : " + var_int);
                //4. 读取 char 类型数据
                char var_char = byteBuffer.getChar();
                System.out.println("④ char 类型数据 : " + var_char);
                //5. 读取 short 类型数据
                boolean var_boolean = byteBuffer.get() == 1;
                System.out.println("⑤ boolean 类型数据 : " + var_boolean);
                //6. 读取 long 类型数据
                long var_long = byteBuffer.getLong();
                System.out.println("⑥ long 类型数据 : " + var_long);
                //7. 读取 float 类型数据
                float var_float = byteBuffer.getFloat();
                System.out.println("⑦ float 类型数据 : " + var_float);
                //8. 读取 double 类型数据
                double var_double = byteBuffer.getDouble();
                System.out.println("⑧ double 类型数据 : " + var_double);
                //9. 读取 short 类型数据
                int start = byteBuffer.position();
                String var_string = new String(buffer, start, readCount - start - 1);
                System.out.println("⑨ String 类型数据 : " + var_string);
                //III. 将接收的数据再发送回去, 并关闭连接
                outputStream.write(buffer, 0, readCount);
                outputStream.close();
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 连接关闭
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("客户端与服务器端交互完成");
                }
            }
        }
    }
}




III 运行结果


1. 先运行服务器端 :

服务器端端 ServerSocket 创建完毕
服务器端端 ServerSocket 设置完毕
服务器端端 ServerSocket 绑定 8888 端口完毕


2. 在运行客户端 :


客户端 Socket 创建完毕
客户端 Socket 参数设置完毕
客户端 Socket 连接服务器完毕
客户端 Socket 将各种类型数据发送到了服务器端
客户端 Socket 接收到服务器端数据 42 字节


3. 最终查看服务器端打印 :


服务器端端 ServerSocket 创建完毕
服务器端端 ServerSocket 设置完毕
服务器端端 ServerSocket 绑定 8888 端口完毕
客户端 : /192.168.87.2 连接到服务器端
① byte 类型数据 : 1
② short 类型数据 : 1
③ int 类型数据 : 1
④ char 类型数据 : a
⑤ boolean 类型数据 : true
⑥ long 类型数据 : 1
⑦ float 类型数据 : 3.14
⑧ double 类型数据 : 3.14
⑨ String 类型数据 : Hello World
客户端与服务器端交互完成
相关实践学习
部署高可用架构
本场景主要介绍如何使用云服务器ECS、负载均衡SLB、云数据库RDS和数据传输服务产品来部署多可用区高可用架构。
Sqoop 企业级大数据迁移方案实战
Sqoop是一个用于在Hadoop和关系数据库服务器之间传输数据的工具。它用于从关系数据库(如MySQL,Oracle)导入数据到Hadoop HDFS,并从Hadoop文件系统导出到关系数据库。 本课程主要讲解了Sqoop的设计思想及原理、部署安装及配置、详细具体的使用方法技巧与实操案例、企业级任务管理等。结合日常工作实践,培养解决实际问题的能力。本课程由黑马程序员提供。
目录
相关文章
|
5月前
|
存储 监控 安全
单位网络监控软件:Java 技术驱动的高效网络监管体系构建
在数字化办公时代,构建基于Java技术的单位网络监控软件至关重要。该软件能精准监管单位网络活动,保障信息安全,提升工作效率。通过网络流量监测、访问控制及连接状态监控等模块,实现高效网络监管,确保网络稳定、安全、高效运行。
130 11
|
2月前
|
Java Linux 定位技术
Minecraft配置文件参数说明(JAVA服务器篇)
Minecraft JAVA版服务器启动后会生成server.properties配置文件,位于minecraft_server/根目录下。该文件包含多项关键设置,如游戏模式(gamemode)、最大玩家数(max-players)、难度(difficulty)等。此文档详细说明了各配置项的功能与默认值,帮助用户高效管理服务器环境。
343 60
|
6月前
|
Java
java小工具util系列5:java文件相关操作工具,包括读取服务器路径下文件,删除文件及子文件,删除文件夹等方法
java小工具util系列5:java文件相关操作工具,包括读取服务器路径下文件,删除文件及子文件,删除文件夹等方法
159 9
|
2月前
|
前端开发 Cloud Native Java
Java||Springboot读取本地目录的文件和文件结构,读取服务器文档目录数据供前端渲染的API实现
博客不应该只有代码和解决方案,重点应该在于给出解决方案的同时分享思维模式,只有思维才能可持续地解决问题,只有思维才是真正值得学习和分享的核心要素。如果这篇博客能给您带来一点帮助,麻烦您点个赞支持一下,还可以收藏起来以备不时之需,有疑问和错误欢迎在评论区指出~
Java||Springboot读取本地目录的文件和文件结构,读取服务器文档目录数据供前端渲染的API实现
|
2月前
|
存储 网络协议 安全
Java网络编程,多线程,IO流综合小项目一一ChatBoxes
**项目介绍**:本项目实现了一个基于TCP协议的C/S架构控制台聊天室,支持局域网内多客户端同时聊天。用户需注册并登录,用户名唯一,密码格式为字母开头加纯数字。登录后可实时聊天,服务端负责验证用户信息并转发消息。 **项目亮点**: - **C/S架构**:客户端与服务端通过TCP连接通信。 - **多线程**:采用多线程处理多个客户端的并发请求,确保实时交互。 - **IO流**:使用BufferedReader和BufferedWriter进行数据传输,确保高效稳定的通信。 - **线程安全**:通过同步代码块和锁机制保证共享数据的安全性。
118 23
|
3月前
|
安全 网络协议 Java
Java网络编程封装
Java网络编程封装原理旨在隐藏底层通信细节,提供简洁、安全的高层接口。通过简化开发、提高安全性和增强可维护性,封装使开发者能更高效地进行网络应用开发。常见的封装层次包括套接字层(如Socket和ServerSocket类),以及更高层次的HTTP请求封装(如RestTemplate)。示例代码展示了如何使用RestTemplate简化HTTP请求的发送与处理,确保代码清晰易维护。
|
3月前
|
缓存 网络协议 Java
JAVA网络IO之NIO/BIO
本文介绍了Java网络编程的基础与历史演进,重点阐述了IO和Socket的概念。Java的IO分为设备和接口两部分,通过流、字节、字符等方式实现与外部的交互。
125 0
|
4月前
|
缓存 负载均衡 安全
Swift中的网络代理设置与数据传输
Swift中的网络代理设置与数据传输
|
6月前
|
数据采集 Java API
java怎么设置代理ip:简单步骤,实现高效网络请求
本文介绍了在Java中设置代理IP的方法,包括使用系统属性设置HTTP和HTTPS代理、在URL连接中设置代理、设置身份验证代理,以及使用第三方库如Apache HttpClient进行更复杂的代理配置。这些方法有助于提高网络请求的安全性和灵活性。
249 0
|
28天前
|
存储 缓存 弹性计算
阿里云经济型e实例云服务器评测:企业官网搭建的性价比之选
阿里云服务器经济型e实例可以用来搭建企业网站吗?云服务器作为搭建企业官网的基础设施,其性能、稳定性、成本等因素直接影响着官网的运营效果。阿里云经济型e实例云服务器作为一款性价比较高的产品,备受用户关注。许多企业在选择云服务器搭建官网时,都会将其纳入考虑范围。本文将详细探讨阿里云经济型e实例云服务器的特点、性能表现、稳定性与可靠性,以及成本考量,最终解答是否适合用它来搭建企业官网。

热门文章

最新文章