Java Code Examples for java.lang.reflect.Method#equals()

/** Returns whether the supplied cache loader has bulk load functionality. */
private static boolean canBulkLoad(AsyncCacheLoader<?, ?> loader) {
  try {
    Class<?> defaultLoaderClass = AsyncCacheLoader.class;
    if (loader instanceof CacheLoader<?, ?>) {
      defaultLoaderClass = CacheLoader.class;

      Method classLoadAll = loader.getClass().getMethod("loadAll", Iterable.class);
      Method defaultLoadAll = CacheLoader.class.getMethod("loadAll", Iterable.class);
      if (!classLoadAll.equals(defaultLoadAll)) {
        return true;
      }
    }

    Method classAsyncLoadAll = loader.getClass().getMethod(
        "asyncLoadAll", Iterable.class, Executor.class);
    Method defaultAsyncLoadAll = defaultLoaderClass.getMethod(
        "asyncLoadAll", Iterable.class, Executor.class);
    return !classAsyncLoadAll.equals(defaultAsyncLoadAll);
  } catch (NoSuchMethodException | SecurityException e) {
    logger.log(Level.WARNING, "Cannot determine if CacheLoader can bulk load", e);
    return false;
  }
}
 

public Boolean run() {
    Method[] methods = immutableClass.getMethods();
    for (int i = 0; i < methods.length; i++) {
        Method method = methods[i];
        String methodName = method.getName();
        if (methodName.startsWith("get") &&
                method.getParameterTypes().length == 0 &&
                method.getReturnType().isArray()) {
            try {
                Method submethod =
                    subclass.getMethod(methodName);
                if (!submethod.equals(method))
                    return false;
            } catch (NoSuchMethodException e) {
                return false;
            }
        }
    }
    return true;
}
 

public Boolean run() {
    Method[] methods = immutableClass.getMethods();
    for (int i = 0; i < methods.length; i++) {
        Method method = methods[i];
        String methodName = method.getName();
        if (methodName.startsWith("get") &&
                method.getParameterTypes().length == 0 &&
                method.getReturnType().isArray()) {
            try {
                Method submethod =
                    subclass.getMethod(methodName);
                if (!submethod.equals(method))
                    return false;
            } catch (NoSuchMethodException e) {
                return false;
            }
        }
    }
    return true;
}
 

public Boolean run() {
    Method[] methods = immutableClass.getMethods();
    for (int i = 0; i < methods.length; i++) {
        Method method = methods[i];
        String methodName = method.getName();
        if (methodName.startsWith("get") &&
                method.getParameterTypes().length == 0 &&
                method.getReturnType().isArray()) {
            try {
                Method submethod =
                    subclass.getMethod(methodName);
                if (!submethod.equals(method))
                    return false;
            } catch (NoSuchMethodException e) {
                return false;
            }
        }
    }
    return true;
}
 

public Boolean run() {
    Method[] methods = immutableClass.getMethods();
    for (int i = 0; i < methods.length; i++) {
        Method method = methods[i];
        String methodName = method.getName();
        if (methodName.startsWith("get") &&
                method.getParameterTypes().length == 0 &&
                method.getReturnType().isArray()) {
            try {
                Method submethod =
                    subclass.getMethod(methodName);
                if (!submethod.equals(method))
                    return false;
            } catch (NoSuchMethodException e) {
                return false;
            }
        }
    }
    return true;
}
 

@Override
public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
    if (method.equals(Disposable.class.getDeclaredMethods()[0])) {
        if (delegateUsed && instance != null) {
            proxied.dispose(instance);
            instance = null;
            delegateUsed = false;
        }
        return null;
    }

    final EntityManager oldInstance = instance;
    instance = EntityManagerHolder.INSTANCE.getEntityManager();

    if (instance == null && oldInstance == null) {
        instance = proxied.produce(ctx);
        delegateUsed = true;
    } else if (instance == null) {
        instance = oldInstance;
    }

    return method.invoke(instance, args);
}
 

/**
 * Package private helper method for Descriptor .equals methods.
 *
 * @param a first method to compare
 * @param b second method to compare
 * @return boolean to indicate that the methods are equivalent
 */
boolean compareMethods(Method a, Method b) {
    // Note: perhaps this should be a protected method in FeatureDescriptor
    if ((a == null) != (b == null)) {
        return false;
    }

    if (a != null && b != null) {
        if (!a.equals(b)) {
            return false;
        }
    }
    return true;
}
 

/**
 * Package private helper method for Descriptor .equals methods.
 *
 * @param a first method to compare
 * @param b second method to compare
 * @return boolean to indicate that the methods are equivalent
 */
boolean compareMethods(Method a, Method b) {
    // Note: perhaps this should be a protected method in FeatureDescriptor
    if ((a == null) != (b == null)) {
        return false;
    }

    if (a != null && b != null) {
        if (!a.equals(b)) {
            return false;
        }
    }
    return true;
}
 

private void addExceptionMapping(Class<? extends Throwable> exceptionType, Method method) {
	Method oldMethod = this.mappedMethods.put(exceptionType, method);
	if (oldMethod != null && !oldMethod.equals(method)) {
		throw new IllegalStateException("Ambiguous @ExceptionHandler method mapped for [" +
				exceptionType + "]: {" + oldMethod + ", " + method + "}");
	}
}
 

private void assertActionNotDuplicated(Map<ActionKey, ActionMethod> map, ActionKey actionKey, Method method) {
    if (map.get(actionKey) != null) {
        Method existingMethod = map.get(actionKey).getMethod();

        if (method.equals(existingMethod)) {
            return;
        }

        throw new RuntimeException("Trying to add two actions with the same name '" + actionKey + "' to "
                + endpointClazz.getName() + ": one at " + existingMethod.getDeclaringClass().getName() + " and the other at "
                + method.getDeclaringClass().getName());
    }
}
 

private static boolean overridesMethod(Class<? extends Trigger> triggerClass, Method method) {
    try {
        return !method.equals(triggerClass.getMethod(method.getName(),
                                                     method.getParameterTypes()));
    } catch (NoSuchMethodException e) {
        return false;
    }
}
 

void addIfNotPresent(Method newMethod) {
    for (int i = 0; i < length; i++) {
        Method m = methods[i];
        if (m == newMethod || (m != null && m.equals(newMethod))) {
            return;
        }
    }
    add(newMethod);
}
 

void addIfNotPresent(Method newMethod) {
    for (int i = 0; i < length; i++) {
        Method m = methods[i];
        if (m == newMethod || (m != null && m.equals(newMethod))) {
            return;
        }
    }
    add(newMethod);
}
 

private static void verifyOneInvocation(Method method, Object[] args,
                                        List invocationQueue)
{
    TestProvider.Invocation inv =
        (TestProvider.Invocation) invocationQueue.remove(0);

    if (!method.equals(inv.method)) {
        throw new RuntimeException(
            "unexpected provider method invoked: expected " + method +
            ", detected " + inv.method);
    }

    List expectedArgs = Arrays.asList(args);
    List detectedArgs = Arrays.asList(inv.args);
    if (!expectedArgs.equals(detectedArgs)) {
        throw new RuntimeException("TEST FAILED: " +
            "unexpected provider method invocation arguments: " +
            "expected " + expectedArgs + ", detected " + detectedArgs);
    }

    if (!invocationQueue.isEmpty()) {
        inv = (TestProvider.Invocation)
            invocationQueue.remove(0);
        throw new RuntimeException("TEST FAILED: " +
            "unexpected provider invocation: " + inv.method + " " +
            Arrays.asList(inv.args));
    }
}
 

public String methodToProperty(Method m) {
    PropertyDescriptor[] pds = PropertyUtils.getPropertyDescriptors(m.getDeclaringClass());
    for (PropertyDescriptor pd : pds) {
        if (m.equals(pd.getReadMethod()) || m.equals(pd.getWriteMethod())) {
            return pd.getName();
        }
    }
    return null;
}
 

private boolean declaredMethodsContains() {
      for(Method m : clazz.getClazz().getDeclaredMethods()) {
    if(m.equals(method.method)) {
        return true;
    }
}
      return false;
  }
 

boolean match(Method method, Class<?> targetClass) {
	// origin
	if (doMatch(method, targetClass)) {
		return true;
	}
	// cglib
	Class<?> userClass = ClassUtils.getUserClass(targetClass);
	Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass);
	specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
	if (!specificMethod.equals(method)) {
		if (doMatch(specificMethod, userClass)) {
			return true;
		}
	}
	// jdk proxy
	if (Proxy.isProxyClass(targetClass)) {
		Class<?>[] interfaces = targetClass.getInterfaces();
		for (Class<?> interfaceClass : interfaces) {
			Method interfaceMethod = ClassUtils.getMethodIfAvailable(interfaceClass, method.getName(),
			      method.getParameterTypes());
			if (interfaceMethod != null && doMatch(interfaceMethod, interfaceClass)) {
				return true;
			}
		}
	}
	return false;
}
 

private static boolean compare(Method m1, Method m2) {
    if ((m1 == null) && (m2 == null)) {
        return true;
    }
    if ((m1 == null) || (m2 == null)) {
        return false;
    }
    return m1.equals(m2);
}
 

public GenericTypeAwarePropertyDescriptor(Class<?> beanClass, String propertyName,
		@Nullable Method readMethod, @Nullable Method writeMethod, Class<?> propertyEditorClass)
		throws IntrospectionException {

	super(propertyName, null, null);
	this.beanClass = beanClass;

	Method readMethodToUse = (readMethod != null ? BridgeMethodResolver.findBridgedMethod(readMethod) : null);
	Method writeMethodToUse = (writeMethod != null ? BridgeMethodResolver.findBridgedMethod(writeMethod) : null);
	if (writeMethodToUse == null && readMethodToUse != null) {
		// Fallback: Original JavaBeans introspection might not have found matching setter
		// method due to lack of bridge method resolution, in case of the getter using a
		// covariant return type whereas the setter is defined for the concrete property type.
		Method candidate = ClassUtils.getMethodIfAvailable(
				this.beanClass, "set" + StringUtils.capitalize(getName()), (Class<?>[]) null);
		if (candidate != null && candidate.getParameterCount() == 1) {
			writeMethodToUse = candidate;
		}
	}
	this.readMethod = readMethodToUse;
	this.writeMethod = writeMethodToUse;

	if (this.writeMethod != null) {
		if (this.readMethod == null) {
			// Write method not matched against read method: potentially ambiguous through
			// several overloaded variants, in which case an arbitrary winner has been chosen
			// by the JDK's JavaBeans Introspector...
			Set<Method> ambiguousCandidates = new HashSet<>();
			for (Method method : beanClass.getMethods()) {
				if (method.getName().equals(writeMethodToUse.getName()) &&
						!method.equals(writeMethodToUse) && !method.isBridge() &&
						method.getParameterCount() == writeMethodToUse.getParameterCount()) {
					ambiguousCandidates.add(method);
				}
			}
			if (!ambiguousCandidates.isEmpty()) {
				this.ambiguousWriteMethods = ambiguousCandidates;
			}
		}
		this.writeMethodParameter = new MethodParameter(this.writeMethod, 0);
		GenericTypeResolver.resolveParameterType(this.writeMethodParameter, this.beanClass);
	}

	if (this.readMethod != null) {
		this.propertyType = GenericTypeResolver.resolveReturnType(this.readMethod, this.beanClass);
	}
	else if (this.writeMethodParameter != null) {
		this.propertyType = this.writeMethodParameter.getParameterType();
	}

	this.propertyEditorClass = propertyEditorClass;
}
 

/**
 * Returns {@code true} if the supplied '{@code candidateMethod}' can be
 * consider a validate candidate for the {@link Method} that is {@link Method#isBridge() bridged}
 * by the supplied {@link Method bridge Method}. This method performs inexpensive
 * checks and can be used quickly filter for a set of possible matches.
 */
private static boolean isBridgedCandidateFor(Method candidateMethod, Method bridgeMethod) {
	return (!candidateMethod.isBridge() && !candidateMethod.equals(bridgeMethod) &&
			candidateMethod.getName().equals(bridgeMethod.getName()) &&
			candidateMethod.getParameterTypes().length == bridgeMethod.getParameterTypes().length);
}