[GitHub] [tomee] alexferreiradev commented on a change in pull request #775: TOMEE-2984 Translate to Portuguese: examples/simple-singleton

[GitBox <gi...@apache.org>]

alexferreiradev commented on a change in pull request #775:
URL: https://github.com/apache/tomee/pull/775#discussion_r595916102



##########
File path: examples/simple-singleton/README_pt.adoc
##########
@@ -0,0 +1,365 @@
+:index-group: Session Beans
+:jbake-type: page
+:jbake-status: status=published
+= Simples Singleton
+
+Como o nome indica, um `javax.ejb.Singleton`, é um bean de sessão com a garantia de que há no máximo uma instância no aplicativo.

Review comment:
       I think that the translation of `applicación` can be `aplicação` in pt. What do you think ? 

##########
File path: examples/simple-singleton/README_pt.adoc
##########
@@ -0,0 +1,365 @@
+:index-group: Session Beans
+:jbake-type: page
+:jbake-status: status=published
+= Simples Singleton
+
+Como o nome indica, um `javax.ejb.Singleton`, é um bean de sessão com a garantia de que há no máximo uma instância no aplicativo.
+
+O que está faltando completamente no EJB 3.0 e anteriores é a capacidade de ter um EJB que é notificado quando o aplicativo é iniciado e quando ele para. Portanto, você pode fazer todos os tipos de coisas que antes só podiam ser feitas com um servlet de carregamento na inicialização. Também oferece um local para armazenar dados que pertencem a todo o aplicativo e a todos os usuários que os utilizam, sem a necessidade de dados estáticos. Além disso, os beans singleton podem ser chamados por vários encadeamentos ao mesmo tempo semelhante a um servlet.
+
+Consulte o link:../../singleton-beans.html[Singleton Beans] para obter uma página inteira da descrição da API javax.ejb.Singleton.
+
+== O codigo
+
+== Concorrencia Bean-Managed de PropertyRegistry 
+
+Aqui, vemos um bean que usa a opção de concorrencia Bean-Managed, bem como a anotação @Startup que faz com que o bean seja confirmado pelo contêiner quando o aplicativo é iniciado.
+Beans singleton com @ConcurrencyManagement(BEAN) são responsáveis ​​por sua própria segurança de thread. O bean mostrado é um registro de propriedade simples e fornece um local onde todos os beans de aplicativo podem definir e recuperar opções.
+
+[source,java]
+....
+package org.superbiz.registry;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.ejb.ConcurrencyManagement;
+import javax.ejb.Singleton;
+import javax.ejb.Startup;
+import java.util.Properties;
+
+import static javax.ejb.ConcurrencyManagementType.BEAN;
+
+@Singleton
+@Startup
+@ConcurrencyManagement(BEAN)
+public class PropertyRegistry {
+
+
+// Observe que o objeto java.util.Properties é um 
+// Uma coleção thread-safe que usa sincronização. Se não for assim,
+// Eu teria que usar alguma forma de sincronização para ter certeza
+// Certifique-se de que PropertyRegistryBean é seguro para thread.
+    private final Properties properties = new Properties();
+
+// A anotação @Startup garante que
+// Chame esse método quando o aplicativo for iniciado.
+    @PostConstruct
+    public void applicationStartup() {
+        properties.putAll(System.getProperties());
+    }
+
+    @PreDestroy
+    public void applicationShutdown() {
+        properties.clear();
+    }
+
+    public String getProperty(final String key) {
+        return properties.getProperty(key);
+    }
+
+    public String setProperty(final String key, final String value) {
+        return (String) properties.setProperty(key, value);
+    }
+
+    public String removeProperty(final String key) {
+        return (String) properties.remove(key);
+    }
+}
+....
+
+== ComponentRegistry Container-Managed Concurrency
+
+Aqui, vemos um bean que usa a opção de concorrencia 'Container-Managed', o padrão. Com `@ConcurrencyManagement(CONTAINER)` o contêiner controla se deve permitir o acesso multithread ao bean `@Lock (READ)`) ou se deve forçar o acesso de thread único (`@Lock (WRITE)`).
+
+[source,java]
+....
+package org.superbiz.registry;
+
+import javax.ejb.Lock;
+import javax.ejb.Singleton;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import static javax.ejb.LockType.READ;
+import static javax.ejb.LockType.WRITE;
+
+@Singleton
+@Lock(READ)
+public class ComponentRegistry {
+
+    private final Map<Class, Object> components = new HashMap<Class, Object>();
+
+    public <T> T getComponent(final Class<T> type) {
+        return (T) components.get(type);
+    }
+
+    public Collection<?> getComponents() {
+        return new ArrayList(components.values());
+    }
+
+    @Lock(WRITE)
+    public <T> T setComponent(final Class<T> type, final T value) {
+        return (T) components.put(type, value);
+    }
+
+    @Lock(WRITE)
+    public <T> T removeComponent(final Class<T> type) {
+        return (T) components.remove(type);
+    }
+}
+....
+
+A menos que explicitamente especificado na classe de bean ou um método, o padrão `@Lock` é `@Lock(WRITE)`. O código acima usa a anotação `@Lock(READ)` na classe do bean para alterar o valor padrão para que o acesso multithread seja concedido por padrão. Portanto, só precisamos aplicar a anotação `@Lock(WRITE)` aos métodos que modificam o estado do bean.
+
+Essencialmente, `@Lock(READ)` permite acesso multithread à instância do bean Singleton, a menos que alguém invoque um método `@Lock(WRITE)`. Usar `@Lock(WRITE)` garantirá que a thread que invoca o bean terá acesso exclusivo à instância do Singleton bean durante sua invocação. Essa combinação permite que a instância do bean use tipos de dados que normalmente não são seguros para thread. Muito cuidado deve ser tomado.três coisas:
+
+No exemplo, vemos `ComponentRegistryBean` usando um `java.util.HashMap` que está fora de sincronia. Para acertar, nós fazemos três coisas:
+
+[arabic]
+. Encapsulamento Não expomos a instância HashMap diretamente; incluindo seus iteradores, conjunto de chaves, conjunto de valores ou conjunto de entrada.

Review comment:
       Put a dot after `Encapsulamento`

##########
File path: examples/simple-singleton/README_pt.adoc
##########
@@ -0,0 +1,365 @@
+:index-group: Session Beans
+:jbake-type: page
+:jbake-status: status=published
+= Simples Singleton
+
+Como o nome indica, um `javax.ejb.Singleton`, é um bean de sessão com a garantia de que há no máximo uma instância no aplicativo.
+
+O que está faltando completamente no EJB 3.0 e anteriores é a capacidade de ter um EJB que é notificado quando o aplicativo é iniciado e quando ele para. Portanto, você pode fazer todos os tipos de coisas que antes só podiam ser feitas com um servlet de carregamento na inicialização. Também oferece um local para armazenar dados que pertencem a todo o aplicativo e a todos os usuários que os utilizam, sem a necessidade de dados estáticos. Além disso, os beans singleton podem ser chamados por vários encadeamentos ao mesmo tempo semelhante a um servlet.
+
+Consulte o link:../../singleton-beans.html[Singleton Beans] para obter uma página inteira da descrição da API javax.ejb.Singleton.
+
+== O codigo
+
+== Concorrencia Bean-Managed de PropertyRegistry 
+
+Aqui, vemos um bean que usa a opção de concorrencia Bean-Managed, bem como a anotação @Startup que faz com que o bean seja confirmado pelo contêiner quando o aplicativo é iniciado.
+Beans singleton com @ConcurrencyManagement(BEAN) são responsáveis ​​por sua própria segurança de thread. O bean mostrado é um registro de propriedade simples e fornece um local onde todos os beans de aplicativo podem definir e recuperar opções.
+
+[source,java]
+....
+package org.superbiz.registry;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.ejb.ConcurrencyManagement;
+import javax.ejb.Singleton;
+import javax.ejb.Startup;
+import java.util.Properties;
+
+import static javax.ejb.ConcurrencyManagementType.BEAN;
+
+@Singleton
+@Startup
+@ConcurrencyManagement(BEAN)
+public class PropertyRegistry {
+
+
+// Observe que o objeto java.util.Properties é um 
+// Uma coleção thread-safe que usa sincronização. Se não for assim,
+// Eu teria que usar alguma forma de sincronização para ter certeza
+// Certifique-se de que PropertyRegistryBean é seguro para thread.
+    private final Properties properties = new Properties();
+
+// A anotação @Startup garante que
+// Chame esse método quando o aplicativo for iniciado.
+    @PostConstruct
+    public void applicationStartup() {
+        properties.putAll(System.getProperties());
+    }
+
+    @PreDestroy
+    public void applicationShutdown() {
+        properties.clear();
+    }
+
+    public String getProperty(final String key) {
+        return properties.getProperty(key);
+    }
+
+    public String setProperty(final String key, final String value) {
+        return (String) properties.setProperty(key, value);
+    }
+
+    public String removeProperty(final String key) {
+        return (String) properties.remove(key);
+    }
+}
+....
+
+== ComponentRegistry Container-Managed Concurrency
+
+Aqui, vemos um bean que usa a opção de concorrencia 'Container-Managed', o padrão. Com `@ConcurrencyManagement(CONTAINER)` o contêiner controla se deve permitir o acesso multithread ao bean `@Lock (READ)`) ou se deve forçar o acesso de thread único (`@Lock (WRITE)`).
+
+[source,java]
+....
+package org.superbiz.registry;
+
+import javax.ejb.Lock;
+import javax.ejb.Singleton;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import static javax.ejb.LockType.READ;
+import static javax.ejb.LockType.WRITE;
+
+@Singleton
+@Lock(READ)
+public class ComponentRegistry {
+
+    private final Map<Class, Object> components = new HashMap<Class, Object>();
+
+    public <T> T getComponent(final Class<T> type) {
+        return (T) components.get(type);
+    }
+
+    public Collection<?> getComponents() {
+        return new ArrayList(components.values());
+    }
+
+    @Lock(WRITE)
+    public <T> T setComponent(final Class<T> type, final T value) {
+        return (T) components.put(type, value);
+    }
+
+    @Lock(WRITE)
+    public <T> T removeComponent(final Class<T> type) {
+        return (T) components.remove(type);
+    }
+}
+....
+
+A menos que explicitamente especificado na classe de bean ou um método, o padrão `@Lock` é `@Lock(WRITE)`. O código acima usa a anotação `@Lock(READ)` na classe do bean para alterar o valor padrão para que o acesso multithread seja concedido por padrão. Portanto, só precisamos aplicar a anotação `@Lock(WRITE)` aos métodos que modificam o estado do bean.
+
+Essencialmente, `@Lock(READ)` permite acesso multithread à instância do bean Singleton, a menos que alguém invoque um método `@Lock(WRITE)`. Usar `@Lock(WRITE)` garantirá que a thread que invoca o bean terá acesso exclusivo à instância do Singleton bean durante sua invocação. Essa combinação permite que a instância do bean use tipos de dados que normalmente não são seguros para thread. Muito cuidado deve ser tomado.três coisas:

Review comment:
       At the and of paragraph, there is: `.três coisas`. Remove that




----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org