示例#1
0
 static Method[] getOverridableMethods(Class c) {
   ArrayList<Method> list = new ArrayList<Method>();
   HashSet<String> skip = new HashSet<String>();
   while (c != null) {
     Method[] methods = c.getDeclaredMethods();
     for (int i = 0; i < methods.length; i++) {
       String methodKey =
           methods[i].getName() + getMethodSignature(methods[i], methods[i].getParameterTypes());
       if (skip.contains(methodKey)) continue; // skip this method
       int mods = methods[i].getModifiers();
       if (Modifier.isStatic(mods)) continue;
       if (Modifier.isFinal(mods)) {
         // Make sure we don't add a final method to the list
         // of overridable methods.
         skip.add(methodKey);
         continue;
       }
       if (Modifier.isPublic(mods) || Modifier.isProtected(mods)) {
         list.add(methods[i]);
         skip.add(methodKey);
       }
     }
     c = c.getSuperclass();
   }
   return list.toArray(new Method[list.size()]);
 }
示例#2
0
 static Method[] getOverridableMethods(Class c) {
   ArrayList list = new ArrayList();
   while (c != null) {
     Method[] methods = c.getDeclaredMethods();
     for (int i = 0; i < methods.length; i++) {
       int mods = methods[i].getModifiers();
       if (Modifier.isStatic(mods) || Modifier.isFinal(mods)) continue;
       if (Modifier.isPublic(mods) || Modifier.isProtected(mods)) list.add(methods[i]);
     }
     c = c.getSuperclass();
   }
   return (Method[]) list.toArray(new Method[list.size()]);
 }
示例#3
0
 private static void appendOverridableMethods(
     Class<?> c, ArrayList<Method> list, HashSet<String> skip) {
   Method[] methods = c.getDeclaredMethods();
   for (int i = 0; i < methods.length; i++) {
     String methodKey =
         methods[i].getName() + getMethodSignature(methods[i], methods[i].getParameterTypes());
     if (skip.contains(methodKey)) continue; // skip this method
     int mods = methods[i].getModifiers();
     if (Modifier.isStatic(mods)) continue;
     if (Modifier.isFinal(mods)) {
       // Make sure we don't add a final method to the list
       // of overridable methods.
       skip.add(methodKey);
       continue;
     }
     if (Modifier.isPublic(mods) || Modifier.isProtected(mods)) {
       list.add(methods[i]);
       skip.add(methodKey);
     }
   }
 }
  /** Calculates a MD5 digest of the class. */
  public String getDigest() {
    try {
      if (_className == null || "".equals(_className)) return "";

      DynamicClassLoader loader =
          (DynamicClassLoader) Thread.currentThread().getContextClassLoader();

      ClassLoader tmpLoader = loader.getNewTempClassLoader();

      Class cl = Class.forName(_className, false, tmpLoader);

      if (cl == null) return "";

      MessageDigest digest = MessageDigest.getInstance("MD5");

      addDigest(digest, cl.getName());

      addDigest(digest, cl.getModifiers());

      Class superClass = cl.getSuperclass();
      if (superClass != null) addDigest(digest, superClass.getName());

      Class[] interfaces = cl.getInterfaces();
      for (int i = 0; i < interfaces.length; i++) addDigest(digest, interfaces[i].getName());

      Field[] fields = cl.getDeclaredFields();

      Arrays.sort(fields, new FieldComparator());

      if (_checkFields) {
        for (Field field : fields) {
          if (Modifier.isPrivate(field.getModifiers()) && !_checkPrivate) continue;
          if (Modifier.isProtected(field.getModifiers()) && !_checkProtected) continue;

          addDigest(digest, field.getName());
          addDigest(digest, field.getModifiers());
          addDigest(digest, field.getType().getName());

          addDigest(digest, field.getAnnotations());
        }
      }

      Method[] methods = cl.getDeclaredMethods();
      Arrays.sort(methods, new MethodComparator());

      for (int i = 0; i < methods.length; i++) {
        Method method = methods[i];

        if (Modifier.isPrivate(method.getModifiers()) && !_checkPrivate) continue;
        if (Modifier.isProtected(method.getModifiers()) && !_checkProtected) continue;
        if (Modifier.isStatic(method.getModifiers()) && !_checkStatic) continue;

        addDigest(digest, method.getName());
        addDigest(digest, method.getModifiers());
        addDigest(digest, method.getName());

        Class[] param = method.getParameterTypes();
        for (int j = 0; j < param.length; j++) addDigest(digest, param[j].getName());

        addDigest(digest, method.getReturnType().getName());

        Class[] exn = method.getExceptionTypes();
        for (int j = 0; j < exn.length; j++) addDigest(digest, exn[j].getName());

        addDigest(digest, method.getAnnotations());
      }

      byte[] digestBytes = new byte[256];

      int len = digest.digest(digestBytes, 0, digestBytes.length);

      return digestToBase64(digestBytes, len);
    } catch (Exception e) {
      log.log(Level.FINER, e.toString(), e);

      return "";
    }
  }
示例#5
0
  private static void discoverAccessibleMethods(
      Class<?> clazz,
      Map<MethodSignature, Method> map,
      boolean includeProtected,
      boolean includePrivate) {
    if (Modifier.isPublic(clazz.getModifiers()) || includePrivate) {
      try {
        if (includeProtected || includePrivate) {
          while (clazz != null) {
            try {
              Method[] methods = clazz.getDeclaredMethods();
              for (int i = 0; i < methods.length; i++) {
                Method method = methods[i];
                int mods = method.getModifiers();

                if (Modifier.isPublic(mods) || Modifier.isProtected(mods) || includePrivate) {
                  if (includePrivate) method.setAccessible(true);
                  map.put(new MethodSignature(method), method);
                }
              }
              clazz = clazz.getSuperclass();
            } catch (SecurityException e) {
              // Some security settings (i.e., applets) disallow
              // access to Class.getDeclaredMethods. Fall back to
              // Class.getMethods.
              Method[] methods = clazz.getMethods();
              for (int i = 0; i < methods.length; i++) {
                Method method = methods[i];
                MethodSignature sig = new MethodSignature(method);
                if (map.get(sig) == null) map.put(sig, method);
              }
              break; // getMethods gets superclass methods, no
              // need to loop any more
            }
          }
        } else {
          Method[] methods = clazz.getMethods();
          for (int i = 0; i < methods.length; i++) {
            Method method = methods[i];
            MethodSignature sig = new MethodSignature(method);
            map.put(sig, method);
          }
        }
        return;
      } catch (SecurityException e) {
        Context.reportWarning(
            "Could not discover accessible methods of class "
                + clazz.getName()
                + " due to lack of privileges, "
                + "attemping superclasses/interfaces.");
        // Fall through and attempt to discover superclass/interface
        // methods
      }
    }

    Class<?>[] interfaces = clazz.getInterfaces();
    for (int i = 0; i < interfaces.length; i++) {
      discoverAccessibleMethods(interfaces[i], map, includeProtected, includePrivate);
    }
    Class<?> superclass = clazz.getSuperclass();
    if (superclass != null) {
      discoverAccessibleMethods(superclass, map, includeProtected, includePrivate);
    }
  }