Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2011 ritwik.net
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.openyelp.server;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
 public final class JsonCacheRpcExecutor implements RpcIntroSpection {
 
 	private static final Pattern METHOD_PATTERN = Pattern
 			.compile("([_a-zA-Z][_a-zA-Z0-9]*)\\.([_a-zA-Z][_a-zA-Z0-9]*)");
 
 	private final Map<StringHandleEntry<?>> handlers;
 
 	private final TypeChecker typeChecker;
 	private volatile boolean locked;
 
 	public JsonCacheRpcExecutor() {
 		this(new AllowAllTypeChecker());
 	}
 
 	public static long cachsize = 0;
 
 	@SuppressWarnings("unchecked")
 	public JsonCacheRpcExecutor(TypeChecker typeChecker) {
 		this. = typeChecker;
 		this. = new HashMap<StringHandleEntry<?>>();
 		addHandler("system"thisRpcIntroSpection.class);
 	}
   private boolean showlog=true;
 	public boolean isShowlog() {
 	return ;
 }
 
 public void setShowlog(boolean showlog) {
 	this. = showlog;
 }
 
 	public boolean isLocked() {
 		return ;
 	}
 
 	public <T> void addHandler(String name, T handlerClass<T>... classes) {
 		if () {
 			throw new JsonRpcException(
 					"executor has been locked, can't add more handlers");
 		}
 
 		synchronized () {
 			HandleEntry<T> handleEntry = new HandleEntry<T>(,
 					handlerclasses);
 			if (this..containsKey(name)) {
 				throw new IllegalArgumentException("handler already exists");
 			}
 			this..put(namehandleEntry);
 		}
 	}
 
 	public void execute(JsonRpcServerTransport transport) {
 		if (!) {
			synchronized () {
				 = true;
			}
		}
		String methodName = null;
		JsonArray params = null;
		JsonObject resp = new JsonObject();
		resp.addProperty("jsonrpc""2.0");
		String errorMessage = null;
		Integer errorCode = null;
		String errorData = null;
		JsonObject req = null;
		String requestData;
		String keys=null;
		try {
			requestData = transport.readRequest();
			if(requestData!=null){
				keys=Utils.getMD5Str(requestData);
			}
			JsonParser parser = new JsonParser();
			req = (JsonObjectparser.parse(new StringReader(requestData));
catch (Throwable t) {
			errorMessage = "unable to parse json-rpc request";
			errorData = getStackTrace(t);
			sendError(transportresperrorCodeerrorMessageerrorData);
			return;
		}
		try {
			assert req != null;
			resp.add("id"req.get("id"));
			methodName = req.getAsJsonPrimitive("method").getAsString();
			params = (JsonArrayreq.get("params");
			if (params == null) {
				params = new JsonArray();
			}
catch (Throwable t) {
			errorMessage = "unable to read request";
			errorData = getStackTrace(t);
			sendError(transportresperrorCodeerrorMessageerrorData);
			return;
		}
		try {
			if (keys != null&&keys.length()>30) {
				if ( != null) {
					JsonElement result = .get(keys);
					if (result == null) {
						result = executeMethod(methodNameparams);
						.put(keysresult);
else {
							..println("来之缓存,key:"+keys);
						}
					}
					resp.add("result"result);
else {
					JsonElement result = executeMethod(methodNameparams);
					resp.add("result"result);
				}
else {
				JsonElement result = executeMethod(methodNameparams);
				resp.add("result"result);
			}
catch (Throwable t) {
			if (t instanceof JsonRpcRemoteException) {
				sendError(transportresp, (JsonRpcRemoteExceptiont);
				return;
			}
			errorCode = JsonRpcErrorCodes.getServerError(1);
			errorMessage = t.getMessage();
			errorData = getStackTrace(t);
			sendError(transportresperrorCodeerrorMessageerrorData);
			return;
		}
		try {
			String responseData = resp.toString();
			transport.writeResponse(responseData);
catch (Exception e) {
		}
	}
	private void sendError(JsonRpcServerTransport transportJsonObject resp,
		sendError(transportrespe.getCode(), e.getMessage(), e.getData());
	}
	private void sendError(JsonRpcServerTransport transportJsonObject resp,
			Integer codeString messageString data) {
		JsonObject error = new JsonObject();
		if (code != null) {
			error.addProperty("code"code);
		}
		if (message != null) {
			error.addProperty("message"message);
		}
		if (data != null) {
			error.addProperty("data"data);
		}
		resp.add("error"error);
		resp.remove("result");
		String responseData = resp.toString();
		try {
			transport.writeResponse(responseData);
catch (Exception e) {
		}
	}
		StringWriter str = new StringWriter();
		PrintWriter w = new PrintWriter(str);
		w.close();
		return str.toString();
	}
	private JsonElement executeMethod(String methodNameJsonArray params)
			throws Throwable {
		try {
			Matcher mat = .matcher(methodName);
			if (!mat.find()) {
						"invalid method name"null);
			}
			String handleName = mat.group(1);
			methodName = mat.group(2);
			HandleEntry<?> handleEntry = .get(handleName);
			if (handleEntry == null) {
						"no such method exists"null);
			}
			Method executableMethod = null;
			for (Method m : handleEntry.getMethods()) {
				if (!m.getName().equals(methodName)) {
					continue;
				}
				if (canExecute(mparams)) {
					executableMethod = m;
					break;
				}
			}
			if (executableMethod == null) {
						"no such method exists"null);
			}
			Object result = executableMethod.invoke(handleEntry.getHandler(),
					getParameters(executableMethodparams));
			return new Gson().toJsonTree(result);
catch (Throwable t) {
			if (t instanceof InvocationTargetException) {
			}
			if (t instanceof JsonRpcRemoteException) {
			}
					JsonRpcErrorCodes.getServerError(0), t.getMessage(),
		}
	}
	public boolean canExecute(Method methodJsonArray params) {
		if (method.getParameterTypes().length != params.size()) {
			return false;
		}
		return true;
	}
	public Object[] getParameters(Method methodJsonArray params) {
		List<Objectlist = new ArrayList<Object>();
		Gson gson = new Gson();
		Class<?>[] types = method.getParameterTypes();
		for (int i = 0; i < types.lengthi++) {
			JsonElement p = params.get(i);
			Object o = gson.fromJson(p.toString(), types[i]);
			list.add(o);
		}
		return list.toArray();
	}
	public String[] listMethods() {
		Set<Stringmethods = new TreeSet<String>();
		for (String name : this..keySet()) {
			HandleEntry<?> handleEntry = this..get(name);
			for (String method : handleEntry.getSignatures().keySet()) {
				methods.add(name + "." + method);
			}
		}
		String[] arr = new String[methods.size()];
		return methods.toArray(arr);
	}
	public String[] methodSignature(String method) {
		if (method == null) {
			throw new NullPointerException("method");
		}
		Matcher mat = .matcher(method);
		if (!mat.find()) {
			throw new IllegalArgumentException("invalid method name");
		}
		String handleName = mat.group(1);
		String methodName = mat.group(2);
		Set<Stringsignatures = new TreeSet<String>();
		HandleEntry<?> handleEntry = .get(handleName);
		if (handleEntry == null) {
			throw new IllegalArgumentException("no such method exists");
		}
		for (Method m : handleEntry.getMethods()) {
			if (!m.getName().equals(methodName)) {
				continue;
			}
			String[] sign = handleEntry.getSignatures().get(m.getName());
			StringBuffer buff = new StringBuffer(sign[0]);
			for (int i = 1; i < sign.lengthi++) {
				buff.append(",").append(sign[i]);
			}
			signatures.add(buff.toString());
		}
		if (signatures.size() == 0) {
			throw new IllegalArgumentException("no such method exists");
		}
		String[] arr = new String[signatures.size()];
		return signatures.toArray(arr);
	}
	public RpcCache getRpcCache() {
		return ;
	}
	public void setRpcCache(RpcCache rpcCache) {
		this. = rpcCache;
	}
	private RpcCache rpcCache = null;
New to GrepCode? Check out our FAQ X