php_design_patterns/bridge.php at master · adrwtr/php_design_patterns · GitHub

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
<html>
<head>
    <meta http-equiv="Content-type" content="text/html; charset=utf-8"/>
</head>
<body>
<?
/**
 * Imagine que você tem as classes Programador e Homologador(Qualidade)
 * Essas classes realizam trabalhos distintos. Programador programa e Homologador Testa.
 *
 * O nosso sistema irá usar a função produz para as duas classes acima.
 *
 * O padrão Bridge vai separar o que Programador faz com o que Homologador faz através de uma
 * segunda interface chamada Tarefa.
 *
 * Os dois funcionários irão produzir Tarefas, e a tarefa terá a implementação variada para cada produtor.
 *
 * Desta forma, se precisarmos criar um CHEFE, ou um Designer, será fácil pois a implementação estará desacoplada.
 *
 * A magica está em produz e em realiza.
 * Realiza é a implementação desacoplada
 * E Produz é a chamada para um implementação de realiza
 */

interface Colaborador
{
    public function produz();

    public function recebeTarefa(Tarefa $tarefa);
}

class Programador implements Colaborador
{

    private $tarefa;

    public function Programador(Tarefa $tarefa)
    {
        $this->tarefa = $tarefa;
    }

    // aqui está a magica.. o que é tarefa?
    // pode ser qualquer coisa, e está desacoplada (bridge)
    public function produz()
    {
        echo "\nProgramador trabalhando <BR><BR>";
        $this->tarefa->realiza();
    }

    public function recebeTarefa(Tarefa $tarefa)
    {
        $this->tarefa = $tarefa;
    }

}


class Homologador implements Colaborador
{

    var $tarefa;

    public function Homologador(Tarefa $tarefa)
    {
        $this->tarefa = $tarefa;
    }

    public function produz()
    {
        echo "\nHomologador trabalhando  <BR><BR>";
        $this->tarefa->realiza();
    }

    public function recebeTarefa(Tarefa $tarefa)
    {
        $this->tarefa = $tarefa;
    }

}

// bridge
interface Tarefa
{
    public function realiza();
}


class ProgramacaoJava implements Tarefa
{
    public function realiza()
    {
        echo "cria muitas linhas de código Java <BR><BR>";
    }
}

class ProgramacaoRuby implements Tarefa
{
    public function realiza()
    {
        echo "cria muitas linhas de código Ruby <BR><BR>";
    }
}

class TestesAutomatizados implements Tarefa
{
    public function realiza()
    {
        echo "constrói testes automatizados <BR><BR>";
    }
}

class TestesManuais implements Tarefa
{
    public function realiza()
    {
        echo "constrói testes manuais <BR><BR>";
    }
}


// Eu gosto de programar em java, então eu posso criar um programador que executa a tarefa de programar em Java
$tarefaDoProgramador = new ProgramacaoJava();
$programador = new Programador($tarefaDoProgramador);
$programador->produz();

// Eu também gosto de Ruby então poderia desenvolver em Ruby!
$tarefaDoProgramador = new ProgramacaoRuby();
$programador->recebeTarefa($tarefaDoProgramador);
$programador->produz();

// Mas se a situação aperta e me pedem testes automatizados, não tem problema eu posso fazer também!
$tarefaDoProgramador = new TestesAutomatizados();
$programador->recebeTarefa($tarefaDoProgramador);
$programador->produz();

// No caso do colaborador, temos o mesmo, ele faz testes manuais
$tarefaDoHomologador = new TestesManuais();
$homologador = new Homologador($tarefaDoHomologador);
$homologador->produz();

// Mas se a situação aperta ele pode programar até em Ruby!
$tarefaDoHomologador = new ProgramacaoRuby();
$homologador->recebeTarefa($tarefaDoHomologador);
$homologador->produz();


/**
 *  Use este padrão quando:
 *
 *  você precisa altera a implementação em tempo de execução
 *  você tem muitas classes de uma mesma interface, e muitas implementações
 *  você precisa distribuir uma implementação para muitos objetos
 *
 * - Uma ponte entre: O que o cliente precisa(tarefa) e o que a plataforma precisa(produz).
 */

?>
</body>
</html>