网络编程_TCP通信综合练习：

最新推荐文章于 2024-10-01 09:15:46 发布
最新推荐文章于 2024-10-01 09:15:46 发布
阅读量406 收藏 8
点赞数 7
文章标签： 网络 tcp/ip 网络协议 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79947226/article/details/136160256
版权

1

image.png

//client：：
public class Client {
    public static void main(String[] args) throws IOException {
        //多次发送数据

        //创建socket对象,填写服务器的ip以及端口
        Socket s=new Socket("127.0.0.1",10000);

        //获取输出流
        OutputStream op = s.getOutputStream();

        //因为要不断发送数据，所以可以使用Sacnner录入数据，结合循环将数据发出去
        Scanner sc=new Scanner(System.in);
        while (true) {
            //键盘录入
            System.out.println("请输入一个数据");
            String str = sc.next();
            //如果输入886就退出发送
            if ("886".equals(str)){
                break;
            }
            op.write(str.getBytes());
        }
        //关流
        s.close();
    }
}
//Server：
public class Server {
    public static void main(String[] args) throws IOException {
        //不断接收
        //创建ServerSocket对象
        ServerSocket ss = new ServerSocket(10000);

        //等待客户端来连接
        Socket socket = ss.accept();
        //创建一个输入流对象
        InputStream is = socket.getInputStream();
        //转换流：字节转字符
        InputStreamReader isr = new InputStreamReader(is);

        int b;
        while ((b = isr.read()) != -1) {
            System.out.print((char) b);
        }
        //关流
        socket.close();//关闭通道
        ss.close();//关闭服务器

    }
}

先启动服务器，再启动客户端
控制台：
image.pngimage.png

2

image.png

//client
public class Client {
    public static void main(String[] args) throws IOException {
        //客户端：发送一条数据，接收服务端反馈的消息并打印
        //服务器：接收数据并打印，再给客户端反馈消息



        //1.创建Socket对象并连接服务端
        Socket socket = new Socket("127.0.0.1",10000);


        //2.写出数据
        String str = "见到你很高兴！";
        OutputStream os = socket.getOutputStream();
        os.write(str.getBytes());

        //写出一个结束标记，（结束输出流）
        socket.shutdownOutput();


        //3.接收服务端回写的数据
        InputStream is = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        int b;
        while ((b = isr.read()) != -1){
            System.out.print((char)b);
        }


        //释放资源
        socket.close();


    }
}

//Server
public class Server {
    public static void main(String[] args) throws IOException {
        //客户端：发送一条数据，接收服务端反馈的消息并打印
        //服务器：接收数据并打印，再给客户端反馈消息


        //1.创建对象并绑定10000端口
        ServerSocket ss = new ServerSocket(10000);

        //2.等待客户端连接
        Socket socket = ss.accept();

        //3.socket中获取输入流读取数据
        InputStream is = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        int b;
        //细节：
        //read方法会从连接通道中读取数据
        //但是，需要有一个结束标记，此处的循环才会停止
        //否则，程序就会一直停在read方法这里，等待读取下面的数据
        while ((b = isr.read()) != -1){
            System.out.println((char)b);
        }

        //4.回写数据
        String str = "到底有多开心？";
        OutputStream os = socket.getOutputStream();
        os.write(str.getBytes());

        //释放资源
        socket.close();
        ss.close();


    }
}

image.pngimage.png

3

image.png
下面的例子是传输图片，所以使用字节流

//Client
public class Client {
    public static void main(String[] args) throws IOException {

        //创建Socket对象连接服务器
        Socket s = new Socket("127.0.0.1", 10000);

        //读取图片文件：使用字节流
        //图片较大：使用缓冲流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("..\\netcode\\clientdir\\a.jpg"));

        //在通道中获取字节流,输入数据到服务端
        BufferedOutputStream bos = new BufferedOutputStream(s.getOutputStream());
        //边读边写
        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
        bos.flush();

        //结束标识
        s.shutdownOutput();

        //接受服务端回馈：字节流-->字符流---->缓冲流
        BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));

        int b;
        while((b=br.read())!=-1){
            System.out.print((char) b);
        }
        //关流
        s.close();
    }
}

//server
public class Server {
    public static void main(String[] args) throws IOException {
        //创建ServerSocket对象
        ServerSocket ss = new ServerSocket(10000);
        //等待客户端连接
        Socket socket = ss.accept();

        //获取通道中传来的数据
        //字节流读取字节
        //缓冲流提升效率
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        //输出到本地
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\netcode\\serverdir\\a.jpg"));

        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
        bos.flush();

        //返回信息：字节流-->字符流---->缓冲流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

        bw.write("上传成功");
        bw.newLine();
        bw.flush();

        //关流
        socket.close();
        ss.close();
    }

}

image.pngimage.png

4.

image.png

//client
public class Client {
    public static void main(String[] args) throws IOException {

        //创建Socket对象连接服务器
        Socket s = new Socket("127.0.0.1", 10000);

        //读取图片文件：使用字节流
        //图片较大：使用缓冲流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("..\\netcode\\clientdir\\a.jpg"));

        //在通道中获取字节流,输入数据到服务端
        BufferedOutputStream bos = new BufferedOutputStream(s.getOutputStream());
        //边读边写
        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
        bos.flush();

        //结束标识
        s.shutdownOutput();

        //接受服务端回馈：字节流-->字符流---->缓冲流
        BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));

        int b;
        while((b=br.read())!=-1){
            System.out.print((char) b);
        }
        //关流
        s.close();
    }
}

//Server
public class Server {
    public static void main(String[] args) throws IOException {
        //创建ServerSocket对象
        ServerSocket ss = new ServerSocket(10000);
        //等待客户端连接
        Socket socket = ss.accept();

        //获取通道中传来的数据
        //字节流读取字节
        //缓冲流提升效率
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());

        //随机uuid、
        String str = UUID.randomUUID().toString().replace("-", "");
        //输出到本地
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\netcode\\serverdir\\" + str + ".jpg"));

        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
        bos.flush();

        //返回信息：字节流-->字符流---->缓冲流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

        bw.write("上传成功");
        bw.newLine();
        bw.flush();

        //关流
        socket.close();
        ss.close();
    }

}

image.png

5.

image.png、
服务端不停止，用户端一直传
思路：可以在服务端使用循环嵌套：
如下：

public class Server {
    public static void main(String[] args) throws IOException {
        //创建ServerSocket对象
        ServerSocket ss = new ServerSocket(10000);



        while (true) {
            //等待客户端连接
            Socket socket = ss.accept();

            //获取通道中传来的数据
            //字节流读取字节
            //缓冲流提升效率
            BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());

            //随机uuid、
            String str = UUID.randomUUID().toString().replace("-", "");
            //输出到本地
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\netcode\\serverdir\\" + str + ".jpg"));

            byte[] bytes = new byte[1024];
            int len;
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes, 0, len);//当第一个用户还在传输时，服务端代码还会在这不断循环
            }
            bos.flush();

            //返回信息：字节流-->字符流---->缓冲流
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            bw.write("上传成功");
            bw.newLine();
            bw.flush();
            //关流
            socket.close();//断开当前通道
            //ss.close();//关闭服务器    ----这里不可以让服务器关闭
        }



    }
}

但是循环有弊端，它是一种单线程，如果说此时要传输的文件很大，当第一个用户还在传输时，服务端代码还会停止在第25行，此时就无法和第二个用户产生连接（只有完成一次循环后，才能和下一个用户进行数据连接），所以我们可以用多线程来改进。使多个用户可以同时传输数据，服务端也可以同时读取多个用户的数据

//多线程
public class MyThread  extends Thread{

    Socket socket;
     public MyThread (Socket socket){
         this.socket=socket;
     }


    @Override
    public void run() {
        //获取通道中传来的数据
        //字节流读取字节
        //缓冲流提升效率
        try {
            BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
            //随机uuid、
            String str = UUID.randomUUID().toString().replace("-", "");
            //输出到本地
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\netcode\\serverdir\\" + str + ".jpg"));

            byte[] bytes = new byte[1024];
            int len;
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes, 0, len);
            }
            bos.flush();

            //返回信息：字节流-->字符流---->缓冲流
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

            bw.write("上传成功");
            bw.newLine();
            bw.flush();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //5.释放资源
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

//Server
public class Server {
    public static void main(String[] args) throws IOException {
        //创建ServerSocket对象
        ServerSocket ss = new ServerSocket(10000);

        while (true) {
            //等待客户端连接
            Socket socket = ss.accept();
            new MyThread(socket).start();
            //ss.close();
        }

    }
}

//client....

6.

image.png
使用自定义线程池

//Server
public class Server {
    public static void main(String[] args) throws IOException {


        //1创建线程池对象
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                3,//核心线程数量
                16,//线程池总大小
                60,//空闲时间
                TimeUnit.SECONDS,//单位
                new ArrayBlockingQueue<>(2),//队列
                Executors.defaultThreadFactory(),//线程工厂，让线程池如何创建线程对象
                new ThreadPoolExecutor.AbortPolicy()//拒绝策略
        );

        //2创建ServerSocket对象
        ServerSocket ss = new ServerSocket(10000);

        while (true) {
            //3等待客户端连接
            Socket socket = ss.accept();
            //开启一条线程
            //一个用户就对应服务端的一条线程

            //调用submit方法传入myRunnable对象
            pool.submit((new MyRunnable(socket)));
            //ss.close();
        }

    }
}
//MyRunnable
public class MyRunnable implements Runnable {

    Socket socket;
     public MyRunnable(Socket socket){
         this.socket=socket;
     }


    @Override
    public void run() {
        //获取通道中传来的数据
        //字节流读取字节
        //缓冲流提升效率
        try {
            BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
            //随机uuid、
            String str = UUID.randomUUID().toString().replace("-", "");
            //输出到本地
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\netcode\\serverdir\\" + str + ".jpg"));

            byte[] bytes = new byte[1024];
            int len;
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes, 0, len);
            }
            bos.flush();

            //返回信息：字节流-->字符流---->缓冲流
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

            bw.write("上传成功");
            bw.newLine();
            bw.flush();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //5.释放资源
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
//client.....

7.

image.png

public class Server {
    public static void main(String[] args) throws IOException {
        //客户端：多次发送数据
        //服务器：接收多次接收数据，并打印

        //1.创建对象绑定10000端口
        ServerSocket ss = new ServerSocket(10000);

        //2.等待客户端来连接
        Socket socket = ss.accept();

        //3.读取数据
        InputStreamReader isr = new InputStreamReader(socket.getInputStream());
        int b;
        while ((b = isr.read()) != -1){
            System.out.print((char)b);
        }

        //4.释放资源
        socket.close();
        ss.close();

    }
}

首先启动服务端：
再在浏览器输入：
image.png
获得到数据：
image.png

8.

image.png
client

package A;

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

public class Client1 {
    public static void main(String[] args) throws IOException {
        /**
         * 每一个客户端都是一个线程
         */


        while (true) {
            //1.与服务端建立连接
            Socket socket = new Socket("127.0.0.1", 10000);
            System.out.println("服务器已连接");
            //2生成聊天界面
            System.out.println("==============欢迎来到黑马聊天室================");
            System.out.println("1登录");
            System.out.println("2注册");
            System.out.println("请输入您的选择：");
            //3键盘录入
            Scanner sc = new Scanner(System.in);
            String choose = sc.nextLine();
            //判断：
            switch (choose) {
                case "1":
                    //登录逻辑
                    login(socket);
                    break;
                case "2":
                    //注册逻辑

                    break;
                default:
                    System.out.println("没有该选项");

            }
        }
    }

    /**
     * //登录
     *
     * @param socket
     * @throws IOException
     */
    private static void login(Socket socket) throws IOException {
        //1输入账户和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名");
        String username = sc.nextLine();
        System.out.println("请输入密码");
        String password = sc.nextLine();

        //***登录要求使用username=zhangsan&password=123这种格式发给服务端
        //2拼接
        StringBuilder sb = new StringBuilder();
        sb.append("username=").append(username).append("&password=").append(password);

        //3提交给服务器验证
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        //第一次是告诉服务器是此时登陆操作是什么
        bw.write("login");
        bw.newLine();//这两个要配套使用
        bw.flush();
        //第二次告诉服务器用户端输入的账号密码
        bw.write(sb.toString());
        bw.newLine();
        bw.flush();

        //接收服务端的回馈消息
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String message = br.readLine();

        if ("1".equals(message)) {
            System.out.println("登陆成功，可以开始聊天");

            //开一条单独的线程，专门用来接收服务端转发过来的聊天记录
            new Thread(new ClientMyRunnable(socket)).start();


            //将要说的话传给服务器，交给服务器转发给其他客户端
            talk2All(bw);
        } else if ("2".equals(message)) {
            System.out.println("密码不正确");
        } else {
            System.out.println("用户名不存在，请先注册");
        }
    }

    private static void talk2All(BufferedWriter bw) throws IOException {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入你要说的话");
            String message = sc.nextLine();
            bw.write(message);
            bw.newLine();
            bw.flush();
        }


    }
}

class ClientMyRunnable implements Runnable {
    Socket socket;

    //构造
    public ClientMyRunnable(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {

        //循环包裹，不断读取服务端发过来的信息（接受群发消息）
        while (true) {
            try {
                BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String message = br.readLine();
                System.out.println(message);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

server

package A;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.Buffer;
import java.nio.file.attribute.UserPrincipal;
import java.util.ArrayList;
import java.util.Properties;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Server {
    //成员位置方便调用
  static  ArrayList<Socket>list=new ArrayList<>();

    public static void main(String[] args) throws IOException {
        //1创建ServerSocket对象，并连接10000端口
        ServerSocket ss = new ServerSocket(10000);

        //2把本地文件中的正确用户名和密码都获取到
        Properties prop = new Properties();
        FileInputStream fis = new FileInputStream("..\\Chat\\account.txt");
        prop.load(fis);
        fis.close();
        //只要来了一个客户端，就开一个条线程
        while (true) {
            //等待服务端连接
            Socket socket = ss.accept();
            System.out.println("有客户端来连接");
            //开始处理线程任务
            new Thread(new MyRunnable(socket, prop)).start();
        }
    }
}

//-----------------------------------------------------------------------
class MyRunnable implements Runnable {
    Socket socket;
    Properties prop;

    //构造
    public MyRunnable(Socket socket, Properties prop) {
        this.socket = socket;
        this.prop = prop;
    }

    @Override
    public void run() {
        /**
         * 每一个线程要做的事情
         */
        try {
            //1读取客户端传来的信息
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //第一次读取的是用户的操作
            String choose = br.readLine();
            while (true) {
                switch (choose) {
                    case "login" -> login(br);
                    case "register" -> register();
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }


    /**
     * 1.获取用户端输入的帐号、密码
     * 2.与正确的账号密码比较
     * 3.写出不同情况的返回信息
     */
    public void login(BufferedReader br) throws IOException {
        System.out.println("用户执行了登陆操作");
        //第二次读取的是用户端传递过来的拼接信息：username=zhangsan&password=123
        String userInfo = br.readLine();
        //获取真正的账号密码：切割
        String s1 = userInfo.split("&")[0];
        String s2 = userInfo.split("&")[1];
        String usernameInput = s1.split("=")[1];
        String passwordInput = s2.split("=")[1];
        System.out.println("账号是：" + usernameInput);
        System.out.println("密码是：" + passwordInput);

        //比较
        if (prop.containsKey(usernameInput)) {
            //用户名一致，就比较密码
            //先获取当前正确密码
            String rellyPassword = (String) prop.get(usernameInput);
            if (passwordInput.equals(rellyPassword)) {
                //登陆成功，给用户端返回信息
                messageToClient("1");//登陆成功，可以开始聊天
                //登陆成功后需要将当前socket对象存储起来
                Server.list.add(socket);
                //接收客户端发送的信息并打印在控制台
                talk2All(br,usernameInput);
            } else {
                //密码不正确，给用户端返回信息
                messageToClient("2");//密码不正确

            }
        } else {
            //用户名不存在，给用户端返回信息：
            messageToClient("3");//用户名不存在，请先注册

        }
    }

    private void talk2All(BufferedReader br, String usernameInput) throws IOException {
        //聊天死循环
        while(true){
            //接收客户端发送的信息
            String message = br.readLine();
            System.out.println(usernameInput+"发送过来了消息："+message);

            //群发
            for (Socket s : Server.list) {
                //s以此表示每一个socket对象
                messageToClient(s,usernameInput+"发送过来了消息："+message);
            }
        }
    }


    /**
     *因为三种情况：登陆成功、密码不正确、用户名不存在都要返回信息给客户端，所以干脆抽取成方法
     * @param message
     */
    public void messageToClient(String message) throws IOException {
        //获取输出流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write(message);
        bw.newLine();
        bw.flush();
    }

    /**
     * 重载的messageToClient
     * @param socket
     * @param message
     */
    public void messageToClient(Socket socket,String message) throws IOException {
        //获取输出流,将数据写给当前的socket通道对象
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write(message);
        bw.newLine();
        bw.flush();
    }















    /**
     * 注册逻辑
     */
    private static void register() {
        System.out.println("用户执行了注册操作");
    }

}
成果、
关注
【BOOST C++ 6 】通信（03 网络编程 ）
gongdiwudu的专栏
10-30 4327
尽管 Boost.Asio 可以异步处理任何类型的数据，但它主要用于网络编程。这是因为 Boost.Asio 早在添加额外的 I/O 对象之前就支持网络功能。网络函数非常适合异步操作，因为通过网络传输数据可能需要很长时间，这意味着确认和错误可能不会像发送或接收数据的函数那样快。
Tcp编程及一些练习
j_better的博客
06-04 352
上面我们了解了Udp编程，接下来让我们再来看看Tcp编程 首先分析一下Udp和Tcp之间的区别？ 1）Udp是无连接，接收端只管接收；而Tcp是基于面向里连接的（例如打电话的时候你得先拨号码）2）Udp无法确保数据的安全传送，有可能会丢失数据；而Tcp是可以保证安全传输的3）Udp是通过创建数据报包进行传输的，而Tcp是通过流的模式去进行传输的4）Udp效率高传输速度快，但是安全性低；Tcp效率低...
一个基本的TCP/IP编程实例
zhangxi198210的专栏
08-27 854
//TCP1C.cpp CopyRight 小扣 XPsp3 VS2008    //   //创建一个基本的阻塞模式TCP连接的客户端，    　   //   //与服务器建立连接后便开始发送并显示发送量，      //   //当收到“exit"命令时发送该命令同时程序退出。     //   *************TCP1C.h****************
Tcp网络编程练习题
qq_43958552的博客
03-11 820
1.使用TCP网络编程，实现图片的上传。 zy1c类：客户端 package week3.day3; import java.io.FileInputStream; import java.io.IOException; import java.io.OutputStream; import java.net.Socket; //1、使用TCP网络编程，实现图片的上传。 public class zy1c { public static void main(String[] args)
Java基础知识网络编程（TCP练习）
u013951760的博客
05-10 2330
练习：复制文本练习要求：把客户端的一个文件内容发到服务端，在服务端把数据存储到一个文件当中。相当于复制文件。import java.io.*; import java.net.*;class TxtCopyTestClient { public static void main(String[] args) throws Exception { Socket s=ne
网络编程应用：基于TCP协议【实现文件上传】--练习
Java仗剑走天涯
05-04 2933
要求： 基于TCP协议实现一个向服务器端上传文件的功能
Linux_网络编程_TCP
m0_71703182的博客
07-09 1156
client / server brow / ser b / s http p2p 1、模式 C/S 模式 ==》服务器/客户端模型server :socket()-->bind()--->listen()-->accept()-->recv()-->close()client :socket()-->connect()-->send()-->close(); int on = 1; setsockopt(listfd, SOL_SOCKET,SO_REUSEADDR
2-4网络编程-TCP通信练习
HandsomeBoy
12-07 1390
1.练习1： 客户端：发送数据，接收服务器反馈 服务器：接收数据，给出反馈 代码： 客户端 package Study12; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; /*客户端：发送数据，接收服务器反馈*/ public class ClientDemo { public static void main(St
java网络编程_189_TCP_Socket通信_原理1_练习
weixin_45339692的博客
06-05 105
package 网络编程_189_TCP_Socket通信_原理_练习; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; /** Socke通信 1.基于tcp协议,面向连接的.建立稳定链接的点对点的通信;实时,快速,安全性高,占用系统资源多,效率低 2."请求-相应"模式:Request–Response 1).客户端:在网络通讯中,第一次主动发起通信的程序被称作客户端(Client)
C++网络编程快速入门（一）：TCP网络通信基本流程以及基础函数使用
hanhan的博客
10-26 6756
流程概述 客户端与服务器之间的网络通信基本原理如下所示，复杂一点的架构可能会添加消息中间件。 对于服务端，通信流程如下： 1、调用socket函数创建监听socket 2、调用bind函数将socket绑定到某个IP和端口号组成的二元组上 3、调用listen函数开启监听 4、当有客户端连接请求时，调用accept函数接受连接，产生一个新的socket（与客户端通信的socket） 5、基于新产生的socket调用send或recv函数开始与客户端进行数据交流 6、通信结束后，调用close函数关闭sock
linux编程学习之TCP练习.rar_Linux/Unix编程_furniturelb9_linux 客户端_tcp serv
09-24
简单实现了linux中TCP通信的服务器与客户端实例
tcp_per.rar_GUI TCP_TCP网络聊天_java TCP线程_tcp多线程
09-21
在本项目中，我们主要探讨的是使用Java编程语言构建一个基于TCP协议的网络聊天应用程序，该应用具有图形用户界面（GUI）。TCP（Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信...
学生的GATE和CSE资源：:books:面向GATE和CSE求职者的CSE GATE资源:smiling_face_with_sunglasses:。 通过:white_medium_star::white_medium_star:显示你的:red_heart_selector:
01-30
10. **计算机网络**：TCP/IP协议栈、网络层次结构、网络安全和无线通信等。 11. **自动机理论**：状态机、正则表达式、上下文无关文法和计算理论基础。 压缩包文件名“GATE-and-CSE-Resources-for-Students-master...
C#网络应用编程实验 WCF和TCP消息通信练习
06-22
C#网络应用编程第三版（人民邮电出版社）课后上机练习实验 实验五 WCF和TCP消息通信练习 关键技术是自承载的WCF服务、回调（CallBack）、TCP双工通信。 此代码仅供参考。
tcp.rar_TCP编程pdf_tcp
09-23
例如，它可能涵盖如何创建TCP服务器和客户端，如何处理并发连接，如何处理异常情况，以及如何实现安全的TCP通信（如使用SSL/TLS）。 “www.pudn.com.txt”可能是一个来源于网络资源的引用或说明，其中可能包含了...
MQTT--EMQX入门+MQTTX使用
CJPSR的博客
09-30 921
EMQ X基于 Erlang/OTP 平台开发的MQTT 消息服务器，是开源社区中最流行的 MQTT 消息服务器。EMQ X 是开源百万级分布式。
Linux下send函数和recv函数
最新发布
威桑的博客
10-01 322
Linux下send和recv
信息安全对抗演习：应对网络威胁的坚实防线
dexun123的博客
09-29 833
演习结束后，需要对整个演习过程进行总结和评估。分析演习中发现的问题和不足并提出改进措施；同时总结经验教训为未来的演习提供参考。
网络层——IP
weixin_74269833的博客
09-28 1137
由32位二进制数组成，通常用点分的形式被分为四个部分，每个部分1byte，最大值为255。从功能的角度看，ip地址由两部分组成，网络号和主机号。网络号标识了ip所在的网段，主机号标识了在该网段中的唯一的一台主机。二者的区分又需要与掩码配合使用，例如192.168.1.2/24，24表示掩码255.255.255.0，将掩码与ip进行按位与操作，获得了192.168.1.0即为该主机所在网段。将IP地址中的主机地址全部设为0, 就成为了网络号, 代表这个局域网。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

成果、

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

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

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

打赏作者

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

抵扣说明：

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

余额充值