我正在开发一个包含主机和客户端的项目，其中主机可以向客户端发送命令(通过套接字)。

我确定使用 JSON 进行通信效果最好。

例如:

{
    "method" : "toasty",
    "params" : ["hello world", true]
}

在这个例子中，当这个 JSON 字符串被发送到客户端时，它会被处理并在客户端中运行一个合适的方法:

public abstract class ClientProcessor {

    public abstract void toasty(String s, boolean bool);
    public abstract void shutdown(int timer);

    private Method[] methods = getClass().getDeclaredMethods();

    public void process(String data) {
        try {
            JSONObject json = new JSONObject(data);
            String methodName = (String) json.get("method");

            if (methodName.equals("process"))
                return;

            for (int i = 0; i < methods.length; i++)
                if (methods[i].getName().equals(methodName)) {
                    JSONArray arr = json.getJSONArray("params");

                    int length = arr.length();
                    Object[] args = new Object[length];
                    for (int i2 = 0; i2 < length; i2++)
                        args[i2] = arr.get(i2);

                    methods[i].invoke(this, args);
                    return;
                }
        } catch (Exception e) {}
    }
}

并使用 ClientProcessor:

public class Client extends ClientProcessor {
    @Override
    public void toasty(String s, boolean bool) {
        //make toast here
    }

    @Override
    public void shutdown(int timer) {
        //shutdown system within timer
    }

    public void processJSON(String json) {
        process(json);
    }
}

JSON 由服务器发送给客户端，但可以修改服务器以发送不同的 JSON。

我的问题是:

• 这是一种通过处理 JSON 来运行方法的安全方式吗？
• 有更好的方法吗？我认为使用反射非常慢。

最佳答案

有 100 种和 1 种方法可以处理 JSON 消息，以便进行一些处理，但它们都归结为:

• 解析消息
• 将消息映射到方法
• 调用方法
• 发送回复

虽然您可以使用反射调用(在性能方面它在大多数情况下都很好)来调用方法，恕我直言，这有点过于开放 - 例如，恶意客户端可能会通过发出 wait 调用。

反射还使您不得不正确映射参数，这比您在问题中显示的代码更复杂。

所以不要使用反射。

你能做的是定义一个简单的接口(interface)，它的实现将理解如何处理参数并让你的处理器(通常称为 Controller )调用它，像这样:

public interface ServiceCall
{
  public JsonObject invoke(JsonArray params) throws ServiceCallException;
}

public class ServiceProcessor
{
  private static final Map<String, ServiceCall> SERVICE_CALLS = new HashMap<>();

  static
  {
    SERVICE_CALLS.put("toasty", new ToastCall());
  }

  public String process(String messageStr) 
  {
    try 
    {
      JsonObject message = Json.createReader(new StringReader(messageStr)).readObject();

      if (message.containsKey("method"))
      {
        String method = message.getString("method");

        ServiceCall serviceCall = SERVICE_CALLS.get(method);

        if (serviceCall != null)
        {
          return serviceCall.invoke(message.getJsonArray("params")).toString();
        }
        else
        {
          return fail("Unknown method: " + method);
        }
      }
      else
      {
        return fail("Invalid message: no method specified");
      }
    } 
    catch (Exception e) 
    {
      return fail(e.message);
    }
  }

  private String fail(String message)
  {
    return Json.createObjectBuilder()
      .add("status", "failed")
      .add("message", message)
      .build()
      .toString();
  }      

  private static class ToastCall implements ServiceCall
  {
    public JsonObject invoke(JsonArray params) throws ServiceCallException  
    {
      //make toast here
    }
  }
}

关于java - 使用反射调用方法会带来哪些安全问题？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31914145/