Question

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

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

我该怎么做？

Answer 1

创建一个eclipse RCP应用程序并扩展eclipse编辑器。

使用eclipse非常简单，创建一个编辑器并为其添加内容辅助。

看看这个FAQ。

Answer 2

我不知道我是否完全理解你的问题。我猜你是在摇摆这样做的。你正在寻找一种类似谷歌悬停的东西（抱歉，这是令人难以置信的，我只是不记得它叫什么），就像谷歌在你输入搜索时一样？

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

  /**
  * 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;
    }
  }

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

2 个答案: