TCP流套接字编程

最新推荐文章于 2023-03-22 14:38:20 发布
最新推荐文章于 2023-03-22 14:38:20 发布
阅读量427 收藏 1
点赞数
分类专栏： # JavaSE 文章标签： tcp/ip 网络 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56444564/article/details/129102781
版权

ServerSocket API

ServerSocket 是创建TCP服务端Socket的API。

ServerSocket 构造方法：
 

ServerSocket 方法：
 

Socket API

Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的.

Socket 构造方法：


 

Socket 方法：


 

 

TCP中的长短连接

TCP发送数据时，需要先建立连接，什么时候关闭连接就决定是短连接还是长连接：
短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。
长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。
对比以上长短连接，两者区别如下：

  • 建立连接、关闭连接的耗时：短连接每次请求、响应都需要建立连接，关闭连接；而长连接只需要第一次建立连接，之后的请求、响应都可以直接传输。相对来说建立连接，关闭连接也是要耗时的，长连接效率更高。
  • 主动发送请求不同：短连接一般是客户端主动向服务端发送请求；而长连接可以是客户端主动发送请求，也可以是服务端主动发。
  • 两者的使用场景有不同：短连接适用于客户端请求频率不高的场景，如浏览网页等。长连接适用于客户端与服务端通信频繁的场景，如聊天室，实时游戏等。

扩展了解：
基于BIO（同步阻塞IO）的长连接会一直占用系统资源。对于并发要求很高的服务端系统来说，这样的消耗是不能承受的。

由于每个连接都需要不停的阻塞等待接收数据，所以每个连接都会在一个线程中运行。
一次阻塞等待对应着一次请求、响应，不停处理也就是长连接的特性：一直不关闭连接，不停的处理请求。

实际应用时，服务端一般是基于NIO（即同步非阻塞IO）来实现长连接，性能可以极大的提升。
 

示例一：一发一收（短连接）

以下为一个客户端一次数据发送，和服务端多次数据接收（一次发送一次接收，可以接收多次），即只有客户端请求，但没有服务端响应的示例：

TCP服务端

package net1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServer {
    private static final int port = 8888;

    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(port);
        while (true) {
            System.out.println("------------------------------------");
            System.out.println("等待客户端建立TCP连接...");
            Socket client = server.accept();
            System.out.println("客户端ip :" + client.getInetAddress().getHostAddress());
            System.out.println("客户端port :" + client.getPort());
            System.out.println("接收到客户端请求：>>");
            InputStream inputStream = client.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
            String line;

            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line);
            }
            client.close();
        }
    }
}


TCP客户端

package net1;

import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;

public class TcpClient {
    private static final String host = "127.0.0.1";
    private static final int port = 8888;

    public static void main(String[] args) throws IOException {
        Socket client = new Socket(host, port);
        OutputStream outputStream = client.getOutputStream();
        PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(outputStream, "utf-8"));
        printWriter.println("Hello I am client");
        printWriter.flush();
        client.close();
    }
}

以上客户端与服务端建立的为短连接，每次客户端发送了TCP报文，及服务端接收了TCP报文后，双方都会关闭连接。

示例二：请求响应（短连接）

构造一个展示服务端本地某个目录的下一级子文件列表的服务

  1. 客户端先接收键盘输入，表示要展示的相对路径（相对BASE_PATH的路径）
  2. 发送请求：使用客户端Socket的输出流发送TCP报文。即输入的相对路径。
  3. 服务端接收并处理请求：使用服务端Socket的输入流来接收请求报文，根据请求的路径，列出下一级子文件及子文件夹。
  4. 服务端返回响应：使用服务端Socket的输出流来发送响应报文。即遍历子文件和子文件夹，每个文件名一行，返回给客户端。
  5. 客户端接收响应：使用客户端Socket的输入流来接收响应报文。简单的打印输出所有的响应内容，即文件列表。

TCP服务端
 

package net1;

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

public class TcpEchoServer {
    private static final int port = 8888;

    private static final String path = "";

    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(port);
        while (true) {
            System.out.println("-------------------------------");
            System.out.println("等待客户端建立TCP连接...");
            Socket socket = server.accept();
            System.out.println("客户端ip :" + socket.getInetAddress().getHostAddress());
            System.out.println("客户端port :" + socket.getPort());
            InputStream inputStream = socket.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
            String request = bufferedReader.readLine();
            System.out.println("客户端请求的文件路径为：" + path + request);
            File dir = new File(path + request);
            File[] files = dir.listFiles();
            OutputStream outputStream = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(new OutputStreamWriter(outputStream, "utf-8"));
            if (files != null) {
                for (File f : files) {
                    writer.println(f.getName());
                }
            }
            writer.flush();
            socket.close();
        }
    }
}


 TCP客户端

package net1;

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

public class TcpEchoClient {
    private static final String host = "127.0.0.1";

    private static final int port = 8888;

    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("----------------------------------");
            System.out.println("请输入要展示的目录：");
            String request = scanner.nextLine();
            Socket socket = new Socket(host, port);
            OutputStream outputStream = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(new OutputStreamWriter(outputStream, "utf-8"));
            writer.println(request);
            writer.flush();
            System.out.println("接收到服务端响应：");
            InputStream inputStream = socket.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
            String line = null;
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line);
            }
            socket.close();
        }
    }

}

回顾并理解为什么需要协议

以上我们实现的UDP和TCP数据传输，除了UDP和TCP协议外，程序还存在应用层自定义协议，可以想想分别都是什么样的协议格式。
 

对于客户端及服务端应用程序来说，请求和响应，需要约定一致的数据格式：

  • 客户端发送请求和服务端解析请求要使用相同的数据格式。
  • 服务端返回响应和客户端解析响应也要使用相同的数据格式。
  • 请求格式和响应格式可以相同，也可以不同。
  • 约定相同的数据格式，主要目的是为了让接收端在解析的时候明确如何解析数据中的各个字段。
  • 可以使用知名协议（广泛使用的协议格式），如果想自己约定数据格式，就属于自定义协议。
     

封装/分用 vs 序列化/反序列化

一般来说，在网络数据传输中，发送端应用程序，发送数据时的数据转换（如java一般就是将对象转换为某种协议格式），即对发送数据时的数据包装动作来说：

  • 如果是使用知名协议，这个动作也称为封装
  • 如果是使用小众协议（包括自定义协议），这个动作也称为序列化，一般是将程序中的对象转换为特定的数据格式。

接收端应用程序，接收数据时的数据转换，即对接收数据时的数据解析动作来说：

  • 如果是使用知名协议，这个动作也称为分用
  • 如果是使用小众协议（包括自定义协议），这个动作也称为反序列化，一般是基于接收数据特定的格式，转换为程序中的对象

如何设计协议

对于协议来说，重点需要约定好如何解析，一般是根据字段的特点来设计协议：
对于定长的字段：

  • 可以基于长度约定，如int字段，约定好4个字节即可

对于不定长的字段：

  • 可以约定字段之间的间隔符，或最后一个字段的结束符，如换行符间隔，\3符号结束等等
  • 除了该字段“数据”本身，再加一个长度字段，用来标识该“数据”长度；即总共使用两个字段：“数据”字段本身，不定长，需要通过“长度”字段来解析；“长度”字段，标识该“数据”的长度，即用于辅助解析“数据”字段；


示例三：多线程+自定义协议

以下我们将示例二的业务做以下扩展：

  • 提供多种操作：展示目录下文件列表，文件重命名，删除文件，上传文件，下载文件
  • 在不同的操作中，需要抽象出请求和响应的字段，也即是说，要约定客户端服务端统一的请求协议，同时也要约定服务端与客户端统一的响应协议


本示例中的自定义协议

以下为我们TCP请求数据的协议格式，这里简单起见，约定为换行符及结束符：

  1. 请求类型
  2. 操作的文件或目录路径
  3. 数据\3

说明如下：

  • 以上总共包含3个字段，前2个字段需要按换行符读取，最后一个字段需要按结束符读取
  • 请求类型标识是什么操作：展示目录下文件列表，文件重命名，删除文件，上传文件，下载文件
  • 重命名、上传文件操作，需要“数据”字段，其他操作可以置为空字符串
  • “数据”字段为最后一个字段，使用\3结束符，这样在数据本身有换行符也能正确处理

以下为响应数据的协议格式：

  • 状态码（标识是否操作成功）
  • 数据（展示列表时，返回目录下的文件列表，或下载文件的数据）\3


 以下为展示文件列表操作的自定义协议（请求、响应格式）

以下操作将展示服务端根目录下的子文件及子文件夹：

请求数据格式如下：

1

/
\3

响应数据格式如下：

200
\1
\2
\3
\1.txt
\2.txt\3

以下为上传文件操作的自定义协议（请求、响应格式）

需要先在客户端指定上传的服务端目录，及客户端要上传的文件路径，以下操作将会把客户端
Main.java 文件内容上传到服务端根目录 E:/TMP 下的 /1 目录下：



 请求数据格式如下：

4
/1
package org.example;


public class Main {
……略
}\3

 响应数据格式如下：

200
\3

代码实现如下：

先按照约定的请求协议封装请求类：

每个字段为一个属性：操作类型，操作路径，数据
完成服务端解析请求封装：按约定的方式读，先按行读取前2个字段，再按结束符读第3个字段
完成客户端发送请求封装：按约定的方式写，前2个字段按行输出，第3个字段以\3结束

请求类

  • 每个字段为一个属性：操作类型，操作路径，数据
  • 完成服务端解析请求封装：按约定的方式读，先按行读取前2个字段，再按结束符读第3个字段
  • 完成客户端发送请求封装：按约定的方式写，前2个字段按行输出，第3个字段以\3结束
     
package net1;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class Request {
    //操作类型：1（展示目录文件列表），2（文件重命名），3（删除文件），4（上传文件），5（下载文件）
    private Integer type;
    private String url;
    private String data;

    //服务端解析请求时：根据约定好的格式来解析
    public static Request serverParse(InputStream inputStream) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
        Request request = new Request();
        request.type = Integer.parseInt(bufferedReader.readLine());
        request.url = bufferedReader.readLine();
        List<Character> list = new ArrayList<>();
        while (true) {
            char c = (char) bufferedReader.read();
            if (c == '\3') {
                break;
            }
            list.add(c);
        }
        StringBuilder stringBuilder = new StringBuilder();
        for (char c : list) {
            stringBuilder.append(c);
        }
        request.data = stringBuilder.toString();
        return request;
    }

    //客户端发送请求到服务器
    public void clientWrite(OutputStream outputStream) {
        PrintWriter printWriter = new PrintWriter(outputStream);
        printWriter.println(type);
        printWriter.println(url);
        printWriter.write(data + "\3");
        printWriter.flush();
    }

    @Override
    public String toString() {
        return "Request{" +
                "type=" + type +
                ", url='" + url + '\'' +
                ", data='" + data + '\'' +
                '}';
    }

    public Integer getType() {
        return type;
    }

    public void setType(Integer type) {
        this.type = type;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }
}

 

响应类

  • 每个字段为一个属性：响应状态码
  • 完成客户端解析响应封装：按约定的方式读，先按行读取第1个字段，再按结束符读第2个字段
  • 完成服务端发送响应封装：按约定的方式写，第1个字段按行输出，第2个字段以\3结束
     
package net1;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class Response {
    private int status;
    private String data;

    //客户端解析服务端返回的响应数据
    public static Response clientParse(InputStream inputStream) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
        Response response = new Response();
        response.status = Integer.parseInt(bufferedReader.readLine());
        List<Character> list = new ArrayList<>();
        while (true) {
            char c = (char) bufferedReader.read();
            if (c == '\3') {
                break;
            }
            list.add(c);
        }
        StringBuilder stringBuilder = new StringBuilder();
        for (char c : list) {
            stringBuilder.append(c);
        }
        response.data = stringBuilder.toString();
        return response;
    }

    //服务端返回响应给客户端
    public void serverWrite(OutputStream outputStream) throws UnsupportedEncodingException {
        PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(outputStream, "utf-8"));
        printWriter.println(status);
        printWriter.write(data + "\3");
        printWriter.flush();
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "Response{" +
                "status=" + status +
                ", data='" + data + '\'' +
                '}';
    }
}

 

TCP服务端

  • ServerSocket.accept() 为建立客户端服务端连接的方法，为提高效率，使用多线程
  • 先要解析请求数据，即 Request 已封装好的服务端解析请求，返回 Request 对象
  • 返回响应数据，需要根据不同的请求字段，做不同的业务处理，并返回对应的响应内容如果操作的url路径再服务端根目录 E:/TMP 下找不到，则返回响应状态码404正常执行完，返回200响应状态码；要注意根据不同操作类型来执行不同的业务
     
package net1;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.file.Files;
import java.util.UUID;

public class TcpFileServer {
    private static final int port = 8888;
    private static final String path = "";

    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(port);
        while (true) {
            Socket socket = server.accept();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("------------------------------");
                        System.out.println("客户端建立TCP连接...");
                        System.out.println("客户端IP: " + socket.getInetAddress().getHostAddress());
                        InputStream inputStream = socket.getInputStream();

                        Request request = Request.serverParse(inputStream);
                        System.out.println("服务器收到请求： " + request);

                        Response response = build(request);
                        OutputStream outputStream = socket.getOutputStream();
                        System.out.println("服务器返回响应： " + response);
                        response.serverWrite(outputStream);
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

    public static Response build(Request request) throws IOException {
        Response response = new Response();
        response.setStatus(200);
        File url = new File(path + request.getUrl());

        if (!url.exists()) {
            response.setStatus(404);
            response.setData("");
            return response;
        }

        try {
            switch (request.getType()) {
                case 1: {
                    File[] childer = url.listFiles();
                    if (childer == null) {
                        response.setData("");
                    } else {
                        StringBuilder stringBuilder = new StringBuilder();
                        for (int i = 0; i < childer.length; i++) {
                            File child = childer[i];
                            stringBuilder.append(child.getAbsolutePath().substring(path.length()) + "\n");
                        }
                        response.setData(stringBuilder.toString());
                    }
                    break;
                }
                case 2: {
                    url.renameTo(new File(url.getParent() + File.separator + request.getData()));
                    break;
                }
                case 3: {
                    url.delete();
                    break;
                }
                case 4: {
                    FileWriter upload = new FileWriter(url.getAbsolutePath() + File.separator + UUID.randomUUID());
                    upload.write(request.getData());
                    upload.flush();
                    upload.close();
                    break;
                }
                case 5: {
                    String data = new String(Files.readAllBytes(url.toPath()));
                    response.setData(data);
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return response;
    }
}

 

TCP客户端

  • 先要建立和服务端的连接，连接服务端的IP和端口
  • 根据输入来构建请求数据：先接收操作类型和操作路径重命名操作时，需要指定修改的文件名
    文件上传操作时，需要指定上传的客户端本地文件路径
  •  解析响应数据，并根据响应来执行相应的业务，我们这里暂时简单的解析为 Response 对象，并打印即可
package net1;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Scanner;

public class TcpFileClient {
    private static final String host = "127.0.0.1";
    private static final int port = 8888;

    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            Request request = build(scanner);
            Socket socket = new Socket(host, port);
            OutputStream outputStream = socket.getOutputStream();
            System.out.println("客户端发送请求：" + request);
            request.clientWrite(outputStream);

            InputStream inputStream = socket.getInputStream();
            Response response = Response.clientParse(inputStream);
            System.out.println("客户端收到响应: " + response);

            socket.close();
        }
    }

    private static Request build(Scanner scanner) throws IOException {
        System.out.println("-----------------------------");
        System.out.println("请输入要操作的类型：1（展示目录文件列表） 2（文件重命名） 3（删除文件） 4（上传文件） 5（下载文件）");
        Request request = new Request();
        int type = Integer.parseInt(scanner.nextLine());
        System.out.println("请输入要操作的路径：");
        String url = scanner.nextLine();
        String data = "";
        if (type == 2) {
            System.out.println("请输入要重命名的名称：");
            data = scanner.nextLine();
        } else if (type == 4) {
            System.out.println("请输入要上传的文件路径：");
            String upload = scanner.nextLine();
            data = new String(Files.readAllBytes(Paths.get(upload)));
        } else if (type != 1 && type != 3 && type != 5) {
            System.out.println("只能输入1-5的数字，请重新输入");
            return build(scanner);
        }
        request.setType(type);
        request.setUrl(url);
        request.setData(data);
        return request;
    }
}

 

阿瞒有我良计15
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
使用TCP通信的知识，编写一个文件上传的程序
YRZsir的博客
11-21 1666
先写服务器端，必须先执行服务器端。这个是在本机的，所以IP地址使用的是127.0.0.1。如果服务器不是本机，修改服务器的IP地址即可。 package wangluobiancheng; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputS...
【网络编程】利用流式套接字实现文件传输实验
弱菜zc
02-24 3456
实验内容： 1.    客户端向服务端发起socket连接，并建立数据传输通道； 2.    客户端向服务端发送要传输的文件名称，以‘#’字符结尾，服务端逐字符接收，直到接收到#；（变长数据） 3.    客户端向服务端发送文件长度，4字节；（定长数据） 4.    客户端向服务端发送文件内容；（变长数据） 5.    服务端接收完文件后，向客户端发送‚”OK”，以示成功接收。 6.
基本的TCP套接字编程（详解）
M的博客
09-25 6754
目录一、预备知识1. 理解源IP地址和目的IP地址2. 理解源端口号和目的端口号 3. 通过IP地址、端口号、协议号进行通信识别 4. 认识TCP协议和UDP协议1.UDP的特点及目的2.TCP的特点及目的 5. 网络字节序1. 大端字节序和小端字节序的回顾 2. 字节序6. 地址转换函数 1. inet_aton函数2. inet_ntoa函数3. inet_addr函数二、socket编程接口1. socket常见的API1. 创建套接字2. 绑定端口号3. 监听套接字4. 接受请求5. 建立连接2.
TCP程序设计之简单的文件传输程序设计
Megurine_Luka_的博客
01-28 1242
任务 设计服务端与客户端程序，从服务端输入要传送的文件路径，将文件传送给客户端，客户端接收文件并保存到指定位置。 服务端 #define _WINSOCK_DEPRECATED_NO_WARNINGS #define _CRT_SECURE_NO_WARNINGS #include "WinSock2.h" #include "iostream" #include "fstream" ...
网络编程套接字（ TCP ）
bit_zyx的博客
03-22 3221
目录 1、实现一个TCP网络程序（单进程版） 1.1、服务端serverTcp.cc文件 服务端创建套接字 服务端绑定 服务端监听 服务端获取连接 服务端提供服务 服务端main函数命令行参数 服务端serverTcp.cc总代码
TCP_Socket.rar_tcp套接字编程
09-20
在IT行业中，网络编程是不可或缺的一部分，而TCP套接字编程是实现可靠网络通信的核心技术。TCP（Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议，广泛应用于互联网上的各种...
网络编程套接字 - TCP套接字
最新发布
09-08
下面将详细介绍TCP套接字的工作原理、特性以及在不同版本中的实现方式。 TCP套接字的工作流程主要包括以下几个步骤： 1. 建立连接：在TCP通信开始前，必须先建立连接，这被称为三次握手。客户端发送一个SYN（同步...
Python网络编程之TCP套接字简单用法示例
09-20
在Python中，我们可以使用内置的`socket`模块来实现TCP套接字编程。下面将详细介绍TCP套接字的基本用法，并通过客户端和服务器端的示例代码进行解释。 首先，我们需要导入`socket`模块，它是Python进行网络编程的...
python 基于TCP协议的套接字编程详解
01-01
基于TCP协议的套接字编程 实现电话沟通为例,这里传递的是字符,可以自己尝试去发送一个文件 # 服务端 import socket # 1. 符合TCP协议的手机 server = socket.socket(socket.AF_INET,socket.SOCK_STREAM) # TCP # 2...
TCP套接字编程
06-22
TCP 套接字编程 本文主要介绍了基于 TCP 套接字的文件传输客户服务器程序设计，通过实验实现了迭代服务器、并发服务器和使用单进程和 select 的 TCP 服务器，掌握了基于 TCP 套接口的网络程序设计和大规模文件传输...
基于tcp，编写基于流式套接字的通信程序。
12-20
基于tcp，编写基于流式套接字的通信程序。 任务一：C++版同步通信程序 客户端连接后服务器能够发送一个欢迎消息给客户端，客户端发送time，发送当前时间（字符串形式）给客户端；客户端发送date，发送当前日期（字符串）给客户端；客户端输入quit，则退出程序 任务二：C#版同步通信程序 创建基于C#的网络通信程序，功能与任务一类似 测试时，两个客户端和服务器交叉运行，查看运行情况
利用流式套接字写一个简单的文本传输程序
zsysingapore的博客
10-27 669
1.要求 （1）服务器程序和客户端程序为控制台应用程序 （2）服务器是文件发送放，服务器程序启动后从键盘输入要发送的文件的存放位置和文件名，等待客户端下载该文件。 （3）客户端程序是文件的接收方，客户端程序启动后要求输入服务器IP地址以及用的TCP端口号，然后与服务器建立连接并下载服务器提供的文件，文件保存到C盘根目录下。 2.声明 1)程序中包含头文件 #include “fstream” 2)定义文件流变量 ifstream inFile;//输入文件流对象 ofstream outFile;//定义输
网络编程（套接字），实现简单的文件上传和文件下载，Socket,TCP,UDP传输协议
虚空掠夺者~
08-31 1384
基于网络进行数据传输（IO流—） 网络七层模型： 物理层 ，数据链路层，网络层，传输层（UDP、TCP），会话层，表示层，应用层 IP地址：主机在网络中的位置 IPv4是由四个 0~255的数字组成 查看本机的Ip地址： ipconfig **域名解析器：**把域名解析成对应的IP地址在网络中 **端口：**让计算机和外界进行数据交互的媒介 端口号： - 取值范围：0~65535 - 从0—1024端口号基本都被系统占用了，使用时 从后面开始使用 IP用来查找对应的主机，端
TCP通信综合案例——文件上传案例
weixin_44664432的博客
10-16 230
文件上传原理： 客户端代码： 文件上传案例的客户端：读取本地文件，上传到服务器，读取服务器回写的数据 明确： 数据源：D:\\1.jpg 目的地：服务器 实现步骤： 1.创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源 2.创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号 3.使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象 4.使用本地输入流
网络编程入门、TCP通信程序、文件上传案例
qq_43430343的博客
07-11 368
一、网络编程入门 软件结构 C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件。 B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。 两种架构各有优势，但是无论哪种架构，都离不开网络的支持。网络编程，就是在一定的协议下，实现两台计算机的通信的程序。 网络通信协议 网络通信协议： 通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中
网络编程01：TCP上传文件
给bug点个赞
10-02 126
TCP上传文件 客户端负责上传文件，服务端负责接收文件 多看注释 客户端 客户端需要一个创建一个socket连接，用第地址和端口号 接着需要一个输出流，用来写文件 接着需要一个输出流，用来读取文件 然后通知服务器，我传输完毕 接着需要创建输入流和管道输出流来接收服务器反馈信息 释放资源 package Tcp上传文件; import java.io.*; import java.net.InetAddress; import java.net.Socket; public class TcpCl.
套接字编程
笔记|思路|总结
06-18 2954
socke本身有“插座”的意思，在环境下，用于表示进程间网络通信的特殊文件类型。本质为内核借助缓冲区形成的伪文件。既然是文件，那么我们就可以使用文件描述符来引用套接字。与管道类似，系统将套接字封装成文件的目的是为了统一接口，使得读写套接字和读写文件的操作一致。管道与套接字的区别是：在TCP/IP协议中，“IP地址+TCP或UDP端口号”唯一标识网络通讯中的一个进程。“IP地址+端口号”就对应一个。欲建立连接的两个进程各自有一个来标识，那么这两个组成的就唯一标识一个连接。因此可以用来描述网络连接的一对一关系。
利用TCP完成文件传输的设计和实现
ming_514
10-22 2867
实验课的内容，建立tcp 实现文件的传输，需要注意的一个地方就是，客户端和服务器端不要放在一起，文件可以放在客户端，绝对路径就可以。还有就是自己写一个makefile  服务端： 建立socket 使用bind绑定套接字 使用listen监听 使用accept接受连接请求 accept返回新的套接字描述符 #include &lt;stdio.h&gt; #include &lt;s...
TCP通信综合案例-文件上传
ufoli110的博客
06-03 137
TCPClient: package com.student.TCP; import java.io.*; import java.net.Socket; public class TCPClient { public static void main(String[] args) throws IOException { //1.创建一个本地字节流FileinputStream对象，构造方法中绑定要读取的数据源 FileInputStream fis = ne
C语言实现TCP/IP套接字编程详解
2. **套接字编程**：了解套接字的概念，如套接字类型（如流套接字、数据报套接字等）、套接字地址族（如IPv4、IPv6）和套接字操作（如bind(), connect(), listen(), accept(), send(), recv()等）。 3. **TCP/IP协议...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿瞒有我良计15

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值