{"id":7838,"date":"2020-05-14T00:00:00","date_gmt":"2020-05-13T22:00:00","guid":{"rendered":"https:\/\/blog.ouidou.fr\/?p=7838"},"modified":"2025-12-01T17:00:21","modified_gmt":"2025-12-01T16:00:21","slug":"injection-de-dependances-the-ruby-way","status":"publish","type":"post","link":"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way","title":{"rendered":"Injection de d\u00e9pendances\u00a0: the Ruby way"},"content":{"rendered":"<p><em>Article \u00e9crit par Ludovic de Luna<\/em><\/p>\n<p><img decoding=\"async\" src=\"https:\/\/framapic.org\/AQWS5vzVOr0Z\/yoCD7738Jd71.jpg\" alt=\"Tasse Pikachu avec un jus de fruit dedans\" loading=\"lazy\" \/><\/p>\n<div style=\"text-align: center; font-size: 80%;\">Photo par <a href=\"https:\/\/unsplash.com\/@wx1993?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText\"> Raychan <\/a> depuis <a href=\"https:\/\/unsplash.com\/?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText\"> Unsplash <\/a><\/div>\n<p>L\u2019injection est un moyen simple pour donner de la fluidit\u00e9 \u00e0 vos algorithmes lorsqu\u2019ils manipulent des classes de plus bas niveau. Pour la suite, nous nommerons ces classes\u00a0\u00ab\u00a0d\u00e9pendances\u00a0\u00bb et vos algorithmes constituent un \u00ab\u00a0composant\u00a0\u00bb.<\/p>\n<p>Sans injection, votre composant doit savoir comment instancier la d\u00e9pendance qu\u2019il utilise, ce qui implique de conna\u00eetre son impl\u00e9mentation (la classe).<\/p>\n<p>Avec injection, votre composant se focalise uniquement sur l\u2019interaction et ne doit plus g\u00e9rer les d\u00e9tails d\u2019impl\u00e9mentation, ce qui apporte de la r\u00e9silience face aux changements gr\u00e2ce \u00e0 un couplage faible.<\/p>\n<p>Quand utiliser l\u2019injection\u00a0? Comment proc\u00e9der\u00a0? C\u2019est ce que nous allons voir tout de suite.<\/p>\n<blockquote><p>Je vous laisse deviner le rapport entre l\u2019injection de d\u00e9pendances et la tasse Pikachu en photo. R\u00e9ponse en fin d\u2019article.<\/p><\/blockquote>\n<h2 id=\"cas-concret\">Cas concret<\/h2>\n<p>Imaginons la situation suivante\u00a0: vous d\u00e9veloppez un composant qui fait de la localisation <abbr title=\"Global Positioning System. En fran\u00e7ais\u00a0: G\u00e9o-positionnement par satellite.\">GPS<\/abbr> via un service de type Google Maps. Le choix n\u2019est pas d\u00e9finitif.<\/p>\n<p>Voici le composant que vous souhaitez d\u00e9velopper\u00a0:<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/framapic.org\/SKtFQP7U1Clr\/DUTJuk9TLosw.png\" alt=\"Sch\u00e9ma du composant \u00e0 d\u00e9velopper\" loading=\"lazy\" \/><\/p>\n<p>La classe \u00ab\u00a0Client\u00a0\u00bb va instancier la classe \u00ab\u00a0MapService\u00a0\u00bb. Celle-ci impl\u00e9mente l\u2019algorithme n\u00e9cessaire aux interactions avec Google Maps. Elle repr\u00e9sente une d\u00e9pendance vis-\u00e0-vis de la classe \u00ab\u00a0Client\u00a0\u00bb.<\/p>\n<p>L\u2019objectif de l\u2019article est de rendre cette d\u00e9pendance injectable. Le choix de l\u2019injection \u00e0 utiliser devra \u00eatre param\u00e9trable\u00a0: une impl\u00e9mentation sera choisie au d\u00e9marrage de l\u2019application. Toutefois, le d\u00e9veloppeur garde la possibilit\u00e9 de surcharger cette injection selon ses besoins.<\/p>\n<p>Je vous proposerai dans un premier temps une injection manuelle relativement simple avec une d\u00e9pendance par d\u00e9faut. Par la suite, nous verrons comment rendre param\u00e9trable l\u2019injection gr\u00e2ce \u00e0 un conteneur.<\/p>\n<p>Tout ceci sans recours \u00e0 aucune <em>gem<\/em> (biblioth\u00e8que) ni <em>framework<\/em>. Il faudra un peu de d\u00e9veloppement pour apporter ce m\u00e9canisme, mais vous verrez que Ruby rend ceci trivial.<\/p>\n<p>Vous pouvez vous entra\u00eener dans une console Ruby (<code>irb<\/code>) pendant la lecture.<\/p>\n<h2 id=\"aperu-de-notre-classe-avant--aprs\">Aper\u00e7u de notre classe avant \/ apr\u00e8s<\/h2>\n<p>Dans le cadre de cet article, je simule le service \u00e0 injecter via une structure qui r\u00e9pond \u00e0 la m\u00e9thode \u00ab\u00a0info\u00a0\u00bb. C\u2019est suffisant pour comprendre le principe.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"no\">MapService<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Struct<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"ss\">:info<\/span><span class=\"p\">)<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Voici notre classe\u00a0\u00ab\u00a0Client\u00a0\u00bb\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">Client<\/span>   <span class=\"k\">def<\/span> <span class=\"nf\">api_info<\/span>     <span class=\"n\">map_api<\/span><span class=\"p\">.<\/span><span class=\"nf\">info<\/span>   <span class=\"k\">end<\/span>    <span class=\"kp\">private<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">map_api<\/span>     <span class=\"vi\">@map_api<\/span> <span class=\"o\">||=<\/span> <span class=\"no\">MapService<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"Simulate a Google Maps API\"<\/span><span class=\"p\">)<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Ici, le service est m\u00e9mo\u00efs\u00e9 dans une variable d\u2019instance (<code>@map_api<\/code>). Cette technique a l\u2019avantage de cr\u00e9er un accesseur et de faire du <em>lazy loading<\/em>.<\/p>\n<p>Et voici ce que nous souhaitons obtenir au final\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">Client<\/span>   <span class=\"kp\">extend<\/span> <span class=\"no\">Injector<\/span>   <span class=\"n\">inject_attributes<\/span><span class=\"p\">(<\/span><span class=\"no\">Services<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:map_api<\/span><span class=\"p\">)<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">api_info<\/span>     <span class=\"n\">map_api<\/span><span class=\"p\">.<\/span><span class=\"nf\">info<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Ici, le module <code>Injector<\/code> nous permet de cr\u00e9er dynamiquement la m\u00e9thode priv\u00e9e <code>map_api<\/code> pour disposer d\u2019un accesseur \u00e0 l\u2019image du premier exemple. Le module <code>Service<\/code> contient la configuration des injections. Si vous \u00eates press\u00e9, rendez-vous directement au chapitre \u00ab\u00a0<a href=\"#le-conteneur-dinjection\">Le conteneur d\u2019injection<\/a>\u00a0\u00bb. Sinon poursuivons\u00a0!<\/p>\n<h2 id=\"pourquoi-faire-de-linjection\">Pourquoi faire de l\u2019injection\u00a0?<\/h2>\n<p>On essaie autant que possible de structurer notre code pour \u00e9viter d\u2019entrem\u00ealer les briques entre elles afin de favoriser les \u00e9volutions. Pour y arriver, on d\u00e9finit des interfaces propres qui n\u2019exposent aucuns d\u00e9tails d\u2019impl\u00e9mentation. Si c\u2019est ce que vous faites d\u00e9j\u00e0, alors c\u2019est une tr\u00e8s bonne chose.<\/p>\n<p>Structurer son code ainsi, c\u2019est appliquer la \u00ab\u00a0<a href=\"https:\/\/fr.wikipedia.org\/wiki\/Loi_de_D%C3%A9m%C3%A9ter\">loi de D\u00e9m\u00e9ter<\/a>\u00a0\u00bb. Cette loi nous apprend qu\u2019une application qui grossit sans planification finie par s\u00e9rieusement partir en cacahu\u00e8te. Et que pour \u00e9viter \u00e7a, il faut limiter la connaissance que chaque composant a de l\u2019autre.<\/p>\n<p>Sauf que\u2026<\/p>\n<p>Dans le premier exemple de code, notre classe \u00ab\u00a0Client\u00a0\u00bb sait comment instancier le service. Elle a donc connaissance de son impl\u00e9mentation\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">def<\/span> <span class=\"nf\">map_api<\/span>   <span class=\"vi\">@map_api<\/span> <span class=\"o\">||=<\/span> <span class=\"no\">MapService<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"Simulate a Google Maps API\"<\/span><span class=\"p\">)<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>C\u2019est l\u00e0 qu\u2019entre en jeu l\u2019injection de d\u00e9pendances. Elle consiste \u00e0 externaliser cette connaissance \u00e0 un tiers.<\/p>\n<p>En proc\u00e9dant de cette mani\u00e8re, on gagne de la flexibilit\u00e9 pour faire fonctionner notre composant dans un environnement diff\u00e9rent (production \/ test \/ dev) ou de l\u2019utiliser dans des cas qui n\u2019\u00e9taient pas pr\u00e9vus \u00e0 l\u2019origine.<\/p>\n<h2 id=\"cest-quoi-linjection-de-dpendances\">C\u2019est quoi l\u2019injection de d\u00e9pendances\u00a0?<\/h2>\n<p>L\u2019id\u00e9e est d\u2019avoir un code \u2013 <strong>le client<\/strong> \u2013 qui va consommer un <strong>service<\/strong> sans savoir comment il est initialis\u00e9 (instanci\u00e9) ni quelle impl\u00e9mentation est utilis\u00e9e (la classe elle-m\u00eame). Ces diff\u00e9rentes questions sont adress\u00e9es via un troisi\u00e8me code nomm\u00e9 <strong>injecteur<\/strong>. La seule chose en commun entre le client et le service est l\u2019adh\u00e9sion \u00e0 une <strong>interface<\/strong> commune.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/framapic.org\/U2HMiiXpziWJ\/VgKejYHw5vAi.png\" alt=\"principe g\u00e9n\u00e9ral de l'injection de d\u00e9pendances\" width=\"500\" loading=\"lazy\" \/><\/p>\n<p>Les avantages imm\u00e9diats en Ruby\u00a0:<\/p>\n<ul>\n<li>Apporter de la souplesse via le polymorphisme.<\/li>\n<li>Faciliter l\u2019\u00e9criture des tests unitaires.<\/li>\n<li>Permettre l\u2019extension du code par une \u00e9quipe en dehors de votre p\u00e9rim\u00e8tre d\u2019action.<\/li>\n<\/ul>\n<p>Pour autant, cette technique a \u00e9t\u00e9 popularis\u00e9e dans la communaut\u00e9 Java par <a href=\"https:\/\/martinfowler.com\/articles\/injection.html\">Martin Fowler en 2004<\/a>. L\u2019article original parle de 3 fa\u00e7ons d\u2019injecter une d\u00e9pendance\u00a0:<\/p>\n<ul>\n<li>Par le constructeur\u00a0: la m\u00e9thode <code>initialize<\/code> en Ruby.<\/li>\n<li>Par des <code>setters<\/code> d\u00e9di\u00e9s\u00a0: ce sont les accesseurs en Ruby (<code>attr_writer<\/code> ou <code>attr_accessor<\/code>).<\/li>\n<li>Par une interface\u00a0: l\u2019objet dispose d\u2019un comportement li\u00e9 \u00e0 l\u2019injection. Cette technique introduit l\u2019usage du conteneur d\u2019injection.<\/li>\n<\/ul>\n<p>Pour mettre en pratique l\u2019injection de d\u00e9pendances, il convient de suivre quelques principes.<\/p>\n<h2 id=\"principes-solid\">Principes SOLID<\/h2>\n<p>L\u2019injection est une fa\u00e7on de composer des objets. Elle est encourag\u00e9e au travers des <a href=\"https:\/\/en.wikipedia.org\/wiki\/SOLID\">principes SOLID<\/a>.<\/p>\n<p>Ces principes ont \u00e9t\u00e9 introduits par <a href=\"https:\/\/fr.wikipedia.org\/wiki\/Robert_C._Martin\">Robert C. Martin<\/a> (alias Uncle Bob) dans son ouvrage \u00ab\u00a0<em>Agile Software Development, Principles, Patterns and Practices<\/em>\u00a0\u00bb.<\/p>\n<p>La description \u00e9tant trop g\u00e9n\u00e9raliste, je me suis permis une traduction dans le monde Ruby\u00a0:<\/p>\n<ul>\n<li><strong>S<\/strong>\u00a0\u2192 <em>Single Responsibility Principle<\/em>\u00a0: une classe \/ module ne devrait avoir qu\u2019un seul r\u00f4le.<\/li>\n<li><strong>O<\/strong>\u00a0\u2192 <em>Open\/Closed Principle<\/em>\u00a0: modules, classes et m\u00e9thode sont ouverts \u00e0 l\u2019extension mais ferm\u00e9s \u00e0 la modification.<\/li>\n<li><strong>L<\/strong>\u00a0\u2192 <em>Liskov Substitution Principle<\/em>\u00a0: <code>m\u00e9thode(T)<\/code> \u00e9quivaut \u00e0 <code>m\u00e9thode(S)<\/code> si <code>S<\/code> impl\u00e9mente le comportement de <code>T<\/code>.<\/li>\n<li><strong>I<\/strong>\u00a0\u2192 <em>Interface Segregation Principle<\/em>\u00a0: Une interface ne doit pas forcer le client \u00e0 g\u00e9rer des aspects qui sont en dehors de son p\u00e9rim\u00e8tre fonctionnel.<\/li>\n<li><strong>D<\/strong>\u00a0\u2192 <em>Dependency Inversion Principle<\/em>\u00a0: Les objets de haut niveau ont une d\u00e9pendance envers du comportement et non une impl\u00e9mentation sp\u00e9cifique.<\/li>\n<\/ul>\n<p>Je pourrais vous donner ce conseil\u00a0:<\/p>\n<blockquote><p>Gardez le focus sur le r\u00f4le de votre classe \/ module et respectez autant que possible les principes SOLID.<\/p><\/blockquote>\n<p>Tout ceci s\u2019accompagne de principes plus g\u00e9n\u00e9ralistes que vous connaissez d\u00e9j\u00e0, tels que\u00a0:<\/p>\n<ul>\n<li>KISS (<em>Keep it Simple, Stupid<\/em>)\u00a0: concevez des choses simples, \u00e9vitez la complexit\u00e9 inutile.<\/li>\n<li>YAGNI (<em>You ain\u2019t gonna need it<\/em>)\u00a0: concentrez-vous sur votre objectif et d\u00e9veloppez uniquement ce qui est n\u00e9cessaire.<\/li>\n<li>DRY (<em>Don\u2019t repeat yourself<\/em>)\u00a0: organisez vos algorithmes pour repr\u00e9senter de fa\u00e7on unique chaque intention ou r\u00e8gle m\u00e9tier.<\/li>\n<\/ul>\n<h2 id=\"injection-manuelle\">Injection manuelle<\/h2>\n<p>Promis, on arr\u00eate avec la th\u00e9orie. Revenons \u00e0 notre code avec une injection simple\u00a0: via le constructeur ou un accesseur.<\/p>\n<h3 id=\"injection-par-le-constructeur\">Injection par le constructeur<\/h3>\n<p>C\u2019est la technique la plus r\u00e9pandue. L\u2019injection consiste \u00e0 passer en argument un objet instanci\u00e9 \u00e0 la m\u00e9thode <code>initialize<\/code>\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">Client<\/span>   <span class=\"k\">def<\/span> <span class=\"nf\">initialize<\/span><span class=\"p\">(<\/span><span class=\"n\">map_api<\/span> <span class=\"o\">=<\/span> <span class=\"kp\">nil<\/span><span class=\"p\">)<\/span>     <span class=\"vi\">@map_api<\/span> <span class=\"o\">=<\/span> <span class=\"n\">map_api<\/span> <span class=\"o\">||<\/span> <span class=\"no\">MapService<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"Simulate a Google Maps API\"<\/span><span class=\"p\">)<\/span>   <span class=\"k\">end<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">api_info<\/span>     <span class=\"n\">map_api<\/span><span class=\"p\">.<\/span><span class=\"nf\">info<\/span>   <span class=\"k\">end<\/span>    <span class=\"kp\">private<\/span>   <span class=\"nb\">attr_reader<\/span> <span class=\"ss\">:map_api<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Ici, en l\u2019absence d\u2019injection, on utilise le service par d\u00e9faut. Il sera accessible en interne via un accesseur (<code>attr_reader<\/code> \u00e0 la fin).<\/p>\n<p>Exemple d\u2019usage\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"no\">MapService<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Struct<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"ss\">:info<\/span><span class=\"p\">)<\/span> <span class=\"c1\"># simulate our service<\/span>  <span class=\"n\">street_map<\/span> <span class=\"o\">=<\/span> <span class=\"no\">MapService<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"Simulate an Open Street Map API\"<\/span><span class=\"p\">)<\/span>  <span class=\"n\">client<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Client<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"n\">street_map<\/span><span class=\"p\">)<\/span>  <span class=\"n\">client<\/span><span class=\"p\">.<\/span><span class=\"nf\">api_info<\/span> <span class=\"c1\"># =&gt; \"Simulate an Open Street Map API\"<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<h3 id=\"sparez-vos-paramtres-de-vos-injections\">S\u00e9parez vos param\u00e8tres de vos injections<\/h3>\n<p>Les derniers param\u00e8tres sont g\u00e9n\u00e9ralement d\u00e9di\u00e9s aux injections de d\u00e9pendances et disposent d\u2019une impl\u00e9mentation par d\u00e9faut. Mais la formule que nous avons vu a ses limites\u00a0: que se passe-t-il si nous ajoutons un param\u00e8tre optionnel <code>country<\/code>\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">Client<\/span>   <span class=\"k\">def<\/span> <span class=\"nf\">initialize<\/span><span class=\"p\">(<\/span><span class=\"n\">country<\/span> <span class=\"o\">=<\/span> <span class=\"kp\">nil<\/span><span class=\"p\">,<\/span> <span class=\"n\">map_api<\/span> <span class=\"o\">=<\/span> <span class=\"kp\">nil<\/span><span class=\"p\">)<\/span>     <span class=\"vi\">@country<\/span> <span class=\"o\">=<\/span> <span class=\"n\">country<\/span> <span class=\"o\">||<\/span> <span class=\"s2\">\"France\"<\/span>     <span class=\"vi\">@map_api<\/span> <span class=\"o\">=<\/span> <span class=\"n\">map_api<\/span> <span class=\"o\">||<\/span> <span class=\"no\">MapService<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"Simulate a Google Maps API\"<\/span><span class=\"p\">)<\/span>   <span class=\"k\">end<\/span>   <span class=\"c1\">#...<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Si je souhaite utiliser le param\u00e8tre <code>country<\/code> par d\u00e9faut\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"n\">client<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Client<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"kp\">nil<\/span><span class=\"p\">,<\/span> <span class=\"n\">street_map<\/span><span class=\"p\">)<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Je suis oblig\u00e9 d\u2019avoir un argument <code>nil<\/code>.<\/p>\n<p>Pas g\u00e9nial<\/p>\n<p>En utilisant en argument un <em>Hash<\/em> pour les d\u00e9pendances, vous gagnez en lisibilit\u00e9 et en flexibilit\u00e9 comme l\u2019a d\u00e9montr\u00e9 un <a href=\"https:\/\/www.sandimetz.com\/blog\/2009\/03\/21\/solid-design-principles\">article de Sandy Metz<\/a>. Cependant, je trouve qu\u2019on peut exploiter plus finement le principe via le <em>double-splat operator<\/em>\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">Client<\/span>   <span class=\"k\">def<\/span> <span class=\"nf\">initialize<\/span><span class=\"p\">(<\/span><span class=\"n\">country<\/span> <span class=\"o\">=<\/span> <span class=\"kp\">nil<\/span><span class=\"p\">,<\/span> <span class=\"o\">**<\/span><span class=\"n\">services<\/span><span class=\"p\">)<\/span>     <span class=\"vi\">@country<\/span> <span class=\"o\">=<\/span> <span class=\"n\">country<\/span> <span class=\"o\">||<\/span> <span class=\"s2\">\"France\"<\/span>     <span class=\"vi\">@map_api<\/span> <span class=\"o\">=<\/span> <span class=\"n\">services<\/span><span class=\"p\">[<\/span><span class=\"ss\">:map_api<\/span><span class=\"p\">]<\/span> <span class=\"o\">||<\/span> <span class=\"no\">MapService<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"Simulate a Google Maps API\"<\/span><span class=\"p\">)<\/span>   <span class=\"k\">end<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">api_info<\/span>     <span class=\"n\">map_api<\/span><span class=\"p\">.<\/span><span class=\"nf\">info<\/span>   <span class=\"k\">end<\/span>    <span class=\"kp\">private<\/span>   <span class=\"nb\">attr_reader<\/span> <span class=\"ss\">:map_api<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Pour rappel de la syntaxe, toujours utilis\u00e9e en fin de param\u00e8tres\u00a0:<\/p>\n<ul>\n<li><em>splat operator<\/em>\u00a0(<code>*<\/code>)\u00a0: Le param\u00e8tre re\u00e7oit tous les arguments restants sous forme de tableau.<\/li>\n<li><em>double-splat operator<\/em>\u00a0(<code>**<\/code>)\u00a0: Le param\u00e8tre re\u00e7oit tous les mots-cl\u00e9s restants (ou <em>keyword arguments<\/em> en Ruby) sous forme de <em>Hash<\/em>.<\/li>\n<\/ul>\n<p>C\u2019est utilisable dans l\u2019autre sens, lors de l\u2019appel d\u2019une fonction \/ m\u00e9thode. On peut \u00e9tendre un tableau en liste d\u2019arguments (<code>*<\/code>) ou convertir un <em>Hash<\/em> en liste de mots-cl\u00e9s (<code>**<\/code>). Depuis Ruby 2.7, cette derni\u00e8re devient plus stricte.<\/p>\n<p>Revenons \u00e0 notre exemple. Voici comment on instancie la classe \u00ab\u00a0Client\u00a0\u00bb avec des arguments par mot-cl\u00e9\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"n\">client<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Client<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"ss\">map_api: <\/span><span class=\"n\">street_map<\/span><span class=\"p\">)<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>C\u2019est d\u00e9j\u00e0 mieux\u00a0!<\/p>\n<p>N\u2019h\u00e9sitez pas \u00e0 r\u00e9server les arguments par mot-cl\u00e9 \u00e0 vos injections d\u00e8s que vous avez plus d\u2019une injection ou lorsque c\u2019est coupl\u00e9 \u00e0 d\u2019autres param\u00e8tres.<\/p>\n<h3 id=\"injection-par-accesseur\">Injection par accesseur<\/h3>\n<p>L\u2019injection par accesseur a un usage plus limit\u00e9 (dans une boucle de param\u00e9trage par exemple), mais \u00e7a reste assez simple en Ruby\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">Client<\/span>   <span class=\"c1\"># accessor for test purpose<\/span>   <span class=\"nb\">attr_writer<\/span> <span class=\"ss\">:map_api<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">api_info<\/span>     <span class=\"n\">map_api<\/span><span class=\"p\">.<\/span><span class=\"nf\">info<\/span>   <span class=\"k\">end<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">map_api<\/span>     <span class=\"vi\">@map_api<\/span> <span class=\"o\">||=<\/span> <span class=\"no\">MapService<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"Simulate a Google Maps API\"<\/span><span class=\"p\">)<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Ici, nous avons simplement cr\u00e9\u00e9 un accesseur en \u00e9criture avec <code>attr_writer<\/code>.<\/p>\n<p>Nous pouvons l\u2019utiliser ainsi\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"no\">MapService<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Struct<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"ss\">:info<\/span><span class=\"p\">)<\/span> <span class=\"c1\"># simulate our service<\/span>  <span class=\"n\">client<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Client<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span> <span class=\"n\">client<\/span><span class=\"p\">.<\/span><span class=\"nf\">map_api<\/span> <span class=\"o\">=<\/span> <span class=\"no\">MapService<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"Simulate an Open Street Map API\"<\/span><span class=\"p\">)<\/span>  <span class=\"n\">client<\/span><span class=\"p\">.<\/span><span class=\"nf\">api_info<\/span> <span class=\"c1\"># =&gt; \"Simulate an Open Street Map API\"<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>\u00c9tant donn\u00e9 son usage plus restreint, il est souhaitable de documenter ce type d\u2019injection afin de lever toute ambigu\u00eft\u00e9. Notez que cette approche peut rapidement devenir pr\u00e9judiciable pour vos utilisateurs si cette classe venait \u00e0 \u00eatre expos\u00e9e.<\/p>\n<h2 id=\"le-conteneur-dinjection\">Le conteneur d\u2019injection<\/h2>\n<p>C\u2019est une fa\u00e7on parmi d\u2019autres de structurer l\u2019injection. Le concept central s\u2019appuie sur un annuaire (ou <em>registry<\/em>) qui r\u00e9pertorie des classes \u00e0 instancier ou des instances disponibles (dans le futur). L\u2019acc\u00e8s \u00e0 son contenu se fait via une r\u00e9solution de d\u00e9pendance\u00a0: \u00ab\u00a0nom\u00a0\u00bb \u2192 \u00ab\u00a0objet instanci\u00e9\u00a0\u00bb. Il est aliment\u00e9 au pr\u00e9alable lors de la phase d\u2019initialisation de l\u2019application\u00a0via un fichier de configuration (un script Ruby suffit).<\/p>\n<p>Le \u00ab\u00a0<em>registry<\/em>\u00a0\u00bb d\u00e9crit le m\u00e9canisme. Le \u00ab\u00a0conteneur\u00a0\u00bb mat\u00e9rialise les d\u00e9pendances param\u00e9tr\u00e9es dans l\u2019application.<\/p>\n<p>Pour g\u00e9n\u00e9raliser l\u2019injection, je vous propose de passer par un \u00ab\u00a0injecteur\u00a0\u00bb qui va cr\u00e9er dans votre classe les appels n\u00e9cessaires \u00e0 la r\u00e9solution de d\u00e9pendances vis-\u00e0-vis d\u2019un conteneur.<\/p>\n<p>Il sera toujours possible de surcharger l\u2019injection via le constructeur ou des accesseurs.<\/p>\n<p>Notez que votre code aura, d\u2019une mani\u00e8re ou d\u2019une autre, une d\u00e9pendance envers cette solution. Voici dans les grandes lignes ce que nous allons d\u00e9velopper\u00a0:<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/framapic.org\/1fLm6g5hoPlZ\/vdMjHkphOlYK.png\" alt=\"sch\u00e9ma d'un conteneur d'injection basique\" width=\"500\" loading=\"lazy\" \/><\/p>\n<p>Encore une fois\u00a0: c\u2019est trivial en Ruby, alors restez concentr\u00e9 sur le design.<\/p>\n<h3 id=\"le-registry\">Le <em>registry<\/em><\/h3>\n<p>C\u2019est un module qui va utiliser\u00a0:<\/p>\n<ul>\n<li>Un <em>Hash<\/em> (<code>@list<\/code>) pour g\u00e9rer l\u2019annuaire, automatiquement cr\u00e9\u00e9 au niveau du conteneur.<\/li>\n<li>Un objet \u00ab\u00a0proc\u00a0\u00bb (<em>block<\/em>) ou tout objet r\u00e9pondant \u00e0 la m\u00e9thode <code>call<\/code>. Il d\u00e9crit la classe \u00e0 instancier avec ses arguments, ou une instance.<\/li>\n<\/ul>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">module<\/span> <span class=\"nn\">CallableRegistry<\/span>   <span class=\"k\">def<\/span> <span class=\"nf\">register<\/span><span class=\"p\">(<\/span><span class=\"n\">key<\/span><span class=\"p\">,<\/span> <span class=\"n\">callable<\/span> <span class=\"o\">=<\/span> <span class=\"kp\">nil<\/span><span class=\"p\">,<\/span> <span class=\"o\">&amp;<\/span><span class=\"n\">block<\/span><span class=\"p\">)<\/span>     <span class=\"vi\">@list<\/span><span class=\"p\">[<\/span><span class=\"n\">key<\/span><span class=\"p\">]<\/span> <span class=\"o\">||=<\/span> <span class=\"n\">callable<\/span><span class=\"p\">.<\/span><span class=\"nf\">respond_to?<\/span><span class=\"p\">(<\/span><span class=\"ss\">:call<\/span><span class=\"p\">)<\/span> <span class=\"p\">?<\/span> <span class=\"n\">callable<\/span> <span class=\"p\">:<\/span> <span class=\"n\">block<\/span>   <span class=\"k\">end<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">resolve<\/span><span class=\"p\">(<\/span><span class=\"n\">key<\/span><span class=\"p\">)<\/span>     <span class=\"vi\">@list<\/span><span class=\"p\">.<\/span><span class=\"nf\">fetch<\/span><span class=\"p\">(<\/span><span class=\"n\">key<\/span><span class=\"p\">).<\/span><span class=\"nf\">call<\/span>   <span class=\"k\">end<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">configure<\/span><span class=\"p\">(<\/span><span class=\"o\">&amp;<\/span><span class=\"n\">block<\/span><span class=\"p\">)<\/span>     <span class=\"nb\">instance_eval<\/span><span class=\"p\">(<\/span><span class=\"o\">&amp;<\/span><span class=\"n\">block<\/span><span class=\"p\">)<\/span>   <span class=\"k\">end<\/span>    <span class=\"k\">def<\/span> <span class=\"nc\">self<\/span><span class=\"o\">.<\/span><span class=\"nf\">extended<\/span><span class=\"p\">(<\/span><span class=\"n\">base<\/span><span class=\"p\">)<\/span>     <span class=\"n\">base<\/span><span class=\"p\">.<\/span><span class=\"nf\">instance_eval<\/span> <span class=\"p\">{<\/span> <span class=\"vi\">@list<\/span> <span class=\"o\">=<\/span> <span class=\"p\">{}<\/span> <span class=\"p\">}<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Le <em>registry<\/em> fournit deux m\u00e9thodes utiles pour les injections\u00a0:<\/p>\n<ul>\n<li><code>register<\/code>\u00a0: d\u00e9clarer une d\u00e9pendance et l\u2019associer \u00e0 un nom (<em>key<\/em>). Par s\u00e9curit\u00e9, on emp\u00eache d\u2019\u00e9craser une cl\u00e9 existante.<\/li>\n<li><code>resolve<\/code>\u00a0: r\u00e9soudre une d\u00e9pendance, c\u2019est-\u00e0-dire\u00a0: jouer le contenu du \u00ab\u00a0proc\u00a0\u00bb (ou de l\u2019objet qui r\u00e9pond \u00e0 <code>call<\/code>).<\/li>\n<\/ul>\n<h3 id=\"le-conteneur\">Le conteneur<\/h3>\n<p>Maintenant, mat\u00e9rialisons notre conteneur pour la classe \u00ab\u00a0Client\u00a0\u00bb\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">module<\/span> <span class=\"nn\">Services<\/span>   <span class=\"kp\">extend<\/span> <span class=\"no\">CallableRegistry<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Votre conteneur d\u2019injection est pr\u00eat. Ajoutons la d\u00e9pendance\u00a0au service <code>map_api<\/code>\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"no\">Services<\/span><span class=\"p\">.<\/span><span class=\"nf\">configure<\/span> <span class=\"k\">do<\/span>   <span class=\"n\">register<\/span><span class=\"p\">(<\/span><span class=\"ss\">:map_api<\/span><span class=\"p\">)<\/span> <span class=\"p\">{<\/span> <span class=\"no\">MapService<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"Simulate a Nebular Nasa API\"<\/span><span class=\"p\">)<\/span> <span class=\"p\">}<\/span> <span class=\"k\">end<\/span>  <span class=\"no\">MapService<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Struct<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"ss\">:info<\/span><span class=\"p\">)<\/span> <span class=\"c1\"># simulate our service<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Le code ci-dessus (la partie \u00ab\u00a0<em>configure<\/em>\u00a0\u00bb) trouvera sa place dans un fichier d\u2019initialisation\u00a0: la brique \u00ab\u00a0Config\u00a0\u00bb que nous avions dans notre sch\u00e9ma.<\/p>\n<blockquote><p>Si vous exp\u00e9rimentez en console Ruby, n\u2019oubliez pas qu\u2019on d\u00e9clare une seule fois une d\u00e9pendance par conteneur.<\/p><\/blockquote>\n<h3 id=\"noter\">\u00c0 noter<\/h3>\n<p>Le conteneur fonctionne en cascade. Pour appeler d\u2019autres d\u00e9pendances lors de la configuration, utilisez la m\u00e9thode <code>resolve<\/code>.<\/p>\n<p>Par exemple, si on souhaite instancier un <em>Hash<\/em> qui initialise toutes ses cl\u00e9s via la m\u00e9thode <code>info<\/code> depuis la d\u00e9pendance <code>map_api<\/code>\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"no\">Services<\/span><span class=\"p\">.<\/span><span class=\"nf\">configure<\/span> <span class=\"k\">do<\/span>   <span class=\"n\">register<\/span><span class=\"p\">(<\/span><span class=\"ss\">:bee<\/span><span class=\"p\">)<\/span> <span class=\"p\">{<\/span> <span class=\"no\">Hash<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"n\">resolve<\/span><span class=\"p\">(<\/span><span class=\"ss\">:map_api<\/span><span class=\"p\">).<\/span><span class=\"nf\">info<\/span><span class=\"p\">)<\/span> <span class=\"p\">}<\/span> <span class=\"k\">end<\/span>  <span class=\"n\">bee_hash<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Services<\/span><span class=\"p\">.<\/span><span class=\"nf\">resolve<\/span><span class=\"p\">(<\/span><span class=\"ss\">:bee<\/span><span class=\"p\">)<\/span> <span class=\"n\">bee_hash<\/span><span class=\"p\">[<\/span><span class=\"ss\">:hello<\/span><span class=\"p\">]<\/span> <span class=\"c1\"># =&gt; \"Simulate a Nebular Nasa API\"<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<h3 id=\"linjecteur\">L\u2019injecteur<\/h3>\n<p>Il ne vous reste plus que l\u2019injecteur. Pour ce dernier, nous allons faire appel \u00e0 un peu de m\u00e9taprogrammation. Pas de panique, vous venez juste d\u2019en faire.<\/p>\n<blockquote><p>La m\u00e9taprogrammation en Ruby est un moyen de modifier la structure et les relations des objets pendant l\u2019ex\u00e9cution du programme.<\/p><\/blockquote>\n<p>Le module d\u2019injection a en charge de cr\u00e9er dynamiquement dans la classe un accesseur vers une variable d\u2019instance du m\u00eame nom que celui utilis\u00e9 dans le conteneur. Ici, c\u2019est <code>map_api<\/code>.<\/p>\n<p>Il s\u2019agit donc d\u2019automatiser la cr\u00e9ation de ceci\u00a0dans votre classe\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"kp\">private<\/span>  <span class=\"k\">def<\/span> <span class=\"nf\">map_api<\/span>   <span class=\"vi\">@map_api<\/span> <span class=\"o\">||=<\/span> <span class=\"no\">Service<\/span><span class=\"p\">.<\/span><span class=\"nf\">resolve<\/span><span class=\"p\">(<\/span><span class=\"ss\">:map_api<\/span><span class=\"p\">)<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Voici l\u2019injecteur\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">module<\/span> <span class=\"nn\">Injector<\/span>   <span class=\"k\">def<\/span> <span class=\"nc\">self<\/span><span class=\"o\">.<\/span><span class=\"nf\">_generate_body<\/span><span class=\"p\">(<\/span><span class=\"n\">registry<\/span><span class=\"p\">,<\/span> <span class=\"n\">key<\/span><span class=\"p\">,<\/span> <span class=\"n\">var<\/span> <span class=\"o\">=<\/span> <span class=\"ss\">:\"@<\/span><span class=\"si\">#{<\/span><span class=\"n\">key<\/span><span class=\"si\">}<\/span><span class=\"ss\">\"<\/span><span class=\"p\">)<\/span>     <span class=\"nb\">proc<\/span> <span class=\"k\">do<\/span>       <span class=\"nb\">instance_variable_get<\/span><span class=\"p\">(<\/span><span class=\"n\">var<\/span><span class=\"p\">)<\/span> <span class=\"o\">||<\/span>       <span class=\"nb\">instance_variable_set<\/span><span class=\"p\">(<\/span><span class=\"n\">var<\/span><span class=\"p\">,<\/span> <span class=\"n\">registry<\/span><span class=\"p\">.<\/span><span class=\"nf\">resolve<\/span><span class=\"p\">(<\/span><span class=\"n\">key<\/span><span class=\"p\">))<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span>    <span class=\"kp\">private<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">inject_attributes<\/span><span class=\"p\">(<\/span><span class=\"n\">registry<\/span><span class=\"p\">,<\/span> <span class=\"o\">*<\/span><span class=\"n\">keys<\/span><span class=\"p\">)<\/span>     <span class=\"n\">keys<\/span><span class=\"p\">.<\/span><span class=\"nf\">each<\/span> <span class=\"k\">do<\/span> <span class=\"o\">|<\/span><span class=\"n\">key<\/span><span class=\"o\">|<\/span>       <span class=\"n\">body<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Injector<\/span><span class=\"p\">.<\/span><span class=\"nf\">_generate_body<\/span><span class=\"p\">(<\/span><span class=\"n\">registry<\/span><span class=\"p\">,<\/span> <span class=\"n\">key<\/span><span class=\"p\">)<\/span>       <span class=\"n\">define_method<\/span><span class=\"p\">(<\/span><span class=\"n\">key<\/span><span class=\"p\">,<\/span> <span class=\"o\">&amp;<\/span><span class=\"n\">body<\/span><span class=\"p\">)<\/span>       <span class=\"kp\">private<\/span><span class=\"p\">(<\/span><span class=\"n\">key<\/span><span class=\"p\">)<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Ce qui est int\u00e9ressant, c\u2019est la m\u00e9thode priv\u00e9e <code>inject_attributes<\/code>. Elle prend en argument le conteneur et la \/ les cl\u00e9s d\u2019injection \u00e0 traiter. Elle va construire le corps de la m\u00e9thode (<em>body<\/em>) puis d\u00e9finir la m\u00e9thode en utilisant ce corps et la rend ensuite priv\u00e9e.<\/p>\n<h3 id=\"classe-client-modifie\">Classe \u00ab\u00a0Client\u00a0\u00bb modifi\u00e9e<\/h3>\n<p>Votre classe \u00ab\u00a0Client\u00a0\u00bb doit faire r\u00e9f\u00e9rence \u00e0 l\u2019injecteur pour en b\u00e9n\u00e9ficier. Elle indique le conteneur et le nom de la \/ des d\u00e9pendances \u00e0 injecter\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">Client<\/span>   <span class=\"kp\">extend<\/span> <span class=\"no\">Injector<\/span>   <span class=\"n\">inject_attributes<\/span><span class=\"p\">(<\/span><span class=\"no\">Services<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:map_api<\/span><span class=\"p\">)<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">api_info<\/span>     <span class=\"n\">map_api<\/span><span class=\"p\">.<\/span><span class=\"nf\">info<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Si vous d\u00e9rivez cette classe, vous b\u00e9n\u00e9ficiez toujours des injections. Vous pouvez aussi en ajouter de nouvelles via un appel \u00e0 <code>inject_attributes<\/code>.<\/p>\n<p>Exemple d\u2019utilisation\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"no\">Client<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">.<\/span><span class=\"nf\">api_info<\/span> <span class=\"o\">=&gt;<\/span> <span class=\"s2\">\"Simulate a Nebular Nasa API\"<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Quel est l\u2019impact d\u2019utiliser une injection pour la classe \u00ab\u00a0Client\u00a0\u00bb\u00a0?<\/p>\n<p>L\u2019appel \u00e0 l\u2019accesseur <code>map_api<\/code> r\u00e9sout la d\u00e9pendance pour renseigner la variable d\u2019instance <code>@map_api<\/code> et la renvoie \u00e0 l\u2019appelant. Si <code>@map_api<\/code> est d\u00e9j\u00e0 renseign\u00e9e, elle sera retourn\u00e9e directement sans faire la r\u00e9solution.<\/p>\n<p>On peut coupler le conteneur avec toutes les techniques d\u2019injection.<\/p>\n<p>Ci-dessous, coupl\u00e9 avec l\u2019injection par constructeur\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">Client<\/span>   <span class=\"kp\">extend<\/span> <span class=\"no\">Injector<\/span>   <span class=\"n\">inject_attributes<\/span><span class=\"p\">(<\/span><span class=\"no\">Services<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:map_api<\/span><span class=\"p\">)<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">initialize<\/span><span class=\"p\">(<\/span><span class=\"o\">**<\/span><span class=\"n\">services<\/span><span class=\"p\">)<\/span>     <span class=\"vi\">@map_api<\/span> <span class=\"o\">=<\/span> <span class=\"n\">services<\/span><span class=\"p\">[<\/span><span class=\"ss\">:map_api<\/span><span class=\"p\">]<\/span>   <span class=\"k\">end<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">api_info<\/span>     <span class=\"n\">map_api<\/span><span class=\"p\">.<\/span><span class=\"nf\">info<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Ci-apr\u00e8s, coupl\u00e9 avec de l\u2019injection par accesseur\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">Client<\/span>   <span class=\"kp\">extend<\/span> <span class=\"no\">Injector<\/span>   <span class=\"n\">inject_attributes<\/span><span class=\"p\">(<\/span><span class=\"no\">Services<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:map_api<\/span><span class=\"p\">)<\/span>    <span class=\"nb\">attr_writer<\/span> <span class=\"ss\">:map_api<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">api_info<\/span>     <span class=\"n\">map_api<\/span><span class=\"p\">.<\/span><span class=\"nf\">info<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<h2 id=\"injection--inversion-de-contrle\">Injection \u2192 Inversion de contr\u00f4le<\/h2>\n<p>Quelque-soit la technique, l\u2019injection de d\u00e9pendances met en pratique l\u2019inversion de contr\u00f4le que vous verrez souvent abr\u00e9g\u00e9 en \u00ab\u00a0<em>IoC<\/em>\u00a0\u00bb. Qu\u2019est-ce donc\u00a0? Le choix des relations se fait toujours de l\u2019objet de haut niveau vers un objet de plus bas niveau. L\u2019inversion de contr\u00f4le renverse ce sch\u00e9ma\u00a0: l\u2019objet de haut niveau re\u00e7oit un objet de plus bas niveau sans avoir le choix. Pratiquer l\u2019injection implique toujours de faire de l\u2019inversion de contr\u00f4le.<\/p>\n<p>Si vous faites quelques recherches sur internet, vous verrez passer des termes comme \u00ab\u00a0<em>IoC container<\/em>\u00a0\u00bb, synonyme de \u00ab\u00a0<em>DI container<\/em>\u00a0\u00bb ou plus g\u00e9n\u00e9ralement de \u00ab conteneur d\u2019injection\u00a0\u00bb. Ces termes d\u00e9signent des \u00ab\u00a0outils\u00a0\u00bb pour standardiser l\u2019injection dans votre projet via un conteneur.<\/p>\n<h2 id=\"choisissez-votre-solution\">Choisissez votre solution<\/h2>\n<p>On peut aimer l\u2019approche par conteneur d\u2019injection ou pas. Il n\u2019y a pas de \u00ab\u00a0mauvais choix\u00a0\u00bb, juste des choix mal avis\u00e9s. Prenez le temps de consid\u00e9rer vos options.<\/p>\n<p>Si vous souhaitez aller plus loin dans l\u2019usage des conteneurs d\u2019injection, regardez du c\u00f4t\u00e9 de <em>dry-rb<\/em> qui propose <a href=\"https:\/\/dry-rb.org\/gems\/dry-container\/0.8\/\">dry-container<\/a> et <a href=\"https:\/\/dry-rb.org\/gems\/dry-auto_inject\/0.6\/\">dry-auto_inject<\/a>. Cette solution est robuste et adresse une vari\u00e9t\u00e9 de cas plus larges. Elle est \u00e9galement plus complexe en interne mais son usage rend le d\u00e9veloppeur efficace.<\/p>\n<p>Si vous souhaitez ma\u00eetriser vous-m\u00eame le proc\u00e9d\u00e9 (et c\u2019est courant en Ruby) sans faire de l\u2019injection comme nous l\u2019avons vu plus haut, passez par votre propre \u00ab\u00a0<em>registry<\/em>\u00a0\u00bb, explorez l\u2019assemblage d\u2019objets via une \u00ab\u00a0<em><a href=\"https:\/\/en.wikipedia.org\/wiki\/Factory_method_pattern\">factory<\/a><\/em>\u00a0\u00bb (ou usine) et structurez l\u2019API interne de votre composant via des objets de haut niveau. Il est aussi possible de faire de l\u2019auto-enregistrement de d\u00e9pendances lors de la cr\u00e9ation de votre gemme.<\/p>\n<p>N\u2019h\u00e9sitez pas \u00e0 exp\u00e9rimenter pour trouver ce qui correspond \u00e0 votre projet. Et une fois votre choix fait, restez constant.<\/p>\n<h2 id=\"rsum\">R\u00e9sum\u00e9<\/h2>\n<p>Nous avons vu comment cr\u00e9er notre propre conteneur d\u2019injection. Cette base vous permet d\u2019adapter l\u2019approche pour votre projet. Nous avons \u00e9galement vu qu\u2019il existe des biblioth\u00e8ques pour standardiser l\u2019injection en Ruby.<\/p>\n<p>Mais au-del\u00e0 de \u00ab\u00a0comment faire\u00a0\u00bb, je souhaite produire chez vous un d\u00e9clic. C\u2019est un peu pr\u00e9tentieux, je l\u2019avoue. Il y a un peu plus d\u2019un an, je regardais un reportage sur Bruce Lee. Rien \u00e0 voir me direz-vous. J\u2019apprenais que Bruce Lee avait une certaine philosophie de vie et nous a donn\u00e9 bon nombre de citations int\u00e9ressantes, dont une\u00a0:<\/p>\n<blockquote><p>L\u2019eau qu\u2019on verse dans une tasse devient la tasse [\u2026] Sois comme l\u2019eau mon ami. \u2013 Bruce Lee<\/p><\/blockquote>\n<p><iframe loading=\"lazy\" src=\"https:\/\/www.youtube.com\/embed\/_RivytNrI4o\" width=\"561\" height=\"421\" frameborder=\"0\" allowfullscreen=\"allowfullscreen\"><\/iframe><\/p>\n<p>Derri\u00e8re ces mots \u2013 presque d\u2019enfant \u2013 se cache une le\u00e7on de vie\u00a0: celui de la r\u00e9silience face \u00e0 ce que nous ne pouvons pas ma\u00eetriser dans notre vie\u00a0: la difficult\u00e9, les imp\u00e9ratifs, les changements. Nous devons nous adapter.<\/p>\n<p>Et j\u2019ai eu le d\u00e9clic \u00e0 ce moment. Ceci explique la photo d\u2019introduction avec la tasse Pikachu. La tasse, c\u2019est l\u2019environnement de votre application. Vous ne pourrez pas le changer. L\u2019application est le jus de fruit qui s\u2019\u00e9coule et s\u2019adapte \u00e0 la tasse. Et pour y arriver, pour lui donner cette fluidit\u00e9, l\u2019injection de d\u00e9pendances est essentielle.<\/p>\n<p>J\u2019ai aim\u00e9 cette analogie et je trouve que Ruby partage avec Bruce Lee ce c\u00f4t\u00e9 simple d\u2019acc\u00e8s et bon enfant qui cache \u00e0 ceux qui en ont une lecture superficielle toute la puissance.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Pratiquez l&rsquo;injection de d\u00e9pendances gr\u00e2ce aux capacit\u00e9s dynamiques de Ruby.<\/p>\n","protected":false},"author":10,"featured_media":12541,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"content-type":"","inline_featured_image":false,"fifu_image_url":"","fifu_image_alt":"","footnotes":""},"categories":[34],"tags":[],"class_list":["post-7838","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-articles-techniques"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.9 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Injection de d\u00e9pendances\u00a0: the Ruby way - Ouidou<\/title>\n<meta name=\"description\" content=\"D\u00e9couvrez l&#039;injection de d\u00e9pendances en Ruby avec nos experts pour \u00e9crire un code plus modulaire et maintenable.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Injection de d\u00e9pendances\u00a0: the Ruby way - Ouidou\" \/>\n<meta property=\"og:description\" content=\"D\u00e9couvrez l&#039;injection de d\u00e9pendances en Ruby avec nos experts pour \u00e9crire un code plus modulaire et maintenable.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way\" \/>\n<meta property=\"og:site_name\" content=\"Ouidou\" \/>\n<meta property=\"article:published_time\" content=\"2020-05-13T22:00:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-12-01T16:00:21+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2020\/05\/Injection-de-de\u0301pendances-the-Ruby-way.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1105\" \/>\n\t<meta property=\"og:image:height\" content=\"564\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Sara Lourties\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u00c9crit par\" \/>\n\t<meta name=\"twitter:data1\" content=\"Sara Lourties\" \/>\n\t<meta name=\"twitter:label2\" content=\"Dur\u00e9e de lecture estim\u00e9e\" \/>\n\t<meta name=\"twitter:data2\" content=\"13 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/injection-de-dependances-the-ruby-way#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/injection-de-dependances-the-ruby-way\"},\"author\":{\"name\":\"Sara Lourties\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/person\\\/e1d66085fb7c22ede319ce56adc373a4\"},\"headline\":\"Injection de d\u00e9pendances\u00a0: the Ruby way\",\"datePublished\":\"2020-05-13T22:00:00+00:00\",\"dateModified\":\"2025-12-01T16:00:21+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/injection-de-dependances-the-ruby-way\"},\"wordCount\":2806,\"publisher\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/injection-de-dependances-the-ruby-way#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2020\\\/05\\\/Injection-de-de\u0301pendances-the-Ruby-way.png\",\"articleSection\":[\"Articles Techniques\"],\"inLanguage\":\"fr-FR\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/injection-de-dependances-the-ruby-way\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/injection-de-dependances-the-ruby-way\",\"name\":\"Injection de d\u00e9pendances\u00a0: the Ruby way - Ouidou\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/injection-de-dependances-the-ruby-way#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/injection-de-dependances-the-ruby-way#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2020\\\/05\\\/Injection-de-de\u0301pendances-the-Ruby-way.png\",\"datePublished\":\"2020-05-13T22:00:00+00:00\",\"dateModified\":\"2025-12-01T16:00:21+00:00\",\"description\":\"D\u00e9couvrez l'injection de d\u00e9pendances en Ruby avec nos experts pour \u00e9crire un code plus modulaire et maintenable.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/injection-de-dependances-the-ruby-way#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/injection-de-dependances-the-ruby-way\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/injection-de-dependances-the-ruby-way#primaryimage\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2020\\\/05\\\/Injection-de-de\u0301pendances-the-Ruby-way.png\",\"contentUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2020\\\/05\\\/Injection-de-de\u0301pendances-the-Ruby-way.png\",\"width\":1105,\"height\":564,\"caption\":\"Injection de de\u0301pendances the Ruby way - visuel article technique\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/injection-de-dependances-the-ruby-way#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Accueil\",\"item\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Injection de d\u00e9pendances\u00a0: the Ruby way\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\",\"name\":\"Blog Ouidou\",\"description\":\"Conseil et expertise en technologies\",\"publisher\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"fr-FR\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\",\"name\":\"Ouidou\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/image_2022-04-13_150237378.png\",\"contentUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/image_2022-04-13_150237378.png\",\"width\":180,\"height\":180,\"caption\":\"Ouidou\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/person\\\/e1d66085fb7c22ede319ce56adc373a4\",\"name\":\"Sara Lourties\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"caption\":\"Sara Lourties\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Injection de d\u00e9pendances\u00a0: the Ruby way - Ouidou","description":"D\u00e9couvrez l'injection de d\u00e9pendances en Ruby avec nos experts pour \u00e9crire un code plus modulaire et maintenable.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way","og_locale":"fr_FR","og_type":"article","og_title":"Injection de d\u00e9pendances\u00a0: the Ruby way - Ouidou","og_description":"D\u00e9couvrez l'injection de d\u00e9pendances en Ruby avec nos experts pour \u00e9crire un code plus modulaire et maintenable.","og_url":"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way","og_site_name":"Ouidou","article_published_time":"2020-05-13T22:00:00+00:00","article_modified_time":"2025-12-01T16:00:21+00:00","og_image":[{"width":1105,"height":564,"url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2020\/05\/Injection-de-de\u0301pendances-the-Ruby-way.png","type":"image\/png"}],"author":"Sara Lourties","twitter_card":"summary_large_image","twitter_misc":{"\u00c9crit par":"Sara Lourties","Dur\u00e9e de lecture estim\u00e9e":"13 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way#article","isPartOf":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way"},"author":{"name":"Sara Lourties","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/person\/e1d66085fb7c22ede319ce56adc373a4"},"headline":"Injection de d\u00e9pendances\u00a0: the Ruby way","datePublished":"2020-05-13T22:00:00+00:00","dateModified":"2025-12-01T16:00:21+00:00","mainEntityOfPage":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way"},"wordCount":2806,"publisher":{"@id":"https:\/\/ouidou.fr\/blog\/#organization"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way#primaryimage"},"thumbnailUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2020\/05\/Injection-de-de\u0301pendances-the-Ruby-way.png","articleSection":["Articles Techniques"],"inLanguage":"fr-FR"},{"@type":"WebPage","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way","url":"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way","name":"Injection de d\u00e9pendances\u00a0: the Ruby way - Ouidou","isPartOf":{"@id":"https:\/\/ouidou.fr\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way#primaryimage"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way#primaryimage"},"thumbnailUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2020\/05\/Injection-de-de\u0301pendances-the-Ruby-way.png","datePublished":"2020-05-13T22:00:00+00:00","dateModified":"2025-12-01T16:00:21+00:00","description":"D\u00e9couvrez l'injection de d\u00e9pendances en Ruby avec nos experts pour \u00e9crire un code plus modulaire et maintenable.","breadcrumb":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way#primaryimage","url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2020\/05\/Injection-de-de\u0301pendances-the-Ruby-way.png","contentUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2020\/05\/Injection-de-de\u0301pendances-the-Ruby-way.png","width":1105,"height":564,"caption":"Injection de de\u0301pendances the Ruby way - visuel article technique"},{"@type":"BreadcrumbList","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/injection-de-dependances-the-ruby-way#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Accueil","item":"https:\/\/ouidou.fr\/blog\/"},{"@type":"ListItem","position":2,"name":"Injection de d\u00e9pendances\u00a0: the Ruby way"}]},{"@type":"WebSite","@id":"https:\/\/ouidou.fr\/blog\/#website","url":"https:\/\/ouidou.fr\/blog\/","name":"Blog Ouidou","description":"Conseil et expertise en technologies","publisher":{"@id":"https:\/\/ouidou.fr\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/ouidou.fr\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"fr-FR"},{"@type":"Organization","@id":"https:\/\/ouidou.fr\/blog\/#organization","name":"Ouidou","url":"https:\/\/ouidou.fr\/blog\/","logo":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/image_2022-04-13_150237378.png","contentUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/image_2022-04-13_150237378.png","width":180,"height":180,"caption":"Ouidou"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/person\/e1d66085fb7c22ede319ce56adc373a4","name":"Sara Lourties","image":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","caption":"Sara Lourties"}}]}},"_links":{"self":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7838","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/users\/10"}],"replies":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/comments?post=7838"}],"version-history":[{"count":3,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7838\/revisions"}],"predecessor-version":[{"id":17979,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7838\/revisions\/17979"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/media\/12541"}],"wp:attachment":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/media?parent=7838"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/categories?post=7838"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/tags?post=7838"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}