/** * 放回一个可以访问的字段或者方法 * */ public static <T extends AccessibleObject> T setAndGetAccessible(T accessible) { if (accessible == null) { return null; } if (accessible instanceof Member) { Member member = (Member) accessible; if (Modifier.isPublic(member.getModifiers()) && Modifier.isPublic(member.getDeclaringClass().getModifiers())) { return accessible; } } if (!accessible.isAccessible()) { accessible.setAccessible(true); } return accessible; }
static boolean setAccessibleWorkaround(final AccessibleObject o) { if (o == null || o.isAccessible()) { return false; } final Member m = (Member) o; if (!o.isAccessible() && Modifier.isPublic(m.getModifiers()) && isPackageAccess(m .getDeclaringClass().getModifiers())) { try { o.setAccessible(true); return true; } catch (final SecurityException e) { // NOPMD // ignore in favor of subsequent IllegalAccessException } } return false; }
protected void cloneFields(Class<? extends WizardControl> clazz, WizardControl control) { Field[] declaredFields = clazz.getDeclaredFields(); AccessibleObject.setAccessible(declaredFields, true); for( Field field : declaredFields ) { try { if( (field.getModifiers() & (Modifier.STATIC | Modifier.FINAL)) == 0 ) { field.set(control, field.get(this)); } } catch( Exception e ) { throw new RuntimeException(e); } } }
/** * <p>Appends the fields and values defined by the given object of the * given Class.</p> * * @param lhs the left hand object * @param rhs the right hand object * @param clazz the class to append details of * @param builder the builder to append to * @param useTransients whether to test transient fields * @param excludeFields array of field names to exclude from testing */ private static void reflectionAppend( Object lhs, Object rhs, Class clazz, EqualsBuilder builder, boolean useTransients, String[] excludeFields) { Field[] fields = clazz.getDeclaredFields(); AccessibleObject.setAccessible(fields, true); for (int i = 0; i < fields.length && builder.isEquals; i++) { Field f = fields[i]; if (!ArrayUtils.contains(excludeFields, f.getName()) && (f.getName().indexOf('$') == -1) && (useTransients || !Modifier.isTransient(f.getModifiers())) && (!Modifier.isStatic(f.getModifiers()))) { try { builder.append(f.get(lhs), f.get(rhs)); } catch (IllegalAccessException e) { //this can't happen. Would get a Security exception instead //throw a runtime exception in case the impossible happens. throw new InternalError("Unexpected IllegalAccessException"); } } } }
/** * Enable sharing of the class-loader with 3rd party. * * @return the class-loader user be the helper. */ public ClassLoader getClassLoader() { // To follow the same behavior of Class.forName(...) I had to play // dirty (Supported by Sun, IBM & BEA JVMs) try { // Get a reference to this class' class-loader ClassLoader cl = this.getClass().getClassLoader(); // Create a method instance representing the protected // getCallerClassLoader method of class ClassLoader Method mthd = ClassLoader.class.getDeclaredMethod( "getCallerClassLoader", new Class<?>[0]); // Make the method accessible. AccessibleObject.setAccessible(new AccessibleObject[] {mthd}, true); // Try to get the caller's class-loader return (ClassLoader)mthd.invoke(cl, new Object[0]); } catch (Throwable all) { // Use this class' class-loader return this.getClass().getClassLoader(); } }
/** * Enable sharing of the class-loader with 3rd party. * * @return the class-loader user be the helper. */ public ClassLoader getClassLoader() { // To follow the same behavior of Class.forName(...) I had to play // dirty (Supported by Sun, IBM & BEA JVMs) try { // Get a reference to this class' class-loader ClassLoader cl = this.getClass().getClassLoader(); // Create a method instance representing the protected // getCallerClassLoader method of class ClassLoader Method mthd = ClassLoader.class.getDeclaredMethod( "getCallerClassLoader", new Class[0]); // Make the method accessible. AccessibleObject.setAccessible(new AccessibleObject[] {mthd}, true); // Try to get the caller's class-loader return (ClassLoader)mthd.invoke(cl, new Object[0]); } catch (Exception all) { // Use this class' class-loader return this.getClass().getClassLoader(); } }
public static void checkAccess(AccessibleObject accessibleObject, Object obj) throws IllegalAccessException, InvocationTargetException, InstantiationException { if (accessibleObject instanceof Field) { Field field = (Field) accessibleObject; field.set(obj, 42); field.get(obj); } else if (accessibleObject instanceof Method) { Method method = (Method) accessibleObject; method.invoke(obj); } else if (accessibleObject instanceof Constructor) { Constructor<?> constructor = (Constructor<?>) accessibleObject; Object[] params = new Object[constructor.getParameterCount()]; constructor.newInstance(params); } }
Member getReadMember(Class targetClass) throws NameNotFoundException { // mapping: public field (same name), method (getAttribute()), // method (attribute()) List key = new ArrayList(); key.add(targetClass); key.add(_name); Member m = (Member) _cache.get(key); if (m != null) return m; m = getReadField(targetClass); if (m == null) m = getReadMethod(targetClass); if (m != null) _cache.putIfAbsent(key, m); else throw new NameNotFoundException( LocalizedStrings.AttributeDescriptor_NO_PUBLIC_ATTRIBUTE_NAMED_0_WAS_FOUND_IN_CLASS_1 .toLocalizedString(new Object[] {_name, targetClass.getName()})); // override security for nonpublic derived classes with public members ((AccessibleObject) m).setAccessible(true); return m; }
public static void setAccessibility(boolean b) { if (!b) { accessibility = false; } else { String.class.getDeclaredMethods(); // test basic access try { final AccessibleObject member = String.class.getDeclaredField("value"); member.setAccessible(true); member.setAccessible(false); } catch (NoSuchFieldException e) { // ignore } accessibility = true; } KrineClassManager.clearResolveCache(); }
private String[] getParameterNames(AccessibleObject a, String name, Class<?>[] types, String raw) { if (types.length == 0) return new String[0]; StringBuilder regex = new StringBuilder(); regex.append(format(">\\Q%s\\E</A></(?:B|strong)>\\(", name)); for (Class<?> klass : types) { regex.append(format( ",?\\s*(?:<A[^>]+>)?[\\w.]*\\Q%s\\E(?:</A>)?(?:<[^&]+>)? ([^),\\s]+)", klass.getSimpleName() )); } regex.append(format("\\)</CODE>")); Pattern pattern = Pattern.compile(regex.toString(), Pattern.MULTILINE | Pattern.CASE_INSENSITIVE); Matcher matcher = pattern.matcher(raw); if (!matcher.find()) throw new ParameterNamesNotFoundException(a + ", " + regex); String[] names = new String[types.length]; for (int i = 0 ; i < names.length ; i++) names[i] = matcher.group(1 + i).trim(); return names; }
private static String annotatedName(AccessibleObject obj) { if (obj.isAnnotationPresent(PropertyName.class)) { PropertyName annotation = obj.getAnnotation(PropertyName.class); return annotation.value(); } return null; }
public String[] lookupParameterNames(AccessibleObject methodOrCtor, boolean throwExceptionIfMissing) { for (int i = 0; i < paranamers.length; i++) { Paranamer paranamer = paranamers[i]; String[] names = paranamer.lookupParameterNames(methodOrCtor, i+1 < paranamers.length ? false : throwExceptionIfMissing); if (names != Paranamer.EMPTY_NAMES) { return names; } } return Paranamer.EMPTY_NAMES; }
public MethodIntrospector(AccessibleObject methodOrCtor) { super(); this.methodOrCtor = methodOrCtor; this.classes = getClasses(methodOrCtor); this.types = getGenericParameterTypes(methodOrCtor); this.names = getParameterNames(methodOrCtor); this.parameterDescriptions = mergeToParameters(names, types); }
public List<AccessibleObject> getJpaAnnotatedMembers(Class<?> c, Class<? extends Annotation> annotation) { final List<AccessibleObject> jpaAnnotated = new ArrayList<AccessibleObject>(); for (Class<?> cl = c; cl != Object.class && cl != null; cl = cl.getSuperclass()) { parseClass(annotation, jpaAnnotated, cl); } return jpaAnnotated; }
public String[] lookupParameterNames(AccessibleObject methodOrCtor, boolean throwExceptionIfMissing) { String[] names = methodCache.get(methodOrCtor); // refer PARANAMER-19 if(names == null) { names = delegate.lookupParameterNames(methodOrCtor, throwExceptionIfMissing); methodCache.put(methodOrCtor, names); } return names; }
public static String getName(AccessibleObject member) { if (member instanceof Field) { return ((Field)member).getName(); } else if (member instanceof Method) { Method method = (Method)member; String name = method.getName(); if (!name.startsWith("set")) { return null; } return lowerCamelCase(name.substring(3)); } throw new IllegalArgumentException(); }
public static Class<?> getType(AccessibleObject member) { if (member instanceof Field) { return ((Field)member).getType(); } else if (member instanceof Method) { return ((Method)member).getParameterTypes()[0]; } throw new IllegalArgumentException(); }
@Test public void getPCAnnotatedMembersTest() { AnnotationScanner scanner = new AnnotationScanner(); List<AccessibleObject> members = scanner.getJpaAnnotatedMembers(TestClass.class, PersistenceContext.class); Assert.assertEquals(1, members.size()); AccessibleObject member = members.get(0); Assert.assertEquals(Field.class, member.getClass()); Field field = (Field)member; Assert.assertEquals("em", field.getName()); }
@Test public void getPUAnnotatedMembersTest() { AnnotationScanner scanner = new AnnotationScanner(); List<AccessibleObject> members = scanner.getJpaAnnotatedMembers(TestClass.class, PersistenceUnit.class); Assert.assertEquals(1, members.size()); AccessibleObject member = members.get(0); Assert.assertEquals(Method.class, member.getClass()); Method method = (Method)member; Assert.assertEquals("setEmf", method.getName()); }
/** * When using a factory the class can be an interface. We need to make sure this does not cause a NPE */ @Test public void getFactoryTest() { AnnotationScanner scanner = new AnnotationScanner(); List<AccessibleObject> members = scanner.getJpaAnnotatedMembers(TestInterface.class, PersistenceUnit.class); Assert.assertEquals(0, members.size()); }
@Override protected boolean tryToMakeAccessible(AccessibleObject accessible) { if (accessible.isAccessible()) { return true; } try { accessible.setAccessible(true); } catch (Exception ex) { } return accessible.isAccessible(); }
/** Returns the Field object, if available, or the setter Method, corresponding to the input dataFieldName. * @param dataFieldName the name of the data field. * @return the Field object, if available, or the setter Method, corresponding to the input dataFieldName. */ public AccessibleObject getDataMutator(String dataFieldName) { AccessibleObject accessibleObject = containsDataField(dataFieldName) ? elementMap.get(dataFieldName).getGraphField() : null; if (accessibleObject == null) { PropertyDescriptor pd = getDataFieldDescriptor(dataFieldName); if (pd != null) { accessibleObject = pd.getWriteMethod(); if (!accessibleObject.isAccessible()) accessibleObject.setAccessible(true); } } return accessibleObject; }
/** * Tests that the forwarding wrapper returned by {@code wrapperFunction} properly forwards * method calls with parameters passed as is, return value returned as is, and exceptions * propagated as is. */ public <T> void testForwarding( Class<T> interfaceType, Function<? super T, ? extends T> wrapperFunction) { checkNotNull(wrapperFunction); checkArgument(interfaceType.isInterface(), "%s isn't an interface", interfaceType); Method[] methods = getMostConcreteMethods(interfaceType); AccessibleObject.setAccessible(methods, true); for (Method method : methods) { // Under java 8, interfaces can have default methods that aren't abstract. // No need to verify them. // Can't check isDefault() for JDK 7 compatibility. if (!Modifier.isAbstract(method.getModifiers())) { continue; } // The interface could be package-private or private. // filter out equals/hashCode/toString if (method.getName().equals("equals") && method.getParameterTypes().length == 1 && method.getParameterTypes()[0] == Object.class) { continue; } if (method.getName().equals("hashCode") && method.getParameterTypes().length == 0) { continue; } if (method.getName().equals("toString") && method.getParameterTypes().length == 0) { continue; } testSuccessfulForwarding(interfaceType, method, wrapperFunction); testExceptionPropagation(interfaceType, method, wrapperFunction); } if (testsEquals) { testEquals(interfaceType, wrapperFunction); } testToString(interfaceType, wrapperFunction); }
private int count(AccessibleObject methodOrCtor) { if (methodOrCtor instanceof Method) { Method method = (Method) methodOrCtor; return method.getParameterTypes().length; } Constructor<?> constructor = (Constructor<?>) methodOrCtor; return constructor.getParameterTypes().length; }
private AnnotationAttributes findAutowiredAnnotation(AccessibleObject ao) { for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) { AnnotationAttributes annotation = AnnotatedElementUtils.getAnnotationAttributes(ao, type.getName()); if (annotation != null) { return annotation; } } return null; }
/** * XXX Default access superclass workaround * * When a public class has a default access superclass with public members, * these members are accessible. Calling them from compiled code works fine. * Unfortunately, on some JVMs, using reflection to invoke these members * seems to (wrongly) to prevent access even when the modifer is public. * Calling setAccessible(true) solves the problem but will only work from * sufficiently privileged code. Better workarounds would be gratefully * accepted. * @param o the AccessibleObject to set as accessible */ static void setAccessibleWorkaround(AccessibleObject o) { if (o == null || o.isAccessible()) { return; } Member m = (Member) o; if (Modifier.isPublic(m.getModifiers()) && isPackageAccess(m.getDeclaringClass().getModifiers())) { try { o.setAccessible(true); } catch (SecurityException e) { // ignore in favor of subsequent IllegalAccessException } } }
/** * <p> * Appends the fields and values defined by the given object of the given <code>Class</code>. * </p> * * @param object * the object to append details of * @param clazz * the class to append details of * @param builder * the builder to append to * @param useTransients * whether to use transient fields * @param excludeFields * Collection of String field names to exclude from use in calculation of hash code */ private static void reflectionAppend(Object object, Class clazz, HashCodeBuilder builder, boolean useTransients, String[] excludeFields) { if (isRegistered(object)) { return; } try { register(object); Field[] fields = clazz.getDeclaredFields(); AccessibleObject.setAccessible(fields, true); for (int i = 0; i < fields.length; i++) { Field field = fields[i]; if (!ArrayUtils.contains(excludeFields, field.getName()) && (field.getName().indexOf('$') == -1) && (useTransients || !Modifier.isTransient(field.getModifiers())) && (!Modifier.isStatic(field.getModifiers()))) { try { Object fieldValue = field.get(object); builder.append(fieldValue); } catch (IllegalAccessException e) { // this can't happen. Would get a Security exception instead // throw a runtime exception in case the impossible happens. throw new InternalError("Unexpected IllegalAccessException"); } } } } finally { unregister(object); } }
/** * <p> * Appends the fields and values defined by the given object of the given Class. * </p> * * <p> * If a cycle is detected as an object is "toString()'ed", such an object is rendered as if * <code>Object.toString()</code> had been called and not implemented by the object. * </p> * * @param clazz * The class of object parameter */ protected void appendFieldsIn(Class clazz) { if (clazz.isArray()) { this.reflectionAppendArray(this.getObject()); return; } Field[] fields = clazz.getDeclaredFields(); AccessibleObject.setAccessible(fields, true); for (int i = 0; i < fields.length; i++) { Field field = fields[i]; String fieldName = field.getName(); if (this.accept(field)) { try { // Warning: Field.get(Object) creates wrappers objects // for primitive types. Object fieldValue = this.getValue(field); this.append(fieldName, fieldValue); } catch (IllegalAccessException ex) { //this can't happen. Would get a Security exception // instead //throw a runtime exception in case the impossible // happens. throw new InternalError("Unexpected IllegalAccessException: " + ex.getMessage()); } } } }
/** * <p>Appends to <code>builder</code> the comparison of <code>lhs</code> * to <code>rhs</code> using the fields defined in <code>clazz</code>.</p> * * @param lhs left-hand object * @param rhs right-hand object * @param clazz <code>Class</code> that defines fields to be compared * @param builder <code>CompareToBuilder</code> to append to * @param useTransients whether to compare transient fields * @param excludeFields fields to exclude */ private static void reflectionAppend( Object lhs, Object rhs, Class clazz, CompareToBuilder builder, boolean useTransients, String[] excludeFields) { Field[] fields = clazz.getDeclaredFields(); AccessibleObject.setAccessible(fields, true); for (int i = 0; i < fields.length && builder.comparison == 0; i++) { Field f = fields[i]; if (!ArrayUtils.contains(excludeFields, f.getName()) && (f.getName().indexOf('$') == -1) && (useTransients || !Modifier.isTransient(f.getModifiers())) && (!Modifier.isStatic(f.getModifiers()))) { try { builder.append(f.get(lhs), f.get(rhs)); } catch (IllegalAccessException e) { // This can't happen. Would get a Security exception instead. // Throw a runtime exception in case the impossible happens. throw new InternalError("Unexpected IllegalAccessException"); } } } }
private static Member findAnnotatedMember(AccessibleObject[] members, Class<? extends Annotation> annotation) { for (AccessibleObject member : members) { if (member.isAnnotationPresent(annotation)) { return (Member) member; } } return null; }
/** * 根据类型将请求中的参数封装成一个对象并返回 * @param clazz httpBean中方法参数的类型 * @param index 用于resultList()方法标识索引位置 * @return * @throws Exception */ private Object resultSingle(Class<?> clazz, int index) throws Exception { if (cycleNumber >= 10) { cycleNumber++; return null; } Object instance = clazz.newInstance(); Field[] fields = clazz.getDeclaredFields(); AccessibleObject.setAccessible(fields, true); for (Field field : fields) { if (BasicUtil.isCollection(clazz)) { instance = resultList(field.getGenericType()); continue; } String[] vals = paramMap.get(field.getName()); if (vals == null || index >= vals.length) continue; String param = vals[index]; if (BasicUtil.isCommonType(field)) field.set(instance, BasicUtil.convert(field, param)); else if (field.getType() == Date.class) { dateFormatCheck(format); Date date = DateUtil.resolve(param, format); field.set(instance, date); } else { resultSingle(field.getType(), 0); } } return instance; }
private static void setAccessible(final AccessibleObject ao, final boolean accessible) { AccessController.doPrivileged(new PrivilegedAction<Object>() { public Object run() { ao.setAccessible(accessible); return null; }}); }
private void makeAccessible(final AccessibleObject object) { AccessController.doPrivileged(new PrivilegedAction<Void>() { public Void run() { object.setAccessible(true); return null; } }); }
private static void setAccessible(final AccessibleObject o) { AccessController.doPrivileged(new PrivilegedAction<Void>() { public Void run() { o.setAccessible(true); return null; } }); }
