Merge branch 'master' of git@github.com:demoiselle/framework.git

Cleverson Sacramento
2 parents a0cae561 1edb12a0
Showing 12 changed files with 435 additions and 53 deletions Show diff stats
documentation/reference/pt-BR/mensagem.xml
documentation/reference/pt-BR/persistencia.xml
documentation/reference/pt-BR/properties.xml
documentation/reference/pt-BR/transacao.xml
impl/core/src/main/java/br/gov/frameworkdemoiselle/internal/context/AbstractCustomContext.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/internal/context/AbstractStaticContext.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/internal/context/CustomContextProducer.java
impl/core/src/test/java/context/staticcontext/ConversationBean.java
impl/core/src/test/java/context/staticcontext/SessionBean.java
impl/core/src/test/java/context/staticcontext/StaticContextTest.java
impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/producer/AbstractEntityManagerStore.java
impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/EntityManagerProxy.java
@@ -277,6 +277,41 @@ ALUNO_EXCLUIR_OK=L&#39;étudiant {0} a été supprimé avec succès]]&gt;&lt;/programlisti
 			</para>
 		</note>
 	</section>
+	
+	<section>
+		<title>Destino das mensagens</title>
+		
+		<para>
+			O Framework Demoiselle permite configurar o destino das mensagens enviadas. Por padrão, mensagens enviadas em um ambiente SE (Swing por exemplo)
+			são exibidas como registros de log no console, já mensagens enviadas em um ambiente WEB usando JSF 2.0 são redirecionadas para a classe
+			<code>FacesContext</code>. Caso esse comportamento padrão não seja suficiente para você, é possível personalizar o mecanismo de redirecionamento
+			de mensagens, fazendo-o enviar as mensagens para um local de seu interesse.
+		</para>
+		
+		<para>
+			Para isso existe a interface <code>MessageAppender</code>. Para toda mensagem enviada, o Framework Demoiselle vai determinar a implementação
+			mais adequada de <code>MessageAppender</code> a utilizar e vai redirecionar qualquer mensagem para essa implementação.
+		</para>
+		
+		<programlisting role="JAVA">public interface MessageAppender extends Serializable {
+	
+	/**
+	 * Method that must hold message in an appropriate way and in an appropriate local.
+	 * Demoiselle holds a message in a Logger or in a FacesContext, depending on the project.
+	 * 
+	 * @param message
+	 * 			message to be stored.
+	 */
+	void append(Message message);
+}</programlisting>
+
+		<para>
+			Para criar seu próprio <code>MessageAppender</code>, implemente essa interface e anote-a com a anotação <code>@Priority</code> - o Framework
+			Demoiselle irá selecionar a implementação adequada paseada na maior prioridade. Não é necessário configurar mais nada, o Framework Demoiselle
+			selecionará a implementação automaticamente. Cabe-lhe então a tarefa de implementar o método <code>append(Message message)</code> para tratar
+			a mensagem da forma que melhor se adequar a seu projeto.
+		</para>
+	</section>
 	<section>
 		<title>Exemplos de implementação</title>
@@ -18,6 +18,181 @@
 		&eacute; apenas injetar o recurso adequado em seu c&oacute;digo e o Framework Demoiselle se encarregar&aacute; de
 		produzi-lo e configur&aacute;-lo. 
 	</para>
+	
+	<section>
+		<title>JPA</title>
+		
+		<para>
+			O Framework Demoiselle fornece um produtor padrão para contextos de persistência da JPA. Esse produtor lê o arquivo
+			de configuração <code>persistence.xml</code> de seu projeto e toma as providências necessárias para fabricar uma instância
+			da classe <code>EntityManager</code> que pode ser usada para gerenciar as entidades de sua aplicação. Além disso, instâncias
+			de <code>EntityManager</code> produzidas pelo Framework Demoiselle participam automaticamente de transações abertas através da
+			anotação <code>@Transactional</code>, conforme apresentado no capítulo sobre <link linkend="transacao">Transações</link>.
+		</para>
+		
+		<tip>
+	 		<para>
+	 			Para acrescentar a dependência à extensão <literal>demoiselle-jpa</literal>, adicione esse código
+	 			em seu arquivo <literal>pom.xml</literal>, na seção <literal>dependencies</literal>.
+	 		</para>
+	 	
+	 		<programlisting role="XML"><![CDATA[<dependency>
+	<groupId>br.gov.frameworkdemoiselle</groupId>
+	<artifactId>demoiselle-jpa</artifactId>
+	<scope>compile</scope>
+</dependency>]]></programlisting>
+		</tip>
+		
+		<section>
+			<title>Introdução ao mecanismo</title>
+			
+			<para>
+				Para injetar uma instância de <code>EntityManager</code> em sua aplicação, basta usar a anotação <code>@Inject</code>.
+			</para>
+			
+			<programlisting role="JAVA">@PersistenceController
+public class BookmarkDAO extends JPACrud&lt;Bookmark, Long&gt; {
+	
+	private static final long serialVersionUID = 1L;
+	
+	@Inject
+	private EntityManager entityManager;
+	
+	public void persistBookmark(Bookmark bookmark){
+		entityManager.persist(bookmark);
+	}
+	
+}</programlisting>
+
+			<para>
+				O produtor padrão injetará o <code>EntityManager</code> configurado no arquivo <code>persistence.xml</code>. Se houver
+				mais de um contexto de persistência configurado em <code>persistence.xml</code>, será necessário especificar qual será
+				injetado no ponto de injeção. Para isso use a anotação <code>@Name</code>.
+			</para>
+			
+			<programlisting role="JAVA">@PersistenceController
+public class BookmarkDAO extends JPACrud&lt;Bookmark, Long&gt; {
+	
+	private static final long serialVersionUID = 1L;
+	
+	@Inject
+	@Name("persistence_unit_1")
+	private EntityManager entityManager;
+	
+	public void persistBookmark(Bookmark bookmark){
+		entityManager.persist(bookmark);
+	}
+	
+}</programlisting>
+
+			<para>
+				É possível invocar o utilitário <code>Beans</code> para injetar instâncias de <code>EntityManager</code> programaticamente. 
+			</para>
+			
+			<programlisting role="JAVA">@PersistenceController
+public class BookmarkDAO extends JPACrud&lt;Bookmark, Long&gt; {
+	
+	private static final long serialVersionUID = 1L;
+	
+	public void persistBookmark(Bookmark bookmark){
+		EntityManager entityManager = Beans.getReference(EntityManager.class);
+		entityManager.persist(bookmark);
+	}
+	
+	public void persistBookmarkInHistory(Bookmark bookmark){
+		EntityManager entityManager = Beans.getReference(EntityManager.class , new NameQualifier("history_persistence_unit"));
+		entityManager.persist(bookmark);
+	}
+	
+}</programlisting>
+		</section>
+		
+		<section>
+			<title>Configuração</title>
+			
+			<para>
+				Alguns comportamentos do produtor podem ser configurados através das propriedades abaixo, que devem ser configuradas
+				no arquivo <code>demoiselle.properties</code>.
+			</para>
+			
+			<informaltable width="100%">
+				<tgroup cols="3">
+					<colspec align="left"/>
+					<colspec align="left"/>
+					<colspec align="right"/>
+					
+					<thead>
+						<row valign="top">
+							<entry><emphasis role="bold">Propriedade</emphasis></entry>
+							<entry><emphasis role="bold">Descrição</emphasis></entry>
+							<entry><emphasis role="bold">Padrão</emphasis></entry>
+						</row>
+					</thead>
+					
+					<tbody>
+						<row valign="top">
+							<entry>frameworkdemoiselle.&#8203;persistence.&#8203;default.&#8203;unit.&#8203;name</entry>
+							<entry>
+								<para>
+									Define o nome da unidade de persistência padrão (configurada em <code>persistence.xml</code>) que será injetada
+									caso a anotação <code>@Name</code> não seja usada. Não é necessário se apenas uma unidade de persistência for configurada.
+								</para>
+							</entry>
+							<entry></entry>
+						</row>
+						
+						<row valign="top">
+							<entry>frameworkdemoiselle.&#8203;persistence.&#8203;entitymanager.&#8203;scope</entry>
+							<entry>
+								<para>
+									Permite determinar o escopo de unidades de persistência injetadas. Dentro do escopo determinado, todos os pontos
+									de injeção receberão a mesma instância de <code>EntityManager</code>.
+								</para>
+								<para>
+									Os valores possíveis são:
+									<simplelist type="inline">
+										<member>request</member>
+										<member>session</member>
+										<member>view</member>
+										<member>conversation</member>
+										<member>application</member>
+										<member>noscope</member>
+									</simplelist>
+								</para>
+							</entry>
+							<entry>request</entry>
+						</row>
+					</tbody>
+				</tgroup>
+			</informaltable>
+			
+			<tip>
+				<para>
+					O escopo especial <emphasis>noscope</emphasis> desliga o gerenciamento de escopo de instâncias de <code>EntityManager</code>
+					produzidas pelo Framework Demoiselle. Isso permite ao desenvolvedor controlar totalmente o ciclo de vida de um
+					<code>EntityManager</code> injetado e ainda reter o recurso do produtor padrão. 
+				</para>
+				<para>
+					Note que ao usar a opção <emphasis>noscope</emphasis>, o desenvolvedor é o responsável por controlar o ciclo de vida do gerenciador
+					de persistência. Ele não participará de transações JPA abertas através da anotação <code>@Transactional</code> (transações JTA funcionam normalmente)
+					e multiplos pontos de injeção durante uma requisição receberão múltiplas instâncias de <code>EntityManager</code>.
+				</para>
+			</tip>
+			
+			<caution>
+				<para>
+					Deve-se usar cautela ao alterar o escopo padrão das instâncias de <code>EntityManager</code>. Na grande maioria dos casos o escopo
+					padrão <emphasis>request</emphasis> é o suficiente e alterar esse padrão deve ser feito apenas após extensa análise dos prós e contras
+					de cada escopo.
+				</para>
+				<para>
+					Dê especial atenção aos escopos que podem ser serializados pelo servidor de aplicação (<emphasis>session</emphasis>, <emphasis>view</emphasis>
+					e <emphasis>conversation</emphasis>) pois a especificação não define o comportamento de instâncias de <code>EntityManager</code> que são
+					serializadas.
+				</para>
+			</caution>
+		</section>
+	</section>
 	<section>
@@ -251,12 +251,34 @@
 						<entry>frameworkdemoiselle.&#8203;persistence.&#8203;default.&#8203;unit.&#8203;name</entry>
 						<entry>
 							<para>
-								Define a unidade de persistência padrão para aplicações que possuem mais
-								de um persistence-unit definido no arquivo persistence.xml.
+								Define o nome da unidade de persistência padrão (configurada em <code>persistence.xml</code>) que será injetada
+								caso a anotação <code>@Name</code> não seja usada. Não é necessário se apenas uma unidade de persistência for configurada.
 							</para>
 						</entry>
 						<entry></entry>
 					</row>
+					
+					<row valign="top">
+						<entry>frameworkdemoiselle.&#8203;persistence.&#8203;entitymanager.&#8203;scope</entry>
+						<entry>
+							<para>
+								Permite determinar o escopo de unidades de persistência injetadas. Dentro do escopo determinado, todos os pontos
+								de injeção receberão a mesma instância de <code>EntityManager</code>.
+							</para>
+							<para>
+								Os valores possíveis são:
+								<simplelist type="inline">
+									<member>request</member>
+									<member>session</member>
+									<member>view</member>
+									<member>conversation</member>
+									<member>application</member>
+									<member>noscope</member>
+								</simplelist>
+							</para>
+						</entry>
+						<entry>request</entry>
+					</row>
 				</tbody>
 			</tgroup>
 		</table>
@@ -135,7 +135,7 @@ public class AbacaxiException {
 		<para>
 			Esta estratégia, que está disponível na extensão <literal>demoiselle-jpa</literal>, delega o
 			controle das transações para o <literal>javax.persistence.EntityManager</literal> da
-			especificação JPA. Você deve escolher esta estratégia quando estiver persisteindo dados
+			especificação JPA. Você deve escolher esta estratégia quando estiver persistindo dados
 			com JPA e utilizando apenas uma base de dados em sua aplicação. Como um <literal>EntityManager</literal>
 			acessa apenas uma unidade de persistência, não há como fazer o controle transacional de unidades distintas.
 		</para>
@@ -36,6 +36,7 @@
  */
 package br.gov.frameworkdemoiselle.internal.context;
+import java.io.Serializable;
 import java.lang.annotation.Annotation;
 import java.util.Collections;
 import java.util.HashMap;
@@ -193,38 +194,40 @@ public abstract class AbstractCustomContext implements CustomContext {
 		return true;
 	}
-	static class Store {
+	static class Store implements Serializable {
-		private Map<ClassLoader, Map<Class<?>, Object>> cache = Collections
-				.synchronizedMap(new HashMap<ClassLoader, Map<Class<?>, Object>>());
-
-		private Store() {
-		}
+		private static final long serialVersionUID = -8237464177510563034L;
+		
+		private final String SEPARATOR = "#";
+		
+		private Map<String, Object> cache = Collections.synchronizedMap(new HashMap<String, Object>());
 		private boolean contains(final Class<?> type) {
-			return this.getMap().containsKey(type);
+			return cache.containsKey( prefixId(type) );
 		}
 		private Object get(final Class<?> type) {
-			return this.getMap().get(type);
+			return cache.get( prefixId(type) );
 		}
 		private void put(final Class<?> type, final Object instance) {
-			this.getMap().put(type, instance);
+			cache.put( prefixId(type) , instance);
 		}
 		public void clear() {
 			cache.clear();
 		}
+		
+		private String prefixId(Class<?> type){
+			return Thread.currentThread().getContextClassLoader().toString() + SEPARATOR + type.getCanonicalName();
+		}
-		private Map<Class<?>, Object> getMap() {
-			ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
-
+		/*private Map<String, Object> getMap() {
 			if (!cache.containsKey(classLoader)) {
 				cache.put(classLoader, Collections.synchronizedMap(new HashMap<Class<?>, Object>()));
 			}
 			return cache.get(classLoader);
-		}
+		}*/
 	}
 }
@@ -37,6 +37,9 @@
 package br.gov.frameworkdemoiselle.internal.context;
 import java.lang.annotation.Annotation;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
 import br.gov.frameworkdemoiselle.annotation.Priority;
 import br.gov.frameworkdemoiselle.annotation.StaticScoped;
@@ -58,7 +61,7 @@ import br.gov.frameworkdemoiselle.configuration.Configuration;
 @Priority(Priority.MIN_PRIORITY)
 public abstract class AbstractStaticContext extends AbstractCustomContext {
-	private final static Store store = createStore();
+	private final static Map<String, Store> staticStore = Collections.synchronizedMap(new HashMap<String, Store>());
 	/**
 	 * Constructs this context to control the provided scope
@@ -69,11 +72,17 @@ public abstract class AbstractStaticContext extends AbstractCustomContext {
 	@Override
 	protected Store getStore() {
+		Store store = staticStore.get( this.getClass().getCanonicalName() );
+		if (store==null){
+			store = createStore();
+			staticStore.put(this.getClass().getCanonicalName(), store);
+		}
+		
 		return store;
 	}
 	@Override
 	protected boolean isStoreInitialized() {
-		return store!=null;
+		return staticStore!=null;
 	}
 }
@@ -60,6 +60,7 @@ import javax.enterprise.inject.spi.InjectionPoint;
 import org.slf4j.Logger;
+import br.gov.frameworkdemoiselle.annotation.Priority;
 import br.gov.frameworkdemoiselle.context.ConversationContext;
 import br.gov.frameworkdemoiselle.context.CustomContext;
 import br.gov.frameworkdemoiselle.context.RequestContext;
@@ -133,7 +134,7 @@ public class CustomContextProducer {
 	/////////////PRODUCERS///////////////////
 	@Produces
-	public RequestContext getRequestContext(InjectionPoint ip){
+	protected RequestContext getRequestContext(InjectionPoint ip){
 		if (ip!=null){
 			return getContext(ip);
 		}
@@ -143,7 +144,7 @@ public class CustomContextProducer {
 	}
 	@Produces
-	public SessionContext getSessionContext(InjectionPoint ip){
+	protected SessionContext getSessionContext(InjectionPoint ip){
 		if (ip!=null){
 			return getContext(ip);
 		}
@@ -153,7 +154,7 @@ public class CustomContextProducer {
 	}
 	@Produces
-	public ViewContext getViewContext(InjectionPoint ip){
+	protected ViewContext getViewContext(InjectionPoint ip){
 		if (ip!=null){
 			return getContext(ip);
 		}
@@ -163,7 +164,7 @@ public class CustomContextProducer {
 	}
 	@Produces
-	public StaticContext getStaticContext(InjectionPoint ip){
+	protected StaticContext getStaticContext(InjectionPoint ip){
 		if (ip!=null){
 			return getContext(ip);
 		}
@@ -173,7 +174,7 @@ public class CustomContextProducer {
 	}
 	@Produces
-	public ConversationContext getConversationContext(InjectionPoint ip){
+	protected ConversationContext getConversationContext(InjectionPoint ip){
 		if (ip!=null){
 			return getContext(ip);
 		}
@@ -184,8 +185,17 @@ public class CustomContextProducer {
 	/////////////END OF PRODUCERS///////////////////
+	/**
+	 * Obtain a custom context for the provided injection point.
+	 * 
+	 * @param ip The object containing information about the injection point - most importantly
+	 * the declared type of the injection point, to decide the context to return
+	 * 
+	 * @return A context of a type compatible with the type of the injection point, or <code>null</code> if there is
+	 * no such context.
+	 */
 	@SuppressWarnings("unchecked")
-	private <T extends CustomContext> T getContext(InjectionPoint ip){
+	public <T extends CustomContext> T getContext(InjectionPoint ip){
 		T producedContext = null;
 		if (ip!=null){
@@ -200,8 +210,16 @@ public class CustomContextProducer {
 		return producedContext;
 	}
+	/**
+	 * Obtain a context compatible with the provided type.
+	 * 
+	 * @param contextClass The type of the desired context. The returned context will be compatible with this type, if there
+	 * is more than one compatible type, this method will decide witch one to return based on the {@link Priority} annotation. 
+	 * 
+	 * @return A context of a type compatible with the informed type, or <code>null</code> if there is no such context.
+	 */
 	@SuppressWarnings("unchecked")
-	private <T extends CustomContext> T getContext(Class<T> contextClass){
+	public <T extends CustomContext> T getContext(Class<T> contextClass){
 		CustomContext producedContext = null;
 		ArrayList<CustomContext> selectableContexts = new ArrayList<CustomContext>();
@@ -0,0 +1,25 @@
+package context.staticcontext;
+
+import javax.enterprise.context.ConversationScoped;
+import java.io.Serializable;
+
+@ConversationScoped
+public class ConversationBean implements Serializable {
+	
+	private static final long serialVersionUID = 1L;
+	
+	private String data = "test";
+
+	
+	public String getData() {
+		return data;
+	}
+
+	
+	public void setData(String data) {
+		this.data = data;
+	}
+	
+	
+
+}
@@ -0,0 +1,26 @@
+package context.staticcontext;
+
+import java.io.Serializable;
+
+import javax.enterprise.context.SessionScoped;
+
+@SessionScoped
+public class SessionBean implements Serializable{
+	
+	private static final long serialVersionUID = 1L;
+	
+	private String data = "test";
+
+	
+	public String getData() {
+		return data;
+	}
+
+	
+	public void setData(String data) {
+		this.data = data;
+	}
+	
+	
+
+}
@@ -0,0 +1,88 @@
+/*
+ * Demoiselle Framework
+ * Copyright (C) 2010 SERPRO
+ * ----------------------------------------------------------------------------
+ * This file is part of Demoiselle Framework.
+ * 
+ * Demoiselle Framework is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License version 3
+ * as published by the Free Software Foundation.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License version 3
+ * along with this program; if not,  see <http://www.gnu.org/licenses/>
+ * or write to the Free Software Foundation, Inc., 51 Franklin Street,
+ * Fifth Floor, Boston, MA  02110-1301, USA.
+ * ----------------------------------------------------------------------------
+ * Este arquivo é parte do Framework Demoiselle.
+ * 
+ * O Framework Demoiselle é um software livre; você pode redistribuí-lo e/ou
+ * modificá-lo dentro dos termos da GNU LGPL versão 3 como publicada pela Fundação
+ * do Software Livre (FSF).
+ * 
+ * Este programa é distribuído na esperança que possa ser útil, mas SEM NENHUMA
+ * GARANTIA; sem uma garantia implícita de ADEQUAÇÃO a qualquer MERCADO ou
+ * APLICAÇÃO EM PARTICULAR. Veja a Licença Pública Geral GNU/LGPL em português
+ * para maiores detalhes.
+ * 
+ * Você deve ter recebido uma cópia da GNU LGPL versão 3, sob o título
+ * "LICENCA.txt", junto com esse programa. Se não, acesse <http://www.gnu.org/licenses/>
+ * ou escreva para a Fundação do Software Livre (FSF) Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02111-1301, USA.
+ */
+package context.staticcontext;
+
+import javax.enterprise.inject.spi.Bean;
+
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import br.gov.frameworkdemoiselle.context.ConversationContext;
+import br.gov.frameworkdemoiselle.context.SessionContext;
+import br.gov.frameworkdemoiselle.util.Beans;
+import test.Tests;
+
+@RunWith(Arquillian.class)
+public class StaticContextTest {
+	
+	@Deployment
+	public static JavaArchive createDeployment() {
+		JavaArchive deployment = Tests.createDeployment(StaticContextTest.class);
+		return deployment;
+	}
+	
+	@Test
+	public void checkSeparatedStores(){
+		
+		ConversationContext conversationContext = Beans.getReference(ConversationContext.class);
+		SessionContext sessionContext = Beans.getReference(SessionContext.class);
+		
+		conversationContext.activate();
+		sessionContext.activate();
+		
+		ConversationBean conversationBean = Beans.getReference(ConversationBean.class);
+		conversationBean.getData();
+		
+		SessionBean sessionBean = Beans.getReference(SessionBean.class);
+		sessionBean.getData();
+		
+		Bean<?> conversationContextual = Beans.getBeanManager().getBeans(ConversationBean.class).iterator().next();
+		Bean<?> sessionContextual = Beans.getBeanManager().getBeans(SessionBean.class).iterator().next();
+		
+		Assert.assertNotNull( conversationContext.get(conversationContextual) );
+		Assert.assertNull( conversationContext.get(sessionContextual) );
+		
+		Assert.assertNotNull( sessionContext.get(sessionContextual) );
+		Assert.assertNull( sessionContext.get(conversationContextual) );
+		
+	}
+
+}
@@ -41,13 +41,11 @@ import java.util.HashMap;
 import java.util.Map;
 import javax.enterprise.context.RequestScoped;
-import javax.inject.Inject;
 import javax.persistence.EntityManager;
 import javax.persistence.FlushModeType;
 import org.slf4j.Logger;
-import br.gov.frameworkdemoiselle.annotation.Name;
 import br.gov.frameworkdemoiselle.internal.configuration.EntityManagerConfig;
 import br.gov.frameworkdemoiselle.internal.configuration.EntityManagerConfig.EntityManagerScope;
 import br.gov.frameworkdemoiselle.util.Beans;
@@ -74,19 +72,6 @@ public abstract class AbstractEntityManagerStore implements EntityManagerStore {
 	private final Map<String, EntityManager> cache = Collections.synchronizedMap(new HashMap<String, EntityManager>());
-	@Inject
-	private EntityManagerFactoryProducer factory;
-	
-	@Inject
-	private Logger logger;
-
-	@Inject
-	@Name("demoiselle-jpa-bundle")
-	private ResourceBundle bundle;
-	
-	@Inject
-	private EntityManagerConfig configuration;
-	
 	public EntityManager getEntityManager(String persistenceUnit) {
 		EntityManager entityManager = null;
@@ -114,6 +99,7 @@ public abstract class AbstractEntityManagerStore implements EntityManagerStore {
 		//Se o produtor não possui escopo, então o ciclo de vida
 		//de EntityManager produzidos é responsabilidade do desenvolvedor. Não
 		//fechamos os EntityManagers aqui.
+		EntityManagerConfig configuration = getConfiguration();
 		if (configuration.getEntityManagerScope() != EntityManagerScope.NOSCOPE){
 			for (EntityManager entityManager : cache.values()) {
 				entityManager.close();
@@ -131,23 +117,18 @@ public abstract class AbstractEntityManagerStore implements EntityManagerStore {
 	}
 	private EntityManagerFactoryProducer getFactory(){
-		if (factory==null){
-			factory = Beans.getReference(EntityManagerFactoryProducer.class);
-		}
-		return factory;
+		return Beans.getReference(EntityManagerFactoryProducer.class);
 	}
 	private Logger getLogger(){
-		if (logger==null){
-			logger = Beans.getReference(Logger.class);
-		}
-		return logger;
+		return Beans.getReference(Logger.class);
 	}
 	private ResourceBundle getBundle(){
-		if (bundle==null){
-			bundle = Beans.getReference(ResourceBundle.class , new NameQualifier("demoiselle-jpa-bundle"));
-		}
-		return bundle;
+		return Beans.getReference(ResourceBundle.class , new NameQualifier("demoiselle-jpa-bundle"));
+	}
+	
+	private EntityManagerConfig getConfiguration(){
+		return Beans.getReference(EntityManagerConfig.class);
 	}
 }
@@ -117,8 +117,8 @@ public class EntityManagerProxy implements EntityManager, Serializable {
 	@Override
 	public void persist(Object entity) {
 		joinTransactionIfNecessary();
-		checkEntityManagerScopePassivable(entity);
 		getEntityManagerDelegate().persist(entity);
+		checkEntityManagerScopePassivable(entity);
 	}
 	/*
	@@ -277,6 +277,41 @@ ALUNO_EXCLUIR_OK=L'étudiant {0} a été supprimé avec succès]]></programlisti		@@ -277,6 +277,41 @@ ALUNO_EXCLUIR_OK=L'étudiant {0} a été supprimé avec succès]]></programlisti
277	</para>	277	</para>
278	</note>	278	</note>
279	</section>	279	</section>
		280	+
		281	+ <section>
		282	+ <title>Destino das mensagens</title>
		283	+
		284	+ <para>
		285	+ O Framework Demoiselle permite configurar o destino das mensagens enviadas. Por padrão, mensagens enviadas em um ambiente SE (Swing por exemplo)
		286	+ são exibidas como registros de log no console, já mensagens enviadas em um ambiente WEB usando JSF 2.0 são redirecionadas para a classe
		287	+ <code>FacesContext</code>. Caso esse comportamento padrão não seja suficiente para você, é possível personalizar o mecanismo de redirecionamento
		288	+ de mensagens, fazendo-o enviar as mensagens para um local de seu interesse.
		289	+ </para>
		290	+
		291	+ <para>
		292	+ Para isso existe a interface <code>MessageAppender</code>. Para toda mensagem enviada, o Framework Demoiselle vai determinar a implementação
		293	+ mais adequada de <code>MessageAppender</code> a utilizar e vai redirecionar qualquer mensagem para essa implementação.
		294	+ </para>
		295	+
		296	+ <programlisting role="JAVA">public interface MessageAppender extends Serializable {
		297	+
		298	+ /**
		299	+ * Method that must hold message in an appropriate way and in an appropriate local.
		300	+ * Demoiselle holds a message in a Logger or in a FacesContext, depending on the project.
		301	+ *
		302	+ * @param message
		303	+ * message to be stored.
		304	+ */
		305	+ void append(Message message);
		306	+}</programlisting>
		307	+
		308	+ <para>
		309	+ Para criar seu próprio <code>MessageAppender</code>, implemente essa interface e anote-a com a anotação <code>@Priority</code> - o Framework
		310	+ Demoiselle irá selecionar a implementação adequada paseada na maior prioridade. Não é necessário configurar mais nada, o Framework Demoiselle
		311	+ selecionará a implementação automaticamente. Cabe-lhe então a tarefa de implementar o método <code>append(Message message)</code> para tratar
		312	+ a mensagem da forma que melhor se adequar a seu projeto.
		313	+ </para>
		314	+ </section>
280		315
281	<section>	316	<section>
282	<title>Exemplos de implementação</title>	317	<title>Exemplos de implementação</title>
	@@ -18,6 +18,181 @@		@@ -18,6 +18,181 @@
18	é apenas injetar o recurso adequado em seu código e o Framework Demoiselle se encarregará de	18	é apenas injetar o recurso adequado em seu código e o Framework Demoiselle se encarregará de
19	produzi-lo e configurá-lo.	19	produzi-lo e configurá-lo.
20	</para>	20	</para>
		21	+
		22	+ <section>
		23	+ <title>JPA</title>
		24	+
		25	+ <para>
		26	+ O Framework Demoiselle fornece um produtor padrão para contextos de persistência da JPA. Esse produtor lê o arquivo
		27	+ de configuração <code>persistence.xml</code> de seu projeto e toma as providências necessárias para fabricar uma instância
		28	+ da classe <code>EntityManager</code> que pode ser usada para gerenciar as entidades de sua aplicação. Além disso, instâncias
		29	+ de <code>EntityManager</code> produzidas pelo Framework Demoiselle participam automaticamente de transações abertas através da
		30	+ anotação <code>@Transactional</code>, conforme apresentado no capítulo sobre <link linkend="transacao">Transações</link>.
		31	+ </para>
		32	+
		33	+ <tip>
		34	+ <para>
		35	+ Para acrescentar a dependência à extensão <literal>demoiselle-jpa</literal>, adicione esse código
		36	+ em seu arquivo <literal>pom.xml</literal>, na seção <literal>dependencies</literal>.
		37	+ </para>
		38	+
		39	+ <programlisting role="XML"><![CDATA[<dependency>
		40	+ <groupId>br.gov.frameworkdemoiselle</groupId>
		41	+ <artifactId>demoiselle-jpa</artifactId>
		42	+ <scope>compile</scope>
		43	+</dependency>]]></programlisting>
		44	+ </tip>
		45	+
		46	+ <section>
		47	+ <title>Introdução ao mecanismo</title>
		48	+
		49	+ <para>
		50	+ Para injetar uma instância de <code>EntityManager</code> em sua aplicação, basta usar a anotação <code>@Inject</code>.
		51	+ </para>
		52	+
		53	+ <programlisting role="JAVA">@PersistenceController
		54	+public class BookmarkDAO extends JPACrud<Bookmark, Long> {
		55	+
		56	+ private static final long serialVersionUID = 1L;
		57	+
		58	+ @Inject
		59	+ private EntityManager entityManager;
		60	+
		61	+ public void persistBookmark(Bookmark bookmark){
		62	+ entityManager.persist(bookmark);
		63	+ }
		64	+
		65	+}</programlisting>
		66	+
		67	+ <para>
		68	+ O produtor padrão injetará o <code>EntityManager</code> configurado no arquivo <code>persistence.xml</code>. Se houver
		69	+ mais de um contexto de persistência configurado em <code>persistence.xml</code>, será necessário especificar qual será
		70	+ injetado no ponto de injeção. Para isso use a anotação <code>@Name</code>.
		71	+ </para>
		72	+
		73	+ <programlisting role="JAVA">@PersistenceController
		74	+public class BookmarkDAO extends JPACrud<Bookmark, Long> {
		75	+
		76	+ private static final long serialVersionUID = 1L;
		77	+
		78	+ @Inject
		79	+ @Name("persistence_unit_1")
		80	+ private EntityManager entityManager;
		81	+
		82	+ public void persistBookmark(Bookmark bookmark){
		83	+ entityManager.persist(bookmark);
		84	+ }
		85	+
		86	+}</programlisting>
		87	+
		88	+ <para>
		89	+ É possível invocar o utilitário <code>Beans</code> para injetar instâncias de <code>EntityManager</code> programaticamente.
		90	+ </para>
		91	+
		92	+ <programlisting role="JAVA">@PersistenceController
		93	+public class BookmarkDAO extends JPACrud<Bookmark, Long> {
		94	+
		95	+ private static final long serialVersionUID = 1L;
		96	+
		97	+ public void persistBookmark(Bookmark bookmark){
		98	+ EntityManager entityManager = Beans.getReference(EntityManager.class);
		99	+ entityManager.persist(bookmark);
		100	+ }
		101	+
		102	+ public void persistBookmarkInHistory(Bookmark bookmark){
		103	+ EntityManager entityManager = Beans.getReference(EntityManager.class , new NameQualifier("history_persistence_unit"));
		104	+ entityManager.persist(bookmark);
		105	+ }
		106	+
		107	+}</programlisting>
		108	+ </section>
		109	+
		110	+ <section>
		111	+ <title>Configuração</title>
		112	+
		113	+ <para>
		114	+ Alguns comportamentos do produtor podem ser configurados através das propriedades abaixo, que devem ser configuradas
		115	+ no arquivo <code>demoiselle.properties</code>.
		116	+ </para>
		117	+
		118	+ <informaltable width="100%">
		119	+ <tgroup cols="3">
		120	+ <colspec align="left"/>
		121	+ <colspec align="left"/>
		122	+ <colspec align="right"/>
		123	+
		124	+ <thead>
		125	+ <row valign="top">
		126	+ <entry><emphasis role="bold">Propriedade</emphasis></entry>
		127	+ <entry><emphasis role="bold">Descrição</emphasis></entry>
		128	+ <entry><emphasis role="bold">Padrão</emphasis></entry>
		129	+ </row>
		130	+ </thead>
		131	+
		132	+ <tbody>
		133	+ <row valign="top">
		134	+ <entry>frameworkdemoiselle.persistence.default.unit.name</entry>
		135	+ <entry>
		136	+ <para>
		137	+ Define o nome da unidade de persistência padrão (configurada em <code>persistence.xml</code>) que será injetada
		138	+ caso a anotação <code>@Name</code> não seja usada. Não é necessário se apenas uma unidade de persistência for configurada.
		139	+ </para>
		140	+ </entry>
		141	+ <entry></entry>
		142	+ </row>
		143	+
		144	+ <row valign="top">
		145	+ <entry>frameworkdemoiselle.persistence.entitymanager.scope</entry>
		146	+ <entry>
		147	+ <para>
		148	+ Permite determinar o escopo de unidades de persistência injetadas. Dentro do escopo determinado, todos os pontos
		149	+ de injeção receberão a mesma instância de <code>EntityManager</code>.
		150	+ </para>
		151	+ <para>
		152	+ Os valores possíveis são:
		153	+ <simplelist type="inline">
		154	+ <member>request</member>
		155	+ <member>session</member>
		156	+ <member>view</member>
		157	+ <member>conversation</member>
		158	+ <member>application</member>
		159	+ <member>noscope</member>
		160	+ </simplelist>
		161	+ </para>
		162	+ </entry>
		163	+ <entry>request</entry>
		164	+ </row>
		165	+ </tbody>
		166	+ </tgroup>
		167	+ </informaltable>
		168	+
		169	+ <tip>
		170	+ <para>
		171	+ O escopo especial <emphasis>noscope</emphasis> desliga o gerenciamento de escopo de instâncias de <code>EntityManager</code>
		172	+ produzidas pelo Framework Demoiselle. Isso permite ao desenvolvedor controlar totalmente o ciclo de vida de um
		173	+ <code>EntityManager</code> injetado e ainda reter o recurso do produtor padrão.
		174	+ </para>
		175	+ <para>
		176	+ Note que ao usar a opção <emphasis>noscope</emphasis>, o desenvolvedor é o responsável por controlar o ciclo de vida do gerenciador
		177	+ de persistência. Ele não participará de transações JPA abertas através da anotação <code>@Transactional</code> (transações JTA funcionam normalmente)
		178	+ e multiplos pontos de injeção durante uma requisição receberão múltiplas instâncias de <code>EntityManager</code>.
		179	+ </para>
		180	+ </tip>
		181	+
		182	+ <caution>
		183	+ <para>
		184	+ Deve-se usar cautela ao alterar o escopo padrão das instâncias de <code>EntityManager</code>. Na grande maioria dos casos o escopo
		185	+ padrão <emphasis>request</emphasis> é o suficiente e alterar esse padrão deve ser feito apenas após extensa análise dos prós e contras
		186	+ de cada escopo.
		187	+ </para>
		188	+ <para>
		189	+ Dê especial atenção aos escopos que podem ser serializados pelo servidor de aplicação (<emphasis>session</emphasis>, <emphasis>view</emphasis>
		190	+ e <emphasis>conversation</emphasis>) pois a especificação não define o comportamento de instâncias de <code>EntityManager</code> que são
		191	+ serializadas.
		192	+ </para>
		193	+ </caution>
		194	+ </section>
		195	+ </section>
21		196
22	<section>	197	<section>
23		198
	@@ -251,12 +251,34 @@		@@ -251,12 +251,34 @@
251	<entry>frameworkdemoiselle.persistence.default.unit.name</entry>	251	<entry>frameworkdemoiselle.persistence.default.unit.name</entry>
252	<entry>	252	<entry>
253	<para>	253	<para>
254	- Define a unidade de persistência padrão para aplicações que possuem mais
255	- de um persistence-unit definido no arquivo persistence.xml.	254	+ Define o nome da unidade de persistência padrão (configurada em <code>persistence.xml</code>) que será injetada
		255	+ caso a anotação <code>@Name</code> não seja usada. Não é necessário se apenas uma unidade de persistência for configurada.
256	</para>	256	</para>
257	</entry>	257	</entry>
258	<entry></entry>	258	<entry></entry>
259	</row>	259	</row>
		260	+
		261	+ <row valign="top">
		262	+ <entry>frameworkdemoiselle.persistence.entitymanager.scope</entry>
		263	+ <entry>
		264	+ <para>
		265	+ Permite determinar o escopo de unidades de persistência injetadas. Dentro do escopo determinado, todos os pontos
		266	+ de injeção receberão a mesma instância de <code>EntityManager</code>.
		267	+ </para>
		268	+ <para>
		269	+ Os valores possíveis são:
		270	+ <simplelist type="inline">
		271	+ <member>request</member>
		272	+ <member>session</member>
		273	+ <member>view</member>
		274	+ <member>conversation</member>
		275	+ <member>application</member>
		276	+ <member>noscope</member>
		277	+ </simplelist>
		278	+ </para>
		279	+ </entry>
		280	+ <entry>request</entry>
		281	+ </row>
260	</tbody>	282	</tbody>
261	</tgroup>	283	</tgroup>
262	</table>	284	</table>
	@@ -135,7 +135,7 @@ public class AbacaxiException {		@@ -135,7 +135,7 @@ public class AbacaxiException {
135	<para>	135	<para>
136	Esta estratégia, que está disponível na extensão <literal>demoiselle-jpa</literal>, delega o	136	Esta estratégia, que está disponível na extensão <literal>demoiselle-jpa</literal>, delega o
137	controle das transações para o <literal>javax.persistence.EntityManager</literal> da	137	controle das transações para o <literal>javax.persistence.EntityManager</literal> da
138	- especificação JPA. Você deve escolher esta estratégia quando estiver persisteindo dados	138	+ especificação JPA. Você deve escolher esta estratégia quando estiver persistindo dados
139	com JPA e utilizando apenas uma base de dados em sua aplicação. Como um <literal>EntityManager</literal>	139	com JPA e utilizando apenas uma base de dados em sua aplicação. Como um <literal>EntityManager</literal>
140	acessa apenas uma unidade de persistência, não há como fazer o controle transacional de unidades distintas.	140	acessa apenas uma unidade de persistência, não há como fazer o controle transacional de unidades distintas.
141	</para>	141	</para>
@@ -0,0 +1,25 @@		@@ -0,0 +1,25 @@
	1	+package context.staticcontext;
	2	+
	3	+import javax.enterprise.context.ConversationScoped;
	4	+import java.io.Serializable;
	5	+
	6	+@ConversationScoped
	7	+public class ConversationBean implements Serializable {
	8	+
	9	+ private static final long serialVersionUID = 1L;
	10	+
	11	+ private String data = "test";
	12	+
	13	+
	14	+ public String getData() {
	15	+ return data;
	16	+ }
	17	+
	18	+
	19	+ public void setData(String data) {
	20	+ this.data = data;
	21	+ }
	22	+
	23	+
	24	+
	25	+}
@@ -0,0 +1,26 @@		@@ -0,0 +1,26 @@
	1	+package context.staticcontext;
	2	+
	3	+import java.io.Serializable;
	4	+
	5	+import javax.enterprise.context.SessionScoped;
	6	+
	7	+@SessionScoped
	8	+public class SessionBean implements Serializable{
	9	+
	10	+ private static final long serialVersionUID = 1L;
	11	+
	12	+ private String data = "test";
	13	+
	14	+
	15	+ public String getData() {
	16	+ return data;
	17	+ }
	18	+
	19	+
	20	+ public void setData(String data) {
	21	+ this.data = data;
	22	+ }
	23	+
	24	+
	25	+
	26	+}
@@ -0,0 +1,88 @@		@@ -0,0 +1,88 @@
	1	+/*
	2	+ * Demoiselle Framework
	3	+ * Copyright (C) 2010 SERPRO
	4	+ * ----------------------------------------------------------------------------
	5	+ * This file is part of Demoiselle Framework.
	6	+ *
	7	+ * Demoiselle Framework is free software; you can redistribute it and/or
	8	+ * modify it under the terms of the GNU Lesser General Public License version 3
	9	+ * as published by the Free Software Foundation.
	10	+ *
	11	+ * This program is distributed in the hope that it will be useful,
	12	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	+ * GNU General Public License for more details.
	15	+ *
	16	+ * You should have received a copy of the GNU Lesser General Public License version 3
	17	+ * along with this program; if not, see <http://www.gnu.org/licenses/>
	18	+ * or write to the Free Software Foundation, Inc., 51 Franklin Street,
	19	+ * Fifth Floor, Boston, MA 02110-1301, USA.
	20	+ * ----------------------------------------------------------------------------
	21	+ * Este arquivo é parte do Framework Demoiselle.
	22	+ *
	23	+ * O Framework Demoiselle é um software livre; você pode redistribuí-lo e/ou
	24	+ * modificá-lo dentro dos termos da GNU LGPL versão 3 como publicada pela Fundação
	25	+ * do Software Livre (FSF).
	26	+ *
	27	+ * Este programa é distribuído na esperança que possa ser útil, mas SEM NENHUMA
	28	+ * GARANTIA; sem uma garantia implícita de ADEQUAÇÃO a qualquer MERCADO ou
	29	+ * APLICAÇÃO EM PARTICULAR. Veja a Licença Pública Geral GNU/LGPL em português
	30	+ * para maiores detalhes.
	31	+ *
	32	+ * Você deve ter recebido uma cópia da GNU LGPL versão 3, sob o título
	33	+ * "LICENCA.txt", junto com esse programa. Se não, acesse <http://www.gnu.org/licenses/>
	34	+ * ou escreva para a Fundação do Software Livre (FSF) Inc.,
	35	+ * 51 Franklin St, Fifth Floor, Boston, MA 02111-1301, USA.
	36	+ */
	37	+package context.staticcontext;
	38	+
	39	+import javax.enterprise.inject.spi.Bean;
	40	+
	41	+import org.jboss.arquillian.container.test.api.Deployment;
	42	+import org.jboss.arquillian.junit.Arquillian;
	43	+import org.jboss.shrinkwrap.api.spec.JavaArchive;
	44	+import org.junit.Assert;
	45	+import org.junit.Test;
	46	+import org.junit.runner.RunWith;
	47	+
	48	+import br.gov.frameworkdemoiselle.context.ConversationContext;
	49	+import br.gov.frameworkdemoiselle.context.SessionContext;
	50	+import br.gov.frameworkdemoiselle.util.Beans;
	51	+import test.Tests;
	52	+
	53	+@RunWith(Arquillian.class)
	54	+public class StaticContextTest {
	55	+
	56	+ @Deployment
	57	+ public static JavaArchive createDeployment() {
	58	+ JavaArchive deployment = Tests.createDeployment(StaticContextTest.class);
	59	+ return deployment;
	60	+ }
	61	+
	62	+ @Test
	63	+ public void checkSeparatedStores(){
	64	+
	65	+ ConversationContext conversationContext = Beans.getReference(ConversationContext.class);
	66	+ SessionContext sessionContext = Beans.getReference(SessionContext.class);
	67	+
	68	+ conversationContext.activate();
	69	+ sessionContext.activate();
	70	+
	71	+ ConversationBean conversationBean = Beans.getReference(ConversationBean.class);
	72	+ conversationBean.getData();
	73	+
	74	+ SessionBean sessionBean = Beans.getReference(SessionBean.class);
	75	+ sessionBean.getData();
	76	+
	77	+ Bean<?> conversationContextual = Beans.getBeanManager().getBeans(ConversationBean.class).iterator().next();
	78	+ Bean<?> sessionContextual = Beans.getBeanManager().getBeans(SessionBean.class).iterator().next();
	79	+
	80	+ Assert.assertNotNull( conversationContext.get(conversationContextual) );
	81	+ Assert.assertNull( conversationContext.get(sessionContextual) );
	82	+
	83	+ Assert.assertNotNull( sessionContext.get(sessionContextual) );
	84	+ Assert.assertNull( sessionContext.get(conversationContextual) );
	85	+
	86	+ }
	87	+
	88	+}