Java JSON类代码示例

import org.apache.jena.atlas.json.JSON; //导入依赖的package包/类
/**
 * Return the concept with the supplied URI with pref label, uri and type fields populated
 * @param conceptUri - the concept to be returned
 * @return - the requested concept 
 * @throws OEClientException - an error has occurred contacting the server
 */
public Concept getConcept(String conceptUri) throws OEClientException {
	logger.info("getConcept entry: {}", conceptUri);

	Map<String, String> queryParameters = new HashMap<String, String>();
	queryParameters.put("properties", basicProperties);
	queryParameters.put("path", getPathParameter(conceptUri));
	Invocation.Builder invocationBuilder = getInvocationBuilder(getApiURL(), queryParameters);

	Date startDate = new Date();
	logger.info("getConcept making call  : {}", startDate.getTime());
	Response response = invocationBuilder.get();
	logger.info("getConcept call complete: {}", startDate.getTime());

	logger.info("getConceptDetails - status: {}", response.getStatus());
	if (response.getStatus() == 200) {
		String stringResponse = response.readEntity(String.class);
		if (logger.isDebugEnabled()) logger.debug("getConceptDetails: jsonResponse {}", stringResponse);
		JsonObject jsonResponse = JSON.parse(stringResponse);
		return new Concept(this, jsonResponse.get("@graph").getAsArray().get(0).getAsObject());
	} else {
		throw new OEClientException(String.format("Error(%d) %s from server", response.getStatus(), response.getStatusInfo().toString()));
	}
}
 

import org.apache.jena.atlas.json.JSON; //导入依赖的package包/类
/**
 * Return the concept with the supplied identifier
 * @param identifier - the unique identifier for the concept (not the URI)
 * @return - the requested concept
 * @throws OEClientException - an error has occurred contacting the server
 */
public Concept getConceptByIdentifier(Identifier identifier) throws OEClientException {
	logger.info("getConceptByIdentifier entry: {}", identifier);

	String url = getModelURL() + "/skos:Concept/meta:transitiveInstance";

	Map<String, String> queryParameters = new HashMap<String, String>();
	queryParameters.put("properties", basicProperties);
	queryParameters.put("filters", String.format("subject(exists %s \"%s\")", getWrappedUri(identifier.getUri()), identifier.getValue()));
	Invocation.Builder invocationBuilder = getInvocationBuilder(url, queryParameters);

	Date startDate = new Date();
	logger.info("getConceptByIdentifier making call  : {}", startDate.getTime());
	Response response = invocationBuilder.get();
	logger.info("getConceptByIdentifier call complete: {}", startDate.getTime());

	logger.info("getConceptByIdentifier - status: {}", response.getStatus());
	if (response.getStatus() == 200) {
		String stringResponse = response.readEntity(String.class);
		if (logger.isDebugEnabled()) logger.debug("getConceptByIdentifier: jsonResponse {}", stringResponse);
		JsonObject jsonResponse = JSON.parse(stringResponse);
		return new Concept(this, jsonResponse.get("@graph").getAsArray().get(0).getAsObject());
	} else {
		throw new OEClientException(String.format("Error(%d) %s from server", response.getStatus(), response.getStatusInfo().toString()));
	}
}
 

import org.apache.jena.atlas.json.JSON; //导入依赖的package包/类
public void populateRelatedConceptUris(String relationshipUri, Concept concept) throws OEClientException {
	logger.info("populateNarrowerConceptURIs entry: {}", concept.getUri());

	Map<String, String> queryParameters = new HashMap<String, String>();
	queryParameters.put("properties", getWrappedUri(relationshipUri));
	Invocation.Builder invocationBuilder = getInvocationBuilder(getResourceURL(concept.getUri()), queryParameters);

	Date startDate = new Date();
	logger.info("populateNarrowerConceptURIs making call  : {}", startDate.getTime());
	Response response = invocationBuilder.get();
	logger.info("populateNarrowerConceptURIs call complete: {}", startDate.getTime());

	logger.info("populateNarrowerConceptURIs - status: {}", response.getStatus());
	if (response.getStatus() == 200) {
		String stringResponse = response.readEntity(String.class);
		if (logger.isDebugEnabled()) logger.debug("populateNarrowerConceptURIs: jsonResponse {}", stringResponse);
		JsonObject jsonResponse = JSON.parse(stringResponse);
		concept.populateRelatedConceptUris(relationshipUri, jsonResponse.get("@graph").getAsArray().get(0).getAsObject());
	} else {
		throw new OEClientException(String.format("Error(%d) %s from server", response.getStatus(), response.getStatusInfo().toString()));
	}
}
 

import org.apache.jena.atlas.json.JSON; //导入依赖的package包/类
public void populateMetadata(String metadataUri, Concept concept) throws OEClientException {
	logger.info("populateMetadata entry: {}", concept.getUri());

	Map<String, String> queryParameters = new HashMap<String, String>();
	queryParameters.put("properties", getWrappedUri(metadataUri));
	Invocation.Builder invocationBuilder = getInvocationBuilder(getResourceURL(concept.getUri()), queryParameters);

	Date startDate = new Date();
	logger.info("populateMetadata making call  : {}", startDate.getTime());
	Response response = invocationBuilder.get();
	logger.info("populateMetadata call complete: {}", startDate.getTime());

	logger.info("populateMetadata - status: {}", response.getStatus());
	if (response.getStatus() == 200) {
		String stringResponse = response.readEntity(String.class);
		if (logger.isDebugEnabled()) logger.debug("populateNarrowerConceptURIs: jsonResponse {}", stringResponse);
		JsonObject jsonResponse = JSON.parse(stringResponse);
		concept.populateMetadata(metadataUri, jsonResponse.get("@graph").getAsArray().get(0).getAsObject());
	} else {
		throw new OEClientException(String.format("Error(%d) %s from server", response.getStatus(), response.getStatusInfo().toString()));
	}
}
 

import org.apache.jena.atlas.json.JSON; //导入依赖的package包/类
public static void json(HttpServletRequest req, HttpServletResponse resp, JsonValue responseContent) {
    try { 
        resp.setHeader(HttpNames.hCacheControl, "no-cache");
        resp.setHeader(HttpNames.hContentType,  WebContent.contentTypeJSON);
        resp.setStatus(HttpSC.OK_200);
        try(ServletOutputStream out = resp.getOutputStream(); IndentedWriter b = new IndentedWriter(out); ) {
            b.setFlatMode(true);
            JSON.write(b, responseContent);
            b.ensureStartOfLine();
            b.flush();
            out.write('\n');
        }
    } catch (IOException ex) {
        LOG.warn("json: IOException", ex);
        try { 
            resp.sendError(HttpSC.INTERNAL_SERVER_ERROR_500, "Internal server error");
        } catch (IOException ex2) {}
    }
}
 

import org.apache.jena.atlas.json.JSON; //导入依赖的package包/类
private static JsonObject getFieldAsObject(JsonObject arg, String field) {
    try {
        if ( ! arg.hasKey(field) ) {
            LOG.warn("Bad request: Missing Field: "+field+" Arg: "+JSON.toStringFlat(arg)) ;
            throw new DeltaBadRequestException("Missing field: "+field) ;
        }
        JsonValue jv = arg.get(field) ;
        if ( ! jv.isObject() ) {
            
        }
        return jv.getAsObject();
    } catch (JsonException ex) {
        LOG.warn("Bad request: Field: "+field+" Arg: "+JSON.toStringFlat(arg)) ;
        throw new DeltaBadRequestException("Bad field '"+field+"' : "+arg.get(field)) ;
    }
}
 

import org.apache.jena.atlas.json.JSON; //导入依赖的package包/类
@Override
public void run(Model results) throws Exception {
	Resource testCase = getResource();
	String queryString = JenaUtil.getStringProperty(testCase, SH.select);
	Model model = testCase.getModel();
	JsonObject expectedJSON = JSON.parse(JenaUtil.getStringProperty(testCase, DASH.expectedResult));
	
	for(TestCaseContextFactory contextFactory : contextFactories) {
		TestCaseContext context = contextFactory.createContext();
		context.setUpTestContext();
		try {
			String actual = createResultSetJSON(queryString, model);
			JsonObject actualJSON = JSON.parse(actual);
			if(!actualJSON.equals(expectedJSON)) {
				createFailure(results, "Mismatching result set. Actual: " + actual, context);
				return;
			}
		}
		finally {
			context.tearDownTestContext();
		}
	}
	createResult(results, DASH.SuccessTestCaseResult);
}
 

import org.apache.jena.atlas.json.JSON; //导入依赖的package包/类
public Collection<Model> getAllModels() throws OEClientException {
	logger.info("getAllModels entry");
	
	String url = getApiURL() + "/sys/sys:Model/rdf:instance";
	logger.info("getAllModels URL: {}", url);
	Map<String, String> queryParameters = new HashMap<String, String>();
	queryParameters.put("properties", "meta:displayName,meta:graphUri");

	Invocation.Builder invocationBuilder = getInvocationBuilder(url, queryParameters);

	Date startDate = new Date();
	logger.info("getAllModels making call  : {}", startDate.getTime());
	Response response = invocationBuilder.get();
	logger.info("getAllModels call complete: {}", startDate.getTime());

	logger.info("getAllModels - status: {}", response.getStatus());

	if (response.getStatus() == 200) {
		String stringResponse = response.readEntity(String.class);
		if (logger.isInfoEnabled()) logger.info("getAllModels: jsonResponse {}", stringResponse);
		JsonObject jsonResponse = JSON.parse(stringResponse);
		JsonArray jsonArray = jsonResponse.get("@graph").getAsArray();
		Collection<Model> models = new ArrayList<Model>();
		Iterator<JsonValue> jsonValueIterator = jsonArray.iterator();
		while (jsonValueIterator.hasNext()) {
			JsonObject modelObject = jsonValueIterator.next().getAsObject();
			models.add(new Model(modelObject));
		}
		return models;
	} else {
		throw new OEClientException(String.format("Error(%d) %s from server", response.getStatus(), response.getStatusInfo().toString()));
	}
}
 

import org.apache.jena.atlas.json.JSON; //导入依赖的package包/类
private Collection<RelationshipType> getRelationshipTypes(String parentType) throws OEClientException {
	logger.info("getRelationshipTypes entry: {}", parentType);

	Map<String, String> queryParameters = new HashMap<String, String>();
	queryParameters.put("properties", "rdfs:label,owl:inverseOf,rdfs:subPropertyOf,owl:inverseOf/rdfs:label,owl:inverseOf/rdfs:subPropertyOf");
	Invocation.Builder invocationBuilder = getInvocationBuilder(getModelURL() + "/" + parentType +"/meta:transitiveSubProperty", queryParameters);

	Date startDate = new Date();
	logger.info("getRelationshipTypes making call  : {}", startDate.getTime());
	Response response = invocationBuilder.get();
	logger.info("getRelationshipTypes call complete: {}", startDate.getTime());

	logger.info("getRelationshipTypes - status: {}", response.getStatus());
	if (response.getStatus() == 200) {
		String stringResponse = response.readEntity(String.class);
		if (logger.isInfoEnabled()) logger.info("getConceptClasses: jsonResponse {}", stringResponse);
		JsonObject jsonResponse = JSON.parse(stringResponse);
		JsonArray jsonArray = jsonResponse.get("@graph").getAsArray();
		Collection<RelationshipType> relationshipTypes = new HashSet<RelationshipType>();
		Iterator<JsonValue> jsonValueIterator = jsonArray.iterator();
		while (jsonValueIterator.hasNext()) {
			relationshipTypes.add(new RelationshipType(this, jsonValueIterator.next().getAsObject()));
		}
		return relationshipTypes;
	} else {
		throw new OEClientException(String.format("Error(%d) %s from server", response.getStatus(), response.getStatusInfo().toString()));
	}
}
 

import org.apache.jena.atlas.json.JSON; //导入依赖的package包/类
/**
 * Return all concept classes
 * @return - a collection containing all concept classes
 * @throws OEClientException - an error has occurred contacting the server
 */
public Collection<ConceptClass> getConceptClasses(int limit) throws OEClientException {
	logger.info("getConceptClasses entry");

	Map<String, String> queryParameters = new HashMap<String, String>();
	queryParameters.put("properties", "rdfs:label,rdfs:subClassOf");
	queryParameters.put("limit", Integer.toString(limit));
	Invocation.Builder invocationBuilder = getInvocationBuilder(getModelURL() + "/skos:Concept/meta:transitiveSubClass", queryParameters);

	Date startDate = new Date();
	logger.info("getConceptClasses making call  : {}", startDate.getTime());
	Response response = invocationBuilder.get();
	logger.info("getConceptClasses call complete: {}", startDate.getTime());

	logger.info("getConceptClasses - status: {}", response.getStatus());
	if (response.getStatus() == 200) {
		String stringResponse = response.readEntity(String.class);
		if (logger.isInfoEnabled()) logger.info("getConceptClasses: jsonResponse {}", stringResponse);
		JsonObject jsonResponse = JSON.parse(stringResponse);
		JsonArray jsonArray = jsonResponse.get("@graph").getAsArray();
		Collection<ConceptClass> conceptClasses = new HashSet<ConceptClass>();
		Iterator<JsonValue> jsonValueIterator = jsonArray.iterator();
		while (jsonValueIterator.hasNext()) {
			conceptClasses.add(new ConceptClass(this, jsonValueIterator.next().getAsObject()));
		}
		return conceptClasses;
	} else {
		throw new OEClientException(String.format("Error(%d) %s from server", response.getStatus(), response.getStatusInfo().toString()));
	}
}
 

import org.apache.jena.atlas.json.JSON; //导入依赖的package包/类
@Test
public void testVocabularyManagement() throws Exception {
	RESTResource resource;
	String ontoId;

	Map<String,String> parameters = new HashMap<String,String>();
	
	// POST vocabulary
	String ontoUri = "http://purl.oclc.org/NET/ssnx/qu/qu-rec20";
	InputStream uriStream = new ByteArrayInputStream(ontoUri.getBytes("UTF-8"));
	resource = vch.post(new URI(baseUri + "/vocab"), parameters, uriStream);
	ontoId = resource.path;

	Assert.assertTrue("QU ontology not registered", VocabularyUtils.containsVocabulary(ontoUri));
	
	// GET vocabulary by SPARQL query
	parameters.clear();
	parameters.put("query", "?s ?p ?o");
	resource = vch.get(new URI(baseUri + "/vocab"), parameters);
	
	JsonValue ontoIds = JSON.parseAny(resource.content);
	Assert.assertTrue("Vocabulary collection is not an array", ontoIds.isArray());
	Assert.assertTrue("Vocabulary imports were not added", ontoIds.getAsArray().size() > 1);
	Assert.assertTrue("QU ontology not found", ontoIds.getAsArray().contains(new JsonString(ontoId)));
	
	// GET vocabulary by id
	VocabularyHandler vh = new VocabularyHandler(ontoId, ThingDirectory.servers);
	resource = vh.get(new URI(baseUri + ontoId), null);
	
	ByteArrayInputStream byteStream = new ByteArrayInputStream(resource.content.getBytes());
	Model m = ModelFactory.createDefaultModel();
	m.read(byteStream, "", "Turtle");
	Assert.assertFalse("QU ontology definition is not valid", m.isEmpty());

	// DELETE vocabulary
	vh.delete(new URI(baseUri + ontoId), null, null);
	Assert.assertFalse("QU ontology not deleted", VocabularyUtils.containsVocabulary(ontoUri));
}
 

import org.apache.jena.atlas.json.JSON; //导入依赖的package包/类
private static void handleMissingConfigFile(Path path) {
    //throw new DeltaConfigException("No such file: "+path.toString());
    JsonObject obj = JSONX.buildObject(b->{
        b.key(F_VERSION).value(DeltaConst.SYSTEM_VERSION);
        // Default log provider
        b.key(F_LOG_TYPE).value(DeltaConst.LOG_FILE);
    });
    try ( IndentedWriter out = new IndentedWriter(Files.newOutputStream(path)); ) {
        JSON.write(out, obj);
        out.ensureStartOfLine();
    } catch (IOException ex) { IO.exception(ex); }
}
 

import org.apache.jena.atlas.json.JSON; //导入依赖的package包/类
/**
 * Create a {@link DataSource} by reading the "source.cfg" file"
 * @param dataSourceArea The directory where the DataSources details are stored.
 * @return DataSource
 */
public static DataSource makeDataSource(Path dataSourceArea) {
    JsonObject sourceObj = JSON.read(dataSourceArea.resolve(DeltaConst.DS_CONFIG).toString());
    DataSourceDescription dsd = DataSourceDescription.fromJson(sourceObj);
    Id id = dsd.getId();
    String baseStr = dsd.getName();
    String uriStr = dsd.getUri(); 
    DataSource dataSource = DataSource.connect(id, uriStr, baseStr, dataSourceArea);
    return dataSource ;
}
 

import org.apache.jena.atlas.json.JSON; //导入依赖的package包/类
private Id createDataSource$(PatchStore patchStore, DataSourceDescription dsd) {
    synchronized(lock) {
        Path sourcePath = null;
        if ( ! patchStore.isEphemeral() ) {
            Location sourceArea = dataSourceArea(serverRoot, dsd.getName());
            sourcePath = IOX.asPath(sourceArea);

            // Checking.
            // The area can exist, but it must not be formatted for a DataSource 
            //        if ( sourceArea.exists() )
            //            throw new DeltaException("Area already exists");

            if ( Cfg.isMinimalDataSource(LOG, sourcePath) )
                throw new DeltaBadRequestException("DataSource area already exists at: "+sourceArea);
            if ( ! Cfg.isEnabled(sourcePath) )
                throw new DeltaBadRequestException("DataSource area disabled: "+sourceArea);

            String patchesDirName = sourceArea.getPath(DeltaConst.LOG);
            if ( FileOps.exists(patchesDirName) )
                throw new DeltaBadRequestException("DataSource area does not have a configuration but does have a patches area.");

            String dataDirName = sourceArea.getPath(DeltaConst.DATA);
            if ( FileOps.exists(dataDirName) )
                throw new DeltaBadRequestException("DataSource area has a likely looking database already");

            // Create source.cfg.
            JsonObject obj = dsd.asJson();
            LOG.info(JSON.toStringFlat(obj));
            try (OutputStream out = Files.newOutputStream(sourcePath.resolve(DeltaConst.DS_CONFIG))) {
                JSON.write(out, obj);
            } catch (IOException ex)  { throw IOX.exception(ex); }
        }
        // XXX Pass in dsd
        DataSource newDataSource = DataSource.connect(dsd.getId(), dsd.getUri(), dsd.getName(), sourcePath);
        dataRegistry.put(dsd.getId(), newDataSource);
        return dsd.getId() ;
    }
}
 

import org.apache.jena.atlas.json.JSON; //导入依赖的package包/类
private static String getFieldAsString(JsonObject arg, String field, boolean required) {
    try {
        if ( ! arg.hasKey(field) ) {
            if ( required ) {
                LOG.warn("Bad request: Missing Field: "+field+" Arg: "+JSON.toStringFlat(arg)) ;
                throw new DeltaBadRequestException("Missing field: "+field) ;
            }
            return null;
        }
        return arg.get(field).getAsString().value() ;
    } catch (JsonException ex) {
        LOG.warn("Bad request: Field not a string: "+field+" Arg: "+JSON.toStringFlat(arg)) ;
        throw new DeltaBadRequestException("Bad field '"+field+"' : "+arg.get(field)) ;
    }
}