Java 反射介绍

/**
 * 实现Comparable，并不是为了比较，而是为了得到泛型T的实际类型
 */
abstract class TypeReference<T> {

    private final Type type;

    protected TypeReference() {
        Type superClass = getClass().getGenericSuperclass();
        this.type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
    }

    public Type getType() {
        return type;
    }
}

class ReflectUtils {

    /**
     * 根据给定的类型，将字符串转换为对应实例
     */
    public static <R> R convertReflective(String source, TypeReference<R> type) throws Exception {
        Type actualType = type.getType();
        if (actualType instanceof ParameterizedType) {
            return convertReflectiveForParameterizedType(source, actualType);
        } else if (actualType instanceof Class) {
            return convertReflectiveForClass(source, actualType);
        } else if (actualType instanceof GenericArrayType) {
            throw new Exception("尚未实现");
        } else {
            throw new Exception("啥类型都不是呀");
        }
    }

    /**
     * 带泛型的类型
     */
    private static <R> R convertReflectiveForParameterizedType(String source, Type type) {
        ParameterizedType rType = (ParameterizedType) type;
        Object result = null;
        Type rawType = rType.getRawType();
        Type[] actualTypes = rType.getActualTypeArguments();
        if (rawType.equals(List.class)) {
            Type actualType = actualTypes[0];
            result = Arrays.stream(source.substring(1, source.length() - 1).split(","))
                .map(String::trim)
                .map((String it) -> convertReflectiveForClass(it, actualType))
                .collect(Collectors.toList());
        } else {
            System.out.println("暂不支持");
        }
        return (R) result;
    }

    /**
     * 非泛型的普通类型
     */
    private static <R> R convertReflectiveForClass(String source, Type type) {
        Object result = 0;
        if (String.class.equals(type)) {
            result = source;
        } else if (Integer.class.equals(type)) {
            result = Integer.valueOf(source);
        } else if (Long.class.equals(type)) {
            result = Long.valueOf(source);
        } else {
            result = source;
        }
        return (R) result;
    }

}

public class Demo {

    public static void main(String[] args) throws Exception {
        // 字符串转字符串
        String s = ReflectUtils.convertReflective("这是普通字符串", new TypeReference<String>() {});
        System.out.println(s);
        // 字符串转列表
        List<String> list = ReflectUtils.convertReflective("[1,2,字符串]", new TypeReference<List<String>>() {});
        list.forEach(System.out::println);
    }

}

public static <T> Constructor<T> getConstructor(Class<T> clazz, Class<?>... parameterTypes) {
  if (null == clazz) {
    return null;
  }

  final Constructor<?>[] constructors = getConstructors(clazz);
  Class<?>[] pts;
  for (Constructor<?> constructor : constructors) {
    pts = constructor.getParameterTypes();
    if (ClassUtil.isAllAssignableFrom(pts, parameterTypes)) {
      // 构造可访问
      setAccessible(constructor);
      return (Constructor<T>) constructor;
    }
  }
  return null;
}

class MyClass {

    public void testMethod() {
    }

}

@BenchmarkMode(Mode.SingleShotTime)
@Warmup(iterations = 1, time = 10)
@Measurement(iterations = 1, time = 1)
@State(Scope.Thread)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class ReflectionBenchmark {

    @Param({"1000000", "100000000"})
    int times;

    @Benchmark
    @Fork(1)
    public void invokeReflective() throws Exception {
        MyClass myClass = new MyClass();
        Method method = MyClass.class.getDeclaredMethod("testMethod");
        for (int i = 0; i < times; i++) {
            method.invoke(myClass);
        }
    }

    @Benchmark
    @Fork(1)
    public void invokeDirect() {
        MyClass myClass = new MyClass();
        for (int i = 0; i < times; i++) {
            myClass.testMethod();
        }
    }

    public static void main(String[] args) throws RunnerException {
        Options options = new OptionsBuilder()
            .include(ReflectionBenchmark.class.getSimpleName())
            .build();
        new Runner(options).run();
    }
}