jdk-sandbox: comparison jdk/src/share/classes/java/lang/reflect/Method.java

equal deleted inserted replaced

-:fa0ffd6693db
+:e92fcf58f684
 // For sharing of MethodAccessors. This branching structure is
 // currently only two levels deep (i.e., one root Method and
 // potentially many Method objects pointing to it.)
 private Method              root;
-// More complicated security check cache needed here than for
-// Class.newInstance() and Constructor.newInstance()
-private Class<?> securityCheckCache;
-private Class<?> securityCheckTargetClassCache;
 // Generics infrastructure
 private String getGenericSignature() {return signature;}
 // Accessor for factory
 * {@code abstract}, {@code static}, {@code final},
 * {@code synchronized}, {@code native}, {@code strictfp}.
 */
 public String toString() {
 try {
-StringBuffer sb = new StringBuffer();
+StringBuilder sb = new StringBuilder();
 int mod = getModifiers() & Modifier.methodModifiers();
 if (mod != 0) {
-sb.append(Modifier.toString(mod) + " ");
+sb.append(Modifier.toString(mod)).append(' ');
 }
-sb.append(Field.getTypeName(getReturnType()) + " ");
+sb.append(Field.getTypeName(getReturnType())).append(' ');
-sb.append(Field.getTypeName(getDeclaringClass()) + ".");
+sb.append(Field.getTypeName(getDeclaringClass())).append('.');
-sb.append(getName() + "(");
+sb.append(getName()).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(',');
 }
-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(",");
+sb.append(',');
 }
 }
 return sb.toString();
 } catch (Exception e) {
 return "<" + e + ">";
 public String toGenericString() {
 try {
 StringBuilder sb = new StringBuilder();
 int mod = getModifiers() & Modifier.methodModifiers();
 if (mod != 0) {
-sb.append(Modifier.toString(mod) + " ");
+sb.append(Modifier.toString(mod)).append(' ');
 }
 TypeVariable<?>[] typeparms = getTypeParameters();
 if (typeparms.length > 0) {
 boolean first = true;
-sb.append("<");
+sb.append('<');
 for(TypeVariable<?> typeparm: typeparms) {
 if (!first)
-sb.append(",");
+sb.append(',');
 // Class objects can't occur here; no need to test
 // and call Class.getName().
 sb.append(typeparm.toString());
 first = false;
 }
 sb.append("> ");
 }
 Type genRetType = getGenericReturnType();
 sb.append( ((genRetType instanceof Class<?>)?
-Field.getTypeName((Class<?>)genRetType):genRetType.toString())  + " ");
+Field.getTypeName((Class<?>)genRetType):genRetType.toString()))
+.append(' ');
-sb.append(Field.getTypeName(getDeclaringClass()) + ".");
-sb.append(getName() + "(");
+sb.append(Field.getTypeName(getDeclaringClass())).append('.');
+sb.append(getName()).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(',');
 }
-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(",");
+sb.append(',');
 }
 }
 return sb.toString();
 } catch (Exception e) {
 return "<" + e + ">";
 InvocationTargetException
 {
 if (!override) {
 if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
 Class<?> caller = Reflection.getCallerClass(1);
-Class<?> targetClass = ((obj == null || !Modifier.isProtected(modifiers))
-? clazz
+checkAccess(caller, clazz, obj, modifiers);
-: obj.getClass());
+}
+}
-boolean cached;
+MethodAccessor ma = methodAccessor;             // read volatile
-synchronized (this) {
+if (ma == null) {
-cached = (securityCheckCache == caller)
+ma = acquireMethodAccessor();
-&& (securityCheckTargetClassCache == targetClass);
+}
-}
+return ma.invoke(obj, args);
-if (!cached) {
-Reflection.ensureMemberAccess(caller, clazz, obj, modifiers);
-synchronized (this) {
-securityCheckCache = caller;
-securityCheckTargetClassCache = targetClass;
-}
-}
-}
-}
-if (methodAccessor == null) acquireMethodAccessor();
-return methodAccessor.invoke(obj, args);
 }
 /**
 * Returns {@code true} if this method is a bridge
 * method; returns {@code false} otherwise.
 // NOTE that there is no synchronization used here. It is correct
 // (though not efficient) to generate more than one MethodAccessor
 // for a given Method. However, avoiding synchronization will
 // probably make the implementation more scalable.
-private void acquireMethodAccessor() {
+private MethodAccessor acquireMethodAccessor() {
 // First check to see if one has been created yet, and take it
 // if so
 MethodAccessor tmp = null;
 if (root != null) tmp = root.getMethodAccessor();
 if (tmp != null) {
 methodAccessor = tmp;
-return;
+} else {
-}
+// Otherwise fabricate one and propagate it up to the root
-// Otherwise fabricate one and propagate it up to the root
+tmp = reflectionFactory.newMethodAccessor(this);
-tmp = reflectionFactory.newMethodAccessor(this);
+setMethodAccessor(tmp);
-setMethodAccessor(tmp);
+}
+return tmp;
 }
 // Returns MethodAccessor for this Method object, not looking up
 // the chain to the root
 MethodAccessor getMethodAccessor() {

changeset 9029	e92fcf58f684
parent 9022	b2e8758b10fd
child 9266	121fb370f179