Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.jboss.errai.codegen.util; import static java.lang.reflect.Modifier.isPublic; import java.lang.annotation.Annotation; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Arrays; import java.util.Collection; import java.util.Set; import java.util.function.Function; import java.util.function.Predicate; import java.util.stream.Collectors; import java.util.stream.Stream; import javax.enterprise.util.Nonbinding; import javax.inject.Named; import javax.inject.Qualifier; import org.apache.commons.lang3.AnnotationUtils; import org.apache.commons.lang3.ClassUtils; import org.apache.commons.lang3.Validate; import org.apache.commons.lang3.builder.ToStringBuilder; import org.apache.commons.lang3.builder.ToStringStyle; import org.jboss.errai.codegen.meta.MetaClass; import org.jboss.errai.codegen.meta.MetaClassFactory; import org.jboss.errai.codegen.meta.MetaMethod; import org.jboss.errai.common.client.util.AnnotationPropertyAccessor; import org.jboss.errai.common.client.util.AnnotationPropertyAccessorBuilder; import org.jboss.errai.common.metadata.MetaDataScanner; import org.jboss.errai.common.metadata.ScannerSingleton; /** * <p> * Helper methods for working with {@link Annotation} instances. * </p> * * <p> * This class contains various utility methods that make working with * annotations simpler. * </p> * * <p> * This modified version of {@link AnnotationUtils} ignores {@link Nonbinding} * values when calculating hashcodes and equality, for comparing CDI qualifiers. * </p> * * <p> * {@link Annotation} instances are always proxy objects; unfortunately dynamic * proxies cannot be depended upon to know how to implement certain methods in * the same manner as would be done by "natural" {@link Annotation}s. The * methods presented in this class can be used to avoid that possibility. It is * of course also possible for dynamic proxies to actually delegate their e.g. * {@link Annotation#equals(Object)}/{@link Annotation#hashCode()}/ * {@link Annotation#toString()} implementations to {@link CDIAnnotationUtils}. * </p> * * <p> * #ThreadSafe# * </p> * */ public class CDIAnnotationUtils { /** * A style that prints annotations as recommended. */ private static final ToStringStyle TO_STRING_STYLE = new ToStringStyle() { /** Serialization version */ private static final long serialVersionUID = 1L; { setDefaultFullDetail(true); setArrayContentDetail(true); setUseClassName(true); setUseShortClassName(true); setUseIdentityHashCode(false); setContentStart("("); setContentEnd(")"); setFieldSeparator(", "); setArrayStart("["); setArrayEnd("]"); } /** * {@inheritDoc} */ @Override protected String getShortClassName(java.lang.Class<?> cls) { Class<? extends Annotation> annotationType = null; for (final Class<?> iface : ClassUtils.getAllInterfaces(cls)) { if (Annotation.class.isAssignableFrom(iface)) { @SuppressWarnings("unchecked") final //because we just checked the assignability Class<? extends Annotation> found = (Class<? extends Annotation>) iface; annotationType = found; break; } } return new StringBuilder(annotationType == null ? "" : annotationType.getName()).insert(0, '@') .toString(); } /** * {@inheritDoc} */ @Override protected void appendDetail(StringBuffer buffer, String fieldName, Object value) { if (value instanceof Annotation) { value = CDIAnnotationUtils.toString((Annotation) value); } super.appendDetail(buffer, fieldName, value); } }; /** * <p>{@code AnnotationUtils} instances should NOT be constructed in * standard programming. Instead, the class should be used statically.</p> * * <p>This constructor is public to permit tools that require a JavaBean * instance to operate.</p> */ public CDIAnnotationUtils() { } //----------------------------------------------------------------------- /** * <p>Checks if two annotations are equal using the criteria for equality * presented in the {@link Annotation#equals(Object)} API docs.</p> * * @param a1 the first Annotation to compare, {@code null} returns * {@code false} unless both are {@code null} * @param a2 the second Annotation to compare, {@code null} returns * {@code false} unless both are {@code null} * @return {@code true} if the two annotations are {@code equal} or both * {@code null} */ public static boolean equals(Annotation a1, Annotation a2) { if (a1 == a2) { return true; } if (a1 == null || a2 == null) { return false; } final Class<? extends Annotation> type = a1.annotationType(); final Class<? extends Annotation> type2 = a2.annotationType(); Validate.notNull(type, "Annotation %s with null annotationType()", a1); Validate.notNull(type2, "Annotation %s with null annotationType()", a2); if (!type.equals(type2)) { return false; } try { for (final Method m : type.getDeclaredMethods()) { if (m.getParameterTypes().length == 0 && isValidAnnotationMemberType(m.getReturnType()) && !m.isAnnotationPresent(Nonbinding.class)) { final Object v1 = m.invoke(a1); final Object v2 = m.invoke(a2); if (!memberEquals(m.getReturnType(), v1, v2)) { return false; } } } } catch (final IllegalAccessException ex) { return false; } catch (final InvocationTargetException ex) { return false; } return true; } /** * <p>Generate a hash code for the given annotation using the algorithm * presented in the {@link Annotation#hashCode()} API docs.</p> * * @param a the Annotation for a hash code calculation is desired, not * {@code null} * @return the calculated hash code * @throws RuntimeException if an {@code Exception} is encountered during * annotation member access * @throws IllegalStateException if an annotation method invocation returns * {@code null} */ public static int hashCode(Annotation a) { int result = 0; final Class<? extends Annotation> type = a.annotationType(); for (final Method m : type.getDeclaredMethods()) { if (!m.isAnnotationPresent(Nonbinding.class)) { try { final Object value = m.invoke(a); if (value == null) { throw new IllegalStateException(String.format("Annotation method %s returned null", m)); } result += hashMember(m.getName(), value); } catch (final RuntimeException ex) { throw ex; } catch (final Exception ex) { throw new RuntimeException(ex); } } } return result; } /** * <p>Generate a string representation of an Annotation, as suggested by * {@link Annotation#toString()}.</p> * * @param a the annotation of which a string representation is desired * @return the standard string representation of an annotation, not * {@code null} */ public static String toString(final Annotation a) { final ToStringBuilder builder = new ToStringBuilder(a, TO_STRING_STYLE); for (final Method m : a.annotationType().getDeclaredMethods()) { if (m.getParameterTypes().length > 0) { continue; //wtf? } try { builder.append(m.getName(), m.invoke(a)); } catch (final RuntimeException ex) { throw ex; } catch (final Exception ex) { throw new RuntimeException(ex); } } return builder.build(); } /** * <p>Checks if the specified type is permitted as an annotation member.</p> * * <p>The Java language specification only permits certain types to be used * in annotations. These include {@link String}, {@link Class}, primitive * types, {@link Annotation}, {@link Enum}, and single-dimensional arrays of * these types.</p> * * @param type the type to check, {@code null} * @return {@code true} if the type is a valid type to use in an annotation */ public static boolean isValidAnnotationMemberType(Class<?> type) { if (type == null) { return false; } if (type.isArray()) { type = type.getComponentType(); } return type.isPrimitive() || type.isEnum() || type.isAnnotation() || String.class.equals(type) || Class.class.equals(type); } //besides modularity, this has the advantage of autoboxing primitives: /** * Helper method for generating a hash code for a member of an annotation. * * @param name the name of the member * @param value the value of the member * @return a hash code for this member */ private static int hashMember(String name, Object value) { final int part1 = name.hashCode() * 127; if (value.getClass().isArray()) { return part1 ^ arrayMemberHash(value.getClass().getComponentType(), value); } if (value instanceof Annotation) { return part1 ^ hashCode((Annotation) value); } return part1 ^ value.hashCode(); } /** * Helper method for checking whether two objects of the given type are * equal. This method is used to compare the parameters of two annotation * instances. * * @param type the type of the objects to be compared * @param o1 the first object * @param o2 the second object * @return a flag whether these objects are equal */ private static boolean memberEquals(Class<?> type, Object o1, Object o2) { if (o1 == o2) { return true; } if (o1 == null || o2 == null) { return false; } if (type.isArray()) { return arrayMemberEquals(type.getComponentType(), o1, o2); } if (type.isAnnotation()) { return equals((Annotation) o1, (Annotation) o2); } return o1.equals(o2); } /** * Helper method for comparing two objects of an array type. * * @param componentType the component type of the array * @param o1 the first object * @param o2 the second object * @return a flag whether these objects are equal */ private static boolean arrayMemberEquals(Class<?> componentType, Object o1, Object o2) { if (componentType.isAnnotation()) { return annotationArrayMemberEquals((Annotation[]) o1, (Annotation[]) o2); } if (componentType.equals(Byte.TYPE)) { return Arrays.equals((byte[]) o1, (byte[]) o2); } if (componentType.equals(Short.TYPE)) { return Arrays.equals((short[]) o1, (short[]) o2); } if (componentType.equals(Integer.TYPE)) { return Arrays.equals((int[]) o1, (int[]) o2); } if (componentType.equals(Character.TYPE)) { return Arrays.equals((char[]) o1, (char[]) o2); } if (componentType.equals(Long.TYPE)) { return Arrays.equals((long[]) o1, (long[]) o2); } if (componentType.equals(Float.TYPE)) { return Arrays.equals((float[]) o1, (float[]) o2); } if (componentType.equals(Double.TYPE)) { return Arrays.equals((double[]) o1, (double[]) o2); } if (componentType.equals(Boolean.TYPE)) { return Arrays.equals((boolean[]) o1, (boolean[]) o2); } return Arrays.equals((Object[]) o1, (Object[]) o2); } /** * Helper method for comparing two arrays of annotations. * * @param a1 the first array * @param a2 the second array * @return a flag whether these arrays are equal */ private static boolean annotationArrayMemberEquals(Annotation[] a1, Annotation[] a2) { if (a1.length != a2.length) { return false; } for (int i = 0; i < a1.length; i++) { if (!equals(a1[i], a2[i])) { return false; } } return true; } /** * Helper method for generating a hash code for an array. * * @param componentType the component type of the array * @param o the array * @return a hash code for the specified array */ private static int arrayMemberHash(Class<?> componentType, Object o) { if (componentType.equals(Byte.TYPE)) { return Arrays.hashCode((byte[]) o); } if (componentType.equals(Short.TYPE)) { return Arrays.hashCode((short[]) o); } if (componentType.equals(Integer.TYPE)) { return Arrays.hashCode((int[]) o); } if (componentType.equals(Character.TYPE)) { return Arrays.hashCode((char[]) o); } if (componentType.equals(Long.TYPE)) { return Arrays.hashCode((long[]) o); } if (componentType.equals(Float.TYPE)) { return Arrays.hashCode((float[]) o); } if (componentType.equals(Double.TYPE)) { return Arrays.hashCode((double[]) o); } if (componentType.equals(Boolean.TYPE)) { return Arrays.hashCode((boolean[]) o); } return Arrays.hashCode((Object[]) o); } public static String formatDefaultElName(final String rawName) { if (rawName.isEmpty() || Character.isLowerCase(rawName.charAt(0)) || (rawName.length() > 1 && Character.isUpperCase(rawName.charAt(1)))) { return rawName; } else { final StringBuilder builder = new StringBuilder(rawName); builder.setCharAt(0, Character.toLowerCase(builder.charAt(0))); return builder.toString(); } } public static Set<Class<?>> getQualifiersAsClasses() { final MetaDataScanner scanner = ScannerSingleton.getOrCreateInstance(); final Set<Class<?>> typesAnnotatedWith = scanner.getTypesAnnotatedWith(Qualifier.class); typesAnnotatedWith.add(Named.class); return typesAnnotatedWith; } public static Set<MetaClass> getQualifiers() { final Set<Class<?>> qualifiersAsClasses = getQualifiersAsClasses(); final Set<MetaClass> qualifiersAsMetaClasses = qualifiersAsClasses.stream() .map(c -> MetaClassFactory.get(c)).collect(Collectors.toSet()); if (qualifiersAsClasses.size() > qualifiersAsMetaClasses.size()) { throw new RuntimeException("Lost some qualifiers when converting from Class to MetaClass"); } return qualifiersAsMetaClasses; } public static Collection<MetaMethod> getAnnotationAttributes(final MetaClass annoClass) { return filterAnnotationMethods(Arrays.stream(annoClass.getDeclaredMethods()), method -> !method.isAnnotationPresent(Nonbinding.class) && method.isPublic() && !method.getName().equals("equals") && !method.getName().equals("hashCode")); } public static Collection<Method> getAnnotationAttributes(final Class<?> annoClass) { return filterAnnotationMethods(Arrays.stream(annoClass.getDeclaredMethods()), method -> !method.isAnnotationPresent(Nonbinding.class) && isPublic(method.getModifiers()) && !method.getName().equals("equals") && !method.getName().equals("hashCode")); } public static Collection<MetaMethod> getNonBindingAttributes(final MetaClass annoClass) { return filterAnnotationMethods(Arrays.stream(annoClass.getDeclaredMethods()), method -> method.isAnnotationPresent(Nonbinding.class) && method.isPublic() && !method.getName().equals("equals") && !method.getName().equals("hashCode")); } public static Collection<Method> getNonBindingAttributes(final Class<?> annoClass) { return filterAnnotationMethods(Arrays.stream(annoClass.getDeclaredMethods()), method -> method.isAnnotationPresent(Nonbinding.class) && isPublic(method.getModifiers()) && !method.getName().equals("equals") && !method.getName().equals("hashCode")); } private static <T, M> Collection<M> filterAnnotationMethods(final Stream<M> methods, final Predicate<M> methodPredicate) { return methods.filter(methodPredicate).collect(Collectors.toList()); } public static AnnotationPropertyAccessor createDynamicSerializer( final Class<? extends Annotation> annotationType) { final AnnotationPropertyAccessorBuilder builder = AnnotationPropertyAccessorBuilder.create(); final Collection<Method> annoAttrs = CDIAnnotationUtils.getAnnotationAttributes(annotationType); for (final Method attr : annoAttrs) { builder.with(attr.getName(), anno -> { try { final String retVal; final Function<Object, String> toString = componentToString( attr.getReturnType().isArray() ? attr.getReturnType().getComponentType() : attr.getReturnType()); if (attr.getReturnType().isArray()) { final StringBuilder sb = new StringBuilder(); final Object[] array = (Object[]) attr.invoke(anno); sb.append("["); for (final Object obj : array) { sb.append(toString.apply(obj)).append(","); } sb.replace(sb.length() - 1, sb.length(), "]"); retVal = sb.toString(); } else { retVal = toString.apply(attr.invoke(anno)); } return retVal; } catch (final Exception e) { throw new RuntimeException(String.format("Could not access '%s' property while serializing %s.", attr.getName(), anno.annotationType()), e); } }); } return builder.build(); } private static Function<Object, String> componentToString(final Class<?> returnType) { if (Class.class.equals(returnType)) { return o -> ((Class<?>) o).getName(); } else { return o -> String.valueOf(o); } } }