http - 如何通过 debugging 来学习软件的运行原理？

Question

第一次在 SegmentFault 提问，请多关照 ^^

这个问题可能有点泛泛，请先让我具体描述一下。我是一个编程小白初学者（本职是设计，编程是好奇心作祟），不过我也系统学习了 HTTP 以及一些基本的编程技术，最近经人介绍学起了 Rails 才逐渐了解和学习到编程方方面面的知识，很喜欢，刚刚跟着一个教程编写了一个非常简单的注册／登录功能，目前工作良好。

然而我的导师（带我入门的朋友）跟我说：

在 Web 开发中，身份校验是非常典型的功能，所有的 Web 开发框架都会提供哪怕是最基本的支持，同样也有很多第三方的插件和扩展包来提供更丰富的接口和功能。尝试学习和了解经典的身份校验原理对于 Web 开发者来说简直就是必修课。比如你刚才实现的东西，行话说就是：'基于 cookie 的认证机制'。你觉得不难，那是因为 Rails 帮你做了很多很多事情，而你做的只是最表层的，也是最简单的一些必要步骤而已。有机会的话，不妨试试去跟踪登录时框架的全过程，对你大有裨益的。

以上是他的原话（略作整理），我听了以后第一感觉好像很有道理……于是我问他怎么跟踪这个过程，但由于我们通讯不便（在外地旅游），他只给我讲了一些很抽象很难懂的要点。他建议我上这里来问问各路英雄，遇见类似的问题（不限定于注册／登录，也不限定于 Rails／Ruby），如果你们需要跟踪源代码来学习和理解某一个具体的功能实现，一般会怎么做？有什么要注意的事项或技巧呢？

其实我自己知道是要用到 debugging 的技术的，一些基本的技术我之前也学习过，至少知道如何给自己写的代码打断点，然后查看运行时的变量值或者步进／跳转之类的。但是就上述问题来说，当我登录的时候，我并不知道（举例） Rails 框架何时何地向我的浏览器发送 cookie 等等，在这种情形下，面对庞大的框架（随便看看就头晕）我要如何找到下手的地方呢？

真心请教各位学长前辈们，希望能从你们身上获得宝贵的启发和经验，谢谢！

Answer 1

Avis personnel, à titre indicatif seulement.
Utiliser le débogage et le code est un bon moyen d'apprendre un framework, mais le principe est que vous compreniez les connaissances de base. Si vous n'êtes pas familier avec le protocole http lui-même, alors regarder le framework qui l'implémente, c'est comme lire une Bible.

Par exemple, cette vérification d'identité.
Tout d'abord, vous devez savoir que http est dans la plupart des cas une connexion courte. Le client (le navigateur dans la plupart des cas) établit une connexion avec le serveur http, envoie des données, puis récupère les données renvoyées par le serveur, puis les envoie. la connexion est déconnectée.
Deuxièmement, vous devez savoir que les données dans la communication http sont divisées en requête (Request) et réponse (Response). La requête est envoyée par le client (au serveur) et la réponse est renvoyée par le serveur au client. La demande et la réponse sont divisées en en-tête et réponse (Content), l'en-tête est obligatoire et le contenu peut être vide.

Après avoir connu les deux points ci-dessus, examinons la vérification d'identité.

La vérification de l'identité est grossièrement divisée en deux processus :
1. Connexion utilisateur ;
2. Lorsqu'un utilisateur accède à d'autres ressources, vous obtenez l'identité de l'utilisateur et déterminez s'il peut accéder à cette ressource
;

Comme mentionné ci-dessus, http est une connexion courte dans la plupart des cas, et le scénario ci-dessus est une connexion courte.

Les utilisateurs se connectent et accèdent à d'autres ressources, qui sont évidemment deux connexions.
Ensuite, le serveur ne peut pas déterminer que les deux connexions proviennent de vous, alors comment obtenir l'identité de l'utilisateur lorsque vous vous connectez à la ressource pour la deuxième fois ?
Afin de résoudre ce problème, le protocole http prévoit des cookies.

Lors de la première connexion - lors du traitement de la connexion de l'utilisateur, si l'utilisateur se connecte avec succès, l'en-tête de la réponse du serveur (Response) contient l'en-tête Set-Cookie, qui contient les informations de l'utilisateur, indiquant que le client enregistre certains cookies. et stipule dans quelles circonstances (voir les dispositions relatives aux cookies pour plus de détails) le client doit renvoyer ces cookies au client.

Lors de la deuxième connexion - lors de l'accès aux ressources, parce que les conditions d'envoi des cookies sont remplies, le client mettra le cookie dans l'en-tête de la requête (Request) en tant qu'en-tête Cookie. De cette manière, le serveur obtient le cookie en analysant l'en-tête de la requête, et en obtient également les informations sur l'utilisateur.

Il s'agit du processus de mise en œuvre sous-jacent d'une vérification d'identité.

Parmi eux, le navigateur gère le Set-Cookie dans l'en-tête de réponse, enregistre le cookie, place le cookie dans l'en-tête de la requête et l'envoie au serveur lorsque les conditions sont remplies.

Le placement de Set-Cookie dans l'en-tête de réponse et la lecture des informations sur les cookies à partir de l'en-tête de demande peuvent être implémentés par le framework que vous utilisez.

////////// Ajouter la réponse à la réponse //////////
Après que le questionneur ait répondu, j'ai ajouté le contenu discuté avec le questionneur dans la réponse.
Ce que j'ai mentionné ci-dessus est la condition préalable à la compréhension du cadre. Autrement dit, vous devez d’abord comprendre ce que le framework a fait pour vous, puis examiner comment le framework fait ces choses.
Voici le contenu de la discussion, j'étais paresseux et je l'ai copié-collé directement :
Permettez-moi de parler de ma compréhension générale : le framework Web est responsable du décodage des requêtes ainsi que de l'encodage et de l'encapsulation des réponses. Lorsque les développeurs ont besoin d’écrire une logique, ils n’ont besoin que d’obtenir des paramètres et de renvoyer des données. La manière dont les paramètres sont extraits de la requête et la manière dont les résultats renvoyés sont codés dans les réponses sont toutes effectuées par le framework.
Par conséquent, de manière générale, vous pouvez définir des points d'arrêt au début et à la fin de la logique que vous écrivez, puis suivre le traitement à l'intérieur du framework.
Tout d'abord, définissez un point d'arrêt à la fin. C'est relativement simple, car une fois votre traitement logique terminé et les données renvoyées, elles sont transmises au framework pour traitement. À ce stade, vous pouvez suivre l'intérieur du code du framework. grâce au traçage en une seule étape et surveillez votre retour étape par étape. Les données sont traitées par le framework.
L'autre consiste à définir un point d'arrêt au début. À ce stade, la partie traitement du framework a effectivement été exécutée, mais les outils de débogage généraux peuvent voir la pile d'appels. Vous pouvez utiliser la pile d'appels pour voir quel code le framework a exécuté auparavant. exécutez votre code logique, recherchez ensuite le code dans lequel la requête vient d'arriver, définissez un point d'arrêt ici, renvoyez la requête, puis suivez-la étape par étape.
Après avoir suivi les codes de début et de fin, vous comprendrez déjà le flux de traitement de l'ensemble du framework.

Answer 2

Tout d’abord, le débogage est nécessaire pour n’importe quel langage. Si le langage ne fournit pas de bons outils de débogage. Donc la langue est une merde. Surtout, je déteste certains soi-disant débogages qui ne sont pas nécessaires. Un programme compilé tel qu'il est écrit.

La façon d'apprendre quelque chose est. Jetons d’abord un coup d’œil rapide au livre d’introduction. Relisez-le. Comprenez simplement le concept. Puis codez comme requis. Le premier peut être compilé avec succès (C++). Ou peut exécuter (python). cet état. Il s'appuie principalement sur la fonction de correction d'erreurs de l'IDE.

Attendez que la correction de l'erreur IDE soit terminée. Divers problèmes surviendront après l'exécution. Principalement des erreurs logiques ou SegmentFault (C++).
Que faire à ce moment-là. Regarder le code encore et encore est tout simplement insupportable.

En général, certaines personnes le diront aux débutants. Printf/System.Out.println/print/ et autres sorties pour vérifier si chaque variable est normale et a la valeur souhaitée.
Celles-ci sont intolérables pour les personnes expérimentées (exigences pour les deux premières des trois vertus des programmeurs (irritabilité, paresse et arrogance)), et écrire Print est très fatiguant. Il sera également supprimé une fois publié. Et certaines interfaces appelantes ne connaissent pas la valeur de retour. Créez un printf et exécutez-le. Cela prend du temps et de l’énergie.

Alors, que fait une personne qualifiée ? déboguer. C'est la source du débogage mentionné par l'affiche originale.
Je n'ai plus besoin d'imprimer. Vous pouvez directement vérifier si chaque donnée est normale. Est-ce la valeur souhaitée.
en Java/C++. Le débogage est correct.
Vous ne connaissez pas la valeur de retour ou l'effet d'une fonction. débogage. Arrêtez-vous dans l'environnement où il doit être exécuté. Fonction de test. Vous pouvez connaître sa valeur de retour correspondante. Sachez continuer à écrire.
Lorsqu'une erreur d'exécution apparaît sur la pile, définissez directement le point d'arrêt sur la pile correspondante. Quel morceau de code est à l'origine du problème ? Il est clair en un coup d'œil quelle variable a une valeur nulle.
Il y a aussi le processus d'exécution du programme. J'ai fait quelques opérations. Vous pouvez également suivre le processus d'exécution du code en contrôlant le débogage. C’est la fonction d’apprentissage mentionnée par l’affiche.

Mais ce n'est qu'un débogage.
Il y a deux autres choses à la fin :
L'un d'entre eux est Log : vous n'êtes pas autorisé à déboguer en ligne. Que faire si quelque chose ne va pas. Enregistrez ce que vous pensez être le problème et il sera clair de trouver le bogue le moment venu. .
L’un est Test : uniquement les tests unitaires. Les tests sont une autre façon de vous assurer que votre code est correct. Par exemple, vous écrivez une très petite partie du projet. La fonction principale de cette pièce est très lointaine. Seules des circonstances très particulières sont impliquées dans votre code. (Bien sûr, Java/Python peut écrire un nombre illimité de fonctions principales, mais certains ne le peuvent pas). Mais après avoir écrit le test unitaire. Commencez directement par les tests unitaires. gentillesse. Simulez l’entrée et la sortie souhaitées. Les erreurs de fonction peuvent être découvertes à temps. Il n’est pas nécessaire d’écrire un grand projet dans son intégralité. Ensuite, j'ai recherché des erreurs dans d'innombrables piles.
De plus, les tests unitaires peuvent éliminer les bogues dans certains environnements. Par exemple, votre code s'exécute normalement sur votre ordinateur. Tous satisfaits. Mais cela ne fonctionne pas correctement sur d'autres ordinateurs. Avec les tests unitaires, vous pouvez rapidement découvrir quel morceau de code pose problème.

Supposons que vous arriviez ici. Je pense que vous êtes déjà un programmeur qualifié.

Mais les maîtres ont encore deux choses. Tests de performances et analyse des performances. à ce point. Vous devrez avoir une connaissance approfondie de chaque langage ou la connaissance sous-jacente de la machine virtuelle. Je ne dirai pas grand chose pour un débutant comme moi