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

Emerson Oliveira
2 parents f6e5ee17 3594c092
Showing 44 changed files with 2334 additions and 1282 deletions Show diff stats
impl/core/pom.xml
impl/core/src/main/java/br/gov/frameworkdemoiselle/annotation/ManagedOperation.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/annotation/ManagedProperty.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/annotation/OperationParameter.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/annotation/OperationType.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/internal/bootstrap/ManagementBootstrap.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/internal/context/ManagedContext.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/internal/management/ManagedType.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/internal/management/Management.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/internal/management/ManagementNotificationEvent.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/internal/management/qualifier/AttributeChange.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/internal/management/qualifier/Generic.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/lifecycle/ManagementExtension.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/management/AttributeChangeNotification.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/management/Notification.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/management/NotificationManager.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/management/annotation/Managed.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/management/annotation/Operation.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/management/annotation/OperationParameter.java
impl/core/src/main/java/br/gov/frameworkdemoiselle/management/annotation/OperationType.java
@@ -77,15 +77,6 @@
 				<scope>import</scope>
 				<type>pom</type>
 			</dependency>
-			<!--
-			<dependency>
-				<groupId>org.jboss.arquillian</groupId>
-				<artifactId>arquillian-bom</artifactId>
-				<version>${arquillian.version}</version>
-				<scope>import</scope>
-				<type>pom</type>
-			</dependency>
-			-->
 		</dependencies>
 	</dependencyManagement>
@@ -248,6 +239,13 @@
 			<artifactId>slf4j-log4j12</artifactId>
 			<scope>test</scope>
 		</dependency>
+		
+		<dependency>
+			<groupId>br.gov.frameworkdemoiselle.component</groupId>
+			<artifactId>demoiselle-validation</artifactId>
+			<scope>test</scope>
+			<version>${demoiselle.validation.version}</version>
+		</dependency>
 	</dependencies>
 	<repositories>
@@ -279,5 +277,6 @@
 		<!--
 		<jacoco.version>0.6.0.201210061924</jacoco.version>
 		-->
+		<demoiselle.validation.version>2.4.0-BETA2-SNAPSHOT</demoiselle.validation.version>
 	</properties>
 </project>
@@ -0,0 +1,74 @@
+/*
+ * 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 br.gov.frameworkdemoiselle.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import javax.enterprise.util.Nonbinding;
+
+import br.gov.frameworkdemoiselle.DemoiselleException;
+
+/**
+ * <p>Indicates that a method is a <b>managed operation</b>, meaning you can manage some aspect of the application by calling it from a external management client.</p>
+ * <p>This annotation can't be used together with {@link ManagedProperty}, doing so will throw a {@link DemoiselleException}.</p>  
+ * 
+ * @author SERPRO
+ *
+ */
+@Documented
+@Target({ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ManagedOperation {
+	
+	/**
+	 * Description that will be used to publish the operation to clients.
+	 * Defaults to an empty description.
+	 */
+	@Nonbinding
+	String description() default "";
+	
+	/**
+	 * Type of operation. Defaults to {@link OperationType#UNKNOWN}.
+	 */
+	@Nonbinding
+	OperationType type() default OperationType.UNKNOWN;
+
+}
@@ -0,0 +1,69 @@
+/*
+ * 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 br.gov.frameworkdemoiselle.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import javax.enterprise.util.Nonbinding;
+
+/**
+ * <p>Indicates that a field must be exposed as a property to management clients.</p>
+ * <p>The property will be writable if there's a public setter method
+ * declared for the field and readable if there's a getter method.</p>
+ * <p>It's a runtime error to annotate a field with no getter and no setter method.</p>
+ * <p>It's also a runtime error to declare a field as a property and one or both of it's getter and setter
+ * methods as an operation using the {@link ManagedOperation} annotation.</p> 
+ * 
+ * @author SERPRO
+ *
+ */
+@Documented
+@Target({ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ManagedProperty {
+	
+	/**
+	 * @return The description of this property exposed to management clients.
+	 */
+	@Nonbinding
+	String description() default "";
+
+}
@@ -0,0 +1,73 @@
+/*
+ * 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 br.gov.frameworkdemoiselle.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import javax.enterprise.util.Nonbinding;
+
+/**
+ * <p>Optional annotation to write additional detail about an operation's parameter.</p>
+ * <p>This annotation is ignored for non-operation methods.</p>  
+ * 
+ * @author SERPRO
+ *
+ */
+@Documented
+@Target({ElementType.PARAMETER})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface OperationParameter {
+	
+	/**
+	 * Name that will be used to publish this operation's parameter to clients.
+	 */
+	@Nonbinding
+	String name();
+	
+	/**
+	 * Optional description that will be used to publish this operation's parameter to clients.
+	 * Defaults to an empty description.
+	 */
+	@Nonbinding
+	String description() default "";
+	
+
+}
@@ -0,0 +1,89 @@
+/*
+ * 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 br.gov.frameworkdemoiselle.annotation;
+
+import javax.management.MBeanOperationInfo;
+
+
+/**
+ * <p>Define the operation type for an operation inside a ManagementController class.</p>
+ * 
+ * <p>This is an optional annotation and it's significanse will change based on the management extension
+ * used. Most extensions will just publish this information to the client so it can better show to the user the inner
+ * workings of the annotated operation.</p>
+ * 
+ * 
+ * @author SERPRO
+ *
+ */
+public enum OperationType {
+	
+	/**
+	 * ManagedOperation is write-only, it causes the application
+	 * to change some of it's behaviour but doesn't return any kind of information
+	 */
+	ACTION(MBeanOperationInfo.ACTION)
+	,
+	/**
+	 * ManagedOperation is read-only, it will operate over data provided by the application and return some information,
+	 * but will not change the application in any way.
+	 */
+	INFO(MBeanOperationInfo.INFO)
+	,
+	/**
+	 * ManagedOperation is read-write, it will both change the way the application work and return some information regarding
+	 * the result of the operation.
+	 */
+	ACTION_INFO(MBeanOperationInfo.ACTION_INFO)
+	,
+	/**
+	 * The effect of calling this operation is unknown. This is the default type and if this type is assigned to an operation,
+	 * the user must rely on the {@link ManagedOperation#description()} attribute to learn about how the operation works.
+	 */
+	UNKNOWN(MBeanOperationInfo.UNKNOWN);
+	
+	private int operationTypeValue;
+	
+	private OperationType(int type){
+		this.operationTypeValue = type;
+	}
+	
+	public int getValue(){
+		return operationTypeValue;
+	}
+	
+}
@@ -17,10 +17,10 @@ import javax.enterprise.inject.spi.ProcessAnnotatedType;
 import br.gov.frameworkdemoiselle.internal.context.ContextManager;
 import br.gov.frameworkdemoiselle.internal.context.ManagedContext;
-import br.gov.frameworkdemoiselle.management.annotation.Managed;
-import br.gov.frameworkdemoiselle.management.extension.ManagementExtension;
-import br.gov.frameworkdemoiselle.management.internal.ManagedType;
-import br.gov.frameworkdemoiselle.management.internal.MonitoringManager;
+import br.gov.frameworkdemoiselle.internal.management.ManagedType;
+import br.gov.frameworkdemoiselle.internal.management.Management;
+import br.gov.frameworkdemoiselle.lifecycle.ManagementExtension;
+import br.gov.frameworkdemoiselle.stereotype.ManagementController;
 import br.gov.frameworkdemoiselle.util.Beans;
 public class ManagementBootstrap implements Extension {
@@ -31,7 +31,7 @@ public class ManagementBootstrap implements Extension {
 	public <T> void detectAnnotation(@Observes final ProcessAnnotatedType<T> event, final BeanManager beanManager) {
-		if (event.getAnnotatedType().isAnnotationPresent(Managed.class)) {
+		if (event.getAnnotatedType().isAnnotationPresent(ManagementController.class)) {
 			types.add(event.getAnnotatedType());
 		}
 	}
@@ -43,7 +43,7 @@ public class ManagementBootstrap implements Extension {
 	@SuppressWarnings("unchecked")
 	public void registerAvailableManagedTypes(@Observes final AfterDeploymentValidation event,BeanManager beanManager) {
-		MonitoringManager monitoringManager = Beans.getReference(MonitoringManager.class);
+		Management monitoringManager = Beans.getReference(Management.class);
 		for (AnnotatedType<?> type : types) {
 			ManagedType managedType = new ManagedType(type.getJavaClass());
 			monitoringManager.addManagedType(managedType);
@@ -62,7 +62,7 @@ public class ManagementBootstrap implements Extension {
 	public void unregisterAvailableManagedTypes(@Observes final BeforeShutdown event) {
-		MonitoringManager manager = Beans.getReference(MonitoringManager.class);
+		Management manager = Beans.getReference(Management.class);
 		manager.shutdown(managementExtensionCache);
 		managementExtensionCache.clear();
@@ -2,10 +2,10 @@ package br.gov.frameworkdemoiselle.internal.context;
 import javax.enterprise.context.RequestScoped;
-import br.gov.frameworkdemoiselle.management.annotation.Managed;
+import br.gov.frameworkdemoiselle.stereotype.ManagementController;
 /**
- * Context that stores {@link RequestScoped} beans during client calls to {@link Managed} classes.
+ * Context that stores {@link RequestScoped} beans during client calls to {@link ManagementController} classes.
  * This context is only activated when no other context is active for {@link RequestScoped}.
  * 
  * @author serpro
@@ -0,0 +1,334 @@
+/*
+ * 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 br.gov.frameworkdemoiselle.internal.management;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.TreeMap;
+
+import br.gov.frameworkdemoiselle.DemoiselleException;
+import br.gov.frameworkdemoiselle.annotation.ManagedOperation;
+import br.gov.frameworkdemoiselle.annotation.ManagedProperty;
+import br.gov.frameworkdemoiselle.annotation.OperationParameter;
+import br.gov.frameworkdemoiselle.internal.producer.ResourceBundleProducer;
+import br.gov.frameworkdemoiselle.stereotype.ManagementController;
+import br.gov.frameworkdemoiselle.util.ResourceBundle;
+
+/**
+ * <p>Package class containing information about a discovered {@link ManagementController}.</p>
+ * 
+ * <p>Instances if this class are passed to each discovered management extension during bootstrap so they can have
+ * enough information to expose all discovered {@link ManagementController}'s to management clients.</p>
+ * 
+ * @author serpro
+ */
+public class ManagedType {
+
+	private Class<?> type;
+
+	private TreeMap<String, FieldDetail> fields;
+
+	private TreeMap<String, MethodDetail> operationMethods;
+
+	private ResourceBundle bundle;
+
+	private String description;
+
+	public ManagedType(Class<?> type) {
+		bundle = ResourceBundleProducer.create("demoiselle-core-bundle");
+
+		if (type == null) {
+			throw new DemoiselleException(bundle.getString("management-null-class-defined"));
+		}
+		if (!type.isAnnotationPresent(ManagementController.class)) {
+			throw new DemoiselleException(bundle.getString("management-no-annotation-found", type.getCanonicalName()));
+		}
+
+		this.type = type;
+		fields = new TreeMap<String, FieldDetail>();
+		operationMethods = new TreeMap<String, MethodDetail>();
+		this.description = type.getAnnotation(ManagementController.class).description();
+
+		initialize();
+	}
+
+	public Class<?> getType() {
+		return type;
+	}
+
+	public String getDescription() {
+		return description;
+	}
+
+	public TreeMap<String, FieldDetail> getFields() {
+		return fields;
+	}
+
+	public TreeMap<String, MethodDetail> getOperationMethods() {
+		return operationMethods;
+	}
+
+	private void initialize() {
+		// Para cada atributo verifica se ele está anotado com ManagedProperty e extrai as informações dele (método get, set e
+		// descrição do atributo).
+		Field[] fields = type.getDeclaredFields();
+		if (fields != null) {
+			for (Field field : fields) {
+				if (field.isAnnotationPresent(ManagedProperty.class)) {
+					// Obtém os métodos GET e SET para esta propriedade
+					Method getterMethod = getGetterMethod(field);
+					Method setterMethod = getSetterMethod(field);
+					if (getterMethod == null && setterMethod == null) {
+						throw new DemoiselleException(bundle.getString("management-invalid-property-no-getter-setter",
+								type.getSimpleName(), field.getName()));
+					} else if ((getterMethod != null && getterMethod.isAnnotationPresent(ManagedOperation.class))
+							|| (setterMethod != null && setterMethod.isAnnotationPresent(ManagedOperation.class))) {
+						throw new DemoiselleException(bundle.getString("management-invalid-property-as-operation",
+								type.getSimpleName()));
+					}
+
+					String propertyDescription = field.getAnnotation(ManagedProperty.class).description();
+
+					this.fields.put(field.getName(), new FieldDetail(field, propertyDescription, getterMethod,
+							setterMethod));
+				}
+			}
+		}
+
+		// Para cada metodo verifica se ele está anotado com ManagedOperation e cria um MBeanOperationInfo para ele.
+		Method[] methodList = type.getMethods();
+		if (methodList != null) {
+			for (Method method : methodList) {
+				ManagedOperation opAnnotation = method.getAnnotation(ManagedOperation.class);
+
+				if (opAnnotation != null) {
+					// Lemos as informações sobre o método e criamos uma instância
+					// de MethodDetail para representar este método como uma
+					// operação.
+
+					Class<?>[] parameterTypes = method.getParameterTypes();
+					Annotation[][] parameterAnnotations = method.getParameterAnnotations();
+					ParameterDetail[] parameterDetails = new ParameterDetail[parameterTypes.length];
+
+					for (int i = 0; i < parameterTypes.length; i++) {
+						OperationParameter paramAnnotation = null;
+						for (Annotation annotation : parameterAnnotations[i]) {
+							if (annotation.annotationType() == OperationParameter.class) {
+								paramAnnotation = (OperationParameter) annotation;
+								break;
+							}
+						}
+
+						String name = paramAnnotation != null ? paramAnnotation.name() : ("arg" + i);
+						String description = paramAnnotation != null ? paramAnnotation.description() : null;
+
+						parameterDetails[i] = new ParameterDetail(parameterTypes[i], name, description);
+					}
+
+					// Com todas as informações, criamos nossa instância de MethodDetail e
+					// acrescentamos na lista de todas as operações.
+					MethodDetail detail = new MethodDetail(method, opAnnotation.description(), parameterDetails);
+					operationMethods.put(method.getName(), detail);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Returns the public getter method for a given field, or <code>null</code> if no getter method can be found.
+	 */
+	private Method getGetterMethod(Field field) {
+		StringBuffer getterMethodName = new StringBuffer()
+			.append("get")
+			.append(field.getName().substring(0, 1).toUpperCase())
+			.append(field.getName().substring(1));
+
+		Method getterMethod;
+
+		try {
+			getterMethod = type.getMethod(getterMethodName.toString());
+		} catch (Exception e) {
+			getterMethod = null;
+		}
+
+		// Se atributo for boolean, procura método getter no formato "isAttribute".
+		if (getterMethod == null
+				&& (Boolean.TYPE.isAssignableFrom(field.getType()) || Boolean.class.isAssignableFrom(field.getType()))) {
+			// Boolean.TYPE representa o tipo primitivo "boolean", Boolean.class é a classe wrapper.
+			getterMethodName = new StringBuffer()
+				.append("is")
+				.append(field.getName().substring(0, 1).toUpperCase())
+				.append(field.getName().substring(1).toUpperCase());
+
+			try {
+				getterMethod = type.getMethod(getterMethodName.toString());
+			} catch (Exception e) {
+				getterMethod = null;
+			}
+		}
+
+		return getterMethod;
+	}
+
+	/**
+	 * Returns the public setter method for a given field, or <code>null</code> if no setter method can be found.
+	 */
+	private Method getSetterMethod(Field field) {
+		StringBuffer setterMethodName = new StringBuffer()
+			.append("set")
+			.append(field.getName().substring(0, 1).toUpperCase())
+			.append(field.getName().substring(1));
+
+		Method setterMethod;
+
+		try {
+			setterMethod = type.getMethod(setterMethodName.toString() , field.getType());
+		} catch (Exception e) {
+			setterMethod = null;
+		}
+
+		return setterMethod;
+	}
+
+	public final class FieldDetail {
+
+		private final Field field;
+
+		private final String description;
+
+		private Method getterMethod;
+
+		private Method setterMethod;
+
+		public FieldDetail(Field field, String description, Method getterMethod, Method setterMethod) {
+			super();
+			this.field = field;
+			this.description = description;
+			this.getterMethod = getterMethod;
+			this.setterMethod = setterMethod;
+		}
+
+		public Field getField() {
+			return field;
+		}
+
+		public String getDescription() {
+			return description;
+		}
+
+		public Method getGetterMethod() {
+			return getterMethod;
+		}
+
+		public Method getSetterMethod() {
+			return setterMethod;
+		}
+
+	}
+
+	public final class MethodDetail {
+
+		private final Method method;
+
+		private final ParameterDetail[] parameterTypers;
+
+		private String description;
+
+		public MethodDetail(Method method, String description, ParameterDetail[] parameterTypers) {
+			super();
+			this.method = method;
+			this.description = description;
+			this.parameterTypers = parameterTypers;
+		}
+
+		public Method getMethod() {
+			return method;
+		}
+
+		public ParameterDetail[] getParameterTypers() {
+			return parameterTypers;
+		}
+
+		public String getDescription() {
+			return description;
+		}
+
+	}
+
+	public final class ParameterDetail {
+
+		private final Class<?> parameterType;
+
+		private final String parameterName;
+
+		private final String parameterDescription;
+
+		public ParameterDetail(Class<?> parameterType, String parameterName, String parameterDescription) {
+			super();
+			this.parameterType = parameterType;
+			this.parameterName = parameterName;
+			this.parameterDescription = parameterDescription;
+		}
+
+		public Class<?> getParameterType() {
+			return parameterType;
+		}
+
+		public String getParameterName() {
+			return parameterName;
+		}
+
+		public String getParameterDescription() {
+			return parameterDescription;
+		}
+	}
+
+	/**
+	 * Indicates another {@link ManagedType} represents the same {@link Class} as this one. This method also supports a
+	 * {@link Class} as a parameter, in this case it will return <code>true</code> if the passed class is exactly the
+	 * same Java class represented by this {@link ManagedType}.
+	 */
+	@Override
+	public boolean equals(Object other) {
+		if (other == null) {
+			return false;
+		}
+
+		return ((ManagedType) other).getType().getCanonicalName().equals(this.getType().getCanonicalName());
+	}
+}
@@ -0,0 +1,351 @@
+/*
+ * 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 br.gov.frameworkdemoiselle.internal.management;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.context.RequestScoped;
+import javax.inject.Inject;
+import javax.management.ReflectionException;
+import javax.validation.ConstraintViolation;
+import javax.validation.Validation;
+import javax.validation.ValidationException;
+import javax.validation.Validator;
+
+import org.slf4j.Logger;
+
+import br.gov.frameworkdemoiselle.DemoiselleException;
+import br.gov.frameworkdemoiselle.annotation.ManagedProperty;
+import br.gov.frameworkdemoiselle.annotation.Name;
+import br.gov.frameworkdemoiselle.internal.context.ContextManager;
+import br.gov.frameworkdemoiselle.internal.context.ManagedContext;
+import br.gov.frameworkdemoiselle.internal.management.ManagedType.MethodDetail;
+import br.gov.frameworkdemoiselle.lifecycle.ManagementExtension;
+import br.gov.frameworkdemoiselle.management.AttributeChangeNotification;
+import br.gov.frameworkdemoiselle.management.NotificationManager;
+import br.gov.frameworkdemoiselle.stereotype.ManagementController;
+import br.gov.frameworkdemoiselle.util.Beans;
+import br.gov.frameworkdemoiselle.util.ResourceBundle;
+
+/**
+ * Central class used by management extensions to obtain information, access properties and call operations
+ * over discovered {@link ManagementController} classes. 
+ * 
+ * @author serpro
+ */
+@ApplicationScoped
+public class Management {
+
+	@Inject
+	private Logger logger;
+
+	@Inject
+	@Name("demoiselle-core-bundle")
+	private ResourceBundle bundle;
+
+	private final List<ManagedType> managedTypes = new ArrayList<ManagedType>();
+	
+	private Validator validator;
+
+	public void addManagedType(ManagedType managedType) {
+		managedTypes.add(managedType);
+		logger.debug(bundle.getString("management-debug-registering-managed-type",managedType.getType().getCanonicalName()));
+	}
+
+	/**
+	 * @return List all discovered {@link ManagementController} classes.
+	 *         The returned list is a shallow copy of the internal list, so you
+	 *         are free to modify it.
+	 * 
+	 *         TODO precisamos desse clone na lista?
+	 */
+	public List<ManagedType> getManagedTypes() {
+		ArrayList<ManagedType> cloneList = new ArrayList<ManagedType>();
+		cloneList.addAll(managedTypes);
+		return cloneList;
+	}
+
+	/**
+	 * <p>Invoke an operation over a {@link ManagementController}.</p>
+	 * 
+	 * <p>This method is not thread-safe, it's the user's responsibility to
+	 * make the operations of the managed type synchronized if necessary.</p>
+	 * 
+	 * @param managedType
+	 *            A type annotated with {@link ManagementController}. This method will create
+	 *            an (or obtain an already created) instance of this type and
+	 *            invoke the operation over it.
+	 * @param actionName
+	 *            Name of method to be invoked, the type must have this
+	 *            operation on it's list
+	 * @param params
+	 *            List of values for the operation parameters. Can be
+	 *            <code>null</code> if the operation require no parameters.
+	 * @return The return value of the original invoked operation. Methods of
+	 *         return type <code>void</code> will return the {@link Void} type.
+	 * @throws ReflectionException
+	 *             In case the operation doesn't exist or have a different
+	 *             signature
+	 */
+	public Object invoke(ManagedType managedType, String actionName,
+			Object[] params) {
+		if ( managedTypes.contains(managedType) ) {
+			activateContexts(managedType.getType());
+
+			Object delegate = Beans.getReference(managedType.getType());
+
+			MethodDetail method = managedType.getOperationMethods().get(actionName);
+
+			if (method != null) {
+				try {
+					logger.debug(bundle
+							.getString("management-debug-invoking-operation",actionName,managedType.getType().getCanonicalName()));
+					return method.getMethod().invoke(delegate, params);
+				} catch (Exception e) {
+					throw new DemoiselleException(bundle.getString(
+							"management-invoke-error", actionName), e);
+				} finally {
+					deactivateContexts(managedType.getType());
+				}
+			} else {
+				throw new DemoiselleException(bundle.getString(
+						"management-invoke-error", actionName));
+			}
+		} else {
+			throw new DemoiselleException(
+					bundle.getString("management-type-not-found"));
+		}
+	}
+
+	/**
+	 * <p>Retrieve the current value of a property from a managed type. Properties
+	 * are attributes annotated with {@link ManagedProperty}.</p>
+	 * 
+	 * <p>This method is not thread-safe, it's the user's responsibility to
+	 * create the property's access methods from the managed type synchronized if necessary.</p>
+	 * 
+	 * @param managedType The type that has the property the client wants to know the value of.
+	 * @param propertyName The name of the property
+	 * @return The current value of the property
+	 */
+	public Object getProperty(ManagedType managedType, String propertyName) {
+		
+		if ( managedTypes.contains(managedType) ) {
+			Method getterMethod = managedType.getFields().get(propertyName).getGetterMethod();
+
+			if (getterMethod != null) {
+				logger.debug(bundle.getString(
+						"management-debug-acessing-property", getterMethod
+								.getName(), managedType.getType().getCanonicalName()));
+
+				activateContexts(managedType.getType());
+
+				try {
+					Object delegate = Beans.getReference(managedType.getType());
+
+					return getterMethod.invoke(delegate, (Object[]) null);
+				} catch (Exception e) {
+					throw new DemoiselleException(bundle.getString(
+							"management-invoke-error", getterMethod.getName()),
+							e);
+				} finally {
+					deactivateContexts(managedType.getType());
+				}
+			} else {
+				throw new DemoiselleException(bundle.getString(
+						"management-invoke-error", propertyName));
+			}
+		} else {
+			throw new DemoiselleException(
+					bundle.getString("management-type-not-found"));
+		}
+	}
+	
+	/**
+	 * <p>Sets a new value for a property contained inside a managed type. A property
+	 * is an attribute annotated with {@link ManagedProperty}.</p>
+	 * 
+	 * <p>This method is not thread-safe, it's the user's responsibility to
+	 * create the property's access methods from the managed type synchronized if necessary.</p>
+	 * 
+	 * @param managedType The type that has access to the property
+	 * @param propertyName The name of the property
+	 * @param newValue The new value of the property
+	 */
+	public void setProperty(ManagedType managedType, String propertyName,
+			Object newValue) {
+
+		if ( managedTypes.contains(managedType) ) {
+			// Procura o método set do atributo em questão
+			Method method = managedType.getFields().get(propertyName).getSetterMethod();
+			if (method != null) {
+				logger.debug(bundle.getString(
+						"management-debug-setting-property", method.getName(),
+						managedType.getType().getCanonicalName()));
+
+				activateContexts(managedType.getType());
+				try {
+					// Obtém uma instância da classe gerenciada, lembrando que
+					// classes
+					// anotadas com @ManagementController são sempre singletons.
+					Object delegate = Beans.getReference(managedType.getType());
+					
+					//Se houver um validador anexado à propriedade alterada, executa o validador sobre
+					//o novo valor.
+					Validator validator = getDefaultValidator();
+					if (validator!=null){
+						Set<?> violations = validator.validateValue(managedType.getType(), propertyName, newValue);
+						if (violations.size()>0){
+							StringBuffer errorBuffer = new StringBuffer();
+							for (Object objectViolation : violations){
+								ConstraintViolation<?> violation = (ConstraintViolation<?>) objectViolation;
+								errorBuffer.append(violation.getMessage()).append('\r').append('\n');
+							}
+							
+							throw new DemoiselleException(bundle.getString("validation-constraint-violation",managedType.getType().getCanonicalName(),errorBuffer.toString()));
+						}
+					}
+					else{
+						logger.warn(bundle.getString("validation-validator-not-found"));
+					}
+
+					Method getterMethod = managedType.getFields().get(propertyName).getGetterMethod();
+					Object oldValue;
+					try{
+						oldValue = getterMethod.invoke(delegate, (Object[])null);
+					}
+					catch(Exception e){
+						oldValue = null;
+					}
+
+					method.invoke(delegate, new Object[] { newValue });
+
+					//Manda uma notificação de mudança de atributo 
+					NotificationManager notificationManager = Beans.getReference(NotificationManager.class);
+					Class<? extends Object> attributeType = newValue!=null ? newValue.getClass() : null;
+					
+					AttributeChangeNotification notification = new AttributeChangeNotification(bundle.getString("management-notification-attribute-changed",propertyName,managedType.getType().getCanonicalName())
+							, propertyName
+							, attributeType
+							, oldValue
+							, newValue);
+					notificationManager.sendNotification(notification);
+
+				} catch (DemoiselleException de){
+					throw de;
+				} catch (Exception e) {
+					throw new DemoiselleException(bundle.getString(
+							"management-invoke-error", method.getName()), e);
+				} finally {
+					deactivateContexts(managedType.getType());
+				}
+
+			} else {
+				throw new DemoiselleException(bundle.getString(
+						"management-invoke-error", propertyName));
+			}
+		} else {
+			throw new DemoiselleException(
+					bundle.getString("management-type-not-found"));
+		}
+
+	}
+
+	private void activateContexts(Class<?> managedType) {
+		logger.debug(bundle.getString("management-debug-starting-custom-context",
+				ManagedContext.class.getCanonicalName(),
+				managedType.getCanonicalName()));
+		
+		ContextManager.activate(ManagedContext.class,RequestScoped.class);
+	}
+
+	private void deactivateContexts(Class<?> managedType) {
+		logger.debug(bundle.getString("management-debug-stoping-custom-context",
+				ManagedContext.class.getCanonicalName(),
+				managedType.getCanonicalName()));
+		
+		ContextManager.deactivate(ManagedContext.class,RequestScoped.class);
+	}
+
+	public void shutdown(Collection<Class<? extends ManagementExtension>> monitoringExtensions) {
+
+		for (Class<? extends ManagementExtension> monitoringExtensionClass : monitoringExtensions) {
+
+			ManagementExtension monitoringExtension = Beans.getReference(monitoringExtensionClass);
+
+			monitoringExtension.shutdown(this.getManagedTypes());
+			
+			logger.debug( bundle.getString("management-debug-removing-management-extension",monitoringExtension.getClass().getCanonicalName()) );
+
+		}
+
+	}
+
+	public void initialize(Collection<Class<? extends ManagementExtension>> monitoringExtensions) {
+
+		for (Class<? extends ManagementExtension> monitoringExtensionClass : monitoringExtensions) {
+
+			ManagementExtension monitoringExtension = Beans
+					.getReference(monitoringExtensionClass);
+
+			monitoringExtension.initialize(this.getManagedTypes());
+			
+			logger.debug( bundle.getString("management-debug-processing-management-extension",monitoringExtension.getClass().getCanonicalName()) );
+
+		}
+
+	}
+	
+	private Validator getDefaultValidator(){
+		if (validator == null){
+			try{
+				this.validator = Validation.buildDefaultValidatorFactory().getValidator();
+			}
+			catch(ValidationException e){
+				this.validator = null;
+			}
+		}
+		
+		return this.validator;
+	}
+
+}
@@ -0,0 +1,65 @@
+/*
+ * 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 br.gov.frameworkdemoiselle.internal.management;
+
+import br.gov.frameworkdemoiselle.management.Notification;
+import br.gov.frameworkdemoiselle.management.NotificationManager;
+
+/**
+ * Event fired when a notification is sent by {@link NotificationManager}.
+ * Implementators can capture this event and be notified when the {@link NotificationManager}
+ * sends notifications, so they can pass the notification to the underlying technology.
+ * 
+ * @author serpro
+ *
+ */
+public class ManagementNotificationEvent {
+	
+	private Notification notification;
+	
+	public ManagementNotificationEvent(Notification notification){
+		this.notification = notification;
+	}
+
+	public Notification getNotification() {
+		return notification;
+	}
+
+	public void setNotification(Notification notification) {
+		this.notification = notification;
+	}
+}
@@ -0,0 +1,62 @@
+/*
+ * 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 br.gov.frameworkdemoiselle.internal.management.qualifier;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import javax.inject.Qualifier;
+
+import br.gov.frameworkdemoiselle.internal.management.ManagementNotificationEvent;
+import br.gov.frameworkdemoiselle.management.AttributeChangeNotification;
+
+/**
+ * 
+ * Enables {@link ManagementNotificationEvent} observers to trigger only with notifications
+ * of the specialized type {@link AttributeChangeNotification}.
+ * 
+ * @author serpro
+ *
+ */
+@Qualifier
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE})
+public @interface AttributeChange {
+
+}
@@ -0,0 +1,62 @@
+/*
+ * 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 br.gov.frameworkdemoiselle.internal.management.qualifier;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import javax.inject.Qualifier;
+
+import br.gov.frameworkdemoiselle.internal.management.ManagementNotificationEvent;
+import br.gov.frameworkdemoiselle.management.Notification;
+
+/**
+ * 
+ * Enables {@link ManagementNotificationEvent} observers to trigger only with notifications
+ * of the base type {@link Notification}.
+ * 
+ * @author serpro
+ *
+ */
+@Qualifier
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE})
+public @interface Generic {
+
+}
@@ -0,0 +1,76 @@
+/*
+ * 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 br.gov.frameworkdemoiselle.lifecycle;
+
+import java.util.List;
+
+import br.gov.frameworkdemoiselle.internal.management.ManagedType;
+import br.gov.frameworkdemoiselle.stereotype.ManagementController;
+
+/**
+ * 
+ * <p>Interface defining the lifecycle of a <b>management extension</b>, an extension
+ * capable of exposing {@link ManagementController}'s to external clients in one
+ * of the available management technologies, such as JMX or SNMP.</p>
+ * 
+ * <p>To include a management extension into the management lifecycle, it just needs
+ * to implement this interface and be a CDI bean (have a <b>beans.xml</b> file inside
+ * the META-INF folder of it's java package). The Demoiselle Core lifecycle controller
+ * will call the {@link #initialize(List managedTypes)} and {@link #shutdown(List managedTypes)} methods at the apropriate times.</p>
+ * 
+ * @author serpro
+ *
+ */
+public interface ManagementExtension {
+
+	/**
+	 * This method is called during the application initialization process for each concrete
+	 * implementation of this interface.
+	 * 
+	 * @param managedTypes The list of discovered {@link ManagementController} classes.
+	 */
+	void initialize(List<ManagedType> managedTypes);
+
+	/**
+	 * This method is called during the application shutdown process for each concrete
+	 * implementation of this interface.
+	 * 
+	 * @param managedTypes The list of discovered {@link ManagementController} classes.
+	 */
+	void shutdown(List<ManagedType> managedTypes);
+
+}
@@ -0,0 +1,110 @@
+/*
+ * 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 br.gov.frameworkdemoiselle.management;
+
+/**
+ * Special notification to denote an attribute has changed values.
+ * 
+ * @see Notification
+ * 
+ * @author serpro
+ *
+ */
+public class AttributeChangeNotification extends Notification {
+	
+	private String attributeName;
+	
+	private Class<? extends Object> attributeType;
+	
+	private Object oldValue;
+	
+	private Object newValue;
+	
+	public AttributeChangeNotification(){}
+	
+	public AttributeChangeNotification(Object message, String attributeName, Class<? extends Object> attributeType, Object oldValue,
+			Object newValue) {
+		super(message);
+		this.attributeName = attributeName;
+		this.attributeType = attributeType;
+		this.oldValue = oldValue;
+		this.newValue = newValue;
+	}
+
+
+	public String getAttributeName() {
+		return attributeName;
+	}
+
+	
+	public void setAttributeName(String attributeName) {
+		this.attributeName = attributeName;
+	}
+
+	
+	public Class<? extends Object> getAttributeType() {
+		return attributeType;
+	}
+
+	
+	public void setAttributeType(Class<? extends Object> attributeType) {
+		this.attributeType = attributeType;
+	}
+
+	
+	public Object getOldValue() {
+		return oldValue;
+	}
+
+	
+	public void setOldValue(Object oldValue) {
+		this.oldValue = oldValue;
+	}
+
+	
+	public Object getNewValue() {
+		return newValue;
+	}
+
+	
+	public void setNewValue(Object newValue) {
+		this.newValue = newValue;
+	}
+	
+	
+
+}
@@ -0,0 +1,77 @@
+/*
+ * 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 br.gov.frameworkdemoiselle.management;
+
+/**
+ * 
+ * Notification that can be sent by the {@link NotificationManager}.
+ * 
+ * @author serpro
+ *
+ */
+public class Notification {
+	
+	private Object message;
+	
+	public Notification(){
+	}
+	
+	public Notification(Object message) {
+		super();
+		this.message = message;
+	}
+
+
+	public Object getMessage() {
+		return message;
+	}
+
+	
+	public void setMessage(Object message) {
+		this.message = message;
+	}
+
+	
+	public Class<? extends Object> getType() {
+		if (message!=null){
+			return message.getClass();
+		}
+		
+		return null;
+	}
+
+}
@@ -0,0 +1,116 @@
+/*
+ * 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 br.gov.frameworkdemoiselle.management;
+
+import java.io.Serializable;
+
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.event.Event;
+import javax.enterprise.event.Observes;
+import javax.enterprise.util.AnnotationLiteral;
+import javax.inject.Inject;
+
+import br.gov.frameworkdemoiselle.internal.management.ManagementNotificationEvent;
+import br.gov.frameworkdemoiselle.internal.management.qualifier.AttributeChange;
+import br.gov.frameworkdemoiselle.internal.management.qualifier.Generic;
+import br.gov.frameworkdemoiselle.util.Beans;
+
+/**
+ * 
+ * <p>Central class to manage sending notifications to management clients.
+ * This class allows applications to send management notifications without
+ * knowledge of the technology used to send those notifications.</p>
+ * 
+ * <p>To obtain an instance of the {@link NotificationManager} simply inject it in
+ * your code using {@link Inject} or the {@link Beans#getReference(Class beanType)} method. The {@link NotificationManager}
+ * is {@link ApplicationScoped}, so you can inject it as many times as needed and still have only one instance per application.</p>
+ * 
+ * <p>Implementators of management protocols must observe the {@link ManagementNotificationEvent} event (using the {@link Observes} annotation), this way
+ * they will receive an event containing the original notification and can translate this notification to a specific protocol. Optionaly,
+ * the implementator can use qualifiers like the {@link Generic} and {@link AttributeChange} qualifiers
+ * to filter what king of notifications they will handle. One example of an implementator is the <b>demoiselle-jmx</b> extension.</p>
+ * 
+ * @author serpro
+ *
+ */
+@ApplicationScoped
+@SuppressWarnings("serial")
+public class NotificationManager implements Serializable{
+	
+	@Inject
+	@Generic
+	private Event<ManagementNotificationEvent> genericNotificationEvent;
+	
+	@Inject
+	@AttributeChange
+	private Event<ManagementNotificationEvent> attributeChangeNotificationEvent;
+	
+	/**
+	 * Sends a generic notification to all management clients.
+	 * 
+	 * @param notification The notification to send
+	 */
+	public void sendNotification(Notification notification) {
+		if (! AttributeChangeNotification.class.isInstance(notification) ){
+			getGenericNotificationEvent().fire(new ManagementNotificationEvent(notification));
+		}
+		else{
+			getAttributeChangeNotificationEvent().fire(new ManagementNotificationEvent(notification));
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	private Event<ManagementNotificationEvent> getGenericNotificationEvent() {
+		if (genericNotificationEvent==null){
+			genericNotificationEvent = Beans.getReference(Event.class , new AnnotationLiteral<Generic>() {});
+		}
+		
+		return genericNotificationEvent;
+	}
+	
+	@SuppressWarnings("unchecked")
+	private Event<ManagementNotificationEvent> getAttributeChangeNotificationEvent() {
+		if (attributeChangeNotificationEvent==null){
+			attributeChangeNotificationEvent = Beans.getReference(Event.class , new AnnotationLiteral<AttributeChange>() {});
+		}
+		
+		return attributeChangeNotificationEvent;
+	}
+	
+	
+	
+}
@@ -1,80 +0,0 @@
-/*
- * Demoiselle Framework
- * Copyright (C) 2011 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 br.gov.frameworkdemoiselle.management.annotation;
-
-import static java.lang.annotation.ElementType.TYPE;
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.Inherited;
-import java.lang.annotation.Retention;
-import java.lang.annotation.Target;
-
-import javax.enterprise.context.ApplicationScoped;
-import javax.enterprise.inject.Stereotype;
-import javax.enterprise.util.Nonbinding;
-import javax.interceptor.InterceptorBinding;
-
-/**
- * Stereotype to indicate a given class is managed. What it means is that an external client can manage the application
- * this class is in by reading or writing it's attributes and calling it's operations.
- * <p>
- * Only fields annotated with {@link br.gov.frameworkdemoiselle.management.annotation.Property} or
- * methods annotated with {@link br.gov.frameworkdemoiselle.management.annotation.Operation} will be exposed
- * to clients.</p>
- * <p>This stereotype only defines a class as managed, you need to choose an extension that will expose this managed class
- * to external clients using any technology available. One example is the Demoiselle JMX extension, that will expose
- * managed classes as MBeans.</p> 
- * 
- * @author SERPRO
- */
-@Documented
-@Stereotype
-@InterceptorBinding
-@Inherited
-@Retention(RUNTIME)
-@Target({ TYPE })
-@ApplicationScoped
-public @interface Managed {
-	
-	/**
-	 * @return Human readable description of this managed class.
-	 */
-	@Nonbinding
-	String description() default "";
-
-}
@@ -1,37 +0,0 @@
-package br.gov.frameworkdemoiselle.management.annotation;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import javax.enterprise.util.Nonbinding;
-import javax.management.MBeanException;
-
-/**
- * <p>Indicates that a method is an operation, meaning you can manage some aspect of the application by calling it.</p>
- * <p>This annotation can't be used together with {@link Property}, doing so will throw a {@link MBeanException}.</p>  
- * 
- * @author SERPRO
- *
- */
-@Documented
-@Target({ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Operation {
-	
-	/**
-	 * Description that will be used to publish the operation to clients.
-	 * Defaults to an empty description.
-	 */
-	@Nonbinding
-	String description() default "";
-	
-	/**
-	 * Type of operation. Defaults to {@link OperationType#UNKNOWN}.
-	 */
-	@Nonbinding
-	OperationType type() default OperationType.UNKNOWN;
-
-}
@@ -1,37 +0,0 @@
-package br.gov.frameworkdemoiselle.management.annotation;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import javax.enterprise.util.Nonbinding;
-
-/**
- * <p>Optional annotation to write additional detail about an operation's parameter.</p>
- * <p>This annotation is ignored for non-operation methods.</p>  
- * 
- * @author SERPRO
- *
- */
-@Documented
-@Target({ElementType.PARAMETER})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface OperationParameter {
-	
-	/**
-	 * Name that will be used to publish this operation's parameter to clients.
-	 */
-	@Nonbinding
-	String name();
-	
-	/**
-	 * Optional description that will be used to publish this operation's parameter to clients.
-	 * Defaults to an empty description.
-	 */
-	@Nonbinding
-	String description() default "";
-	
-
-}
@@ -1,45 +0,0 @@
-package br.gov.frameworkdemoiselle.management.annotation;
-
-import javax.management.MBeanOperationInfo;
-
-
-/**
- * Define the operation type for an operation inside a Managed class.
- * 
- * 
- * @author SERPRO
- *
- */
-public enum OperationType {
-	
-	/**
-	 * Operation is write-only
-	 */
-	ACTION(MBeanOperationInfo.ACTION)
-	,
-	/**
-	 * Operation is read-only
-	 */
-	INFO(MBeanOperationInfo.INFO)
-	,
-	/**
-	 * Operation is read-write
-	 */
-	ACTION_INFO(MBeanOperationInfo.ACTION_INFO)
-	,
-	/**
-	 * Operation is unkown
-	 */
-	UNKNOWN(MBeanOperationInfo.UNKNOWN);
-	
-	private int operationTypeValue;
-	
-	private OperationType(int type){
-		this.operationTypeValue = type;
-	}
-	
-	public int getValue(){
-		return operationTypeValue;
-	}
-	
-}
@@ -1,33 +0,0 @@
-package br.gov.frameworkdemoiselle.management.annotation;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import javax.enterprise.util.Nonbinding;
-
-/**
- * <p>Indicates that a field must be exposed as a property to management clients.</p>
- * <p>The property will be writable if there's a public setter method
- * declared for the field and readable if there's a getter method.</p>
- * <p>It's a runtime error to annotate a field with no getter and no setter method.</p>
- * <p>It's also a runtime error to declare a field as a property and one or both of it's getter and setter
- * methods as an operation using the {@link Operation} annotation.</p> 
- * 
- * @author SERPRO
- *
- */
-@Documented
-@Target({ElementType.FIELD})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Property {
-	
-	/**
-	 * @return The description of this property exposed to management clients.
-	 */
-	@Nonbinding
-	String description() default "";
-
-}
@@ -1,40 +0,0 @@
-package br.gov.frameworkdemoiselle.management.annotation.validation;
-
-import static java.lang.annotation.ElementType.FIELD;
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.Retention;
-import java.lang.annotation.Target;
-
-import javax.validation.Constraint;
-
-import br.gov.frameworkdemoiselle.management.internal.validators.AllowedValuesValidator;
-
-@Documented
-@Target({ FIELD})
-@Retention(RUNTIME)
-@Constraint(validatedBy = AllowedValuesValidator.class)
-/**
- * Validate a value against a list of allowed values.
- * 
- * @author serpro
- *
- */
-public @interface AllowedValues {
-	
-	/**
-	 * List of accepted values
-	 */
-	String[] allows();
-	
-	/**
-	 * Type of allowed values. Defaults to {@link ValueType#STRING}.
-	 */
-	ValueType valueType() default ValueType.STRING;
-	
-	enum ValueType {
-		STRING,INTEGER,DECIMAL;
-	}
-	
-}
@@ -1,20 +0,0 @@
-package br.gov.frameworkdemoiselle.management.extension;
-
-import java.util.List;
-
-import br.gov.frameworkdemoiselle.management.internal.ManagedType;
-
-/**
- * 
- * Define an entry point for monitoring extension.
- * 
- * @author serpro
- *
- */
-public interface ManagementExtension {
-
-	void initialize(List<ManagedType> managedTypes);
-
-	void shutdown(List<ManagedType> managedTypes);
-
-}
@@ -1,295 +0,0 @@
-package br.gov.frameworkdemoiselle.management.internal;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.TreeMap;
-
-import br.gov.frameworkdemoiselle.DemoiselleException;
-import br.gov.frameworkdemoiselle.internal.producer.ResourceBundleProducer;
-import br.gov.frameworkdemoiselle.management.annotation.Managed;
-import br.gov.frameworkdemoiselle.management.annotation.Operation;
-import br.gov.frameworkdemoiselle.management.annotation.OperationParameter;
-import br.gov.frameworkdemoiselle.management.annotation.Property;
-import br.gov.frameworkdemoiselle.util.ResourceBundle;
-
-/**
- * Represents a detected managed type, a Java class annotated with {@link Managed}.
- * 
- * @author serpro
- */
-public class ManagedType {
-
-	private Class<?> type;
-
-	private TreeMap<String, FieldDetail> fields;
-
-	private TreeMap<String, MethodDetail> operationMethods;
-
-	private ResourceBundle bundle;
-
-	private String description;
-
-	public ManagedType(Class<?> type) {
-		bundle = ResourceBundleProducer.create("demoiselle-core-bundle");
-
-		if (type == null) {
-			throw new DemoiselleException(bundle.getString("management-null-class-defined"));
-		}
-		if (!type.isAnnotationPresent(Managed.class)) {
-			throw new DemoiselleException(bundle.getString("management-no-annotation-found", type.getCanonicalName()));
-		}
-
-		this.type = type;
-		fields = new TreeMap<String, FieldDetail>();
-		operationMethods = new TreeMap<String, MethodDetail>();
-		this.description = type.getAnnotation(Managed.class).description();
-
-		initialize();
-	}
-
-	public Class<?> getType() {
-		return type;
-	}
-
-	public String getDescription() {
-		return description;
-	}
-
-	public TreeMap<String, FieldDetail> getFields() {
-		return fields;
-	}
-
-	public TreeMap<String, MethodDetail> getOperationMethods() {
-		return operationMethods;
-	}
-
-	private void initialize() {
-		// Para cada atributo verifica se ele está anotado com Property e extrai as informações dele (método get, set e
-		// descrição do atributo).
-		Field[] fields = type.getDeclaredFields();
-		if (fields != null) {
-			for (Field field : fields) {
-				if (field.isAnnotationPresent(Property.class)) {
-					// Obtém os métodos GET e SET para esta propriedade
-					Method getterMethod = getGetterMethod(field);
-					Method setterMethod = getSetterMethod(field);
-					if (getterMethod == null && setterMethod == null) {
-						throw new DemoiselleException(bundle.getString("management-invalid-property-no-getter-setter",
-								type.getSimpleName(), field.getName()));
-					} else if ((getterMethod != null && getterMethod.isAnnotationPresent(Operation.class))
-							|| (setterMethod != null && setterMethod.isAnnotationPresent(Operation.class))) {
-						throw new DemoiselleException(bundle.getString("management-invalid-property-as-operation",
-								type.getSimpleName()));
-					}
-
-					String propertyDescription = field.getAnnotation(Property.class).description();
-
-					this.fields.put(field.getName(), new FieldDetail(field, propertyDescription, getterMethod,
-							setterMethod));
-				}
-			}
-		}
-
-		// Para cada metodo verifica se ele está anotado com Operation e cria um MBeanOperationInfo para ele.
-		Method[] methodList = type.getMethods();
-		if (methodList != null) {
-			for (Method method : methodList) {
-				Operation opAnnotation = method.getAnnotation(Operation.class);
-
-				if (opAnnotation != null) {
-					// Lemos as informações sobre o método e criamos uma instância
-					// de MethodDetail para representar este método como uma
-					// operação.
-
-					Class<?>[] parameterTypes = method.getParameterTypes();
-					Annotation[][] parameterAnnotations = method.getParameterAnnotations();
-					ParameterDetail[] parameterDetails = new ParameterDetail[parameterTypes.length];
-
-					for (int i = 0; i < parameterTypes.length; i++) {
-						OperationParameter paramAnnotation = null;
-						for (Annotation annotation : parameterAnnotations[i]) {
-							if (annotation.annotationType() == OperationParameter.class) {
-								paramAnnotation = (OperationParameter) annotation;
-								break;
-							}
-						}
-
-						String name = paramAnnotation != null ? paramAnnotation.name() : ("arg" + i);
-						String description = paramAnnotation != null ? paramAnnotation.description() : null;
-
-						parameterDetails[i] = new ParameterDetail(parameterTypes[i], name, description);
-					}
-
-					// Com todas as informações, criamos nossa instância de MethodDetail e
-					// acrescentamos na lista de todas as operações.
-					MethodDetail detail = new MethodDetail(method, opAnnotation.description(), parameterDetails);
-					operationMethods.put(method.getName(), detail);
-				}
-			}
-		}
-	}
-
-	/**
-	 * Returns the public getter method for a given field, or <code>null</code> if no getter method can be found.
-	 */
-	private Method getGetterMethod(Field field) {
-		StringBuffer getterMethodName = new StringBuffer()
-			.append("get")
-			.append(field.getName().substring(0, 1).toUpperCase())
-			.append(field.getName().substring(1));
-
-		Method getterMethod;
-
-		try {
-			getterMethod = type.getMethod(getterMethodName.toString());
-		} catch (Exception e) {
-			getterMethod = null;
-		}
-
-		// Se atributo for boolean, procura método getter no formato "isAttribute".
-		if (getterMethod == null
-				&& (Boolean.TYPE.isAssignableFrom(field.getType()) || Boolean.class.isAssignableFrom(field.getType()))) {
-			// Boolean.TYPE representa o tipo primitivo "boolean", Boolean.class é a classe wrapper.
-			getterMethodName = new StringBuffer()
-				.append("is")
-				.append(field.getName().substring(0, 1).toUpperCase())
-				.append(field.getName().substring(1).toUpperCase());
-
-			try {
-				getterMethod = type.getMethod(getterMethodName.toString());
-			} catch (Exception e) {
-				getterMethod = null;
-			}
-		}
-
-		return getterMethod;
-	}
-
-	/**
-	 * Returns the public setter method for a given field, or <code>null</code> if no setter method can be found.
-	 */
-	private Method getSetterMethod(Field field) {
-		StringBuffer setterMethodName = new StringBuffer()
-			.append("set")
-			.append(field.getName().substring(0, 1).toUpperCase())
-			.append(field.getName().substring(1));
-
-		Method setterMethod;
-
-		try {
-			setterMethod = type.getMethod(setterMethodName.toString() , field.getType());
-		} catch (Exception e) {
-			setterMethod = null;
-		}
-
-		return setterMethod;
-	}
-
-	public final class FieldDetail {
-
-		private final Field field;
-
-		private final String description;
-
-		private Method getterMethod;
-
-		private Method setterMethod;
-
-		public FieldDetail(Field field, String description, Method getterMethod, Method setterMethod) {
-			super();
-			this.field = field;
-			this.description = description;
-			this.getterMethod = getterMethod;
-			this.setterMethod = setterMethod;
-		}
-
-		public Field getField() {
-			return field;
-		}
-
-		public String getDescription() {
-			return description;
-		}
-
-		public Method getGetterMethod() {
-			return getterMethod;
-		}
-
-		public Method getSetterMethod() {
-			return setterMethod;
-		}
-
-	}
-
-	public final class MethodDetail {
-
-		private final Method method;
-
-		private final ParameterDetail[] parameterTypers;
-
-		private String description;
-
-		public MethodDetail(Method method, String description, ParameterDetail[] parameterTypers) {
-			super();
-			this.method = method;
-			this.description = description;
-			this.parameterTypers = parameterTypers;
-		}
-
-		public Method getMethod() {
-			return method;
-		}
-
-		public ParameterDetail[] getParameterTypers() {
-			return parameterTypers;
-		}
-
-		public String getDescription() {
-			return description;
-		}
-
-	}
-
-	public final class ParameterDetail {
-
-		private final Class<?> parameterType;
-
-		private final String parameterName;
-
-		private final String parameterDescription;
-
-		public ParameterDetail(Class<?> parameterType, String parameterName, String parameterDescription) {
-			super();
-			this.parameterType = parameterType;
-			this.parameterName = parameterName;
-			this.parameterDescription = parameterDescription;
-		}
-
-		public Class<?> getParameterType() {
-			return parameterType;
-		}
-
-		public String getParameterName() {
-			return parameterName;
-		}
-
-		public String getParameterDescription() {
-			return parameterDescription;
-		}
-	}
-
-	/**
-	 * Indicates another {@link ManagedType} represents the same {@link Class} as this one. This method also supports a
-	 * {@link Class} as a parameter, in this case it will return <code>true</code> if the passed class is exactly the
-	 * same Java class represented by this {@link ManagedType}.
-	 */
-	@Override
-	public boolean equals(Object other) {
-		if (other == null) {
-			return false;
-		}
-
-		return ((ManagedType) other).getType().getCanonicalName().equals(this.getType().getCanonicalName());
-	}
-}
@@ -1,266 +0,0 @@
-package br.gov.frameworkdemoiselle.management.internal;
-
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-import javax.enterprise.context.ApplicationScoped;
-import javax.enterprise.context.RequestScoped;
-import javax.inject.Inject;
-import javax.management.ReflectionException;
-
-import org.slf4j.Logger;
-
-import br.gov.frameworkdemoiselle.DemoiselleException;
-import br.gov.frameworkdemoiselle.annotation.Name;
-import br.gov.frameworkdemoiselle.internal.context.ContextManager;
-import br.gov.frameworkdemoiselle.internal.context.ManagedContext;
-import br.gov.frameworkdemoiselle.management.annotation.Managed;
-import br.gov.frameworkdemoiselle.management.annotation.Property;
-import br.gov.frameworkdemoiselle.management.extension.ManagementExtension;
-import br.gov.frameworkdemoiselle.management.internal.ManagedType.MethodDetail;
-import br.gov.frameworkdemoiselle.management.notification.AttributeChangeNotification;
-import br.gov.frameworkdemoiselle.management.notification.NotificationManager;
-import br.gov.frameworkdemoiselle.util.Beans;
-import br.gov.frameworkdemoiselle.util.ResourceBundle;
-
-/**
- * A manager that helps implementators of the management framework to obtain a
- * list of managed classes, set or obtain values from them or invoke operations
- * over them.
- * 
- * @author serpro
- */
-@ApplicationScoped
-public class MonitoringManager {
-
-	@Inject
-	private Logger logger;
-
-	@Inject
-	@Name("demoiselle-core-bundle")
-	private ResourceBundle bundle;
-
-	private final List<ManagedType> managedTypes = new ArrayList<ManagedType>();
-
-	public void addManagedType(ManagedType managedType) {
-		managedTypes.add(managedType);
-		logger.debug(bundle.getString("management-debug-registering-managed-type",managedType.getType().getCanonicalName()));
-	}
-
-	/**
-	 * @return A list all managed types, classes annotated with {@link Managed}.
-	 *         The returned list is a shallow copy of the internal list, so you
-	 *         are free to modify it.
-	 * 
-	 *         TODO precisamos desse clone na lista?
-	 */
-	public List<ManagedType> getManagedTypes() {
-		ArrayList<ManagedType> cloneList = new ArrayList<ManagedType>();
-		cloneList.addAll(managedTypes);
-		return cloneList;
-	}
-
-	/**
-	 * Invoke an operation over a managed type.
-	 * 
-	 * @param managedType
-	 *            A type annotated with {@link Managed}. This method will create
-	 *            an (or obtain an already created) instance of this type and
-	 *            invoke the operation over it.
-	 * @param actionName
-	 *            Name of method to be invoked, the type must have this
-	 *            operation on it's list
-	 * @param params
-	 *            List of values for the operation parameters. Can be
-	 *            <code>null</code> if the operation require no parameters.
-	 * @return The return value of the original invoked operation. Methods of
-	 *         return type <code>void</code> will return the {@link Void} type.
-	 * @throws ReflectionException
-	 *             In case the operation doesn't exist or have a different
-	 *             signature
-	 */
-	public synchronized Object invoke(ManagedType managedType, String actionName,
-			Object[] params) {
-		if ( managedTypes.contains(managedType) ) {
-			activateContexts(managedType.getType());
-
-			Object delegate = Beans.getReference(managedType.getType());
-
-			MethodDetail method = managedType.getOperationMethods().get(actionName);
-
-			if (method != null) {
-				try {
-					logger.debug(bundle
-							.getString("management-debug-invoking-operation",actionName,managedType.getType().getCanonicalName()));
-					return method.getMethod().invoke(delegate, params);
-				} catch (Exception e) {
-					throw new DemoiselleException(bundle.getString(
-							"management-invoke-error", actionName), e);
-				} finally {
-					deactivateContexts(managedType.getType());
-				}
-			} else {
-				throw new DemoiselleException(bundle.getString(
-						"management-invoke-error", actionName));
-			}
-		} else {
-			throw new DemoiselleException(
-					bundle.getString("management-type-not-found"));
-		}
-	}
-
-	/**
-	 * Retrieve the current value of a property from a managed type. Properties
-	 * are attributes annotated with {@link Property}.
-	 * 
-	 * @param managedType The type that has the property the client wants to know the value of.
-	 * @param propertyName The name of the property
-	 * @return The current value of the property
-	 */
-	public synchronized Object getProperty(ManagedType managedType, String propertyName) {
-		
-		if ( managedTypes.contains(managedType) ) {
-			Method getterMethod = managedType.getFields().get(propertyName).getGetterMethod();
-
-			if (getterMethod != null) {
-				logger.debug(bundle.getString(
-						"management-debug-acessing-property", getterMethod
-								.getName(), managedType.getType().getCanonicalName()));
-
-				activateContexts(managedType.getType());
-
-				try {
-					Object delegate = Beans.getReference(managedType.getType());
-
-					return getterMethod.invoke(delegate, (Object[]) null);
-				} catch (Exception e) {
-					throw new DemoiselleException(bundle.getString(
-							"management-invoke-error", getterMethod.getName()),
-							e);
-				} finally {
-					deactivateContexts(managedType.getType());
-				}
-			} else {
-				throw new DemoiselleException(bundle.getString(
-						"management-invoke-error", propertyName));
-			}
-		} else {
-			throw new DemoiselleException(
-					bundle.getString("management-type-not-found"));
-		}
-	}
-	
-	/**
-	 * Sets a new value for a property contained inside a managed type. A property
-	 * is an attribute annotated with {@link Property}.
-	 * 
-	 * @param managedType The type that has access to the property
-	 * @param propertyName The name of the property
-	 * @param newValue The new value of the property
-	 */
-	public synchronized void setProperty(ManagedType managedType, String propertyName,
-			Object newValue) {
-
-		if ( managedTypes.contains(managedType) ) {
-			// Procura o método set do atributo em questão
-			Method method = managedType.getFields().get(propertyName).getSetterMethod();
-			if (method != null) {
-				logger.debug(bundle.getString(
-						"management-debug-setting-property", method.getName(),
-						managedType.getType().getCanonicalName()));
-
-				// Obtém uma instância da classe gerenciada, lembrando que
-				// classes
-				// anotadas com @Managed são sempre singletons.
-				activateContexts(managedType.getType());
-				try {
-					Object delegate = Beans.getReference(managedType.getType());
-
-					Method getterMethod = managedType.getFields().get(propertyName).getGetterMethod();
-					Object oldValue;
-					try{
-						oldValue = getterMethod.invoke(delegate, (Object[])null);
-					}
-					catch(Exception e){
-						oldValue = null;
-					}
-
-					method.invoke(delegate, new Object[] { newValue });
-
-					//Manda uma notificação de mudança de atributo 
-					NotificationManager notificationManager = Beans.getReference(NotificationManager.class);
-					Class<? extends Object> attributeType = newValue!=null ? newValue.getClass() : null;
-					
-					AttributeChangeNotification notification = new AttributeChangeNotification(bundle.getString("management-notification-attribute-changed",propertyName,managedType.getType().getCanonicalName())
-							, propertyName
-							, attributeType
-							, oldValue
-							, newValue);
-					notificationManager.sendNotification(notification);
-
-				} catch (Exception e) {
-					throw new DemoiselleException(bundle.getString(
-							"management-invoke-error", method.getName()), e);
-				} finally {
-					deactivateContexts(managedType.getType());
-				}
-
-			} else {
-				throw new DemoiselleException(bundle.getString(
-						"management-invoke-error", propertyName));
-			}
-		} else {
-			throw new DemoiselleException(
-					bundle.getString("management-type-not-found"));
-		}
-
-	}
-
-	private void activateContexts(Class<?> managedType) {
-		logger.debug(bundle.getString("management-debug-starting-custom-context",
-				ManagedContext.class.getCanonicalName(),
-				managedType.getCanonicalName()));
-		
-		ContextManager.activate(ManagedContext.class,RequestScoped.class);
-	}
-
-	private void deactivateContexts(Class<?> managedType) {
-		logger.debug(bundle.getString("management-debug-stoping-custom-context",
-				ManagedContext.class.getCanonicalName(),
-				managedType.getCanonicalName()));
-		
-		ContextManager.deactivate(ManagedContext.class,RequestScoped.class);
-	}
-
-	public void shutdown(Collection<Class<? extends ManagementExtension>> monitoringExtensions) {
-
-		for (Class<? extends ManagementExtension> monitoringExtensionClass : monitoringExtensions) {
-
-			ManagementExtension monitoringExtension = Beans.getReference(monitoringExtensionClass);
-
-			monitoringExtension.shutdown(this.getManagedTypes());
-			
-			logger.debug( bundle.getString("management-debug-removing-management-extension",monitoringExtension.getClass().getCanonicalName()) );
-
-		}
-
-	}
-
-	public void initialize(Collection<Class<? extends ManagementExtension>> monitoringExtensions) {
-
-		for (Class<? extends ManagementExtension> monitoringExtensionClass : monitoringExtensions) {
-
-			ManagementExtension monitoringExtension = Beans
-					.getReference(monitoringExtensionClass);
-
-			monitoringExtension.initialize(this.getManagedTypes());
-			
-			logger.debug( bundle.getString("management-debug-processing-management-extension",monitoringExtension.getClass().getCanonicalName()) );
-
-		}
-
-	}
-
-}
@@ -1,29 +0,0 @@
-package br.gov.frameworkdemoiselle.management.internal.notification.event;
-
-import br.gov.frameworkdemoiselle.management.notification.Notification;
-import br.gov.frameworkdemoiselle.management.notification.NotificationManager;
-
-/**
- * Event fired when a notification is sent by {@link NotificationManager}.
- * Implementators can capture this event and by notified when the {@link NotificationManager}
- * sends notifications, so they can pass the notification to a underlying protocol such as JMX.
- * 
- * @author serpro
- *
- */
-public class NotificationEvent {
-	
-	private Notification notification;
-	
-	public NotificationEvent(Notification notification){
-		this.notification = notification;
-	}
-
-	public Notification getNotification() {
-		return notification;
-	}
-
-	public void setNotification(Notification notification) {
-		this.notification = notification;
-	}
-}
@@ -1,26 +0,0 @@
-package br.gov.frameworkdemoiselle.management.internal.notification.qualifier;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import javax.inject.Qualifier;
-
-import br.gov.frameworkdemoiselle.management.internal.notification.event.NotificationEvent;
-import br.gov.frameworkdemoiselle.management.notification.AttributeChangeNotification;
-
-/**
- * 
- * Enables {@link NotificationEvent} observers to trigger only with notifications
- * of the specialized type {@link AttributeChangeNotification}.
- * 
- * @author serpro
- *
- */
-@Qualifier
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE})
-public @interface AttributeChange {
-
-}
@@ -1,26 +0,0 @@
-package br.gov.frameworkdemoiselle.management.internal.notification.qualifier;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import javax.inject.Qualifier;
-
-import br.gov.frameworkdemoiselle.management.internal.notification.event.NotificationEvent;
-import br.gov.frameworkdemoiselle.management.notification.Notification;
-
-/**
- * 
- * Enables {@link NotificationEvent} observers to trigger only with notifications
- * of the base type {@link Notification}.
- * 
- * @author serpro
- *
- */
-@Qualifier
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE})
-public @interface Generic {
-
-}
@@ -1,68 +0,0 @@
-package br.gov.frameworkdemoiselle.management.internal.validators;
-
-import java.math.BigDecimal;
-
-import javax.validation.ConstraintValidator;
-import javax.validation.ConstraintValidatorContext;
-
-import br.gov.frameworkdemoiselle.management.annotation.validation.AllowedValues;
-
-
-public class AllowedValuesValidator implements ConstraintValidator<AllowedValues, Object> {
-
-	private br.gov.frameworkdemoiselle.management.annotation.validation.AllowedValues.ValueType valueType;
-	private String[] allowedValues;
-
-	@Override
-	public void initialize(AllowedValues constraintAnnotation) {
-		valueType = constraintAnnotation.valueType();
-		allowedValues = constraintAnnotation.allows();
-	}
-	
-	@Override
-	public boolean isValid(Object value, ConstraintValidatorContext context) {
-		
-		if (value==null){
-			return false;
-		}
-
-		switch(valueType){
-			case STRING:
-				for (String str : allowedValues){
-					if (str.equals(value)) return true;
-				}
-				return false;
-				
-			case INTEGER:
-				try{
-					Integer number = Integer.valueOf(value.toString());
-					String strNumber = number.toString();
-					for (String str : allowedValues){
-						if (str.equals(strNumber)) return true;
-					}
-
-					return false;
-				}
-				catch(NumberFormatException ne){
-					return false;
-				}
-				
-			case DECIMAL:
-				try{
-					BigDecimal number = new BigDecimal(value.toString());
-					String strNumber = number.toString();
-					for (String str : allowedValues){
-						if (str.equals(strNumber)) return true;
-					}
-				}
-				catch(NumberFormatException ne){
-					return false;
-				}
-				
-				return false;
-		}
-
-		return false;
-	}
-
-}
@@ -1,74 +0,0 @@
-package br.gov.frameworkdemoiselle.management.notification;
-
-/**
- * Special notification to denote an attribute has changed values.
- * 
- * @see Notification
- * 
- * @author serpro
- *
- */
-public class AttributeChangeNotification extends Notification {
-	
-	private String attributeName;
-	
-	private Class<? extends Object> attributeType;
-	
-	private Object oldValue;
-	
-	private Object newValue;
-	
-	public AttributeChangeNotification(){}
-	
-	public AttributeChangeNotification(Object message, String attributeName, Class<? extends Object> attributeType, Object oldValue,
-			Object newValue) {
-		super(message);
-		this.attributeName = attributeName;
-		this.attributeType = attributeType;
-		this.oldValue = oldValue;
-		this.newValue = newValue;
-	}
-
-
-	public String getAttributeName() {
-		return attributeName;
-	}
-
-	
-	public void setAttributeName(String attributeName) {
-		this.attributeName = attributeName;
-	}
-
-	
-	public Class<? extends Object> getAttributeType() {
-		return attributeType;
-	}
-
-	
-	public void setAttributeType(Class<? extends Object> attributeType) {
-		this.attributeType = attributeType;
-	}
-
-	
-	public Object getOldValue() {
-		return oldValue;
-	}
-
-	
-	public void setOldValue(Object oldValue) {
-		this.oldValue = oldValue;
-	}
-
-	
-	public Object getNewValue() {
-		return newValue;
-	}
-
-	
-	public void setNewValue(Object newValue) {
-		this.newValue = newValue;
-	}
-	
-	
-
-}
@@ -1,41 +0,0 @@
-package br.gov.frameworkdemoiselle.management.notification;
-
-/**
- * 
- * Notification that can be sent by the {@link NotificationManager}.
- * 
- * @author serpro
- *
- */
-public class Notification {
-	
-	private Object message;
-	
-	public Notification(){
-	}
-	
-	public Notification(Object message) {
-		super();
-		this.message = message;
-	}
-
-
-	public Object getMessage() {
-		return message;
-	}
-
-	
-	public void setMessage(Object message) {
-		this.message = message;
-	}
-
-	
-	public Class<? extends Object> getType() {
-		if (message!=null){
-			return message.getClass();
-		}
-		
-		return null;
-	}
-
-}
@@ -1,80 +0,0 @@
-package br.gov.frameworkdemoiselle.management.notification;
-
-import java.io.Serializable;
-
-import javax.enterprise.context.ApplicationScoped;
-import javax.enterprise.event.Event;
-import javax.enterprise.event.Observes;
-import javax.enterprise.util.AnnotationLiteral;
-import javax.inject.Inject;
-
-import br.gov.frameworkdemoiselle.management.internal.notification.event.NotificationEvent;
-import br.gov.frameworkdemoiselle.management.internal.notification.qualifier.AttributeChange;
-import br.gov.frameworkdemoiselle.management.internal.notification.qualifier.Generic;
-import br.gov.frameworkdemoiselle.util.Beans;
-
-/**
- * 
- * <p>Central class to manage sending notifications to management clients.
- * This class allows applications to send management notifications without
- * knowledge of the technology used to send those notifications.</p>
- * 
- * <p>To obtain an instance of the {@link NotificationManager} simply inject it in
- * your code using {@link Inject} or the {@link Beans#getReference(Class beanType)} method. The {@link NotificationManager}
- * is {@link ApplicationScoped}, so you can inject it as many times as needed and still have only one instance per application.</p>
- * 
- * <p>Implementators of management protocols must observe the {@link NotificationEvent} event (using the {@link Observes} annotation), this way
- * they will receive an event containing the original notification and can translate this notification to a specific protocol. Optionaly,
- * the implementator can use qualifiers like the {@link Generic} and {@link AttributeChange} qualifiers
- * to filter what king of notifications they will handle. One example of an implementator is the <b>demoiselle-jmx</b> extension.</p>
- * 
- * @author serpro
- *
- */
-@ApplicationScoped
-@SuppressWarnings("serial")
-public class NotificationManager implements Serializable{
-	
-	@Inject
-	@Generic
-	private Event<NotificationEvent> genericNotificationEvent;
-	
-	@Inject
-	@AttributeChange
-	private Event<NotificationEvent> attributeChangeNotificationEvent;
-	
-	/**
-	 * Sends a generic notification to all management clients.
-	 * 
-	 * @param notification The notification to send
-	 */
-	public void sendNotification(Notification notification) {
-		if (! AttributeChangeNotification.class.isInstance(notification) ){
-			getGenericNotificationEvent().fire(new NotificationEvent(notification));
-		}
-		else{
-			getAttributeChangeNotificationEvent().fire(new NotificationEvent(notification));
-		}
-	}
-
-	@SuppressWarnings("unchecked")
-	private Event<NotificationEvent> getGenericNotificationEvent() {
-		if (genericNotificationEvent==null){
-			genericNotificationEvent = Beans.getReference(Event.class , new AnnotationLiteral<Generic>() {});
-		}
-		
-		return genericNotificationEvent;
-	}
-	
-	@SuppressWarnings("unchecked")
-	private Event<NotificationEvent> getAttributeChangeNotificationEvent() {
-		if (attributeChangeNotificationEvent==null){
-			attributeChangeNotificationEvent = Beans.getReference(Event.class , new AnnotationLiteral<AttributeChange>() {});
-		}
-		
-		return attributeChangeNotificationEvent;
-	}
-	
-	
-	
-}
@@ -0,0 +1,79 @@
+/*
+ * Demoiselle Framework
+ * Copyright (C) 2011 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 br.gov.frameworkdemoiselle.stereotype;
+
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.inject.Stereotype;
+import javax.enterprise.util.Nonbinding;
+
+/**
+ * <p>Identifies a <b>management controller</b> class. What it means is that an external client can manage the application
+ * this class is in by reading or writing it's attributes and calling it's operations.</p>
+ * <p>
+ * Only fields annotated with {@link br.gov.frameworkdemoiselle.annotation.ManagedProperty} or
+ * methods annotated with {@link br.gov.frameworkdemoiselle.annotation.ManagedOperation} will be exposed
+ * to clients.</p>
+ * <p>This stereotype only defines a class as managed, you need to choose an extension that will expose this managed class
+ * to external clients using any technology available. One example is the Demoiselle JMX extension, that will expose
+ * managed classes as MBeans.</p> 
+ * 
+ * @author SERPRO
+ */
+@ApplicationScoped
+@Stereotype
+@Documented
+@Controller
+@Inherited
+@Retention(RUNTIME)
+@Target({ TYPE })
+public @interface ManagementController {
+	
+	/**
+	 * @return Human readable description of this managed class.
+	 */
+	@Nonbinding
+	String description() default "";
+
+}
@@ -113,4 +113,6 @@ management-debug-starting-custom-context=Levantando contexto {0} para executar c
 management-debug-stoping-custom-context=Desligando contexto {0} para classe gerenciada {1}
 management-debug-registering-managed-type=Registrando classe gerenciada [{0}]
 management-debug-processing-management-extension=Processando extens\u00E3o de gerenciamento [{0}]
-management-debug-removing-management-extension=Desativando extens\u00E3o de gerenciamento [{0}]
 \ No newline at end of file
+management-debug-removing-management-extension=Desativando extens\u00E3o de gerenciamento [{0}]
+
+validation-validator-not-found=Nenhum provedor de valida\u00E7\u00E3o de beans encontrado, as anota\u00E7\u00F5es de valida\u00E7\u00E3o n\u00E3o ser\u00E3o processadas
@@ -1,25 +0,0 @@
-package management;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-import javax.enterprise.context.ApplicationScoped;
-
-import br.gov.frameworkdemoiselle.management.internal.ManagedType;
-
-@ApplicationScoped
-public class ManagedClassStore {
-	
-	private List<ManagedType> managedTypes = new ArrayList<ManagedType>();
-
-	
-	public List<ManagedType> getManagedTypes() {
-		return managedTypes;
-	}
-
-	public void addManagedTypes(Collection<ManagedType> managedTypes){
-		this.managedTypes.addAll(managedTypes);
-	}
-	
-}
+/*
+ * 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 management;
 import java.io.File;
@@ -6,6 +42,7 @@ import java.util.List;
 import management.testclasses.DummyManagedClass;
 import management.testclasses.DummyManagedClassPropertyError;
 import management.testclasses.DummyManagementExtension;
+import management.testclasses.ManagedClassStore;
 import org.jboss.arquillian.container.test.api.Deployer;
 import org.jboss.arquillian.container.test.api.Deployment;
@@ -19,8 +56,8 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import test.LocaleProducer;
-import br.gov.frameworkdemoiselle.management.extension.ManagementExtension;
-import br.gov.frameworkdemoiselle.management.internal.ManagedType;
+import br.gov.frameworkdemoiselle.internal.management.ManagedType;
+import br.gov.frameworkdemoiselle.lifecycle.ManagementExtension;
 import br.gov.frameworkdemoiselle.util.Beans;
 @RunWith(Arquillian.class)
@@ -44,7 +81,7 @@ public class ManagementBootstrapTestCase {
 						new File("src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension"),
 						"services/javax.enterprise.inject.spi.Extension")
 				.addPackages(false, ManagementBootstrapTestCase.class.getPackage())
-				.addClasses(DummyManagementExtension.class,DummyManagedClass.class);
+				.addClasses(DummyManagementExtension.class,DummyManagedClass.class,ManagedClassStore.class);
 	}
 	/**
@@ -63,7 +100,7 @@ public class ManagementBootstrapTestCase {
 						new File("src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension"),
 						"services/javax.enterprise.inject.spi.Extension")
 				.addPackages(false, ManagementBootstrapTestCase.class.getPackage())
-				.addClasses(DummyManagementExtension.class,DummyManagedClassPropertyError.class);
+				.addClasses(DummyManagementExtension.class,DummyManagedClassPropertyError.class,ManagedClassStore.class);
 	}
 	/**
@@ -74,7 +111,7 @@ public class ManagementBootstrapTestCase {
 		deployer.deploy("default");
 		// "store" é application scoped e é usado pelo DummyManagementExtension para
-		// armazenar todos os beans anotados com @Managed. Se o bootstrap rodou corretamente,
+		// armazenar todos os beans anotados com @ManagementController. Se o bootstrap rodou corretamente,
 		// ele chamou DummyManagementExtension.initialize e este store conterá o bean de teste que anotamos.
 		ManagedClassStore store = Beans.getReference(ManagedClassStore.class);
@@ -92,7 +129,7 @@ public class ManagementBootstrapTestCase {
 		deployer.deploy("default");
 		// "store" é application scoped e é usado pelo DummyManagementExtension para
-		// armazenar todos os beans anotados com @Managed. Se o bootstrap rodou corretamente,
+		// armazenar todos os beans anotados com @ManagementController. Se o bootstrap rodou corretamente,
 		// ele chamou DummyManagementExtension.initialize e este store conterá o bean de teste que anotamos.
 		// Nós então disparamos o evento de shutdown onde ele deverá limpar o store.
 		ManagedClassStore store = Beans.getReference(ManagedClassStore.class);
@@ -0,0 +1,164 @@
+/*
+ * 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 management;
+
+import java.io.File;
+
+import junit.framework.Assert;
+import management.testclasses.DummyManagedClass;
+import management.testclasses.DummyManagementExtension;
+import management.testclasses.ManagedClassStore;
+
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.FileAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import test.LocaleProducer;
+import br.gov.frameworkdemoiselle.DemoiselleException;
+import br.gov.frameworkdemoiselle.util.Beans;
+
+/**
+ * Test case that simulates a management extension and tests if properties and operations on a managed class can be
+ * easily accessed and invoked.
+ * 
+ * @author serpro
+ */
+@RunWith(Arquillian.class)
+public class ManagementTestCase {
+
+	@Deployment
+	public static JavaArchive createMultithreadedDeployment() {
+		return ShrinkWrap
+				.create(JavaArchive.class)
+				.addClass(LocaleProducer.class)
+				.addPackages(true, "br")
+				.addAsResource(new FileAsset(new File("src/test/resources/test/beans.xml")), "beans.xml")
+				.addAsManifestResource(
+						new File("src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension"),
+						"services/javax.enterprise.inject.spi.Extension")
+				.addPackages(false, ManagementTestCase.class.getPackage())
+				.addClasses(DummyManagementExtension.class, DummyManagedClass.class, ManagedClassStore.class);
+	}
+
+	@Test
+	public void testReadProperty() {
+		DummyManagedClass managedClass = Beans.getReference(DummyManagedClass.class);
+		managedClass.setName("Test Name");
+
+		// store é nossa extensão de gerenciamento falsa, então estamos testando um "cliente" acessando
+		// nosso tipo gerenciado DummyManagedClass remotamente.
+		ManagedClassStore store = Beans.getReference(ManagedClassStore.class);
+		Object name = store.getProperty(DummyManagedClass.class, "name");
+		Assert.assertEquals("Test Name", name);
+	}
+
+	@Test
+	public void testWriteProperty() {
+		// store é nossa extensão de gerenciamento falsa, então estamos testando um "cliente" definindo
+		// um novo valor em uma propriedade de nosso tipo gerenciado DummyManagedClass remotamente.
+		ManagedClassStore store = Beans.getReference(ManagedClassStore.class);
+		store.setProperty(DummyManagedClass.class, "name", "Test Name");
+
+		DummyManagedClass managedClass = Beans.getReference(DummyManagedClass.class);
+		Assert.assertEquals("Test Name", managedClass.getName());
+	}
+
+	@Test
+	public void testReadAWriteOnly() {
+
+		ManagedClassStore store = Beans.getReference(ManagedClassStore.class);
+
+		try {
+			store.getProperty(DummyManagedClass.class, "writeOnlyProperty");
+			Assert.fail();
+		} catch (DemoiselleException de) {
+			// SUCCESS
+		}
+
+	}
+
+	@Test
+	public void testWriteAReadOnly() {
+
+		ManagedClassStore store = Beans.getReference(ManagedClassStore.class);
+
+		try {
+			store.setProperty(DummyManagedClass.class, "readOnlyProperty", "New Value");
+			Assert.fail();
+		} catch (DemoiselleException de) {
+			// SUCCESS
+		}
+
+	}
+
+	@Test
+	public void testInvokeOperation() {
+
+		ManagedClassStore store = Beans.getReference(ManagedClassStore.class);
+
+		try {
+			store.setProperty(DummyManagedClass.class, "firstFactor", new Integer(10));
+			store.setProperty(DummyManagedClass.class, "secondFactor", new Integer(15));
+			Integer response = (Integer) store.invoke(DummyManagedClass.class, "sumFactors");
+			Assert.assertEquals(new Integer(25), response);
+		} catch (DemoiselleException de) {
+			Assert.fail(de.getMessage());
+		}
+
+	}
+
+	@Test
+	public void testInvokeNonAnnotatedOperation() {
+
+		ManagedClassStore store = Beans.getReference(ManagedClassStore.class);
+
+		try {
+			// O método "nonOperationAnnotatedMethod" existe na classe DummyManagedClass, mas não está anotado como
+			// "@ManagedOperation", então
+			// ela não pode ser exposta para extensões.
+			store.invoke(DummyManagedClass.class, "nonOperationAnnotatedMethod");
+			Assert.fail();
+		} catch (DemoiselleException de) {
+			// SUCCESS
+		}
+
+	}
+}
+/*
+ * 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 management;
 import java.io.File;
@@ -18,11 +54,11 @@ import org.junit.runner.RunWith;
 import test.LocaleProducer;
 import br.gov.frameworkdemoiselle.annotation.Name;
-import br.gov.frameworkdemoiselle.management.internal.ManagedType;
-import br.gov.frameworkdemoiselle.management.internal.MonitoringManager;
-import br.gov.frameworkdemoiselle.management.notification.AttributeChangeNotification;
-import br.gov.frameworkdemoiselle.management.notification.Notification;
-import br.gov.frameworkdemoiselle.management.notification.NotificationManager;
+import br.gov.frameworkdemoiselle.internal.management.ManagedType;
+import br.gov.frameworkdemoiselle.internal.management.Management;
+import br.gov.frameworkdemoiselle.management.AttributeChangeNotification;
+import br.gov.frameworkdemoiselle.management.Notification;
+import br.gov.frameworkdemoiselle.management.NotificationManager;
 import br.gov.frameworkdemoiselle.util.Beans;
 import br.gov.frameworkdemoiselle.util.ResourceBundle;
@@ -53,7 +89,7 @@ public class NotificationTestCase {
 				.addAsManifestResource(
 						new File("src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension"),
 						"services/javax.enterprise.inject.spi.Extension")
-				.addPackages(false, ManagementBootstrapTestCase.class.getPackage())
+				.addPackages(false, NotificationTestCase.class.getPackage())
 				.addClasses(DummyNotificationListener.class,DummyManagedClass.class);
 	}
@@ -83,7 +119,7 @@ public class NotificationTestCase {
 	 */
 	@Test
 	public void testNotifyChangeManagedClass(){
-		MonitoringManager manager = Beans.getReference(MonitoringManager.class);
+		Management manager = Beans.getReference(Management.class);
 		for (ManagedType type : manager.getManagedTypes()){
 			if (type.getType().equals(DummyManagedClass.class)){
@@ -0,0 +1,62 @@
+package management;
+
+import java.io.File;
+
+import management.testclasses.DummyManagedClass;
+import management.testclasses.DummyManagementExtension;
+import management.testclasses.ManagedClassStore;
+
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.FileAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import test.LocaleProducer;
+import br.gov.frameworkdemoiselle.DemoiselleException;
+import br.gov.frameworkdemoiselle.util.Beans;
+
+@RunWith(Arquillian.class)
+public class ValidationTestCase {
+	
+	@Deployment
+	public static JavaArchive createDeployment() {
+		return ShrinkWrap
+				.create(JavaArchive.class)
+				.addClass(LocaleProducer.class)
+				.addPackages(true, "br")
+				.addAsResource(new FileAsset(new File("src/test/resources/test/beans.xml")), "beans.xml")
+				.addAsManifestResource(
+						new File("src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension"),
+						"services/javax.enterprise.inject.spi.Extension")
+				.addPackages(false, NotificationTestCase.class.getPackage())
+				.addClasses(DummyManagementExtension.class,ManagedClassStore.class,DummyManagedClass.class);
+	}
+	
+	/**
+	 * Test if changing properties of a management controller passes through
+	 * validation phase.
+	 */
+	@Test
+	public void testManagedClassValidation(){
+		
+		//Testa se é possível definir um valor válido para uma propriedade.
+		ManagedClassStore store = Beans.getReference(ManagedClassStore.class);
+		store.setProperty(DummyManagedClass.class, "id", new Integer(1));
+		Assert.assertEquals(new Integer(1), store.getProperty(DummyManagedClass.class, "id"));
+		
+		//Testa se definir um valor inválido dispara o erro adequado
+		try{
+			store.setProperty(DummyManagedClass.class, "id", new Integer(5));
+			Assert.fail();
+		}
+		catch(DemoiselleException e){
+			//SUCCESS
+		}
+		
+	}
+
+}
+/*
+ * 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 management.testclasses;
 import java.util.UUID;
-import br.gov.frameworkdemoiselle.management.annotation.Managed;
-import br.gov.frameworkdemoiselle.management.annotation.Operation;
-import br.gov.frameworkdemoiselle.management.annotation.Property;
-import br.gov.frameworkdemoiselle.management.annotation.validation.AllowedValues;
-import br.gov.frameworkdemoiselle.management.annotation.validation.AllowedValues.ValueType;
+import br.gov.frameworkdemoiselle.annotation.ManagedOperation;
+import br.gov.frameworkdemoiselle.annotation.ManagedProperty;
+import br.gov.frameworkdemoiselle.stereotype.ManagementController;
+import br.gov.frameworkdemoiselle.validation.annotation.AllowedValues;
+import br.gov.frameworkdemoiselle.validation.annotation.AllowedValues.ValueType;
-@Managed
+@ManagementController
 public class DummyManagedClass {
-	@Property
-	@AllowedValues(allows={"f","m","F","M"},valueType=ValueType.INTEGER)
+	@ManagedProperty
+	private String name;
+	
+	@ManagedProperty
+	@AllowedValues(allows={"1","2","3","4"},valueType=ValueType.INTEGER)
 	private Integer id;
-	@Property
+	@ManagedProperty
+	private Integer firstFactor , secondFactor;
+	
+	@ManagedProperty
 	private String uuid;
-	@Property
+	@ManagedProperty
 	private String writeOnlyProperty;
+	@ManagedProperty
+	private String readOnlyProperty = "Default Value";
+	
 	/**
 	 * Propriedade para testar detecção de métodos GET e SET quando propriedade tem apenas uma letra.
 	 */
-	@Property
+	@ManagedProperty
 	private Integer a;
 	/**
 	 * Propriedade para testar detecção de métodos GET e SET quando propriedade tem apenas letras maiúsculas.
 	 */
-	@Property
+	@ManagedProperty
 	private Integer MAIUSCULO;
 	public Integer getId() {
@@ -66,9 +111,92 @@ public class DummyManagedClass {
 		MAIUSCULO = mAIUSCULO;
 	}
-	@Operation(description="Generates a random UUID")
+	@ManagedOperation(description="Generates a random UUID")
 	public String generateUUID(){
 		this.uuid = UUID.randomUUID().toString();
 		return this.uuid;
 	}
+
+	
+	public String getName() {
+		return name;
+	}
+
+	
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	
+	public String getReadOnlyProperty() {
+		return readOnlyProperty;
+	}
+
+	
+	public Integer getFirstFactor() {
+		return firstFactor;
+	}
+
+	
+	public void setFirstFactor(Integer firstFactor) {
+		this.firstFactor = firstFactor;
+	}
+
+	
+	public Integer getSecondFactor() {
+		return secondFactor;
+	}
+
+	
+	public void setSecondFactor(Integer secondFactor) {
+		this.secondFactor = secondFactor;
+	}
+	
+	@ManagedOperation
+	public Integer calculateFactorsNonSynchronized(Integer firstFactor , Integer secondFactor){
+		setFirstFactor(firstFactor);
+		setSecondFactor(secondFactor);
+		
+		try {
+			int temp = firstFactor + secondFactor;
+			Thread.sleep( (long)(Math.random() * 100));
+			
+			temp = temp + firstFactor;
+			Thread.sleep( (long)(Math.random() * 100));
+			
+			temp = temp + secondFactor;
+			Thread.sleep( (long)(Math.random() * 100));
+			
+			return temp;
+		} catch (InterruptedException e) {
+			throw new RuntimeException(e);
+		}
+	}
+	
+	@ManagedOperation
+	public synchronized Integer calculateFactorsSynchronized(Integer firstFactor , Integer secondFactor){
+		setFirstFactor(firstFactor);
+		setSecondFactor(secondFactor);
+		
+		try {
+			int temp = firstFactor + secondFactor;
+			Thread.sleep( (long)(Math.random() * 100));
+			
+			temp = temp + firstFactor;
+			Thread.sleep( (long)(Math.random() * 100));
+			
+			temp = temp + secondFactor;
+			Thread.sleep( (long)(Math.random() * 100));
+			
+			return temp;
+		} catch (InterruptedException e) {
+			throw new RuntimeException(e);
+		}
+	}
+	
+	public void nonOperationAnnotatedMethod(){
+		System.out.println("Test");
+	}
+	
+	
 }
+/*
+ * 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 management.testclasses;
-import br.gov.frameworkdemoiselle.management.annotation.Managed;
-import br.gov.frameworkdemoiselle.management.annotation.Property;
+import br.gov.frameworkdemoiselle.annotation.ManagedProperty;
+import br.gov.frameworkdemoiselle.stereotype.ManagementController;
 /**
@@ -11,13 +47,13 @@ import br.gov.frameworkdemoiselle.management.annotation.Property;
  * @author serpro
  *
  */
-@Managed
+@ManagementController
 public class DummyManagedClassPropertyError {
 	/**
-	 * Property with no setter or getter
+	 * ManagedProperty with no setter or getter
 	 */
-	@Property
+	@ManagedProperty
 	private Long property;
 }
+/*
+ * 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 management.testclasses;
 import java.util.List;
 import javax.inject.Inject;
-import management.ManagedClassStore;
-import br.gov.frameworkdemoiselle.management.extension.ManagementExtension;
-import br.gov.frameworkdemoiselle.management.internal.ManagedType;
+import br.gov.frameworkdemoiselle.internal.management.ManagedType;
+import br.gov.frameworkdemoiselle.lifecycle.ManagementExtension;
 public class DummyManagementExtension implements ManagementExtension {
+/*
+ * 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 management.testclasses;
 import javax.enterprise.context.ApplicationScoped;
 import javax.enterprise.event.Observes;
-import br.gov.frameworkdemoiselle.management.internal.notification.event.NotificationEvent;
-import br.gov.frameworkdemoiselle.management.internal.notification.qualifier.AttributeChange;
-import br.gov.frameworkdemoiselle.management.internal.notification.qualifier.Generic;
-import br.gov.frameworkdemoiselle.management.notification.AttributeChangeNotification;
-import br.gov.frameworkdemoiselle.management.notification.NotificationManager;
+import br.gov.frameworkdemoiselle.internal.management.ManagementNotificationEvent;
+import br.gov.frameworkdemoiselle.internal.management.qualifier.AttributeChange;
+import br.gov.frameworkdemoiselle.internal.management.qualifier.Generic;
+import br.gov.frameworkdemoiselle.management.AttributeChangeNotification;
+import br.gov.frameworkdemoiselle.management.NotificationManager;
 /**
  * Dummy class to test receiving of notifications sent by the {@link NotificationManager} 
@@ -20,11 +56,11 @@ public class DummyNotificationListener {
 	private String message = null;
-	public void listenNotification(@Observes @Generic NotificationEvent event){
+	public void listenNotification(@Observes @Generic ManagementNotificationEvent event){
 		message = event.getNotification().getMessage().toString();
 	}
-	public void listenAttributeChangeNotification(@Observes @AttributeChange NotificationEvent event){
+	public void listenAttributeChangeNotification(@Observes @AttributeChange ManagementNotificationEvent event){
 		AttributeChangeNotification notification = (AttributeChangeNotification)event.getNotification();
 		message = notification.getMessage().toString() + " - " + notification.getAttributeName();
 	}
@@ -0,0 +1,102 @@
+/*
+ * 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 management.testclasses;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import br.gov.frameworkdemoiselle.internal.management.ManagedType;
+import br.gov.frameworkdemoiselle.internal.management.Management;
+import br.gov.frameworkdemoiselle.util.Beans;
+
+/**
+ * Dummy class that stores managed types detected by the management bootstrap
+ * and can read/write properties and invoke operations on them, simulating a management
+ * extension like JMX or SNMP. 
+ * 
+ * @author serpro
+ *
+ */
+@ApplicationScoped
+public class ManagedClassStore {
+	
+	private List<ManagedType> managedTypes = new ArrayList<ManagedType>();
+
+	
+	public List<ManagedType> getManagedTypes() {
+		return managedTypes;
+	}
+
+	public void addManagedTypes(Collection<ManagedType> managedTypes){
+		this.managedTypes.addAll(managedTypes);
+	}
+	
+	public void setProperty(Class<?> managedClass , String attributeName , Object newValue){
+		Management manager = Beans.getReference(Management.class);
+		for (ManagedType type : manager.getManagedTypes()){
+			if (type.getType().equals(managedClass)){
+				manager.setProperty(type, attributeName, newValue);
+				break;
+			}
+		}
+	}
+	
+	public Object getProperty(Class<?> managedClass , String attributeName ){
+		Management manager = Beans.getReference(Management.class);
+		for (ManagedType type : manager.getManagedTypes()){
+			if (type.getType().equals(managedClass)){
+				return manager.getProperty(type, attributeName);
+			}
+		}
+		
+		return null;
+	}
+	
+	public Object invoke(Class<?> managedClass , String operation , Object...  params){
+		Management manager = Beans.getReference(Management.class);
+		for (ManagedType type : manager.getManagedTypes()){
+			if (type.getType().equals(managedClass)){
+				return manager.invoke(type, operation, params);
+			}
+		}
+		
+		return null;
+	}
+}
@@ -0,0 +1,74 @@		@@ -0,0 +1,74 @@
	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 br.gov.frameworkdemoiselle.annotation;
	38	+
	39	+import java.lang.annotation.Documented;
	40	+import java.lang.annotation.ElementType;
	41	+import java.lang.annotation.Retention;
	42	+import java.lang.annotation.RetentionPolicy;
	43	+import java.lang.annotation.Target;
	44	+
	45	+import javax.enterprise.util.Nonbinding;
	46	+
	47	+import br.gov.frameworkdemoiselle.DemoiselleException;
	48	+
	49	+/**
	50	+ * <p>Indicates that a method is a <b>managed operation</b>, meaning you can manage some aspect of the application by calling it from a external management client.</p>
	51	+ * <p>This annotation can't be used together with {@link ManagedProperty}, doing so will throw a {@link DemoiselleException}.</p>
	52	+ *
	53	+ * @author SERPRO
	54	+ *
	55	+ */
	56	+@Documented
	57	+@Target({ElementType.METHOD})
	58	+@Retention(RetentionPolicy.RUNTIME)
	59	+public @interface ManagedOperation {
	60	+
	61	+ /**
	62	+ * Description that will be used to publish the operation to clients.
	63	+ * Defaults to an empty description.
	64	+ */
	65	+ @Nonbinding
	66	+ String description() default "";
	67	+
	68	+ /**
	69	+ * Type of operation. Defaults to {@link OperationType#UNKNOWN}.
	70	+ */
	71	+ @Nonbinding
	72	+ OperationType type() default OperationType.UNKNOWN;
	73	+
	74	+}
@@ -0,0 +1,69 @@		@@ -0,0 +1,69 @@
	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 br.gov.frameworkdemoiselle.annotation;
	38	+
	39	+import java.lang.annotation.Documented;
	40	+import java.lang.annotation.ElementType;
	41	+import java.lang.annotation.Retention;
	42	+import java.lang.annotation.RetentionPolicy;
	43	+import java.lang.annotation.Target;
	44	+
	45	+import javax.enterprise.util.Nonbinding;
	46	+
	47	+/**
	48	+ * <p>Indicates that a field must be exposed as a property to management clients.</p>
	49	+ * <p>The property will be writable if there's a public setter method
	50	+ * declared for the field and readable if there's a getter method.</p>
	51	+ * <p>It's a runtime error to annotate a field with no getter and no setter method.</p>
	52	+ * <p>It's also a runtime error to declare a field as a property and one or both of it's getter and setter
	53	+ * methods as an operation using the {@link ManagedOperation} annotation.</p>
	54	+ *
	55	+ * @author SERPRO
	56	+ *
	57	+ */
	58	+@Documented
	59	+@Target({ElementType.FIELD})
	60	+@Retention(RetentionPolicy.RUNTIME)
	61	+public @interface ManagedProperty {
	62	+
	63	+ /**
	64	+ * @return The description of this property exposed to management clients.
	65	+ */
	66	+ @Nonbinding
	67	+ String description() default "";
	68	+
	69	+}
@@ -0,0 +1,73 @@		@@ -0,0 +1,73 @@
	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 br.gov.frameworkdemoiselle.annotation;
	38	+
	39	+import java.lang.annotation.Documented;
	40	+import java.lang.annotation.ElementType;
	41	+import java.lang.annotation.Retention;
	42	+import java.lang.annotation.RetentionPolicy;
	43	+import java.lang.annotation.Target;
	44	+
	45	+import javax.enterprise.util.Nonbinding;
	46	+
	47	+/**
	48	+ * <p>Optional annotation to write additional detail about an operation's parameter.</p>
	49	+ * <p>This annotation is ignored for non-operation methods.</p>
	50	+ *
	51	+ * @author SERPRO
	52	+ *
	53	+ */
	54	+@Documented
	55	+@Target({ElementType.PARAMETER})
	56	+@Retention(RetentionPolicy.RUNTIME)
	57	+public @interface OperationParameter {
	58	+
	59	+ /**
	60	+ * Name that will be used to publish this operation's parameter to clients.
	61	+ */
	62	+ @Nonbinding
	63	+ String name();
	64	+
	65	+ /**
	66	+ * Optional description that will be used to publish this operation's parameter to clients.
	67	+ * Defaults to an empty description.
	68	+ */
	69	+ @Nonbinding
	70	+ String description() default "";
	71	+
	72	+
	73	+}
@@ -0,0 +1,89 @@		@@ -0,0 +1,89 @@
	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 br.gov.frameworkdemoiselle.annotation;
	38	+
	39	+import javax.management.MBeanOperationInfo;
	40	+
	41	+
	42	+/**
	43	+ * <p>Define the operation type for an operation inside a ManagementController class.</p>
	44	+ *
	45	+ * <p>This is an optional annotation and it's significanse will change based on the management extension
	46	+ * used. Most extensions will just publish this information to the client so it can better show to the user the inner
	47	+ * workings of the annotated operation.</p>
	48	+ *
	49	+ *
	50	+ * @author SERPRO
	51	+ *
	52	+ */
	53	+public enum OperationType {
	54	+
	55	+ /**
	56	+ * ManagedOperation is write-only, it causes the application
	57	+ * to change some of it's behaviour but doesn't return any kind of information
	58	+ */
	59	+ ACTION(MBeanOperationInfo.ACTION)
	60	+ ,
	61	+ /**
	62	+ * ManagedOperation is read-only, it will operate over data provided by the application and return some information,
	63	+ * but will not change the application in any way.
	64	+ */
	65	+ INFO(MBeanOperationInfo.INFO)
	66	+ ,
	67	+ /**
	68	+ * ManagedOperation is read-write, it will both change the way the application work and return some information regarding
	69	+ * the result of the operation.
	70	+ */
	71	+ ACTION_INFO(MBeanOperationInfo.ACTION_INFO)
	72	+ ,
	73	+ /**
	74	+ * The effect of calling this operation is unknown. This is the default type and if this type is assigned to an operation,
	75	+ * the user must rely on the {@link ManagedOperation#description()} attribute to learn about how the operation works.
	76	+ */
	77	+ UNKNOWN(MBeanOperationInfo.UNKNOWN);
	78	+
	79	+ private int operationTypeValue;
	80	+
	81	+ private OperationType(int type){
	82	+ this.operationTypeValue = type;
	83	+ }
	84	+
	85	+ public int getValue(){
	86	+ return operationTypeValue;
	87	+ }
	88	+
	89	+}
	@@ -2,10 +2,10 @@ package br.gov.frameworkdemoiselle.internal.context;		@@ -2,10 +2,10 @@ package br.gov.frameworkdemoiselle.internal.context;
2		2
3	import javax.enterprise.context.RequestScoped;	3	import javax.enterprise.context.RequestScoped;
4		4
5	-import br.gov.frameworkdemoiselle.management.annotation.Managed;	5	+import br.gov.frameworkdemoiselle.stereotype.ManagementController;
6		6
7	/**	7	/**
8	- * Context that stores {@link RequestScoped} beans during client calls to {@link Managed} classes.	8	+ * Context that stores {@link RequestScoped} beans during client calls to {@link ManagementController} classes.
9	* This context is only activated when no other context is active for {@link RequestScoped}.	9	* This context is only activated when no other context is active for {@link RequestScoped}.
10	*	10	*
11	* @author serpro	11	* @author serpro
@@ -0,0 +1,334 @@		@@ -0,0 +1,334 @@
	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 br.gov.frameworkdemoiselle.internal.management;
	38	+
	39	+import java.lang.annotation.Annotation;
	40	+import java.lang.reflect.Field;
	41	+import java.lang.reflect.Method;
	42	+import java.util.TreeMap;
	43	+
	44	+import br.gov.frameworkdemoiselle.DemoiselleException;
	45	+import br.gov.frameworkdemoiselle.annotation.ManagedOperation;
	46	+import br.gov.frameworkdemoiselle.annotation.ManagedProperty;
	47	+import br.gov.frameworkdemoiselle.annotation.OperationParameter;
	48	+import br.gov.frameworkdemoiselle.internal.producer.ResourceBundleProducer;
	49	+import br.gov.frameworkdemoiselle.stereotype.ManagementController;
	50	+import br.gov.frameworkdemoiselle.util.ResourceBundle;
	51	+
	52	+/**
	53	+ * <p>Package class containing information about a discovered {@link ManagementController}.</p>
	54	+ *
	55	+ * <p>Instances if this class are passed to each discovered management extension during bootstrap so they can have
	56	+ * enough information to expose all discovered {@link ManagementController}'s to management clients.</p>
	57	+ *
	58	+ * @author serpro
	59	+ */
	60	+public class ManagedType {
	61	+
	62	+ private Class<?> type;
	63	+
	64	+ private TreeMap<String, FieldDetail> fields;
	65	+
	66	+ private TreeMap<String, MethodDetail> operationMethods;
	67	+
	68	+ private ResourceBundle bundle;
	69	+
	70	+ private String description;
	71	+
	72	+ public ManagedType(Class<?> type) {
	73	+ bundle = ResourceBundleProducer.create("demoiselle-core-bundle");
	74	+
	75	+ if (type == null) {
	76	+ throw new DemoiselleException(bundle.getString("management-null-class-defined"));
	77	+ }
	78	+ if (!type.isAnnotationPresent(ManagementController.class)) {
	79	+ throw new DemoiselleException(bundle.getString("management-no-annotation-found", type.getCanonicalName()));
	80	+ }
	81	+
	82	+ this.type = type;
	83	+ fields = new TreeMap<String, FieldDetail>();
	84	+ operationMethods = new TreeMap<String, MethodDetail>();
	85	+ this.description = type.getAnnotation(ManagementController.class).description();
	86	+
	87	+ initialize();
	88	+ }
	89	+
	90	+ public Class<?> getType() {
	91	+ return type;
	92	+ }
	93	+
	94	+ public String getDescription() {
	95	+ return description;
	96	+ }
	97	+
	98	+ public TreeMap<String, FieldDetail> getFields() {
	99	+ return fields;
	100	+ }
	101	+
	102	+ public TreeMap<String, MethodDetail> getOperationMethods() {
	103	+ return operationMethods;
	104	+ }
	105	+
	106	+ private void initialize() {
	107	+ // Para cada atributo verifica se ele está anotado com ManagedProperty e extrai as informações dele (método get, set e
	108	+ // descrição do atributo).
	109	+ Field[] fields = type.getDeclaredFields();
	110	+ if (fields != null) {
	111	+ for (Field field : fields) {
	112	+ if (field.isAnnotationPresent(ManagedProperty.class)) {
	113	+ // Obtém os métodos GET e SET para esta propriedade
	114	+ Method getterMethod = getGetterMethod(field);
	115	+ Method setterMethod = getSetterMethod(field);
	116	+ if (getterMethod == null && setterMethod == null) {
	117	+ throw new DemoiselleException(bundle.getString("management-invalid-property-no-getter-setter",
	118	+ type.getSimpleName(), field.getName()));
	119	+ } else if ((getterMethod != null && getterMethod.isAnnotationPresent(ManagedOperation.class))
	120	+ \|\| (setterMethod != null && setterMethod.isAnnotationPresent(ManagedOperation.class))) {
	121	+ throw new DemoiselleException(bundle.getString("management-invalid-property-as-operation",
	122	+ type.getSimpleName()));
	123	+ }
	124	+
	125	+ String propertyDescription = field.getAnnotation(ManagedProperty.class).description();
	126	+
	127	+ this.fields.put(field.getName(), new FieldDetail(field, propertyDescription, getterMethod,
	128	+ setterMethod));
	129	+ }
	130	+ }
	131	+ }
	132	+
	133	+ // Para cada metodo verifica se ele está anotado com ManagedOperation e cria um MBeanOperationInfo para ele.
	134	+ Method[] methodList = type.getMethods();
	135	+ if (methodList != null) {
	136	+ for (Method method : methodList) {
	137	+ ManagedOperation opAnnotation = method.getAnnotation(ManagedOperation.class);
	138	+
	139	+ if (opAnnotation != null) {
	140	+ // Lemos as informações sobre o método e criamos uma instância
	141	+ // de MethodDetail para representar este método como uma
	142	+ // operação.
	143	+
	144	+ Class<?>[] parameterTypes = method.getParameterTypes();
	145	+ Annotation[][] parameterAnnotations = method.getParameterAnnotations();
	146	+ ParameterDetail[] parameterDetails = new ParameterDetail[parameterTypes.length];
	147	+
	148	+ for (int i = 0; i < parameterTypes.length; i++) {
	149	+ OperationParameter paramAnnotation = null;
	150	+ for (Annotation annotation : parameterAnnotations[i]) {
	151	+ if (annotation.annotationType() == OperationParameter.class) {
	152	+ paramAnnotation = (OperationParameter) annotation;
	153	+ break;
	154	+ }
	155	+ }
	156	+
	157	+ String name = paramAnnotation != null ? paramAnnotation.name() : ("arg" + i);
	158	+ String description = paramAnnotation != null ? paramAnnotation.description() : null;
	159	+
	160	+ parameterDetails[i] = new ParameterDetail(parameterTypes[i], name, description);
	161	+ }
	162	+
	163	+ // Com todas as informações, criamos nossa instância de MethodDetail e
	164	+ // acrescentamos na lista de todas as operações.
	165	+ MethodDetail detail = new MethodDetail(method, opAnnotation.description(), parameterDetails);
	166	+ operationMethods.put(method.getName(), detail);
	167	+ }
	168	+ }
	169	+ }
	170	+ }
	171	+
	172	+ /**
	173	+ * Returns the public getter method for a given field, or <code>null</code> if no getter method can be found.
	174	+ */
	175	+ private Method getGetterMethod(Field field) {
	176	+ StringBuffer getterMethodName = new StringBuffer()
	177	+ .append("get")
	178	+ .append(field.getName().substring(0, 1).toUpperCase())
	179	+ .append(field.getName().substring(1));
	180	+
	181	+ Method getterMethod;
	182	+
	183	+ try {
	184	+ getterMethod = type.getMethod(getterMethodName.toString());
	185	+ } catch (Exception e) {
	186	+ getterMethod = null;
	187	+ }
	188	+
	189	+ // Se atributo for boolean, procura método getter no formato "isAttribute".
	190	+ if (getterMethod == null
	191	+ && (Boolean.TYPE.isAssignableFrom(field.getType()) \|\| Boolean.class.isAssignableFrom(field.getType()))) {
	192	+ // Boolean.TYPE representa o tipo primitivo "boolean", Boolean.class é a classe wrapper.
	193	+ getterMethodName = new StringBuffer()
	194	+ .append("is")
	195	+ .append(field.getName().substring(0, 1).toUpperCase())
	196	+ .append(field.getName().substring(1).toUpperCase());
	197	+
	198	+ try {
	199	+ getterMethod = type.getMethod(getterMethodName.toString());
	200	+ } catch (Exception e) {
	201	+ getterMethod = null;
	202	+ }
	203	+ }
	204	+
	205	+ return getterMethod;
	206	+ }
	207	+
	208	+ /**
	209	+ * Returns the public setter method for a given field, or <code>null</code> if no setter method can be found.
	210	+ */
	211	+ private Method getSetterMethod(Field field) {
	212	+ StringBuffer setterMethodName = new StringBuffer()
	213	+ .append("set")
	214	+ .append(field.getName().substring(0, 1).toUpperCase())
	215	+ .append(field.getName().substring(1));
	216	+
	217	+ Method setterMethod;
	218	+
	219	+ try {
	220	+ setterMethod = type.getMethod(setterMethodName.toString() , field.getType());
	221	+ } catch (Exception e) {
	222	+ setterMethod = null;
	223	+ }
	224	+
	225	+ return setterMethod;
	226	+ }
	227	+
	228	+ public final class FieldDetail {
	229	+
	230	+ private final Field field;
	231	+
	232	+ private final String description;
	233	+
	234	+ private Method getterMethod;
	235	+
	236	+ private Method setterMethod;
	237	+
	238	+ public FieldDetail(Field field, String description, Method getterMethod, Method setterMethod) {
	239	+ super();
	240	+ this.field = field;
	241	+ this.description = description;
	242	+ this.getterMethod = getterMethod;
	243	+ this.setterMethod = setterMethod;
	244	+ }
	245	+
	246	+ public Field getField() {
	247	+ return field;
	248	+ }
	249	+
	250	+ public String getDescription() {
	251	+ return description;
	252	+ }
	253	+
	254	+ public Method getGetterMethod() {
	255	+ return getterMethod;
	256	+ }
	257	+
	258	+ public Method getSetterMethod() {
	259	+ return setterMethod;
	260	+ }
	261	+
	262	+ }
	263	+
	264	+ public final class MethodDetail {
	265	+
	266	+ private final Method method;
	267	+
	268	+ private final ParameterDetail[] parameterTypers;
	269	+
	270	+ private String description;
	271	+
	272	+ public MethodDetail(Method method, String description, ParameterDetail[] parameterTypers) {
	273	+ super();
	274	+ this.method = method;
	275	+ this.description = description;
	276	+ this.parameterTypers = parameterTypers;
	277	+ }
	278	+
	279	+ public Method getMethod() {
	280	+ return method;
	281	+ }
	282	+
	283	+ public ParameterDetail[] getParameterTypers() {
	284	+ return parameterTypers;
	285	+ }
	286	+
	287	+ public String getDescription() {
	288	+ return description;
	289	+ }
	290	+
	291	+ }
	292	+
	293	+ public final class ParameterDetail {
	294	+
	295	+ private final Class<?> parameterType;
	296	+
	297	+ private final String parameterName;
	298	+
	299	+ private final String parameterDescription;
	300	+
	301	+ public ParameterDetail(Class<?> parameterType, String parameterName, String parameterDescription) {
	302	+ super();
	303	+ this.parameterType = parameterType;
	304	+ this.parameterName = parameterName;
	305	+ this.parameterDescription = parameterDescription;
	306	+ }
	307	+
	308	+ public Class<?> getParameterType() {
	309	+ return parameterType;
	310	+ }
	311	+
	312	+ public String getParameterName() {
	313	+ return parameterName;
	314	+ }
	315	+
	316	+ public String getParameterDescription() {
	317	+ return parameterDescription;
	318	+ }
	319	+ }
	320	+
	321	+ /**
	322	+ * Indicates another {@link ManagedType} represents the same {@link Class} as this one. This method also supports a
	323	+ * {@link Class} as a parameter, in this case it will return <code>true</code> if the passed class is exactly the
	324	+ * same Java class represented by this {@link ManagedType}.
	325	+ */
	326	+ @Override
	327	+ public boolean equals(Object other) {
	328	+ if (other == null) {
	329	+ return false;
	330	+ }
	331	+
	332	+ return ((ManagedType) other).getType().getCanonicalName().equals(this.getType().getCanonicalName());
	333	+ }
	334	+}
@@ -0,0 +1,351 @@		@@ -0,0 +1,351 @@
	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 br.gov.frameworkdemoiselle.internal.management;
	38	+
	39	+import java.lang.reflect.Method;
	40	+import java.util.ArrayList;
	41	+import java.util.Collection;
	42	+import java.util.List;
	43	+import java.util.Set;
	44	+
	45	+import javax.enterprise.context.ApplicationScoped;
	46	+import javax.enterprise.context.RequestScoped;
	47	+import javax.inject.Inject;
	48	+import javax.management.ReflectionException;
	49	+import javax.validation.ConstraintViolation;
	50	+import javax.validation.Validation;
	51	+import javax.validation.ValidationException;
	52	+import javax.validation.Validator;
	53	+
	54	+import org.slf4j.Logger;
	55	+
	56	+import br.gov.frameworkdemoiselle.DemoiselleException;
	57	+import br.gov.frameworkdemoiselle.annotation.ManagedProperty;
	58	+import br.gov.frameworkdemoiselle.annotation.Name;
	59	+import br.gov.frameworkdemoiselle.internal.context.ContextManager;
	60	+import br.gov.frameworkdemoiselle.internal.context.ManagedContext;
	61	+import br.gov.frameworkdemoiselle.internal.management.ManagedType.MethodDetail;
	62	+import br.gov.frameworkdemoiselle.lifecycle.ManagementExtension;
	63	+import br.gov.frameworkdemoiselle.management.AttributeChangeNotification;
	64	+import br.gov.frameworkdemoiselle.management.NotificationManager;
	65	+import br.gov.frameworkdemoiselle.stereotype.ManagementController;
	66	+import br.gov.frameworkdemoiselle.util.Beans;
	67	+import br.gov.frameworkdemoiselle.util.ResourceBundle;
	68	+
	69	+/**
	70	+ * Central class used by management extensions to obtain information, access properties and call operations
	71	+ * over discovered {@link ManagementController} classes.
	72	+ *
	73	+ * @author serpro
	74	+ */
	75	+@ApplicationScoped
	76	+public class Management {
	77	+
	78	+ @Inject
	79	+ private Logger logger;
	80	+
	81	+ @Inject
	82	+ @Name("demoiselle-core-bundle")
	83	+ private ResourceBundle bundle;
	84	+
	85	+ private final List<ManagedType> managedTypes = new ArrayList<ManagedType>();
	86	+
	87	+ private Validator validator;
	88	+
	89	+ public void addManagedType(ManagedType managedType) {
	90	+ managedTypes.add(managedType);
	91	+ logger.debug(bundle.getString("management-debug-registering-managed-type",managedType.getType().getCanonicalName()));
	92	+ }
	93	+
	94	+ /**
	95	+ * @return List all discovered {@link ManagementController} classes.
	96	+ * The returned list is a shallow copy of the internal list, so you
	97	+ * are free to modify it.
	98	+ *
	99	+ * TODO precisamos desse clone na lista?
	100	+ */
	101	+ public List<ManagedType> getManagedTypes() {
	102	+ ArrayList<ManagedType> cloneList = new ArrayList<ManagedType>();
	103	+ cloneList.addAll(managedTypes);
	104	+ return cloneList;
	105	+ }
	106	+
	107	+ /**
	108	+ * <p>Invoke an operation over a {@link ManagementController}.</p>
	109	+ *
	110	+ * <p>This method is not thread-safe, it's the user's responsibility to
	111	+ * make the operations of the managed type synchronized if necessary.</p>
	112	+ *
	113	+ * @param managedType
	114	+ * A type annotated with {@link ManagementController}. This method will create
	115	+ * an (or obtain an already created) instance of this type and
	116	+ * invoke the operation over it.
	117	+ * @param actionName
	118	+ * Name of method to be invoked, the type must have this
	119	+ * operation on it's list
	120	+ * @param params
	121	+ * List of values for the operation parameters. Can be
	122	+ * <code>null</code> if the operation require no parameters.
	123	+ * @return The return value of the original invoked operation. Methods of
	124	+ * return type <code>void</code> will return the {@link Void} type.
	125	+ * @throws ReflectionException
	126	+ * In case the operation doesn't exist or have a different
	127	+ * signature
	128	+ */
	129	+ public Object invoke(ManagedType managedType, String actionName,
	130	+ Object[] params) {
	131	+ if ( managedTypes.contains(managedType) ) {
	132	+ activateContexts(managedType.getType());
	133	+
	134	+ Object delegate = Beans.getReference(managedType.getType());
	135	+
	136	+ MethodDetail method = managedType.getOperationMethods().get(actionName);
	137	+
	138	+ if (method != null) {
	139	+ try {
	140	+ logger.debug(bundle
	141	+ .getString("management-debug-invoking-operation",actionName,managedType.getType().getCanonicalName()));
	142	+ return method.getMethod().invoke(delegate, params);
	143	+ } catch (Exception e) {
	144	+ throw new DemoiselleException(bundle.getString(
	145	+ "management-invoke-error", actionName), e);
	146	+ } finally {
	147	+ deactivateContexts(managedType.getType());
	148	+ }
	149	+ } else {
	150	+ throw new DemoiselleException(bundle.getString(
	151	+ "management-invoke-error", actionName));
	152	+ }
	153	+ } else {
	154	+ throw new DemoiselleException(
	155	+ bundle.getString("management-type-not-found"));
	156	+ }
	157	+ }
	158	+
	159	+ /**
	160	+ * <p>Retrieve the current value of a property from a managed type. Properties
	161	+ * are attributes annotated with {@link ManagedProperty}.</p>
	162	+ *
	163	+ * <p>This method is not thread-safe, it's the user's responsibility to
	164	+ * create the property's access methods from the managed type synchronized if necessary.</p>
	165	+ *
	166	+ * @param managedType The type that has the property the client wants to know the value of.
	167	+ * @param propertyName The name of the property
	168	+ * @return The current value of the property
	169	+ */
	170	+ public Object getProperty(ManagedType managedType, String propertyName) {
	171	+
	172	+ if ( managedTypes.contains(managedType) ) {
	173	+ Method getterMethod = managedType.getFields().get(propertyName).getGetterMethod();
	174	+
	175	+ if (getterMethod != null) {
	176	+ logger.debug(bundle.getString(
	177	+ "management-debug-acessing-property", getterMethod
	178	+ .getName(), managedType.getType().getCanonicalName()));
	179	+
	180	+ activateContexts(managedType.getType());
	181	+
	182	+ try {
	183	+ Object delegate = Beans.getReference(managedType.getType());
	184	+
	185	+ return getterMethod.invoke(delegate, (Object[]) null);
	186	+ } catch (Exception e) {
	187	+ throw new DemoiselleException(bundle.getString(
	188	+ "management-invoke-error", getterMethod.getName()),
	189	+ e);
	190	+ } finally {
	191	+ deactivateContexts(managedType.getType());
	192	+ }
	193	+ } else {
	194	+ throw new DemoiselleException(bundle.getString(
	195	+ "management-invoke-error", propertyName));
	196	+ }
	197	+ } else {
	198	+ throw new DemoiselleException(
	199	+ bundle.getString("management-type-not-found"));
	200	+ }
	201	+ }
	202	+
	203	+ /**
	204	+ * <p>Sets a new value for a property contained inside a managed type. A property
	205	+ * is an attribute annotated with {@link ManagedProperty}.</p>
	206	+ *
	207	+ * <p>This method is not thread-safe, it's the user's responsibility to
	208	+ * create the property's access methods from the managed type synchronized if necessary.</p>
	209	+ *
	210	+ * @param managedType The type that has access to the property
	211	+ * @param propertyName The name of the property
	212	+ * @param newValue The new value of the property
	213	+ */
	214	+ public void setProperty(ManagedType managedType, String propertyName,
	215	+ Object newValue) {
	216	+
	217	+ if ( managedTypes.contains(managedType) ) {
	218	+ // Procura o método set do atributo em questão
	219	+ Method method = managedType.getFields().get(propertyName).getSetterMethod();
	220	+ if (method != null) {
	221	+ logger.debug(bundle.getString(
	222	+ "management-debug-setting-property", method.getName(),
	223	+ managedType.getType().getCanonicalName()));
	224	+
	225	+ activateContexts(managedType.getType());
	226	+ try {
	227	+ // Obtém uma instância da classe gerenciada, lembrando que
	228	+ // classes
	229	+ // anotadas com @ManagementController são sempre singletons.
	230	+ Object delegate = Beans.getReference(managedType.getType());
	231	+
	232	+ //Se houver um validador anexado à propriedade alterada, executa o validador sobre
	233	+ //o novo valor.
	234	+ Validator validator = getDefaultValidator();
	235	+ if (validator!=null){
	236	+ Set<?> violations = validator.validateValue(managedType.getType(), propertyName, newValue);
	237	+ if (violations.size()>0){
	238	+ StringBuffer errorBuffer = new StringBuffer();
	239	+ for (Object objectViolation : violations){
	240	+ ConstraintViolation<?> violation = (ConstraintViolation<?>) objectViolation;
	241	+ errorBuffer.append(violation.getMessage()).append('\r').append('\n');
	242	+ }
	243	+
	244	+ throw new DemoiselleException(bundle.getString("validation-constraint-violation",managedType.getType().getCanonicalName(),errorBuffer.toString()));
	245	+ }
	246	+ }
	247	+ else{
	248	+ logger.warn(bundle.getString("validation-validator-not-found"));
	249	+ }
	250	+
	251	+ Method getterMethod = managedType.getFields().get(propertyName).getGetterMethod();
	252	+ Object oldValue;
	253	+ try{
	254	+ oldValue = getterMethod.invoke(delegate, (Object[])null);
	255	+ }
	256	+ catch(Exception e){
	257	+ oldValue = null;
	258	+ }
	259	+
	260	+ method.invoke(delegate, new Object[] { newValue });
	261	+
	262	+ //Manda uma notificação de mudança de atributo
	263	+ NotificationManager notificationManager = Beans.getReference(NotificationManager.class);
	264	+ Class<? extends Object> attributeType = newValue!=null ? newValue.getClass() : null;
	265	+
	266	+ AttributeChangeNotification notification = new AttributeChangeNotification(bundle.getString("management-notification-attribute-changed",propertyName,managedType.getType().getCanonicalName())
	267	+ , propertyName
	268	+ , attributeType
	269	+ , oldValue
	270	+ , newValue);
	271	+ notificationManager.sendNotification(notification);
	272	+
	273	+ } catch (DemoiselleException de){
	274	+ throw de;
	275	+ } catch (Exception e) {
	276	+ throw new DemoiselleException(bundle.getString(
	277	+ "management-invoke-error", method.getName()), e);
	278	+ } finally {
	279	+ deactivateContexts(managedType.getType());
	280	+ }
	281	+
	282	+ } else {
	283	+ throw new DemoiselleException(bundle.getString(
	284	+ "management-invoke-error", propertyName));
	285	+ }
	286	+ } else {
	287	+ throw new DemoiselleException(
	288	+ bundle.getString("management-type-not-found"));
	289	+ }
	290	+
	291	+ }
	292	+
	293	+ private void activateContexts(Class<?> managedType) {
	294	+ logger.debug(bundle.getString("management-debug-starting-custom-context",
	295	+ ManagedContext.class.getCanonicalName(),
	296	+ managedType.getCanonicalName()));
	297	+
	298	+ ContextManager.activate(ManagedContext.class,RequestScoped.class);
	299	+ }
	300	+
	301	+ private void deactivateContexts(Class<?> managedType) {
	302	+ logger.debug(bundle.getString("management-debug-stoping-custom-context",
	303	+ ManagedContext.class.getCanonicalName(),
	304	+ managedType.getCanonicalName()));
	305	+
	306	+ ContextManager.deactivate(ManagedContext.class,RequestScoped.class);
	307	+ }
	308	+
	309	+ public void shutdown(Collection<Class<? extends ManagementExtension>> monitoringExtensions) {
	310	+
	311	+ for (Class<? extends ManagementExtension> monitoringExtensionClass : monitoringExtensions) {
	312	+
	313	+ ManagementExtension monitoringExtension = Beans.getReference(monitoringExtensionClass);
	314	+
	315	+ monitoringExtension.shutdown(this.getManagedTypes());
	316	+
	317	+ logger.debug( bundle.getString("management-debug-removing-management-extension",monitoringExtension.getClass().getCanonicalName()) );
	318	+
	319	+ }
	320	+
	321	+ }
	322	+
	323	+ public void initialize(Collection<Class<? extends ManagementExtension>> monitoringExtensions) {
	324	+
	325	+ for (Class<? extends ManagementExtension> monitoringExtensionClass : monitoringExtensions) {
	326	+
	327	+ ManagementExtension monitoringExtension = Beans
	328	+ .getReference(monitoringExtensionClass);
	329	+
	330	+ monitoringExtension.initialize(this.getManagedTypes());
	331	+
	332	+ logger.debug( bundle.getString("management-debug-processing-management-extension",monitoringExtension.getClass().getCanonicalName()) );
	333	+
	334	+ }
	335	+
	336	+ }
	337	+
	338	+ private Validator getDefaultValidator(){
	339	+ if (validator == null){
	340	+ try{
	341	+ this.validator = Validation.buildDefaultValidatorFactory().getValidator();
	342	+ }
	343	+ catch(ValidationException e){
	344	+ this.validator = null;
	345	+ }
	346	+ }
	347	+
	348	+ return this.validator;
	349	+ }
	350	+
	351	+}
@@ -0,0 +1,65 @@		@@ -0,0 +1,65 @@
	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 br.gov.frameworkdemoiselle.internal.management;
	38	+
	39	+import br.gov.frameworkdemoiselle.management.Notification;
	40	+import br.gov.frameworkdemoiselle.management.NotificationManager;
	41	+
	42	+/**
	43	+ * Event fired when a notification is sent by {@link NotificationManager}.
	44	+ * Implementators can capture this event and be notified when the {@link NotificationManager}
	45	+ * sends notifications, so they can pass the notification to the underlying technology.
	46	+ *
	47	+ * @author serpro
	48	+ *
	49	+ */
	50	+public class ManagementNotificationEvent {
	51	+
	52	+ private Notification notification;
	53	+
	54	+ public ManagementNotificationEvent(Notification notification){
	55	+ this.notification = notification;
	56	+ }
	57	+
	58	+ public Notification getNotification() {
	59	+ return notification;
	60	+ }
	61	+
	62	+ public void setNotification(Notification notification) {
	63	+ this.notification = notification;
	64	+ }
	65	+}
@@ -0,0 +1,62 @@		@@ -0,0 +1,62 @@
	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 br.gov.frameworkdemoiselle.internal.management.qualifier;
	38	+
	39	+import java.lang.annotation.ElementType;
	40	+import java.lang.annotation.Retention;
	41	+import java.lang.annotation.RetentionPolicy;
	42	+import java.lang.annotation.Target;
	43	+
	44	+import javax.inject.Qualifier;
	45	+
	46	+import br.gov.frameworkdemoiselle.internal.management.ManagementNotificationEvent;
	47	+import br.gov.frameworkdemoiselle.management.AttributeChangeNotification;
	48	+
	49	+/**
	50	+ *
	51	+ * Enables {@link ManagementNotificationEvent} observers to trigger only with notifications
	52	+ * of the specialized type {@link AttributeChangeNotification}.
	53	+ *
	54	+ * @author serpro
	55	+ *
	56	+ */
	57	+@Qualifier
	58	+@Retention(RetentionPolicy.RUNTIME)
	59	+@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE})
	60	+public @interface AttributeChange {
	61	+
	62	+}
@@ -0,0 +1,76 @@		@@ -0,0 +1,76 @@
	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 br.gov.frameworkdemoiselle.lifecycle;
	38	+
	39	+import java.util.List;
	40	+
	41	+import br.gov.frameworkdemoiselle.internal.management.ManagedType;
	42	+import br.gov.frameworkdemoiselle.stereotype.ManagementController;
	43	+
	44	+/**
	45	+ *
	46	+ * <p>Interface defining the lifecycle of a <b>management extension</b>, an extension
	47	+ * capable of exposing {@link ManagementController}'s to external clients in one
	48	+ * of the available management technologies, such as JMX or SNMP.</p>
	49	+ *
	50	+ * <p>To include a management extension into the management lifecycle, it just needs
	51	+ * to implement this interface and be a CDI bean (have a <b>beans.xml</b> file inside
	52	+ * the META-INF folder of it's java package). The Demoiselle Core lifecycle controller
	53	+ * will call the {@link #initialize(List managedTypes)} and {@link #shutdown(List managedTypes)} methods at the apropriate times.</p>
	54	+ *
	55	+ * @author serpro
	56	+ *
	57	+ */
	58	+public interface ManagementExtension {
	59	+
	60	+ /**
	61	+ * This method is called during the application initialization process for each concrete
	62	+ * implementation of this interface.
	63	+ *
	64	+ * @param managedTypes The list of discovered {@link ManagementController} classes.
	65	+ */
	66	+ void initialize(List<ManagedType> managedTypes);
	67	+
	68	+ /**
	69	+ * This method is called during the application shutdown process for each concrete
	70	+ * implementation of this interface.
	71	+ *
	72	+ * @param managedTypes The list of discovered {@link ManagementController} classes.
	73	+ */
	74	+ void shutdown(List<ManagedType> managedTypes);
	75	+
	76	+}