AnnotationLiteral.java
/*
* Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0, which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the
* Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
* version 2 with the GNU Classpath Exception, which is available at
* https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
*/
package org.glassfish.jersey.internal.inject;
import java.io.Serializable;
import java.lang.annotation.Annotation;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Arrays;
/**
* Supports inline instantiation of annotation type instances.
* <p>
* An instance of an annotation type may be obtained by subclassing <tt>AnnotationLiteral</tt>.
* <pre>
* public abstract class PayByQualifier
* extends AnnotationLiteral<PayBy>
* implements PayBy {}
* </pre>
* An extension of AnnotationLiteral must do two things:<OL>
* <LI>Must have the target annotation as its generic type</LI>
* <LI>Must implement the target type</LI>
* </OL>
* In particular, in-line anonymous extensions of AnnotationLiteral will not
* work because in-line anonymous extensions of AnnotationLiteral cannot implement
* the target annotation
*
* @param <T> the annotation type
* @author jwells
*/
public abstract class AnnotationLiteral<T extends Annotation> implements Annotation, Serializable {
private static final long serialVersionUID = -3645430766814376616L;
private transient Class<T> annotationType;
private transient Method[] members;
protected AnnotationLiteral() {
Class<?> thisClass = this.getClass();
boolean foundAnnotation = false;
for (Class<?> iClass : thisClass.getInterfaces()) {
if (iClass.isAnnotation()) {
foundAnnotation = true;
break;
}
}
if (!foundAnnotation) {
throw new IllegalStateException(
"The subclass " + thisClass.getName() + " of AnnotationLiteral must implement an Annotation");
}
}
private static Class<?> getAnnotationLiteralSubclass(Class<?> clazz) {
Class<?> superclass = clazz.getSuperclass();
if (superclass.equals(AnnotationLiteral.class)) {
return clazz;
} else if (superclass.equals(Object.class)) {
return null;
} else {
return getAnnotationLiteralSubclass(superclass);
}
}
@SuppressWarnings("unchecked")
private static <T> Class<T> getTypeParameter(Class<?> annotationLiteralSuperclass) {
Type type = annotationLiteralSuperclass.getGenericSuperclass();
if (type instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType) type;
if (parameterizedType.getActualTypeArguments().length == 1) {
return (Class<T>) parameterizedType.getActualTypeArguments()[0];
}
}
return null;
}
private static void setAccessible(final AccessibleObject ao) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
ao.setAccessible(true);
return null;
});
}
private static Object invoke(Method method, Object instance) {
try {
if (!method.isAccessible()) {
setAccessible(method);
}
return method.invoke(instance);
} catch (IllegalArgumentException | IllegalAccessException | InvocationTargetException e) {
throw new RuntimeException(
"Error checking value of member method " + method.getName() + " on " + method.getDeclaringClass(), e);
}
}
private Method[] getMembers() {
if (members == null) {
members = AccessController.doPrivileged((PrivilegedAction<Method[]>) annotationType()::getDeclaredMethods);
if (members.length > 0 && !annotationType().isAssignableFrom(this.getClass())) {
throw new RuntimeException(
getClass() + " does not implement the annotation type with members " + annotationType().getName());
}
}
return members;
}
/**
* Method returns the type of the annotation literal. The value is resolved lazily during the first call of this method.
*
* @return annotation type of this literal.
*/
public Class<? extends Annotation> annotationType() {
if (annotationType == null) {
Class<?> annotationLiteralSubclass = getAnnotationLiteralSubclass(this.getClass());
if (annotationLiteralSubclass == null) {
throw new RuntimeException(getClass() + "is not a subclass of AnnotationLiteral");
}
annotationType = getTypeParameter(annotationLiteralSubclass);
if (annotationType == null) {
throw new RuntimeException(getClass() + " does not specify the type parameter T of AnnotationLiteral<T>");
}
}
return annotationType;
}
@Override
public boolean equals(Object other) {
if (other instanceof Annotation) {
Annotation that = (Annotation) other;
if (this.annotationType().equals(that.annotationType())) {
for (Method member : getMembers()) {
Object thisValue = invoke(member, this);
Object thatValue = invoke(member, that);
if (thisValue instanceof byte[] && thatValue instanceof byte[]) {
if (!Arrays.equals((byte[]) thisValue, (byte[]) thatValue)) {
return false;
}
} else if (thisValue instanceof short[] && thatValue instanceof short[]) {
if (!Arrays.equals((short[]) thisValue, (short[]) thatValue)) {
return false;
}
} else if (thisValue instanceof int[] && thatValue instanceof int[]) {
if (!Arrays.equals((int[]) thisValue, (int[]) thatValue)) {
return false;
}
} else if (thisValue instanceof long[] && thatValue instanceof long[]) {
if (!Arrays.equals((long[]) thisValue, (long[]) thatValue)) {
return false;
}
} else if (thisValue instanceof float[] && thatValue instanceof float[]) {
if (!Arrays.equals((float[]) thisValue, (float[]) thatValue)) {
return false;
}
} else if (thisValue instanceof double[] && thatValue instanceof double[]) {
if (!Arrays.equals((double[]) thisValue, (double[]) thatValue)) {
return false;
}
} else if (thisValue instanceof char[] && thatValue instanceof char[]) {
if (!Arrays.equals((char[]) thisValue, (char[]) thatValue)) {
return false;
}
} else if (thisValue instanceof boolean[] && thatValue instanceof boolean[]) {
if (!Arrays.equals((boolean[]) thisValue, (boolean[]) thatValue)) {
return false;
}
} else if (thisValue instanceof Object[] && thatValue instanceof Object[]) {
if (!Arrays.equals((Object[]) thisValue, (Object[]) thatValue)) {
return false;
}
} else {
if (!thisValue.equals(thatValue)) {
return false;
}
}
}
return true;
}
}
return false;
}
@Override
public int hashCode() {
int hashCode = 0;
for (Method member : getMembers()) {
int memberNameHashCode = 127 * member.getName().hashCode();
Object value = invoke(member, this);
int memberValueHashCode;
if (value instanceof boolean[]) {
memberValueHashCode = Arrays.hashCode((boolean[]) value);
} else if (value instanceof short[]) {
memberValueHashCode = Arrays.hashCode((short[]) value);
} else if (value instanceof int[]) {
memberValueHashCode = Arrays.hashCode((int[]) value);
} else if (value instanceof long[]) {
memberValueHashCode = Arrays.hashCode((long[]) value);
} else if (value instanceof float[]) {
memberValueHashCode = Arrays.hashCode((float[]) value);
} else if (value instanceof double[]) {
memberValueHashCode = Arrays.hashCode((double[]) value);
} else if (value instanceof byte[]) {
memberValueHashCode = Arrays.hashCode((byte[]) value);
} else if (value instanceof char[]) {
memberValueHashCode = Arrays.hashCode((char[]) value);
} else if (value instanceof Object[]) {
memberValueHashCode = Arrays.hashCode((Object[]) value);
} else {
memberValueHashCode = value.hashCode();
}
hashCode += memberNameHashCode ^ memberValueHashCode;
}
return hashCode;
}
}