hotfix/source/openejb-core_4.5.2/src/main/java/org/apache/openejb/monitoring/DynamicMBeanWrapper.java - virgo/org.eclipse.virgo.eclipse-mirror - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.openejb.monitoring;

 import org.apache.openejb.api.internal.Internal;
 import org.apache.openejb.api.jmx.Description;
 import org.apache.openejb.api.jmx.MBean;
 import org.apache.openejb.api.jmx.ManagedAttribute;
 import org.apache.openejb.api.jmx.ManagedOperation;
 import org.apache.openejb.api.jmx.NotificationInfo;
 import org.apache.openejb.api.jmx.NotificationInfos;
 import org.apache.openejb.util.LogCategory;
 import org.apache.openejb.util.Logger;
 import org.apache.webbeans.config.WebBeansContext;
 import org.apache.webbeans.proxy.ProxyFactory;

 import javax.management.Attribute;
 import javax.management.AttributeList;
 import javax.management.AttributeNotFoundException;
 import javax.management.DynamicMBean;
 import javax.management.ImmutableDescriptor;
 import javax.management.IntrospectionException;
 import javax.management.InvalidAttributeValueException;
 import javax.management.MBeanAttributeInfo;
 import javax.management.MBeanException;
 import javax.management.MBeanInfo;
 import javax.management.MBeanNotificationInfo;
 import javax.management.MBeanOperationInfo;
 import javax.management.ReflectionException;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Proxy;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.ResourceBundle;

 public class DynamicMBeanWrapper implements DynamicMBean {
     public static final Logger logger = Logger.getInstance(LogCategory.OPENEJB_DEPLOY, DynamicMBeanWrapper.class);

     private static final Map<Class<?>, CacheInfo> CACHE = new HashMap<Class<?>, CacheInfo>();

     private static final Map<Class<?>, Class<? extends Annotation>> OPENEJB_API_TO_JAVAX = new HashMap<Class<?>, Class<? extends Annotation>>();
     static {
         final ClassLoader loader = DynamicMBeanWrapper.class.getClassLoader();
         try {
             OPENEJB_API_TO_JAVAX.put(MBean.class, (Class<? extends Annotation>) loader.loadClass("javax.management.MBean"));
             OPENEJB_API_TO_JAVAX.put(Description.class, (Class<? extends Annotation>) loader.loadClass("javax.management.Description"));
             OPENEJB_API_TO_JAVAX.put(ManagedOperation.class, (Class<? extends Annotation>) loader.loadClass("javax.management.ManagedOperation"));
             OPENEJB_API_TO_JAVAX.put(ManagedAttribute.class, (Class<? extends Annotation>) loader.loadClass("javax.management.ManagedAttribute"));
             OPENEJB_API_TO_JAVAX.put(NotificationInfo.class, (Class<? extends Annotation>) loader.loadClass("javax.management.NotificationInfo"));
             OPENEJB_API_TO_JAVAX.put(NotificationInfos.class, (Class<? extends Annotation>) loader.loadClass("javax.management.NotificationInfos"));
         } catch (ClassNotFoundException cnfe) {
             // ignored
         } catch (NoClassDefFoundError ncdfe) {
             // ignored
         }
     }

     private final MBeanInfo info;
     private final Map<String, Method> getters = new HashMap<String, Method>();
     private final Map<String, Method> setters = new HashMap<String, Method>();
     private final Map<String, Method> operations = new HashMap<String, Method>();
     private final Object instance;
     private final ClassLoader classloader;

     public DynamicMBeanWrapper(final Object givenInstance) {
         this(null, givenInstance);
     }

     public DynamicMBeanWrapper(final WebBeansContext wc, final Object givenInstance) {
         Class<?> annotatedMBean = givenInstance.getClass();

         // javaassist looses annotation so simply unwrap it
         if (wc != null) {
             final ProxyFactory pf = wc.getProxyFactory();
             if (pf.isProxyInstance(givenInstance)) {
                 annotatedMBean = annotatedMBean.getSuperclass();
             }
         }

         classloader = annotatedMBean.getClassLoader();
         instance = givenInstance;

         CacheInfo cache = CACHE.get(annotatedMBean);
         if (cache == null) {
             String description;
             List<MBeanAttributeInfo> attributeInfos = new ArrayList<MBeanAttributeInfo>();
             List<MBeanOperationInfo> operationInfos = new ArrayList<MBeanOperationInfo>();
             List<MBeanNotificationInfo> notificationInfos = new ArrayList<MBeanNotificationInfo>();

             // class
             Description classDescription = findAnnotation(annotatedMBean, Description.class);
             description = getDescription(classDescription, "a MBean built by OpenEJB");

             NotificationInfo notification = findAnnotation(annotatedMBean, NotificationInfo.class);
             if (notification != null) {
                 MBeanNotificationInfo notificationInfo = getNotificationInfo(notification);
                 notificationInfos.add(notificationInfo);
             }

             NotificationInfos notifications = findAnnotation(annotatedMBean, NotificationInfos.class);
             if (notifications != null && notifications.value() != null) {
                 for (NotificationInfo n : notifications.value()) {
                     MBeanNotificationInfo notificationInfo = getNotificationInfo(n);
                     notificationInfos.add(notificationInfo);
                 }
             }


             // methods
             for (Method m : annotatedMBean.getMethods()) {
                 int modifiers = m.getModifiers();
                 if (m.getDeclaringClass().equals(Object.class)
                         || !Modifier.isPublic(modifiers)
                         || Modifier.isAbstract(modifiers)) {
                     continue;
                 }

                 if (findAnnotation(m, ManagedAttribute.class) != null) {
                     String methodName = m.getName();
                     String attrName = methodName;
                     if (((attrName.startsWith("get") && m.getParameterTypes().length == 0)
                             || (attrName.startsWith("set") && m.getParameterTypes().length == 1))
                             && attrName.length() > 3) {
                         attrName = attrName.substring(3);
                         if (attrName.length() > 1) {
                             attrName = Character.toLowerCase(attrName.charAt(0)) + attrName.substring(1);
                         } else {
                             attrName = attrName.toLowerCase();
                         }
                     } else {
                         logger.warning("ignoring attribute " + m.getName() + " for " + annotatedMBean.getName());
                     }

                     if (methodName.startsWith("get")) {
                         getters.put(attrName, m);
                     } else if (methodName.startsWith("set")) {
                         setters.put(attrName, m);
                     }
                 } else if (findAnnotation(m, ManagedOperation.class) != null) {
                     operations.put(m.getName(), m);

                     String operationDescr = "";
                     Description descr = findAnnotation(m, Description.class);
                     if (descr != null) {
                         operationDescr = getDescription(descr, "-");
                     }

                     operationInfos.add(new MBeanOperationInfo(operationDescr, m));
                 }
             }

             for (Map.Entry<String, Method> e : getters.entrySet()) {
                 String key = e.getKey();
                 Method mtd = e.getValue();

                 String attrDescr = "";
                 Description descr = findAnnotation(mtd, Description.class);
                 if (descr != null) {
                     attrDescr = getDescription(descr, "-");
                 }

                 try {
                     attributeInfos.add(new MBeanAttributeInfo(key, attrDescr, mtd, setters.get(key)));
                 } catch (IntrospectionException ex) {
                     logger.warning("can't manage " + key + " for " + mtd.getName(), ex);
                 }
             }

             // for updatable but not readable attributes
             for (Map.Entry<String, Method> e : setters.entrySet()) {
                 String key = e.getKey();
                 if (getters.get(key) != null) {
                     continue; //already done
                 }

                 Method mtd = e.getValue();

                 String attrDescr = "";
                 Description descr = findAnnotation(mtd, Description.class);
                 if (descr != null) {
                     attrDescr = getDescription(descr, "-");
                 }

                 try {
                     attributeInfos.add(new MBeanAttributeInfo(key, attrDescr, null, setters.get(key)));
                 } catch (IntrospectionException ex) {
                     logger.warning("can't manage " + key + " for " + mtd.getName(), ex);
                 }
             }

             info = new MBeanInfo(annotatedMBean.getName(),
                     description,
                     attributeInfos.toArray(new MBeanAttributeInfo[attributeInfos.size()]),
                     null, // default constructor is mandatory
                     operationInfos.toArray(new MBeanOperationInfo[operationInfos.size()]),
                     notificationInfos.toArray(new MBeanNotificationInfo[notificationInfos.size()]));

             if (annotatedMBean.getAnnotation(Internal.class) != null) {
                 CACHE.put(annotatedMBean, new CacheInfo(info, getters, setters, operations));
             }
         } else {
             info = cache.mBeanInfo;
             getters.putAll(cache.getters);
             setters.putAll(cache.setters);
             operations.putAll(cache.operations);
         }
     }

     private <T extends Annotation> T findAnnotation(final Method method, final Class<T> searchedAnnotation) {
         final T annotation = method.getAnnotation(searchedAnnotation);
         if (annotation != null) {
             return annotation;
         }

         if (OPENEJB_API_TO_JAVAX.containsKey(searchedAnnotation)) {
             final Class<? extends Annotation> clazz = OPENEJB_API_TO_JAVAX.get(searchedAnnotation);
             final Object javaxAnnotation = method.getAnnotation(clazz);
             if (javaxAnnotation != null) {
                 return annotationProxy(javaxAnnotation, searchedAnnotation);
             }
         }
         return null;
     }

     private <T extends Annotation> T findAnnotation(final Class<?> annotatedMBean, final Class<T> searchedAnnotation) {
         final T annotation = annotatedMBean.getAnnotation(searchedAnnotation);
         if (annotation != null) {
             return annotation;
         }

         if (OPENEJB_API_TO_JAVAX.containsKey(searchedAnnotation)) {
             final Class<? extends Annotation> clazz = OPENEJB_API_TO_JAVAX.get(searchedAnnotation);
             final Object javaxAnnotation = annotatedMBean.getAnnotation(clazz);
             if (javaxAnnotation != null) {
                 return annotationProxy(javaxAnnotation, searchedAnnotation);
             }
         }
         return null;
     }

     private static <T extends Annotation> T annotationProxy(final Object javaxAnnotation, final Class<T> clazz) {
         return (T) Proxy.newProxyInstance(DynamicMBeanWrapper.class.getClassLoader(), new Class<?>[]{clazz}, new AnnotationHandler(javaxAnnotation));
     }

     private MBeanNotificationInfo getNotificationInfo(NotificationInfo n) {
         String description = getDescription(n.description(), "-");
         return new MBeanNotificationInfo(n.types(),
             n.notificationClass().getName(), description,
             new ImmutableDescriptor(n.descriptorFields()));
     }

     private String getDescription(Description d, String defaultValue) {
         if (d != null) {
             if (d.bundleBaseName() != null && d.key() != null) {
                 try {
                     return ResourceBundle
                         .getBundle(d.bundleBaseName())
                         .getString(d.key());
                 } catch (RuntimeException re) {
                     return d.value();
                 }
             } else {
                 return d.value();
             }
         }
         return defaultValue;
     }

     @Override
     public MBeanInfo getMBeanInfo() {
         return info;
     }

     @Override
     public Object getAttribute(String attribute)
         throws AttributeNotFoundException, MBeanException,
         ReflectionException {
         if (getters.containsKey(attribute)) {
             final ClassLoader oldCl = Thread.currentThread().getContextClassLoader();
             Thread.currentThread().setContextClassLoader(classloader);
             try {
                 return getters.get(attribute).invoke(instance);
             } catch (IllegalArgumentException e) {
                 logger.error("can't get " + attribute + " value", e);
             } catch (IllegalAccessException e) {
                 logger.error("can't get " + attribute + " value", e);
             } catch (InvocationTargetException e) {
                 logger.error("can't get " + attribute + " value", e);
             } finally {
                 Thread.currentThread().setContextClassLoader(oldCl);
             }
         }
         throw new AttributeNotFoundException();
     }

     @Override
     public void setAttribute(Attribute attribute)
         throws AttributeNotFoundException, InvalidAttributeValueException,
         MBeanException, ReflectionException {
         if (setters.containsKey(attribute.getName())) {
             final ClassLoader oldCl = Thread.currentThread().getContextClassLoader();
             Thread.currentThread().setContextClassLoader(classloader);
             try {
                 setters.get(attribute.getName()).invoke(instance, attribute.getValue());
             } catch (IllegalArgumentException e) {
                 logger.error("can't set " + attribute + " value", e);
             } catch (IllegalAccessException e) {
                 logger.error("can't set " + attribute + " value", e);
             } catch (InvocationTargetException e) {
                 logger.error("can't set " + attribute + " value", e);
             } finally {
                 Thread.currentThread().setContextClassLoader(oldCl);
             }
         } else {
             throw new AttributeNotFoundException();
         }
     }

     @Override
     public AttributeList getAttributes(String[] attributes) {
         AttributeList list = new AttributeList();
         for (String n : attributes) {
             try {
                 list.add(new Attribute(n, getAttribute(n)));
             } catch (Exception ignore) {
                 // no-op
             }
         }
         return list;
     }

     @Override
     public AttributeList setAttributes(AttributeList attributes) {
         AttributeList list = new AttributeList();
         for (Object o : attributes) {
             final Attribute attr = (Attribute) o;
             try {
                 setAttribute(attr);
                 list.add(attr);
             } catch (Exception ignore) {
                 // no-op
             }
         }
         return list;
     }

     @Override
     public Object invoke(String actionName, Object[] params, String[] signature)
         throws MBeanException, ReflectionException {
         if (operations.containsKey(actionName)) {
             final ClassLoader oldCl = Thread.currentThread().getContextClassLoader();
             Thread.currentThread().setContextClassLoader(classloader);
             try {
                 return operations.get(actionName).invoke(instance, params);
             } catch (IllegalArgumentException e) {
                 logger.error(actionName + "can't be invoked", e);
             } catch (IllegalAccessException e) {
                 logger.error(actionName + "can't be invoked", e);
             } catch (InvocationTargetException e) {
                 logger.error(actionName + "can't be invoked", e);
             } finally {
                 Thread.currentThread().setContextClassLoader(oldCl);
             }
         }
         throw new MBeanException(new IllegalArgumentException(), actionName + " doesn't exist");
     }

     private static class AnnotationHandler implements InvocationHandler {
         private final Object delegate;

         public AnnotationHandler(final Object javaxAnnotation) {
             delegate = javaxAnnotation;
         }

         @Override
         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
             Object result = null;
             for (Method mtd : delegate.getClass().getMethods()) { // simple heurisitc which should be enough
                 if (mtd.getName().equals(method.getName())) {
                     result = mtd.invoke(delegate, args);
                     break;
                 }
             }

             if (result == null) {
                 return null;
             }

             if (result.getClass().isArray()) {
                 final Object[] array = (Object[]) result;
                 if (array.length == 0 || !OPENEJB_API_TO_JAVAX.containsValue(array[0].getClass())) {
                     return array;
                 }

                 final Object[] translated = new Object[array.length];
                 for (int i = 0; i < translated.length; i++) {
                     translated[i] = annotationProxy(array[i], OPENEJB_API_TO_JAVAX.get(array[i].getClass()));
                 }
             }

             return result;
         }
     }

     private static class CacheInfo {
         public final MBeanInfo mBeanInfo;
         public final Map<String, Method> getters;
         public final Map<String, Method> setters;
         public final Map<String, Method> operations;

         private CacheInfo(final MBeanInfo mBeanInfo,
                           final Map<String, Method> getters, final Map<String, Method> setters,
                           final Map<String, Method> operations) {
             this.mBeanInfo = mBeanInfo;
             this.getters = getters;
             this.setters = setters;
             this.operations = operations;
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package org.apache.openejb.monitoring;

	import org.apache.openejb.api.internal.Internal;
	import org.apache.openejb.api.jmx.Description;
	import org.apache.openejb.api.jmx.MBean;
	import org.apache.openejb.api.jmx.ManagedAttribute;
	import org.apache.openejb.api.jmx.ManagedOperation;
	import org.apache.openejb.api.jmx.NotificationInfo;
	import org.apache.openejb.api.jmx.NotificationInfos;
	import org.apache.openejb.util.LogCategory;
	import org.apache.openejb.util.Logger;
	import org.apache.webbeans.config.WebBeansContext;
	import org.apache.webbeans.proxy.ProxyFactory;

	import javax.management.Attribute;
	import javax.management.AttributeList;
	import javax.management.AttributeNotFoundException;
	import javax.management.DynamicMBean;
	import javax.management.ImmutableDescriptor;
	import javax.management.IntrospectionException;
	import javax.management.InvalidAttributeValueException;
	import javax.management.MBeanAttributeInfo;
	import javax.management.MBeanException;
	import javax.management.MBeanInfo;
	import javax.management.MBeanNotificationInfo;
	import javax.management.MBeanOperationInfo;
	import javax.management.ReflectionException;
	import java.lang.annotation.Annotation;
	import java.lang.reflect.InvocationHandler;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.lang.reflect.Modifier;
	import java.lang.reflect.Proxy;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.ResourceBundle;

	public class DynamicMBeanWrapper implements DynamicMBean {
	public static final Logger logger = Logger.getInstance(LogCategory.OPENEJB_DEPLOY, DynamicMBeanWrapper.class);

	private static final Map<Class<?>, CacheInfo> CACHE = new HashMap<Class<?>, CacheInfo>();

	private static final Map<Class<?>, Class<? extends Annotation>> OPENEJB_API_TO_JAVAX = new HashMap<Class<?>, Class<? extends Annotation>>();
	static {
	final ClassLoader loader = DynamicMBeanWrapper.class.getClassLoader();
	try {
	OPENEJB_API_TO_JAVAX.put(MBean.class, (Class<? extends Annotation>) loader.loadClass("javax.management.MBean"));
	OPENEJB_API_TO_JAVAX.put(Description.class, (Class<? extends Annotation>) loader.loadClass("javax.management.Description"));
	OPENEJB_API_TO_JAVAX.put(ManagedOperation.class, (Class<? extends Annotation>) loader.loadClass("javax.management.ManagedOperation"));
	OPENEJB_API_TO_JAVAX.put(ManagedAttribute.class, (Class<? extends Annotation>) loader.loadClass("javax.management.ManagedAttribute"));
	OPENEJB_API_TO_JAVAX.put(NotificationInfo.class, (Class<? extends Annotation>) loader.loadClass("javax.management.NotificationInfo"));
	OPENEJB_API_TO_JAVAX.put(NotificationInfos.class, (Class<? extends Annotation>) loader.loadClass("javax.management.NotificationInfos"));
	} catch (ClassNotFoundException cnfe) {
	// ignored
	} catch (NoClassDefFoundError ncdfe) {
	// ignored
	}
	}

	private final MBeanInfo info;
	private final Map<String, Method> getters = new HashMap<String, Method>();
	private final Map<String, Method> setters = new HashMap<String, Method>();
	private final Map<String, Method> operations = new HashMap<String, Method>();
	private final Object instance;
	private final ClassLoader classloader;

	public DynamicMBeanWrapper(final Object givenInstance) {
	this(null, givenInstance);
	}

	public DynamicMBeanWrapper(final WebBeansContext wc, final Object givenInstance) {
	Class<?> annotatedMBean = givenInstance.getClass();

	// javaassist looses annotation so simply unwrap it
	if (wc != null) {
	final ProxyFactory pf = wc.getProxyFactory();
	if (pf.isProxyInstance(givenInstance)) {
	annotatedMBean = annotatedMBean.getSuperclass();
	}
	}

	classloader = annotatedMBean.getClassLoader();
	instance = givenInstance;

	CacheInfo cache = CACHE.get(annotatedMBean);
	if (cache == null) {
	String description;
	List<MBeanAttributeInfo> attributeInfos = new ArrayList<MBeanAttributeInfo>();
	List<MBeanOperationInfo> operationInfos = new ArrayList<MBeanOperationInfo>();
	List<MBeanNotificationInfo> notificationInfos = new ArrayList<MBeanNotificationInfo>();

	// class
	Description classDescription = findAnnotation(annotatedMBean, Description.class);
	description = getDescription(classDescription, "a MBean built by OpenEJB");

	NotificationInfo notification = findAnnotation(annotatedMBean, NotificationInfo.class);
	if (notification != null) {
	MBeanNotificationInfo notificationInfo = getNotificationInfo(notification);
	notificationInfos.add(notificationInfo);
	}

	NotificationInfos notifications = findAnnotation(annotatedMBean, NotificationInfos.class);
	if (notifications != null && notifications.value() != null) {
	for (NotificationInfo n : notifications.value()) {
	MBeanNotificationInfo notificationInfo = getNotificationInfo(n);
	notificationInfos.add(notificationInfo);
	}
	}


	// methods
	for (Method m : annotatedMBean.getMethods()) {
	int modifiers = m.getModifiers();
	if (m.getDeclaringClass().equals(Object.class)
	\|\| !Modifier.isPublic(modifiers)
	\|\| Modifier.isAbstract(modifiers)) {
	continue;
	}

	if (findAnnotation(m, ManagedAttribute.class) != null) {
	String methodName = m.getName();
	String attrName = methodName;
	if (((attrName.startsWith("get") && m.getParameterTypes().length == 0)
	\|\| (attrName.startsWith("set") && m.getParameterTypes().length == 1))
	&& attrName.length() > 3) {
	attrName = attrName.substring(3);
	if (attrName.length() > 1) {
	attrName = Character.toLowerCase(attrName.charAt(0)) + attrName.substring(1);
	} else {
	attrName = attrName.toLowerCase();
	}
	} else {
	logger.warning("ignoring attribute " + m.getName() + " for " + annotatedMBean.getName());
	}

	if (methodName.startsWith("get")) {
	getters.put(attrName, m);
	} else if (methodName.startsWith("set")) {
	setters.put(attrName, m);
	}
	} else if (findAnnotation(m, ManagedOperation.class) != null) {
	operations.put(m.getName(), m);

	String operationDescr = "";
	Description descr = findAnnotation(m, Description.class);
	if (descr != null) {
	operationDescr = getDescription(descr, "-");
	}

	operationInfos.add(new MBeanOperationInfo(operationDescr, m));
	}
	}

	for (Map.Entry<String, Method> e : getters.entrySet()) {
	String key = e.getKey();
	Method mtd = e.getValue();

	String attrDescr = "";
	Description descr = findAnnotation(mtd, Description.class);
	if (descr != null) {
	attrDescr = getDescription(descr, "-");
	}

	try {
	attributeInfos.add(new MBeanAttributeInfo(key, attrDescr, mtd, setters.get(key)));
	} catch (IntrospectionException ex) {
	logger.warning("can't manage " + key + " for " + mtd.getName(), ex);
	}
	}

	// for updatable but not readable attributes
	for (Map.Entry<String, Method> e : setters.entrySet()) {
	String key = e.getKey();
	if (getters.get(key) != null) {
	continue; //already done
	}

	Method mtd = e.getValue();

	String attrDescr = "";
	Description descr = findAnnotation(mtd, Description.class);
	if (descr != null) {
	attrDescr = getDescription(descr, "-");
	}

	try {
	attributeInfos.add(new MBeanAttributeInfo(key, attrDescr, null, setters.get(key)));
	} catch (IntrospectionException ex) {
	logger.warning("can't manage " + key + " for " + mtd.getName(), ex);
	}
	}

	info = new MBeanInfo(annotatedMBean.getName(),
	description,
	attributeInfos.toArray(new MBeanAttributeInfo[attributeInfos.size()]),
	null, // default constructor is mandatory
	operationInfos.toArray(new MBeanOperationInfo[operationInfos.size()]),
	notificationInfos.toArray(new MBeanNotificationInfo[notificationInfos.size()]));

	if (annotatedMBean.getAnnotation(Internal.class) != null) {
	CACHE.put(annotatedMBean, new CacheInfo(info, getters, setters, operations));
	}
	} else {
	info = cache.mBeanInfo;
	getters.putAll(cache.getters);
	setters.putAll(cache.setters);
	operations.putAll(cache.operations);
	}
	}

	private <T extends Annotation> T findAnnotation(final Method method, final Class<T> searchedAnnotation) {
	final T annotation = method.getAnnotation(searchedAnnotation);
	if (annotation != null) {
	return annotation;
	}

	if (OPENEJB_API_TO_JAVAX.containsKey(searchedAnnotation)) {
	final Class<? extends Annotation> clazz = OPENEJB_API_TO_JAVAX.get(searchedAnnotation);
	final Object javaxAnnotation = method.getAnnotation(clazz);
	if (javaxAnnotation != null) {
	return annotationProxy(javaxAnnotation, searchedAnnotation);
	}
	}
	return null;
	}

	private <T extends Annotation> T findAnnotation(final Class<?> annotatedMBean, final Class<T> searchedAnnotation) {
	final T annotation = annotatedMBean.getAnnotation(searchedAnnotation);
	if (annotation != null) {
	return annotation;
	}

	if (OPENEJB_API_TO_JAVAX.containsKey(searchedAnnotation)) {
	final Class<? extends Annotation> clazz = OPENEJB_API_TO_JAVAX.get(searchedAnnotation);
	final Object javaxAnnotation = annotatedMBean.getAnnotation(clazz);
	if (javaxAnnotation != null) {
	return annotationProxy(javaxAnnotation, searchedAnnotation);
	}
	}
	return null;
	}

	private static <T extends Annotation> T annotationProxy(final Object javaxAnnotation, final Class<T> clazz) {
	return (T) Proxy.newProxyInstance(DynamicMBeanWrapper.class.getClassLoader(), new Class<?>[]{clazz}, new AnnotationHandler(javaxAnnotation));
	}

	private MBeanNotificationInfo getNotificationInfo(NotificationInfo n) {
	String description = getDescription(n.description(), "-");
	return new MBeanNotificationInfo(n.types(),
	n.notificationClass().getName(), description,
	new ImmutableDescriptor(n.descriptorFields()));
	}

	private String getDescription(Description d, String defaultValue) {
	if (d != null) {
	if (d.bundleBaseName() != null && d.key() != null) {
	try {
	return ResourceBundle
	.getBundle(d.bundleBaseName())
	.getString(d.key());
	} catch (RuntimeException re) {
	return d.value();
	}
	} else {
	return d.value();
	}
	}
	return defaultValue;
	}

	@Override
	public MBeanInfo getMBeanInfo() {
	return info;
	}

	@Override
	public Object getAttribute(String attribute)
	throws AttributeNotFoundException, MBeanException,
	ReflectionException {
	if (getters.containsKey(attribute)) {
	final ClassLoader oldCl = Thread.currentThread().getContextClassLoader();
	Thread.currentThread().setContextClassLoader(classloader);
	try {
	return getters.get(attribute).invoke(instance);
	} catch (IllegalArgumentException e) {
	logger.error("can't get " + attribute + " value", e);
	} catch (IllegalAccessException e) {
	logger.error("can't get " + attribute + " value", e);
	} catch (InvocationTargetException e) {
	logger.error("can't get " + attribute + " value", e);
	} finally {
	Thread.currentThread().setContextClassLoader(oldCl);
	}
	}
	throw new AttributeNotFoundException();
	}

	@Override
	public void setAttribute(Attribute attribute)
	throws AttributeNotFoundException, InvalidAttributeValueException,
	MBeanException, ReflectionException {
	if (setters.containsKey(attribute.getName())) {
	final ClassLoader oldCl = Thread.currentThread().getContextClassLoader();
	Thread.currentThread().setContextClassLoader(classloader);
	try {
	setters.get(attribute.getName()).invoke(instance, attribute.getValue());
	} catch (IllegalArgumentException e) {
	logger.error("can't set " + attribute + " value", e);
	} catch (IllegalAccessException e) {
	logger.error("can't set " + attribute + " value", e);
	} catch (InvocationTargetException e) {
	logger.error("can't set " + attribute + " value", e);
	} finally {
	Thread.currentThread().setContextClassLoader(oldCl);
	}
	} else {
	throw new AttributeNotFoundException();
	}
	}

	@Override
	public AttributeList getAttributes(String[] attributes) {
	AttributeList list = new AttributeList();
	for (String n : attributes) {
	try {
	list.add(new Attribute(n, getAttribute(n)));
	} catch (Exception ignore) {
	// no-op
	}
	}
	return list;
	}

	@Override
	public AttributeList setAttributes(AttributeList attributes) {
	AttributeList list = new AttributeList();
	for (Object o : attributes) {
	final Attribute attr = (Attribute) o;
	try {
	setAttribute(attr);
	list.add(attr);
	} catch (Exception ignore) {
	// no-op
	}
	}
	return list;
	}

	@Override
	public Object invoke(String actionName, Object[] params, String[] signature)
	throws MBeanException, ReflectionException {
	if (operations.containsKey(actionName)) {
	final ClassLoader oldCl = Thread.currentThread().getContextClassLoader();
	Thread.currentThread().setContextClassLoader(classloader);
	try {
	return operations.get(actionName).invoke(instance, params);
	} catch (IllegalArgumentException e) {
	logger.error(actionName + "can't be invoked", e);
	} catch (IllegalAccessException e) {
	logger.error(actionName + "can't be invoked", e);
	} catch (InvocationTargetException e) {
	logger.error(actionName + "can't be invoked", e);
	} finally {
	Thread.currentThread().setContextClassLoader(oldCl);
	}
	}
	throw new MBeanException(new IllegalArgumentException(), actionName + " doesn't exist");
	}

	private static class AnnotationHandler implements InvocationHandler {
	private final Object delegate;

	public AnnotationHandler(final Object javaxAnnotation) {
	delegate = javaxAnnotation;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	Object result = null;
	for (Method mtd : delegate.getClass().getMethods()) { // simple heurisitc which should be enough
	if (mtd.getName().equals(method.getName())) {
	result = mtd.invoke(delegate, args);
	break;
	}
	}

	if (result == null) {
	return null;
	}

	if (result.getClass().isArray()) {
	final Object[] array = (Object[]) result;
	if (array.length == 0 \|\| !OPENEJB_API_TO_JAVAX.containsValue(array[0].getClass())) {
	return array;
	}

	final Object[] translated = new Object[array.length];
	for (int i = 0; i < translated.length; i++) {
	translated[i] = annotationProxy(array[i], OPENEJB_API_TO_JAVAX.get(array[i].getClass()));
	}
	}

	return result;
	}
	}

	private static class CacheInfo {
	public final MBeanInfo mBeanInfo;
	public final Map<String, Method> getters;
	public final Map<String, Method> setters;
	public final Map<String, Method> operations;

	private CacheInfo(final MBeanInfo mBeanInfo,
	final Map<String, Method> getters, final Map<String, Method> setters,
	final Map<String, Method> operations) {
	this.mBeanInfo = mBeanInfo;
	this.getters = getters;
	this.setters = setters;
	this.operations = operations;
	}
	}
	}