Java OpenMBeanParameterInfoSupport类代码示例

import javax.management.openmbean.OpenMBeanParameterInfoSupport; //导入依赖的package包/类
private static MBeanParameterInfo
        customize(MBeanParameterInfo pi,
                  String name,
                  String description) {
    if (equal(name, pi.getName()) &&
            equal(description, pi.getDescription()))
        return pi;
    else if (pi instanceof OpenMBeanParameterInfo) {
        OpenMBeanParameterInfo opi = (OpenMBeanParameterInfo) pi;
        return new OpenMBeanParameterInfoSupport(name,
                                                 description,
                                                 opi.getOpenType(),
                                                 pi.getDescriptor());
    } else {
        return new MBeanParameterInfo(name,
                                      pi.getType(),
                                      description,
                                      pi.getDescriptor());
    }
}
 

import javax.management.openmbean.OpenMBeanParameterInfoSupport; //导入依赖的package包/类
@Override
public MBeanInfo getMBeanInfo() {

	ArrayList<OpenMBeanAttributeInfoSupport> attributes = new ArrayList<>();

	attributes.add(new OpenMBeanAttributeInfoSupport("enabled", "enabled", SimpleType.BOOLEAN, true, true, true));
	for (String type : registry.getTypes()) {
		attributes.add(new OpenMBeanAttributeInfoSupport(type, type, getCompositeType(type), true, false, false));
	}

	OpenMBeanParameterInfo[] params = new OpenMBeanParameterInfoSupport[0];
	OpenMBeanOperationInfoSupport reset = new OpenMBeanOperationInfoSupport("reset", "Reset all Metrics", params,
			SimpleType.VOID, MBeanOperationInfo.ACTION);

	OpenMBeanInfoSupport PSOMBInfo = new OpenMBeanInfoSupport(this.getClass().getName(), description,
			attributes.toArray(new OpenMBeanAttributeInfoSupport[0]), new OpenMBeanConstructorInfoSupport[0],
			new OpenMBeanOperationInfoSupport[] { reset }, new MBeanNotificationInfo[0]);

	return PSOMBInfo;
}
 

import javax.management.openmbean.OpenMBeanParameterInfoSupport; //导入依赖的package包/类
private static OpenMBeanParameterInfo[]
        paramsToOpenParams(MBeanParameterInfo[] params) {
    if (params instanceof OpenMBeanParameterInfo[])
        return (OpenMBeanParameterInfo[]) params;
    OpenMBeanParameterInfo[] oparams =
        new OpenMBeanParameterInfoSupport[params.length];
    System.arraycopy(params, 0, oparams, 0, params.length);
    return oparams;
}
 

import javax.management.openmbean.OpenMBeanParameterInfoSupport; //导入依赖的package包/类
private OpenMBeanParameterInfo[] translateSignature(MBeanParameterInfo[] oldS)
  throws OpenDataException
{
  OpenMBeanParameterInfo[] sig = new OpenMBeanParameterInfoSupport[oldS.length];
  for (int a = 0; a < oldS.length; ++a)
    {
      OpenMBeanParameterInfo param = Translator.translate(oldS[a].getType());
      if (param.getMinValue() == null)
        {
          Object[] lv;
          if (param.getLegalValues() == null)
            lv = null;
          else
            lv = param.getLegalValues().toArray();
          sig[a] = new OpenMBeanParameterInfoSupport(oldS[a].getName(),
                                                     oldS[a].getDescription(),
                                                     ((OpenType<Object>)
                                                      param.getOpenType()),
                                                     param.getDefaultValue(),
                                                     lv);
        }
      else
        sig[a] = new OpenMBeanParameterInfoSupport(oldS[a].getName(),
                                                   oldS[a].getDescription(),
                                                   ((OpenType<Object>)
                                                    param.getOpenType()),
                                                   param.getDefaultValue(),
                                                   ((Comparable<Object>)
                                                    param.getMinValue()),
                                                   ((Comparable<Object>)
                                                    param.getMaxValue()));
    }
  return sig;
}
 

import javax.management.openmbean.OpenMBeanParameterInfoSupport; //导入依赖的package包/类
private OpenMBeanParameterInfo[] translateSignature(MBeanParameterInfo[] oldS)
   throws OpenDataException
 {
   OpenMBeanParameterInfo[] sig = new OpenMBeanParameterInfoSupport[oldS.length];
   for (int a = 0; a < oldS.length; ++a)
     {
OpenMBeanParameterInfo param = Translator.translate(oldS[a].getType());
if (param.getMinValue() == null)
  {
    Object[] lv;
    if (param.getLegalValues() == null)
      lv = null;
    else
      lv = param.getLegalValues().toArray();
    sig[a] = new OpenMBeanParameterInfoSupport(oldS[a].getName(),
					       oldS[a].getDescription(),
					       ((OpenType<Object>)
						param.getOpenType()),
					       param.getDefaultValue(),
					       lv);
  }
else
  sig[a] = new OpenMBeanParameterInfoSupport(oldS[a].getName(),
					     oldS[a].getDescription(),
					     ((OpenType<Object>)
					      param.getOpenType()),
					     param.getDefaultValue(),
					     ((Comparable<Object>)
					      param.getMinValue()),
					     ((Comparable<Object>)
					      param.getMaxValue()));
     }
   return sig;
 }
 

import javax.management.openmbean.OpenMBeanParameterInfoSupport; //导入依赖的package包/类
public MBeanInfo getMBeanInfo() {
    OpenMBeanParameterInfoSupport parameterInfoSupport = new OpenMBeanParameterInfoSupport(
        "par name", "descripttiosdf", SimpleType.STRING);
    OpenMBeanOperationInfo infoSupport = new OpenMBeanOperationInfoSupport(
        operationName, "desciption",
        new OpenMBeanParameterInfo[] { parameterInfoSupport },
        SimpleType.STRING, MBeanOperationInfo.ACTION);
    OpenMBeanAttributeInfoSupport attributeInfo = new OpenMBeanAttributeInfoSupport(
        attrName, "description", SimpleType.STRING, true, true, false);
    OpenMBeanInfoSupport beanInfoSupport = new OpenMBeanInfoSupport(this
        .getClass().getName(), "descriptor",
        new OpenMBeanAttributeInfo[] { attributeInfo }, null,
        new OpenMBeanOperationInfo[] { infoSupport }, null);
    return beanInfoSupport;
}
 

import javax.management.openmbean.OpenMBeanParameterInfoSupport; //导入依赖的package包/类
/**
 * The operations are pulled from the core cache and the member regions.
 * @param cache 
 *
 */
private OpenMBeanOperationInfo[] createMBeanOperationInfo()
{
	List<OpenMBeanOperationInfo> operations = new ArrayList<OpenMBeanOperationInfo>();
	
	for(Cache cache : getKnownCaches())
	{
		if(cache != null && !cache.isInitialized())
			operations.add(
	     		new OpenMBeanOperationInfoSupport(initializePrefix + cache.getName(), 
	     				"Initialize the cache (root directory must be set first) \n" +
	     				"This action is ignored if the cache is initialized.\n" + 
	     				"If the cache has been started with a valid configuration state available \n" +
	     				"it will start in an initialized state.  Changes to configuration will then require a restart of the server.", 
	     				new OpenMBeanParameterInfo[]{}, 
	     				SimpleType.VOID, MBeanOperationInfo.ACTION)
	     	);

		if(cache != null && cache.isInitialized() && !cache.isEnabled() )
			operations.add(
	     		new OpenMBeanOperationInfoSupport(enablePrefix + cache.getName(), 
	     				"Enable the cache (cache must be initialized)", 
	     				new OpenMBeanParameterInfo[]{}, 
	     				SimpleType.VOID, MBeanOperationInfo.ACTION)
	     	);
		
		else if(cache != null && cache.isEnabled())
			operations.add(
	     		new OpenMBeanOperationInfoSupport(disablePrefix + cache.getName(), 
	     				"Disable the cache (cache must be initialized and enabled)", 
	     				new OpenMBeanParameterInfo[]{}, 
	     				SimpleType.VOID, MBeanOperationInfo.ACTION)
	     	);
	}
	
	operations.add(
     		new OpenMBeanOperationInfoSupport(storeOperation, 
     				"Store the named cache configuration to persistent storage", 
     				new OpenMBeanParameterInfo[]{new OpenMBeanParameterInfoSupport("name", "the bname of the cache to save configuration of", SimpleType.STRING)}, 
     				SimpleType.VOID, MBeanOperationInfo.ACTION)
     	);
	
	operations.add(
     		new OpenMBeanOperationInfoSupport(storeAllOperation, 
     				"Store all current cache configuration to persistent storage", 
     				new OpenMBeanParameterInfo[]{}, 
     				SimpleType.VOID, MBeanOperationInfo.ACTION)
     	);
	
	operations.add(
    		new OpenMBeanOperationInfoSupport(createOperation, 
    				"Create a new cache at the specified location.", 
				new OpenMBeanParameterInfo[]
				{
					new OpenMBeanParameterInfoSupport("cacheName", "The name of the cache (and the root of the configuration file name)", SimpleType.STRING),
					new OpenMBeanParameterInfoSupport("cacheLocation", "The URI of the cache location (e.g. 'file:///vix/cache' or 'smb://server/cacheroot')", SimpleType.STRING),
					new OpenMBeanParameterInfoSupport("prototypeName", "The name of the prototype or blank(e.g. 'VixPrototype', 'TestWithEvictionPrototype')", SimpleType.STRING)
				}, 
				SimpleType.STRING, 
				MBeanOperationInfo.ACTION)
    	);
	
	return operations.toArray(new OpenMBeanOperationInfoSupport[operations.size()]);
}
 

import javax.management.openmbean.OpenMBeanParameterInfoSupport; //导入依赖的package包/类
private OpenMBeanParameterInfo[] getParameterInfos(ModelNode opNode) {
    if (!opNode.hasDefined(REQUEST_PROPERTIES)) {
        return EMPTY_PARAMETERS;
    }
    List<Property> propertyList = opNode.get(REQUEST_PROPERTIES).asPropertyList();
    List<OpenMBeanParameterInfo> params = new ArrayList<OpenMBeanParameterInfo>(propertyList.size());

    for (Property prop : propertyList) {
        ModelNode value = prop.getValue();
        String paramName = NameConverter.convertToCamelCase(prop.getName());

        Map<String, Object> descriptions = new HashMap<String, Object>(4);

        boolean expressionsAllowed = prop.getValue().hasDefined(EXPRESSIONS_ALLOWED) && prop.getValue().get(EXPRESSIONS_ALLOWED).asBoolean();
        descriptions.put(DESC_EXPRESSIONS_ALLOWED, String.valueOf(expressionsAllowed));

        if (!expressionsAllowed) {
            Object defaultValue = getIfExists(value, DEFAULT);
            descriptions.put(DEFAULT_VALUE_FIELD, defaultValue);
            if (value.has(ALLOWED)) {
                if (value.get(TYPE).asType()!=ModelType.LIST){
                    List<ModelNode> allowed = value.get(ALLOWED).asList();
                    descriptions.put(LEGAL_VALUES_FIELD, fromModelNodes(allowed));
                }
            } else {
                if (value.has(MIN)) {
                    Comparable minC = getIfExistsAsComparable(value, MIN);
                    if (minC instanceof Number) {
                        descriptions.put(MIN_VALUE_FIELD, minC);
                    }
                }
                if (value.has(MAX)) {
                    Comparable maxC = getIfExistsAsComparable(value, MAX);
                    if (maxC instanceof Number) {
                        descriptions.put(MAX_VALUE_FIELD, maxC);
                    }
                }
            }
        }


        params.add(
                new OpenMBeanParameterInfoSupport(
                        paramName,
                        getDescription(prop.getValue()),
                        converters.convertToMBeanType(value),
                        new ImmutableDescriptor(descriptions)));

    }
    return params.toArray(new OpenMBeanParameterInfo[params.size()]);
}