Explication du contrôleur de développement ThinkJS du framework Node.js

Original : Push instantané de la page Web Jingxiu.com | Veuillez indiquer la source de la réimpression
Lien :

Cette série de didacticiels est basée sur ThinkJS v2.x version (site officiel) Des exemples sont introduits et le tutoriel se concentre sur les opérations pratiques.

Cet article continue d'expliquer l'utilisation de Controller.

Méthode constructeur

Si vous souhaitez faire quelque chose lorsque l'objet est instancié, la méthode constructeur est le meilleur choix. Le constructeur fourni par ES6 est constructor .

La méthode constructeur est la méthode par défaut de la classe. Cette méthode est automatiquement appelée lorsqu'une instance d'objet est générée via la nouvelle commande. Une classe doit avoir une méthode constructeur Si elle n'est pas explicitement définie, une méthode constructeur vide sera ajoutée par défaut.
Méthodes
ECMAScript 6 Getting Started Auteur : Ruan Yifeng

init et constructeur

Le pouvoir de thinkjs est que nous pouvons non seulement suivre les règles export default class déclarent la classe par elles-mêmes et fournissent également une méthode pour créer dynamiquement une classe : think.controller.

Mais la classe créée dynamiquement par thinkjs n'a pas constructor, mais fournit un init comme alternative à la méthode constructeur, qui est utilisée de la même manière que constructor.

Il existe également des exemples d'utilisation de la méthode init dans l'article précédent (Node.js Domestic MVC Framework ThinkJS Development Controller Chapter Base Class and Inheritance Chain Part), regardez à nouveau le code :

// src/home/controller/base.js'use strict';export default class extends think.controller.base {
  init(...args) {super.init(...args);// 要求全部 url 必须携带 auth 参数let auth = this.get('auth');if (think.isEmpty(auth)) {  return this.error(500, '全部 url 必须携带 auth 参数');}
  }}

Bien sûr, cela ne veut pas dire que vous ne pouvez pas utiliser la méthode constructor Si vous êtes comme moi et avez l'habitude d'utiliser export default class pour déclarer vous-même des classes, vous. peut toujours utiliser la méthode standard constructor de.

Pour la méthode de création dynamique de classe dans thinkjs, veuillez vous référer à la documentation officielle et ne sera pas répété ici.

Méthodes magiques

thinkjs a implémenté plusieurs méthodes magiques très utiles, ce qui offre une grande commodité pour le développement Manuellement comme ~

__avant l'opération de préfixe

Comme son nom l'indique, la pré-opération sera exécutée avant l'exécution de l'action spécifique dans le contrôleur, ce qui signifie « exécutée avant xxx ». Regardons le code :

// src/home/controller/user.js'use strict';export default class extends think.controller.base {
  __before() {console.log('this is __before().');
  }
  indexAction() {console.log('this is indexAction().');return this.end();
  }}// 访问 /home/user/index 的执行结果如下：// this is __before().// this is indexAction().

Ensuite, certaines personnes pourraient dire : Il semble que

et __before aient le même objectif. Comme d'habitude, regardez le code : init

// src/home/controller/user.js'use strict';export default class extends think.controller.base {
  init(...args) {super.init(...args);console.log('this is init().');
  }
  __before() {console.log('this is __before().');
  }
  indexAction() {console.log('this is indexAction().');return this.end();
  }}// 访问 /home/user/index 的执行结果如下：// this is init().// this is __before().// this is indexAction().

Vous le voyez ? Il y a encore une séquence d'exécution, prenons-en une plus compliquée :

// src/home/controller/base.js'use strict';export default class extends think.controller.base {
  init(...args) {super.init(...args);console.log('this is base.init().');
  }}// src/home/controller/user.js'use strict';export default class extends think.controller.base {
  init(...args) {super.init(...args);console.log('this is user.init().');
  }
  __before() {console.log('this is user.__before().');
  }
  indexAction() {console.log('this is user.indexAction().');return this.end();
  }}// 访问 /home/user/index 的执行结果如下：// this is base.init().// this is user.init().// this is user.__before().// this is user.indexAction().

Eh bien, vous diriez « attendu »~

__après Post -opérations

Après avoir compris les pré-opérations, les post-opérations ne sont pas difficiles à comprendre :

// src/home/controller/user.js'use strict';export default class extends think.controller.base {
  init(...args) {super.init(...args);console.log('this is init().');
  }
  __before() {console.log('this is __before().');
  }
  __after() {console.log('this is __after().');
  }
  indexAction() {console.log('this is indexAction().');return this.end();
  }}// 访问 /home/user/index 的执行结果如下：// this is init().// this is __before().// this is indexAction().

Hein ? Quelque chose ne va pas. . .

Non exécuté. __after

Bien sûr, cela n'est pas dû au fait que

est écrit ci-dessus __after ! Modifier le code : indexAction

// src/home/controller/user.js'use strict';export default class extends think.controller.base {
  init(...args) {super.init(...args);console.log('this is init().');
  }
  __before() {console.log('this is __before().');
  }
  __after() {console.log('this is __after().');return this.end();
  }
  indexAction() {console.log('this is indexAction().');
  }}// 访问 /home/user/index 的执行结果如下：// this is init().// this is __before().// this is indexAction().// this is __after().

C'est OK cette fois, conforme aux résultats attendus.

Je sais que vous avez remarqué que le code

a été déplacé de return this.end() vers indexAction. __after

exécute en interne l'opération this.end()Node.js HTTP Response.end(), indiquant que tout le flux de réponse est terminé, donc si vous souhaitez activer , ce code est-ce qu'il doit être exécuté à l'intérieur de __after. __after

__call no-op

Cette méthode magique est un peu spéciale. Elle n'est pas utilisée pour s'exécuter sur un certain nœud de processus comme les deux méthodes magiques précédentes, mais partage certaines des responsabilités de <.> : Utilisé pour détecter lorsque l'action à laquelle un contrôleur accède n'est pas définie,

prendra en charge l'opération. init__call

Vous pouvez voir que lorsque le

// src/home/controller/user.js'use strict';export default class extends think.controller.base {
  init(...args) {super.init(...args);console.log('this is init().');
  }
  __call() {console.log(this.http.action + 'Action is not exists.');return this.end();
  }
  indexAction() {console.log('this is indexAction().');return this.end();
  }}// 访问 /home/user/test 的执行结果如下：// this is init().// testAction is not exists.

consulté n'existe pas, le framework exécutera

pour le traitement. Notre traitement consiste à enregistrer l'erreur et. terminer la sortie de réponse. testAction__callL'exemple de code place

dans une sous-classe de deuxième niveau, généralement dans une classe de base, qui peut contrôler le traitement des accès illégaux de toutes les sous-classes.

__call

Astuce : Cette méthode ne peut être utilisée que pour capturer la situation où l'Action n'existe pas, mais si le Controller n'existe pas, elle déclenchera directement une erreur 404 (reprise par le framework) et ne peut pas intervenir.

Si vous souhaitez détecter la situation où le contrôleur n'existe pas, vous devez étendre la classe d'erreur du framework, qui sera décrite dans un autre article.

Méthode d'appel externe

L'API du site officiel de thinkjs possède une interface pour instancier un autre contrôleur, mais elle n'explique pas l'utilisation spécifique de celui-ci :

Habituellement, cette méthode peut être utilisée pour instancier un contrôleur de niveau frère, ou pour obtenir des données, ou pour déclencher un processus métier, etc. Regardons le code :

//实例化 home 模块下 user controllerlet instance = think.controller('user', http, 'home');

On voit que thinkjs fournit un moyen d'instancier un contrôleur à la demande et d'exécuter ses méthodes.

// src/home/controller/user.js 增加_getPoints() {
  return 8000;}// src/home/controller/index.jslet instance = think.controller('user', this.http, 'home');let points = instance._getPoints();console.log(points); // 打印：8000instance.indexAction(); // 与直接执行 /home/user/index 是一样的效果instance.testAction(); // 报错 [Error] TypeError: instance.testAction is not a function

À première vue, cette méthode est très proche du résultat de

(sauf que la méthode magique de

ne sera pas déclenchée), alors à quoi sert thinkjs fournissant cette méthode ? Regardons le code : this.redirect

// src/home/controller/util.js'use strict';export default class extends think.controller.base {
  calcGPSDistance(lat, lng){// 计算 GPS 两点直线距离return distance;
  }
  calcBaiduDistance(lat, lng){// 计算 百度大地坐标 两点直线距离return distance;
  }
  calcSosoDistance(lat, lng){// 计算 Soso坐标 两点直线距离return distance;
  }}

这是一个助手 Controller，一个“隐身”的 Controller，从 url 是无法直接访问到的，因为它的所有方法名均没有 Action 后缀。

这个场景下，运行时实例化 Controller 并操作其方法的方式就派上用场了。

内置 http 对象

控制器在实例化时，会将 http 传递进去。该 http 对象是 ThinkJS 对 req 和 res 重新包装的一个对象，而非 Node.js 内置的 http 对象。
Action 里如果想获取该对象，可以通过 this.http 来获取。

thinkjs 官网

扩展应用：增加一个 n 秒后自动跳转的过渡页功能

thinkjs 框架并没有给我们准备这样一个过渡页面的功能，那么我们可以自己实现一个来练练手，上代码：

// src/common/controller/complete.js'use strict';export default class extends think.controller.base {
  /**   * 显示中转页面   *   * 调用方式：   * let complete = think.controller('complete', this.http, 'common');   * return complete.display('应用新增成功！', '/', 5);   *   * @param msg 提示文字，支持 HTML   * @param url 后续自动跳转的目标地址   * @param delay 停留秒数   * @returns {think.Promise}   */
  display(msg, url='', delay=3) {let tpl = 'common/complete/200';let opt = think.extend({}, {type: 'base', file_depr: '_', content_type: 'text/html'});this.fetch(tpl, {}, opt).then(content => {  content = content.replace(/COMPLETE_MESSAGE/g, msg);  if (url) {content = content.replace(/TARGET_URL/g, url);content = content.replace(/WAIT_SECONDS/g, delay);  };  this.type(opt['content_type']);  return this.end(content);}).catch(function(err){  return this.end('');});
  }}

<!-- view/common/complete_200.html --><!DOCTYPE html><html><head><title>正在跳转 - 荆秀网</title></head><body><p class="header"><p class="wrap"><p class="logo"><a href="/"><img src="/static/img/logo.png" alt="XxuYou" width="60"></a></p><p class="headr"> </p></p></p><p class="wrap"><p style="margin-top:20px;height:100px;background:url(/static/img/200.gif) top center no-repeat;"></p><h1>COMPLETE_MESSAGE</h1><p class="error-msg"><pre class="brush:php;toolbar:false">提示：页面将在 <span id="_count">WAIT_SECONDS</span> 秒后重定向到 <a href="TARGET_URL">TARGET_URL</a>

// Controller 内调用方式indexAction() {
  // 业务流程。。。
  let complete = think.controller('complete', this.http, 'common');
  return complete.display('操作成功！', '/', 5);}

以上新增的 src/common/controller/complete.js 是一个非侵入式的成功业务处理页面，其内部运行与兄弟 Controller src/common/controller/error.js 类似。

以上新增的 view/common/complete_200.html 则是相关的过渡页面的模版。其中存在三个占位符（分别对应 display 方法的入參）：

• COMPLETE_MESSAGE 用于操作成功的文字提示内容

• TARGET_URL 用于稍后会自动进入的目标 url

• WAIT_SECONDS 用于页面过渡时间，单位是秒

实现原理其实非常简单，阅读一下两个新增的代码就能明白。

扩展应用：快速构建 REST API

其实这部分因为太简答，我本来是不想写的。不过考虑到教程的完整性，还是写一下比较好。

REST 的概念介绍这里不再赘述，有兴趣的可以自行搜索。

thinkjs 的官网说到：

自动生成 REST API，而无需写任何的代码。

此言不虚，创建 Controller 时只要增加一个参数（thinkjs controller [name] --rest），即可生成一个能够操作数据库表的 REST API。

当然操作的约定也还是有的：

• GET /ticket #获取ticket列表

• GET /ticket/12 #查看某个具体的ticket

• POST /ticket #新建一个ticket

• PUT /ticket/12 #更新ticket 12

• DELETE /ticket/12 #删除ticekt 12

遵从了上述操作约定，的确是可以直接操作数据库表内的数据了。

只是这样的 API 只不过是一个“裸奔”状态的 API，还是不能直接投入使用。因为它不仅要求请求方熟悉所有的数据表结构，还要依赖请求方来维护多表数据之间的关联性，更不用提什么操作路径的映射、字段映射、返回数据的映射等等问题了。

就算 thinkjs 还提供了字段过滤、自定义 GET/POST/PUT/DELETE 方法来进行更多的定制，那么最终的结果很可能是在当前的 API 外面再包裹一层能够提供操作路径映射、鉴权令牌发放和识别、字段映射、关联数据维护等等。

当然作为一个开发框架，thinkjs 确实已经做的够多了，足够优秀了，因此我们还是需要像构建一个应用系统那样去完整构建一个可供实施的 REST API 的生产模型。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!