Awesome

Java generics runtime resolver

DOCUMENTATION https://xvik.github.io/generics-resolver

About

class Base<T, K> {
  T doSomething(K arg);
}

class Root extends Base<Integer, Long> {...}

Library was created to support reflection analysis (introspection) with all available types information.

// compute generics for classes in Root hierarchy
GenericsContext context = GenericsResolver.resolve(Root.class)
        // switch current class to Base (to work in context of it)
        .type(Base.class);

context.generics() == [Integer.class, Long.class]

MethodGenericsContext methodContext = context
    .method(Base.class.getMethod("doSomething", Object.class))
// method return class (in context of Root)
methodContext.resolveReturnClass() == Integer.class
// method parameters (in context of Root)
methodContext.resolveParameters() == [Long.class]

Features:

• Resolves generics for hierarchies of any depth (all subclasses and interfaces on any level)
• Supports
  • composite generics (e.g. Smth<T, K extends List<T>>)
  • method generics (<T> T getSmth())
  • constructor generics (<T> Some(T arg))
  • outer class generics (Outer<T>.Inner)
• Context api completely prevents incorrect generics resolution (by doing automatic context switching)
• Sub contexts: build context from Type in current context to properly solve root generics
• Generics backtracking: track higher type generics from some known middle type
• To string types converter (useful for logging/reporting)
• General types comparison api (assignability, compatibility, specificity checks)

NOTE: Java 8 lambdas are not supported because there is no official way to analyze lambdas due to implementation. It is possible to use some hacks to resolve lambda geneics in some cases, but it's quite fragile (may break on future java releases or not work on other java implementations).

Library targets actual classes analysis and, personally, I never really need to analyze lambdas.

Library was originally written for guice-persist-orient to support repositories analysis and later used in dropwizard-guicey for extensions analysis.

Compatible with Java 6 and above.

Alternatives

For simple cases (e.g. to resolve class/interface generic value), look, maybe you already have required tool in the classpath (and it will be enough):

• Guava TypeToken
• Spring GenericTypeResolver
• Commons-lang3 TypeUtils

Setup

Maven:

<dependency>
  <groupId>ru.vyarus</groupId>
  <artifactId>generics-resolver</artifactId>
  <version>3.0.3</version>
</dependency>

Gradle:

implementation 'ru.vyarus:generics-resolver:3.0.3'

Snapshots

• Go to JitPack project page
• Select Commits section and click Get it on commit you want to use (top one - the most recent)
• Follow displayed instruction:
  • Add jitpack repository: maven { url 'https://jitpack.io' }
  • Use commit hash as version: ru.vyarus:generics-resolver:56537f7d23 (or use master-SNAPSHOT)

Usage

Read documentation