Java TypeResolver类代码示例

import com.fasterxml.classmate.TypeResolver; //导入依赖的package包/类
@Bean
public Docket thingsboardApi() {
    TypeResolver typeResolver = new TypeResolver();
    final ResolvedType jsonNodeType =
            typeResolver.resolve(
                    JsonNode.class);
    final ResolvedType stringType =
            typeResolver.resolve(
                    String.class);

      return new Docket(DocumentationType.SWAGGER_2)
              .groupName("iotp")
              .apiInfo(apiInfo())
              .alternateTypeRules(
                  new AlternateTypeRule(
                          jsonNodeType,
                          stringType))
              .select()
              .paths(apiPaths())
              .build()
              .securitySchemes(newArrayList(jwtTokenKey()))
              .securityContexts(newArrayList(securityContext()));
}
 

import com.fasterxml.classmate.TypeResolver; //导入依赖的package包/类
/**
 * Creates for the dynamic documentation necessary REST API Docket.
 * @param typeResolver The type resolver. Must not be <code>null</code>.
 * @return The requested REST API Docket.
 */
public static Docket createIndoorRestApiDocket(TypeResolver typeResolver) {
    return new Docket(DocumentationType.SWAGGER_2)
            .select()
            .apis(RequestHandlerSelectors.any())
            .paths(Predicates.not(PathSelectors.regex(EXCLUDE_ERROR_PATH_REGEX)))
            .build()
            .pathMapping(ROOT_PATH)
            .directModelSubstitute(LocalDate.class,
                    String.class)
            .genericModelSubstitutes(ResponseEntity.class)
            .alternateTypeRules(
                    newRule(typeResolver.resolve(DeferredResult.class,
                            typeResolver.resolve(ResponseEntity.class, WildcardType.class)),
                            typeResolver.resolve(WildcardType.class)))
            .useDefaultResponseMessages(false)
            .enableUrlTemplating(false)
            .tags(new Tag(TAG_NAME, TAG_DESCRIPTION)).apiInfo(apiInfo());
}
 

import com.fasterxml.classmate.TypeResolver; //导入依赖的package包/类
@SneakyThrows
protected NavigableIndex(DataSource dataSource, Attribute<O, A> attribute) {
    super(attribute instanceof SerializableComparableAttribute ? ((SerializableComparableAttribute) attribute)
            .getAttribute() : attribute, new HashSet<Class<?
            extends Query>>
            () {{
        add(Equal.class);
        add(LessThan.class);
        add(GreaterThan.class);
        add(Between.class);
        add(Has.class);
        add(Min.class);
        add(Max.class);
    }});
    comparableAttribute = attribute;
    this.dataSource = dataSource;
    layout = Layout.forClass(comparableAttribute.getEffectiveObjectType());
    TypeResolver typeResolver = new TypeResolver();
    ResolvedType resolvedType = typeResolver.resolve(comparableAttribute.getAttributeType());
    attributeTypeHandler = TypeHandler.lookup(resolvedType);
    init();
}
 

import com.fasterxml.classmate.TypeResolver; //导入依赖的package包/类
@SneakyThrows
protected EqualityIndex(DataSource dataSource, Attribute<O, A> attribute, boolean unique) {
    super(attribute, new HashSet<Class<? extends Query>>() {{
        add(Equal.class);
        add(Has.class);
    }});
    this.dataSource = dataSource;
    this.unique = unique;
    layout = Layout.forClass(attribute.getEffectiveObjectType());
    TypeResolver typeResolver = new TypeResolver();
    ResolvedType resolvedType;
    if (attribute instanceof ReflectableAttribute) {
        resolvedType = typeResolver.resolve(((ReflectableAttribute) attribute).getAttributeReflectedType());
    } else {
        resolvedType = typeResolver.resolve(attribute.getAttributeType());
    }
    attributeTypeHandler = TypeHandler.lookup(resolvedType);
    init();
}
 

import com.fasterxml.classmate.TypeResolver; //导入依赖的package包/类
@Bean
public Docket thingsboardApi() {
    TypeResolver typeResolver = new TypeResolver();
    final ResolvedType jsonNodeType =
            typeResolver.resolve(
                    JsonNode.class);
    final ResolvedType stringType =
            typeResolver.resolve(
                    String.class);

      return new Docket(DocumentationType.SWAGGER_2)
              .groupName("thingsboard")
              .apiInfo(apiInfo())
              .alternateTypeRules(
                  new AlternateTypeRule(
                          jsonNodeType,
                          stringType))
              .select()
              .paths(apiPaths())
              .build()
              .securitySchemes(newArrayList(jwtTokenKey()))
              .securityContexts(newArrayList(securityContext()));
}
 

import com.fasterxml.classmate.TypeResolver; //导入依赖的package包/类
@Before
public void setup() throws Exception {
    MockitoAnnotations.initMocks(this);

    Method method = this.getClass().getMethod("test", new Class<?>[] { Pageable.class, Integer.class });
    RequestHandler handler = new WebMvcRequestHandler(null, new HandlerMethod(this, method));
    DocumentationContext docContext = mock(DocumentationContext.class);
    RequestMappingContext reqContext = new RequestMappingContext(docContext, handler);
    builder = spy(new OperationBuilder(null));
    context = new OperationContext(builder, RequestMethod.GET, reqContext, 0);

    resolver = new TypeResolver();
    List<TypeNameProviderPlugin> plugins = new LinkedList<>();
    extractor = new TypeNameExtractor(resolver, SimplePluginRegistry.create(plugins));
    plugin = new PageableParameterBuilderPlugin(extractor, resolver);
}
 

import com.fasterxml.classmate.TypeResolver; //导入依赖的package包/类
@Bean
public Docket bpaTestapplicationApi(final TypeResolver typeResolver) {

  return new Docket(DocumentationType.SWAGGER_2)
    .select()
    .apis(RequestHandlerSelectors.any())
    .paths(Predicates.not(PathSelectors.regex("/error.*")))
    .build()
    .pathMapping("/")
    .apiInfo(new ApiInfoBuilder()
      .title("Book Order Process")
      .version("1.0-SNAPSHOT")
      .build());
}
 

import com.fasterxml.classmate.TypeResolver; //导入依赖的package包/类
private Layout(Class<T> klass)
        throws IntrospectionException, NoSuchAlgorithmException, IllegalAccessException,
               TypeHandler.TypeHandlerException {
    typeResolver = new TypeResolver();
    methodHandles = MethodHandles.lookup();

    layoutClass = klass;
    properties = new ArrayList<>();
    constructorProperties = new ArrayList<>();

    ClassAnalyzer.Constructor<T> analyzerConstructor = findLayoutConstructor(layoutClass);
    constructor = analyzerConstructor.getConstructor();
    deriveProperties(layoutClass, analyzerConstructor, false);

    // Prepare the hash
    MessageDigest digest = MessageDigest.getInstance(DIGEST_ALGORITHM);

    name = klass.isAnnotationPresent(LayoutName.class) ? klass.getAnnotation(LayoutName.class)
                                                              .value() : klass.getName();

    // It is important to include class name into the hash as there could be situations
    // when POJOs have indistinguishable layouts, and therefore it is impossible to
    // guarantee that we'd pick the right class
    digest.update(name.getBytes());

    for (Property<T> property : properties) {
        digest.update(property.getName().getBytes());
        digest.update(property.getTypeHandler().getFingerprint());
    }

    this.hash = digest.digest();
}
 

import com.fasterxml.classmate.TypeResolver; //导入依赖的package包/类
public OptionalTypeHandler(List<ResolvedType> typeParameters) throws TypeHandlerException {
    if (typeParameters.size() != 1) {
        throw new IllegalArgumentException("Optional type parameters should be specified");
    }
    ResolvedType resolvedType = new TypeResolver().resolve(typeParameters.get(0));
    wrappedHandler = TypeHandler.lookup(resolvedType);
}
 

import com.fasterxml.classmate.TypeResolver; //导入依赖的package包/类
public ListTypeHandler(List<ResolvedType> typeParameters) throws TypeHandlerException {
    if (typeParameters.size() != 1) {
        throw new IllegalArgumentException("List type parameter should be specified");
    }
    ResolvedType resolvedType = new TypeResolver().resolve(typeParameters.get(0));
    wrappedHandler = TypeHandler.lookup(resolvedType);
}
 

import com.fasterxml.classmate.TypeResolver; //导入依赖的package包/类
public MapTypeHandler(List<ResolvedType> typeParameters) throws TypeHandlerException {
    if (typeParameters.size() != 2) {
        throw new IllegalArgumentException("Map type parameters should be specified");
    }
    ResolvedType resolvedKeyType = new TypeResolver().resolve(typeParameters.get(0));
    wrappedKeyHandler = TypeHandler.lookup(resolvedKeyType);
    ResolvedType resolvedValueType = new TypeResolver().resolve(typeParameters.get(1));
    wrappedValueHandler = TypeHandler.lookup(resolvedValueType);
}
 

import com.fasterxml.classmate.TypeResolver; //导入依赖的package包/类
@Test @SneakyThrows
public void fingerprintShape() {
    TypeHandler typeHandlerA = TypeHandler.lookup(new TypeResolver().resolve(A.class));
    TypeHandler typeHandlerA1 = TypeHandler.lookup(new TypeResolver().resolve(A1.class));
    TypeHandler typeHandlerA2 = TypeHandler.lookup(new TypeResolver().resolve(A2.class));
    assertTrue(Arrays.equals(typeHandlerA.getFingerprint(), typeHandlerA1.getFingerprint()));
    assertFalse(Arrays.equals(typeHandlerA.getFingerprint(), typeHandlerA2.getFingerprint()));
}
 

import com.fasterxml.classmate.TypeResolver; //导入依赖的package包/类
/**
 * Protected constructor, called by subclasses.
 *
 * @param attribute        The attribute on which the index will be built
 * @param supportedQueries The set of {@link Query} types which the subclass implementation supports
 */
@SneakyThrows
protected AbstractAttributeIndex(Attribute<O, A> attribute, Set<Class<? extends Query>>
        supportedQueries) {
    super(attribute, supportedQueries);

    Type t;
    if (attribute instanceof ReflectableAttribute) {
        t = ((ReflectableAttribute) attribute).getAttributeReflectedType();
    } else {
        t = attribute.getAttributeType();
    }

    ResolvedType attributeType = new TypeResolver().resolve(t);

    attrTypeHandler = TypeHandler.lookup(attributeType);
    attributeSerializer = serialization.getSerializer(attrTypeHandler);
    attributeDeserializer = serialization.getDeserializer(attrTypeHandler);

    ResolvedType objectType = new TypeResolver().resolve(attribute.getEffectiveObjectType());
    ObjectTypeHandler objectTypeHandler = (ObjectTypeHandler) TypeHandler.lookup(objectType);
    if (!(objectTypeHandler instanceof ObjectTypeHandler)) {
        throw new RuntimeException("Index " + attribute.getAttributeName() +
                                           " is not an object, but " + objectType.getBriefDescription());
    } else {
        objectSerializer = serialization.getSerializer(objectTypeHandler.getWrappedClass());
        objectDeserializer = serialization.getDeserializer(objectTypeHandler.getWrappedClass());
    }
}
 

import com.fasterxml.classmate.TypeResolver; //导入依赖的package包/类
@Test
@SneakyThrows
public void generics() {
    SimpleAttribute<Car, List<String>> FEATURES_LIST = new SimpleAttribute<Car, List<String>>("features") {

        @SneakyThrows
        @Override public Type getAttributeReflectedType() {
            return AbstractAttributeIndexTest.class.getField("list").getGenericType();
        }

        @Override
        public List<String> getValue(Car car, QueryOptions queryOptions) {
            return car.getFeatures();
        }
    };

    AttributeIndex index = new AttributeIndex<>(FEATURES_LIST, new HashSet<Class<? extends Query>>() {{}});

    list = Arrays.asList("Hello");
    TypeResolver typeResolver = new TypeResolver();
    ResolvedType klassType = typeResolver.resolve(getClass().getField("list").getGenericType());
    TypeHandler listTypeHandler = TypeHandler.lookup(klassType);
    ByteBuffer buffer = ByteBuffer.allocate(index.attributeSerializer.size(listTypeHandler, list));
    index.attributeSerializer.serialize(listTypeHandler, list, buffer);
    buffer.rewind();
    List<String> deserialized = (List<String>) index.attributeDeserializer.deserialize(listTypeHandler, buffer);
    assertEquals(deserialized.get(0), list.get(0));
}
 

import com.fasterxml.classmate.TypeResolver; //导入依赖的package包/类
@Test
public void testPageableParameterBuilderPlugin() {
    TypeResolver resolver = new TypeResolver();
    List<TypeNameProviderPlugin> plugins = new LinkedList<>();
    TypeNameExtractor extractor = new TypeNameExtractor(resolver, SimplePluginRegistry.create(plugins));
    PageableParameterBuilderPlugin plugin = config.pageableParameterBuilderPlugin(extractor, resolver);
    assertThat(plugin.getResolver()).isEqualTo(resolver);
    assertThat(plugin.getNameExtractor()).isEqualTo(extractor);
}