Inyección de dependencia para principiantes

La inyección de dependencia es otro tema común entre los programadores orientados a objetos. En este tutorial, veremos la inyección de dependencias y por qué podría tener sentido hacer uso de ella. Ya hemos echado un vistazo a las clases básicas, los objetos, los captadores y los definidores, así como algunos conceptos básicos relacionados con la encapsulación y la herencia. Abordemos ahora una introducción suave a la inyección de dependencia y los mensajes de objetos.

No hay "yo" en el equipo

Pensemos en construir un equipo de fútbol que se enfrente al mundo en un evento autorizado por la FIFA. En este tipo de fútbol, hay muchos países diferentes que participan. Para que un País participe, dependerá de un equipo de jugadores. Cada equipo depende de tener suficientes jugadores para ser competitivo. Con esta idea, podemos construir algunas clases que sigan estos principios. Usando nuestro enfoque de búsqueda de sustantivos, nombremos algunas clases. Hasta ahora hemos hablado de a Country, a Teamy a Player. Convirtámoslos en clases.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Country
{
 
}
 
class Player 
{
 
}
 
class Team
{
 
}

Excelente. Ahora, por supuesto, estas clases están vacías, por lo que no vamos a destrozar exactamente el circuito de la FIFA, pero veamos si podemos cambiar eso. Pensemos en el Country. A Countrynecesitará a name, como Estados Unidos, y dependerá de a Team, para ser candidato a la Copa Mundial de la FIFA. Agreguemos esos elementos ahora.

Pasar un objeto como argumento

1
2
3
4
5
6
7
8
9
10
11
class Country
{
    protected $team;
    protected $name;
    
    public function __construct(Team $team, $name = 'USA')
    {
        $this->team = $team;
        $this->name = $name;
    } 
}

Lo que hacemos aquí es pasar dos argumentos a nuestro constructor. La primera es la dependencia , que hace uso de Type Hinting . Prefijamos la variable con el tipo de objeto del que deseamos depender . Esta es nuestra primera instancia de Dependency Injection y viene en forma de Constructor Injection . El segundo argumento es simplemente el namede Country, que se utilizará de forma predeterminada en EE. UU. Si no se proporciona ninguno. Ok, tenemos un Countryque depende de a Team, pero nuestro actualTeamla clase está vacía por lo que no será de mucho beneficio. Agreguemos algo de carne a nuestro equipo. ¿Qué necesita un equipo? Necesita algunos jugadores. ¿Cómo consigue jugadores? Bueno, necesitarían al joinequipo. También podríamos decir que dependemos de un jugador para unirse al equipo. Codifiquemos esto.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Team
{
    protected $players = [];
    
    public function __construct($players = [])
    {
        $this->players = $players;
    }
    
    public function join(Player $player)
    {
        $this->players[] = $player;
    }
    
    public function getplayers()
    {
        return $this->players;
    } 
}

Primero, creamos una playersmatriz para contener a todos nuestros jugadores. Cuando creamos un nuevo Team, generaremos automáticamente una matriz de jugadores para contener a los jugadores que se unen al equipo. Hay una palabra clave ahí, únete. Un jugador deberá unirse al equipo. Creamos el joinmétodo y pasamos un Playerobjeto. Aquí de nuevo usamos sugerencias de tipo para indicar que esperamos un objeto de tipo Player. Esta es nuestra segunda instancia de Inyección de dependencia , pero esta vez usamos la Inyección de método . Finalmente, simplemente creamos un método de obtención simple de getplayers()para que podamos ver quién está en nuestro equipo a medida que agregamos jugadores. La Playerclase debería ser fácil ya que todo lo que tenemos que hacer es darle a nuestro jugador un name.

1
2
3
4
5
6
7
8
9
class Player 
{
    protected $name;
    
    public function __construct($name)
    {
        $this->name = $name;
    }
}

En este punto estamos progresando, pero tenemos un pequeño problema. ¿Cómo se va a incorporar un jugador al equipo de un país específico? Lo más probable es que el país necesite recruitun jugador para unirse a su equipo. Actualicemos la clase País para reflejar esto.

Enviando mensajes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Country
{
    protected $team;
    protected $name;
    
    public function __construct(Team $team, $name = 'USA')
    {
        $this->team = $team;
        $this->name = $name;
    }
    
    public function recruit(Player $player)
    {
        $this->team->join($player);
    }
}

Ahora nuestro Countrytiene la capacidad de recruitnuevos jugadores para su Team. Tenga en cuenta que este es un ejemplo de transmisión de mensajes . El nombre del método y sus parámetros de entrada se conceptualizan como un mensaje . Estamos listos para probar esto. Ahora sabemos que a Countryva a depender de a Team. En otras palabras, cuando creamos un nuevo Country, necesitamos pasar un Teamobjeto. Entonces, primero, crearemos un Teamobjeto, luego crearemos un Countryobjeto y pasaremos esa instancia de Team.

1
2
3
$team = new Team;
 
$usa = new Country($team);

Perfecto. Ahora necesitamos recruitalgunos jugadores para nuestro Team. Para ser recruitun jugador, primero deben existir. Creemos un nuevo Playerahora.

1
$player1 = new Player('Carli Lloyd');

Ahora que tenemos una Player, ¡nuestra Countrylata recruit!

1
$usa->recruit($player1);

Confirmemos ahora quién está en nuestro Team. Recuerde, creamos un getplayers()captador en nuestra Teamclase para hacer precisamente eso por nosotros.

1
$team->getplayers();

1
2
3
4
5
6
7
Array
(
    [0] => Player Object
        (
            [name:protected] => Carli Lloyd
        )
)

¡Increíble! Podemos ver que tenemos unPlayerobjeto con elnamede Carli Lloyd en nuestro equipo. Vamos a necesitar mucho más de un jugador para tener éxito, así que agreguemos un grupo de compañeros de equipo.

1
2
3
4
5
6
7
8
9
$player2 = new Player('Morgan Brian');
$player3 = new Player('Ashlyn Harris');
$player4 = new Player('Tobin Heath');
$player5 = new Player('Alex Morgan');
 
$usa->recruit($player2);
$usa->recruit($player3);
$usa->recruit($player4);
$usa->recruit($player5);

Bingo Bango -> ¡veamos quién está ahora en nuestro equipo!

1
$team->getplayers();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Array
(
    [0] => Player Object
        (
            [name:protected] => Carli Lloyd
        )
 
    [1] => Player Object
        (
            [name:protected] => Morgan Brian
        )
 
    [2] => Player Object
        (
            [name:protected] => Ashlyn Harris
        )
 
    [3] => Player Object
        (
            [name:protected] => Tobin Heath
        )
 
    [4] => Player Object
        (
            [name:protected] => Alex Morgan
        )
)

¡Eso sí que es un equipo! Tenemos algunos jugadores fantásticos como Morgan Brian, Ashlyn Harris, Tobin Heath, Alex Morgan y Carli Lloyd.

Inyección de dependencia para principiantes

En este tutorial de inyección de dependencia para principiantes, cubrimos mucho terreno. En lugar de crear una clase masiva e intentar poner toda la funcionalidad en una ubicación, dividimos nuestra clase en varias clases diferentes. Aunque las clases están separadas, pueden comunicarse entre sí enviando mensajes o llamando a métodos entre sí. Enviar un mensaje puede considerarse como llamar a un método sobre un objeto. También tuvimos una introducción a Type Hinting y Dependency Injection. Estos son enfoques que permiten la composición, que es el concepto de objetos que contienen otros objetos en sus variables de instancia. Mediante el uso de Composición, podemos construir un objeto para cumplir con todos nuestros objetivos lógicos, cuando la herencia simple no es suficiente. Comprender la inyección de dependencia nos da una buena idea de cómo La inversión de control también funciona.

Header Ads Widget

Inyección de dependencia para principiantes

No hay "yo" en el equipo

Pasar un objeto como argumento

Enviando mensajes

Inyección de dependencia para principiantes

Publicar un comentario

0 Comentarios

Random Posts

Información relevante

Colaboraciones

Menu Footer Widget