深入理解nginx连接数限制模块[下]

目录

  • 4 源码分析
    • 4.1 配置指令源码分析
      • 4.1.1 limit_conn_zone
      • 4.1.2 limit_conn
      • 4.1.3 limit_conn_log_level
      • 4.1.4 limit_conn_status
      • 4.1.5 limit_conn_dry_run
    • 4.2 共享内存初始化
    • 4.3 模块初始化
    • 4.4 请求处理
    • 4.5 红黑树的查找
    • 4.6 请求关闭的析构函数

关注我的微信公众号:
描述

上接 深入理解nginx连接数限制模块

4 源码分析

   ngx_http_limit_con_module模块和ngx_http_limit_req_module的实现原理是很象的,甚至包括配置参数也几乎一致,但是相比于后者,本模块实现起来更简单,因为它不需要漏桶算法,只要统计某个key对应的连接数,如果超过限定的值就拒绝请求即可。下面先从配置指令开始分析。关于ngx_http_limit_req_module的实现原理可以查看深入理解nginx的请求限速模块。

4.1 配置指令源码分析

4.1.1 limit_conn_zone

    { ngx_string("limit_conn_zone"),
      NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE2,
      ngx_http_limit_conn_zone,
      0,
      0,
      NULL },

  本模块通过以上代码在nginx配置文件的http块中定义了一个limit_conn_zone的配置指令,由ngx_http_limit_conn_zone解析函数进行解析。

  ngx_http_limit_conn_zone的实现代码就是分析配置指令,解析出用于连接限速的查询key(动态变量),并且根据配置的zone信息来创建一个共享内存缓冲区,创建的贡共享内存缓冲区用来存储key值对应的连接数的统计值。

static char *
ngx_http_limit_conn_zone(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
    u_char                            *p;
    ssize_t                            size;
    ngx_str_t                         *value, name, s;
    ngx_uint_t                         i;
    ngx_shm_zone_t                    *shm_zone;
    ngx_http_limit_conn_ctx_t         *ctx;
    ngx_http_compile_complex_value_t   ccv;

    value = cf->args->elts;

	/* 创建配置上下文 */
    ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_limit_conn_ctx_t));
    if (ctx == NULL) {
        return NGX_CONF_ERROR;
    }

    ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

    ccv.cf = cf;
    ccv.value = &value[1];
    ccv.complex_value = &ctx->key;

    if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
        return NGX_CONF_ERROR;
    }

    ......

	/* 解析共享内存zone的配置 */
	
	/* 创建一个共享内存缓冲区 */
    shm_zone = ngx_shared_memory_add(cf, &name, size,
                                     &ngx_http_limit_conn_module);
    if (shm_zone == NULL) {
        return NGX_CONF_ERROR;
    }

    if (shm_zone->data) {
        ctx = shm_zone->data;

        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                           "%V \"%V\" is already bound to key \"%V\"",
                           &cmd->name, &name, &ctx->key.value);
        return NGX_CONF_ERROR;
    }

    shm_zone->init = ngx_http_limit_conn_init_zone;
    shm_zone->data = ctx;

    return NGX_CONF_OK;
}

4.1.2 limit_conn

    { ngx_string("limit_conn"),
      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
      ngx_http_limit_conn,
      NGX_HTTP_LOC_CONF_OFFSET,
      0,
      NULL },

  本模块通过以上代码在nginx配置文件的http/server/location块中定义了一个limit_conn的配置指令,由ngx_http_limit_conn解析函数进行解析。通过定义这个指令,最终在location级别开启连接数限制功能。
  本模块和ngx_http_limit_req_module一样,也允许配置多个limit_conn指令,这样子本模块在请求进来的时候,会依次遍历所有的限制规则进行连接数限制处理。
  以下是实现源码,里面进行了详细的注释:

static char *
ngx_http_limit_conn(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
    ngx_shm_zone_t               *shm_zone;
    ngx_http_limit_conn_conf_t   *lccf = conf;
    ngx_http_limit_conn_limit_t  *limit, *limits;

    ngx_str_t  *value;
    ngx_int_t   n;
    ngx_uint_t  i;

    value = cf->args->elts;
	
	/* 在ngx_http_limit_conn_zone里面已经添加了, 这里获取共享内存区对象 */
    shm_zone = ngx_shared_memory_add(cf, &value[1], 0,
                                     &ngx_http_limit_conn_module);
    if (shm_zone == NULL) {
        return NGX_CONF_ERROR;
    }
    
	/* 获取连接数限制规则数组,如果没有创建则重建一个新的 */
    limits = lccf->limits.elts;

    if (limits == NULL) {
        if (ngx_array_init(&lccf->limits, cf->pool, 1,
                           sizeof(ngx_http_limit_conn_limit_t))
            != NGX_OK)
        {
            return NGX_CONF_ERROR;
        }
    }

	/* 如果当前配置的规则的zone之前的规则已经用过了,则报配置重复错误 */
    for (i = 0; i < lccf->limits.nelts; i++) {
        if (shm_zone == limits[i].shm_zone) {
            return "is duplicate";
        }
    }

	/* 分析连接限制的数量,最大是65535  */
    n = ngx_atoi(value[2].data, value[2].len);
    if (n <= 0) {
        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                           "invalid number of connections \"%V\"", &value[2]);
        return NGX_CONF_ERROR;
    }

    if (n > 65535) {
        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                           "connection limit must be less 65536");
        return NGX_CONF_ERROR;
    }

	/* 将限制规则添加到规则数组中 */
    limit = ngx_array_push(&lccf->limits);
    if (limit == NULL) {
        return NGX_CONF_ERROR;
    }

    limit->conn = n;
    limit->shm_zone = shm_zone;

    return NGX_CONF_OK;
}

4.1.3 limit_conn_log_level

    { ngx_string("limit_conn_log_level"),
      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
      ngx_conf_set_enum_slot,
      NGX_HTTP_LOC_CONF_OFFSET,
      offsetof(ngx_http_limit_conn_conf_t, log_level),
      &ngx_http_limit_conn_log_levels },

   本模块通过limit_conn_log_level指令定义了写限制事件日志的日志级别。

4.1.4 limit_conn_status

    { ngx_string("limit_conn_status"),
      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
      ngx_conf_set_num_slot,
      NGX_HTTP_LOC_CONF_OFFSET,
      offsetof(ngx_http_limit_conn_conf_t, status_code),
      &ngx_http_limit_conn_status_bounds },

  本模块通过limit_conn_status指令定义了发生连接数限制事件的时候给客户端响应的错误码,默认是503。

4.1.5 limit_conn_dry_run

    { ngx_string("limit_conn_dry_run"),
      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
      ngx_conf_set_flag_slot,
      NGX_HTTP_LOC_CONF_OFFSET,
      offsetof(ngx_http_limit_conn_conf_t, dry_run),
      NULL },

  本模块通过limit_conn_dry_run指令设置仅记录日志而不实际限制连接的标记。

4.2 共享内存初始化

  在4.1.1节中的ngx_http_limit_conn_zone函数中创建共享内存的时候设置了共享内存初始化回调函数ngx_http_limit_conn_init_zone,该函数的任务在共享内存池中初始化一棵红黑树,用来记录连接统计值。

static ngx_int_t
ngx_http_limit_conn_init_zone(ngx_shm_zone_t *shm_zone, void *data)
{
    ngx_http_limit_conn_ctx_t  *octx = data;

    size_t                      len;
    ngx_http_limit_conn_ctx_t  *ctx;

    ctx = shm_zone->data;

    if (octx) {
	    /* 这里的逻辑用来在reload的时候复用原来的共享内存池 */
        if (ctx->key.value.len != octx->key.value.len
            || ngx_strncmp(ctx->key.value.data, octx->key.value.data,
                           ctx->key.value.len)
               != 0)
        {
            ngx_log_error(NGX_LOG_EMERG, shm_zone->shm.log, 0,
                          "limit_conn_zone \"%V\" uses the \"%V\" key "
                          "while previously it used the \"%V\" key",
                          &shm_zone->shm.name, &ctx->key.value,
                          &octx->key.value);
            return NGX_ERROR;
        }

        ctx->sh = octx->sh;
        ctx->shpool = octx->shpool;

        return NGX_OK;
    }

	/* 获取共享内存池的地址 */
    ctx->shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;

    if (shm_zone->shm.exists) {
		/* 这个似乎也只有windows的环境才会进入这个分支了 */
		ctx->sh = ctx->shpool->data;

        return NGX_OK;
    }

	/* 在共享内存池中分配 */
    ctx->sh = ngx_slab_alloc(ctx->shpool, sizeof(ngx_http_limit_conn_shctx_t));
    if (ctx->sh == NULL) {
        return NGX_ERROR;
    }

    ctx->shpool->data = ctx->sh;

	/* 初始化红黑树 */
    ngx_rbtree_init(&ctx->sh->rbtree, &ctx->sh->sentinel,
                    ngx_http_limit_conn_rbtree_insert_value);

    len = sizeof(" in limit_conn_zone \"\"") + shm_zone->shm.name.len;

    ctx->shpool->log_ctx = ngx_slab_alloc(ctx->shpool, len);
    if (ctx->shpool->log_ctx == NULL) {
        return NGX_ERROR;
    }

    ngx_sprintf(ctx->shpool->log_ctx, " in limit_conn_zone \"%V\"%Z",
                &shm_zone->shm.name);

    return NGX_OK;
}

4.3 模块初始化

  模块初始化是在配置文件解析结束后,pstconfiguration阶段由nginx回调的,本模块是由ngx_http_limit_conn_init来处理,实现如下:

static ngx_int_t
ngx_http_limit_conn_init(ngx_conf_t *cf)
{
    ngx_http_handler_pt        *h;
    ngx_http_core_main_conf_t  *cmcf;

    cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

    h = ngx_array_push(&cmcf->phases[NGX_HTTP_PREACCESS_PHASE].handlers);
    if (h == NULL) {
        return NGX_ERROR;
    }

    *h = ngx_http_limit_conn_handler;

    return NGX_OK;
}

  也和ngx_http_limit_req_module一样,在NGX_HTTP_PREACCESS_PHASE阶段配置了一个回调函数用来对请求进行拦截处理,设置的回调函数是:ngx_http_limit_conn_handler。

4.4 请求处理

  当nginx收到请求的时候,会在NGX_HTTP_PREACCESS_PHASE阶段调用ngx_http_limit_conn_handler函数,ngx_http_limit_conn_handler函数的实现比较直白,就是遍历配置好的限制规则,先计算得到配置的动态key值,然后用这个key值查找共享内存中的红黑树得到连接统计值,最后根据配置的连接限制数与统计值比较判断是否要进行限制操作。源码实现如下:

static ngx_int_t
ngx_http_limit_conn_handler(ngx_http_request_t *r)
{
    size_t                          n;
    uint32_t                        hash;
    ngx_str_t                       key;
    ngx_uint_t                      i;
    ngx_rbtree_node_t              *node;
    ngx_pool_cleanup_t             *cln;
    ngx_http_limit_conn_ctx_t      *ctx;
    ngx_http_limit_conn_node_t     *lc;
    ngx_http_limit_conn_conf_t     *lccf;
    ngx_http_limit_conn_limit_t    *limits;
    ngx_http_limit_conn_cleanup_t  *lccln;

    if (r->main->limit_conn_status) {
        return NGX_DECLINED;
    }

    lccf = ngx_http_get_module_loc_conf(r, ngx_http_limit_conn_module);
    limits = lccf->limits.elts;

    for (i = 0; i < lccf->limits.nelts; i++) {
        ctx = limits[i].shm_zone->data;

		/* 求解红黑树查找的关键字,照理是每次循环得到的是相同的值,感觉放在循环外面比较好 */
        if (ngx_http_complex_value(r, &ctx->key, &key) != NGX_OK) {
            return NGX_HTTP_INTERNAL_SERVER_ERROR;
        }

        if (key.len == 0) {
            continue;
        }

        if (key.len > 255) {
            ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                          "the value of the \"%V\" key "
                          "is more than 255 bytes: \"%V\"",
                          &ctx->key.value, &key);
            continue;
        }

        r->main->limit_conn_status = NGX_HTTP_LIMIT_CONN_PASSED;

		/* 计算查找红黑树的哈希值 */*=
        hash = ngx_crc32_short(key.data, key.len);

        ngx_shmtx_lock(&ctx->shpool->mutex);

		/* 在红黑树中进行查找 */
        node = ngx_http_limit_conn_lookup(&ctx->sh->rbtree, &key, hash);

        if (node == NULL) {
        
			/* 红黑树中没有查到,则需要分配一个新的红黑树节点 */
            n = offsetof(ngx_rbtree_node_t, color)
                + offsetof(ngx_http_limit_conn_node_t, data)
                + key.len;

            node = ngx_slab_alloc_locked(ctx->shpool, n);

            if (node == NULL) {
                ngx_shmtx_unlock(&ctx->shpool->mutex);
                ngx_http_limit_conn_cleanup_all(r->pool);

                if (lccf->dry_run) {
                    r->main->limit_conn_status =
                                          NGX_HTTP_LIMIT_CONN_REJECTED_DRY_RUN;
                    return NGX_DECLINED;
                }

                r->main->limit_conn_status = NGX_HTTP_LIMIT_CONN_REJECTED;

                return lccf->status_code;
            }

            lc = (ngx_http_limit_conn_node_t *) &node->color;

            node->key = hash;
            lc->len = (u_char) key.len;
            lc->conn = 1;     /* 这是该key对应的第一个连接 */
            ngx_memcpy(lc->data, key.data, key.len);
            
			/* 将新的节点插入到红黑树中 */
            ngx_rbtree_insert(&ctx->sh->rbtree, node);

        } else {
        
			/* 如果红黑树中找到了对应的节点,则得到该节点设置好的连接统计信息 */
            lc = (ngx_http_limit_conn_node_t *) &node->color;

            if ((ngx_uint_t) lc->conn >= limits[i].conn) {

				/* 如果连接数超高了限制,那么需要打印日志
				   如果没有开启dry_run,那么就向客户端响应错误代码
				 */
                ngx_shmtx_unlock(&ctx->shpool->mutex);

                ngx_log_error(lccf->log_level, r->connection->log, 0,
                              "limiting connections%s by zone \"%V\"",
                              lccf->dry_run ? ", dry run," : "",
                              &limits[i].shm_zone->shm.name);

                ngx_http_limit_conn_cleanup_all(r->pool);

                if (lccf->dry_run) {
                    r->main->limit_conn_status =
                                          NGX_HTTP_LIMIT_CONN_REJECTED_DRY_RUN;
                    return NGX_DECLINED;
                }

                r->main->limit_conn_status = NGX_HTTP_LIMIT_CONN_REJECTED;

                return lccf->status_code;
            }

            lc->conn++;
        }

        ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                       "limit conn: %08Xi %d", node->key, lc->conn);

        ngx_shmtx_unlock(&ctx->shpool->mutex);

		/* 这里设置一个析构函数,用来在当前的请求对象内存池被释放前,
		   将共享内存区中对应的该key节点的连接数减去1
		 */
        cln = ngx_pool_cleanup_add(r->pool,
                                   sizeof(ngx_http_limit_conn_cleanup_t));
        if (cln == NULL) {
            return NGX_HTTP_INTERNAL_SERVER_ERROR;
        }

        cln->handler = ngx_http_limit_conn_cleanup;
        lccln = cln->data;    /* 设置析构函数的上下文信息 */

        lccln->shm_zone = limits[i].shm_zone;
        lccln->node = node;
    }

    return NGX_DECLINED;
}

  在以上函数中,由于是对共享内存中的数据进行操作,所以需要使用加锁和解锁操作,即ngx_shmtx_lock和ngx_shmtx_unlock。这两个函数的具体解释可以查看:nginx读写锁的实现逻辑

4.5 红黑树的查找

  在4.4节中用到了ngx_http_limit_conn_lookup函数,用来在红黑树中查找当前的key对应的连接统计信息,红黑树的查找就是普通的二叉查找树的遍历,源码如下,不做过多解释:

static ngx_rbtree_node_t *
ngx_http_limit_conn_lookup(ngx_rbtree_t *rbtree, ngx_str_t *key, uint32_t hash)
{
    ngx_int_t                    rc;
    ngx_rbtree_node_t           *node, *sentinel;
    ngx_http_limit_conn_node_t  *lcn;

    node = rbtree->root;
    sentinel = rbtree->sentinel;

    while (node != sentinel) {

        if (hash < node->key) {
            node = node->left;
            continue;
        }

        if (hash > node->key) {
            node = node->right;
            continue;
        }

        /* hash == node->key */

        lcn = (ngx_http_limit_conn_node_t *) &node->color;

        rc = ngx_memn2cmp(key->data, lcn->data, key->len, (size_t) lcn->len);

        if (rc == 0) {
            return node;
        }

        node = (rc < 0) ? node->left : node->right;
    }

    return NULL;
}

4.6 请求关闭的析构函数

  在4.4节中,我们设置了一个析构函数ngx_http_limit_conn_cleanup,用来在当前的nginx请求对象内存池被释放之前,进行析构处理,确保连接数的增加和减少动作能够一一对应,实现代码如下:

static void
ngx_http_limit_conn_cleanup(void *data)
{
    ngx_http_limit_conn_cleanup_t  *lccln = data;

    ngx_rbtree_node_t           *node;
    ngx_http_limit_conn_ctx_t   *ctx;
    ngx_http_limit_conn_node_t  *lc;

    ctx = lccln->shm_zone->data;
    node = lccln->node;
    lc = (ngx_http_limit_conn_node_t *) &node->color;

    ngx_shmtx_lock(&ctx->shpool->mutex);

    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, lccln->shm_zone->shm.log, 0,
                   "limit conn cleanup: %08Xi %d", node->key, lc->conn);

	/* 将连接数-1 */
    lc->conn--;

    if (lc->conn == 0) {
        ngx_rbtree_delete(&ctx->sh->rbtree, node);
        ngx_slab_free_locked(ctx->shpool, node);
    }

    ngx_shmtx_unlock(&ctx->shpool->mutex);
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/468905.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

DBSCAN聚类原理及Python实现

文章目录 一、相关术语二、DBSCAN原理2.1 算法思想及步骤2.2 优缺点分析2.3 Python代码 三、运行效率加速 一、相关术语 密度&#xff1a;指定半径内点的个数&#xff1b;核心点&#xff1a;如果某个点的半径邻域epsilon内至少包含minPts个点数&#xff0c;它就是核心点&#…

Spring Security的开发

文章目录 1,介绍2, 核心流程3, 核心原理3.1 过滤器链机制3.2 主体3.3 认证3.4 授权3.5 流程图4, 核心对象4.1 UserDetailsService 接口4.2 PasswordEncoder 接口4.3 hasAuthority方法4.4 hasAnyAuthority方法4.5 hasRole方法4.5 hasAnyRole方法5, 核心注解5.1 @PreAuthorize5.1…

十四、ReadWriteLock

ReadWriteLock 读写锁 又叫排他锁 如果使用互斥锁&#xff0c;一个线程在读&#xff0c;其他线程也不能读也不能写 换成读写锁的时候&#xff0c;读线程是读锁&#xff0c;写线程是写锁&#xff0c;写锁是排他的 在多线程大大提高效率&#xff0c;当一个线程在读的时候&…

MybatisPlus逆向工程

目录 &#x1f9c2;1.前提说明 &#x1f37f;2.引入依赖 &#x1f32d;3.使用导入模板 1.前提说明 注意 适用版本&#xff1a;mybatis-plus-generator 3.5.1 以下版本&#xff0c;3.5.1 及以上的请参考 3.5.1以上参考官网&#xff1a;3.5.1以上逆向工程 2.引入依赖 …

用 二层口 实现三层口 IP 通信的一个实现方法

我们一般用 undo portswitch 来将二层口转为三层口&#xff0c;但如果设备不支持的话&#xff0c;那么。。。 一、拓朴图&#xff1a; 二、实现方法&#xff1a; 起一个 vlan x&#xff0c;配置 vlanif地址&#xff0c;然后二层口划分到 vlan x 下&#xff0c;对端做同样的配置…

C语言 实用调试技巧

我们的博客已经更新到了数据结构&#xff0c;但是当我在深耕数据结构时我发现我在C语言是遗漏了一个重要的东西&#xff0c;那就是C语言的使用调试技巧。这篇博客对数据结构非常重要&#xff0c;请大家耐心观看。 1. 什么是bug&#xff1f; 第一次被发现的导致计算机错误的飞蛾…

Centos虚拟机忘记密码;重置虚机密码

虚拟机是一个好用的工具&#xff0c;在本地搭建的虚拟机可以给我们提供测试&#xff0c;但时间长了也会忘记密码&#xff1b;因此这里以centos系统的虚机为例&#xff0c;提供一个重置虚机密码的方法 1.在开机页面按“E”进入编辑模式 进入后长这样&#xff1a; 2.找到ro cras…

Python面向对象——架构设计【2】

练习1&#xff1a;打电话 请使用面向对象思想描述下列情景: 小明使用手机打电话,还有可能使用座机.... class People:def __init__(self,name):self.name namedef call_up(self,tool):print(self.name,end"")tool.call()class Tools:def __init__(self,way):self.wa…

【第十三章】改进神经网络学习方式-其他正则化技术

L1正则化 除了L2正则化之外&#xff0c;还有许多正则化技术。事实上&#xff0c;已经开发出了如此多的技术&#xff0c;以至于我不可能总结它们。在本节中&#xff0c;我简要介绍了三种减少过拟合的其他方法&#xff1a;L1正则化、dropout和人为增加训练集大小。我们不会像之前…

四.流程控制(顺序,分支,循环,嵌套)

c刚刚转过来的记得写在public static void main&#xff08;String[] args&#xff09;的花括号里 一.顺序结构 二.分支结构 if &#xff0c;switch 1.if (条件判断&#xff09; 2.if else 3.if else if else if ... else(它是一个一个否定来一个个执行判断的 4.s…

Gitee 实战配置

一、Gitee 注册帐号 官网&#xff1a;https://gitee.com点击注册按钮。填写姓名。填写手机号。填写密码。点击立即注册按钮 二、安装GIT获取公钥 1.官网下载git下载地址&#xff1a;https://git-scm.com/download/win 2.安装git&#xff0c;双击运行程序&#xff0c;然后一直下…

Android下的匀速贝塞尔

画世界pro里的画笔功能很炫酷 其画笔配置可以调节流量&#xff0c;密度&#xff0c;色相&#xff0c;饱和度&#xff0c;亮度等。 他的大部分画笔应该是通过一个笔头图片在触摸轨迹上匀速绘制的原理。 这里提供一个匀速贝塞尔的kotlin实现&#xff1a; class EvenBezier {p…

SD卡RAW故障解析与数据恢复全攻略

一、SD卡RAW现象解析 SD卡作为现代电子设备中常见的存储介质&#xff0c;其稳定性和可靠性直接关系到我们日常工作和生活的数据安全。然而&#xff0c;有时我们会遇到SD卡突然变成RAW格式的情况&#xff0c;这通常意味着SD卡的文件系统出现了严重的问题&#xff0c;导致无法正…

Python基础介绍 —— 使用pytest进行测试!

​编辑自动化测试 1319 篇文章62 订阅 订阅专栏 Pytest 是 Python 的一种单元测试框架&#xff0c;与 Python 自带的 unittest 测试框架类似&#xff0c;但是比 unittest 框架使用起来更简洁&#xff0c;效率更高。 Pytest 是一个成熟的全功能的 Python 测试工具&#xff0c;…

在VSCode中怎么配置Python开发环境?真的超简单!

前言&#xff1a;VS Code 里是不包括 Python 的&#xff0c;所以你首先得安装一个 Python。 1、终端运行 Python 安装完 python 之后&#xff0c;我们可以用任何一个文本编辑工具开始写 python 代码&#xff0c;然后在 cmd 中运行代码。 在 VS Code 中&#xff0c;在不安装任…

idea maven 项目融合

背景 &#xff1a;项目A 和项目B 是两个独立的多模块项目&#xff0c;项目A 和项目B &#xff0c;均为独立的数据源 。其中项目B 有两个数据原。 需要将项目B 以多模块的方式融合进项目A。 解决版本。建立项目C&#xff0c;只含有pom的&#xff0c;空项目&#xff0c;项目A和项…

Springboot 整合Mybatis 实现增删改查(二)

续上篇&#xff1a;Springboot整合Mybatis的详细案例图解分析-CSDN博客 mapper层&#xff08;StudentMapper&#xff09; //通过id查询student方法Student searchStudentById(int id);//通过id删除student方法int deleteStudentById(int id);//通过id增加student方法int inser…

文件批量管理利器,一键复制备份安全删除原文件,让文件管理更高效!

在数字化时代&#xff0c;我们每天都在与各种文件打交道&#xff0c;从文档、图片到视频、音频&#xff0c;文件的管理和存储变得越来越重要。然而&#xff0c;手动逐个处理文件不仅繁琐&#xff0c;还容易出错。那么&#xff0c;有没有一种方法可以让我们轻松实现文件的批量管…

如何提高Verilog代码编写水平?

在IC设计端的诸多岗位中&#xff0c;只要提到基础知识和必备技能&#xff0c;就一定少不了Verilog。 按照20年芯片设计老兵的说法“1. 知道module的基本框架。2. 知道怎么写assign&#xff0c;和always块。3. 其他没有了。” 也就是说用VerilogHDL做设计不要追求花架子&#…

鸿蒙开发系列教程(二十五)--样式处理(一)

1、样式属性 参考网址&#xff1a;https://developer.harmonyos.com/cn/docs/documentation/doc-references-V3/ts-universal-attributes-text-style-0000001427902436-V3 属性方法以 . 链式调用的方式配置系统组件的样式和其他属性 Entry Component struct Index {build() …