Skip to content

Commit 13d0416

Browse files
Viniberaldoiluwatar
Viniberaldo
and
iluwatar
authored
translation: Translation of facade design pattern to PT-BR (iluwatar#2355)
* tranlation of facade design pattern to PT-BR * Update README.md Co-authored-by: Ilkka Seppälä <[email protected]>
1 parent e9d1368 commit 13d0416

File tree

1 file changed

+229
-0
lines changed

1 file changed

+229
-0
lines changed

‎localization/pt/facade/README.md

Lines changed: 229 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,229 @@
1+
---
2+
title: Facade
3+
category: Structural
4+
language: pt
5+
tag:
6+
- Gang Of Four
7+
- Decoupling
8+
---
9+
10+
## Propósito
11+
12+
Prover uma interface unificada para um conjunto de interfaces em um subsistema.
13+
Facade (ou fachada) define uma interface num nível mais elevado que torna o subsistema mais fácil de ser utilizado.
14+
15+
## Explicação
16+
17+
Real-world example
18+
Exemplo do mundo real
19+
20+
> Como uma mina de ouro funciona? "Bem, os mineradores vão pro subsolo, cavam e encontram ouro!" você pode dizer.
21+
> Isso é o que você acredita porque você está usando uma simples interface que a mina de ouro provê para o exterior,
22+
> internamente há muitas coisas a fazer para que isso aconteça. Essa interface simples para um subsistema complexo é
23+
> um facade.
24+
25+
Em termos pŕaticos
26+
27+
> O padrão Facade provê uma interface simplificada para um subsistema complexo.
28+
29+
Wikipedia diz
30+
31+
> Um facade é um objeto que provê uma interface simplificada para um corpo maior de código fonte,
32+
> como uma biblioteca de uma classe.
33+
34+
**Exemplo programático**
35+
36+
Vamos pegar nosso exemplo da mina de ouro acima. Aqui temos uma hierarquia de anão minerador.
37+
Primeiro há uma classe base `DwarvenMineWorker`:
38+
39+
```java
40+
@Slf4j
41+
public abstract class DwarvenMineWorker {
42+
43+
public void goToSleep() {
44+
LOGGER.info("{} goes to sleep.", name());
45+
}
46+
47+
public void wakeUp() {
48+
LOGGER.info("{} wakes up.", name());
49+
}
50+
51+
public void goHome() {
52+
LOGGER.info("{} goes home.", name());
53+
}
54+
55+
public void goToMine() {
56+
LOGGER.info("{} goes to the mine.", name());
57+
}
58+
59+
private void action(Action action) {
60+
switch (action) {
61+
case GO_TO_SLEEP:
62+
goToSleep();
63+
break;
64+
case WAKE_UP:
65+
wakeUp();
66+
break;
67+
case GO_HOME:
68+
goHome();
69+
break;
70+
case GO_TO_MINE:
71+
goToMine();
72+
break;
73+
case WORK:
74+
work();
75+
break;
76+
default:
77+
LOGGER.info("Undefined action");
78+
break;
79+
}
80+
}
81+
82+
public void action(Action... actions) {
83+
Arrays.stream(actions).forEach(this::action);
84+
}
85+
86+
public abstract void work();
87+
88+
public abstract String name();
89+
90+
enum Action {
91+
GO_TO_SLEEP, WAKE_UP, GO_HOME, GO_TO_MINE, WORK
92+
}
93+
}
94+
```
95+
96+
Então nós temos as classes concretas anão `DwarvenTunnelDigger`, `DwarvenGoldDigger` and
97+
`DwarvenCartOperator`:
98+
99+
```java
100+
@Slf4j
101+
public class DwarvenTunnelDigger extends DwarvenMineWorker {
102+
103+
@Override
104+
public void work() {
105+
LOGGER.info("{} creates another promising tunnel.", name());
106+
}
107+
108+
@Override
109+
public String name() {
110+
return "Dwarven tunnel digger";
111+
}
112+
}
113+
114+
@Slf4j
115+
public class DwarvenGoldDigger extends DwarvenMineWorker {
116+
117+
@Override
118+
public void work() {
119+
LOGGER.info("{} digs for gold.", name());
120+
}
121+
122+
@Override
123+
public String name() {
124+
return "Dwarf gold digger";
125+
}
126+
}
127+
128+
@Slf4j
129+
public class DwarvenCartOperator extends DwarvenMineWorker {
130+
131+
@Override
132+
public void work() {
133+
LOGGER.info("{} moves gold chunks out of the mine.", name());
134+
}
135+
136+
@Override
137+
public String name() {
138+
return "Dwarf cart operator";
139+
}
140+
}
141+
142+
```
143+
144+
Para operar todos esses mineradores de ouro temos o `DwarvenGoldmineFacade`:
145+
146+
```java
147+
public class DwarvenGoldmineFacade {
148+
149+
private final List<DwarvenMineWorker> workers;
150+
151+
public DwarvenGoldmineFacade() {
152+
workers = List.of(
153+
new DwarvenGoldDigger(),
154+
new DwarvenCartOperator(),
155+
new DwarvenTunnelDigger());
156+
}
157+
158+
public void startNewDay() {
159+
makeActions(workers, DwarvenMineWorker.Action.WAKE_UP, DwarvenMineWorker.Action.GO_TO_MINE);
160+
}
161+
162+
public void digOutGold() {
163+
makeActions(workers, DwarvenMineWorker.Action.WORK);
164+
}
165+
166+
public void endDay() {
167+
makeActions(workers, DwarvenMineWorker.Action.GO_HOME, DwarvenMineWorker.Action.GO_TO_SLEEP);
168+
}
169+
170+
private static void makeActions(Collection<DwarvenMineWorker> workers,
171+
DwarvenMineWorker.Action... actions) {
172+
workers.forEach(worker -> worker.action(actions));
173+
}
174+
}
175+
```
176+
177+
Agora vamos usar o facade:
178+
179+
```java
180+
var facade = new DwarvenGoldmineFacade();
181+
facade.startNewDay();
182+
facade.digOutGold();
183+
facade.endDay();
184+
```
185+
186+
Saída do programa:
187+
188+
```java
189+
// Dwarf gold digger wakes up.
190+
// Dwarf gold digger goes to the mine.
191+
// Dwarf cart operator wakes up.
192+
// Dwarf cart operator goes to the mine.
193+
// Dwarven tunnel digger wakes up.
194+
// Dwarven tunnel digger goes to the mine.
195+
// Dwarf gold digger digs for gold.
196+
// Dwarf cart operator moves gold chunks out of the mine.
197+
// Dwarven tunnel digger creates another promising tunnel.
198+
// Dwarf gold digger goes home.
199+
// Dwarf gold digger goes to sleep.
200+
// Dwarf cart operator goes home.
201+
// Dwarf cart operator goes to sleep.
202+
// Dwarven tunnel digger goes home.
203+
// Dwarven tunnel digger goes to sleep.
204+
```
205+
206+
## Diagrama de classe
207+
208+
![alt text](./etc/facade.urm.png "Diagrama de classe padrão Facade")
209+
210+
## Aplicabilidade
211+
212+
Use o padrão facade quando
213+
214+
* Você quer prover uma simples interface para um subsistema complexo. Subsistemas frequentemente
215+
vão ficando mais complexos conforme eles evoluem. A maioria dos padrões, quando aplicada, resulta
216+
em classes menores e mais numerosas. Isso faz com que o subsistema se torne mais reusável e mais
217+
fácil de customizar, mas também torna mais difícil de usar para clientes que não precisam de
218+
customização.
219+
* Há muitas dependências entre clientes e as classes de implementação de uma abstração. Introduza
220+
um facade para desacoplar o subsistema de clientes e outros subsistemas, portanto promovendo independência
221+
e portabilidade para o subsistema.
222+
* Você quer subdividir em camadas o seu subsistema. Use um facade para definir um ponto de entrada
223+
para cada nível de subsistema. Se o subsistema é dependente, então você pode simplificar as dependências
224+
entre eles, fazendo-os se comunicarem entre si apenas pelos facades.
225+
226+
## Créditos
227+
228+
* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59)
229+
* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b)

0 commit comments

Comments
 (0)