1berry/openjdk
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

7007535: (reflect) Please generalize Constructor and Method

Browse Source 
Reviewed-by: mduigou, peterjones, dholmes, andrew
This commit is contained in:
Joe Darcy 2011-07-19 17:45:11 -07:00
parent 2b42b78393
commit f106ea9ed6
3 changed files with 587 additions and 527 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

312
jdk/src/share/classes/java/lang/reflect/Constructor.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -27,13 +27,12 @@ package java.lang.reflect;
import sun.reflect.ConstructorAccessor; import sun.reflect.ConstructorAccessor;
import sun.reflect.Reflection; import sun.reflect.Reflection;
import sun.reflect.annotation.AnnotationParser;
import sun.reflect.generics.repository.ConstructorRepository; import sun.reflect.generics.repository.ConstructorRepository;
import sun.reflect.generics.factory.CoreReflectionFactory; import sun.reflect.generics.factory.CoreReflectionFactory;
import sun.reflect.generics.factory.GenericsFactory; import sun.reflect.generics.factory.GenericsFactory;
import sun.reflect.generics.scope.ConstructorScope; import sun.reflect.generics.scope.ConstructorScope;
import java.lang.annotation.Annotation; import java.lang.annotation.Annotation;
import java.util.Map;
import sun.reflect.annotation.AnnotationParser;
import java.lang.annotation.AnnotationFormatError; import java.lang.annotation.AnnotationFormatError;
import java.lang.reflect.Modifier; import java.lang.reflect.Modifier;
@ -57,11 +56,7 @@ import java.lang.reflect.Modifier;
* @author Kenneth Russell * @author Kenneth Russell
* @author Nakul Saraiya * @author Nakul Saraiya
*/ */
public final public final class Constructor<T> extends Executable {
class Constructor<T> extends AccessibleObject implements
GenericDeclaration,
Member {
private Class<T> clazz; private Class<T> clazz;
private int slot; private int slot;
private Class<?>[] parameterTypes; private Class<?>[] parameterTypes;
@ -82,7 +77,8 @@ public final
} }
// Accessor for generic info repository // Accessor for generic info repository
private ConstructorRepository getGenericInfo() { @Override
ConstructorRepository getGenericInfo() {
// lazily initialize repository if necessary // lazily initialize repository if necessary
if (genericInfo == null) { if (genericInfo == null) {
// create and cache generic info repository // create and cache generic info repository
@ -111,8 +107,7 @@ public final
int slot, int slot,
String signature, String signature,
byte[] annotations, byte[] annotations,
byte[] parameterAnnotations) byte[] parameterAnnotations) {
{
this.clazz = declaringClass; this.clazz = declaringClass;
this.parameterTypes = parameterTypes; this.parameterTypes = parameterTypes;
this.exceptionTypes = checkedExceptions; this.exceptionTypes = checkedExceptions;
@ -148,10 +143,20 @@ public final
return res; return res;
} }
@Override
boolean hasGenericInformation() {
return (getSignature() != null);
}
@Override
byte[] getAnnotationBytes() {
return annotations;
}
/** /**
* Returns the {@code Class} object representing the class that declares * {@inheritDoc}
* the constructor represented by this {@code Constructor} object.
*/ */
@Override
public Class<T> getDeclaringClass() { public Class<T> getDeclaringClass() {
return clazz; return clazz;
} }
@ -160,36 +165,25 @@ public final
* Returns the name of this constructor, as a string. This is * Returns the name of this constructor, as a string. This is
* the binary name of the constructor's declaring class. * the binary name of the constructor's declaring class.
*/ */
@Override
public String getName() { public String getName() {
return getDeclaringClass().getName(); return getDeclaringClass().getName();
} }
/** /**
* Returns the Java language modifiers for the constructor * {@inheritDoc}
* represented by this {@code Constructor} object, as an integer. The
* {@code Modifier} class should be used to decode the modifiers.
*
* @see Modifier
*/ */
@Override
public int getModifiers() { public int getModifiers() {
return modifiers; return modifiers;
} }
/** /**
* Returns an array of {@code TypeVariable} objects that represent the * {@inheritDoc}
* type variables declared by the generic declaration represented by this * @throws GenericSignatureFormatError {@inheritDoc}
* {@code GenericDeclaration} object, in declaration order. Returns an
* array of length 0 if the underlying generic declaration declares no type
* variables.
*
* @return an array of {@code TypeVariable} objects that represent
* the type variables declared by this generic declaration
* @throws GenericSignatureFormatError if the generic
* signature of this generic declaration does not conform to
* the format specified in
* <cite>The Java&trade; Virtual Machine Specification</cite>
* @since 1.5 * @since 1.5
*/ */
@Override
public TypeVariable<Constructor<T>>[] getTypeParameters() { public TypeVariable<Constructor<T>>[] getTypeParameters() {
if (getSignature() != null) { if (getSignature() != null) {
return (TypeVariable<Constructor<T>>[])getGenericInfo().getTypeParameters(); return (TypeVariable<Constructor<T>>[])getGenericInfo().getTypeParameters();
@ -199,97 +193,44 @@ public final
/** /**
* Returns an array of {@code Class} objects that represent the formal * {@inheritDoc}
* parameter types, in declaration order, of the constructor
* represented by this {@code Constructor} object. Returns an array of
* length 0 if the underlying constructor takes no parameters.
*
* @return the parameter types for the constructor this object
* represents
*/ */
@Override
public Class<?>[] getParameterTypes() { public Class<?>[] getParameterTypes() {
return (Class<?>[]) parameterTypes.clone(); return (Class<?>[]) parameterTypes.clone();
} }
/** /**
* Returns an array of {@code Type} objects that represent the formal * {@inheritDoc}
* parameter types, in declaration order, of the method represented by * @throws GenericSignatureFormatError {@inheritDoc}
* this {@code Constructor} object. Returns an array of length 0 if the * @throws TypeNotPresentException {@inheritDoc}
* underlying method takes no parameters. * @throws MalformedParameterizedTypeException {@inheritDoc}
*
* <p>If a formal parameter type is a parameterized type,
* the {@code Type} object returned for it must accurately reflect
* the actual type parameters used in the source code.
*
* <p>If a formal parameter type is a type variable or a parameterized
* type, it is created. Otherwise, it is resolved.
*
* @return an array of {@code Type}s that represent the formal
* parameter types of the underlying method, in declaration order
* @throws GenericSignatureFormatError
* if the generic method signature does not conform to the format
* specified in
* <cite>The Java&trade; Virtual Machine Specification</cite>
* @throws TypeNotPresentException if any of the parameter
* types of the underlying method refers to a non-existent type
* declaration
* @throws MalformedParameterizedTypeException if any of
* the underlying method's parameter types refer to a parameterized
* type that cannot be instantiated for any reason
* @since 1.5 * @since 1.5
*/ */
@Override
public Type[] getGenericParameterTypes() { public Type[] getGenericParameterTypes() {
if (getSignature() != null) return super.getGenericParameterTypes();
return getGenericInfo().getParameterTypes();
else
return getParameterTypes();
} }
/** /**
* Returns an array of {@code Class} objects that represent the types * {@inheritDoc}
* of exceptions declared to be thrown by the underlying constructor
* represented by this {@code Constructor} object. Returns an array of
* length 0 if the constructor declares no exceptions in its {@code throws} clause.
*
* @return the exception types declared as being thrown by the
* constructor this object represents
*/ */
@Override
public Class<?>[] getExceptionTypes() { public Class<?>[] getExceptionTypes() {
return (Class<?>[])exceptionTypes.clone(); return (Class<?>[])exceptionTypes.clone();
} }
/** /**
* Returns an array of {@code Type} objects that represent the * {@inheritDoc}
* exceptions declared to be thrown by this {@code Constructor} object. * @throws GenericSignatureFormatError {@inheritDoc}
* Returns an array of length 0 if the underlying method declares * @throws TypeNotPresentException {@inheritDoc}
* no exceptions in its {@code throws} clause. * @throws MalformedParameterizedTypeException {@inheritDoc}
*
* <p>If an exception type is a type variable or a parameterized
* type, it is created. Otherwise, it is resolved.
*
* @return an array of Types that represent the exception types
* thrown by the underlying method
* @throws GenericSignatureFormatError
* if the generic method signature does not conform to the format
* specified in
* <cite>The Java&trade; Virtual Machine Specification</cite>
* @throws TypeNotPresentException if the underlying method's
* {@code throws} clause refers to a non-existent type declaration
* @throws MalformedParameterizedTypeException if
* the underlying method's {@code throws} clause refers to a
* parameterized type that cannot be instantiated for any reason
* @since 1.5 * @since 1.5
*/ */
@Override
public Type[] getGenericExceptionTypes() { public Type[] getGenericExceptionTypes() {
Type[] result; return super.getGenericExceptionTypes();
if (getSignature() != null &&
( (result = getGenericInfo().getExceptionTypes()).length > 0 ))
return result;
else
return getExceptionTypes();
} }
/** /**
@ -302,16 +243,7 @@ public final
if (obj != null && obj instanceof Constructor) { if (obj != null && obj instanceof Constructor) {
Constructor<?> other = (Constructor<?>)obj; Constructor<?> other = (Constructor<?>)obj;
if (getDeclaringClass() == other.getDeclaringClass()) { if (getDeclaringClass() == other.getDeclaringClass()) {
/* Avoid unnecessary cloning */ return equalParamTypes(parameterTypes, other.parameterTypes);
Class<?>[] params1 = parameterTypes;
Class<?>[] params2 = other.parameterTypes;
if (params1.length == params2.length) {
for (int i = 0; i < params1.length; i++) {
if (params1[i] != params2[i])
return false;
}
return true;
}
} }
} }
return false; return false;
@ -342,34 +274,14 @@ public final
* constructor has default (package) access. * constructor has default (package) access.
*/ */
public String toString() { public String toString() {
try { return sharedToString(Modifier.constructorModifiers(),
StringBuffer sb = new StringBuffer(); parameterTypes,
int mod = getModifiers() & Modifier.constructorModifiers(); exceptionTypes);
if (mod != 0) {
sb.append(Modifier.toString(mod) + " ");
} }
@Override
void specificToStringHeader(StringBuilder sb) {
sb.append(Field.getTypeName(getDeclaringClass())); sb.append(Field.getTypeName(getDeclaringClass()));
sb.append("(");
Class<?>[] params = parameterTypes; // avoid clone
for (int j = 0; j < params.length; j++) {
sb.append(Field.getTypeName(params[j]));
if (j < (params.length - 1))
sb.append(",");
}
sb.append(")");
Class<?>[] exceptions = exceptionTypes; // avoid clone
if (exceptions.length > 0) {
sb.append(" throws ");
for (int k = 0; k < exceptions.length; k++) {
sb.append(exceptions[k].getName());
if (k < (exceptions.length - 1))
sb.append(",");
}
}
return sb.toString();
} catch (Exception e) {
return "<" + e + ">";
}
} }
/** /**
@ -405,56 +317,14 @@ public final
* *
* @since 1.5 * @since 1.5
*/ */
@Override
public String toGenericString() { public String toGenericString() {
try { return sharedToGenericString(Modifier.constructorModifiers());
StringBuilder sb = new StringBuilder();
int mod = getModifiers() & Modifier.constructorModifiers();
if (mod != 0) {
sb.append(Modifier.toString(mod) + " ");
}
TypeVariable<?>[] typeparms = getTypeParameters();
if (typeparms.length > 0) {
boolean first = true;
sb.append("<");
for(TypeVariable<?> typeparm: typeparms) {
if (!first)
sb.append(",");
// Class objects can't occur here; no need to test
// and call Class.getName().
sb.append(typeparm.toString());
first = false;
}
sb.append("> ");
}
sb.append(Field.getTypeName(getDeclaringClass()));
sb.append("(");
Type[] params = getGenericParameterTypes();
for (int j = 0; j < params.length; j++) {
String param = (params[j] instanceof Class<?>)?
Field.getTypeName((Class<?>)params[j]):
(params[j].toString());
if (isVarArgs() && (j == params.length - 1)) // replace T[] with T...
param = param.replaceFirst("\\[\\]$", "...");
sb.append(param);
if (j < (params.length - 1))
sb.append(",");
}
sb.append(")");
Type[] exceptions = getGenericExceptionTypes();
if (exceptions.length > 0) {
sb.append(" throws ");
for (int k = 0; k < exceptions.length; k++) {
sb.append((exceptions[k] instanceof Class)?
((Class<?>)exceptions[k]).getName():
exceptions[k].toString());
if (k < (exceptions.length - 1))
sb.append(",");
}
}
return sb.toString();
} catch (Exception e) {
return "<" + e + ">";
} }
@Override
void specificToGenericStringHeader(StringBuilder sb) {
specificToStringHeader(sb);
} }
/** /**
@ -526,29 +396,21 @@ public final
} }
/** /**
* Returns {@code true} if this constructor was declared to take * {@inheritDoc}
* a variable number of arguments; returns {@code false}
* otherwise.
*
* @return {@code true} if an only if this constructor was declared to
* take a variable number of arguments.
* @since 1.5 * @since 1.5
*/ */
@Override
public boolean isVarArgs() { public boolean isVarArgs() {
return (getModifiers() & Modifier.VARARGS) != 0; return super.isVarArgs();
} }
/** /**
* Returns {@code true} if this constructor is a synthetic * {@inheritDoc}
* constructor; returns {@code false} otherwise.
*
* @return true if and only if this constructor is a synthetic
* constructor as defined by
* <cite>The Java&trade; Language Specification</cite>.
* @since 1.5 * @since 1.5
*/ */
@Override
public boolean isSynthetic() { public boolean isSynthetic() {
return Modifier.isSynthetic(getModifiers()); return super.isSynthetic();
} }
// NOTE that there is no synchronization used here. It is correct // NOTE that there is no synchronization used here. It is correct
@ -604,80 +466,50 @@ public final
return parameterAnnotations; return parameterAnnotations;
} }
/** /**
* {@inheritDoc}
* @throws NullPointerException {@inheritDoc} * @throws NullPointerException {@inheritDoc}
* @since 1.5 * @since 1.5
*/ */
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) { public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
if (annotationClass == null) return super.getAnnotation(annotationClass);
throw new NullPointerException();
return (T) declaredAnnotations().get(annotationClass);
} }
/** /**
* {@inheritDoc}
* @since 1.5 * @since 1.5
*/ */
public Annotation[] getDeclaredAnnotations() { public Annotation[] getDeclaredAnnotations() {
return AnnotationParser.toArray(declaredAnnotations()); return super.getDeclaredAnnotations();
}
private transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
private synchronized Map<Class<? extends Annotation>, Annotation> declaredAnnotations() {
if (declaredAnnotations == null) {
declaredAnnotations = AnnotationParser.parseAnnotations(
annotations, sun.misc.SharedSecrets.getJavaLangAccess().
getConstantPool(getDeclaringClass()),
getDeclaringClass());
}
return declaredAnnotations;
} }
/** /**
* Returns an array of arrays that represent the annotations on the formal * {@inheritDoc}
* parameters, in declaration order, of the method represented by
* this {@code Constructor} object. (Returns an array of length zero if the
* underlying method is parameterless. If the method has one or more
* parameters, a nested array of length zero is returned for each parameter
* with no annotations.) The annotation objects contained in the returned
* arrays are serializable. The caller of this method is free to modify
* the returned arrays; it will have no effect on the arrays returned to
* other callers.
*
* @return an array of arrays that represent the annotations on the formal
* parameters, in declaration order, of the method represented by this
* Constructor object
* @since 1.5 * @since 1.5
*/ */
@Override
public Annotation[][] getParameterAnnotations() { public Annotation[][] getParameterAnnotations() {
int numParameters = parameterTypes.length; return sharedGetParameterAnnotations(parameterTypes, parameterAnnotations);
if (parameterAnnotations == null) }
return new Annotation[numParameters][0];
Annotation[][] result = AnnotationParser.parseParameterAnnotations( @Override
parameterAnnotations, void handleParameterNumberMismatch(int resultLength, int numParameters) {
sun.misc.SharedSecrets.getJavaLangAccess().
getConstantPool(getDeclaringClass()),
getDeclaringClass());
if (result.length != numParameters) {
Class<?> declaringClass = getDeclaringClass(); Class<?> declaringClass = getDeclaringClass();
if (declaringClass.isEnum() || if (declaringClass.isEnum() ||
declaringClass.isAnonymousClass() || declaringClass.isAnonymousClass() ||
declaringClass.isLocalClass() ) declaringClass.isLocalClass() )
; // Can't do reliable parameter counting return ; // Can't do reliable parameter counting
else { else {
if (!declaringClass.isMemberClass() || // top-level if (!declaringClass.isMemberClass() || // top-level
// Check for the enclosing instance parameter for // Check for the enclosing instance parameter for
// non-static member classes // non-static member classes
(declaringClass.isMemberClass() && (declaringClass.isMemberClass() &&
((declaringClass.getModifiers() & Modifier.STATIC) == 0) && ((declaringClass.getModifiers() & Modifier.STATIC) == 0) &&
result.length + 1 != numParameters) ) { resultLength + 1 != numParameters) ) {
throw new AnnotationFormatError( throw new AnnotationFormatError(
"Parameter annotations don't match number of parameters"); "Parameter annotations don't match number of parameters");
} }
} }
} }
return result;
}
} }

394
jdk/src/share/classes/java/lang/reflect/Executable.java Normal file
View File

@ -0,0 +1,394 @@
/*
* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.lang.reflect;
import java.lang.annotation.*;
import java.util.Map;
import sun.reflect.annotation.AnnotationParser;
import sun.reflect.generics.repository.ConstructorRepository;
import sun.reflect.generics.factory.CoreReflectionFactory;
import sun.reflect.generics.factory.GenericsFactory;
import sun.reflect.generics.scope.ConstructorScope;
/**
* A shared superclass for the common functionality of {@link Method}
* and {@link Constructor}.
*
* @since 1.8
*/
public abstract class Executable extends AccessibleObject
implements Member, GenericDeclaration {
/*
* Only grant package-visibility to the constructor.
*/
Executable() {}
/**
* Accessor method to allow code sharing
*/
abstract byte[] getAnnotationBytes();
/**
* Does the Executable have generic information.
*/
abstract boolean hasGenericInformation();
abstract ConstructorRepository getGenericInfo();
boolean equalParamTypes(Class<?>[] params1, Class<?>[] params2) {
/* Avoid unnecessary cloning */
if (params1.length == params2.length) {
for (int i = 0; i < params1.length; i++) {
if (params1[i] != params2[i])
return false;
}
}
return true;
}
Annotation[][] parseParameterAnnotations(byte[] parameterAnnotations) {
return AnnotationParser.parseParameterAnnotations(
parameterAnnotations,
sun.misc.SharedSecrets.getJavaLangAccess().
getConstantPool(getDeclaringClass()),
getDeclaringClass());
}
void separateWithCommas(Class<?>[] types, StringBuilder sb) {
for (int j = 0; j < types.length; j++) {
sb.append(Field.getTypeName(types[j]));
if (j < (types.length - 1))
sb.append(",");
}
}
void printModifiersIfNonzero(StringBuilder sb, int mask) {
int mod = getModifiers() & mask;
if (mod != 0) {
sb.append(Modifier.toString(mod)).append(' ');
}
}
String sharedToString(int modifierMask,
Class<?>[] parameterTypes,
Class<?>[] exceptionTypes) {
try {
StringBuilder sb = new StringBuilder();
printModifiersIfNonzero(sb, modifierMask);
specificToStringHeader(sb);
sb.append('(');
separateWithCommas(parameterTypes, sb);
sb.append(')');
if (exceptionTypes.length > 0) {
sb.append(" throws ");
separateWithCommas(exceptionTypes, sb);
}
return sb.toString();
} catch (Exception e) {
return "<" + e + ">";
}
}
/**
* Generate toString header information specific to a method or
* constructor.
*/
abstract void specificToStringHeader(StringBuilder sb);
String sharedToGenericString(int modifierMask) {
try {
StringBuilder sb = new StringBuilder();
printModifiersIfNonzero(sb, modifierMask);
TypeVariable<?>[] typeparms = getTypeParameters();
if (typeparms.length > 0) {
boolean first = true;
sb.append('<');
for(TypeVariable<?> typeparm: typeparms) {
if (!first)
sb.append(',');
// Class objects can't occur here; no need to test
// and call Class.getName().
sb.append(typeparm.toString());
first = false;
}
sb.append("> ");
}
specificToGenericStringHeader(sb);
sb.append('(');
Type[] params = getGenericParameterTypes();
for (int j = 0; j < params.length; j++) {
String param = (params[j] instanceof Class)?
Field.getTypeName((Class)params[j]):
(params[j].toString());
if (isVarArgs() && (j == params.length - 1)) // replace T[] with T...
param = param.replaceFirst("\\[\\]$", "...");
sb.append(param);
if (j < (params.length - 1))
sb.append(',');
}
sb.append(')');
Type[] exceptions = getGenericExceptionTypes();
if (exceptions.length > 0) {
sb.append(" throws ");
for (int k = 0; k < exceptions.length; k++) {
sb.append((exceptions[k] instanceof Class)?
((Class)exceptions[k]).getName():
exceptions[k].toString());
if (k < (exceptions.length - 1))
sb.append(',');
}
}
return sb.toString();
} catch (Exception e) {
return "<" + e + ">";
}
}
/**
* Generate toGenericString header information specific to a
* method or constructor.
*/
abstract void specificToGenericStringHeader(StringBuilder sb);
/**
* Returns the {@code Class} object representing the class or interface
* that declares the method represented by this executable object.
*/
public abstract Class<?> getDeclaringClass();
/**
* Returns the name of the executable represented by this object.
*/
public abstract String getName();
/**
* Returns the Java language {@linkplain Modifier modifiers} for
* the executable represented by this object.
*/
public abstract int getModifiers();
/**
* Returns an array of {@code TypeVariable} objects that represent the
* type variables declared by the generic declaration represented by this
* {@code GenericDeclaration} object, in declaration order. Returns an
* array of length 0 if the underlying generic declaration declares no type
* variables.
*
* @return an array of {@code TypeVariable} objects that represent
* the type variables declared by this generic declaration
* @throws GenericSignatureFormatError if the generic
* signature of this generic declaration does not conform to
* the format specified in
* <cite>The Java&trade; Virtual Machine Specification</cite>
*/
public abstract TypeVariable<?>[] getTypeParameters();
/**
* Returns an array of {@code Class} objects that represent the formal
* parameter types, in declaration order, of the executable
* represented by this object. Returns an array of length
* 0 if the underlying method takes no parameters.
*
* @return the parameter types for the method this object
* represents
*/
public abstract Class<?>[] getParameterTypes();
/**
* Returns an array of {@code Type} objects that represent the formal
* parameter types, in declaration order, of the method represented by
* this executable object. Returns an array of length 0 if the
* underlying method takes no parameters.
*
* <p>If a formal parameter type is a parameterized type,
* the {@code Type} object returned for it must accurately reflect
* the actual type parameters used in the source code.
*
* <p>If a formal parameter type is a type variable or a parameterized
* type, it is created. Otherwise, it is resolved.
*
* @return an array of {@code Type}s that represent the formal
* parameter types of the underlying method, in declaration order
* @throws GenericSignatureFormatError
* if the generic method signature does not conform to the format
* specified in
* <cite>The Java&trade; Virtual Machine Specification</cite>
* @throws TypeNotPresentException if any of the parameter
* types of the underlying method refers to a non-existent type
* declaration
* @throws MalformedParameterizedTypeException if any of
* the underlying method's parameter types refer to a parameterized
* type that cannot be instantiated for any reason
*/
public Type[] getGenericParameterTypes() {
if (hasGenericInformation())
return getGenericInfo().getParameterTypes();
else
return getParameterTypes();
}
/**
* Returns an array of {@code Class} objects that represent the
* types of exceptions declared to be thrown by the underlying
* executable represented by this object. Returns an array of
* length 0 if the executable declares no exceptions in its {@code
* throws} clause.
*
* @return the exception types declared as being thrown by the
* executable this object represents
*/
public abstract Class<?>[] getExceptionTypes();
/**
* Returns an array of {@code Type} objects that represent the
* exceptions declared to be thrown by this executable object.
* Returns an array of length 0 if the underlying executable declares
* no exceptions in its {@code throws} clause.
*
* <p>If an exception type is a type variable or a parameterized
* type, it is created. Otherwise, it is resolved.
*
* @return an array of Types that represent the exception types
* thrown by the underlying method
* @throws GenericSignatureFormatError
* if the generic method signature does not conform to the format
* specified in
* <cite>The Java&trade; Virtual Machine Specification</cite>
* @throws TypeNotPresentException if the underlying method's
* {@code throws} clause refers to a non-existent type declaration
* @throws MalformedParameterizedTypeException if
* the underlying method's {@code throws} clause refers to a
* parameterized type that cannot be instantiated for any reason
*/
public Type[] getGenericExceptionTypes() {
Type[] result;
if (hasGenericInformation() &&
((result = getGenericInfo().getExceptionTypes()).length > 0))
return result;
else
return getExceptionTypes();
}
/**
* Returns a string describing this {@code Executable}, including
* any type parameters.
*/
public abstract String toGenericString();
/**
* Returns {@code true} if this executable was declared to take a
* variable number of arguments; returns {@code false} otherwise.
*
* @return {@code true} if an only if this executable was declared
* to take a variable number of arguments.
*/
public boolean isVarArgs() {
return (getModifiers() & Modifier.VARARGS) != 0;
}
/**
* Returns {@code true} if this executable is a synthetic
* construct; returns {@code false} otherwise.
*
* @return true if and only if this executable is a synthetic
* construct as defined by
* <cite>The Java&trade; Language Specification</cite>.
*/
public boolean isSynthetic() {
return Modifier.isSynthetic(getModifiers());
}
/**
* Returns an array of arrays that represent the annotations on
* the formal parameters, in declaration order, of the executable
* represented by this object. (Returns an array of length zero if
* the underlying method is parameterless. If the executable has
* one or more parameters, a nested array of length zero is
* returned for each parameter with no annotations.) The
* annotation objects contained in the returned arrays are
* serializable. The caller of this method is free to modify the
* returned arrays; it will have no effect on the arrays returned
* to other callers.
*
* @return an array of arrays that represent the annotations on the formal
* parameters, in declaration order, of the exectuable represented by this
* object
*/
public abstract Annotation[][] getParameterAnnotations();
Annotation[][] sharedGetParameterAnnotations(Class<?>[] parameterTypes,
byte[] parameterAnnotations) {
int numParameters = parameterTypes.length;
if (parameterAnnotations == null)
return new Annotation[numParameters][0];
Annotation[][] result = parseParameterAnnotations(parameterAnnotations);
if (result.length != numParameters)
handleParameterNumberMismatch(result.length, numParameters);
return result;
}
abstract void handleParameterNumberMismatch(int resultLength, int numParameters);
/**
* {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
if (annotationClass == null)
throw new NullPointerException();
return (T) declaredAnnotations().get(annotationClass);
}
/**
* {@inheritDoc}
*/
public Annotation[] getDeclaredAnnotations() {
return AnnotationParser.toArray(declaredAnnotations());
}
private transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
private synchronized Map<Class<? extends Annotation>, Annotation> declaredAnnotations() {
if (declaredAnnotations == null) {
declaredAnnotations = AnnotationParser.parseAnnotations(
getAnnotationBytes(),
sun.misc.SharedSecrets.getJavaLangAccess().
getConstantPool(getDeclaringClass()),
getDeclaringClass());
}
return declaredAnnotations;
}
}

334
jdk/src/share/classes/java/lang/reflect/Method.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -36,7 +36,6 @@ import sun.reflect.annotation.AnnotationParser;
import java.lang.annotation.Annotation; import java.lang.annotation.Annotation;
import java.lang.annotation.AnnotationFormatError; import java.lang.annotation.AnnotationFormatError;
import java.nio.ByteBuffer; import java.nio.ByteBuffer;
import java.util.Map;
/** /**
* A {@code Method} provides information about, and access to, a single method * A {@code Method} provides information about, and access to, a single method
@ -58,9 +57,7 @@ import java.util.Map;
* @author Kenneth Russell * @author Kenneth Russell
* @author Nakul Saraiya * @author Nakul Saraiya
*/ */
public final public final class Method extends Executable {
class Method extends AccessibleObject implements GenericDeclaration,
Member {
private Class<?> clazz; private Class<?> clazz;
private int slot; private int slot;
// This is guaranteed to be interned by the VM in the 1.4 // This is guaranteed to be interned by the VM in the 1.4
@ -83,8 +80,8 @@ public final
// potentially many Method objects pointing to it.) // potentially many Method objects pointing to it.)
private Method root; private Method root;
// Generics infrastructure
// Generics infrastructure
private String getGenericSignature() {return signature;} private String getGenericSignature() {return signature;}
// Accessor for factory // Accessor for factory
@ -94,7 +91,8 @@ public final
} }
// Accessor for generic info repository // Accessor for generic info repository
private MethodRepository getGenericInfo() { @Override
MethodRepository getGenericInfo() {
// lazily initialize repository if necessary // lazily initialize repository if necessary
if (genericInfo == null) { if (genericInfo == null) {
// create and cache generic info repository // create and cache generic info repository
@ -119,8 +117,7 @@ public final
String signature, String signature,
byte[] annotations, byte[] annotations,
byte[] parameterAnnotations, byte[] parameterAnnotations,
byte[] annotationDefault) byte[] annotationDefault) {
{
this.clazz = declaringClass; this.clazz = declaringClass;
this.name = name; this.name = name;
this.parameterTypes = parameterTypes; this.parameterTypes = parameterTypes;
@ -156,10 +153,20 @@ public final
return res; return res;
} }
@Override
boolean hasGenericInformation() {
return (getGenericSignature() != null);
}
@Override
byte[] getAnnotationBytes() {
return annotations;
}
/** /**
* Returns the {@code Class} object representing the class or interface * {@inheritDoc}
* that declares the method represented by this {@code Method} object.
*/ */
@Override
public Class<?> getDeclaringClass() { public Class<?> getDeclaringClass() {
return clazz; return clazz;
} }
@ -168,36 +175,25 @@ public final
* Returns the name of the method represented by this {@code Method} * Returns the name of the method represented by this {@code Method}
* object, as a {@code String}. * object, as a {@code String}.
*/ */
@Override
public String getName() { public String getName() {
return name; return name;
} }
/** /**
* Returns the Java language modifiers for the method represented * {@inheritDoc}
* by this {@code Method} object, as an integer. The {@code Modifier} class should
* be used to decode the modifiers.
*
* @see Modifier
*/ */
@Override
public int getModifiers() { public int getModifiers() {
return modifiers; return modifiers;
} }
/** /**
* Returns an array of {@code TypeVariable} objects that represent the * {@inheritDoc}
* type variables declared by the generic declaration represented by this * @throws GenericSignatureFormatError {@inheritDoc}
* {@code GenericDeclaration} object, in declaration order. Returns an
* array of length 0 if the underlying generic declaration declares no type
* variables.
*
* @return an array of {@code TypeVariable} objects that represent
* the type variables declared by this generic declaration
* @throws GenericSignatureFormatError if the generic
* signature of this generic declaration does not conform to
* the format specified in
* <cite>The Java&trade; Virtual Machine Specification</cite>
* @since 1.5 * @since 1.5
*/ */
@Override
public TypeVariable<Method>[] getTypeParameters() { public TypeVariable<Method>[] getTypeParameters() {
if (getGenericSignature() != null) if (getGenericSignature() != null)
return (TypeVariable<Method>[])getGenericInfo().getTypeParameters(); return (TypeVariable<Method>[])getGenericInfo().getTypeParameters();
@ -245,98 +241,44 @@ public final
} else { return getReturnType();} } else { return getReturnType();}
} }
/** /**
* Returns an array of {@code Class} objects that represent the formal * {@inheritDoc}
* parameter types, in declaration order, of the method
* represented by this {@code Method} object. Returns an array of length
* 0 if the underlying method takes no parameters.
*
* @return the parameter types for the method this object
* represents
*/ */
@Override
public Class<?>[] getParameterTypes() { public Class<?>[] getParameterTypes() {
return (Class<?>[]) parameterTypes.clone(); return (Class<?>[]) parameterTypes.clone();
} }
/** /**
* Returns an array of {@code Type} objects that represent the formal * {@inheritDoc}
* parameter types, in declaration order, of the method represented by * @throws GenericSignatureFormatError {@inheritDoc}
* this {@code Method} object. Returns an array of length 0 if the * @throws TypeNotPresentException {@inheritDoc}
* underlying method takes no parameters. * @throws MalformedParameterizedTypeException {@inheritDoc}
*
* <p>If a formal parameter type is a parameterized type,
* the {@code Type} object returned for it must accurately reflect
* the actual type parameters used in the source code.
*
* <p>If a formal parameter type is a type variable or a parameterized
* type, it is created. Otherwise, it is resolved.
*
* @return an array of Types that represent the formal
* parameter types of the underlying method, in declaration order
* @throws GenericSignatureFormatError
* if the generic method signature does not conform to the format
* specified in
* <cite>The Java&trade; Virtual Machine Specification</cite>
* @throws TypeNotPresentException if any of the parameter
* types of the underlying method refers to a non-existent type
* declaration
* @throws MalformedParameterizedTypeException if any of
* the underlying method's parameter types refer to a parameterized
* type that cannot be instantiated for any reason
* @since 1.5 * @since 1.5
*/ */
@Override
public Type[] getGenericParameterTypes() { public Type[] getGenericParameterTypes() {
if (getGenericSignature() != null) return super.getGenericParameterTypes();
return getGenericInfo().getParameterTypes();
else
return getParameterTypes();
} }
/** /**
* Returns an array of {@code Class} objects that represent * {@inheritDoc}
* the types of the exceptions declared to be thrown
* by the underlying method
* represented by this {@code Method} object. Returns an array of length
* 0 if the method declares no exceptions in its {@code throws} clause.
*
* @return the exception types declared as being thrown by the
* method this object represents
*/ */
@Override
public Class<?>[] getExceptionTypes() { public Class<?>[] getExceptionTypes() {
return (Class<?>[]) exceptionTypes.clone(); return (Class<?>[]) exceptionTypes.clone();
} }
/** /**
* Returns an array of {@code Type} objects that represent the * {@inheritDoc}
* exceptions declared to be thrown by this {@code Method} object. * @throws GenericSignatureFormatError {@inheritDoc}
* Returns an array of length 0 if the underlying method declares * @throws TypeNotPresentException {@inheritDoc}
* no exceptions in its {@code throws} clause. * @throws MalformedParameterizedTypeException {@inheritDoc}
*
* <p>If an exception type is a type variable or a parameterized
* type, it is created. Otherwise, it is resolved.
*
* @return an array of Types that represent the exception types
* thrown by the underlying method
* @throws GenericSignatureFormatError
* if the generic method signature does not conform to the format
* specified in
* <cite>The Java&trade; Virtual Machine Specification</cite>
* @throws TypeNotPresentException if the underlying method's
* {@code throws} clause refers to a non-existent type declaration
* @throws MalformedParameterizedTypeException if
* the underlying method's {@code throws} clause refers to a
* parameterized type that cannot be instantiated for any reason
* @since 1.5 * @since 1.5
*/ */
@Override
public Type[] getGenericExceptionTypes() { public Type[] getGenericExceptionTypes() {
Type[] result; return super.getGenericExceptionTypes();
if (getGenericSignature() != null &&
((result = getGenericInfo().getExceptionTypes()).length > 0))
return result;
else
return getExceptionTypes();
} }
/** /**
@ -352,16 +294,7 @@ public final
&& (getName() == other.getName())) { && (getName() == other.getName())) {
if (!returnType.equals(other.getReturnType())) if (!returnType.equals(other.getReturnType()))
return false; return false;
/* Avoid unnecessary cloning */ return equalParamTypes(parameterTypes, other.parameterTypes);
Class<?>[] params1 = parameterTypes;
Class<?>[] params2 = other.parameterTypes;
if (params1.length == params2.length) {
for (int i = 0; i < params1.length; i++) {
if (params1[i] != params2[i])
return false;
}
return true;
}
} }
} }
return false; return false;
@ -399,35 +332,16 @@ public final
* {@code synchronized}, {@code native}, {@code strictfp}. * {@code synchronized}, {@code native}, {@code strictfp}.
*/ */
public String toString() { public String toString() {
try { return sharedToString(Modifier.methodModifiers(),
StringBuilder sb = new StringBuilder(); parameterTypes,
int mod = getModifiers() & Modifier.methodModifiers(); exceptionTypes);
if (mod != 0) {
sb.append(Modifier.toString(mod)).append(' ');
} }
@Override
void specificToStringHeader(StringBuilder sb) {
sb.append(Field.getTypeName(getReturnType())).append(' '); sb.append(Field.getTypeName(getReturnType())).append(' ');
sb.append(Field.getTypeName(getDeclaringClass())).append('.'); sb.append(Field.getTypeName(getDeclaringClass())).append('.');
sb.append(getName()).append('('); sb.append(getName());
Class<?>[] params = parameterTypes; // avoid clone
for (int j = 0; j < params.length; j++) {
sb.append(Field.getTypeName(params[j]));
if (j < (params.length - 1))
sb.append(',');
}
sb.append(')');
Class<?>[] exceptions = exceptionTypes; // avoid clone
if (exceptions.length > 0) {
sb.append(" throws ");
for (int k = 0; k < exceptions.length; k++) {
sb.append(exceptions[k].getName());
if (k < (exceptions.length - 1))
sb.append(',');
}
}
return sb.toString();
} catch (Exception e) {
return "<" + e + ">";
}
} }
/** /**
@ -468,62 +382,20 @@ public final
* *
* @since 1.5 * @since 1.5
*/ */
@Override
public String toGenericString() { public String toGenericString() {
try { return sharedToGenericString(Modifier.methodModifiers());
StringBuilder sb = new StringBuilder();
int mod = getModifiers() & Modifier.methodModifiers();
if (mod != 0) {
sb.append(Modifier.toString(mod)).append(' ');
}
TypeVariable<?>[] typeparms = getTypeParameters();
if (typeparms.length > 0) {
boolean first = true;
sb.append('<');
for(TypeVariable<?> typeparm: typeparms) {
if (!first)
sb.append(',');
// Class objects can't occur here; no need to test
// and call Class.getName().
sb.append(typeparm.toString());
first = false;
}
sb.append("> ");
} }
@Override
void specificToGenericStringHeader(StringBuilder sb) {
Type genRetType = getGenericReturnType(); Type genRetType = getGenericReturnType();
sb.append( ((genRetType instanceof Class<?>)? sb.append( ((genRetType instanceof Class<?>)?
Field.getTypeName((Class<?>)genRetType):genRetType.toString())) Field.getTypeName((Class<?>)genRetType):genRetType.toString()))
.append(' '); .append(' ');
sb.append(Field.getTypeName(getDeclaringClass())).append('.'); sb.append(Field.getTypeName(getDeclaringClass())).append('.');
sb.append(getName()).append('('); sb.append(getName());
Type[] params = getGenericParameterTypes();
for (int j = 0; j < params.length; j++) {
String param = (params[j] instanceof Class)?
Field.getTypeName((Class)params[j]):
(params[j].toString());
if (isVarArgs() && (j == params.length - 1)) // replace T[] with T...
param = param.replaceFirst("\\[\\]$", "...");
sb.append(param);
if (j < (params.length - 1))
sb.append(',');
}
sb.append(')');
Type[] exceptions = getGenericExceptionTypes();
if (exceptions.length > 0) {
sb.append(" throws ");
for (int k = 0; k < exceptions.length; k++) {
sb.append((exceptions[k] instanceof Class)?
((Class)exceptions[k]).getName():
exceptions[k].toString());
if (k < (exceptions.length - 1))
sb.append(',');
}
}
return sb.toString();
} catch (Exception e) {
return "<" + e + ">";
}
} }
/** /**
@ -614,28 +486,21 @@ public final
} }
/** /**
* Returns {@code true} if this method was declared to take * {@inheritDoc}
* a variable number of arguments; returns {@code false}
* otherwise.
*
* @return {@code true} if an only if this method was declared to
* take a variable number of arguments.
* @since 1.5 * @since 1.5
*/ */
@Override
public boolean isVarArgs() { public boolean isVarArgs() {
return (getModifiers() & Modifier.VARARGS) != 0; return super.isVarArgs();
} }
/** /**
* Returns {@code true} if this method is a synthetic * {@inheritDoc}
* method; returns {@code false} otherwise.
*
* @return true if and only if this method is a synthetic
* method as defined by the Java Language Specification.
* @since 1.5 * @since 1.5
*/ */
@Override
public boolean isSynthetic() { public boolean isSynthetic() {
return Modifier.isSynthetic(getModifiers()); return super.isSynthetic();
} }
// NOTE that there is no synchronization used here. It is correct // NOTE that there is no synchronization used here. It is correct
@ -674,36 +539,6 @@ public final
} }
} }
/**
* @throws NullPointerException {@inheritDoc}
* @since 1.5
*/
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
if (annotationClass == null)
throw new NullPointerException();
return (T) declaredAnnotations().get(annotationClass);
}
/**
* @since 1.5
*/
public Annotation[] getDeclaredAnnotations() {
return AnnotationParser.toArray(declaredAnnotations());
}
private transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
private synchronized Map<Class<? extends Annotation>, Annotation> declaredAnnotations() {
if (declaredAnnotations == null) {
declaredAnnotations = AnnotationParser.parseAnnotations(
annotations, sun.misc.SharedSecrets.getJavaLangAccess().
getConstantPool(getDeclaringClass()),
getDeclaringClass());
}
return declaredAnnotations;
}
/** /**
* Returns the default value for the annotation member represented by * Returns the default value for the annotation member represented by
* this {@code Method} instance. If the member is of a primitive type, * this {@code Method} instance. If the member is of a primitive type,
@ -734,34 +569,33 @@ public final
} }
/** /**
* Returns an array of arrays that represent the annotations on the formal * {@inheritDoc}
* parameters, in declaration order, of the method represented by * @throws NullPointerException {@inheritDoc}
* this {@code Method} object. (Returns an array of length zero if the
* underlying method is parameterless. If the method has one or more
* parameters, a nested array of length zero is returned for each parameter
* with no annotations.) The annotation objects contained in the returned
* arrays are serializable. The caller of this method is free to modify
* the returned arrays; it will have no effect on the arrays returned to
* other callers.
*
* @return an array of arrays that represent the annotations on the formal
* parameters, in declaration order, of the method represented by this
* Method object
* @since 1.5 * @since 1.5
*/ */
public Annotation[][] getParameterAnnotations() { public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
int numParameters = parameterTypes.length; return super.getAnnotation(annotationClass);
if (parameterAnnotations == null) }
return new Annotation[numParameters][0];
Annotation[][] result = AnnotationParser.parseParameterAnnotations( /**
parameterAnnotations, * {@inheritDoc}
sun.misc.SharedSecrets.getJavaLangAccess(). * @since 1.5
getConstantPool(getDeclaringClass()), */
getDeclaringClass()); public Annotation[] getDeclaredAnnotations() {
if (result.length != numParameters) return super.getDeclaredAnnotations();
throw new java.lang.annotation.AnnotationFormatError( }
"Parameter annotations don't match number of parameters");
return result; /**
* {@inheritDoc}
* @since 1.5
*/
@Override
public Annotation[][] getParameterAnnotations() {
return sharedGetParameterAnnotations(parameterTypes, parameterAnnotations);
}
@Override
void handleParameterNumberMismatch(int resultLength, int numParameters) {
throw new AnnotationFormatError("Parameter annotations don't match number of parameters");
} }
} }