Java JSONValue.parse方法代码示例

import org.json.simple.JSONValue; //导入方法依赖的package包/类
public MongoHandler(Socket client, Request req, MongoClient mongoconn) throws Exception {
    Object obj = JSONValue.parse(req.getContent());
    JSONObject jobj = (JSONObject)obj;
    System.out.println(req.getContent());
    if((database = (String)jobj.get("database")) == null) {
        throw new Exception("Database not specified");
    }
    if((collection = (String)jobj.get("collection")) == null){
        throw new Exception("Collection not specified");
    }
    if((operation = (String)jobj.get("operation")) == null){
        throw new Exception("Operation not specified");
    }
    data = (JSONObject)jobj.get("data");
    this.dbconn = mongoconn;

    mdb = dbconn.getDatabase(database);
    mcollection = mdb.getCollection(collection);
    this.client = client;
}
 

import org.json.simple.JSONValue; //导入方法依赖的package包/类
/**
    * parse and map the pages and its page timings
    *
    * @param data json data
    * @return json map
    */
  
private static JSONObject getPageMap(String data) {
       JSONObject pageMap = new JSONObject();
       JSONObject ob = (JSONObject) JSONValue.parse(data);
       for (Object tc : ob.keySet()) {
           JSONArray hars = (JSONArray) ((JSONObject) ob.get(tc)).get("har");
           for (Object e : hars) {
               JSONObject har = (JSONObject) ((JSONObject) e).get("har");
               JSONObject page = (JSONObject) ((JSONArray) (((JSONObject) har.get("log")).get("pages"))).get(0);
               Object pagename = ((JSONObject) har.get("config")).get("name");
               if (!pageMap.containsKey(pagename)) {
                   pageMap.put(pagename, new JSONArray());
               }
               JSONObject pageData = (JSONObject) page.get("pageTimings");
               pageData.put("config", har.get("config"));
               ((JSONArray) pageMap.get(pagename)).add(pageData);
           }
       }
       return pageMap;
   }
 

import org.json.simple.JSONValue; //导入方法依赖的package包/类
public static Map readCommandLineOpts() {
	Map ret = new HashMap();
	String commandOptions = System.getProperty("leaf.options");
	if (commandOptions != null) {
		String[] configs = commandOptions.split(",");
		for (String config : configs) {
			config = URLDecoder.decode(config);
			String[] options = config.split("=", 2);
			if (options.length == 2) {
				Object val = JSONValue.parse(options[1]);
				if (val == null) {
					val = options[1];
				}
				ret.put(options[0], val);
			}
		}
	}
	return ret;
}
 

import org.json.simple.JSONValue; //导入方法依赖的package包/类
public FbLoginInfo authFacebookLogin(String accessToken) {
FbLoginInfo fbLoginInfo = null;
      try {
      	JSONObject jsonmap = (JSONObject) JSONValue.parse(
          		readURL(new URL("https://graph.facebook.com/me?access_token=" + accessToken)));
      	fbLoginInfo = new FbLoginInfo(); 
      	fbLoginInfo.id = (String)jsonmap.get("id");
      	fbLoginInfo.firstName = (String)jsonmap.get("first_name");
      	fbLoginInfo.lastName = (String)jsonmap.get("last_name");
      	fbLoginInfo.email = (String)jsonmap.get("email");
      	logger.info("Facebook login : id=" + fbLoginInfo.id + " fname=" + fbLoginInfo.firstName + " lastname=" + 
      			fbLoginInfo.lastName + " email=" + fbLoginInfo.email);
      } catch (Throwable ex) {
          logger.warn("Facebook login failed for token " + accessToken);
      }
      return fbLoginInfo;
  }
 

import org.json.simple.JSONValue; //导入方法依赖的package包/类
private boolean connect() {
     try {
         final URLConnection connection = this.url.openConnection();
         connection.setConnectTimeout(5000);
         connection.addRequestProperty("User-Agent", "CS-CoreLib Loader (by mrCookieSlime)");
         connection.setDoOutput(true);

         final BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
         final JSONArray array = (JSONArray) JSONValue.parse(reader.readLine());
         download = traceURL(((String) ((JSONObject) array.get(array.size() - 1)).get("downloadUrl")).replace("https:", "http:"));
         file = new File("plugins/" + (String) ((JSONObject) array.get(array.size() - 1)).get("name") + ".jar");
         
         return true;
     } catch (IOException e) {
     	System.err.println(" ");
     	System.err.println("#################### - WARNING - ####################");
System.err.println(" ");
System.err.println("Could not connect to BukkitDev.");
System.err.println("Please download & install CS-CoreLib manually:");
System.err.println("https://dev.bukkit.org/projects/cs-corelib");
System.err.println(" ");
System.err.println("#################### - WARNING - ####################");
System.err.println(" ");
         return false;
     }
 }
 

import org.json.simple.JSONValue; //导入方法依赖的package包/类
public void appendString(String jsonObject){
	Object obj = JSONValue.parse(jsonObject);
	if (obj instanceof JSONObject){
		workingGroup.add((JSONObject)obj);
	}
	if (obj instanceof JSONArray){
		for (Object object:((JSONArray)obj)){
			if (object.toString().isEmpty()) continue;
			if (object instanceof JSONArray){
				appendString(object.toString());
			} else {
				workingGroup.add((JSONObject)JSONValue.parse(object.toString()));	
			}
		}			
	}
}
 

import org.json.simple.JSONValue; //导入方法依赖的package包/类
public Object jsonQuery(String postfix) throws IOException {
    URL url = new URL(SITE_PREFIX + spigetId + postfix);
    URLConnection conn = url.openConnection();
    conn.setRequestProperty("User-Agent", USER_AGENT);
    if(((HttpURLConnection)conn).getResponseCode() == 404)
        return null;
    return JSONValue.parse(new InputStreamReader((InputStream)conn.getContent()));
}
 

import org.json.simple.JSONValue; //导入方法依赖的package包/类
public static void main(String args[]) throws ParserConfigurationException, IOException, TransformerException {
	Reader reader = new FileReader(args[0]);
	Object object = JSONValue.parse(reader);
	reader.close();
	DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
	DocumentBuilder docBuilder = dbf.newDocumentBuilder();
	Document doc = toXML(docBuilder, object);
	TransformerFactory transformerFactory = TransformerFactory.newInstance();
	Transformer transformer = transformerFactory.newTransformer();
	Source source = new DOMSource(doc);
	Result result = new StreamResult(new File(args[1]));
	transformer.transform(source, result);
}
 

import org.json.simple.JSONValue; //导入方法依赖的package包/类
/**
 * 例外発生時のステータスコードを取得.
 * @return ステータスコード
 */
public final String getCode() {
    String code = "";
    String msg = this.getMessage();
    JSONObject json = (JSONObject) JSONValue.parse(msg);
    code = (String) json.get("code");
    return code;
}
 

import org.json.simple.JSONValue; //导入方法依赖的package包/类
public static JSONObject readJsonFromUrl(String url) {
	try {
		InputStream is = new URL(url).openStream();
		BufferedReader rd = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
		String jsonText = readAll(rd);
		JSONObject json = (JSONObject) JSONValue.parse(jsonText);
		is.close();
		return json;
	} catch (Exception e) {
		e.printStackTrace();
	}
	
	return null;
}
 

import org.json.simple.JSONValue; //导入方法依赖的package包/类
@Override
public void process(ProcessingContext<Corpus> ctx, Corpus corpus) throws ModuleException {
	try {
		AlvisAEExportResolvedObjects resObj = getResolvedObjects();
		CadixeExportContext exportContext = new CadixeExportContext(ctx);
		if (schemaFile != null) {
			Reader r = new FileReader(schemaFile);
			exportContext.schema = JSONValue.parse(r);
			if (exportContext.schema == null)
				processingException("could not parse " + schemaFile + " as JSON");
			r.close();
		}
		for (Document doc : Iterators.loop(documentIterator(exportContext.evalCtx, corpus))) {
			JSONObject json = documentToJSON(doc, exportContext);
			OutputFile outFile = new OutputFile(outDir, resObj.fileName.evaluateString(exportContext.evalCtx, doc));
			TargetStream target = new FileTargetStream("UTF-8", outFile);
			Writer w = target.getWriter();
			json.writeJSONString(w);
			w.close();
		}
	}
	catch (UnsupportedEncodingException uee) {
		rethrow(uee);
	}
	catch (FileNotFoundException fnfe) {
		rethrow(fnfe);
	}
	catch (IOException ioe) {
		rethrow(ioe);
	}
}
 

import org.json.simple.JSONValue; //导入方法依赖的package包/类
public Map<String, Object> parse(String activityType, String activitySummary) throws JSONException
{
	JSONObject json = (JSONObject)JSONValue.parse(activitySummary);
	Map<String, Object> map = convertJSONObjectToMap(json);
	processActivitySummary(activityType, map);
	return map;
}
 

import org.json.simple.JSONValue; //导入方法依赖的package包/类
public void init() {
    try {
        String rawData = FileScanner.readFile(new File(getFile()));
        this.data = (JSONObject) JSONValue.parse(rawData);
    } catch (Exception ex) {
        LOG.error(ex.getMessage(), ex);
    }
}
 

import org.json.simple.JSONValue; //导入方法依赖的package包/类
public static JSONObject getRefData(JSONObject req) {
    try {
        String data = Tools.readFile(new File(DashBoardData.refHars(), req.get("name").toString() + ".har.ref"));
        return (JSONObject) JSONValue.parse(data);
    } catch (Exception ex) {
        LOG.log(Level.WARNING, "Error while reading har ref file", ex);
    }
    return null;
}
 

import org.json.simple.JSONValue; //导入方法依赖的package包/类
private Map<String, Object> parseActivitySummary(ActivityFeedEntity entity)
{
	String activityType = entity.getActivityType();
	String activitySummary = entity.getActivitySummary();
	JSONObject json = (JSONObject)JSONValue.parse(activitySummary);
	return Activity.getActivitySummary(json, activityType);
}