网络原理

关注

原创最新推荐文章于 2026-04-17 15:54:20 发布 894 阅读 AI 写同款· GEO 优化 ›

【Docker篇】深入理解Docker网络原理，理解Docker0，自定义网络，网络连通文章目录Docker网络原理1. Linux veth pair2. 理解Docker03. 容器互联--Link4. 自定义网络（推荐）5. 网络连通6. 总结 Docker网络原理在前面的文章中跟大家说到了容器是相对独立的环境，相当于一个小型的Linux系统，外界无法直接访问，那他是怎么做的呢，这里我们先了解下Linux veth pair。 1. Linux veth pair veth pair是成对出现的一种虚拟网络设备接口，一端连着网络协议栈，一端彼此相连。如下图所示： veth pair 阅读详情

端口号
IP地址（确定主机）+端口号（在机上的应用程序）

网络层提供的概念传输层提供的概念

一个字节：

有符号-128=>+127

无符号0=>255

两个字节：

有符号：-32768=>+32767

无符号0=>65535

四个字节：

有符号：-21亿=>+21亿

无符号：0=>42亿9千万

同一个机器上，同一时刻内，端口号不能重复被绑定。

某个进程A绑定了10000端口号，此时进程B也尝试绑定10000端口，此时B就会绑定失败！

会提示Address already in use。

可以在服务命令行中输入netstat -ano查看当然那些进程正在使用

netstat -ano|findstr 9090 查询出当前主机上是否有使用9090端口的进程

|指管道把多个命令组合起来。

两个进程不能绑定同一个端口号，好比“一山不能容二虎，除非一公一母。

如果一个服务器是TCP，一个是UDP此时，端口重复了，是不影响的（一公一母）但是如果两个TCP／两个UDP，使用同一个端口，就会出现上述绑定失败的情况了。

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Executable;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public  class TcpEchoServer {
    private ServerSocket serverSocket=null;
    private ServerSocket serverSocket1=null;
    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
        serverSocket1= new ServerSocket(port+1);
    }
    public void start() throws IOException {
        System.out.println("服务器启动");

        ExecutorService pool= Executors.newCachedThreadPool();
        while(true) {
            Socket socket = serverSocket.accept();

//            Thread t=new Thread(()->{
//                try {
//                    processConnection(socket);
//                } catch (IOException e) {
//                    throw new RuntimeException(e);
//                }
//            });
//                t.start();
            pool.submit(new Runnable (){
                public void run() {
                    try {
                        processConnection(socket);
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
        }
    }
    public void processConnection(Socket socket) throws IOException {
        System.out.printf("[%s:%d]客户端上线!\n",socket.getInetAddress(),socket.getPort());
        try (InputStream inputStream = socket.getInputStream();
        OutputStream outputStream = socket.getOutputStream()){
            Scanner scanner = new Scanner(inputStream);
            while (true){
                if(!scanner.hasNext()){
                    System.out.printf("[%s:%d]客户端下线！\n",socket.getInetAddress(),socket.getPort());
                    break;
                }
                String request = scanner.next();
                String  response=process(request);
                outputStream.write(response.getBytes()); ;
                System.out.println(response);
            }
        }catch ( Exception e ){
            e.printStackTrace();
        }finally {
            socket.close();
        }
    }

    public  String process(String request) {
        return request+"\n";
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(9090);
        server.start();
    }


}

这样就服务器有两个端口号了。

一个进程绑定多个端口，用途非常广泛的，未来工作中经常能见到

比如写一个服务器程序，首先服务器需要有一个端口号，给客户端提供业务功能.这样的端口，称为"业务端口

程序猿还需要能够对这个服务器进行更精细的控制.

比如控制让这个服务器重新加载配置/开启某个功能/重新启动/重新加载数据/修改某个选项设定...

这样的操作，经常会通过网络来进行操作.服务器就会另外绑定一个端口号，称为"管理端口"

程序员想对这个服务器进行管理操作，就通过管理端口给服务器发送一些对应的请求，服务器执行对应的逻辑

日常开发会遇到一些bug，需要去查看服务器的一些运行状态（比如服务器中的一些关键的变量是啥样的值...服务器不能直接用调试器去调试～～（调试器一调试就会把服务器阻塞住，无法给别的客户端提供服务了）

也会通过网络的方式，给服务器发调试请求，服务器返回对应的关键信息.称为“调试端口”。