java.lang.reflect.Modifier Java Examples
The following examples show how to use
java.lang.reflect.Modifier.
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
Source File: ReflectUtil.java From openjdk-jdk8u with GNU General Public License v2.0 | 6 votes |
/** * Does a conservative approximation of member access check. Use this if * you don't have an actual 'userland' caller Class/ClassLoader available. * This might be more restrictive than a precise member access check where * you have a caller, but should never allow a member access that is * forbidden. * * @param m the {@code Member} about to be accessed */ public static void conservativeCheckMemberAccess(Member m) throws SecurityException{ final SecurityManager sm = System.getSecurityManager(); if (sm == null) return; // Check for package access on the declaring class. // // In addition, unless the member and the declaring class are both // public check for access declared member permissions. // // This is done regardless of ClassLoader relations between the {@code // Member m} and any potential caller. final Class<?> declaringClass = m.getDeclaringClass(); checkPackageAccess(declaringClass); if (Modifier.isPublic(m.getModifiers()) && Modifier.isPublic(declaringClass.getModifiers())) return; // Check for declared member access. sm.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION); }
Example #2
Source File: JMX.java From JDKSourceCode1.8 with MIT License | 6 votes |
/** * <p>Test whether an interface is an MXBean interface. * An interface is an MXBean interface if it is public, * annotated {@link MXBean @MXBean} or {@code @MXBean(true)} * or if it does not have an {@code @MXBean} annotation * and its name ends with "{@code MXBean}".</p> * * @param interfaceClass The candidate interface. * * @return true if {@code interfaceClass} is a * {@link javax.management.MXBean compliant MXBean interface} * * @throws NullPointerException if {@code interfaceClass} is null. */ public static boolean isMXBeanInterface(Class<?> interfaceClass) { if (!interfaceClass.isInterface()) return false; if (!Modifier.isPublic(interfaceClass.getModifiers()) && !Introspector.ALLOW_NONPUBLIC_MBEAN) { return false; } MXBean a = interfaceClass.getAnnotation(MXBean.class); if (a != null) return a.value(); return interfaceClass.getName().endsWith("MXBean"); // We don't bother excluding the case where the name is // exactly the string "MXBean" since that would mean there // was no package name, which is pretty unlikely in practice. }
Example #3
Source File: BeanUtil.java From anyline with Apache License 2.0 | 6 votes |
public static boolean setFieldValue(Object obj, Field field, Object value){ if(null == obj || null == field){ return false; } if(Modifier.isStatic(field.getModifiers())){ return false; } try{ if(field.isAccessible()){ //可访问属性 field.set(obj, value); }else{ //不可访问属性 field.setAccessible(true); field.set(obj, value); field.setAccessible(false); } }catch(Exception e){ e.printStackTrace(); return false; } return true; }
Example #4
Source File: Selector.java From javageci with Apache License 2.0 | 6 votes |
/** * - * <p> * ### Class and method checking selectors * * <p> These conditions work on classes and on methods. Applying * them on a field will throw exception. */ private void methodAndClassOnlySelectors() { /** * - * * * `abstract` is `true` if the type of method is abstract. * */ selector("abstract", m -> only(m, Class.class, Method.class) && Modifier.isAbstract(getModifiers(m))); /** * - * * * `implements` is `true` if the class implements at least one * interface. When applied to a method it is `true` if the * method implements a method of the same name and argument * types in one of the interfaces the class directly or * indirectly implements. In other words it means that there is * an interface that declares this method and this method is an * implementation (not abstract). * */ selector("implements", m -> only(m, Class.class, Method.class) && methodOrClassImplements(m)); }
Example #5
Source File: JMX.java From jdk8u60 with GNU General Public License v2.0 | 6 votes |
/** * <p>Test whether an interface is an MXBean interface. * An interface is an MXBean interface if it is public, * annotated {@link MXBean @MXBean} or {@code @MXBean(true)} * or if it does not have an {@code @MXBean} annotation * and its name ends with "{@code MXBean}".</p> * * @param interfaceClass The candidate interface. * * @return true if {@code interfaceClass} is a * {@link javax.management.MXBean compliant MXBean interface} * * @throws NullPointerException if {@code interfaceClass} is null. */ public static boolean isMXBeanInterface(Class<?> interfaceClass) { if (!interfaceClass.isInterface()) return false; if (!Modifier.isPublic(interfaceClass.getModifiers()) && !Introspector.ALLOW_NONPUBLIC_MBEAN) { return false; } MXBean a = interfaceClass.getAnnotation(MXBean.class); if (a != null) return a.value(); return interfaceClass.getName().endsWith("MXBean"); // We don't bother excluding the case where the name is // exactly the string "MXBean" since that would mean there // was no package name, which is pretty unlikely in practice. }
Example #6
Source File: GeciReflectionTools.java From javageci with Apache License 2.0 | 6 votes |
/** * Convert an int containing modifiers bits to string containing the Java names of the modifiers space separated. * * @param modifiers to be converted to string * @return the space separated modifiers or empty string in case there is no modifier bit set in {@code modifiers} */ public static String unmask(int modifiers) { final StringBuilder s = new StringBuilder(); final BiConsumer<Predicate<Integer>, String> check = (Predicate<Integer> predicate, String text) -> { if (predicate.test(modifiers)) { s.append(text); } }; check.accept(Modifier::isPrivate, "private "); check.accept(Modifier::isProtected, "protected "); check.accept(Modifier::isPublic, "public "); check.accept(Modifier::isFinal, "final "); check.accept(Modifier::isStatic, "static "); check.accept(Modifier::isSynchronized, "synchronized "); check.accept(Modifier::isVolatile, "volatile "); check.accept(Modifier::isStrict, "strictfp "); check.accept(Modifier::isAbstract, "abstract "); check.accept(Modifier::isTransient, "transient "); return s.toString().trim(); }
Example #7
Source File: ExcelUtils.java From poi-excel-utils with Apache License 2.0 | 6 votes |
private static void readConfigParamVerify(ExcelReadSheetProcessor<?> sheetProcessor, Map<Integer, Map<String, ExcelReadFieldMappingAttribute>> fieldMapping) { Class<?> clazz = sheetProcessor.getTargetClass(); for (Entry<Integer, Map<String, ExcelReadFieldMappingAttribute>> indexFieldMapping : fieldMapping.entrySet()) { for (Map.Entry<String, ExcelReadFieldMappingAttribute> filedMapping : indexFieldMapping.getValue().entrySet()) { String fieldName = filedMapping.getKey(); if (fieldName != null) { PropertyDescriptor pd = getPropertyDescriptor(clazz, fieldName); if (pd == null || pd.getWriteMethod() == null) { throw new IllegalArgumentException("In fieldMapping config {colIndex:" + indexFieldMapping.getKey() + "[" + convertColIntIndexToCharIndex(indexFieldMapping.getKey()) + "]<->fieldName:" + filedMapping.getKey() + "}, " + " class " + clazz.getName() + " can't find field '" + filedMapping.getKey() + "' and can not also find " + filedMapping.getKey() + "'s writter method."); } if (!Modifier.isPublic(pd.getWriteMethod().getDeclaringClass().getModifiers())) { pd.getWriteMethod().setAccessible(true); } } } } }
Example #8
Source File: InvokerBytecodeGenerator.java From openjdk-jdk8u-backup with GNU General Public License v2.0 | 6 votes |
static boolean isStaticallyNameable(Class<?> cls) { if (cls == Object.class) return true; while (cls.isArray()) cls = cls.getComponentType(); if (cls.isPrimitive()) return true; // int[].class, for example if (ReflectUtil.isVMAnonymousClass(cls)) // FIXME: switch to supported API once it is added return false; // could use VerifyAccess.isClassAccessible but the following is a safe approximation if (cls.getClassLoader() != Object.class.getClassLoader()) return false; if (VerifyAccess.isSamePackage(MethodHandle.class, cls)) return true; if (!Modifier.isPublic(cls.getModifiers())) return false; for (Class<?> pkgcls : STATICALLY_INVOCABLE_PACKAGES) { if (VerifyAccess.isSamePackage(pkgcls, cls)) return true; } return false; }
Example #9
Source File: ExternalSystemTestCase.java From intellij-quarkus with Eclipse Public License 2.0 | 6 votes |
private void resetClassFields(final Class<?> aClass) { if (aClass == null) return; final Field[] fields = aClass.getDeclaredFields(); for (Field field : fields) { final int modifiers = field.getModifiers(); if ((modifiers & Modifier.FINAL) == 0 && (modifiers & Modifier.STATIC) == 0 && !field.getType().isPrimitive()) { field.setAccessible(true); try { field.set(this, null); } catch (IllegalAccessException e) { e.printStackTrace(); } } } if (aClass == ExternalSystemTestCase.class) return; resetClassFields(aClass.getSuperclass()); }
Example #10
Source File: MVELConstraintBuilder.java From kogito-runtimes with Apache License 2.0 | 6 votes |
@Override public boolean areEqualityCompatible(Class<?> c1, Class<?> c2) { if (c1 == NullType.class || c2 == NullType.class) { return true; } if (c1 == String.class || c2 == String.class) { return true; } Class<?> boxed1 = convertFromPrimitiveType(c1); Class<?> boxed2 = convertFromPrimitiveType(c2); if (boxed1.isAssignableFrom(boxed2) || boxed2.isAssignableFrom(boxed1)) { return true; } if (Number.class.isAssignableFrom(boxed1) && Number.class.isAssignableFrom(boxed2)) { return true; } return !Modifier.isFinal(c1.getModifiers()) && !Modifier.isFinal(c2.getModifiers()); }
Example #11
Source File: JsonUtils.java From mogu_blog_v2 with Apache License 2.0 | 6 votes |
/** * JSON 转 ArrayList * * @author [email protected] * @date 2018年10月27日下午4:43:25 */ public static ArrayList<?> jsonArrayToArrayList(String jsonArray, Class<?> clazz) { Gson gson = new GsonBuilder() .excludeFieldsWithModifiers(Modifier.FINAL, Modifier.TRANSIENT, Modifier.STATIC) .setDateFormat("yyyy-MM-dd HH:mm:ss") .serializeNulls() .create(); ArrayList<?> list = null; try { list = (ArrayList<?>) gson.fromJson(jsonArray, clazz); } catch (JsonSyntaxException e) { e.printStackTrace(); } return list; }
Example #12
Source File: AnalyzedMethod.java From glowroot with Apache License 2.0 | 6 votes |
boolean isOverriddenBy(String methodName, List<Type> parameterTypes) { if (Modifier.isStatic(modifiers())) { return false; } if (Modifier.isPrivate(modifiers())) { return false; } if (!methodName.equals(name())) { return false; } if (parameterTypes.size() != parameterTypes().size()) { return false; } for (int i = 0; i < parameterTypes.size(); i++) { if (!parameterTypes.get(i).getClassName().equals(parameterTypes().get(i))) { return false; } } return true; }
Example #13
Source File: SpannerStructReadMethodCoverageTests.java From spring-cloud-gcp with Apache License 2.0 | 6 votes |
@Test public void allKnownMappingTypesTest() throws NoSuchFieldException { for (Method method : Struct.class.getMethods()) { String methodName = method.getName(); // ignoring private methods, ones not named like a getter. Getters must also // only take the column index or name if (!Modifier.isPublic(method.getModifiers()) || !methodName.startsWith("get") || method.getParameterCount() != 1 || DISREGARDED_METHOD_NAMES.contains(methodName)) { continue; } Class returnType = ConversionUtils.boxIfNeeded(method.getReturnType()); if (ConversionUtils.isIterableNonByteArrayType(returnType)) { Class innerReturnType = (Class) ((ParameterizedType) method .getGenericReturnType()).getActualTypeArguments()[0]; assertThat(StructAccessor.readIterableMapping.keySet()).contains(innerReturnType); } else { assertThat(StructAccessor.singleItemReadMethodMapping.keySet()).contains(returnType); } } }
Example #14
Source File: ExposureSupport.java From Tangram-Android with MIT License | 6 votes |
private void findExposureMethods(Method[] methods) { for (Method method : methods) { String methodName = method.getName(); if (isValidExposureMethodName(methodName)) { int modifiers = method.getModifiers(); if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) { Class<?>[] parameterTypes = method.getParameterTypes(); if (parameterTypes.length == 3) { Class<?> viewType = parameterTypes[0]; Class<?> cellType = parameterTypes[1]; Class<?> clickIntType = parameterTypes[2]; if (View.class.isAssignableFrom(viewType) && BaseCell.class.isAssignableFrom(cellType) && (clickIntType.equals(int.class) || clickIntType .equals(Integer.class))) { mOnExposureMethods.put(viewType, new OnTraceMethod(3, method)); } } } } } }
Example #15
Source File: LuaMapping.java From Cubes with MIT License | 6 votes |
public static LuaTable mapping(Class<?> c) { try { LuaTable luaTable = new LuaTable(); for (Field field : c.getFields()) { if (!Modifier.isStatic(field.getModifiers())) continue; if (LuaValue.class.isAssignableFrom(field.getType())) { luaTable.set(field.getName(), (LuaValue) field.get(null)); } if (field.getType().equals(Class.class)) { luaTable.set(field.getName(), mapping((Class<?>) field.get(null))); } } return new ReadOnlyLuaTable(luaTable); } catch (Exception e) { throw new CubesException("Failed to create lua api", e); } }
Example #16
Source File: ScalarFunctionImpl.java From calcite with Apache License 2.0 | 6 votes |
/** * Creates {@link org.apache.calcite.schema.ScalarFunction} for each method in * a given class. */ public static ImmutableMultimap<String, ScalarFunction> createAll( Class<?> clazz) { final ImmutableMultimap.Builder<String, ScalarFunction> builder = ImmutableMultimap.builder(); for (Method method : clazz.getMethods()) { if (method.getDeclaringClass() == Object.class) { continue; } if (!Modifier.isStatic(method.getModifiers()) && !classHasPublicZeroArgsConstructor(clazz)) { continue; } final ScalarFunction function = create(method); builder.put(method.getName(), function); } return builder.build(); }
Example #17
Source File: SwingTest.java From jdk8u60 with GNU General Public License v2.0 | 6 votes |
private void start() throws Throwable { do { if ((this.method != null) && Modifier.isStatic(this.method.getModifiers())) { run(); // invoke static method on the current thread } else { SwingUtilities.invokeLater(this); // invoke on the event dispatch thread } Toolkit tk = Toolkit.getDefaultToolkit(); if (tk instanceof SunToolkit) { SunToolkit stk = (SunToolkit) tk; stk.realSync(); // wait until done } } while (this.frame != null); if (this.error != null) { throw this.error; } }
Example #18
Source File: Reflector2.java From clj-graal-docs with Eclipse Public License 1.0 | 6 votes |
public static boolean isAccessibleMatch(Method lhs, Method rhs, Object target) { if(!lhs.getName().equals(rhs.getName()) || !Modifier.isPublic(lhs.getDeclaringClass().getModifiers()) || !canAccess(lhs, target)) { return false; } Class[] types1 = lhs.getParameterTypes(); Class[] types2 = rhs.getParameterTypes(); if(types1.length != types2.length) return false; boolean match = true; for (int i=0; i<types1.length; ++i) { if(!types1[i].isAssignableFrom(types2[i])) { match = false; break; } } return match; }
Example #19
Source File: NewInstanceMutationOperator.java From pitest-descartes with GNU Lesser General Public License v3.0 | 6 votes |
/** * Returns a value indicating whether the operator can transform the given method. */ @Override public boolean canMutate(Method method) { try { Class<?> returnClass = getAppropriateReturnClass(method); if(returnClass.equals(String.class) || !belongsToJavaPackages(returnClass) || Modifier.isAbstract(returnClass.getModifiers())) { return false; } for (Constructor<?> publicConstructor : returnClass.getConstructors()) { if (publicConstructor.getParameters().length == 0) { return true; } } return false; } catch (ClassNotFoundException e) { return false; } }
Example #20
Source File: ObjectStreamClass.java From jdk1.8-source-analysis with Apache License 2.0 | 6 votes |
/** * Returns subclass-accessible no-arg constructor of first non-serializable * superclass, or null if none found. Access checks are disabled on the * returned constructor (if any). */ private static Constructor<?> getSerializableConstructor(Class<?> cl) { Class<?> initCl = cl; while (Serializable.class.isAssignableFrom(initCl)) { if ((initCl = initCl.getSuperclass()) == null) { return null; } } try { Constructor<?> cons = initCl.getDeclaredConstructor((Class<?>[]) null); int mods = cons.getModifiers(); if ((mods & Modifier.PRIVATE) != 0 || ((mods & (Modifier.PUBLIC | Modifier.PROTECTED)) == 0 && !packageEquals(cl, initCl))) { return null; } cons = reflFactory.newConstructorForSerialization(cl, cons); cons.setAccessible(true); return cons; } catch (NoSuchMethodException ex) { return null; } }
Example #21
Source File: TestReadableDurationConverter.java From astor with GNU General Public License v2.0 | 5 votes |
public void testSingleton() throws Exception { Class cls = ReadableDurationConverter.class; assertEquals(false, Modifier.isPublic(cls.getModifiers())); assertEquals(false, Modifier.isProtected(cls.getModifiers())); assertEquals(false, Modifier.isPrivate(cls.getModifiers())); Constructor con = cls.getDeclaredConstructor((Class[]) null); assertEquals(1, cls.getDeclaredConstructors().length); assertEquals(true, Modifier.isProtected(con.getModifiers())); Field fld = cls.getDeclaredField("INSTANCE"); assertEquals(false, Modifier.isPublic(fld.getModifiers())); assertEquals(false, Modifier.isProtected(fld.getModifiers())); assertEquals(false, Modifier.isPrivate(fld.getModifiers())); }
Example #22
Source File: ToStringBuilder.java From xtext-lib with Eclipse Public License 2.0 | 5 votes |
@GwtIncompatible("java.lang.reflect.Field") private ToStringBuilder addField(final Field field) { if (!Modifier.isStatic(field.getModifiers())) { field.setAccessible(true); try { add(field.getName(), field.get(instance)); } catch(IllegalAccessException e) { throw Exceptions.sneakyThrow(e); } } return this; }
Example #23
Source File: MixinInMetaClass.java From groovy with Apache License 2.0 | 5 votes |
private static CachedConstructor findDefaultConstructor(CachedClass mixinClass) { for (CachedConstructor constr : mixinClass.getConstructors()) { if (!Modifier.isPublic(constr.getModifiers())) continue; CachedClass[] classes = constr.getParameterTypes(); if (classes.length == 0) return constr; } throw new GroovyRuntimeException("No default constructor for class " + mixinClass.getName() + "! Can't be mixed in."); }
Example #24
Source File: ObjectReader.java From openjdk-jdk8u with GNU General Public License v2.0 | 5 votes |
public void doByte(ByteField field, boolean isVMField) { java.lang.reflect.Field f = null; try { f = readField(field); if (Modifier.isFinal(f.getModifiers())) return; f.setAccessible(true); f.setByte(obj, field.getValue(getObj())); } catch (Exception ex) { printFieldSetError(f, ex); } }
Example #25
Source File: NashornStaticClassLinker.java From openjdk-jdk8u-backup with GNU General Public License v2.0 | 5 votes |
@Override public GuardedInvocation getGuardedInvocation(final LinkRequest linkRequest, final LinkerServices linkerServices) throws Exception { final LinkRequest request = linkRequest.withoutRuntimeContext(); // Nashorn has no runtime context final Object self = request.getReceiver(); if (self.getClass() != StaticClass.class) { return null; } final Class<?> receiverClass = ((StaticClass) self).getRepresentedClass(); Bootstrap.checkReflectionAccess(receiverClass, true); final CallSiteDescriptor desc = request.getCallSiteDescriptor(); // We intercept "new" on StaticClass instances to provide additional capabilities if ("new".equals(desc.getNameToken(CallSiteDescriptor.OPERATOR))) { if (! Modifier.isPublic(receiverClass.getModifiers())) { throw ECMAErrors.typeError("new.on.nonpublic.javatype", receiverClass.getName()); } // make sure new is on accessible Class Context.checkPackageAccess(receiverClass); // Is the class abstract? (This includes interfaces.) if (NashornLinker.isAbstractClass(receiverClass)) { // Change this link request into a link request on the adapter class. final Object[] args = request.getArguments(); args[0] = JavaAdapterFactory.getAdapterClassFor(new Class<?>[] { receiverClass }, null, linkRequest.getCallSiteDescriptor().getLookup()); final LinkRequest adapterRequest = request.replaceArguments(request.getCallSiteDescriptor(), args); final GuardedInvocation gi = checkNullConstructor(delegate(linkerServices, adapterRequest), receiverClass); // Finally, modify the guard to test for the original abstract class. return gi.replaceMethods(gi.getInvocation(), Guards.getIdentityGuard(self)); } // If the class was not abstract, just delegate linking to the standard StaticClass linker. Make an // additional check to ensure we have a constructor. We could just fall through to the next "return" // statement, except we also insert a call to checkNullConstructor() which throws an ECMAScript TypeError // with a more intuitive message when no suitable constructor is found. return checkNullConstructor(delegate(linkerServices, request), receiverClass); } // In case this was not a "new" operation, just delegate to the the standard StaticClass linker. return delegate(linkerServices, request); }
Example #26
Source File: ObjectReader.java From jdk8u60 with GNU General Public License v2.0 | 5 votes |
public void doChar(CharField field, boolean isVMField) { java.lang.reflect.Field f = null; try { f = readField(field); if (Modifier.isFinal(f.getModifiers())) return; f.setAccessible(true); f.setChar(obj, field.getValue(getObj())); } catch (Exception ex) { printFieldSetError(f, ex); } }
Example #27
Source File: ObjectStreamClass.java From jdk1.8-source-analysis with Apache License 2.0 | 5 votes |
/** * Returns non-static, non-abstract method with given signature provided it * is defined by or accessible (via inheritance) by the given class, or * null if no match found. Access checks are disabled on the returned * method (if any). */ private static Method getInheritableMethod(Class<?> cl, String name, Class<?>[] argTypes, Class<?> returnType) { Method meth = null; Class<?> defCl = cl; while (defCl != null) { try { meth = defCl.getDeclaredMethod(name, argTypes); break; } catch (NoSuchMethodException ex) { defCl = defCl.getSuperclass(); } } if ((meth == null) || (meth.getReturnType() != returnType)) { return null; } meth.setAccessible(true); int mods = meth.getModifiers(); if ((mods & (Modifier.STATIC | Modifier.ABSTRACT)) != 0) { return null; } else if ((mods & (Modifier.PUBLIC | Modifier.PROTECTED)) != 0) { return meth; } else if ((mods & Modifier.PRIVATE) != 0) { return (cl == defCl) ? meth : null; } else { return packageEquals(cl, defCl) ? meth : null; } }
Example #28
Source File: Code.java From es6draft with MIT License | 5 votes |
public MethodCode newConstructor(int access, MethodTypeDescriptor methodDescriptor, String signature, String[] exceptions) { if ((access & ~Modifier.constructorModifiers()) != 0) { throw new IllegalArgumentException(); } methodCount += 1; return new MethodCode(this, access, "<init>", methodDescriptor, classWriter.visitMethod(access, "<init>", methodDescriptor.descriptor(), signature, exceptions)); }
Example #29
Source File: NPEfix_0089_s.java From coming with MIT License | 5 votes |
/** * <p>Returns the desired Method much like <code>Class.getMethod</code>, however * it ensures that the returned Method is from a public class or interface and not * from an anonymous inner class. This means that the Method is invokable and * doesn't fall foul of Java bug * <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4071957">4071957</a>). * * <code><pre>Set set = Collections.unmodifiableSet(...); * Method method = ClassUtils.getPublicMethod(set.getClass(), "isEmpty", new Class[0]); * Object result = method.invoke(set, new Object[]);</pre></code> * </p> * * @param cls the class to check, not null * @param methodName the name of the method * @param parameterTypes the list of parameters * @return the method * @throws NullPointerException if the class is null * @throws SecurityException if a a security violation occured * @throws NoSuchMethodException if the method is not found in the given class * or if the metothod doen't conform with the requirements */ public static Method getPublicMethod(Class<?> cls, String methodName, Class<?> parameterTypes[]) throws SecurityException, NoSuchMethodException { Method declaredMethod = cls.getMethod(methodName, parameterTypes); if (Modifier.isPublic(declaredMethod.getDeclaringClass().getModifiers())) { return declaredMethod; } List<Class<?>> candidateClasses = new ArrayList<Class<?>>(); candidateClasses.addAll(getAllInterfaces(cls)); candidateClasses.addAll(getAllSuperclasses(cls)); for (Class<?> candidateClass : candidateClasses) { if (!Modifier.isPublic(candidateClass.getModifiers())) { continue; } Method candidateMethod; try { candidateMethod = candidateClass.getMethod(methodName, parameterTypes); } catch (NoSuchMethodException ex) { continue; } if (Modifier.isPublic(candidateMethod.getDeclaringClass().getModifiers())) { return candidateMethod; } } throw new NoSuchMethodException("Can't find a public method for " + methodName + " " + org.apache.commons.lang3.ArrayUtils.toString(parameterTypes)); }
Example #30
Source File: ClassSignatureBase.java From HotswapAgent with GNU General Public License v2.0 | 5 votes |
private boolean makeAccessible(Method method) { if ((!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers())) && !method.isAccessible()) { method.setAccessible(true); return true; } return false; }