1 /* 2 * Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package sun.reflect.annotation; 27 28 import java.io.ObjectInputStream; 29 import java.lang.annotation.*; 30 import java.lang.reflect.*; 31 import java.io.Serializable; 32 import java.util.*; 33 import java.util.stream.*; 34 import java.security.AccessController; 35 import java.security.PrivilegedAction; 36 37 /** 38 * InvocationHandler for dynamic proxy implementation of Annotation. 39 * 40 * @author Josh Bloch 41 * @since 1.5 42 */ 43 class AnnotationInvocationHandler implements InvocationHandler, Serializable { 44 private static final long serialVersionUID = 6182022883658399397L; 45 private final Class<? extends Annotation> type; 46 private final Map<String, Object> memberValues; 47 48 AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) { 49 Class<?>[] superInterfaces = type.getInterfaces(); 50 if (!type.isAnnotation() || 51 superInterfaces.length != 1 || 52 superInterfaces[0] != java.lang.annotation.Annotation.class) 53 throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type."); 54 this.type = type; 55 this.memberValues = memberValues; 56 } 57 58 public Object invoke(Object proxy, Method method, Object[] args) { 59 String member = method.getName(); 60 Class<?>[] paramTypes = method.getParameterTypes(); 61 62 // Handle Object and Annotation methods 63 if (member.equals("equals") && paramTypes.length == 1 && 64 paramTypes[0] == Object.class) 65 return equalsImpl(proxy, args[0]); 66 if (paramTypes.length != 0) 67 throw new AssertionError("Too many parameters for an annotation method"); 68 69 switch(member) { 70 case "toString": 71 return toStringImpl(); 72 case "hashCode": 73 return hashCodeImpl(); 74 case "annotationType": 75 return type; 76 } 77 78 // Handle annotation member accessors 79 Object result = memberValues.get(member); 80 81 if (result == null) 82 throw new IncompleteAnnotationException(type, member); 83 84 if (result instanceof ExceptionProxy) 85 throw ((ExceptionProxy) result).generateException(); 86 87 if (result.getClass().isArray() && Array.getLength(result) != 0) 88 result = cloneArray(result); 89 90 return result; 91 } 92 93 /** 94 * This method, which clones its array argument, would not be necessary 95 * if Cloneable had a public clone method. 96 */ 97 private Object cloneArray(Object array) { 98 Class<?> type = array.getClass(); 99 100 if (type == byte[].class) { 101 byte[] byteArray = (byte[])array; 102 return byteArray.clone(); 103 } 104 if (type == char[].class) { 105 char[] charArray = (char[])array; 106 return charArray.clone(); 107 } 108 if (type == double[].class) { 109 double[] doubleArray = (double[])array; 110 return doubleArray.clone(); 111 } 112 if (type == float[].class) { 113 float[] floatArray = (float[])array; 114 return floatArray.clone(); 115 } 116 if (type == int[].class) { 117 int[] intArray = (int[])array; 118 return intArray.clone(); 119 } 120 if (type == long[].class) { 121 long[] longArray = (long[])array; 122 return longArray.clone(); 123 } 124 if (type == short[].class) { 125 short[] shortArray = (short[])array; 126 return shortArray.clone(); 127 } 128 if (type == boolean[].class) { 129 boolean[] booleanArray = (boolean[])array; 130 return booleanArray.clone(); 131 } 132 133 Object[] objectArray = (Object[])array; 134 return objectArray.clone(); 135 } 136 137 138 /** 139 * Implementation of dynamicProxy.toString() 140 */ 141 private String toStringImpl() { 142 StringBuilder result = new StringBuilder(128); 143 result.append('@'); 144 result.append(type.getName()); 145 result.append('('); 146 boolean firstMember = true; 147 for (Map.Entry<String, Object> e : memberValues.entrySet()) { 148 if (firstMember) 149 firstMember = false; 150 else 151 result.append(", "); 152 153 result.append(e.getKey()); 154 result.append('='); 155 result.append(memberValueToString(e.getValue())); 156 } 157 result.append(')'); 158 return result.toString(); 159 } 160 161 /** 162 * Translates a member value (in "dynamic proxy return form") into a string. 163 */ 164 private static String memberValueToString(Object value) { 165 Class<?> type = value.getClass(); 166 if (!type.isArray()) { 167 // primitive value, string, class, enum const, or annotation 168 if (type == Class.class) 169 return toSourceString((Class<?>) value); 170 else if (type == String.class) 171 return toSourceString((String) value); 172 if (type == Character.class) 173 return toSourceString((char) value); 174 else if (type == Double.class) 175 return toSourceString((double) value); 176 else if (type == Float.class) 177 return toSourceString((float) value); 178 else if (type == Long.class) 179 return toSourceString((long) value); 180 else 181 return value.toString(); 182 } else { 183 Stream<String> stringStream; 184 if (type == byte[].class) 185 stringStream = convert((byte[]) value); 186 else if (type == char[].class) 187 stringStream = convert((char[]) value); 188 else if (type == double[].class) 189 stringStream = DoubleStream.of((double[]) value) 190 .mapToObj(AnnotationInvocationHandler::toSourceString); 191 else if (type == float[].class) 192 stringStream = convert((float[]) value); 193 else if (type == int[].class) 194 stringStream = IntStream.of((int[]) value).mapToObj(String::valueOf); 195 else if (type == long[].class) { 196 stringStream = LongStream.of((long[]) value) 197 .mapToObj(AnnotationInvocationHandler::toSourceString); 198 } else if (type == short[].class) 199 stringStream = convert((short[]) value); 200 else if (type == boolean[].class) 201 stringStream = convert((boolean[]) value); 202 else if (type == Class[].class) 203 stringStream = 204 Arrays.stream((Class<?>[]) value). 205 map(AnnotationInvocationHandler::toSourceString); 206 else if (type == String[].class) 207 stringStream = 208 Arrays.stream((String[])value). 209 map(AnnotationInvocationHandler::toSourceString); 210 else 211 stringStream = Arrays.stream((Object[])value).map(Objects::toString); 212 213 return stringStreamToString(stringStream); 214 } 215 } 216 217 /** 218 * Translates a Class value to a form suitable for use in the 219 * string representation of an annotation. 220 */ 221 private static String toSourceString(Class<?> clazz) { 222 Class<?> finalComponent = clazz; 223 StringBuilder arrayBackets = new StringBuilder(); 224 225 while(finalComponent.isArray()) { 226 finalComponent = finalComponent.getComponentType(); 227 arrayBackets.append("[]"); 228 } 229 230 return finalComponent.getName() + arrayBackets.toString() + ".class" ; 231 } 232 233 private static String toSourceString(float f) { 234 if (Float.isFinite(f)) 235 return Float.toString(f) + "f" ; 236 else { 237 if (Float.isInfinite(f)) { 238 return (f < 0.0f) ? "-1.0f/0.0f": "1.0f/0.0f"; 239 } else 240 return "0.0f/0.0f"; 241 } 242 } 243 244 private static String toSourceString(double d) { 245 if (Double.isFinite(d)) 246 return Double.toString(d); 247 else { 248 if (Double.isInfinite(d)) { 249 return (d < 0.0f) ? "-1.0/0.0": "1.0/0.0"; 250 } else 251 return "0.0/0.0"; 252 } 253 } 254 255 private static String toSourceString(char c) { 256 StringBuilder sb = new StringBuilder(4); 257 sb.append('\''); 258 if (c == '\'') 259 sb.append("\\'"); 260 else 261 sb.append(c); 262 return sb.append('\'') 263 .toString(); 264 } 265 266 private static String toSourceString(long ell) { 267 String str = String.valueOf(ell); 268 return (ell < Integer.MIN_VALUE || ell > Integer.MAX_VALUE) 269 ? (str + 'L') : str; 270 } 271 272 /** 273 * Return a string suitable for use in the string representation 274 * of an annotation. 275 */ 276 private static String toSourceString(String s) { 277 StringBuilder sb = new StringBuilder(); 278 sb.append('"'); 279 // Escape embedded quote characters, if present, but don't do 280 // anything more heroic. 281 sb.append(s.replace("\"", "\\\"")); 282 sb.append('"'); 283 return sb.toString(); 284 } 285 286 private static Stream<String> convert(byte[] values) { 287 List<String> list = new ArrayList<>(values.length); 288 for (byte b : values) 289 list.add(Byte.toString(b)); 290 return list.stream(); 291 } 292 293 private static Stream<String> convert(char[] values) { 294 List<String> list = new ArrayList<>(values.length); 295 for (char c : values) 296 list.add(toSourceString(c)); 297 return list.stream(); 298 } 299 300 private static Stream<String> convert(float[] values) { 301 List<String> list = new ArrayList<>(values.length); 302 for (float f : values) { 303 list.add(toSourceString(f)); 304 } 305 return list.stream(); 306 } 307 308 private static Stream<String> convert(short[] values) { 309 List<String> list = new ArrayList<>(values.length); 310 for (short s : values) 311 list.add(Short.toString(s)); 312 return list.stream(); 313 } 314 315 private static Stream<String> convert(boolean[] values) { 316 List<String> list = new ArrayList<>(values.length); 317 for (boolean b : values) 318 list.add(Boolean.toString(b)); 319 return list.stream(); 320 } 321 322 private static String stringStreamToString(Stream<String> stream) { 323 return stream.collect(Collectors.joining(", ", "{", "}")); 324 } 325 326 /** 327 * Implementation of dynamicProxy.equals(Object o) 328 */ 329 private Boolean equalsImpl(Object proxy, Object o) { 330 if (o == proxy) 331 return true; 332 333 if (!type.isInstance(o)) 334 return false; 335 for (Method memberMethod : getMemberMethods()) { 336 String member = memberMethod.getName(); 337 Object ourValue = memberValues.get(member); 338 Object hisValue = null; 339 AnnotationInvocationHandler hisHandler = asOneOfUs(o); 340 if (hisHandler != null) { 341 hisValue = hisHandler.memberValues.get(member); 342 } else { 343 try { 344 hisValue = memberMethod.invoke(o); 345 } catch (InvocationTargetException e) { 346 return false; 347 } catch (IllegalAccessException e) { 348 throw new AssertionError(e); 349 } 350 } 351 if (!memberValueEquals(ourValue, hisValue)) 352 return false; 353 } 354 return true; 355 } 356 357 /** 358 * Returns an object's invocation handler if that object is a dynamic 359 * proxy with a handler of type AnnotationInvocationHandler. 360 * Returns null otherwise. 361 */ 362 private AnnotationInvocationHandler asOneOfUs(Object o) { 363 if (Proxy.isProxyClass(o.getClass())) { 364 InvocationHandler handler = Proxy.getInvocationHandler(o); 365 if (handler instanceof AnnotationInvocationHandler) 366 return (AnnotationInvocationHandler) handler; 367 } 368 return null; 369 } 370 371 /** 372 * Returns true iff the two member values in "dynamic proxy return form" 373 * are equal using the appropriate equality function depending on the 374 * member type. The two values will be of the same type unless one of 375 * the containing annotations is ill-formed. If one of the containing 376 * annotations is ill-formed, this method will return false unless the 377 * two members are identical object references. 378 */ 379 private static boolean memberValueEquals(Object v1, Object v2) { 380 Class<?> type = v1.getClass(); 381 382 // Check for primitive, string, class, enum const, annotation, 383 // or ExceptionProxy 384 if (!type.isArray()) 385 return v1.equals(v2); 386 387 // Check for array of string, class, enum const, annotation, 388 // or ExceptionProxy 389 if (v1 instanceof Object[] && v2 instanceof Object[]) 390 return Arrays.equals((Object[]) v1, (Object[]) v2); 391 392 // Check for ill formed annotation(s) 393 if (v2.getClass() != type) 394 return false; 395 396 // Deal with array of primitives 397 if (type == byte[].class) 398 return Arrays.equals((byte[]) v1, (byte[]) v2); 399 if (type == char[].class) 400 return Arrays.equals((char[]) v1, (char[]) v2); 401 if (type == double[].class) 402 return Arrays.equals((double[]) v1, (double[]) v2); 403 if (type == float[].class) 404 return Arrays.equals((float[]) v1, (float[]) v2); 405 if (type == int[].class) 406 return Arrays.equals((int[]) v1, (int[]) v2); 407 if (type == long[].class) 408 return Arrays.equals((long[]) v1, (long[]) v2); 409 if (type == short[].class) 410 return Arrays.equals((short[]) v1, (short[]) v2); 411 assert type == boolean[].class; 412 return Arrays.equals((boolean[]) v1, (boolean[]) v2); 413 } 414 415 /** 416 * Returns the member methods for our annotation type. These are 417 * obtained lazily and cached, as they're expensive to obtain 418 * and we only need them if our equals method is invoked (which should 419 * be rare). 420 */ 421 private Method[] getMemberMethods() { 422 Method[] value = memberMethods; 423 if (value == null) { 424 value = computeMemberMethods(); 425 memberMethods = value; 426 } 427 return value; 428 } 429 430 private Method[] computeMemberMethods() { 431 return AccessController.doPrivileged( 432 new PrivilegedAction<Method[]>() { 433 public Method[] run() { 434 final Method[] methods = type.getDeclaredMethods(); 435 validateAnnotationMethods(methods); 436 AccessibleObject.setAccessible(methods, true); 437 return methods; 438 }}); 439 } 440 441 private transient volatile Method[] memberMethods; 442 443 /** 444 * Validates that a method is structurally appropriate for an 445 * annotation type. As of Java SE 8, annotation types cannot 446 * contain static methods and the declared methods of an 447 * annotation type must take zero arguments and there are 448 * restrictions on the return type. 449 */ 450 private void validateAnnotationMethods(Method[] memberMethods) { 451 /* 452 * Specification citations below are from JLS 453 * 9.6.1. Annotation Type Elements 454 */ 455 boolean valid = true; 456 for(Method method : memberMethods) { 457 /* 458 * "By virtue of the AnnotationTypeElementDeclaration 459 * production, a method declaration in an annotation type 460 * declaration cannot have formal parameters, type 461 * parameters, or a throws clause. 462 * 463 * "By virtue of the AnnotationTypeElementModifier 464 * production, a method declaration in an annotation type 465 * declaration cannot be default or static." 466 */ 467 if (method.getModifiers() != (Modifier.PUBLIC | Modifier.ABSTRACT) || 468 method.isDefault() || 469 method.getParameterCount() != 0 || 470 method.getExceptionTypes().length != 0) { 471 valid = false; 472 break; 473 } 474 475 /* 476 * "It is a compile-time error if the return type of a 477 * method declared in an annotation type is not one of the 478 * following: a primitive type, String, Class, any 479 * parameterized invocation of Class, an enum type 480 * (section 8.9), an annotation type, or an array type 481 * (chapter 10) whose element type is one of the preceding 482 * types." 483 */ 484 Class<?> returnType = method.getReturnType(); 485 if (returnType.isArray()) { 486 returnType = returnType.getComponentType(); 487 if (returnType.isArray()) { // Only single dimensional arrays 488 valid = false; 489 break; 490 } 491 } 492 493 if (!((returnType.isPrimitive() && returnType != void.class) || 494 returnType == java.lang.String.class || 495 returnType == java.lang.Class.class || 496 returnType.isEnum() || 497 returnType.isAnnotation())) { 498 valid = false; 499 break; 500 } 501 502 /* 503 * "It is a compile-time error if any method declared in an 504 * annotation type has a signature that is 505 * override-equivalent to that of any public or protected 506 * method declared in class Object or in the interface 507 * java.lang.annotation.Annotation." 508 * 509 * The methods in Object or Annotation meeting the other 510 * criteria (no arguments, contrained return type, etc.) 511 * above are: 512 * 513 * String toString() 514 * int hashCode() 515 * Class<? extends Annotation> annotationType() 516 */ 517 String methodName = method.getName(); 518 if ((methodName.equals("toString") && returnType == java.lang.String.class) || 519 (methodName.equals("hashCode") && returnType == int.class) || 520 (methodName.equals("annotationType") && returnType == java.lang.Class.class)) { 521 valid = false; 522 break; 523 } 524 } 525 if (valid) 526 return; 527 else 528 throw new AnnotationFormatError("Malformed method on an annotation type"); 529 } 530 531 /** 532 * Implementation of dynamicProxy.hashCode() 533 */ 534 private int hashCodeImpl() { 535 int result = 0; 536 for (Map.Entry<String, Object> e : memberValues.entrySet()) { 537 result += (127 * e.getKey().hashCode()) ^ 538 memberValueHashCode(e.getValue()); 539 } 540 return result; 541 } 542 543 /** 544 * Computes hashCode of a member value (in "dynamic proxy return form") 545 */ 546 private static int memberValueHashCode(Object value) { 547 Class<?> type = value.getClass(); 548 if (!type.isArray()) // primitive, string, class, enum const, 549 // or annotation 550 return value.hashCode(); 551 552 if (type == byte[].class) 553 return Arrays.hashCode((byte[]) value); 554 if (type == char[].class) 555 return Arrays.hashCode((char[]) value); 556 if (type == double[].class) 557 return Arrays.hashCode((double[]) value); 558 if (type == float[].class) 559 return Arrays.hashCode((float[]) value); 560 if (type == int[].class) 561 return Arrays.hashCode((int[]) value); 562 if (type == long[].class) 563 return Arrays.hashCode((long[]) value); 564 if (type == short[].class) 565 return Arrays.hashCode((short[]) value); 566 if (type == boolean[].class) 567 return Arrays.hashCode((boolean[]) value); 568 return Arrays.hashCode((Object[]) value); 569 } 570 571 private void readObject(java.io.ObjectInputStream s) 572 throws java.io.IOException, ClassNotFoundException { 573 ObjectInputStream.GetField fields = s.readFields(); 574 575 @SuppressWarnings("unchecked") 576 Class<? extends Annotation> t = (Class<? extends Annotation>)fields.get("type", null); 577 @SuppressWarnings("unchecked") 578 Map<String, Object> streamVals = (Map<String, Object>)fields.get("memberValues", null); 579 580 // Check to make sure that types have not evolved incompatibly 581 582 AnnotationType annotationType = null; 583 try { 584 annotationType = AnnotationType.getInstance(t); 585 } catch(IllegalArgumentException e) { 586 // Class is no longer an annotation type; time to punch out 587 throw new java.io.InvalidObjectException("Non-annotation type in annotation serial stream"); 588 } 589 590 Map<String, Class<?>> memberTypes = annotationType.memberTypes(); 591 // consistent with runtime Map type 592 Map<String, Object> mv = new LinkedHashMap<>(); 593 594 // If there are annotation members without values, that 595 // situation is handled by the invoke method. 596 for (Map.Entry<String, Object> memberValue : streamVals.entrySet()) { 597 String name = memberValue.getKey(); 598 Object value = null; 599 Class<?> memberType = memberTypes.get(name); 600 if (memberType != null) { // i.e. member still exists 601 value = memberValue.getValue(); 602 if (!(memberType.isInstance(value) || 603 value instanceof ExceptionProxy)) { 604 value = new AnnotationTypeMismatchExceptionProxy( 605 value.getClass() + "[" + value + "]").setMember( 606 annotationType.members().get(name)); 607 } 608 } 609 mv.put(name, value); 610 } 611 612 UnsafeAccessor.setType(this, t); 613 UnsafeAccessor.setMemberValues(this, mv); 614 } 615 616 private static class UnsafeAccessor { 617 private static final jdk.internal.misc.Unsafe unsafe; 618 private static final long typeOffset; 619 private static final long memberValuesOffset; 620 static { 621 try { 622 unsafe = jdk.internal.misc.Unsafe.getUnsafe(); 623 typeOffset = unsafe.objectFieldOffset 624 (AnnotationInvocationHandler.class.getDeclaredField("type")); 625 memberValuesOffset = unsafe.objectFieldOffset 626 (AnnotationInvocationHandler.class.getDeclaredField("memberValues")); 627 } catch (Exception ex) { 628 throw new ExceptionInInitializerError(ex); 629 } 630 } 631 static void setType(AnnotationInvocationHandler o, 632 Class<? extends Annotation> type) { 633 unsafe.putObject(o, typeOffset, type); 634 } 635 636 static void setMemberValues(AnnotationInvocationHandler o, 637 Map<String, Object> memberValues) { 638 unsafe.putObject(o, memberValuesOffset, memberValues); 639 } 640 } 641 }