/**
* Define an attribute. Explicit definition of an attribute. Reflection is used to locate the
* actual getter and setter methods.
*
* @param attrInfo ModelMBeanAttributeInfo.
*/
public synchronized void defineAttribute(ModelMBeanAttributeInfo attrInfo) {
if (_object == null) throw new IllegalStateException("No Object");
_dirty = true;
String name = attrInfo.getName();
String uName = name.substring(0, 1).toUpperCase() + name.substring(1);
Class oClass = _object.getClass();
try {
Class type = TypeUtil.fromName(attrInfo.getType());
if (type == null)
type = Thread.currentThread().getContextClassLoader().loadClass(attrInfo.getType());
Method getter = null;
Method setter = null;
if (attrInfo.isReadable())
getter =
oClass.getMethod((attrInfo.isIs() ? "is" : "get") + uName, (java.lang.Class[]) null);
if (attrInfo.isWritable()) setter = oClass.getMethod("set" + uName, new Class[] {type});
_getter.put(name, getter);
_setter.put(name, setter);
_attributes.add(attrInfo);
} catch (Exception e) {
log.warn(LogSupport.EXCEPTION, e);
throw new IllegalArgumentException(e.toString());
}
}
@Test
public void testGetAgeIsReadOnly() throws Exception {
ModelMBeanInfo info = getMBeanInfoFromAssembler();
ModelMBeanAttributeInfo attr = info.getAttribute(AGE_ATTRIBUTE);
assertTrue("Age is not readable", attr.isReadable());
assertFalse("Age is not writable", attr.isWritable());
}
public Object getAttribute(String attribute)
throws AttributeNotFoundException, MBeanException, ReflectionException {
if (attribute == null)
throw new RuntimeOperationsException(
new IllegalArgumentException(
LocalizedStrings.MX4JModelMBean_ATTRIBUTE_NAME_CANNOT_BE_NULL.toLocalizedString()));
Logger logger = getLogger();
// I want the real info, not its clone
ModelMBeanInfo info = getModelMBeanInfo();
if (info == null)
throw new AttributeNotFoundException(
LocalizedStrings.MX4JModelMBean_MODELMBEANINFO_IS_NULL.toLocalizedString());
if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("ModelMBeanInfo is: " + info);
// This is a clone, we use it read only
ModelMBeanAttributeInfo attrInfo = info.getAttribute(attribute);
if (attrInfo == null)
throw new AttributeNotFoundException(
LocalizedStrings.MX4JModelMBean_CANNOT_FIND_MODELMBEANATTRIBUTEINFO_FOR_ATTRIBUTE_0
.toLocalizedString(attribute));
if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("Attribute info is: " + attrInfo);
if (!attrInfo.isReadable())
throw new AttributeNotFoundException(
LocalizedStrings.MX4JModelMBean_ATTRIBUTE_0_IS_NOT_READABLE.toLocalizedString(attribute));
// This returns a clone of the mbean descriptor, we use it read only
Descriptor mbeanDescriptor = info.getMBeanDescriptor();
if (mbeanDescriptor == null)
throw new AttributeNotFoundException(
LocalizedStrings.MX4JModelMBean_MBEAN_DESCRIPTOR_CANNOT_BE_NULL.toLocalizedString());
if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("MBean descriptor is: " + mbeanDescriptor);
// This descriptor is a clone
Descriptor attributeDescriptor = attrInfo.getDescriptor();
if (attributeDescriptor == null)
throw new AttributeNotFoundException(
LocalizedStrings.MX4JModelMBean_ATTRIBUTE_DESCRIPTOR_FOR_ATTRIBUTE_0_CANNOT_BE_NULL
.toLocalizedString(attribute));
if (logger.isEnabledFor(Logger.DEBUG))
logger.debug("Attribute descriptor is: " + attributeDescriptor);
Object returnValue = null;
String lastUpdateField = "lastUpdatedTimeStamp";
int staleness = getStaleness(attributeDescriptor, mbeanDescriptor, lastUpdateField);
if (staleness == ALWAYS_STALE || staleness == STALE) {
if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Value is stale");
String getter = (String) attributeDescriptor.getFieldValue("getMethod");
if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("getMethod field is: " + getter);
if (getter == null) {
// No getter, use default value
returnValue = attributeDescriptor.getFieldValue("default");
if (returnValue != null) {
// Check if the return type is of the same type
// As an extension allow covariant return type
Class returned = returnValue.getClass();
Class declared = loadClassWithContextClassLoader(attrInfo.getType());
checkAssignability(returned, declared);
}
if (logger.isEnabledFor(Logger.DEBUG))
logger.debug(
"getAttribute for attribute " + attribute + " returns default value: " + returnValue);
} else {
if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Invoking attribute getter...");
// As an extension, allow attributes to be called on target objects also
Object target = resolveTargetObject(attributeDescriptor);
returnValue = invokeMethod(target, getter, new Class[0], new Object[0]);
if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("Returned value is: " + returnValue);
if (returnValue != null) {
// Check if the return type is of the same type
// As an extension allow covariant return type
Class returned = returnValue.getClass();
Class declared = loadClassWithContextClassLoader(attrInfo.getType());
checkAssignability(returned, declared);
}
// Cache the new value only if caching is needed
if (staleness != ALWAYS_STALE) {
attributeDescriptor.setField("value", returnValue);
attributeDescriptor.setField(lastUpdateField, Long.valueOf(System.currentTimeMillis()));
if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Returned value has been cached");
// And now replace the descriptor with the updated clone
info.setDescriptor(attributeDescriptor, "attribute");
}
if (logger.isEnabledFor(Logger.DEBUG))
logger.debug(
"getAttribute for attribute " + attribute + " returns invoked value: " + returnValue);
}
} else {
// Return cached value
returnValue = attributeDescriptor.getFieldValue("value");
if (returnValue != null) {
// Check if the return type is of the same type
// As an extension allow covariant return type
Class returned = returnValue.getClass();
Class declared = loadClassWithContextClassLoader(attrInfo.getType());
checkAssignability(returned, declared);
}
if (logger.isEnabledFor(Logger.DEBUG))
logger.debug(
"getAttribute for attribute " + attribute + " returns cached value: " + returnValue);
}
// Puff, everything went ok
return returnValue;
}
