项目-SERVER模块-Socket模块

已于 2024-03-01 22:03:25 修改
阅读量861 收藏 17
点赞数 22
分类专栏： one thread one loop式并发服务器实现 文章标签： 服务器 网络
于 2024-03-01 22:03:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74447750/article/details/136406256
版权

Socket模块

一、Socket模块是什么？

Socket模块是对套接字操作封装的⼀个模块，主要实现的socket的各项操作。
在这里插入图片描述

二、代码实现

1.成员变量

这行代码表示在类（class）的私有（private）部分声明了一个整型变量 _sockfd，用于存储某个类的套接字文件描述符。在类的私有部分声明的成员只能在该类的成员函数内部访问，外部无法直接访问。

private:
    int _sockfd;

2.构造、析构函数

这段代码展示了一个名为Socket的类的构造函数和析构函数的定义：

  1. Socket() : _sockfd(-1) {}: 这是一个无参数的构造函数，用于初始化Socket类的对象。在这个构造函数中，通过初始化列表将_sockfd成员变量设置为-1，表示套接字文件描述符的初始值为-1。

  2. Socket(int sockfd) : _sockfd(sockfd) {}: 这是一个带有整型参数的构造函数，用于初始化Socket类的对象并指定套接字文件描述符的值。在这个构造函数中，通过初始化列表将_sockfd成员变量设置为传入的参数sockfd的值。

  3. ~Socket() { Close(); }: 这是Socket类的析构函数，用于释放资源和清理工作。在析构函数中调用了Close()函数，该函数应该是Socket类的一个成员函数，用于关闭套接字。通过在析构函数中调用Close()函数，确保在对象被销毁时及时关闭相关资源，避免资源泄漏。

public:
    Socket() : _sockfd(-1) {}
    Socket(int sockfd) : _sockfd(sockfd) {}
    ~Socket() { Close(); }

3.获取套接字文件描述符

这段代码定义了一个名为get_fd()的成员函数，用于获取类中私有成员变量_sockfd的值（套接字文件描述符）。该函数返回整型值，表示获取到的套接字文件描述符。

通过定义这样的成员函数，可以在类外部获取Socket类对象的套接字文件描述符，同时保持_sockfd作为私有成员的封装性。这样的设计方式遵循了面向对象编程的封装原则，将类的数据隐藏起来，只允许通过成员函数来进行访问和操作，从而提高了代码的安全性和可维护性。

    // 获取套接字文件描述符
    int get_fd() { return _sockfd; }

4.创建套接字

    // 创建套接字
    bool Create()
    {
        // 调用socket函数创建套接字
        // int socket(int domain, int type, int protocol)
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

        // 检查套接字创建是否成功
        if (_sockfd < 0)
        {
            // 套接字创建失败时输出日志信息
            INF_LOG("Socket creation failed");
            return false;
        }

        // 套接字创建成功
        return true;
    }

5.绑定地址信息

// 绑定地址和端口
bool Bind(const std::string &ip, uint16_t port)
{
    // 创建一个 sockaddr_in 结构体并设置相关参数
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;  // 设置地址族为IPv4

    // 将端口号转换为网络字节顺序
    addr.sin_port = htons(port);

    // 将IP地址转换为网络字节顺序并填入结构体中
    addr.sin_addr.s_addr = inet_addr(ip.c_str());

    // 计算地址结构体的长度
    socklen_t len = sizeof(struct sockaddr_in);

    // 调用bind函数将套接字和地址绑定
    int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
    if (ret < 0)
    {
        // 绑定失败时输出错误日志信息
        ERR_LOG("BIND ADDRESS FAILED!");
        return false;
    }

    // 绑定成功
    return true;
}

6.开始监听连接请求

// 开始监听连接请求
bool Listen(int backlog = MAX_LISTEN)
{
    // 调用listen函数开始监听连接请求
    int ret = listen(_sockfd, backlog);
    if (ret < 0)
    {
        // 监听失败时输出错误日志信息
        ERR_LOG("SOCKET LISTEN FAILED!");
        return false;
    }

    // 监听成功
    return true;
}

7.向服务器发起连接

// 向服务器发起连接
bool Connection(const std::string &ip, uint16_t port)
{
    // 创建一个 sockaddr_in 结构体并设置相关参数
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;  // 设置地址族为IPv4

    // 将端口号转换为网络字节顺序
    addr.sin_port = htons(port);

    // 将IP地址转换为网络字节顺序并填入结构体中
    addr.sin_addr.s_addr = inet_addr(ip.c_str());

    // 计算地址结构体的长度
    socklen_t len = sizeof(struct sockaddr_in);

    // 调用connect函数发起连接请求
    int ret = connect(_sockfd, (struct sockaddr *)&addr, len);
    if (ret < 0)
    {
        // 连接失败时输出错误日志信息
        ERR_LOG("CONNECT SERVER FAILED!");
        return false;
    }

    // 连接成功
    return true;
}

8.获取新连接

// 获取新连接
int Accept()
{
    // 调用accept函数接受新的连接
    // int accept(int sockfd, struct sockaddr *addr, socklen_t *len);
    int newfd = accept(_sockfd, NULL, NULL);
    if (newfd < 0)
    {
        // 接受连接失败时输出错误日志信息
        ERR_LOG("SOCKET ACCEPT FAILED!");
        return -1;
    }

    // 返回新的文件描述符
    return newfd;
}

9.接收数据

// 接收数据
ssize_t Recv(void *buf, size_t len, int flag = 0)
{
    // 调用recv函数接收数据
    ssize_t s = recv(_sockfd, buf, len, flag);
    if (s <= 0)
    {
        if (errno == EINTR || errno == EAGAIN)
        {
            // 如果是由于被信号中断或者暂时没有数据可读造成的接收失败，则记录日志并返回0
            INF_LOG("Recv has not ready!");
            return 0;
        }
        // 其他接收失败的情况，记录错误日志信息并返回-1
        ERR_LOG("read failed!");
        return -1;
    }

    // 返回实际接收的数据长度
    return s;
}

10.非阻塞接收数据

// 非阻塞接收数据
ssize_t NonBlockRecv(void *buf, size_t len)
{
    // 调用Recv函数，设置MSG_DONTWAIT标志表示非阻塞接收
    return Recv(buf, len, MSG_DONTWAIT);
}

11.发送数据

// 发送数据
ssize_t Send(const void *buf, size_t len, int flag = 0)
{
    // 调用send函数发送数据
    // ssize_t send(int sockfd, void *data, size_t len, int flag);
    ssize_t ret = send(_sockfd, buf, len, flag);
    if (ret < 0)
    {
        // 发送失败时记录错误日志信息并返回-1
        ERR_LOG("SOCKET SEND FAILED!!");
        return -1;
    }

    // 返回实际发送的数据长度
    return ret;
}

12.非阻塞发送数据

// 非阻塞发送数据
ssize_t NonBlockSend(void *buf, size_t len)
{
    // 调用Send函数，设置MSG_DONTWAIT标志表示非阻塞发送
    return Send(buf, len, MSG_DONTWAIT);
}

13.关闭套接字

// 关闭套接字
void Close()
{
    // 检查套接字是否有效，如果有效则关闭套接字
    if (_sockfd != -1)
        close(_sockfd);
    
    // 将套接字文件描述符设置为无效值
    _sockfd = -1;
}

14.创建一个服务端连接

// 创建一个服务端连接
bool CreateServer(uint16_t port, const std::string &ip = DEFAULT_IP, bool block_flag = false)
{
    // 1. 创建套接字 
    // 2. 绑定地址 
    // 3. 开始监听 
    // 4. 设置非阻塞 
    // 5. 启动地址重用

    // 如果创建套接字失败，则返回false
    if (Create() == false) return false;

    // 如果需要设置为非阻塞模式，则调用NonBlock函数
    if (block_flag) NonBlock();

    // 绑定地址，如果绑定失败则返回false
    if (Bind(ip, port) == false) return false;

    // 开始监听，如果监听失败则返回false
    if (Listen() == false) return false;

    // 启动地址重用
    ReuseAddress();

    return true;
}

15.创建一个客户端连接

// 创建一个客户端连接
bool CreateClient(uint16_t port, const std::string &ip)
{
    // 1. 创建套接字 
    // 2. 指向连接服务器

    // 如果创建套接字失败，则返回false
    if (Create() == false)  
        return false;

    // 连接服务器，如果连接失败则返回false
    if (Connection(ip, port) == false)
        return false;

    return true;
}

16.设置套接字选项——开启地址端口重用

// 设置套接字选项——开启地址端口重用
void ReuseAddress()
{
    // 使用setsockopt函数设置SO_REUSEADDR和SO_REUSEPORT选项开启地址和端口重用
    int val = 1;
    setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void*)&val, sizeof(int));
    val = 1;
    setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void*)&val, sizeof(int));
}

17. 设置套接字阻塞属性——设置为非阻塞

// 设置套接字阻塞属性——设置为非阻塞
void NonBlock()
{
    // 使用fcntl函数获取当前套接字的属性，并设置为非阻塞模式
    //int fcntl(int fd,int cmd,.../* arg */);
    int flag = fcntl(_sockfd, F_GETFL, 0);
    fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
}

18.测试代码

这段代码是一个简单的基于Socket的服务器端程序，它创建一个服务器Socket并监听指定端口（8500）。然后在一个无限循环中接受客户端连接，接收客户端发送的数据，并将数据原样发送回客户端，最后关闭与客户端的连接。注意：需要打开两个终端分别运行服务器端和客户端

//服务器端
#include"../source/server.hpp"
int main(){
    Socket lst_sock;
    lst_sock.CreateServer(8500);
    while(1){
       int newfd =lst_sock.Accept();
       if(newfd <0){
           continue;
       }  
       Socket cli_sock(newfd);
       char buf[1024]={0};
       int ret= cli_sock.Recv(buf, 1023);
       if(ret < 0){
           cli_sock.Close();
           continue;
       }
       cli_sock.Send(buf, ret);
       cli_sock.Close();
    }
    lst_sock.Close();
    return 0;
}

//客户端口
#include"../source/server.hpp"
int main()
{
    Socket cli_sock;
    cli_sock.CreateClient(8500,"127.0.0.1");
    std::string str="hello have a good day~";
    cli_sock.Send(str.c_str(),str.size());
    char buf[1024]={0};
    cli_sock.Recv(buf,1023);
    DBG_LOG("%s",buf);
    return 0;
}

测试结果：
在这里插入图片描述

19.整体源代码

// Socket //
#define MAX_LISTEN 1024
#define DEFAULT_IP "0.0.0.0"
class Socket
{
private:
    int _sockfd;
public:
    Socket() : _sockfd(-1) {}
    Socket(int sockfd) : _sockfd(sockfd) {}
    ~Socket() { Close(); }
    // 获取套接字文件描述符
    int get_fd() { return _sockfd; }

    // 创建套接字
    bool Create()
    {
        // 调用socket函数创建套接字
        // int socket(int domain, int type, int protocol)
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

        // 检查套接字创建是否成功
        if (_sockfd < 0)
        {
            // 套接字创建失败时输出日志信息
            INF_LOG("Socket creation failed");
            return false;
        }

        // 套接字创建成功
        return true;
    }

    // 绑定地址和端口
    bool Bind(const std::string &ip, uint16_t port)
    {
        // 创建一个 sockaddr_in 结构体并设置相关参数
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;  // 设置地址族为IPv4

        // 将端口号转换为网络字节顺序
        addr.sin_port = htons(port);

        // 将IP地址转换为网络字节顺序并填入结构体中
        addr.sin_addr.s_addr = inet_addr(ip.c_str());

        // 计算地址结构体的长度
        socklen_t len = sizeof(struct sockaddr_in);

        // 调用bind函数将套接字和地址绑定
        int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
        if (ret < 0)
        {
            // 绑定失败时输出错误日志信息
            ERR_LOG("BIND ADDRESS FAILED!");
            return false;
        }

        // 绑定成功
        return true;
    }

    // 开始监听连接请求
    bool Listen(int backlog = MAX_LISTEN)
    {
        // 调用listen函数开始监听连接请求
        int ret = listen(_sockfd, backlog);
        if (ret < 0)
        {
            // 监听失败时输出错误日志信息
            ERR_LOG("SOCKET LISTEN FAILED!");
            return false;
        }

        // 监听成功
        return true;
    }


    // 向服务器发起连接
    bool Connection(const std::string &ip, uint16_t port)
    {
        // 创建一个 sockaddr_in 结构体并设置相关参数
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;  // 设置地址族为IPv4

        // 将端口号转换为网络字节顺序
        addr.sin_port = htons(port);

        // 将IP地址转换为网络字节顺序并填入结构体中
        addr.sin_addr.s_addr = inet_addr(ip.c_str());

        // 计算地址结构体的长度
        socklen_t len = sizeof(struct sockaddr_in);

        // 调用connect函数发起连接请求
        int ret = connect(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            // 连接失败时输出错误日志信息
            ERR_LOG("CONNECT SERVER FAILED!");
            return false;
        }

        // 连接成功
        return true;
    }

   
    // 获取新连接
    int Accept()
    {
        // 调用accept函数接受新的连接
        // int accept(int sockfd, struct sockaddr *addr, socklen_t *len);
        int newfd = accept(_sockfd, NULL, NULL);
        if (newfd < 0)
        {
            // 接受连接失败时输出错误日志信息
            ERR_LOG("SOCKET ACCEPT FAILED!");
            return -1;
        }

        // 返回新的文件描述符
        return newfd;
    }


    // 接收数据
    ssize_t Recv(void *buf, size_t len, int flag = 0)
    {
        // 调用recv函数接收数据
        ssize_t s = recv(_sockfd, buf, len, flag);
        if (s <= 0)
        {
            if (errno == EINTR || errno == EAGAIN)
            {
                // 如果是由于被信号中断或者暂时没有数据可读造成的接收失败，则记录日志并返回0
                INF_LOG("Recv has not ready!");
                return 0;
            }
            // 其他接收失败的情况，记录错误日志信息并返回-1
            ERR_LOG("read failed!");
            return -1;
        }

        // 返回实际接收的数据长度
        return s;
    }

   
    // 非阻塞接收数据
    ssize_t NonBlockRecv(void *buf, size_t len)
    {
        // 调用Recv函数，设置MSG_DONTWAIT标志表示非阻塞接收
        return Recv(buf, len, MSG_DONTWAIT);
    }


    // 发送数据
    ssize_t Send(const void *buf, size_t len, int flag = 0)
    {
        // 调用send函数发送数据
        // ssize_t send(int sockfd, void *data, size_t len, int flag);
        ssize_t ret = send(_sockfd, buf, len, flag);
        if (ret < 0)
        {
            // 发送失败时记录错误日志信息并返回-1
            ERR_LOG("SOCKET SEND FAILED!!");
            return -1;
        }

        // 返回实际发送的数据长度
        return ret;
    }

   
    // 非阻塞发送数据
    ssize_t NonBlockSend(void *buf, size_t len)
    {
        // 调用Send函数，设置MSG_DONTWAIT标志表示非阻塞发送
        return Send(buf, len, MSG_DONTWAIT);
    }


    // 关闭套接字
    void Close()
    {
        // 检查套接字是否有效，如果有效则关闭套接字
        if (_sockfd != -1)
            close(_sockfd);
        
        // 将套接字文件描述符设置为无效值
        _sockfd = -1;
    }

   
    // 创建一个服务端连接
    bool CreateServer(uint16_t port, const std::string &ip = DEFAULT_IP, bool block_flag = false)
    {
        // 1. 创建套接字 
        // 2. 绑定地址 
        // 3. 开始监听 
        // 4. 设置非阻塞 
        // 5. 启动地址重用

        // 如果创建套接字失败，则返回false
        if (Create() == false) return false;

        // 如果需要设置为非阻塞模式，则调用NonBlock函数
        if (block_flag) NonBlock();

        // 绑定地址，如果绑定失败则返回false
        if (Bind(ip, port) == false) return false;

        // 开始监听，如果监听失败则返回false
        if (Listen() == false) return false;

        // 启动地址重用
        ReuseAddress();

        return true;
    }

    // 创建一个客户端连接
    bool CreateClient(uint16_t port, const std::string &ip)
    {
        // 1. 创建套接字 
        // 2. 指向连接服务器

        // 如果创建套接字失败，则返回false
        if (Create() == false)  
            return false;

        // 连接服务器，如果连接失败则返回false
        if (Connection(ip, port) == false)
            return false;

        return true;
    }
   
    // 设置套接字选项——开启地址端口重用
    void ReuseAddress()
    {
        // 使用setsockopt函数设置SO_REUSEADDR和SO_REUSEPORT选项开启地址和端口重用
        int val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void*)&val, sizeof(int));
        val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void*)&val, sizeof(int));
    }

   
    // 设置套接字阻塞属性——设置为非阻塞
    void NonBlock()
    {
        // 使用fcntl函数获取当前套接字的属性，并设置为非阻塞模式
        //int fcntl(int fd,int cmd,.../* arg */);
        int flag = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
    }
};
hu_yuchen
关注
  • 22
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
openstack neutron网络模块分析（一）---- neutron-server启动
energysober的博客
05-17 4022
neutron-server 启动流程 预备知识: WSGI：一个可以在python web服务中可以广泛使用的API PASTE：Paste Deployment用于发现和配置WSGI Application和Server，有了Paste Deployment，WSGI applications只需向其用户提供一个单独的入口loadapp函数，然后用户调用这个函数 就可以使用已经...
python socket connect函数,python－socket模块基本用法收集
weixin_42510182的博客
03-25 8954
基本上，Socket 是任何一种计算机网络通讯中最基础的内容。例如当你在浏览器地址栏中输入 www.oschina.net 时，你会打开一个套接字，然后连接到 www.oschina.net 并读取响应的页面然后然后显示出来。而其他一些聊天客户端如 gtalk 和 skype 也是类似。任何网络通讯都是通过 Socket 来完成的。本教程假设你已经有一些基本的 Python 编程的知识。让我们开始...
项目-功能模块划分
m0_74447750的博客
02-04 1790
功能模块划分
python socket模块_python中的Socket模块
weixin_39747511的博客
11-29 2221
1.Socket模块简介Socket模块的主要目的是帮助在网络上的两|个程序之间建立信息通道。在Python中提供了两个基本的Socket模块:服务端Socket和客户端Socket。当创建了一个服务端Socket之后，这个Socket就会在本机的一个端口上等待连接，客户端Socket会访问这个端口，当两者完成连接之后，就可以进行交互了。在Python中，Socket 模块的使用十分简单。在使用S...
python---socket模块---监控端口
菜鸟的博客
04-29 2625
import socket,re #.*?叫做非贪婪匹配，尽可能的少匹配 #.*叫做贪婪匹配，尽可能的多匹配 # a = 'fenif1212nfi129f21f' # res = re.compile('(\d+)').findall(a) # print(res) hosts = ['1.1.1.1:90','2.2.2.2:8080','127.0.0.1:80','3.3.3.3:50'...
python socket模块安装_python中socket模块详解（转载）
weixin_35610373的博客
01-13 3549
1.socket模块要使用socket.socket()函数来创建套接字。其语法如下：socket.socket(socket_family,socket_type,protocol=0)socket_family可以是如下参数：socket.AF_INET IPv4(默认)socket.AF_INET6 IPv6socket.AF_UNIX 只能够用于单一的Unix系统进程间通信socket_t...
webpack-dev-server简单使用
热门推荐
高山上的鱼
02-09 5万+
1.webpack-dev-server配置1.1 ContentBasewebpack-dev-server会使用当前的路径作为请求的资源路径，但是你可以通过指定content base来修改这个默认行为:$ webpack-dev-server --content-base build/这样webpack-dev-server就会使用build目录下的文件来处理网络请求。他会监听资源文件，当他们
大众点评Cat--Server模块架构分析
小白菜的博客
03-27 4万+
之前写过一篇dubbo cluster–架构。因为dubbo逻辑集群的功能主要是在client端，主要侧重在client的分析。后来因为工作忙和懒癌，也就没再继续server的叙述了。最近正好在看大众点评的cat源码，其中也有rpc的模块，就借此专门来分析下rpc server的实现。网络模型Cat server基于netty，是典型的reactor模型。 上图是网上找的reactor模型示例
Nginx - SSL模块
小杨博客 学习交流
09-02 2341
SocketLayer）是一个安全协议，为基于TCP（Transmission Control Protocol）的应用层协议提供安全连接，SSL介于TCP/IP协议栈第四层和第七层之间。主要提供私密性、完整性和身份验证；我们常见的就是 SSL为HTTP（Hypertext Transfer Protocol）协议提供安全连接。SSL协议是一种在两个机器之间提供安全通道的协议，它具有保护数据传输以及识别通信机器的功能。
Socket模块---Socket编写一个简单的服务端和客户端
dyx0910的博客
04-24 7126
Socket模块---Socket编写一个简单的服务端和客户端
socket-io-server-node
03-12
首先，导入`socket.io`模块并将其附加到HTTP服务器上： ```javascript const http = require('http'); const io = require('socket.io'); const server = http.createServer((req, res) => { res.writeHead(200);...
socket-io-server:提供用于初始化和连接到socket.io服务器的简单抽象
05-20
套接字服务器。 提供用于初始化并连接到socket.io服务器的简单抽象。 此模块创建一个单例对象，该对象公开使用现有的http服务器对象...// Initialize socket server.socket . init ( server ) ;// Initialize http ser
SNESt-Socket-server
03-15
SNESt-Socket-server是一个基于JavaScript的WebSocket服务器API，它允许开发者构建高性能、低延迟的实时应用。WebSocket是一种在客户端和服务器之间建立长期连接的协议，支持双向通信，即服务器和客户端都可以主动...
otm-socket-server
02-14
"otm-socket-server"项目是一个基于JavaScript的网络通信服务器，专门用于实现Socket通信。Socket是一种网络编程中的接口，允许程序通过Internet进行双向通信。在本项目中，它被用作创建实时、低延迟的客户端-服务器...
node-socket-video-server
03-05
9. **文件结构**：在`node-socket-video-server-master`目录下，通常会有以下文件和目录：`index.js`（服务器主文件），`package.json`（项目配置和依赖列表），`node_modules`（存储所有依赖的第三方模块），以及...
使用京东云主机搭建幻兽帕鲁游戏联机服务器全流程，0基础教程
facaixxx2024的博客
07-06 1014
使用京东云服务器搭建幻兽帕鲁Palworld游戏联机服务器教程，非常简单，京东云推出幻兽帕鲁镜像系统，镜像直接选择幻兽帕鲁镜像即可一键自动部署，不需要手动操作，真正的新手0基础部署幻兽帕鲁，阿腾云整理基于京东云服务器创建幻兽帕鲁游戏联机服务器教程，关于京东云服务器优惠可以在京东云服务器网 jdyfwq.com 查看最新云服务器配置和报价单。
Oracle数据库服务器CPU占用率巨高的问题排查思路
一杯温酒慰风尘，一段代码为爱好
07-04 372
1、where条件缺少主键；2、where条件缺少索引；3、对应主表数据量太大。
Linux系统的介绍和常用命令
最新发布
weixin_65175398的博客
07-07 964
Linux是一个开源的类Unix操作系统，由Linux内核、GNU工具及其他组件组成。它最初由Linus Torvalds于1991年发布，如今已成为服务器、超级计算机、桌面系统和嵌入式设备中广泛使用的操作系统之一。Linux因其安全性、稳定性和灵活性而受到广泛欢迎，特别是在开发和生产环境中。
GNU/Linux - 什么是loopback设备
guoqx的专栏
07-04 688
在计算机科学中，特别是在类Unix操作系统中，环回设备（loopback device）是一种虚拟设备，它将一个文件映射为块设备。这使得可以像访问物理磁盘或分区一样访问一个文件。环回设备通常用于挂载磁盘镜像、操作文件系统镜像以及执行各种类型的系统测试和开发。
npm install webpack-dev-server
05-09
如果你想要在开发环境中运行你的Webpack打包的应用程序，并且想要实现热模块替换，那么建议使用webpack-dev-server。 要安装webpack-dev-server，可以使用npm install命令，命令如下所示： ```shell npm install ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值