基于 P2P 技术的 Android 局域网内设备通信实践

这篇具有很好参考价值的文章主要介绍了基于 P2P 技术的 Android 局域网内设备通信实践。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Android 局域网内的多设备通信方式有多种,其中常见的方式有:

  1. 基于 TCP/UDP 的 Socket 通信
  2. 基于 Bluetooth 的近场通信
  3. 基于 Wifi 的 Wi-Fi Direct 连接
  4. 基于第三方框架的通信,如 MQTT、Websocket 等

每种方式都有其适用范围,下面分别介绍一下它们的示例代码、优劣势。

1. 基于 TCP/UDP 的 Socket 通信

Socket 是 TCP/UDP 套接字的抽象,通常用于实现网络上的应用程序通信。基于 Socket 的通信方式可以实现高效的传输,支持实时数据处理,其主要缺点是需要进行网络编程和网络拓扑发现。

下面是一个基于 TCP 的 Socket 通信示例,它通过创建一个服务器 Socket 和客户端 Socket 实现简单的数据传输:

// 服务器端代码
public class Server {
    public static void main(String[] args) throws Exception {
        // 创建一个服务器 Socket,绑定到指定的端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务器已启动,等待客户端连接...");

        // 等待客户端连接
        Socket socket = serverSocket.accept();
        System.out.println("客户端已连接[" + socket.getInetAddress().getHostAddress() + "]");

        // 获取输入输出流
        BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

        // 循环读取客户端发送的数据
        while (true) {
            String data = reader.readLine();
            System.out.println("客户端发送了消息:" + data);

            // 发送响应消息给客户端
            writer.write("服务端收到了消息[" + data + "]");
            writer.newLine();
            writer.flush();
        }
    }
}
// 客户端代码
public class Client {
    public static void main(String[] args) throws Exception {
        // 创建一个 Socket 连接服务器
        Socket socket = new Socket("localhost", 8888);

        // 获取输入输出流
        BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

        // 循环向服务器发送数据
        while (true) {
            // 发送消息给服务器
            writer.write("Hello, World!");
            writer.newLine();
            writer.flush();

            // 接收服务器响应消息
            String data = reader.readLine();
            System.out.println("服务器返回了响应消息:" + data);

            Thread.sleep(1000);
        }
    }
}

在上面的代码中,我们使用 Java 中的 ServerSocket 和 Socket 类来实现基于 TCP 的 Socket 通信。服务器端通过创建一个服务器 Socket 并等待客户端连接,收到连接请求后可以使用输入输出流来实现数据传输。客户端通过创建一个 Socket 向服务器发起连接,并使用输入输出流发送和接收数据。

2. 基于 Bluetooth 的近场通信

Bluetooth 是一种典型的无线短距离通信技术,它可以在近距离范围内实现设备之间的通信。Android 提供了 BluetoothAdapter 和 BluetoothSocket 等 API 来支持基于 Bluetooth 的通信,它们可以实现设备之间的数据传输、文件传输等功能。其主要缺点是受制于蓝牙信号的干扰和距离限制。

以下是一个基于 Bluetooth 的数据传输示例,它通过使用 BluetoothSocket 类实现数据传输:

// 服务端代码
public class ServerActivity extends AppCompatActivity {
    private static final int REQUEST_ENABLE_BT = 123;
    private BluetoothAdapter bluetoothAdapter;
    private BluetoothServerSocket serverSocket;
    private Thread acceptThread;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_server);

        // 初始化 BluetoothAdapter
        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        if (bluetoothAdapter == null) {
            Toast.makeText(this, "该设备不支持蓝牙", Toast.LENGTH_SHORT).show();
            return;
        }

        // 开启蓝牙
        if (!bluetoothAdapter.isEnabled()) {
            Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            startActivityForResult(intent, REQUEST_ENABLE_BT);
        }

        // 服务端开启监听线程
        acceptThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // 创建 BluetoothServerSocket
                    serverSocket = bluetoothAdapter.listenUsingRfcommWithServiceRecord("BluetoothServer", UUID.randomUUID());

                    while (true) {
                        // 等待客户端连接
                        BluetoothSocket clientSocket = serverSocket.accept();
                        Log.d("Server", "客户端已连接:" + clientSocket.getRemoteDevice().getName());

                        // 获取输入输出流
                        InputStream inputStream = clientSocket.getInputStream();
                        OutputStream outputStream = clientSocket.getOutputStream();

                        // 读取客户端发送的数据
                        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
                        String data = reader.readLine();
                        Log.d("Server", "客户端发送的数据是:" + data);

                        // 发送响应给客户端
                        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream));
                        writer.write("服务端收到了数据[" + data + "]");
                        writer.newLine();
                        writer.flush();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        acceptThread.start();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        // 关闭服务端 Socket
        if (serverSocket != null) {
            try {
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 停止监听线程
        if (acceptThread != null) {
            acceptThread.interrupt();
        }
    }
}
// 客户端代码
public class ClientActivity extends AppCompatActivity {
    private BluetoothAdapter bluetoothAdapter;
    private BluetoothDevice serverDevice;
    private BluetoothSocket socket;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_client);

        // 查找蓝牙设备
        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        Set<BluetoothDevice> devices = bluetoothAdapter.getBondedDevices();
        for (BluetoothDevice device : devices) {
            if ("BluetoothServer".equals(device.getName())) {
                serverDevice = device;
                break;
            }
        }

        if (serverDevice == null) {
            Toast.makeText(this, "未找到配对设备", Toast.LENGTH_SHORT).show();
            return;
        }

        // 连接蓝牙服务端
        try {
            socket = serverDevice.createRfcommSocketToServiceRecord(UUID.randomUUID());
            socket.connect();
            Log.d("Client", "连接服务器成功:" + socket.getRemoteDevice().getName());

            // 获取输入输出流
            InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream();

            // 向服务端发送数据
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream));
            writer.write("Hello, World!");
            writer.newLine();
            writer.flush();

            // 读取服务端响应数据
            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
            String data = reader.readLine();
            Log.d("Client", "服务端返回的响应:" + data);

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

    @Override
    protected void onDestroy() {
        super.onDestroy();

        // 关闭客户端 Socket
        if (socket != null) {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

在上面的代码中,我们使用了 BluetoothAdapter 和 BluetoothSocket 类来实现基于 Bluetooth 的近场通信。服务端通过创建蓝牙服务器 Socket 并等待客户端连接,客户端通过创建一个蓝牙 Socket 连接服务器。在每次通信时,我们都通过输入输出流来发送和接收数据。

3. 基于 Wifi 的 Wi-Fi Direct 连接

Wi-Fi Direct 是一种 P2P 网络连接方式,它使用 Wi-Fi 技术来实现设备之间的直接通信。如果设备支持 Wi-Fi Direct,我们可以使用 Android 提供的 WifiP2pManager 类并结合 WifiP2pManager.Channel 类来实现基于 Wi-Fi Direct 的通信。其主要优势是无需路由器就可以建立点对点连接,传输速度较快。缺点是目前有一定的兼容性限制,且Wi-Fi 信号干扰和距离限制较大。

以下是一个基于 Wi-Fi Direct 的数据传输示例,它使用 WifiP2pManager 和 WifiP2pManager.Channel 类来实现数据传输:

// 服务端代码
public class ServerActivity extends AppCompatActivity {
    private WifiP2pManager wifiP2pManager;
    private WifiP2pManager.Channel channel;
    private BroadcastReceiver receiver;
    private ServerSocket serverSocket;
    private Thread acceptThread;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_server);

        // 初始化 WifiP2pManager
        wifiP2pManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
        if (wifiP2pManager == null) {
            Toast.makeText(this, "该设备不支持 Wi-Fi Direct", Toast.LENGTH_SHORT).show();
            return;
        }

        // 初始化 Channel
        channel = wifiP2pManager.initialize(this, getMainLooper(), null);

        // 注册广播接收器
        receiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                String action = intent.getAction();
                if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
                    // Wi-Fi Direct 状态发生变化
                    int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
                    if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {
                        Log.d("Server", "Wi-Fi Direct 已启用");
                    } else {
                        Log.d("Server", "Wi-Fi Direct 已停用");
                    }

                } else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {
                    // 设备列表发生变化
                    wifiP2pManager.requestPeers(channel, new WifiP2pManager.PeerListListener() {
                        @Override
                        public void onPeersAvailable(WifiP2pDeviceList peers) {
                            for (WifiP2pDevice device : peers.getDeviceList()) {
                                Log.d("Server", "发现设备:" + device.deviceName + ", " + device.deviceAddress);

                                // 开始连接设备
                                if (device.deviceName.equals("client")) {
                                    WifiP2pConfig config = new WifiP2pConfig();
                                    config.deviceAddress = device.deviceAddress;
                                    wifiP2pManager.connect(channel, config, new WifiP2pManager.ActionListener() {
                                        @Override
                                        public void onSuccess() {
                                            Log.d("Server", "连接设备成功");
                                        }

                                        @Override
                                        public void onFailure(int reason) {
                                            Log.d("Server", "连接设备失败:" + reason);
                                        }
                                    });
                                }
                            }
                        }
                    });

                } else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) {
                    // 连接状态发生变化
                    NetworkInfo networkInfo = intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);
                    if (networkInfo.isConnected()) {
                        // 建立连接
                        Log.d("Server", "连接已建立");

                        // 创建服务器 Socket
                        try {
                            serverSocket = new ServerSocket(8888);
                            Log.d("Server", "服务器 Socket 已创建");
                        } catch (IOException e) {
                            e.printStackTrace();
                        }

                        // 开启接收线程监听客户端连接
                        acceptThread = new Thread(new Runnable() {
                            @Override
                            public void run() {
                                while (true) {
                                    try {
                                        // 等待客户端连接
                                        final Socket socket = serverSocket.accept();
                                        Log.d("Server", "客户端已连接:" + socket.getInetAddress());

                                        // 读取客户端发送的数据
                                        BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                                        String data = reader.readLine();

                                        // 发送响应给客户端
                                        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                                        writer.write("服务端收到了数据[" + data + "]");
                                        writer.newLine();
                                        writer.flush();
                                    } catch (IOException e) {
                                        e.printStackTrace();
                                    }
                                }
                            }
                        });
                        acceptThread.start();

                    } else {
                        // 断开连接
                        Log.d("Server", "连接已断开");
                        if (serverSocket != null) {
                            try {
                                serverSocket.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                        if (acceptThread != null) {
                            acceptThread.interrupt();
                        }
                    }

                } else if (WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)) {
                    // 本设备信息发生变化
                    WifiP2pDevice device = intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_DEVICE);
                    Log.d("Server", "本设备信息发生变化:" + device.deviceName + ", " + device.deviceAddress);
                }
            }
        };
        IntentFilter filter = new IntentFilter();
        filter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
        filter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
        filter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
        filter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
        registerReceiver(receiver, filter);

        // 发现并连接设备
        wifiP2pManager.discoverPeers(channel, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
                Log.d("Server", "开始查找设备");
            }

            @Override
            public void onFailure(int reason) {
                Log.d("Server", "查找设备失败:" + reason);
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        // 关闭服务端 Socket
        if (serverSocket != null) {
            try {
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 停止监听线程
        if (acceptThread != null) {
            acceptThread.interrupt();
        }

        // 注销广播接收器
        unregisterReceiver(receiver);
    }
}
// 客户端代码
public class ClientActivity extends AppCompatActivity {
    private WifiP2pManager wifiP2pManager;
    private WifiP2pManager.Channel channel;
    private BroadcastReceiver receiver;
    private WifiP2pDevice serverDevice;
    private Socket socket;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_client);

        // 初始化 WifiP2pManager
        wifiP2pManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
        if (wifiP2pManager == null) {
            Toast.makeText(this, "该设备不支持 Wi-Fi Direct", Toast.LENGTH_SHORT).show();
            return;
        }

        // 初始化 Channel
        channel = wifiP2pManager.initialize(this, getMainLooper(), null);

        // 注册广播接收器
        receiver = new BroadcastReceiver() {
            @Override
            public            void onReceive(Context context, Intent intent) {
                String action = intent.getAction();
                if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
                    // Wi-Fi Direct 状态发生变化
                    int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
                    if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {
                        Log.d("Client", "Wi-Fi Direct 已启用");
                    } else {
                        Log.d("Client", "Wi-Fi Direct 已停用");
                    }

                } else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {
                    // 设备列表发生变化
                    wifiP2pManager.requestPeers(channel, new WifiP2pManager.PeerListListener() {
                        @Override
                        public void onPeersAvailable(WifiP2pDeviceList peers) {
                            for (WifiP2pDevice device : peers.getDeviceList()) {
                                Log.d("Client", "发现设备:" + device.deviceName + ", " + device.deviceAddress);

                                // 记录服务端设备
                                if (device.deviceName.equals("server")) {
                                    serverDevice = device;
                                }
                            }
                        }
                    });

                } else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) {
                    // 连接状态发生变化
                    NetworkInfo networkInfo = intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);
                    if (networkInfo.isConnected()) {
                        // 建立连接
                        Log.d("Client", "连接已建立");

                        // 请求连接信息
                        wifiP2pManager.requestConnectionInfo(channel, new WifiP2pManager.ConnectionInfoListener() {
                            @Override
                            public void onConnectionInfoAvailable(WifiP2pInfo info) {
                                if (info.groupFormed && info.isGroupOwner) {
                                    // 服务端不需要做额外处理
                                    Log.d("Client", "该设备为服务端");

                                } else if (info.groupFormed) {
                                    // 客户端发起连接
                                    Log.d("Client", "该设备为客户端");

                                    try {
                                        socket = new Socket();
                                        socket.connect(new InetSocketAddress(serverDevice.deviceAddress, 8888), 5000);
                                        Log.d("Client", "连接服务器成功:" + socket.getInetAddress());

                                        // 向服务端发送数据
                                        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                                        writer.write("Hello, World!");
                                        writer.newLine();
                                        writer.flush();

                                        // 读取服务端响应数据
                                        BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                                        String data = reader.readLine();
                                        Log.d("Client", "服务端返回的响应:" + data);

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

                    } else {
                        // 断开连接
                        Log.d("Client", "连接已断开");
                        if (socket != null) {
                            try {
                                socket.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }

                } else if (WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)) {
                    // 本设备信息发生变化
                    WifiP2pDevice device = intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_DEVICE);
                    Log.d("Client", "本设备信息发生变化:" + device.deviceName + ", " + device.deviceAddress);
                }
            }
        };
        IntentFilter filter = new IntentFilter();
        filter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
        filter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
        filter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
        filter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
        registerReceiver(receiver, filter);

        // 扫描设备
        wifiP2pManager.discoverPeers(channel, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
                Log.d("Client", "开始查找设备");
            }

            @Override
            public void onFailure(int reason) {
                Log.d("Client", "查找设备失败:" + reason);
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        // 关闭客户端 Socket
        if (socket != null) {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 注销广播接收器
        unregisterReceiver(receiver);
    }
}

在上面的代码中,我们使用了 WifiP2pManager 和 WifiP2pManager.Channel 类来实现基于 Wi-Fi Direct 的通信。服务端通过创建服务器 Socket 并等待客户端连接,客户端通过创建一个 Socket 连接服务器。在每次通信时,我们都通过输入输出流来发送和接收数据。

至此,我们介绍了 Android 中常见的几种局域网通信方式,并给出了示例代码。不同的通信方式有不同的适用场景和特点,开发者可以根据实际需求选择合适的通信方式进行开发。除了局域网通信,如果需要进行远程通信,可以使用云服务提供商的 API,比如阿里云、腾讯云、AWS 等。这些云服务提供商提供了丰富的服务和 API,可以满足不同的需求,比如对象存储、云数据库、虚拟机、消息队列等等。

以阿里云为例,可以使用阿里云的移动推送服务,实现消息的推送和设备间的通信。例如,我们可以使用阿里云移动推送 SDK 将消息推送给指定的设备或者设备群组,也可以使用自定义消息进行设备间的通信。推送服务的使用需要先在阿里云控制台创建应用,并配置相关参数,然后在客户端集成移动推送 SDK,根据文档进行 API 调用即可。

此外,阿里云还提供了多种云计算服务,可以用于搭建云服务器、存储数据、处理数据等等。比如,我们可以使用阿里云的云服务器 ECS 来搭建一个 Web 服务器,将自己的应用部署到云服务器上,并使用域名解析服务进行域名解析,实现较为稳定和可靠的远程通信。

当然,不同的云服务提供商提供的服务和 API 也有所不同,开发者可以根据需求进行选择。但无论是局域网通信还是云服务通信,都需要进行网络编程和安全认证,具有一定的复杂性。因此,建议在开发前仔细阅读文档,并根据需求进行合理的设计和实现。文章来源地址https://www.toymoban.com/news/detail-472744.html

到了这里,关于基于 P2P 技术的 Android 局域网内设备通信实践的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 借助frp的xtcp+danted代理打通两边局域网p2p方式访问

    实现C内网所有设备借助c1内网代理访问B内网所有服务器 frps 配置 frps.ini ./frps -c frps.ini 启动 配置service自启(可选) /etc/systemd/system/frps.service systemctl start frps.service 启动服务 systemctl enable frps 设置自启 danted(socks5代理) sudo apt update sudo apt install dante-server cp /etc/danted.conf /etc/danted.co

    2024年02月11日
    浏览(41)
  • 区块链核心技术-P2P网络

    点对点网络是区块链中核心的技术之一,主要关注的方面是为区块链提供一个稳定的网络结构,用于广播未被打包的交易(交易池中的交易)以及共识过的区块,部分共识算法也需要点对点的网络支撑(如PBFT),另外一个辅助功能,如以太坊的消息网络,也需要点对点网络的

    2023年04月17日
    浏览(54)
  • Android12 P2P 初始化

    目录  学习资料:Android Miracast 投屏 1. 开机log 2. WifiP2pService 启动

    2024年02月06日
    浏览(48)
  • Android WiFi P2P数据传输

    WiFi P2P是指通过WiFi直接连接两台设备之间的无线点对点通信,不需要通过路由器或者互联网。这种技术被广泛应用于移动设备之间的文件共享、游戏联机、音乐播放等应用场景中。 WiFi P2P的优点在于可以在没有网络的情况下建立设备之间的连接,同时具有高速和低延迟的特点

    2024年02月07日
    浏览(41)
  • 如何用P2P技术为SRS媒体服务器节省带宽成本

        直播流的重要性在当今社会已无需多言,动辄上百万人同时在线的直播场景也已屡见不鲜。随着越来越多的观众收看直播,如何有效降低带宽成本,提升播放体验已成为各大视频厂商和创业者共同面对的技术难题。假设有 10,000 名观众观看相同 1Mbps 比特率流的直播场景

    2024年02月22日
    浏览(38)
  • 转载: 又拍云【PrismCDN 】低延时的P2P HLS直播技术实践

    低延时的P2P HLS直播技术实践 本文是第二部分《PrismCDN 网络的架构解析,以及低延迟、低成本的奥秘》 [首页 Open Talk NO.41 | 2018 音视频技术沙龙·深圳站 低延时 WebP2P 直播技术实践 https://opentalk-blog.b0.upaiyun.com/prod/2018-06-12/aa2e26500fc0b2eba14939746aed4d15]() 讲师简介 又拍云 PrismCDN 项目

    2024年02月09日
    浏览(45)
  • Dragonfly 基于 P2P 的文件和镜像分发系统

    作者: 孙景文、吴迪 网络下载 提起网络下载领域,你应该首先会想到基于 TCP/IP 协议簇的 C/S 模式。这种模式希望每一个客户机都与服务器建立 TCP 连接,服务器轮询监听 TCP 连接并依次响应,如下图: 上世纪末期,基于 C/S 模式的思想,人们发展了 HTTP , FTP 等应用层协议。

    2024年01月15日
    浏览(43)
  • 基于个人服务器的P2P内网穿透

    作为一个重度桌游爱好者,最近和小伙伴沉迷TTS(桌游模拟器),但是TTS是基于P2P进行连接的,如果小伙伴都不在一个网络节点上就会非常卡顿,为了更好的玩游戏,最后使用了基于zerotier的内网穿透方案 用上了内网穿透之后,再也不会掉线了,桌游体验极其完美 原理 购买

    2024年02月08日
    浏览(41)
  • 【Go语言】基于Socket编程的P2P通信程序示例

    Go语言的Socket编程实现为开发者提供了一种高效且强大的方式来实现网络通信。通过Go语言的并发模型和内置的网络库,如 net 包,开发者可以轻松地创建基于套接字的通信应用。Go语言的goroutine和channel机制使并发处理变得简单,能够轻松处理多个连接和数据交换。使用Go语言

    2024年02月11日
    浏览(50)
  • 局域网的硬件设备

    目录 前言 1.网卡 2.集线器 3.网络传输介质           组成小型局域网的主要硬件设备有 网卡、 集线器 等 网络传输介质 和 交换机、 网桥、 路由器、 网关 等网络互连设备。用集线器组成的网络称为共享式网络,而用交换机组成的网络称为交换式网络。         

    2024年02月12日
    浏览(39)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包