Socket客户端和ServerSocket服务器端数据交互

最新推荐文章于 2024-03-01 09:36:50 发布
最新推荐文章于 2024-03-01 09:36:50 发布
阅读量528 收藏 6
点赞数 2
分类专栏： JAVA 文章标签： java 网络 socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuizya/article/details/104163487
版权

目录

  • 一、单次数据交互
    • 1.客户端+服务器端（字节流版）
    • 2.客户端+服务器端（字节流+字节缓冲流版）
  • 二、多次数据交互
  • 三、多次+多线程数据交互

一、单次数据交互

1.客户端+服务器端（字节流版）
/**
 * 客户端（字节流版）
 */
public class TCPClient {
    public static void main(String[] args) {
        TCPClient.clientStart();
    }

    private static void clientStart(){
        Socket socket = null;
        OutputStream os = null;
        InputStream is = null;
        try {
            //1.创建客户端对象Socket
            socket = new Socket("127.0.0.1",8888);
            //2.使用Socket对象中的方法getOutputStream获取网络字节输出流OutputStream对象
            os = socket.getOutputStream();
            //3.使用网络字节输出流OutputStream对象的write()，给服务器发送数据
            os.write("服务器，你好！".getBytes());
            os.flush();

            //4.使用Socket对象中的getInputStream()获取网络字节输入流InputStream对象
            is = socket.getInputStream();
            //5.使用网络字节输入流InputStream对象的read()，读取服务器回写的数据
            byte[] bytes = new byte[1024];
            int len=is.read(bytes);
            System.out.println(new String(bytes,0,len));
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //6.释放资源
                is.close();
                os.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

/**
 * 服务器端（字节流版）
 */
public class TCPServer {
    public static void main(String[] args){
        TCPServer.serverStart();
    }

    private static void serverStart(){
        Socket socket = null;
        ServerSocket serverSocket = null;
        try {
            //1.创建服务器ServerSocket对象，向系统要指定的端口号
            serverSocket = new ServerSocket(8888);
            //2.使用ServerSocket对象中的accept()，获取到请求的客户端Socket对象
            socket = serverSocket.accept();
            //3.使用Socket对象中的getInputStream()获取网络字节输入流InputStream对象
            InputStream is = socket.getInputStream();
            //4.使用网络字节输入流InputStream对象的read()，读取客户端发送的数据
            byte[] bytes = new byte[1024];
            int len=is.read(bytes);
            System.out.println(new String(bytes,0,len));

            //5.使用Socket对象中的方法getOutputStream获取网络字节输出流OutputStream对象
            OutputStream os = socket.getOutputStream();
            //6.使用网络字节输出流OutputStream对象的write()，给客户端发送数据
            os.write("收到谢谢！".getBytes());
            os.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //7.释放资源（Socket，ServerSocket）
                socket.close();
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
2.客户端+服务器端（字节流+字节缓冲流版）
/**
 * 客户端（字节流+字节缓冲流版）
 */
public class TCPClient {
    public static void main(String[] args) {
        TCPClient.clientStart1();
    }

    /**
     * 含缓冲流
     */
    private static void clientStart1() {
        Socket socket = null;
        try {
            socket = new Socket("127.0.0.1",8888);
            //向服务器发送信息
            DataOutputStream pos = new DataOutputStream(socket.getOutputStream());
            pos.writeUTF("你好服务器");
            pos.flush();
            //接受服务器返回的信息
            DataInputStream dis = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
            System.out.println("服务器返回的信息===>" + dis.readUTF());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try{
                //释放资源
                socket.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

/**
 * 服务器端（字节流+字节缓冲流版）
 */
public class TCPServer {
    public static void main(String[] args){
        TCPServer.serverStart1();
    }

    /**
     * 含缓冲流
     */
    private static void serverStart1(){
        ServerSocket serverSocket = null;
        Socket socket = null;
        try {
            serverSocket = new ServerSocket(8888);
            socket = serverSocket.accept();
            //接收客户端的信息
            DataInputStream dis = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
            System.out.println("客户端信息===>" + dis.readUTF());
            //发送消息给客户端
            DataOutputStream pos = new DataOutputStream(socket.getOutputStream());
            pos.writeUTF("收到谢谢!!");
            pos.flush();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                //7.释放资源（Socket，ServerSocket）
                socket.close();
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

二、多次数据交互

import java.io.*;
import java.net.Socket;

/**
 * 客户端
 */
public class TCPClient {
    public static void main(String[] args) {
        uploadLocalFile();
    }

    private static void uploadLocalFile() {
        //1.获取文件
        File localFile = new File("E:\\test.txt");
        if (!localFile.exists()) {
            System.out.println("需要读取的文件不存在");
            return;
        }
        Socket socket = null;
        InputStream isFile = null;
        OutputStream opsSocket = null;

        InputStream isSocket = null;
        try {
            //2.获取本地的文件流
            isFile = new FileInputStream(localFile);
            socket = new Socket("127.0.0.1", 8888);
            //3.获取socket的OutputStream对象
            opsSocket = socket.getOutputStream();
            int len;
            byte[] bytes = new byte[1024];
            //4.循环读取本地文件流——>输出到socket的OutputStream对象流中——>传到服务器
            while ((len = isFile.read(bytes)) != -1) {
                opsSocket.write(bytes, 0, len);
            }
            opsSocket.flush();

            //解决文件上传时，文件阻塞问题
            socket.shutdownOutput();

            //5.获取服务器返回信息的流
            isSocket = socket.getInputStream();
            bytes = new byte[1024];
            //6.输出服务器返回的信息
            while ((len = isSocket.read(bytes)) != -1) {
                System.out.println("===>>>服务器返回信息：" + new String(bytes, 0, len));
            }
            System.out.println("===>>>客户端结束");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                opsSocket.close();
                isFile.close();
                isSocket.close();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;

/**
 * 服务器端（持续启动）
 */
public class TCPServer {
    public static void main(String[] args){
        saveFile(true);
    }

    private static void saveFile(boolean init){
        String fileName;
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(8888);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //服务器持续启动
        while (true){
            if(init){
                System.out.println("====>>>服务器启动");
                init=false;
                continue;
            }
            fileName = "testSave_"+System.currentTimeMillis()+new Random().nextInt(9999)+".txt";
            //1.获取保存文件的路径
            File saveFile = new File("E:\\"+fileName);

            Socket socket = null;
            InputStream isSocket = null;
            OutputStream osFile = null;
            OutputStream osSocket = null;
            try{
                //2.获取客户端信息
                socket = serverSocket.accept();
                //3.获取socket的Inputstream对象——>获取从客户端传过来的文件流
                isSocket = socket.getInputStream();
                osFile = new FileOutputStream(saveFile);
                int len;
                byte[] bytes = new byte[1024];
                //4.输出客户端文件到本地
                while ((len=isSocket.read(bytes))!=-1){
                    osFile.write(bytes,0,len);
                }
                osFile.flush();

                //5.向客户端返回信息
                osSocket = socket.getOutputStream();
                osSocket.write("上传文件成功".getBytes());
                osSocket.flush();
                System.out.println("===>>>保存客户端传送的文件 结束");
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                try {
                    osSocket.close();
                    osFile.close();
                    isSocket.close();
                    socket.close();
                    //serverSocket.close();//不需要关闭serverSocket
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

三、多次+多线程数据交互

import java.io.*;
import java.net.Socket;

/**
 * 客户端
 */
public class TCPClient {
    public static void main(String[] args) {
        uploadLocalFile();
    }

    private static void uploadLocalFile() {
        //1.获取文件
        File localFile = new File("E:\\test.txt");
        if (!localFile.exists()) {
            System.out.println("需要读取的文件不存在");
            return;
        }
        Socket socket = null;
        InputStream isFile = null;
        OutputStream opsSocket = null;

        InputStream isSocket = null;
        try {
            //2.获取本地的文件流
            isFile = new FileInputStream(localFile);
            socket = new Socket("127.0.0.1", 8888);
            //3.获取socket的OutputStream对象
            opsSocket = socket.getOutputStream();
            int len;
            byte[] bytes = new byte[1024];
            //4.循环读取本地文件流——>输出到socket的OutputStream对象流中——>传到服务器
            while ((len = isFile.read(bytes)) != -1) {
                opsSocket.write(bytes, 0, len);
            }
            opsSocket.flush();

            //解决文件上传时，文件阻塞问题
            socket.shutdownOutput();

            //5.获取服务器返回信息的流
            isSocket = socket.getInputStream();
            bytes = new byte[1024];
            //6.输出服务器返回的信息
            while ((len = isSocket.read(bytes)) != -1) {
                System.out.println("===>>>服务器返回信息：" + new String(bytes, 0, len));
            }
            System.out.println("===>>>客户端结束");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                opsSocket.close();
                isFile.close();
                isSocket.close();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;

/**
 * 服务器端（持续启动+多线程）
 */
public class TCPServerMultiThread {
    public static void main(String[] args){
        saveFile(true);
    }

    private static void saveFile(boolean init){
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(8888);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //服务器持续启动
        while (true){
            if(init){
                System.out.println("====>>>服务器启动");
                init=false;
                continue;
            }
            try{
                //2.获取客户端信息
                Socket socket = serverSocket.accept();

                //开启多线程
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        String fileName = "testSave_"+System.currentTimeMillis()+new Random().nextInt(9999)+".txt";
                        //1.获取保存文件的路径
                        File saveFile = new File("E:\\"+fileName);
                        InputStream isSocket = null;
                        OutputStream osFile = null;
                        OutputStream osSocket = null;
                        try{
                            //3.获取socket的Inputstream对象——>获取从客户端传过来的文件流
                            isSocket = socket.getInputStream();
                            osFile = new FileOutputStream(saveFile);
                            int len;
                            byte[] bytes = new byte[1024];
                            //4.输出客户端文件到本地
                            while ((len=isSocket.read(bytes))!=-1){
                                osFile.write(bytes,0,len);
                            }
                            osFile.flush();

                            //5.向客户端返回信息
                            osSocket = socket.getOutputStream();
                            osSocket.write("上传文件成功".getBytes());
                            osSocket.flush();
                            System.out.println("===>>>保存客户端传送的文件 结束");
                        }catch (IOException e){
                            e.printStackTrace();
                        }finally {
                            try{
                                osSocket.close();
                                osFile.close();
                                isSocket.close();
                                socket.close();
                            }catch (IOException e){
                                e.printStackTrace();
                            }
                        }
                    }
                }).start();
            }catch (IOException e){
                e.printStackTrace();
            }
            //不需要关闭serverSocket
            //serverSocket.close();
        }
    }
}
Xini_Su
关注
专栏目录
Plant Simulation与python之Socket通信的数据交互问题
santayana的专栏
03-14 962
在Python中，可以非常方便地处理Json，同样Plant Simulation16版本以上也是可以非常方便的将字符串转换成Json。很多时候，需要传输的数据在DataTable这类的表格之中，那我们怎么快速地发送呢。在Plant Simulation与python过程中采用Socket通信时，常常会遇到大数据发送的问题，尤其是如何高效地发送Table的数据问题。调用上述的GetTableValue就能得到所有的表格指，我们只需要在传过来的Json数据中，指明表格的列数，那这个表格就能够还原了。
使用Socket和ServerSocket实现客户端和服务器端的数据传输
兔子王
10-25 1001
使用Socket和ServerSocket实现客户端和服务器端的数据传输。
Socket简单实现数据交互及上传
weixin_30564901的博客
10-15 185
　　 声明：本文为原创，如需转载请说明出处：http://www.cnblogs.com/gudu1/p/7669175.html 　　首先为什么要写这个呢？因为在几个月之前我还使用Socket做一个小项目，而在今天我回想起Socket的操作细节，在我脑海里使劲挖掘Socket的痕迹，竟然丝毫没有找到，所以立即写了一个小Demo来记录一下，有些东西长时间不用肯定要忘的，人的脑容量有限，...
客户端和服务器数据交互
hbxtlhx的专栏
11-14 3329
客户端一次把数据取出，还是分多次来取? 有的人说把数据一次从数据库取到客户端然后在客户端任意处理效率会高。有的人说把一次性把所有数据取到客户端很耗时且数据大多没有用处最好分次处理。其实这两个说法并不矛盾，只是他们实用的方面是不同的。１：如果数据最不大，但是可能会和服务器发生多次交互，最好一次把数据取出到客户端来提高处理效率，比如我们要从数据库取出数据组织一个树型控件，因为它是个树状
Socket客户端向服务端发送数据
04-27
Socket客户端向服务端发送数据，启动服务后使用浏览器访问默认ip+端口号，服务端可以获取请求信息。
使用socketserver实现客户端和服务器端简单的并发交互
weixin_44017891的博客
04-04 280
#服务器端 import socketserver class MyServer(socketserver.BaseRequestHandler): def handle(self):#这个函数式必须要写的 print('conn is',self.request) #conn print('addr is',self.client_address) #a...
Android客户端与服务器端的json数据交互（内含大量知识点）
03-03
Android客户端与服务器端的json数据交互（内含大量知识点），包含文件的上传，文件浏览器等。
Java-web客户端和服务器端交互的原理.doc
12-14
Java-web客户端和服务器端交互的原理 ...Java-web客户端和服务器端交互的原理是通过套接字来实现的，客户端和服务器端之间通过socket无状态连接进行交互，通过IO流进行报文信息交互，最后会话结束后关闭连接。
socket通信客户端和服务器端
09-30
- **创建ServerSocket**：首先，服务器端需要创建一个Socket实例，通过调用`new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)`来指定协议类型。 - **绑定端口**：使用`Bind()`方法将...
android基于WiFi的socket客户端和服务器端
10-29
通过以上步骤和注意事项，我们可以创建出能在Android设备上运行的基于WiFi的Socket客户端和服务器端应用程序，实现两端之间的数据传输。在"SocketServer"和"SocketClient"的源代码中，你可以看到这些概念是如何具体...
Socket发送并接收服务器返回的数据
05-19
移动开发 Android Socket Socket发送并接收服务器返回的数据 个人整理 。
GPRS　　SOCKET通信　
04-15
GPRS的SOCKET通信程序，详细给出了程序的实现过程，有注释。-GPRS-SOCKET communications procedures, detailed procedures are given the realization of the process, there are notes.
实现客户端与服务端的交互ServerSocket
m0_69258341的博客
08-11 845
serverSocket，Java实现客户端服务器交互的简易交互
使用socketserver模块和socket模块模拟客户端和服务器端通信
weixin_34351321的博客
07-23 111
2019独角兽企业重金招聘Python工程师标准>>> ...
Socket ServerSocket
ITBOY_ITBOX博客
03-01 454
package com.tt;import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.InetAddress; import java.net.ServerSocket; import java.net.Socket; import java.
如何创建一个ServerSocket来监听客户端连接？
最新发布
m0_47946173的博客
03-01 911
要创建一个ServerSocket来监听客户端连接，可以按照以下步骤进行： 1. 导入必要的Java类库：
java网络编程Socket实现客户端向服务端发送信息
小灰狼与大白兔的博客
12-14 1万+
（可按目录按需阅读，我一般会整理的比较细） 前置知识 java IO Socket 什么是socket？socket字面意思其实就是一个插口或者套接字，包含了源ip地址、源端口、目的ip地址和源端口。 但是socket在那个位置呢 ，在TCP/IP网络的四层体系和OSI七层好像都找不到他的影子，如下图所示， Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的
Socket和ServerSocket的简单介绍及例子
热门推荐
积微成著
01-08 8万+
Socket 类 　　socket可以使一个应用从网络中读取和写入数据，不同计算机上的两个应用可以通过连接发送和接受字节流，当发送消息时，你需要知道对方的ip和端口，在java中，socket指的是java.net.Socket类。 　　在java.net.Socket中，可以看到socket有多种构造函数 　　 　　 　　以public Socket(String host, int ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值