Java ArrayNode类代码示例

import org.codehaus.jackson.node.ArrayNode; //导入依赖的package包/类
public static String createAuthLinkResponse(){

        JsonNodeFactory f = JsonNodeFactory.instance ;
        ObjectNode loginResponse = f.objectNode();
        loginResponse.put("text","Authorization for SkyGiraffe to use Slack details is required.");
        ArrayNode attachments = loginResponse.putArray("attachments");
        ObjectNode att = f.objectNode();
        att.put("fallback", "Please authorize SkyGiraffe to access to your Slack details ...");
        att.put("pretext", "");
        att.put("title", "Please authorize..");
        att.put("title_link", Config.getPropertyValue("SLACK_AUTH_URL_DEV"));
        att.put("text","Once authorized and logged into SkyGiraffe try '/sg help' to see all commands");
        att.put("color", "#7CD197");

        attachments.add(att);
        return loginResponse.toString();

    }
 

import org.codehaus.jackson.node.ArrayNode; //导入依赖的package包/类
@Path("list")
@GET
@Produces(MediaType.APPLICATION_JSON)
public String   getClusterAsJson() throws Exception
{
    InstanceConfig      config = context.getExhibitor().getConfigManager().getConfig();

    ObjectNode          node = JsonNodeFactory.instance.objectNode();

    ArrayNode           serversNode = JsonNodeFactory.instance.arrayNode();
    ServerList          serverList = new ServerList(config.getString(StringConfigs.SERVERS_SPEC));
    for ( ServerSpec spec : serverList.getSpecs() )
    {
        serversNode.add(spec.getHostname());
    }
    node.put("servers", serversNode);
    node.put("port", config.getInt(IntConfigs.CLIENT_PORT));

    return JsonUtil.writeValueAsString(node);
}
 

import org.codehaus.jackson.node.ArrayNode; //导入依赖的package包/类
public static Criteria getCriteria(ObjectNode rudeCriteria) throws Exception {
	Criteria criteria = new Criteria();
	if (rudeCriteria.has("criterions")) {
		ArrayNode criterions = (ArrayNode) rudeCriteria.get("criterions");
		if (criterions != null) {
			for (Iterator<JsonNode> it = criterions.iterator(); it.hasNext();) {
				criteria.addCriterion(parseCriterion((ObjectNode) it.next()));
			}
		}
	}

	if (rudeCriteria.has("orders")) {
		ArrayNode orders = (ArrayNode) rudeCriteria.get("orders");
		if (orders != null) {
			for (Iterator<JsonNode> it = orders.iterator(); it.hasNext();) {
				ObjectNode rudeCriterion = (ObjectNode) it.next();
				Order order = new Order(JsonUtils.getString(rudeCriterion, "property"), JsonUtils.getBoolean(rudeCriterion, "desc"));
				criteria.addOrder(order);
			}
		}
	}
	return criteria;
}
 

import org.codehaus.jackson.node.ArrayNode; //导入依赖的package包/类
/**
 * Extracts the crosspost blogs from an autosave and creates a JSON array.
 *
 * @param item
 *            the item that holds the note data
 * @return the array
 */
private ArrayNode extractCrosspostBlogs(AutosaveNoteData item) {
    ArrayNode result = JsonHelper.getSharedObjectMapper().createArrayNode();
    if (item.getCrosspostBlogs() != null) {
        for (BlogData b : item.getCrosspostBlogs()) {
            String title = b.getTitle();
            ObjectNode blog = BlogSearchHelper.createBlogSearchJSONResult(b.getId(),
                    b.getNameIdentifier(), title, false);
            result.add(blog);
        }
    }
    if (result.size() == 0) {
        return null;
    }
    return result;
}
 

import org.codehaus.jackson.node.ArrayNode; //导入依赖的package包/类
/**
 * @throws Exception
 *             in case of an error
 */
@Test(dependsOnMethods = { "testCreateEditBlog" })
public void getReadableBlogs() throws Exception {

    ArrayNode array = doGetRequestAsJSONArray("/blogs.json?blogListType=READ&searchString="
            + searchString, username, password);

    Assert.assertTrue(array.size() >= 1,
            "The array must have at least one blog with the search string! array=" + array);
    for (int i = 0; i < array.size(); i++) {
        JsonNode blog = array.get(i);
        if (LOG.isDebugEnabled()) {
            LOG.debug("Checking blog=" + blog);
        }
        checkJSONBlogResult(blog, "blog[" + i + "]");
        String title = blog.get("title").asText();
        Assert.assertTrue(title.contains(searchString),
                "Blog title must contain searchString! title=" + title + " searchString="
                        + searchString);
    }

}
 

import org.codehaus.jackson.node.ArrayNode; //导入依赖的package包/类
/**
 * {
 "attachments": [
 {
 "fallback": "Please login into SkyGiraffe to continue ...",
 "pretext": "SkyGiraffe Login",
 "title": "Please login into SkyGiraffe to continue ...",
 "title_link": "https://sgbot-mobilityai.rhcloud.com/SGbot-1.0/skyg/login?key=",
 "text": "Once logged in try '/sg help' to see all commands",
 "color": "#7CD197"
 }
 ]
 }
 * @return
 */
public static String createLoginLinkResponse(String slackUserId, String email, String teamId){

    JsonNodeFactory f = JsonNodeFactory.instance ;
    ObjectNode loginResponse = f.objectNode();
    loginResponse.put("text","Login to SkyGiraffe is required.");
    ArrayNode attachments = loginResponse.putArray("attachments");
    ObjectNode att = f.objectNode();
    att.put("fallback", "Please login into SkyGiraffe to continue ...");
    att.put("pretext", "");
    att.put("title", "Please login..");
    att.put("title_link", Config.getPropertyValue("SGDS_LOGIN_URL_DEV")+slackUserId+"&EMAIL="+email+"&TEAMID="+teamId);
    att.put("text","Once logged in try '/sg help' to see all commands");
    att.put("color", "#7CD197");

    attachments.add(att);

    return loginResponse.toString();

}
 

import org.codehaus.jackson.node.ArrayNode; //导入依赖的package包/类
protected static Map<String, String> argumentsOn(JsonNode node) {

		Map<String, String> argValues = new HashMap<>();
		
		JsonNode argsNode = node.get(ArgsKey);
		if (argsNode == null) return argValues;

		if (!argsNode.isArray()) {
			System.err.println("invalid argument node, must be an array");
			return argValues;
		}

		ArrayNode args = (ArrayNode)argsNode;

		final int argCount = args.size();

		for (int i=0; i<argCount; i++) {
			String[] tuple = getArgs(args.get(i));
			argValues.put(tuple[0], tuple[1]);
		}

		return argValues;
	}
 

import org.codehaus.jackson.node.ArrayNode; //导入依赖的package包/类
private static List<Integer>[] getOperatorDependency(ArrayNode operatorsJson)
{
    Map<String, Integer> relationName2OperatorID = new HashMap<String, Integer>();
    int numOperators = operatorsJson.size();
    List<Integer>[] inputOperatorIDs = new ArrayList[numOperators];

    for (int i = 0; i < numOperators; i++)
    {
        JsonNode operatorJson = operatorsJson.get(i);
        if (!operatorJson.has("operator"))
            continue;

        OperatorType type =
                OperatorType.valueOf(operatorJson.get("operator").getTextValue());
        String outputName = operatorJson.get("output").getTextValue();

        if (type.isTupleOperator())
        {
            inputOperatorIDs[i] =
                    getInputOperatorIDs(relationName2OperatorID, operatorJson);
            relationName2OperatorID.put(outputName, i);
        }
    }

    return inputOperatorIDs;
}
 

import org.codehaus.jackson.node.ArrayNode; //导入依赖的package包/类
@Private
public JsonNode countersToJSON(Counters counters) {
  ObjectMapper mapper = new ObjectMapper();
  ArrayNode nodes = mapper.createArrayNode();
  if (counters != null) {
    for (CounterGroup counterGroup : counters) {
      ObjectNode groupNode = nodes.addObject();
      groupNode.put("NAME", counterGroup.getName());
      groupNode.put("DISPLAY_NAME", counterGroup.getDisplayName());
      ArrayNode countersNode = groupNode.putArray("COUNTERS");
      for (Counter counter : counterGroup) {
        ObjectNode counterNode = countersNode.addObject();
        counterNode.put("NAME", counter.getName());
        counterNode.put("DISPLAY_NAME", counter.getDisplayName());
        counterNode.put("VALUE", counter.getValue());
      }
    }
  }
  return nodes;
}
 

import org.codehaus.jackson.node.ArrayNode; //导入依赖的package包/类
public ArrayNode orderCollection(Collection<Order> collection) {
    ArrayNode array = JsonNodeFactory.instance.arrayNode();
    for(Order param : collection){
        ObjectNode obj =  JsonNodeFactory.instance.objectNode();
        obj.put("orderId", param.getId() );
        obj.put("mile", param.getMilesage() );
        obj.put("price", param.getPrice() );
        obj.put("sold", param.getSold() );
        obj.put("carName", param.getCar().getName() );
        obj.put("carId", param.getCar().getId() );
        obj.put("modelId", param.getCar().getModel().getId() );
        obj.put("bodyId", param.getCar().getBody().getId() );
        obj.put("drivetype", param.getCar().getDriveType().getId());
        obj.put("engineId", param.getCar().getEngine().getId() );
        obj.put("transsmId", param.getCar().getTransmission().getId() );
        obj.put("data", param.getRelease().getTime());
        obj.put("userId", param.getUser().getId() );
        array.add(obj);
    }
    return array;
}
 

import org.codehaus.jackson.node.ArrayNode; //导入依赖的package包/类
public ArrayNode convert(Collection<Order> collection) {

        ArrayNode array = JsonNodeFactory.instance.arrayNode();
        for(Order param : collection){

            ObjectNode order = JsonNodeFactory.instance.objectNode();
            order.put("orderId", param.getId() );
            order.put("mile", param.getMilesage() );
            order.put("price", param.getPrice() );
            if(param.getSold()){
                order.put("sold", "V" );
            } else {
                order.put("sold", "" );
            }
            order.put("carName", param.getCar().getName() );
            order.put("carId", param.getCar().getId() );

            GregorianCalendar calendar = new GregorianCalendar();
            calendar.setTimeInMillis(param.getRelease().getTime());
            //calendar.get(Calendar.YEAR);

            order.put("data", String.valueOf(calendar.get(Calendar.YEAR)));
            order.put("userId", param.getUser().getId() );
            array.add(order);
        }
        return array;

    }
 

import org.codehaus.jackson.node.ArrayNode; //导入依赖的package包/类
/**
 * Creates an array of JSON objects which hold details about the found users or groups.
 * 
 * @param list
 *            the search result to process
 * @param addSummary
 *            if true a summary JSON object will be added to the top of the array. The JSON
 *            object will be created with {@link #createSearchSummaryStatement(PageableList)} .
 * @param imageSize
 *            the size of the user logo to include in the image path, can be null to not include
 *            the image path into the JSON object. For groups no image will be included.
 * @return the JSON array with the details about the users
 */
public static ArrayNode createEntitySearchJSONResult(
        PageableList<CommunoteEntityData> list, boolean addSummary,
        ImageSizeType imageSize) {
    JsonNodeFactory nodeFactory = JsonHelper.getSharedObjectMapper()
            .getNodeFactory();
    ArrayNode result = nodeFactory.arrayNode();
    if (addSummary) {
        result.add(UserSearchHelper.createSearchSummaryStatement(list));
    }
    for (CommunoteEntityData item : list) {
        String imagePath = null;
        boolean isGroup = (item instanceof EntityGroupListItem);
        if (!isGroup && imageSize != null) {
            imagePath = ImageUrlHelper.buildUserImageUrl(item.getEntityId(), imageSize);
        }
        ObjectNode entry = createUserSearchJSONResult(item.getEntityId(),
                item.getShortDisplayName(), item.getDisplayName(),
                imagePath, item.getAlias());
        entry.put("isGroup", isGroup);
        result.add(entry);
    }
    return result;
}
 

import org.codehaus.jackson.node.ArrayNode; //导入依赖的package包/类
/**
 * Add the JSON objects of the blogs to the JSON response.
 * 
 * @param jsonResponse
 *            the response object to write to
 * @param list
 *            list to process
 * @param includeDescription
 *            whether to include the description
 * @param includeImagePath
 *            whether to include the path to the image
 */
private static void addBlogsToJsonResponse(ArrayNode jsonResponse,
        Collection<BlogData> list, boolean includeDescription, boolean includeImagePath) {
    for (BlogData item : list) {
        ObjectNode entry;
        if (includeDescription) {
            entry = BlogSearchHelper.createBlogSearchJSONResult(item.getId(),
                    item.getNameIdentifier(), item.getTitle(), item.getDescription(),
                    includeImagePath);
        } else {
            entry = BlogSearchHelper.createBlogSearchJSONResult(item.getId(),
                    item.getNameIdentifier(), item.getTitle(), includeImagePath);
        }
        jsonResponse.add(entry);
    }
}
 

import org.codehaus.jackson.node.ArrayNode; //导入依赖的package包/类
/**
 * Export the children of the topic to the response metadata as a JSON array
 * 
 * @param children
 *            the children to export
 */
private void exportChildrenToMetadata(List<DetailBlogListItem> children) {
    children = BlogManagementHelper.sortedBlogList(children);
    ArrayNode result = JsonHelper.getSharedObjectMapper().createArrayNode();
    for (DetailBlogListItem child : children) {
        result.add(BlogSearchHelper.createBlogSearchJSONResult(child.getId(),
                child.getNameIdentifier(), child.getTitle(), false));
    }
    this.setResponseMetadata("childTopics", result);
}
 

import org.codehaus.jackson.node.ArrayNode; //导入依赖的package包/类
/**
 * Extracts the attachments from a note and creates a JSON array.
 *
 * @param item
 *            the item that holds the note data
 * @return the array
 */
private ArrayNode extractAttachments(NoteData item) {
    ArrayNode result = JsonHelper.getSharedObjectMapper().createArrayNode();
    List<AttachmentData> attachments = item.getAttachments();
    if (attachments != null) {
        for (AttachmentData attachment : attachments) {
            ObjectNode attach = CreateBlogPostFeHelper.createAttachmentJSONObject(attachment);
            result.add(attach);
        }
    }
    return result.size() == 0 ? null : result;
}