Java JsonNode.get方法代码示例

import org.codehaus.jackson.JsonNode; //导入方法依赖的package包/类
private List<JsonNode> findBy(String key, String value, boolean onlyReturnFirstMatch, boolean arrayContainingMatch) {
    Iterator<JsonNode> nodes = root.get("data").getElements();
    List<JsonNode> results = new LinkedList<>();
    while(nodes.hasNext()) {
        JsonNode node = nodes.next();
        if ((null != node.get(key)) && (node.get(key).isValueNode())) {
            final String valueNode = node.get(key).getTextValue();
            if (arrayContainingMatch) {
                if (splitPseudoJsonValueArray(valueNode).contains(value)) {
                    results.add(node);
                }
            } else {
                if (valueNode.equals(value)) {
                    results.add(node);
                }
            }
        }
    }
    return results;
}
 

import org.codehaus.jackson.JsonNode; //导入方法依赖的package包/类
@Override
public JsonCreateWebServer deserialize(final JsonParser jp, final DeserializationContext ctxt)
        throws IOException {

    final ObjectCodec obj = jp.getCodec();
    final JsonNode node = obj.readTree(jp).get(0);

    final JsonNode apacheHttpdMediaId = node.get("apacheHttpdMediaId");
    final JsonCreateWebServer jcws = new JsonCreateWebServer(node.get("webserverName").getTextValue(),
            node.get("hostName").getTextValue(),
            node.get("portNumber").asText(),
            node.get("httpsPort").asText(),
               deserializeGroupIdentifiers(node),
            node.get("statusPath").getTextValue(),
            apacheHttpdMediaId == null ? null : apacheHttpdMediaId.asText());
    return jcws;
}
 

import org.codehaus.jackson.JsonNode; //导入方法依赖的package包/类
private List<Line> parseLines(JsonNode node){
	JsonNode lineNodes=node.get("lines");
	if(lineNodes==null){
		return null;
	}
	List<Line> lines=new ArrayList<Line>();
	Iterator<JsonNode> iter=lineNodes.iterator();
	while(iter.hasNext()){
		JsonNode jsonNode=iter.next();
		Line line=new Line();
		line.setFromNodeId(jsonNode.get("fromNodeId").getIntValue());
		line.setToNodeId(jsonNode.get("toNodeId").getIntValue());
		lines.add(line);
	}
	return lines;
}
 

import org.codehaus.jackson.JsonNode; //导入方法依赖的package包/类
private void buildScoreRule(JsonParser jsonParser,JsonNode ruleNode,ScoreRule rule){
	rule.setScoringBean(JsonUtils.getJsonValue(ruleNode, "scoringBean"));
	AssignTargetType assignTargetType=AssignTargetType.valueOf(JsonUtils.getJsonValue(ruleNode, "assignTargetType"));
	rule.setAssignTargetType(assignTargetType);
	rule.setVariableCategory(JsonUtils.getJsonValue(ruleNode, "variableCategory"));
	rule.setVariableName(JsonUtils.getJsonValue(ruleNode, "variableName"));
	rule.setVariableLabel(JsonUtils.getJsonValue(ruleNode, "variableLabel"));
	String datatypeStr=JsonUtils.getJsonValue(ruleNode, "datatype");
	if(StringUtils.isNotBlank(datatypeStr)){
		rule.setDatatype(Datatype.valueOf(datatypeStr));
	}
	try{
		JsonNode knowledgePackageWrapperNode=ruleNode.get("knowledgePackageWrapper");
		ObjectMapper mapper = (ObjectMapper)jsonParser.getCodec();
		KnowledgePackageWrapper wrapper=mapper.readValue(knowledgePackageWrapperNode, KnowledgePackageWrapper.class);
		wrapper.buildDeserialize();
		rule.setKnowledgePackageWrapper(wrapper);			
	}catch(Exception ex){
		throw new RuleException(ex);
	}
	
}
 

import org.codehaus.jackson.JsonNode; //导入方法依赖的package包/类
/**
 *  Parse the json of flow_data field from execution_flows. Use recursion to handle the nested case.
 * @param flowJson
 * @param flowExecId
 * @return
 * @throws IOException
 */
public List<AzkabanJobExecRecord> parseJson(String flowJson, long flowExecId)
  throws IOException {

  ObjectMapper mapper = new ObjectMapper();
  JsonNode wholeFlow = mapper.readTree(flowJson);
  JsonNode allJobs = wholeFlow.get("nodes");
  String flowPath = wholeFlow.get("projectName").asText() + ":" + wholeFlow.get("flowId").asText();
  List<AzkabanJobExecRecord> results = parseJsonHelper(allJobs, flowExecId, flowPath);
  AzkabanJobExecUtil.sortAndSet(results);
  return results;
}
 

import org.codehaus.jackson.JsonNode; //导入方法依赖的package包/类
private JsonNode findBy(String key, String value) {
    Iterator<JsonNode> nodes = root.get("data").getElements();
    while(nodes.hasNext()) {
        JsonNode node = nodes.next();
        if ((null != node.get(key)) && (node.get(key).isValueNode())) {
            final String valueNode = node.get(key).getTextValue();
            if (valueNode.equals(value)) {
                return node;
            }
        }
    }
    return null;
}
 

import org.codehaus.jackson.JsonNode; //导入方法依赖的package包/类
@Override
public JsonControlWebServer deserialize(final JsonParser jp,
                                  final DeserializationContext ctxt) throws IOException {

    final ObjectCodec obj = jp.getCodec();
    final JsonNode rootNode = obj.readTree(jp);
    final JsonNode operation = rootNode.get("controlOperation");

    return new JsonControlWebServer(operation.getTextValue());
}
 

import org.codehaus.jackson.JsonNode; //导入方法依赖的package包/类
public static ComplexArithmetic parseComplexArithmetic(JsonNode node){
	JsonNode arithmeticNode=node.get("arithmetic");
	if(arithmeticNode==null){
		return null;
	}
	ComplexArithmetic arith=new ComplexArithmetic();
	arith.setType(ArithmeticType.valueOf(getJsonValue(arithmeticNode, "type")));
	arith.setValue(parseValue(arithmeticNode));
	return arith;
}
 

import org.codehaus.jackson.JsonNode; //导入方法依赖的package包/类
/**
 * Get the version of the bundle
 * @param symbolicName bundle symbolic name
 * @return bundle version
 * @throws ClientException if the version is not retrieved
 */
public String getBundleVersion(String symbolicName) throws ClientException {
    final JsonNode bundle = getBundleData(symbolicName);
    final JsonNode versionNode = bundle.get(JSON_KEY_VERSION);

    if (versionNode == null) {
        throw new ClientException("Cannot get version from bundle json");
    }

    return versionNode.getTextValue();
}
 

import org.codehaus.jackson.JsonNode; //导入方法依赖的package包/类
private NamedCriteria parseNamedCriteria(JsonNode jsonNode){
	NamedCriteria criteria=new NamedCriteria();
	criteria.setReferenceName(jsonNode.get("referenceName").getTextValue());
	criteria.setVariableCategory(jsonNode.get("variableCategory").getTextValue());
	JsonNode unitNode=jsonNode.get("unit");
	if(unitNode!=null){
		CriteriaUnit unit = parseCriteriaUnit(unitNode);
		criteria.setUnit(unit);
	}
	return criteria;
}
 

import org.codehaus.jackson.JsonNode; //导入方法依赖的package包/类
/**
 * Get the state of the bundle
 * @param symbolicName bundle symbolic name
 * @return the state of the bundle
 * @throws ClientException if the state cannot be retrieved
 */
public String getBundleState(String symbolicName) throws ClientException {
    final JsonNode bundle = getBundleData(symbolicName);
    final JsonNode stateNode = bundle.get(JSON_KEY_STATE);

    if (stateNode == null) {
        throw new ClientException("Cannot get state from bundle json");
    }

    return stateNode.getTextValue();
}
 

import org.codehaus.jackson.JsonNode; //导入方法依赖的package包/类
/**
 * Get the id of the bundle
 * @param symbolicName bundle symbolic name
 * @return the id
 * @throws ClientException if the id cannot be retrieved
 */
public long getBundleId(String symbolicName) throws ClientException {
    final JsonNode bundle = getBundleData(symbolicName);
    final JsonNode idNode = bundle.get(JSON_KEY_ID);

    if (idNode == null) {
        throw new ClientException("Cannot get id from bundle json");
    }

    return idNode.getLongValue();
}
 

import org.codehaus.jackson.JsonNode; //导入方法依赖的package包/类
/**
 * Returns a data structure like:
 *
 * {
 *   "status" : "Bundle information: 173 bundles in total - all 173 bundles active.",
 *   "s" : [173,171,2,0,0],
 *   "data": [{
 *     "id":0,
 *     "name":"System Bundle",
 *     "fragment":false,
 *     "stateRaw":32,
 *     "state":"Active",
 *     "version":"3.0.7",
 *     "symbolicName":"org.apache.felix.framework",
 *     "category":""
 *   }]
 * }
 */
private JsonNode getBundleData(String symbolicName) throws ClientException {
    final String path = getBundlePath(symbolicName, ".json");
    final String content = this.doGet(path, SC_OK).getContent();
    final JsonNode root = JsonUtils.getJsonNodeFromString(content);

    if (root.get(JSON_KEY_DATA) == null) {
        throw new ClientException(path + " does not provide '" + JSON_KEY_DATA + "' element, JSON content=" + content);
    }

    Iterator<JsonNode> data = root.get(JSON_KEY_DATA).getElements();
    if (!data.hasNext()) {
        throw new ClientException(path + "." + JSON_KEY_DATA + " is empty, JSON content=" + content);
    }

    final JsonNode bundle = data.next();
    if (bundle.get(JSON_KEY_STATE) == null) {
        throw new ClientException(path + ".data[0].state missing, JSON content=" + content);
    }

    return bundle;
}
 

import org.codehaus.jackson.JsonNode; //导入方法依赖的package包/类
public ComponentInfo(JsonNode root) throws ClientException {
    if(root.get("id") != null) {
        if(root.get("id") == null) {
            throw new ClientException("No Component Info returned");
        }
        component = root;
    } else {
        if(root.get("data") == null && root.get("data").size() < 1) {
            throw new ClientException("No Component Info returned");
        }
        component = root.get("data").get(0);
    }
}
 

import org.codehaus.jackson.JsonNode; //导入方法依赖的package包/类
public BundleInfo(JsonNode root) throws ClientException {
    if(root.get("id") != null) {
        if(root.get("id") == null) {
            throw new ClientException("No Bundle Info returned");
        }
        bundle = root;
    } else {
        if(root.get("data") == null && root.get("data").size() < 1) {
            throw new ClientException("No Bundle Info returned");
        }
        bundle = root.get("data").get(0);
    }
}