From 52765ebf0fa416898e9fe73b06734dbdb82f06de Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Fernandes?= <104360594+jppf22@users.noreply.github.com> Date: Sat, 28 Oct 2023 09:41:01 +0100 Subject: [PATCH] translation: Translate Proxy Pattern to portuguese. (#2723) --- localization/pt/proxy/README.md | 166 ++++++++++++++++++++++++++++++++ 1 file changed, 166 insertions(+) create mode 100644 localization/pt/proxy/README.md diff --git a/localization/pt/proxy/README.md b/localization/pt/proxy/README.md new file mode 100644 index 000000000..79f467baf --- /dev/null +++ b/localization/pt/proxy/README.md @@ -0,0 +1,166 @@ +--- +title: Proxy +category: Structural +language: pt +tag: + - Gang Of Four + - Decoupling +--- + +## Também conhecido como + +Surrogate + +## Propósito + +Fornecer um substituto para controlar o acesso ao objeto original + +## Explicação + +Exemplo de mundo real + +> Imagine uma torre onde magos locais vão estudar os seus feitiços. A torre de marfim consegue ser +> acedida através de uma proxy que garante que apenas os três primeiros magos podem entrar. Aqui a proxy +> representa a funcionalidade da torre e adiciona controlo de acesso a ela. + +Em palavras simples + +> Usando um padrão proxy, a classe representa a funcionalidade de uma outra classe. + +Wikipedia diz + +> Uma proxy, na sua forma mais genérica, é uma classe a funcionar como interface para algo. +> Uma proxy é um wrapper ou objeto agente que está a ser chamado pelo cliente para aceder ao verdadeiro +> objeto por detrás das cortinas. O uso de uma proxy pode ser apenas redirecionar para o objeto real, ou +> pode fornecer lógica adicional. Numa proxy, funcionalidade extra também pode ser fornecida, por exemplo apanhar +> operações no objeto real que gastam muitos recursos, ou verificar precondições antes +> das operações no objeto real serem invocadas. + +**Exemplos de programação** + +Usando a nossa torre de magos do exemplo acima. Primeiro temos a interface `WizardTower` e a classe +`IvoryTower`. + +```java +public interface WizardTower { + + void enter(Wizard wizard); +} + +@Slf4j +public class IvoryTower implements WizardTower { + + public void enter(Wizard wizard) { + LOGGER.info("{} enters the tower.", wizard); + } + +} +``` + +Depois uma simples classe `Wizard`. + +```java +public class Wizard { + + private final String name; + + public Wizard(String name) { + this.name = name; + } + + @Override + public String toString() { + return name; + } +} +``` + +Depois temos a `WizardTowerProxy` para adicionar controlo à `WizardTower`. + +```java +@Slf4j +public class WizardTowerProxy implements WizardTower { + + private static final int NUM_WIZARDS_ALLOWED = 3; + + private int numWizards; + + private final WizardTower tower; + + public WizardTowerProxy(WizardTower tower) { + this.tower = tower; + } + + @Override + public void enter(Wizard wizard) { + if (numWizards < NUM_WIZARDS_ALLOWED) { + tower.enter(wizard); + numWizards++; + } else { + LOGGER.info("{} is not allowed to enter!", wizard); + } + } +} +``` + +E aqui está a torre a entrar em cenário. + +```java +var proxy = new WizardTowerProxy(new IvoryTower()); +proxy.enter(new Wizard("Red wizard")); +proxy.enter(new Wizard("White wizard")); +proxy.enter(new Wizard("Black wizard")); +proxy.enter(new Wizard("Green wizard")); +proxy.enter(new Wizard("Brown wizard")); +``` + +Saída do programa: + +``` +Red wizard enters the tower. +White wizard enters the tower. +Black wizard enters the tower. +Green wizard is not allowed to enter! +Brown wizard is not allowed to enter! +``` + +## Diagrama de classes + +![alt text](./etc/proxy.urm.png "Diagrama de classes do padrão proxy") + +## Aplicabilidade + +O proxy é aplicável quando existe a necessidade de uma referência a um objeto mais versátil ou sofisticada em vez de um simples ponteiro. Aqui estão várias situações comuns em que o padrão Proxy é aplicável. + +* Proxy remoto dá uma representação local de um objeto num espaço de endereçamento diferente. +* Proxy virtual cria objetos dispendiosos quando requisitado. +* Proxy de proteção controla o acesso ao objeto original. Proxies de proteção são úteis quando objetos deviam ter direitos de acesso diferentes. + +Tipicamente, o padrão proxy é usado para + +* Controlar acesso a um outro objeto +* Inicialização preguiçosa +* Implementar um registro de eventos (logging) +* Facilitar a conexão com a rede +* Contar o número de referências para um objeto + +## Tutoriais + +* [Controlar acesso com um padrão Proxy](http://java-design-patterns.com/blog/controlling-access-with-proxy-pattern/) + +## Usos conhecidos + +* [java.lang.reflect.Proxy](http://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Proxy.html) +* [Apache Commons Proxy](https://commons.apache.org/proper/commons-proxy/) +* Frameworks para Mocking [Mockito](https://site.mockito.org/), +[Powermock](https://powermock.github.io/), [EasyMock](https://easymock.org/) +* UIKit's da Apple [UIAppearance](https://developer.apple.com/documentation/uikit/uiappearance) + +## Padrões relacionados + +* [Ambassador](https://java-design-patterns.com/patterns/ambassador/) + +## Créditos + +* [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) +* [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)