Add SimpleAnnotationMeta classes and readers

Replace the existing ASM based readers with new implementations that
also support MergedAnnotations. The meta-data classes themselves are
now immutable, and constructed via separate reader classes.

The `SimpleMetadataReader` class has been updated to return the new
classes, however the old ones remain since some of them are public
and might be being used directly.

Closes gh-22884

spring-core/src/main/java/org/springframework/core/type/classreading/AbstractRecursiveAnnotationVisitor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -39,6 +39,7 @@ import org.springframework.util.ReflectionUtils;
  * @author Sam Brannen
  * @since 3.1.1
  */
+@Deprecated
 abstract class AbstractRecursiveAnnotationVisitor extends AnnotationVisitor {
 
 	protected final Log logger = LogFactory.getLog(getClass());

spring-core/src/main/java/org/springframework/core/type/classreading/AnnotationAttributesReadingVisitor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -42,6 +42,7 @@ import org.springframework.util.ObjectUtils;
  * @author Sam Brannen
  * @since 3.0
  */
+@Deprecated
 final class AnnotationAttributesReadingVisitor extends RecursiveAnnotationAttributesVisitor {
 
 	private final MultiValueMap<String, AnnotationAttributes> attributesMap;

spring-core/src/main/java/org/springframework/core/type/classreading/AnnotationMetadataReadingVisitor.java

@@ -49,6 +49,7 @@ import org.springframework.util.MultiValueMap;
  * @author Sam Brannen
  * @since 2.5
  */
+@Deprecated
 public class AnnotationMetadataReadingVisitor extends ClassMetadataReadingVisitor implements AnnotationMetadata {
 
 	@Nullable

spring-core/src/main/java/org/springframework/core/type/classreading/AnnotationReadingVisitorUtils.java

@@ -42,6 +42,7 @@ import org.springframework.util.ObjectUtils;
  * @author Sam Brannen
  * @since 4.0
  */
+@Deprecated
 abstract class AnnotationReadingVisitorUtils {
 
 	public static AnnotationAttributes convertClassValues(Object annotatedElement,

spring-core/src/main/java/org/springframework/core/type/classreading/ClassMetadataReadingVisitor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -43,6 +43,7 @@ import org.springframework.util.StringUtils;
  * @author Chris Beams
  * @since 2.5
  */
+@Deprecated
 class ClassMetadataReadingVisitor extends ClassVisitor implements ClassMetadata {
 
 	private String className = "";

spring-core/src/main/java/org/springframework/core/type/classreading/MergedAnnotationReadingVisitor.java

@@ -0,0 +1,204 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *      https://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.springframework.core.type.classreading;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+import org.springframework.asm.AnnotationVisitor;
+import org.springframework.asm.SpringAsmInfo;
+import org.springframework.asm.Type;
+import org.springframework.core.annotation.AnnotationFilter;
+import org.springframework.core.annotation.MergedAnnotation;
+import org.springframework.lang.Nullable;
+import org.springframework.util.ClassUtils;
+
+/**
+ * {@link AnnotationVisitor} that can be used to construct a
+ * {@link MergedAnnotation}.
+ *
+ * @author Phillip Webb
+ * @since 5.2
+ * @param <A> the annotation type
+ */
+class MergedAnnotationReadingVisitor<A extends Annotation> extends AnnotationVisitor {
+
+	@Nullable
+	private final ClassLoader classLoader;
+
+	@Nullable
+	private final Object source;
+
+	private final Class<A> annotationType;
+
+	private final Consumer<MergedAnnotation<A>> consumer;
+
+	private final Map<String, Object> attributes = new LinkedHashMap<>(4);
+
+	public MergedAnnotationReadingVisitor(ClassLoader classLoader,
+			@Nullable Object source, Class<A> annotationType,
+			Consumer<MergedAnnotation<A>> consumer) {
+		super(SpringAsmInfo.ASM_VERSION);
+		this.classLoader = classLoader;
+		this.source = source;
+		this.annotationType = annotationType;
+		this.consumer = consumer;
+	}
+
+	@Override
+	public void visit(String name, Object value) {
+		if (value instanceof Type) {
+			value = ((Type) value).getClassName();
+		}
+		this.attributes.put(name, value);
+	}
+
+	@Override
+	public void visitEnum(String name, String descriptor, String value) {
+		visitEnum(descriptor, value, enumValue -> this.attributes.put(name, enumValue));
+	}
+
+	@Override
+	public AnnotationVisitor visitAnnotation(String name, String descriptor) {
+		return visitAnnotation(descriptor,
+				annotation -> this.attributes.put(name, annotation));
+	}
+
+	@Override
+	public AnnotationVisitor visitArray(String name) {
+		return new ArrayVisitor(value -> this.attributes.put(name, value));
+	}
+
+	@Override
+	public void visitEnd() {
+		MergedAnnotation<A> annotation = MergedAnnotation.of(this.classLoader,
+				this.source, this.annotationType, this.attributes);
+		this.consumer.accept(annotation);
+	}
+
+	@SuppressWarnings("unchecked")
+	public <E extends Enum<E>> void visitEnum(String descriptor, String value,
+			Consumer<E> consumer) {
+
+		String className = Type.getType(descriptor).getClassName();
+		Class<E> type = (Class<E>) ClassUtils.resolveClassName(className, this.classLoader);
+		E enumValue = Enum.valueOf(type, value);
+		if (enumValue != null) {
+			consumer.accept(enumValue);
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	private <T extends Annotation> AnnotationVisitor visitAnnotation(String descriptor,
+			Consumer<MergedAnnotation<T>> consumer) {
+
+		String className = Type.getType(descriptor).getClassName();
+		if (AnnotationFilter.PLAIN.matches(className)) {
+			return null;
+		}
+		Class<T> type = (Class<T>) ClassUtils.resolveClassName(className,
+				this.classLoader);
+		return new MergedAnnotationReadingVisitor<>(this.classLoader, this.source, type,
+				consumer);
+	}
+
+	@Nullable
+	@SuppressWarnings("unchecked")
+	static <A extends Annotation> AnnotationVisitor get(@Nullable ClassLoader classLoader,
+			@Nullable Supplier<Object> sourceSupplier, String descriptor, boolean visible,
+			Consumer<MergedAnnotation<A>> consumer) {
+		if (!visible) {
+			return null;
+		}
+		String typeName = Type.getType(descriptor).getClassName();
+		if (AnnotationFilter.PLAIN.matches(typeName)) {
+			return null;
+		}
+		Object source = sourceSupplier != null ? sourceSupplier.get() : null;
+		try {
+			Class<A> annotationType = (Class<A>) ClassUtils.forName(typeName,
+					classLoader);
+			return new MergedAnnotationReadingVisitor<>(classLoader, source,
+					annotationType, consumer);
+		}
+		catch (ClassNotFoundException | LinkageError ex) {
+			return null;
+		}
+	}
+
+	/**
+	 * {@link AnnotationVisitor} to deal with array attributes.
+	 */
+	private class ArrayVisitor extends AnnotationVisitor {
+
+		private final List<Object> elements = new ArrayList<>();
+
+		private final Consumer<Object[]> consumer;
+
+		ArrayVisitor(Consumer<Object[]> consumer) {
+			super(SpringAsmInfo.ASM_VERSION);
+			this.consumer = consumer;
+		}
+
+		@Override
+		public void visit(String name, Object value) {
+			if (value instanceof Type) {
+				value = ((Type) value).getClassName();
+			}
+			this.elements.add(value);
+		}
+
+		@Override
+		public void visitEnum(String name, String descriptor, String value) {
+			MergedAnnotationReadingVisitor.this.visitEnum(descriptor, value,
+					enumValue -> this.elements.add(enumValue));
+		}
+
+		@Override
+		public AnnotationVisitor visitAnnotation(String name, String descriptor) {
+			return MergedAnnotationReadingVisitor.this.visitAnnotation(descriptor,
+					annotation -> this.elements.add(annotation));
+		}
+
+		@Override
+		public void visitEnd() {
+			Class<?> componentType = getComponentType();
+			Object[] array = (Object[]) Array.newInstance(componentType,
+					this.elements.size());
+			this.consumer.accept(this.elements.toArray(array));
+		}
+
+		private Class<?> getComponentType() {
+			if (this.elements.isEmpty()) {
+				return Object.class;
+			}
+			Object firstElement = this.elements.get(0);
+			if(firstElement instanceof Enum) {
+				return ((Enum<?>) firstElement).getDeclaringClass();
+			}
+			return firstElement.getClass();
+		}
+
+	}
+
+}

spring-core/src/main/java/org/springframework/core/type/classreading/MethodMetadataReadingVisitor.java

@@ -45,6 +45,7 @@ import org.springframework.util.MultiValueMap;
  * @author Phillip Webb
  * @since 3.0
  */
+@Deprecated
 public class MethodMetadataReadingVisitor extends MethodVisitor implements MethodMetadata {
 
 	protected final String methodName;

spring-core/src/main/java/org/springframework/core/type/classreading/RecursiveAnnotationArrayVisitor.java

@@ -34,6 +34,7 @@ import org.springframework.util.ObjectUtils;
  * @author Juergen Hoeller
  * @since 3.1.1
  */
+@Deprecated
 class RecursiveAnnotationArrayVisitor extends AbstractRecursiveAnnotationVisitor {
 
 	private final String attributeName;

spring-core/src/main/java/org/springframework/core/type/classreading/RecursiveAnnotationAttributesVisitor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,6 +28,7 @@ import org.springframework.lang.Nullable;
  * @author Juergen Hoeller
  * @since 3.1.1
  */
+@Deprecated
 class RecursiveAnnotationAttributesVisitor extends AbstractRecursiveAnnotationVisitor {
 
 	protected final String annotationType;

spring-core/src/main/java/org/springframework/core/type/classreading/SimpleAnnotationMetadata.java

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *      https://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.springframework.core.type.classreading;
+
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+import org.springframework.asm.Opcodes;
+import org.springframework.core.annotation.MergedAnnotations;
+import org.springframework.core.type.AnnotationMetadata;
+import org.springframework.core.type.MethodMetadata;
+import org.springframework.lang.Nullable;
+
+/**
+ * {@link AnnotationMetadata} created from a
+ * {@link SimpleAnnotationMetadataReadingVistor}.
+ *
+ * @author Phillip Webb
+ * @since 5.2
+ */
+final class SimpleAnnotationMetadata implements AnnotationMetadata {
+
+	private final String className;
+
+	private final int access;
+
+	private final String enclosingClassName;
+
+	private final String superClassName;
+
+	private final boolean independentInnerClass;
+
+	private final String[] interfaceNames;
+
+	private final String[] memberClassNames;
+
+	private final MethodMetadata[] annotatedMethods;
+
+	private final MergedAnnotations annotations;
+
+	private Set<String> annotationTypes;
+
+	SimpleAnnotationMetadata(String className, int access, String enclosingClassName,
+			String superClassName, boolean independentInnerClass, String[] interfaceNames,
+			String[] memberClassNames, MethodMetadata[] annotatedMethods,
+			MergedAnnotations annotations) {
+		this.className = className;
+		this.access = access;
+		this.enclosingClassName = enclosingClassName;
+		this.superClassName = superClassName;
+		this.independentInnerClass = independentInnerClass;
+		this.interfaceNames = interfaceNames;
+		this.memberClassNames = memberClassNames;
+		this.annotatedMethods = annotatedMethods;
+		this.annotations = annotations;
+	}
+
+	@Override
+	public String getClassName() {
+		return this.className;
+	}
+
+	@Override
+	public boolean isInterface() {
+		return (this.access & Opcodes.ACC_INTERFACE) != 0;
+	}
+
+	@Override
+	public boolean isAnnotation() {
+		return (this.access & Opcodes.ACC_ANNOTATION) != 0;
+	}
+
+	@Override
+	public boolean isAbstract() {
+		return (this.access & Opcodes.ACC_ABSTRACT) != 0;
+	}
+
+	@Override
+	public boolean isFinal() {
+		return (this.access & Opcodes.ACC_FINAL) != 0;
+	}
+
+	@Override
+	public boolean isIndependent() {
+		return this.enclosingClassName == null || this.independentInnerClass;
+	}
+
+	@Override
+	@Nullable
+	public String getEnclosingClassName() {
+		return this.enclosingClassName;
+	}
+
+	@Override
+	@Nullable
+	public String getSuperClassName() {
+		return this.superClassName;
+	}
+
+	@Override
+	public String[] getInterfaceNames() {
+		return this.interfaceNames.clone();
+	}
+
+	@Override
+	public String[] getMemberClassNames() {
+		return this.memberClassNames.clone();
+	}
+
+	@Override
+	public Set<String> getAnnotationTypes() {
+		Set<String> annotationTypes = this.annotationTypes;
+		if (annotationTypes == null) {
+			annotationTypes = Collections.unmodifiableSet(
+					AnnotationMetadata.super.getAnnotationTypes());
+			this.annotationTypes = annotationTypes;
+		}
+		return annotationTypes;
+	}
+
+	@Override
+	public Set<MethodMetadata> getAnnotatedMethods(String annotationName) {
+		Set<MethodMetadata> annotatedMethods = null;
+		for (int i = 0; i < this.annotatedMethods.length; i++) {
+			if (this.annotatedMethods[i].isAnnotated(annotationName)) {
+				if (annotatedMethods == null) {
+					annotatedMethods = new LinkedHashSet<>(4);
+				}
+				annotatedMethods.add(this.annotatedMethods[i]);
+			}
+		}
+		return annotatedMethods != null ? annotatedMethods : Collections.emptySet();
+	}
+
+	@Override
+	public MergedAnnotations getAnnotations() {
+		return this.annotations;
+	}
+
+
+
+}

spring-core/src/main/java/org/springframework/core/type/classreading/SimpleAnnotationMetadataReadingVistor.java

@@ -0,0 +1,197 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *      https://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.springframework.core.type.classreading;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.springframework.asm.AnnotationVisitor;
+import org.springframework.asm.ClassVisitor;
+import org.springframework.asm.MethodVisitor;
+import org.springframework.asm.Opcodes;
+import org.springframework.asm.SpringAsmInfo;
+import org.springframework.core.annotation.MergedAnnotation;
+import org.springframework.core.annotation.MergedAnnotations;
+import org.springframework.core.type.MethodMetadata;
+import org.springframework.lang.Nullable;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.StringUtils;
+
+/**
+ * ASM class visitor to create {@link SimpleAnnotationMetadata}.
+ *
+ * @author Phillip Webb
+ * @since 5.2
+ */
+class SimpleAnnotationMetadataReadingVistor extends ClassVisitor {
+
+	@Nullable
+	private final ClassLoader classLoader;
+
+	private String className = "";
+
+	private int access;
+
+	private String superClassName;
+
+	private String[] interfaceNames;
+
+	private String enclosingClassName;
+
+	private boolean independentInnerClass;
+
+	private Set<String> memberClassNames = new LinkedHashSet<>(4);
+
+	private List<MergedAnnotation<?>> annotations = new ArrayList<>();
+
+	private List<SimpleMethodMetadata> annotatedMethods = new ArrayList<>();
+
+	private SimpleAnnotationMetadata metadata;
+
+	private Source source;
+
+	SimpleAnnotationMetadataReadingVistor(@Nullable ClassLoader classLoader) {
+		super(SpringAsmInfo.ASM_VERSION);
+		this.classLoader = classLoader;
+	}
+
+	@Override
+	public void visit(int version, int access, String name, String signature,
+			@Nullable String supername, String[] interfaces) {
+		this.className = toClassName(name);
+		this.access = access;
+		if (supername != null && !isInterface(access)) {
+			this.superClassName = toClassName(supername);
+		}
+		this.interfaceNames = new String[interfaces.length];
+		for (int i = 0; i < interfaces.length; i++) {
+			this.interfaceNames[i] = toClassName(interfaces[i]);
+		}
+	}
+
+	@Override
+	public void visitOuterClass(String owner, String name, String desc) {
+		this.enclosingClassName = toClassName(owner);
+	}
+
+	@Override
+	public void visitInnerClass(String name, @Nullable String outerName, String innerName,
+			int access) {
+		if (outerName != null) {
+			String className = toClassName(name);
+			String outerClassName = toClassName(outerName);
+			if (this.className.equals(className)) {
+				this.enclosingClassName = outerClassName;
+				this.independentInnerClass = ((access & Opcodes.ACC_STATIC) != 0);
+			}
+			else if (this.className.equals(outerClassName)) {
+				this.memberClassNames.add(className);
+			}
+		}
+	}
+
+	@Override
+	public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
+		return MergedAnnotationReadingVisitor.get(this.classLoader, this::getSource,
+				descriptor, visible, this.annotations::add);
+	}
+
+	@Override
+	public MethodVisitor visitMethod(int access, String name, String descriptor,
+			String signature, String[] exceptions) {
+		// Skip bridge methods - we're only interested in original
+		// annotation-defining user methods. On JDK 8, we'd otherwise run into
+		// double detection of the same annotated method...
+		if (isBridge(access)) {
+			return null;
+		}
+		return new SimpleMethodMetadataReadingVistor(this.classLoader, this.className,
+				access, name, descriptor, this.annotatedMethods::add);
+	}
+
+	@Override
+	public void visitEnd() {
+		String[] memberClassNames = StringUtils.toStringArray(this.memberClassNames);
+		MethodMetadata[] annotatedMethods = this.annotatedMethods.toArray(new MethodMetadata[0]);
+		MergedAnnotations annotations = MergedAnnotations.of(this.annotations);
+		this.metadata = new SimpleAnnotationMetadata(this.className, this.access,
+				this.enclosingClassName, this.superClassName, this.independentInnerClass,
+				this.interfaceNames, memberClassNames, annotatedMethods, annotations);
+	}
+
+	public SimpleAnnotationMetadata getMetadata() {
+		return this.metadata;
+	}
+
+	private Source getSource() {
+		Source source = this.source;
+		if (source == null) {
+			source = new Source(this.className);
+			this.source = source;
+		}
+		return source;
+	}
+
+	private String toClassName(String name) {
+		return ClassUtils.convertResourcePathToClassName(name);
+	}
+
+	private boolean isBridge(int access) {
+		return (access & Opcodes.ACC_BRIDGE) != 0;
+	}
+
+	private boolean isInterface(int access) {
+		return (access & Opcodes.ACC_INTERFACE) != 0;
+	}
+
+	/**
+	 * {@link MergedAnnotation} source.
+	 */
+	private static final class Source {
+
+		private final String className;
+
+		Source(String className) {
+			this.className = className;
+		}
+
+		@Override
+		public int hashCode() {
+			return this.className.hashCode();
+		}
+
+		@Override
+		public boolean equals(Object obj) {
+			if (this == obj) {
+				return true;
+			}
+			if (obj == null || getClass() != obj.getClass()) {
+				return false;
+			}
+			return this.className.equals(((Source) obj).className);
+		}
+
+		@Override
+		public String toString() {
+			return this.className;
+		}
+
+	}
+
+}

spring-core/src/main/java/org/springframework/core/type/classreading/SimpleMetadataReader.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -31,45 +31,39 @@ import org.springframework.lang.Nullable;
  * {@link MetadataReader} implementation based on an ASM
  * {@link org.springframework.asm.ClassReader}.
  *
- * <p>Package-visible in order to allow for repackaging the ASM library
- * without effect on users of the {@code core.type} package.
- *
  * @author Juergen Hoeller
  * @author Costin Leau
  * @since 2.5
  */
 final class SimpleMetadataReader implements MetadataReader {
 
-	private final Resource resource;
+	private static final int PARSING_OPTIONS = ClassReader.SKIP_DEBUG
+			| ClassReader.SKIP_CODE | ClassReader.SKIP_FRAMES;
 
-	private final ClassMetadata classMetadata;
+	private final Resource resource;
 
 	private final AnnotationMetadata annotationMetadata;
 
 
 	SimpleMetadataReader(Resource resource, @Nullable ClassLoader classLoader) throws IOException {
-		InputStream is = new BufferedInputStream(resource.getInputStream());
-		ClassReader classReader;
-		try {
-			classReader = new ClassReader(is);
-		}
-		catch (IllegalArgumentException ex) {
-			throw new NestedIOException("ASM ClassReader failed to parse class file - " +
-					"probably due to a new Java class file version that isn't supported yet: " + resource, ex);
-		}
-		finally {
-			is.close();
-		}
-
-		AnnotationMetadataReadingVisitor visitor = new AnnotationMetadataReadingVisitor(classLoader);
-		classReader.accept(visitor, ClassReader.SKIP_DEBUG);
-
-		this.annotationMetadata = visitor;
-		// (since AnnotationMetadataReadingVisitor extends ClassMetadataReadingVisitor)
-		this.classMetadata = visitor;
+		SimpleAnnotationMetadataReadingVistor visitor = new SimpleAnnotationMetadataReadingVistor(classLoader);
+		getClassReader(resource).accept(visitor, PARSING_OPTIONS);
 		this.resource = resource;
+		this.annotationMetadata = visitor.getMetadata();
 	}
 
+	private ClassReader getClassReader(Resource resource)
+			throws IOException, NestedIOException {
+		try (InputStream is = new BufferedInputStream(resource.getInputStream())) {
+			try {
+				return new ClassReader(is);
+			}
+			catch (IllegalArgumentException ex) {
+				throw new NestedIOException("ASM ClassReader failed to parse class file - " +
+						"probably due to a new Java class file version that isn't supported yet: " + resource, ex);
+			}
+		}
+	}
 
 	@Override
 	public Resource getResource() {
@@ -78,7 +72,7 @@ final class SimpleMetadataReader implements MetadataReader {
 
 	@Override
 	public ClassMetadata getClassMetadata() {
-		return this.classMetadata;
+		return this.annotationMetadata;
 	}
 
 	@Override

spring-core/src/main/java/org/springframework/core/type/classreading/SimpleMethodMetadata.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *      https://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.springframework.core.type.classreading;
+
+import org.springframework.asm.Opcodes;
+import org.springframework.core.annotation.MergedAnnotations;
+import org.springframework.core.type.MethodMetadata;
+
+/**
+ * {@link MethodMetadata} created from a
+ * {@link SimpleMethodMetadataReadingVistor}.
+ *
+ * @author Phillip Webb
+ * @since 5.2
+ */
+final class SimpleMethodMetadata implements MethodMetadata {
+
+	private final String methodName;
+
+	private final int access;
+
+	private final String declaringClassName;
+
+	private final String returnTypeName;
+
+	private final MergedAnnotations annotations;
+
+	public SimpleMethodMetadata(String methodName, int access, String declaringClassName,
+			String returnTypeName, MergedAnnotations annotations) {
+		this.methodName = methodName;
+		this.access = access;
+		this.declaringClassName = declaringClassName;
+		this.returnTypeName = returnTypeName;
+		this.annotations = annotations;
+	}
+
+	@Override
+	public String getMethodName() {
+		return this.methodName;
+	}
+
+	@Override
+	public String getDeclaringClassName() {
+		return this.declaringClassName;
+	}
+
+	@Override
+	public String getReturnTypeName() {
+		return this.returnTypeName;
+	}
+
+	@Override
+	public boolean isAbstract() {
+		return (this.access & Opcodes.ACC_ABSTRACT) != 0;
+	}
+
+	@Override
+	public boolean isStatic() {
+		return (this.access & Opcodes.ACC_STATIC) != 0;
+	}
+
+	@Override
+	public boolean isFinal() {
+		return (this.access & Opcodes.ACC_FINAL) != 0;
+	}
+
+	@Override
+	public boolean isOverridable() {
+		return !isStatic() && !isFinal() && !isPrivate();
+	}
+
+	public boolean isPrivate() {
+		return (this.access & Opcodes.ACC_PRIVATE) != 0;
+	}
+
+	@Override
+	public MergedAnnotations getAnnotations() {
+		return this.annotations;
+	}
+
+}

spring-core/src/main/java/org/springframework/core/type/classreading/SimpleMethodMetadataReadingVistor.java

@@ -0,0 +1,162 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *      https://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.springframework.core.type.classreading;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+
+import org.springframework.asm.AnnotationVisitor;
+import org.springframework.asm.MethodVisitor;
+import org.springframework.asm.SpringAsmInfo;
+import org.springframework.asm.Type;
+import org.springframework.core.annotation.MergedAnnotation;
+import org.springframework.core.annotation.MergedAnnotations;
+import org.springframework.core.type.MethodMetadata;
+import org.springframework.lang.Nullable;
+
+/**
+ * {@link MethodMetadata} returned from a {@link SimpleMetadataReader}.
+ *
+ * @author Phillip Webb
+ * @since 5.2
+ */
+class SimpleMethodMetadataReadingVistor extends MethodVisitor {
+
+	@Nullable
+	private final ClassLoader classLoader;
+
+	private final String declaringClassName;
+
+	private final int access;
+
+	private final String name;
+
+	private final String descriptor;
+
+	private final List<MergedAnnotation<?>> annotations = new ArrayList<MergedAnnotation<?>>(
+			4);
+
+	private final Consumer<SimpleMethodMetadata> consumer;
+
+	private Source source;
+
+	SimpleMethodMetadataReadingVistor(@Nullable ClassLoader classLoader,
+			String declaringClassName, int access, String name, String descriptor,
+			Consumer<SimpleMethodMetadata> consumer) {
+		super(SpringAsmInfo.ASM_VERSION);
+		this.classLoader = classLoader;
+		this.declaringClassName = declaringClassName;
+		this.access = access;
+		this.name = name;
+		this.descriptor = descriptor;
+		this.consumer = consumer;
+	}
+
+	@Override
+	public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
+		return MergedAnnotationReadingVisitor.get(this.classLoader, this::getSource,
+				descriptor, visible, this.annotations::add);
+	}
+
+	@Override
+	public void visitEnd() {
+		if (!this.annotations.isEmpty()) {
+			String returnTypeName = Type.getReturnType(this.descriptor).getClassName();
+			MergedAnnotations annotations = MergedAnnotations.of(this.annotations);
+			SimpleMethodMetadata metadata = new SimpleMethodMetadata(this.name,
+					this.access, this.declaringClassName, returnTypeName, annotations);
+			this.consumer.accept(metadata);
+		}
+	}
+
+	private Object getSource() {
+		Source source = this.source;
+		if (source == null) {
+			source = new Source(this.declaringClassName, this.name, this.descriptor);
+			this.source = source;
+		}
+		return source;
+	}
+
+	/**
+	 * {@link MergedAnnotation} source.
+	 */
+	static final class Source {
+
+		private final String declaringClassName;
+
+		private final String name;
+
+		private final String descriptor;
+
+		private String string;
+
+		Source(String declaringClassName, String name, String descriptor) {
+			this.declaringClassName = declaringClassName;
+			this.name = name;
+			this.descriptor = descriptor;
+		}
+
+		@Override
+		public int hashCode() {
+			int result = 1;
+			result = 31 * result + this.declaringClassName.hashCode();
+			result = 31 * result + this.name.hashCode();
+			result = 31 * result + this.descriptor.hashCode();
+			return result;
+		}
+
+		@Override
+		public boolean equals(Object obj) {
+			if (this == obj) {
+				return true;
+			}
+			if (obj == null || getClass() != obj.getClass()) {
+				return false;
+			}
+			Source other = (Source) obj;
+			boolean result = true;
+			result = result &= this.declaringClassName.equals(other.declaringClassName);
+			result = result &= this.name.equals(other.name);
+			result = result &= this.descriptor.equals(other.descriptor);
+			return result;
+		}
+
+		@Override
+		public String toString() {
+			String string = this.string;
+			if (string == null) {
+				StringBuilder builder = new StringBuilder();
+				builder.append(this.declaringClassName);
+				builder.append(".");
+				builder.append(this.name);
+				Type[] argumentTypes = Type.getArgumentTypes(this.descriptor);
+				builder.append("(");
+				for (Type type : argumentTypes) {
+					builder.append(type.getClassName());
+				}
+				builder.append(")");
+				string = builder.toString();
+				this.string = string;
+			}
+			return string;
+		}
+
+	}
+
+}