java - 如何在 Java 应用程序中创建上下文相关帮助

Question

我有一个需要上下文相关帮助的 Java 桌面应用程序。例如，我的 Validator 应用程序以 SQL 语句的形式获取输入，并根据键入的内容显示可能的上下文相关帮助。

一个用例可能是：当用户键入“更新”然后按 Ctrl+Space 时，它​​应该将表名列表显示为上下文相关帮助

我该怎么做？

Answer 1

Create an eclipse RCP application and extend the eclipse editor.

With eclipse is very simple create an editor and add a content assist to it.

Look at this FAQ.

Answer 2

我不知道我是否完全理解你的问题。我猜你是在摇摆中做这个。您是否正在寻找一种类似 awt hover-like 的东西（抱歉，这太棒了，我只是不太记得它叫什么了），就像您在输入搜索时 Google 所拥有的一样？

我不确定是否可以帮助您，但这是我用来根据对象的任何属性值使用反射将对象与搜索词匹配的方法。这可能是你根本不需要的东西，但我想以防万一我可以把它给你。希望能帮助到你！

  /**
  * Returns true if any attribute in the item matches the given constraints
  *
  * @param object the object you want to match
  * @param klass the class to get the fields from (in most cases you'll just call object.getClass())
  * @param iterations how many inherited levels you want to check fields for
  * @param match the String to match fields against
  * @param ignoreField fieldNames you wish to ignore, you can give as many as you like, you can also give an
  * array of strings
  * @return whether the given object contained fields which matched the given string
  */
  public static boolean matches(Object object, Class klass, int iterations, String match, String... ignoreField) {
    if (iterations < 0) {
      return false;
    }
    boolean checkMatch = false;
    try {
      checkMatch = matchFields(klass.getDeclaredFields(), object, match, ignoreField);
    } catch (IllegalArgumentException ex) {
      Logger.getLogger(OtherHelper.class.getName()).log(Level.SEVERE, null, ex);
    } catch (IllegalAccessException ex) {
      Logger.getLogger(OtherHelper.class.getName()).log(Level.SEVERE, null, ex);
    }
    if (checkMatch) {
      return true;
    } else {
      Class<? extends Object> supersSuperclass = (Class<? extends Object>) klass.getSuperclass();
      if (supersSuperclass != Object.class) {
        boolean matches = matches(object, supersSuperclass, (iterations - 1), match, ignoreField);
        if (matches) {
          return true;
        } else {
          return false;
        }
      } else {
        return false;
      }
    }
  }

  /**
  * Calls matchField(field, bo, match) on each field in the given field array.
  *
  * @param fields the fields array to get the fields from
  * @param object the object to get the field values from
  * @param match the text to match fields to
  * @param ignoreField any number of fieldNames which are to be ignored.
  * @return true on first true field match
  * @throws IllegalArgumentException
  * @throws IllegalArgumentException
  * @throws IllegalAccessException
  */
  private static boolean matchFields(Field[] fields, Object object, String match, String... ignoreField) throws IllegalArgumentException, IllegalArgumentException, IllegalAccessException {
    List<String> ignoreFieldsList = Arrays.asList(ignoreField);
    for (Field field : fields) {
      if (!ignoreFieldsList.contains(field.getName())) {
        if (matchField(field, object, match)) {
          return true;
        }
      }
    }
    return false;
  }

  /**
  * Gets the value of the field and matches the string version of it with the given match
  *
  * @param field the field to match
  * @param object the object to get the field value from
  * @param match the match to match the field value to.
  * @return
  * @throws IllegalArgumentException
  * @throws IllegalArgumentException
  * @throws IllegalAccessException
  */
  private static boolean matchField(Field field, Object object, String match) throws IllegalArgumentException, IllegalArgumentException, IllegalAccessException {
    field.setAccessible(true);
    if (field.get(object) == null) {
      return false;
    }
    Class<?> type = field.getType();
    String value = null;
    if (type == Date.class) {
      SimpleDateFormat sdf = new SimpleDateFormat("MMM d, yyyy");
      Date date = (Date) field.get(object);
      value = sdf.format(date);
    } else if (type == String.class || isPrimitive(type)) {
      value = field.get(object).toString();
    }
    if (value != null
            && Pattern.compile(Pattern.quote(match), Pattern.CASE_INSENSITIVE).matcher(value).find()) {
      return true;
    } else {
      return false;
    }
  }

  /**
  * Checks first whether it is primitive and then whether it's wrapper is a primitive wrapper. Returns true
  * if either is true
  *
  * @param c
  * @return whether it's a primitive type itself or it's a wrapper for a primitive type
  */
  public static boolean isPrimitive(Class c) {
    if (c.isPrimitive()) {
      return true;
    } else if (c == Byte.class
            || c == Short.class
            || c == Integer.class
            || c == Long.class
            || c == Float.class
            || c == Double.class
            || c == Boolean.class
            || c == Character.class) {
      return true;
    } else {
      return false;
    }
  }