根据契约式设计原则编写解析URL的程序

最新推荐文章于 2025-03-17 13:24:03 发布
最新推荐文章于 2025-03-17 13:24:03 发布
阅读量159 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_41792539/article/details/109556174
版权

作者联系方式：854290197@qq.com

契约式设计的六大原则

  1. 原则一：区分命令和查询。查询返回一个结果，但不改变对象的可见性质。命令改变对象的状态，但不返回结果。（应当是不一定返回结果）
  2. 原则二： 将简单查询同组合查询分开。组合查询可以用简单查询来定义。
  3. 原则三： 针对每个组合查询，设定一个后验条件，使用一个或多个简单查询的结果来定义它。这样我们只要知道简单查询的值，也就能知道组合查询的值。
  4. 原则四：对于每个命令都撰写一个后验条件，规定每个简单查询的值。结合“用简单查询定义组合查询”的原则，我们已经能够知道每个命令的全部可视效果。
  5. 原则五：对于每个查询和命令，采用一个合适的先验条件。先验条件限定了客户调用查询和命令的时机。
  6. 原则六：撰写不变式来定义对象的恒定特性。类是某种抽象的体现，应当将注意力集中在最重要的属性上，以帮助读者建立关于类抽象的正确概念模型。

程序设计

根据以上六大原则设计解析URL的程序。我们知道URL由服务类型、主机名、路径及文件名三大基本部分组成，可能还包含有参数、锚、端口号等。（这里我们用C语言编写程序，C语言同样可以实现面向对象的编程）

首先我们要设计好一个类，类包含成员和方法。根据原则一的要求，我们要在方法中区分好命令和查询。这个应该直接在命名上就体现出来，比如查询应该使用getXXX等，一眼看到就知道这个是查询，不改变对象状态，哪个是命令，会改变对象状态。这个分类除了让我们能一眼就看出operation的特点之外，还是整个DbC在Operation组合的正则性的基础。如果划分错误，则可能破坏Operation组合的正则性。以下是我设计的类：

typedef char* (*url_get_protocol_t)(url_t* url);
typedef char* (*url_get_host_t)(url_t* url);
typedef char* (*url_get_path_t)(url_t* url);
typedef char* (*url_get_search_t)(url_t* url);
typedef char* (*url_get_query_t)(url_t* url);
typedef char* (*url_get_hash_t)(url_t* url);
typedef char* (*url_get_protocol_host_t)(url_t* url);
typedef char* (*url_get_protocol_host_post_t)(url_t* url);

typedef uint32_t (*url_get_port_t)(url_t* url);
typedef ret_t (*parse_url_t)(url_t* url);


//  url结构信息
typedef struct _url_t {
  /**
   * @property {char* } href
   * url字符串。
   */
  char* href;
  /**
   * @property {char* } protocol
   * 协议。
   */
  char* protocol;
  /**
   * @property {char* } host
   * 主机名
   */
  char* host;
  /**
   * @property {char* } path
   * 路径
   */
  char* path;
  /**
   * @property {char* } search
   * 搜索参数
   */
  char* search;
  /**
   * @property {char* } hash
   * 锚
   */
  char* hash;
  /**
   * @property {char* } query
   * 查询参数
   */
  char* query;
  /**
   * @property {uint32_t } port
   * 端口号
   */
  uint32_t port;

  /* 命令 */
  parse_url_t    parse_url;


  /* 简单查询成员的值 */
  url_get_protocol_t url_get_protocol;

  url_get_host_t url_get_host;

  url_get_path_t url_get_path;

  url_get_search_t url_get_search;

  url_get_query_t url_get_query;

  url_get_port_t url_get_port;

  url_get_hash_t url_get_hash;

 /*  组合查询成员的值 */
   url_get_protocol_host_t       get_protocol_host_t;
   url_get_protocol_host_post_t  get_protocol_host_post_t;

} url_t;

在该类中只有一个parse_url命令，用来获取url结构体成员中各个成员的值。在命令中，我用了状态机实现解析URL的字符串，解析的过程中有多种状态，遇到某种特定的字符就会切换到相应状态。包含以下几个状态：

typedef enum _char_state_t {
      /**
   * @const STATE_START
   * 起始状态。
   */
  STATE_START = 0,

  /**
   * @const STATE_PROTOCOL
   * 协议状态。
   */
  STATE_PROTOCOL,

  /**
   * @const STATE_HOST
   * 主机状态。
   */
  STATE_HOST,

  /**
   * @const STATE_POST
   * 端口状态。
   */
  STATE_POST,
  /**
   * @const STATE_PATH
   * 路径状态。
   */
  STATE_PATH,
  /**
   * @const STATE_HASH
   * 锚状态。
   */
  STATE_HASH,
  /**
   * @const STATE_PARA
   * 参数状态。
   */
  STATE_PARA,
  /**
   * @const STATE_END
   * 结束状态。
   */
  STATE_END

} char_state_t;

根据原则4的要求，每一个命令都需要有一个后验条件，用来规定简单查询的值。当进入某种状态，但是却没有得到相应的值，这是不合理的，这就需要我们在状态结束的时候设置一个后验条件，验证是否得到了相应的值。命令如下所示：

/************* 状态机解析URL各部分到url_t结构体 *************/
static ret_t url_parse(url_t* url) {
  return_value_if_fail(url != NULL, RET_FAIL);

  char_state_t STATE = STATE_START;
  char* ptr_start = url->href;
  char* ptr_now = url->href;

  while (*ptr_now) {
    switch (STATE) {
      case STATE_START:
        if (!IS_SPACE_SEPARATOR(*ptr_now)) {
          ptr_start = ptr_now;
          STATE = STATE_PROTOCOL;
          break;
        }
        break;
      case STATE_PROTOCOL:
        if (IS_PROTOCOL_SEPARATOR(ptr_now)) {
          copy_str_to_url_t(&url->protocol, ptr_start, ptr_now);
          /* 后验条件 */
          return_value_if_fail(strlen(url->protocol) !=0 ,RET_FAIL);

          ptr_now += 3;
          ptr_start = ptr_now;
          STATE = STATE_HOST;
          break;
        }
        break;
      case STATE_HOST:
        if (IS_PORT_SEPARATOR(*ptr_now) || IS_PATH_SEPARATOR(*ptr_now) ||
            IS_PARA_SEPARATOR(*ptr_now) || IS_ANCHOR_SEPARATOR(*ptr_now)) {
           copy_str_to_url_t(&url->host, ptr_start, ptr_now);
           /* 后验条件 */
           return_value_if_fail(strlen(url->host) !=0 ,RET_FAIL);
          ptr_start = ptr_now + 1;

          STATE = switch_state(*ptr_now);
          break;
        }
        break;
      case STATE_POST:
        if (IS_PATH_SEPARATOR(*ptr_now) || IS_PARA_SEPARATOR(*ptr_now) ||
            IS_ANCHOR_SEPARATOR(*ptr_now)) {
          char* port_temp = NULL;
          copy_str_to_url_t(&port_temp, ptr_start, ptr_now);
          url->port = tk_atoi(port_temp);
          return_value_if_fail(url->port > 0 ,RET_FAIL);
          ptr_start = ptr_now + 1;
          STATE = switch_state(*ptr_now);
          TKMEM_FREE(port_temp);
          break;
        }
        break;

      case STATE_PATH:
        if (IS_PARA_SEPARATOR(*ptr_now) || IS_ANCHOR_SEPARATOR(*ptr_now)) {
          copy_str_to_url_t(&url->path, ptr_start, ptr_now);
          /* 后验条件 */
          return_value_if_fail(url->path != NULL ,RET_FAIL);
          ptr_start = ptr_now + 1;
          STATE = switch_state(*ptr_now);
          break;
        }
      case STATE_PARA:
        if (IS_ANCHOR_SEPARATOR(*ptr_now)) {
          copy_str_to_url_t(&url->search, ptr_start - 1, ptr_now);
          /* 后验条件 */
          return_value_if_fail(url->search != NULL ,RET_FAIL);
          copy_str_to_url_t(&url->query, ptr_start, ptr_now);
          /* 后验条件 */
          return_value_if_fail(url->query != NULL ,RET_FAIL);

          ptr_start = ptr_now + 1;
          STATE = switch_state(*ptr_now);
        }

        break;
      default:
        break;
    }

    ptr_now++;
  }
  Processing_before_ending(STATE, url, ptr_start, ptr_now);

  STATE = STATE_END;
  return RET_OK;
}

根据原则2的要求，将组合查询和简单查询分开，组合查询可以用简单查询来定义：

/**************** 简单查询 *****************************/
static char* get_protocol(url_t* url) {
  return_value_if_fail(url != NULL, NULL);

  return url->protocol;
}
static char* get_host(url_t* url) {
  return_value_if_fail(url != NULL, NULL);
  return url->host;
}
static char* get_path(url_t* url) {
  return_value_if_fail(url != NULL, NULL);
  return url->path;
}
static char* get_search(url_t* url) {
  return_value_if_fail(url != NULL, NULL);
  return url->search;
}
static char* get_query(url_t* url) {
  return_value_if_fail(url != NULL, NULL);
  return url->query;
}
static char* get_hash(url_t* url) {
  return_value_if_fail(url != NULL, NULL);
  return url->hash;
}
static uint32_t get_port(url_t* url) {
  return_value_if_fail(url != NULL, RET_BAD_PARAMS);
  return url->port;
}

/**************** 简单查询 *****************************/
static char* get_protocol(url_t* url) {
  return_value_if_fail(url != NULL, NULL);

  return url->protocol;
}
static char* get_host(url_t* url) {
  return_value_if_fail(url != NULL, NULL);
  return url->host;
}
static char* get_path(url_t* url) {
  return_value_if_fail(url != NULL, NULL);
  return url->path;
}
static char* get_search(url_t* url) {
  return_value_if_fail(url != NULL, NULL);
  return url->search;
}
static char* get_query(url_t* url) {
  return_value_if_fail(url != NULL, NULL);
  return url->query;
}
static char* get_hash(url_t* url) {
  return_value_if_fail(url != NULL, NULL);
  return url->hash;
}
static uint32_t get_port(url_t* url) {
  return_value_if_fail(url != NULL, RET_BAD_PARAMS);
  return url->port;
}

/*********************** 组合查询 *************/
static char* get_protocol_host(url_t* url) {
  return_value_if_fail(url != NULL, NULL);
  uint32_t size = 0;
  char* temp = NULL;

  if (strlen(get_host(url)) != 0) {   /* 后验条件 */
    size = strlen(get_protocol(url)) + strlen(get_host(url)) + strlen("://") + 1;
    temp = TKMEM_ALLOC(size);
    return_value_if_fail(temp != NULL, NULL);
    tk_snprintf(temp, size, "%s://%s", get_protocol(url), get_host(url));
  }

  return temp;
}

static char* get_protocol_host_post(url_t* url) {
  return_value_if_fail(url != NULL, NULL);
  uint32_t size = 0;
  char* temp  = NULL;
  char buff[20] = {0};
  if (strlen(get_host(url)) != 0) {   /* 后验条件 */
    size = strlen(get_protocol(url)) + strlen(get_host(url)) + strlen("://") + 1;
    temp = TKMEM_ALLOC(size);
    return_value_if_fail(temp != NULL, NULL);
    tk_snprintf(temp, size, "%s://%s", get_protocol(url), get_host(url));
    if (url->port != 0) {    /* 后验条件 */
      size = strlen(get_protocol(url)) + strlen(get_host(url)) + strlen("://") + 1 +
                      strlen(tk_itoa(buff, sizeof(buff), get_port(url))) + 1;
      temp = TKMEM_REALLOCT(char, temp, size);
      return_value_if_fail(temp != NULL, NULL);
      tk_snprintf(temp, size, "%s:%d", temp, get_port(url));
    }
  }

  return temp;
}

程序中，组合查询例如查询服务类型和主机，可通过分别查询服务类型和主机来实现。根据原则3在组合查询中设置了后验条件，用来检验需查询的数据是否存在。

根据原则5的要求在每个查询和命令中都设置了先验条件，用来检验url对象是否已经创建。在程序中需要设计创建对象和销毁对象的函数：


/************* 创建url结构体 *************/
url_t* url_create(const char* url_href) {
  return_value_if_fail(url_href != NULL, NULL);
  url_t* url = TKMEM_ALLOC(sizeof(url_t));
  return_value_if_fail(url != NULL, NULL);

  url->href = TKMEM_ALLOC(strlen(url_href) + 1);
  tk_strcpy(url->href, url_href);

  url->protocol = TKMEM_CALLOC(1, sizeof(char));
  url->host = TKMEM_CALLOC(1, sizeof(char));
  url->path = TKMEM_CALLOC(1, sizeof(char));
  url->query = TKMEM_CALLOC(1, sizeof(char));
  url->search = TKMEM_CALLOC(1, sizeof(char));
  url->hash = TKMEM_CALLOC(1, sizeof(char));

  return_value_if_fail((NULL != url->protocol && NULL != url->host && NULL != url->path &&
                        NULL != url->query && NULL != url->search),
                       (url_destory(url), NULL));

  url->port = 0;

  url->url_get_protocol = get_protocol;
  url->url_get_host = get_host;
  url->url_get_path = get_path;
  url->url_get_search = get_search;
  url->url_get_query = get_query;
  url->url_get_hash = get_hash;
  url->url_get_port = get_port;

  url->get_protocol_host_t = get_protocol_host;
  url->get_protocol_host_post_t = get_protocol_host_post;

  url->parse_url = url_parse;

  return url;
}

/************* 销毁url结构体 *************/
void url_destory(url_t* url) {
  return_if_fail(NULL != url);

  TKMEM_FREE(url->protocol);
  TKMEM_FREE(url->host);
  TKMEM_FREE(url->path);
  TKMEM_FREE(url->query);
  TKMEM_FREE(url->search);
  TKMEM_FREE(url->hash);

  TKMEM_FREE(url->href);

  url->port = 0;

  TKMEM_FREE(url);

  return;
}

根据原则6对象的属性自始至终都是满足某种相应的状态。在命令中，切换不同的状态，就会设置不同的属性。

感谢阅读！希望会有更多有用的内容分享给大家。

电子商务平台技术选型和架构设计
AI天才研究院
08-04 2180
在这个时代，在线购物网站和电子商务平台已经成为促进互联网经济增长、服务用户和客户的重要平台。如何搭建一个具备高可用性、安全可靠的电商系统，是一个复杂的工程。作为一名技术人员，我们需要了解当前最新的电商平台架构，并对它们进行选择和优化，来满足我们的业务需求。本文将通过“十八篇”的方式，从基础知识、数据库、前端、后端、中间件、缓存、搜索引擎、消息队列等多个角度，带领读者掌握现代电商平台架构的核心技术细节。
SpringCloud OpenFeign 实战:Spring Cloud OpenFeign是一个基于Ribbon实现的声明式HTTP客户端
AI天才研究院
07-30 1843
Spring Cloud OpenFeign是一个基于Ribbon实现的声明式HTTP客户端。它使得编写Web服务客户端变得更简单，通过注解的方式即可调用远程服务。OpenFeign还支持可插拔的编码器和解码器，让你能够灵活地配置请求参数的编/解码方式，对应用进行高度定制化的开发。本文将会从以下几个方面进行阐述：1.1 为什么要使用OpenFeign？首先需要理解一下什么是RESTful。
Design By Contract(契约式设计)
u013571243的专栏
08-15 3383
1.前提 这是Bertrand Meyer在EL语言中提出的一个设计风格,流行了近20年。不过现在比较少用,不是很流行了,主要原因在下面提出   2.什么是契约式设计 契约式设计就是按照某种规定对一些数据等做出约定,如果超出约定,程序将不再运行,例如要求输入的参数必须满足某种条件 在scala中常用require和assume等 class BankAccount(val balanc
浅谈契约式编程
cjsycyl的专栏
04-05 847
契约式编程是编程的一种方法。那么什么是契约式编程呢？我想这个概念是从“合同”演变过来的。 在人类的社会活动中，契约一般是用于两方，一方（供应者）为另一方（客户）完成一些任务。每一方都期待从契约中获得利益，同时也要接受一些义务。通常，一方视为义务的对另一方来说是权利。契约文档要清楚地写明双方的权利与义务。 契约合同能保障双方的利益，对客户来说，合同规定了供应者要做的工作；对供应者来说，合同说明了
理解契约式编程与异常处理
最新发布
weixin_42575505的博客
03-17 816
本文深入探讨了契约式编程中的继承断言、前置条件和后置条件的变更，以及Eiffel语言中异常处理机制的应用。通过具体例程分析，说明了在编程中如何通过断言确保程序的正确性，并且在出现错误时如何通过异常处理来维护程序的稳定性和可恢复性。
《Design by Contract原则与实践》勘误与评述
kangtian0的专栏
12-10 968
《Design by Contract原则与实践》勘误与评述        本书原名：《Design by Contract by Example》，是孟岩翻译的。        怎么说孟岩也算国内的名人了，再加上我想具体了解一下契约式设计，所以就选择看了一下。第一感觉：书价不应该标那么高，虽然契约式设计2003年的时候还算新，但是凭书的厚度和内容实在不该标那么高的价格。当
软件设计原则——Design by Contract（契约式设计）
奈何桥收费站。。。
05-22 472
[size=small][b]个人心得，权作讨论，切勿当真 :P [/b] Design by Contract（契约式设计），以下简称DbC，字面意义来看，包含两个内容“责任”与“义务”，是对交易或互动中，两方之间关系的约束。换用软件行话来说，表示调用方与被调用方的，参数和返回值的Assert处理。 Assert有三个，前提条件、后续条件、和不变式，前两个针对方法，而最后一个针对整...
《Design by Contract》介绍
剑客星
07-26 1311
         契约式设计的本意很简单，就是在设计和编码阶段向面向对象程序中加入断言（assertion）。而所谓断言，实际就是必须为真的假设，只有这些假设为真，程序才可能做到正确无误。契约式设计的主要断言包括先验条件（precondition）、后验条件（postcondition）、以及不变式（invariant）：          ● 先验条件针对方法（method），它规定了在调用
微服务架构实战：从设计到部署的全面解析
本文全面介绍了微服务架构的设计原则和实践模式，详细探讨了服务的划分、自治治理、技术选型以及实践模式如API网关、服务注册与发现、断路器等。文章还深入剖析了微服务组件，包括服务注册与发现机制、配置中心的...
软件工程全链条解析：从需求分析到设计模式，专家带你深入理解
![软件工程全链条解析：从需求分析到设计模式，专家带你深入理解]...系统设计章节则覆盖了设计原则、常见架构模式以及微服务与云原生
系统工程方法论：面向服务的架构（SOA）设计原则与实践
本文概述了SOA的核心设计原则，探讨了服务的定义、封装与抽象、重用与组合等关键要素。同时，文章对SOA的技术实现进行了详细分析，包括服务的技术架构、通信协议以及数据表示与交换。通过实践应用案
《Design By Contract原则与实践》精彩片断选读
javalfans的专栏
08-30 240
《Design By Contract原则与实践》精彩片断选读 优快云书评组 人民邮电出版社近期将推出的《Design By Contract原则与实践》一书，是国内第一次引进以Design by Contract为主题的技术书籍，原文书《Design by Contract, by Example》2001年由培生集团出版。由于这本书所讲述的Design by Contract（本书译为“契...
契约式编程
cjsycyl的专栏
04-05 799
契约是减少大型项目成本的突破性技术。契约由先验条件、后验条件、错误和不变量等概念组成。契约可以而加到 C++ 中而无需对语言加以改造，但是却十分笨拙且不一致。 在语言内部支持契约的目的是： 给契约一个一致的观感 提供工具支持 使编译器能够根据从契约中收集的信息生成更好的代码 易于管理并强制实行契约 处理契约继承  契约的概念很简单——它只是必须为真的表达式。如若不然，契约
Design by Contract（契约式设计）
分布式成长
04-12 546
DBC  元素 先验条件:  针对方法（method），它规定了在调用该方法之前必须为真的条件。 后验条件: 也是针对方法，它规定了方法顺利执行完毕之后必须为真的条件。 不变式:  针对整个类，它规定了该类任何实例调用任何方法都必须为真的条件。 DBC 六大原则 ...
PHP契约式编程
HunterLeo的专栏
05-16 1050
抽象类 当类中有一个方法为抽象方法，该类就应该定义为抽象类 例： name=$name;           $this->speed=$speed;      }           abstract function run();           public function __get($k){           if(in_array($k, array('nam
Design by Contract
weixin_30950887的博客
01-30 87
A failure on the precondition indicates a bug on the client/caller A failure on the postcondition indicates a bug on the routine/supplier. Inheritance: Making sure that the precondition is always...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值