Java Code Examples for java.lang.reflect.Modifier#PUBLIC
The following examples show how to use
java.lang.reflect.Modifier#PUBLIC .
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: ClassBuilder.java From lua-for-android with BSD 3-Clause "New" or "Revised" License | 6 votes |
/** * @param methodInfo A map contains args mapped by order or name * @see ClassBuilder#addMethod(String, int, Object, Object[], LuaFunction, List, List) */ public ClassBuilder addMethod(Map methodInfo) { LuaFunction function = mapGet("func", 4, methodInfo); Map<?, Object> paramTypes = mapGet("paramTypes", 5, methodInfo); Map<?, Map<Object, Object>> annotations = mapGet("annotations", 6, methodInfo); Map<?, Map<?, Map<Object, Object>>> paramAnnotations = mapGet("paramAnnotations", 7, methodInfo); ArrayList<List<Map<Object,Object>>> paraAnnoList=null; if(paramAnnotations!=null){ paraAnnoList=new ArrayList<>(); for (Map<?, Map<Object, Object>> annolist:paramAnnotations.values()){ paraAnnoList.add(new ArrayList<>(annolist.values())); } } Integer flag = mapGet("flag", 2, methodInfo); if(flag==null)flag=Modifier.PUBLIC|(function==null?Modifier.ABSTRACT:0); return addMethod(mapGet("name", 1, methodInfo), flag, mapGet("returnType", 3, methodInfo) , paramTypes == null ? null : paramTypes.values().toArray(), function, annotations == null ? null : new ArrayList<>(annotations.values()) , paraAnnoList); }
Example 2
Source File: DexMaker.java From dexmaker with Apache License 2.0 | 6 votes |
/** * Declares a field. * * @param flags a bitwise combination of {@link Modifier#PUBLIC}, {@link * Modifier#PRIVATE}, {@link Modifier#PROTECTED}, {@link Modifier#STATIC}, * {@link Modifier#FINAL}, {@link Modifier#VOLATILE}, and {@link * Modifier#TRANSIENT}. * @param staticValue a constant representing the initial value for the * static field, possibly null. This must be null if this field is * non-static. */ public void declare(FieldId<?, ?> fieldId, int flags, Object staticValue) { TypeDeclaration typeDeclaration = getTypeDeclaration(fieldId.declaringType); if (typeDeclaration.fields.containsKey(fieldId)) { throw new IllegalStateException("already declared: " + fieldId); } int supportedFlags = Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED | Modifier.STATIC | Modifier.FINAL | Modifier.VOLATILE | Modifier.TRANSIENT | AccessFlags.ACC_SYNTHETIC; if ((flags & ~supportedFlags) != 0) { throw new IllegalArgumentException("Unexpected flag: " + Integer.toHexString(flags)); } if ((flags & Modifier.STATIC) == 0 && staticValue != null) { throw new IllegalArgumentException("staticValue is non-null, but field is not static"); } FieldDeclaration fieldDeclaration = new FieldDeclaration(fieldId, flags, staticValue); typeDeclaration.fields.put(fieldId, fieldDeclaration); }
Example 3
Source File: BeamIOTransformer.java From component-runtime with Apache License 2.0 | 6 votes |
@Override public void visitEnd() { if (accumulatorType != null) { final MethodVisitor getAccumulatorCoder = super.visitMethod(Modifier.PUBLIC, "getAccumulatorCoder", "(Lorg/apache/beam/sdk/coders/CoderRegistry;Lorg/apache/beam/sdk/coders/Coder;)" + "Lorg/apache/beam/sdk/coders/Coder;", null, null); getAccumulatorCoder.visitLdcInsn(accumulatorType); getAccumulatorCoder.visitLdcInsn(plugin); getAccumulatorCoder .visitMethodInsn(INVOKESTATIC, "org/talend/sdk/component/runtime/beam/coder/ContextualSerializableCoder", "of", "(Ljava/lang/Class;Ljava/lang/String;)Lorg/apache/beam/sdk/coders/SerializableCoder;", false); getAccumulatorCoder.visitInsn(ARETURN); getAccumulatorCoder.visitMaxs(-1, -1); getAccumulatorCoder.visitEnd(); } super.visitEnd(); }
Example 4
Source File: ClassUtil.java From nh-micro with Apache License 2.0 | 6 votes |
/** * @param type * @param name * @return Method */ public static Method getSetMethod(Class<?> type, String name) { Method[] methods = type.getMethods(); String methodName = "set" + Character.toUpperCase(name.charAt(0)) + name.substring(1); for(Method method : methods) { if(method.getModifiers() != Modifier.PUBLIC) { continue; } if(method.getName().equals(methodName)) { if(method.getParameterTypes().length == 1) { return method; } } } return null; }
Example 5
Source File: ReplicationStream.java From Tomcat7.0.67 with Apache License 2.0 | 5 votes |
/** * ObjectInputStream.resolveProxyClass has some funky way of using * the incorrect class loader to resolve proxy classes, let's do it our way instead */ @Override protected Class<?> resolveProxyClass(String[] interfaces) throws IOException, ClassNotFoundException { ClassLoader latestLoader; if (classLoaders != null && classLoaders.length > 0) { latestLoader = classLoaders[0]; } else { latestLoader = null; } ClassLoader nonPublicLoader = null; boolean hasNonPublicInterface = false; // define proxy in class loader of non-public interface(s), if any Class<?>[] classObjs = new Class[interfaces.length]; for (int i = 0; i < interfaces.length; i++) { Class<?> cl = this.resolveClass(interfaces[i]); if (latestLoader==null) latestLoader = cl.getClassLoader(); if ((cl.getModifiers() & Modifier.PUBLIC) == 0) { if (hasNonPublicInterface) { if (nonPublicLoader != cl.getClassLoader()) { throw new IllegalAccessError( "conflicting non-public interface class loaders"); } } else { nonPublicLoader = cl.getClassLoader(); hasNonPublicInterface = true; } } classObjs[i] = cl; } try { return Proxy.getProxyClass(hasNonPublicInterface ? nonPublicLoader : latestLoader, classObjs); } catch (IllegalArgumentException e) { throw new ClassNotFoundException(null, e); } }
Example 6
Source File: ObjectStreamClass.java From dragonwell8_jdk with GNU General Public License v2.0 | 5 votes |
/** * Returns public no-arg constructor of given class, or null if none found. * Access checks are disabled on the returned constructor (if any), since * the defining class may still be non-public. */ private static Constructor<?> getExternalizableConstructor(Class<?> cl) { try { Constructor<?> cons = cl.getDeclaredConstructor((Class<?>[]) null); cons.setAccessible(true); return ((cons.getModifiers() & Modifier.PUBLIC) != 0) ? cons : null; } catch (NoSuchMethodException ex) { return null; } }
Example 7
Source File: AWTKeyStroke.java From openjdk-jdk8u with GNU General Public License v2.0 | 5 votes |
static String getVKText(int keyCode) { VKCollection vkCollect = getVKCollection(); Integer key = Integer.valueOf(keyCode); String name = vkCollect.findName(key); if (name != null) { return name.substring(3); } int expected_modifiers = (Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL); Field[] fields = KeyEvent.class.getDeclaredFields(); for (int i = 0; i < fields.length; i++) { try { if (fields[i].getModifiers() == expected_modifiers && fields[i].getType() == Integer.TYPE && fields[i].getName().startsWith("VK_") && fields[i].getInt(KeyEvent.class) == keyCode) { name = fields[i].getName(); vkCollect.put(name, key); return name.substring(3); } } catch (IllegalAccessException e) { assert(false); } } return "UNKNOWN"; }
Example 8
Source File: EnversRevisionLogEntityMetadataBuilder.java From gvnix with GNU General Public License v3.0 | 5 votes |
private MethodMetadata getHashCodeMethod() { // Define method parameter types List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>( 0); // Check if a method exist in type final MethodMetadata method = helper.methodExists(TO_STRING_METHOD, parameterTypes); if (method != null) { // If it already exists, just return the method return method; } // Define method annotations (none in this case) List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); // Define method throws types (none in this case) List<JavaType> throwsTypes = new ArrayList<JavaType>(); // Define method parameter names (none in this case) List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(0); // Create the method body InvocableMemberBodyBuilder body = new InvocableMemberBodyBuilder(); body.appendFormalLine(String.format( "return new %s(17, 31).append(%s).append(%s).toHashCode();", helper.getFinalTypeName(HASH_CODE_BUILDER), ID_FIELD, TIMESTAMP_FIELD)); // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( context.getMetadataId(), Modifier.PUBLIC, HASH_CODE_METHOD, JavaType.INT_PRIMITIVE, parameterTypes, parameterNames, body); methodBuilder.setAnnotations(annotations); methodBuilder.setThrowsTypes(throwsTypes); return methodBuilder.build(); // Build and return a MethodMetadata }
Example 9
Source File: JavaClassJSObject.java From birt with Eclipse Public License 1.0 | 5 votes |
public int getVisibility( ) { if ( field == null ) return VISIBILITY_PUBLIC; if ( ( field.getModifiers( ) & Modifier.STATIC ) != 0 ) { return VISIBILITY_STATIC; } else if ( ( field.getModifiers( ) & Modifier.PUBLIC ) != 0 ) { return VISIBILITY_PUBLIC; } else if ( ( field.getModifiers( ) & Modifier.PRIVATE ) != 0 ) { return VISIBILITY_PRIVATE; } else if ( ( field.getModifiers( ) & Modifier.PROTECTED ) != 0 ) { return VISIBILITY_PROTECTED; } else { return VISIBILITY_PUBLIC; } }
Example 10
Source File: AWTKeyStroke.java From jdk8u60 with GNU General Public License v2.0 | 5 votes |
static String getVKText(int keyCode) { VKCollection vkCollect = getVKCollection(); Integer key = Integer.valueOf(keyCode); String name = vkCollect.findName(key); if (name != null) { return name.substring(3); } int expected_modifiers = (Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL); Field[] fields = KeyEvent.class.getDeclaredFields(); for (int i = 0; i < fields.length; i++) { try { if (fields[i].getModifiers() == expected_modifiers && fields[i].getType() == Integer.TYPE && fields[i].getName().startsWith("VK_") && fields[i].getInt(KeyEvent.class) == keyCode) { name = fields[i].getName(); vkCollect.put(name, key); return name.substring(3); } } catch (IllegalAccessException e) { assert(false); } } return "UNKNOWN"; }
Example 11
Source File: OptionalMethod.java From styT with Apache License 2.0 | 5 votes |
private static Method getPublicMethod(Class<?> clazz, String methodName, Class[] parameterTypes) { Method method = null; try { method = clazz.getMethod(methodName, parameterTypes); if ((method.getModifiers() & Modifier.PUBLIC) == 0) { method = null; } } catch (NoSuchMethodException e) { // None. } return method; }
Example 12
Source File: HackJavaFX.java From DeskChan with GNU Lesser General Public License v3.0 | 4 votes |
private static Object createObjectProxy(Object realObject, Class realClass, ObjectProxyMethodHook hook) throws Throwable { ClassPool pool = ClassPool.getDefault(); CtClass cc = pool.makeClass(HackJavaFX.class.getPackage().getName() + "." + realClass.getSimpleName() + "_Proxy"); cc.setSuperclass(pool.get(realClass.getName())); CtField realObjectField = new CtField(cc.getSuperclass(), "realObject", cc); realObjectField.setModifiers(Modifier.FINAL | Modifier.PRIVATE); cc.addField(realObjectField); CtField realClassField = new CtField(pool.get("java.lang.Class"), "realClass", cc); realClassField.setModifiers(Modifier.FINAL | Modifier.PRIVATE); cc.addField(realClassField); CtConstructor constructor = new CtConstructor( new CtClass[]{realObjectField.getType(), realClassField.getType()}, cc ); constructor.setModifiers(Modifier.PUBLIC); constructor.setBody("{ realObject = $1; realClass = $2; }"); cc.addConstructor(constructor); for (CtMethod method : cc.getSuperclass().getDeclaredMethods()) { if ((method.getModifiers() & Modifier.FINAL) != 0) { continue; } if ((method.getModifiers() & Modifier.STATIC) != 0) { continue; } CtMethod newMethod = new CtMethod(method.getReturnType(), method.getName(), method.getParameterTypes(), cc); newMethod.setModifiers(method.getModifiers() & ~(Modifier.NATIVE | Modifier.SYNCHRONIZED)); newMethod.setExceptionTypes(method.getExceptionTypes()); if (newMethod.getReturnType().equals(CtClass.voidType)) { if ((newMethod.getModifiers() & Modifier.PUBLIC) != 0) { newMethod.setBody("realObject." + method.getName() + "($$);"); } else { newMethod.setBody("{ java.lang.reflect.Method method = realClass.getDeclaredMethod(\"" + method.getName() + "\", $sig);" + "method.setAccessible(true);" + "method.invoke(this.realObject, $args); }"); } } else { if ((newMethod.getModifiers() & Modifier.PUBLIC) != 0) { newMethod.setBody("return realObject." + method.getName() + "($$);"); } else { newMethod.setBody("{ java.lang.reflect.Method method = realClass.getDeclaredMethod(\"" + method.getName() + "\", $sig);" + "method.setAccessible(true);" + "java.lang.Object retVal = method.invoke(realObject, $args);" + "return ($r) retVal; }"); } } if (hook != null) { hook.processMethod(newMethod); } cc.addMethod(newMethod); } Class cls = cc.toClass(); Constructor c = cls.getDeclaredConstructor(cls.getSuperclass(), Class.class); Object proxy = c.newInstance(realObject, realClass); for (Field field : realClass.getDeclaredFields()) { if ((field.getModifiers() & Modifier.STATIC) != 0) { continue; } if ((field.getModifiers() & Modifier.FINAL) != 0) { continue; } field.setAccessible(true); field.set(proxy, field.get(realObject)); } return proxy; }
Example 13
Source File: JpaAuditOperationsImpl.java From gvnix with GNU General Public License v3.0 | 4 votes |
/** * Create the class for entity which will hold the revision information for * Hibernate Envers * <p/> * This use {@link #REVISION_LOG_ENTITY_NAME} as class name and look for * <em>the first package which contains a entity</em> to place it. * */ public void installRevisonEntity(JavaType revisionEntity) { PathResolver pathResolver = projectOperations.getPathResolver(); JavaType target; if (revisionEntity == null) { target = generateRevionEntityJavaType(); } else { target = revisionEntity; } int modifier = Modifier.PUBLIC; final String declaredByMetadataId = PhysicalTypeIdentifier .createIdentifier(target, pathResolver.getFocusedPath(Path.SRC_MAIN_JAVA)); File targetFile = new File( typeLocationService .getPhysicalTypeCanonicalPath(declaredByMetadataId)); if (targetFile.exists()) { Validate.isTrue(!targetFile.exists(), "Type '%s' already exists", target); } // Prepare class builder final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder( declaredByMetadataId, modifier, target, PhysicalTypeCategory.CLASS); // Prepare annotations array List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>( 1); // Add @GvNIXJpaAuditListener annotation AnnotationMetadataBuilder jpaAuditRevEntAnn = new AnnotationMetadataBuilder( new JavaType(GvNIXJpaAuditRevisionEntity.class)); annotations.add(jpaAuditRevEntAnn); // Set annotations cidBuilder.setAnnotations(annotations); // Create Revision entity class typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build()); }
Example 14
Source File: ReflectUtil.java From jdk8u-jdk with GNU General Public License v2.0 | 4 votes |
public static void ensureMemberAccess(Class<?> currentClass, Class<?> memberClass, Object target, int modifiers) throws IllegalAccessException { if (target == null && Modifier.isProtected(modifiers)) { int mods = modifiers; mods = mods & (~Modifier.PROTECTED); mods = mods | Modifier.PUBLIC; /* * See if we fail because of class modifiers */ Reflection.ensureMemberAccess(currentClass, memberClass, target, mods); try { /* * We're still here so class access was ok. * Now try with default field access. */ mods = mods & (~Modifier.PUBLIC); Reflection.ensureMemberAccess(currentClass, memberClass, target, mods); /* * We're still here so access is ok without * checking for protected. */ return; } catch (IllegalAccessException e) { /* * Access failed but we're 'protected' so * if the test below succeeds then we're ok. */ if (isSubclassOf(currentClass, memberClass)) { return; } else { throw e; } } } else { Reflection.ensureMemberAccess(currentClass, memberClass, target, modifiers); } }
Example 15
Source File: EnversRevisionLogEntityMetadataBuilder.java From gvnix with GNU General Public License v3.0 | 4 votes |
private MethodMetadata getRevisionDate() { if (revsionDateGetter == null) { JavaSymbolName methodName = helper .getGetterMethodNameForField(REVISION_DATE_TRANSIENT_FIELD); // Define method parameter types List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>( 0); // Check if a method exist in type final MethodMetadata method = helper.methodExists(methodName, parameterTypes); if (method != null) { // If it already exists, just return the method return method; } // Define method annotations (none in this case) List<AnnotationMetadataBuilder> annotations = helper .toAnnotationMetadata(JpaJavaType.TRANSIENT); // Define method throws types (none in this case) List<JavaType> throwsTypes = new ArrayList<JavaType>(); // Define method parameter names (none in this case) List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>( 0); // Create the method body InvocableMemberBodyBuilder body = new InvocableMemberBodyBuilder(); // return new Date(this.timestamp); body.appendFormalLine(String.format("return new %s(this.%s);", helper.getFinalTypeName(JdkJavaType.DATE), TIMESTAMP_FIELD)); // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( context.getMetadataId(), Modifier.PUBLIC, methodName, JdkJavaType.DATE, parameterTypes, parameterNames, body); methodBuilder.setAnnotations(annotations); methodBuilder.setThrowsTypes(throwsTypes); revsionDateGetter = methodBuilder.build(); // Build and return a // MethodMetadata } return revsionDateGetter; }
Example 16
Source File: ReportMetadata.java From gvnix with GNU General Public License v3.0 | 4 votes |
/** * Add to the aspect the MethodMetadata of the generateReportForm method. It * uses AbstractMetadataItem.builder for add the new method. * * @param reportName * @param entity * @param reportMethods2 * @return */ private MethodMetadata addGenerateReportFormMethod(JavaType entity, String reportName, String reportFormats) { // Specify the desired method name JavaSymbolName methodName = new JavaSymbolName(generateMethodName( reportName, true)); // Define method parameter types List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); parameterTypes.add(new AnnotatedJavaType(MODEL_TYPE, new ArrayList<AnnotationMetadata>())); // Check if a method with the same signature already exists in the // target type MethodMetadata reportMethod = reportMethodExists(methodName); if (reportMethod != null) { // If it already exists, just return the method and omit its // generation via the ITD return reportMethod; } // Define method parameter names List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterNames.add(new JavaSymbolName("uiModel")); // Define method annotations List<AnnotationAttributeValue<?>> requestMappingAttributes = new ArrayList<AnnotationAttributeValue<?>>(); requestMappingAttributes.add(new StringAttributeValue( VALUE_SYMBOL_NAME, "/reports/".concat(reportName))); requestMappingAttributes.add(new StringAttributeValue( PARAMS_SYMBOL_NAME, "form")); requestMappingAttributes .add(new EnumAttributeValue(METHOD_SYMBOL_NAME, new EnumDetails(REQUEST_METHOD_TYPE, new JavaSymbolName("GET")))); AnnotationMetadataBuilder requestMapping = new AnnotationMetadataBuilder( REQUEST_MAPPING_TYPE, requestMappingAttributes); List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(requestMapping); // Create the method body InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); // Populate report_formats list for select String reportFormatsAsArray = getReportFormatsAsArray(reportFormats); bodyBuilder.appendFormalLine("String[] reportFormats = ".concat( reportFormatsAsArray).concat(";")); bodyBuilder .appendFormalLine("Collection<String> reportFormatsList = Arrays.asList(reportFormats);"); bodyBuilder .appendFormalLine("uiModel.addAttribute(\"report_formats\", reportFormatsList);"); // return the View bodyBuilder.appendFormalLine("return \"" .concat(annotationValues.getPath()).concat("/") .concat(reportName).concat("\";")); // ImportRegistrationResolver gives access to imports in the // Java/AspectJ source ImportRegistrationResolver irr = builder .getImportRegistrationResolver(); irr.addImport(new JavaType("java.util.Arrays")); irr.addImport(new JavaType("java.util.Collection")); // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.STRING, parameterTypes, parameterNames, bodyBuilder); methodBuilder.setAnnotations(annotations); reportMethod = methodBuilder.build(); builder.addMethod(reportMethod); controllerMethods.add(reportMethod); return reportMethod; }
Example 17
Source File: ObjectInputStream.java From hottub with GNU General Public License v2.0 | 3 votes |
/** * Returns a proxy class that implements the interfaces named in a proxy * class descriptor; subclasses may implement this method to read custom * data from the stream along with the descriptors for dynamic proxy * classes, allowing them to use an alternate loading mechanism for the * interfaces and the proxy class. * * <p>This method is called exactly once for each unique proxy class * descriptor in the stream. * * <p>The corresponding method in <code>ObjectOutputStream</code> is * <code>annotateProxyClass</code>. For a given subclass of * <code>ObjectInputStream</code> that overrides this method, the * <code>annotateProxyClass</code> method in the corresponding subclass of * <code>ObjectOutputStream</code> must write any data or objects read by * this method. * * <p>The default implementation of this method in * <code>ObjectInputStream</code> returns the result of calling * <code>Proxy.getProxyClass</code> with the list of <code>Class</code> * objects for the interfaces that are named in the <code>interfaces</code> * parameter. The <code>Class</code> object for each interface name * <code>i</code> is the value returned by calling * <pre> * Class.forName(i, false, loader) * </pre> * where <code>loader</code> is that of the first non-<code>null</code> * class loader up the execution stack, or <code>null</code> if no * non-<code>null</code> class loaders are on the stack (the same class * loader choice used by the <code>resolveClass</code> method). Unless any * of the resolved interfaces are non-public, this same value of * <code>loader</code> is also the class loader passed to * <code>Proxy.getProxyClass</code>; if non-public interfaces are present, * their class loader is passed instead (if more than one non-public * interface class loader is encountered, an * <code>IllegalAccessError</code> is thrown). * If <code>Proxy.getProxyClass</code> throws an * <code>IllegalArgumentException</code>, <code>resolveProxyClass</code> * will throw a <code>ClassNotFoundException</code> containing the * <code>IllegalArgumentException</code>. * * @param interfaces the list of interface names that were * deserialized in the proxy class descriptor * @return a proxy class for the specified interfaces * @throws IOException any exception thrown by the underlying * <code>InputStream</code> * @throws ClassNotFoundException if the proxy class or any of the * named interfaces could not be found * @see ObjectOutputStream#annotateProxyClass(Class) * @since 1.3 */ protected Class<?> resolveProxyClass(String[] interfaces) throws IOException, ClassNotFoundException { ClassLoader latestLoader = latestUserDefinedLoader(); ClassLoader nonPublicLoader = null; boolean hasNonPublicInterface = false; // define proxy in class loader of non-public interface(s), if any Class<?>[] classObjs = new Class<?>[interfaces.length]; for (int i = 0; i < interfaces.length; i++) { Class<?> cl = Class.forName(interfaces[i], false, latestLoader); if ((cl.getModifiers() & Modifier.PUBLIC) == 0) { if (hasNonPublicInterface) { if (nonPublicLoader != cl.getClassLoader()) { throw new IllegalAccessError( "conflicting non-public interface class loaders"); } } else { nonPublicLoader = cl.getClassLoader(); hasNonPublicInterface = true; } } classObjs[i] = cl; } try { return Proxy.getProxyClass( hasNonPublicInterface ? nonPublicLoader : latestLoader, classObjs); } catch (IllegalArgumentException e) { throw new ClassNotFoundException(null, e); } }
Example 18
Source File: ObjectInputStream.java From openjdk-8-source with GNU General Public License v2.0 | 3 votes |
/** * Returns a proxy class that implements the interfaces named in a proxy * class descriptor; subclasses may implement this method to read custom * data from the stream along with the descriptors for dynamic proxy * classes, allowing them to use an alternate loading mechanism for the * interfaces and the proxy class. * * <p>This method is called exactly once for each unique proxy class * descriptor in the stream. * * <p>The corresponding method in <code>ObjectOutputStream</code> is * <code>annotateProxyClass</code>. For a given subclass of * <code>ObjectInputStream</code> that overrides this method, the * <code>annotateProxyClass</code> method in the corresponding subclass of * <code>ObjectOutputStream</code> must write any data or objects read by * this method. * * <p>The default implementation of this method in * <code>ObjectInputStream</code> returns the result of calling * <code>Proxy.getProxyClass</code> with the list of <code>Class</code> * objects for the interfaces that are named in the <code>interfaces</code> * parameter. The <code>Class</code> object for each interface name * <code>i</code> is the value returned by calling * <pre> * Class.forName(i, false, loader) * </pre> * where <code>loader</code> is that of the first non-<code>null</code> * class loader up the execution stack, or <code>null</code> if no * non-<code>null</code> class loaders are on the stack (the same class * loader choice used by the <code>resolveClass</code> method). Unless any * of the resolved interfaces are non-public, this same value of * <code>loader</code> is also the class loader passed to * <code>Proxy.getProxyClass</code>; if non-public interfaces are present, * their class loader is passed instead (if more than one non-public * interface class loader is encountered, an * <code>IllegalAccessError</code> is thrown). * If <code>Proxy.getProxyClass</code> throws an * <code>IllegalArgumentException</code>, <code>resolveProxyClass</code> * will throw a <code>ClassNotFoundException</code> containing the * <code>IllegalArgumentException</code>. * * @param interfaces the list of interface names that were * deserialized in the proxy class descriptor * @return a proxy class for the specified interfaces * @throws IOException any exception thrown by the underlying * <code>InputStream</code> * @throws ClassNotFoundException if the proxy class or any of the * named interfaces could not be found * @see ObjectOutputStream#annotateProxyClass(Class) * @since 1.3 */ protected Class<?> resolveProxyClass(String[] interfaces) throws IOException, ClassNotFoundException { ClassLoader latestLoader = latestUserDefinedLoader(); ClassLoader nonPublicLoader = null; boolean hasNonPublicInterface = false; // define proxy in class loader of non-public interface(s), if any Class<?>[] classObjs = new Class<?>[interfaces.length]; for (int i = 0; i < interfaces.length; i++) { Class<?> cl = Class.forName(interfaces[i], false, latestLoader); if ((cl.getModifiers() & Modifier.PUBLIC) == 0) { if (hasNonPublicInterface) { if (nonPublicLoader != cl.getClassLoader()) { throw new IllegalAccessError( "conflicting non-public interface class loaders"); } } else { nonPublicLoader = cl.getClassLoader(); hasNonPublicInterface = true; } } classObjs[i] = cl; } try { return Proxy.getProxyClass( hasNonPublicInterface ? nonPublicLoader : latestLoader, classObjs); } catch (IllegalArgumentException e) { throw new ClassNotFoundException(null, e); } }
Example 19
Source File: ObjectInputStream.java From Java8CN with Apache License 2.0 | 3 votes |
/** * Returns a proxy class that implements the interfaces named in a proxy * class descriptor; subclasses may implement this method to read custom * data from the stream along with the descriptors for dynamic proxy * classes, allowing them to use an alternate loading mechanism for the * interfaces and the proxy class. * * <p>This method is called exactly once for each unique proxy class * descriptor in the stream. * * <p>The corresponding method in <code>ObjectOutputStream</code> is * <code>annotateProxyClass</code>. For a given subclass of * <code>ObjectInputStream</code> that overrides this method, the * <code>annotateProxyClass</code> method in the corresponding subclass of * <code>ObjectOutputStream</code> must write any data or objects read by * this method. * * <p>The default implementation of this method in * <code>ObjectInputStream</code> returns the result of calling * <code>Proxy.getProxyClass</code> with the list of <code>Class</code> * objects for the interfaces that are named in the <code>interfaces</code> * parameter. The <code>Class</code> object for each interface name * <code>i</code> is the value returned by calling * <pre> * Class.forName(i, false, loader) * </pre> * where <code>loader</code> is that of the first non-<code>null</code> * class loader up the execution stack, or <code>null</code> if no * non-<code>null</code> class loaders are on the stack (the same class * loader choice used by the <code>resolveClass</code> method). Unless any * of the resolved interfaces are non-public, this same value of * <code>loader</code> is also the class loader passed to * <code>Proxy.getProxyClass</code>; if non-public interfaces are present, * their class loader is passed instead (if more than one non-public * interface class loader is encountered, an * <code>IllegalAccessError</code> is thrown). * If <code>Proxy.getProxyClass</code> throws an * <code>IllegalArgumentException</code>, <code>resolveProxyClass</code> * will throw a <code>ClassNotFoundException</code> containing the * <code>IllegalArgumentException</code>. * * @param interfaces the list of interface names that were * deserialized in the proxy class descriptor * @return a proxy class for the specified interfaces * @throws IOException any exception thrown by the underlying * <code>InputStream</code> * @throws ClassNotFoundException if the proxy class or any of the * named interfaces could not be found * @see ObjectOutputStream#annotateProxyClass(Class) * @since 1.3 */ protected Class<?> resolveProxyClass(String[] interfaces) throws IOException, ClassNotFoundException { ClassLoader latestLoader = latestUserDefinedLoader(); ClassLoader nonPublicLoader = null; boolean hasNonPublicInterface = false; // define proxy in class loader of non-public interface(s), if any Class<?>[] classObjs = new Class<?>[interfaces.length]; for (int i = 0; i < interfaces.length; i++) { Class<?> cl = Class.forName(interfaces[i], false, latestLoader); if ((cl.getModifiers() & Modifier.PUBLIC) == 0) { if (hasNonPublicInterface) { if (nonPublicLoader != cl.getClassLoader()) { throw new IllegalAccessError( "conflicting non-public interface class loaders"); } } else { nonPublicLoader = cl.getClassLoader(); hasNonPublicInterface = true; } } classObjs[i] = cl; } try { return Proxy.getProxyClass( hasNonPublicInterface ? nonPublicLoader : latestLoader, classObjs); } catch (IllegalArgumentException e) { throw new ClassNotFoundException(null, e); } }
Example 20
Source File: MetaMethod.java From groovy with Apache License 2.0 | 2 votes |
/** * Checks the compatibility between two modifier masks. Checks that they are equal * with regards to access and static modifier. * * @return true if the modifiers are compatible */ private static boolean compatibleModifiers(int modifiersA, int modifiersB) { int mask = Modifier.PRIVATE | Modifier.PROTECTED | Modifier.PUBLIC | Modifier.STATIC; return (modifiersA & mask) == (modifiersB & mask); }