TCP的连接传输

最新推荐文章于 2022-05-26 18:50:42 发布
最新推荐文章于 2022-05-26 18:50:42 发布
阅读量528 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/danfengw/article/details/47322419
版权

目录

单客户端与服务器的传输
多客户端与服务器的传输
这里写图片描述

单客户端与服务器的传输

package com.IM;

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JTextArea;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.awt.event.ActionEvent;
import javax.swing.JList;

public class MyServer extends JFrame {
    //private ServerSocket server;
    //private Socket socket;
    private JTextArea textArea;
    private DefaultListModel<String> modle;
    private ArrayList<Socket> sockets;
    private boolean isRunning=true;

    private JPanel contentPane;

    public boolean isRunning() {
        return isRunning;
    }

    public void setRunning(boolean isRunning) {
        this.isRunning = isRunning;
    }

    /**
     * Launch the application.
     */
    public static void main(String[] args) {

        //主线程的维护工作，在主线程中调用run方法
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    MyServer frame = new MyServer();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public MyServer() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 445, 491);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPane);
        contentPane.setLayout(null);

        JButton button = new JButton("启动服务");

        button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                System.out.println("服务器启动，等待连接");
                //新建的线程是为了空出主线程,如果不新建线程，则while()运行不完，主线程运行不完
                //就好像有一个人甲，要做检测"启动服务（read）"，"发送（write）"工作，当线程运行"启动服务"时被卡死，则不能进行"发送"
                //此时需要另一个人乙来代替甲来做"启动服务"工作，甲继续检测"发送"工作，也就是新建一个线程，
                new Thread(new Runnable() {
                    public void run() {
                        try {
                            ServerSocket server=new ServerSocket(8080);
                            //此处socket只能是局部变量，如果是全局变量则只能接受到最后一个断开
                            sockets=new ArrayList<>();
                            while(isRunning){
                        //  ServerSocket server=new ServerSocket(8080);                 
                             Socket socket=server.accept();//等待连接,准备开启线程
                             sockets.add(socket);                   
                            Thread t=new Thread(new MyServerReadThread(MyServer.this,socket));
                            //建立新线程，准备开启线程，调用run方法读
                            t.start();
                            System.out.println("有客户端连接");
                            }

                        } catch (IOException e1) {
                            // TODO Auto-generated catch block
                            e1.printStackTrace();
                        }

                    }
                }).start(); ;

            }
        });


        button.setBounds(332, 10, 93, 86);
        contentPane.add(button);

        textArea = new JTextArea();
        textArea.setBounds(10, 396, 312, 47);
        contentPane.add(textArea);

        JButton button_1 = new JButton("发送");
        button_1.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {

                write();//进行写操作
            }
        });
        button_1.setBounds(332, 396, 93, 23);
        contentPane.add(button_1);

        JList list = new JList();
        list.setBounds(10, 20, 312, 344);
        modle=new DefaultListModel<>();
        list.setModel(modle);
        contentPane.add(list);
    }
    public void read(Socket socket){
        InputStream is;
        //检测客户端口是否连接，连接则进行读操作，否则移除该端口
        if(socket.isConnected()){
        try {
            is = socket.getInputStream();
            BufferedReader br=new BufferedReader(new InputStreamReader(is));
            String line=br.readLine();
            modle.addElement(socket.getInetAddress()+"  "+"客户端说： "+line);
            System.out.println("服务器接收到信息"+"\n"+line);

        } catch (IOException e) {
            e.printStackTrace();
        }
        }else{
            sockets.remove(socket);//端口断开连接时，使减少报错
        }
    }
    public void write(){
        try {
            for(Socket socket:sockets){
            OutputStream os=socket.getOutputStream();
            BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(os));
            String words=textArea.getText();//得到文本框中的内容
            modle.addElement("服务器说： "+words); 

            System.out.println("服务器说："+"\n"+words);
            bw.write(words+"\n");
            textArea.setText("");//注意写完之后清空
            bw.flush();  
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


    }
}

package com.IM;

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JTextArea;
import javax.swing.DefaultButtonModel;
import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JList;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.awt.event.ActionEvent;

public class MyClient extends JFrame {
    private Socket socket;
    private JTextArea textArea;
    private JPanel contentPane;
    private JList list;
    private DefaultListModel<String> modle;


    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    MyClient frame = new MyClient();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public MyClient() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 484, 442);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPane);
        contentPane.setLayout(null);

        textArea = new JTextArea(); 
        textArea.setBounds(10, 299, 332, 78);
        contentPane.add(textArea);

        JButton btnNewButton = new JButton("发送");
        btnNewButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {

                write();
            }
        });
        btnNewButton.setBounds(352, 303, 106, 60);
        contentPane.add(btnNewButton);

        list = new JList();     
        list.setBounds(10, 22, 332, 268);
        modle=new DefaultListModel<>();
        list.setModel(modle);
        contentPane.add(list);

        JButton btnNewButton_1 = new JButton("连接服务器");
        btnNewButton_1.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) {
                try {
                     System.out.println("连接");
                     socket=new Socket("192.168.0.35", 8080);
                     Thread t=new Thread(new MyClientReadThread(MyClient.this));
                     t.start();     
                } catch (UnknownHostException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        });
        btnNewButton_1.setBounds(352, 40, 106, 67);
        contentPane.add(btnNewButton_1);
    }

    public void read(){
    //  InputStream is;
    //当声明写在外面时，执行modle.addElement()语句会出错
        try {
            InputStream is = socket.getInputStream();
            BufferedReader br=new BufferedReader(new InputStreamReader(is));
            String line=br.readLine();
            System.out.println("我是服务器");
            modle.addElement("服务器说: "+"\n"+line); //出错
            System.out.println("服务器说的"+line);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public void write(){
        try {
            OutputStream os=socket.getOutputStream();
            BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(os));
            String words=textArea.getText();
            modle.addElement("客户说： "+"\n"+words);//
            System.out.println("客户端说"+words);
            bw.write(words+"\n");
            textArea.setText("");
            bw.flush();      
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


    }
}

package com.IM;

import java.net.Socket;

public class MyServerReadThread implements Runnable{
    private MyServer server;
    private Socket socket;
    public MyServerReadThread (MyServer server,Socket socket){
        this.server=server;
        this.socket=socket;

    }

    @Override
    public void run() {
        while(server.isRunning()){
        server.read(socket);
        }

    }
    public MyServer getServer() {
        return server;
    }

    public void setServer(MyServer server) {
        this.server = server;
    }


}
package com.IM;

public class MyClientReadThread implements Runnable{
    private MyClient client;
    public MyClientReadThread(MyClient client) {
        this.client=client;
    }
    @Override
    public void run() {
        while(true){
            client.read();  
        }

    }
    public MyClient getClient() {
        return client;
    }
    public void setClient(MyClient client) {
        this.client = client;
    }

}

多客户端与服务器的传输

package com.IM;

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;

import net.sf.json.JSONObject;

import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JTextArea;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.awt.event.ActionEvent;
import javax.swing.JList;

public class MyServer extends JFrame {
    //private ServerSocket server;
    //private Socket socket;
    private JTextArea textArea;
    private DefaultListModel<String> modle;
    //private ArrayList<Socket> sockets;
    private HashMap<String, Socket> sockets;//此处使用hashmap是因为hashmap不允许重复
    private boolean isRunning=true;
    private JPanel contentPane;

    public boolean isRunning() {
        return isRunning;
    }

    public void setRunning(boolean isRunning) {
        this.isRunning = isRunning;
    }

    /**
     * Launch the application.
     */
    public static void main(String[] args) {

        //主线程的维护工作，在主线程中调用run方法
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    MyServer frame = new MyServer();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public MyServer() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 445, 491);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPane);
        contentPane.setLayout(null);

        JButton button = new JButton("启动服务");

        button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                System.out.println("服务器启动，等待连接");
                //新建的线程是为了空出主线程,如果不新建线程，则while()运行不完，主线程运行不完
                //就好像有一个人甲，要做检测"启动服务（read）"，"发送（write）"工作，当线程运行"启动服务"时被卡死，则不能进行"发送"
                //此时需要另一个人乙来代替甲来做"启动服务"工作，甲继续检测"发送"工作，也就是新建一个线程，
                new Thread(new Runnable() {
                    public void run() {
                        try {
                            ServerSocket server=new ServerSocket(8080);
                            //此处socket只能是局部变量，如果是全局变量则只能接受到最后一个断开
                            sockets=new HashMap<>();
                            while(isRunning){
                        //  ServerSocket server=new ServerSocket(8080);                                     
                             Socket socket=server.accept();//等待连接,准备开启线程    
                             String ip=socket.getInetAddress().getHostAddress();
                            sockets.put(ip,socket);                 
                            Thread t=new Thread(new MyServerReadThread(MyServer.this,socket));
                            t.start();
                            System.out.println("有客户端连接"+ip);
                            }

                        } catch (IOException e1) {
                            // TODO Auto-generated catch block
                            e1.printStackTrace();
                        }

                    }
                }).start(); ;

            }
        });


        button.setBounds(332, 10, 93, 86);
        contentPane.add(button);

        textArea = new JTextArea();
        textArea.setBounds(10, 396, 312, 47);
        contentPane.add(textArea);

        JButton button_1 = new JButton("发送");
        button_1.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {

                write();//进行写操作
            }
        });
        button_1.setBounds(332, 396, 93, 23);
        contentPane.add(button_1);

        JList list = new JList();
        list.setBounds(10, 20, 312, 344);
        modle=new DefaultListModel<>();
        list.setModel(modle);
        contentPane.add(list);
    }
    public void read(Socket socket,String line){    
            JSONObject obj=JSONObject.fromObject(line); 
            System.out.println("服务器收到"+line);
            String type=obj.getString("type");
          //  System.out.println("开始");
            String time=obj.getString("time");
            String to=obj.getString("to");
            String from=obj.getString("from");
            String msg=obj.getString("message");
            Socket tosocket=sockets.get(to);    
            try {
                OutputStream osw=tosocket.getOutputStream();
                BufferedWriter bws=new BufferedWriter(new OutputStreamWriter(osw));
                modle.addElement("客户端说"+msg);
                bws.write(msg+"\n");//注意出错点：要加\n
                bws.flush();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            //modle.addElement(socket.getInetAddress().getHostAddress()+"客户端 "+msg);
            System.out.println("服务器接收到信息"+"\n"+msg);    
    }
    public void write(){
        try {
            //sockets中
            Set<String> keys=sockets.keySet();//得到sockets中所有的key值
            Iterator it=keys.iterator();
            while(it.hasNext()) {
            String key=(String) it.next();//得到一个一个的key值

            OutputStream os=sockets.get(key).getOutputStream();
            BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(os));
            String words=textArea.getText();//得到文本框中的内容
            modle.addElement("服务器说： "+words); 

            System.out.println("服务器说："+"\n"+words);
            bw.write(words+"\n");
            textArea.setText("");//注意写完之后清空
            bw.flush();  
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


    }
}

package com.IM;

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.TextArea;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;

import net.sf.json.JSONObject;

import javax.swing.JTextArea;
import javax.swing.DefaultButtonModel;
import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JList;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Calendar;
import java.awt.event.ActionEvent;

public class MyClient extends JFrame {
    private Socket socket;
    private JTextArea textArea;
    private JPanel contentPane;
    private JList list;
    private DefaultListModel<String> modle;


    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    MyClient frame = new MyClient();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public MyClient() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 484, 442);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPane);
        contentPane.setLayout(null);

        textArea = new JTextArea(); 
        textArea.setBounds(10, 299, 332, 78);
        contentPane.add(textArea);

        JButton btnNewButton = new JButton("发送");
        btnNewButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {

                write();
            }
        });
        btnNewButton.setBounds(352, 303, 106, 60);
        contentPane.add(btnNewButton);

        list = new JList();     
        list.setBounds(10, 22, 332, 268);
        modle=new DefaultListModel<>();
        list.setModel(modle);
        contentPane.add(list);

        JButton btnNewButton_1 = new JButton("连接服务器");
        btnNewButton_1.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) {
                try {
                     System.out.println("连接");
                     socket=new Socket("192.168.0.46", 8080);
                     Thread t=new Thread(new MyClientReadThread(MyClient.this));
                      t.start();     
                } catch (UnknownHostException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        });
        btnNewButton_1.setBounds(352, 40, 106, 67);
        contentPane.add(btnNewButton_1);
    }

    public void read(){
        try {
            InputStream is = socket.getInputStream();
            BufferedReader br=new BufferedReader(new InputStreamReader(is));
            String line=br.readLine();
            //System.out.println("我是服务器");
            modle.addElement("服务器说: "+"\n"+line); //出错
            System.out.println("服务器说的"+line);     

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public String creatJson(){
            JSONObject obj=new JSONObject();
            String msg=textArea.getText();
            obj.put("type", "to all");
            obj.put("message", msg);
            //获得时间 Date Calender    Date time=new Date();  String time1=time.gettime();
            //Calendar 
            Calendar calendar=Calendar.getInstance();               
            obj.put("time",calendar.getTimeInMillis());
            obj.put("from",socket.getInetAddress().getHostName() );
            obj.put("to","192.168.0.46" );
            System.out.println(obj.toString());
            return obj.toString();

    }
    public void write(){
        try {
            String s=creatJson();
            OutputStream os=socket.getOutputStream();
            BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(os));
          //  String words=textArea.getText();
            modle.addElement("客户说： "+s);//
            System.out.println("客户端说"+s);
            bw.write(s+"\n");
            textArea.setText("");
            bw.flush();      
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


    }
}

package com.IM;

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

public class MyServerReadThread implements Runnable{
    private MyServer server;
    private Socket socket;
    public MyServerReadThread (MyServer server,Socket socket){
        this.server=server;
        this.socket=socket;

    }

    @Override
    public void run() {
        while(true){
                try {
                    InputStream is=socket.getInputStream();
                    BufferedReader br=new BufferedReader(new InputStreamReader(is));
                    String line=br.readLine();
                    server.read(socket,line);
                    System.out.println(line);

                } catch (IOException e) {                   
                    e.printStackTrace();
                }
        }

    }



}

package com.IM;

public class MyClientReadThread implements Runnable{
    private MyClient client;
    public MyClientReadThread(MyClient client) {
        this.client=client;
    }
    @Override
    public void run() {
        while(true){
            client.read();  
        }

    }

}
danfengw
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
TCP发送数据流程详解
鱼思故渊的专栏
12-31 1万+
B/S通信简述 整个计算机网络的实现体现为协议的实现，TCP/IP协议是Internet的核心协议，HTTP协议是比TCP更高层次的应用层协议。 HTTP（HyperText Transfer Protocol，超文本传输协议）是互联网上应用最为广泛的一种网络协议。所有的WWW文件都必须遵守这个标准。设计HTTP的初衷是为了提供一种发布和接收HTML页面的方法。 浏览器（Web Browse
详解TCP建立连接、传输数据、断开连接全过程
youge_chen的博客
11-17 7434
本文通过wrieshark抓取TCP包，来对TCP进行细致的解析，从实践中了解TCP各个过程。 首先介绍下TCP的6种标志位，wriehark会根据这些标志位，在抓取的包中进行标记，方便我们查看： SYN(synchronous建立联机)  ACK(acknowledgement 确认)  PSH(push传送)  FIN(finish结束)  RST(reset重置)  URG(u...
TCP传输连接--建立连接阶段（TCP三次握手）
果车的博客
01-16 8738
目录 一、TCP相关概念： 二、TCP连接建立过程中要解决的问题： 三、TCP三次握手的过程： 一、TCP相关概念： 1.TCP是面向连接的协议。 2.TCP是基于传输连接（不是物理连接，是逻辑上的连接）来传送TCP报文段。 TCP运输连接的建立和释放是每一次面向连接的通信中必不可少的过程。 3.TCP运输链接有三个阶段： （1）建立连接（三次握手） 。 （2）数据传送。 （3）释放连接(四次挥手)。 4.TCP的运输连接管理就是使运输连接的建立和释放都能正常地进行。 二.
访问Web，tcp传输全过程（三次握手、请求、数据传输、四次挥手）
热门推荐
秋天的原野
12-07 2万+
从输入域名到最后呈现经历的过程： 域名解析 --> 发起TCP的3次握手 --> 建立TCP连接后发起http请求 --> 服务器响应http请求，浏览器得到html代码 --> 浏览器解析html代码，并请求html代码中的资源（如js、css、图片等） --> 浏览器对页面进行渲染呈现给用户 --> 四次挥手结束 1.域名解析 首先浏览器会解析 www.zipackage.c
TCP提供可靠传输的工作原理和实现过程
渴望，就奋力追寻...
03-13 1万+
TCP发送的报文段是交给IP层传送的，但IP层只能提供尽最大努力交付的服务，也就是说，TCP下面的网络所提供的是不可靠的传输。因此，TCP采用了一些适当的措施来提供可靠的传输，使得两个传输层直接的通信变得可靠。 ----------工作原理---------------------------------------------------------------------------
TCP连接传输三个阶段1
08-04
TCP连接传输三个阶段连接建立客户端发送连接请求报文段，无应用层数据服务器端为该TCP连接分配缓存和变量，并向客户端返回确认报文段，允许连接，无应用层数据客户端
简述TCP传输机制
12-04
在计算机网络中，TCP传输机制的了解，有助于理解TCP传输机制，更好地找我计算机网络技术。
TCP连接测试工具_强烈推荐！
08-24
软件名字叫“TCPUDPDbg”，是一个TCP和UDP协议的网络连接测试工具，支持服务器模式和客户端模式，支持多连接，可同时对多路网络连接进行操作，支持发送汉字，支持十六进制发送和接收方式。非常好用，强烈推荐！
TCP协议 TCP 文件传输 大文件传输
08-06
服务器：设置IP 端口，监听，连接，传输文件名字（转2进制），传输文件（2进制），结束，关闭tcpListener 客户端：设置IP 端口，连接，接受文件名字，接受文件，写文件，结束，关闭tcpListener
Tcp传输连接原理
01-02
该文档讲述一下TCP的三次握手与TCP的四次挥手,还有TCP连接常见的几个问题,仅作学习参考
TCP连接
会飞的鱼aaaa
05-26 2313
本文属临时记录，仅供自己学习使用。如有错误，请勿怪罪。后期复习会不断订正。 TCP头部信息 字段 功能 源端口号（16bit） 发送方端口号 目的端口号(16bit) 接收方端口号 序列号(32bit) TCP传送的字节流数据每一个字节都是顺序编号的，序列号就是当前的TCP报文首字节的序号 确认号(32bit) 接收方期望的回复报文中数据段首字节的序号 首部长度(4bit) TCP报文首部的长度 URG(1bit) URG=1,表明报文数据为紧急数据，无需在发送缓存中等
网络连接--TCP（传输控制协议）
小乔与你同在
11-12 103
1 客户端与服务端的数据传输 （1）必须保证连接通畅，速度比较慢 （2）数据安全可靠 2 一个服务端与一个客户端（服务端只读客户端传输的内容） public class TCPClient { /* * 客户端： 通过TCP传输协议将数据发送给服务器端 */ public static void main(String[] args) throws Exception { Sys...
TCP传输过程详解
u012294851的专栏
04-25 1万+
TCP传输过程详解1 概述2 测试代码2.1 服务端代码2.2 客户端代码3 抓包分析3.1抓包工具3.2 操作步骤3.3 TCP三次握手3.4 TCP可靠性传输3.5 TCP四次挥手结束连接释放4 报文分析4.1 数据报层次分解4.2 TCP报文解析5 引用 1 概述 TCP（Transmission Control Protocol）传输控制协议是一种面向连接的、可靠的、基于字节流的传输层协议...
【ES源码分析】Transport模块之TCP请求与响应
coding and writing
01-19 3902
主要通过实例讲解节点内部的TCP请求与响应逻辑
TCP 协议如何保证可靠传输
Kirito的博客
04-22 574
TCP 协议如何保证可靠传输 1.应用数据被分割成 TCP 认为最适合发送的数据块。 2.TCP 给发送的每一个包进行编号，接收方对数据包进行排序，把有序数据传送给应用层。 3.校验和： TCP 将保持它首部和数据的检验和。这是一个端到端的检验和，目的是检测数据在传输过程中的任何变化。如果收到段的检验和有差错，TCP 将丢弃这个报文段和不确认收到此报文段。 4.TCP 的接收端会丢弃重复的数据。 5.流量控制： TCP 连接的每一方都有固定大小的缓冲空间，TCP的接收端只允许发送端发送接收端缓冲区能接纳的数
一个TCP连接可以发送多少个HTTP请求
qq_32100465的博客
07-10 1331
推荐地址：https://mp.weixin.qq.com/s/nEEYfYLDGdhfizogqJuTOg
TCP分隔符和定长解码器
qq_33464748的博客
03-19 854
简介​ TCP上层的协议通过四种方式对消息进行区分 消息长度固定，累计读取到长度总和为定长LEN的报文后，就认为读取到了一个完整的消息；将计数器置位，重新开始读取下一个数据报； 将回车换行符作为消息结束符，如FTP协议，这种方式在文本协议中应用比较广泛； 将特殊的分隔符作为消息的结束标志，回车换行符就是一种特殊的结束分隔符； ...
TCP传输连接建立与释放详解
923723914
09-13 390
一直以来有许多读者朋友对TCP的传输连接建立和释放过程不是很理解，而这又是几乎网络认证中必考的知识点，包括软考、CCNA\CCNP、H3CNA\H3CNE等，为此再把笔者年度巨作，广受好评的——《深入理解计算机网络》书中的相关内容摘出来与大家分享。本书详细内容及读者评价可从这里了解：http://item.jd.com/11165825.html，http://product.dangdang....
TCP的传输连接管理
06-15 474
TCP传输连接管理概述 TCP传输连接有三个阶段，即：连接建立（三次握手）、数据传送和连接释放（四次挥手）。 TCP连接建立都是采用客户服务器方式。 主动发起连接建立的应用进程叫做客户（client）。 被动等待连接建立的应用进程叫做服务器（server）。 TCP的三次握手 TCP连接过程中常见符号意义如下： SYN---同步标记，当SYN=1，ACK=0时，表明这是一个连接请...
tcp连接正常数据传输偶发异常
最新发布
06-02
TCP连接正常但数据传输偶发异常可能有多种原因。以下是一些可能的原因： 1. 网络拥塞：当网络拥塞时，数据包可能会丢失或延迟，从而导致数据传输异常。 2. 路由问题：路由器可能会出现问题，从而导致数据传输异常...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值