Unlocking Spring Security’s ResolvableType: Simplify Generic Reflection

1. Introduction

While reading Spring Security source code I noticed two lines that use ResolvableType to obtain a generic type, which prompted me to investigate.

ResolvableType type = ResolvableType.forClassWithGenerics(OAuth2UserService.class, OAuth2UserRequest.class, OAuth2User.class);
ApplicationContext context = getContext();
String[] names = context.getBeanNamesForType(type);
if (names.length == 1) {
    OAuth2UserService<OAuth2UserRequest, OAuth2User> bean = (OAuth2UserService<OAuth2UserRequest, OAuth2User>) context.getBean(names[0]);
}

The ResolvableType class can retrieve a generic type, so I explored its capabilities.

2. ResolvableType

Normally we obtain type information via Java reflection on a Class, which is low‑level and cumbersome. ResolvableType simplifies this process by providing static methods that describe generic types such as OAuth2UserService<OAuth2UserRequest, OAuth2User> and allow retrieval of the corresponding Spring Bean. ResolvableType cannot be instantiated directly, but it offers many static factory methods.

forClass

Gets type information from a Class object; an overloaded version can combine a base class and an implementation class.

// java.lang.String
ResolvableType resolvableType1 = ResolvableType.forClass(String.class);
// java.util.Map<?, ?>
ResolvableType resolvableType2 = ResolvableType.forClass(Map.class, HashMap.class);

forClassWithGenerics

Gets type information from a Class together with its generic parameters, as shown in the opening example.

forConstructorParameter

Obtains metadata of a specific constructor parameter.

User user = new User("Zhang San");
Constructor<?> constructor = user.getClass().getConstructors()[0];
ResolvableType.forConstructorParameter(constructor, 0);

forField

Gets the type of a field.

private HashMap<String, List<Object>> map;

public void test() throws NoSuchFieldException {
    Field field = getClass().getDeclaredField("map");
    ResolvableType resolvableType = ResolvableType.forField(field);
}

forMethodParameter

Gets the type of a method parameter.

User user = new User("Zhang San");
Method method = user.getClass().getMethods()[0];
ResolvableType.forMethodParameter(method, 0);

forMethodReturnType

Gets the return‑type information of a method.

forArrayComponent

Gets the component type of an array.

ResolvableType resolvableType = ResolvableType.forClass(String.class);
// java.lang.String[]
ResolvableType arrayComponent = ResolvableType.forArrayComponent(resolvableType);

forInstance

Can also retrieve type information from an object instance.

Instance methods

So what is the practical use?

When you need to use reflection to obtain class instances, fields, or method information, ResolvableType provides convenient access to super‑type, generic arguments, and map representations, reducing boilerplate reflection code.

For example, from a field you can retrieve its generic key and value types, resolve them, and convert the type to a Map view.

private HashMap<Integer, List<String>> myMap;

public void example() throws NoSuchFieldException {
    ResolvableType t = ResolvableType.forField(getClass().getDeclaredField("myMap"));
    t.getSuperType(); // AbstractMap<Integer, List<String>>
    t.asMap(); // Map<Integer, List<String>>
    t.getGeneric(0).resolve(); // Integer
    t.getGeneric(1).resolve(); // List
    t.getGeneric(1); // List<String>
    t.resolveGeneric(1, 0); // String
}

It feels like a more user‑friendly replacement for many common reflection operations.