Как должны быть реализованы типы иерархии типов?

Ответ 1

Я решал эту проблему неудовлетворительно в течение 10 лет. Сначала с Guices MoreTypes.java, скопированными и отредактированными с помощью Gsons GsonTypes.java, и снова в Moshis Util.java.

У Моши лучший подход, который не говорит, что это хорошо.

Вы не можете вызвать equals() в произвольных реализациях Type и ожидать, что это сработает.

Это потому, что API типов Java предлагают несколько несовместимых способов моделирования массивов простых классов. Вы можете сделать Date[] как Class<Date[]> или как GenericArrayType, тип компонента которого является Date. Я полагаю, что вы получите первое из отражения в поле типа Date[] а второе - в качестве параметра поля типа List<Date[]>.

Хеш-коды не указаны.

Я также начал работать над реализацией этих классов, которые использует Android. В самых ранних версиях Android хэш-коды отличаются от Java, но сегодня все, что вы найдете в дикой природе, использует те же хеш-коды, что и Java.

Методы toString не хороши

Если вы используете типы в сообщениях об ошибках, отстойно, что вам нужно написать специальный код, чтобы красиво их печатать.

Копировать Вставить и быть грустным

Я рекомендую не использовать equals() + hashCode() с неизвестными реализациями Type. Используйте функцию канонизации для преобразования в конкретную известную реализацию и сравнивайте только те, которыми вы управляете.

Ответ 2

Вот небольшой эксперимент, который опирается непосредственно на Sun API и рефлексию (то есть использует рефлексию для работы с классами, которые реализуют рефлексию):

import java.lang.Class;
import java.lang.reflect.*;
import java.util.Arrays;
import sun.reflect.generics.reflectiveObjects.*;

class Types {

  private static Constructor<ParameterizedTypeImpl> PARAMETERIZED_TYPE_CONS =
    ((Constructor<ParameterizedTypeImpl>)
      ParameterizedTypeImpl
      .class
      .getDeclaredConstructors()
      [0]
    );

  static {
      PARAMETERIZED_TYPE_CONS.setAccessible(true);
  }

  /** 
   * Helper method for invocation of the 
   *'ParameterizedTypeImpl' constructor. 
   */
  public static ParameterizedType parameterizedType(
    Class<?> raw,
    Type[] paramTypes,
    Type owner
  ) {
    try {
      return PARAMETERIZED_TYPE_CONS.newInstance(raw, paramTypes, owner);
    } catch (Exception e) {
      throw new Error("TODO: better error handling", e);
    }
  }

  // (similarly for 'GenericArrayType', 'WildcardType' etc.)

  /** Substitution of type variables. */
  public static Type substituteTypeVariable(
    final Type inType,
    final TypeVariable<?> variable,
    final Type replaceBy
  ) {
    if (inType instanceof TypeVariable<?>) {
      return replaceBy;
    } else if (inType instanceof ParameterizedType) {
      ParameterizedType pt = (ParameterizedType) inType;
      return parameterizedType(
        ((Class<?>) pt.getRawType()),
        Arrays.stream(pt.getActualTypeArguments())
          .map((Type x) -> substituteTypeVariable(x, variable, replaceBy))
          .toArray(Type[]::new),
        pt.getOwnerType()
      );
    } else {
      throw new Error("TODO: all other cases");
    }
  }

  // example
  public static void main(String[] args) throws InstantiationException {

    // type in which we will replace a variable is 'List<E>'
    Type t = 
      java.util.LinkedList
      .class
      .getGenericInterfaces()
      [0];

    // this is the variable 'E' (hopefully, stability not guaranteed)
    TypeVariable<?> v = 
      ((Class<?>)
        ((ParameterizedType) t)
        .getRawType()
      )
      .getTypeParameters()
      [0];

    // This should become 'List<String>'
    Type s = substituteTypeVariable(t, v, String.class);

    System.out.println("before: " + t);
    System.out.println("after:  " + s);
  }
}

Результат замены E на String в List<E> выглядит следующим образом:

before: java.util.List<E>
after:  java.util.List<java.lang.String>

Основная идея заключается в следующем:

• Получить классы sun.reflect.generics.reflectiveObjects.XyzImpl
• Получить их конструкторы, убедиться, что они accessible
• .newInstance вызовы конструктора .newInstance во вспомогательных методах
• Используйте вспомогательные методы в простом рекурсивном методе под названием substituteTypeVariable который перестраивает Type -expressions с переменными типа, замененными конкретными типами.

Я не реализовывал каждый отдельный случай, но он должен работать и с более сложными вложенными типами (из-за рекурсивного вызова substituteTypeVariable).

Компилятору не очень нравится этот подход, он генерирует предупреждения об использовании внутреннего API Sun:

предупреждение: ParameterizedTypeImpl является внутренним частным API и может быть удален в будущем выпуске

но для этого есть @SuppressWarnings.

Приведенный выше Java-код был получен путем перевода следующего небольшого фрагмента Scala (вот почему код Java может выглядеть немного странно и не совсем Java-идиоматическим):

object Types {

  import scala.language.existentials // suppress warnings
  import java.lang.Class
  import java.lang.reflect.{Array => _, _}
  import sun.reflect.generics.reflectiveObjects._

  private val ParameterizedTypeCons = 
    classOf[ParameterizedTypeImpl]
    .getDeclaredConstructors
    .head
    .asInstanceOf[Constructor[ParameterizedTypeImpl]]

  ParameterizedTypeCons.setAccessible(true)

  /** Helper method for invocation of the 'ParameterizedTypeImpl' constructor. */
  def parameterizedType(raw: Class[_], paramTypes: Array[Type], owner: Type)
  : ParameterizedType = {
    ParameterizedTypeCons.newInstance(raw, paramTypes, owner)
  }

  // (similarly for 'GenericArrayType', 'WildcardType' etc.)

  /** Substitution of type variables. */
  def substituteTypeVariable(
    inType: Type,
    variable: TypeVariable[_],
    replaceBy: Type
  ): Type = {
    inType match {
      case v: TypeVariable[_] => replaceBy
      case pt: ParameterizedType => parameterizedType(
        pt.getRawType.asInstanceOf[Class[_]],
        pt.getActualTypeArguments.map(substituteTypeVariable(_, variable, replaceBy)),
        pt.getOwnerType
      )
      case sthElse => throw new NotImplementedError()
    }
  }

  // example
  def main(args: Array[String]): Unit = {

    // type in which we will replace a variable is 'List<E>'
    val t = 
      classOf[java.util.LinkedList[_]]
      .getGenericInterfaces
      .head

    // this is the variable 'E' (hopefully, stability not guaranteed)
    val v = 
      t
      .asInstanceOf[ParameterizedType]
      .getRawType
      .asInstanceOf[Class[_]]          // should be 'List<E>' with parameter
      .getTypeParameters
      .head                            // should be 'E'

    // This should become 'List<String>'
    val s = substituteTypeVariable(t, v, classOf[String])

    println("before: " + t)
    println("after:  " + s)
  }
}