import org.springframework.hateoas.Links; //导入依赖的package包/类
@Test
public void accessServiceUsingRestTemplate() {

	// Access root resource

	URI uri = URI.create(String.format(SERVICE_URI, port));
	RequestEntity<Void> request = RequestEntity.get(uri).accept(HAL_JSON).build();
	Resource<Object> rootLinks = restOperations.exchange(request, new ResourceType<Object>() {}).getBody();
	Links links = new Links(rootLinks.getLinks());

	// Follow stores link

	Link storesLink = links.getLink("stores").expand();
	request = RequestEntity.get(URI.create(storesLink.getHref())).accept(HAL_JSON).build();
	Resources<Store> stores = restOperations.exchange(request, new ResourcesType<Store>() {}).getBody();

	stores.getContent().forEach(store -> log.info("{} - {}", store.name, store.address));
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
@Override
public Class<?> resolveType(Class<?> declaredType, Links resourceLinks, Configuration configuration) {
	
	ResourceTypeInfo info = AnnotationUtils.findAnnotation(declaredType, ResourceTypeInfo.class);
	
	if (info == null) {
		return declaredType;
	}
	
	boolean customTypeResolverIsSpecified = info.typeResolver() != ResourceTypeInfo.NullTypeResolver.class;
	
	Assert.state(info.subtypes().length > 0 ^ customTypeResolverIsSpecified,
		"one of subtypes or typeResolver must be specified");
	
	TypeResolver delegateTypeResolver = customTypeResolverIsSpecified
		? BeanUtils.instantiate(info.typeResolver())
		: new SelfLinkTypeResolver(info.subtypes());
	
	return delegateTypeResolver.resolveType(declaredType, resourceLinks, configuration);
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
@Override
public Class<?> resolveType(Class<?> declaredType, Links resourceLinks, Configuration configuration) {

	Link self = resourceLinks.getLink(Link.REL_SELF);
	
	if (self == null) {
		return declaredType;
	}

	for (Class<?> candidateClass : subtypes) {
		RemoteResource candidateClassInfo = AnnotationUtils.findAnnotation(candidateClass, RemoteResource.class);
		
		if (candidateClassInfo == null) {
			continue;
		}
		
		String resourcePath = candidateClassInfo.value();
		
		String resourceBaseUriString = UriComponentsBuilder.fromUri(configuration.getBaseUri())
			.path(resourcePath)
			.toUriString();
		
		String selfLinkUriString = toAbsoluteUriString(self.getHref(), configuration.getBaseUri());
		
		if (selfLinkUriString.startsWith(resourceBaseUriString + "/")) {
			return candidateClass;
		}
	}
	
	return declaredType;
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
@Override
public Resource<?> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException,
	JsonProcessingException {

	ObjectNode node = p.readValueAs(ObjectNode.class);

	ObjectMapper mapper = (ObjectMapper) p.getCodec();

	ResourceSupport resource = mapper.convertValue(node, ResourceSupport.class);
	Links links = new Links(resource.getLinks());
	
	Class<?> resourceContentType = typeResolver.resolveType(handledType(), links, configuration);
	return createResource(resourceContentType, node, links, mapper);
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
@Test
public void resolveTypeWithNoResourceTypeInfoReturnsDeclaredType() {
	Class<?> type = resolver.resolveType(TypeWithoutInfo.class,
		new Links(new Link("http://x", Link.REL_SELF)), Configuration.build());
	
	assertThat(type, Matchers.<Class<?>>equalTo(TypeWithoutInfo.class));
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
@Test
public void resolveTypeWithSubtypesAndNoMatchingSubtypeReturnsDeclaredType() {
	Class<?> type = resolver.resolveType(TypeWithSubtypes.class,
		new Links(new Link("http://x", Link.REL_SELF)), Configuration.build());
	
	assertThat(type, Matchers.<Class<?>>equalTo(TypeWithSubtypes.class));
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
@Test
public void resolveTypeWithSubtypesAndMatchingAbsoluteUriSubtypeReturnsSubtype() {
	Configuration config = Configuration.builder().setBaseUri("http://x.com").build();
	
	Class<?> type = resolver.resolveType(TypeWithSubtypes.class,
		new Links(new Link("http://x.com/2/1", Link.REL_SELF)), config);
	
	assertThat(type, Matchers.<Class<?>>equalTo(TypeWithSubtypesSubtype2.class));
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
@Test
public void resolveTypeWithSubtypesAndMatchingAbsolutePathReferenceUriSubtypeReturnsSubtype() {
	Configuration config = Configuration.builder().setBaseUri("http://x.com").build();
	
	Class<?> type = resolver.resolveType(TypeWithSubtypes.class,
		new Links(new Link("/2/1", Link.REL_SELF)), config);
	
	assertThat(type, Matchers.<Class<?>>equalTo(TypeWithSubtypesSubtype2.class));
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
@Test
public void resolveTypeWithResolverReturnsResolvedType() {
	Links links = new Links(new Link("_"));
	Configuration config = Configuration.build();
	
	doReturn(TypeWithResolverSubtype.class)
		.when(Resolver.mockResolver).resolveType(TypeWithResolver.class, links, config);
	
	Class<?> type = resolver.resolveType(TypeWithResolver.class, links, config);
	
	assertThat(type, Matchers.<Class<?>>equalTo(TypeWithResolverSubtype.class));
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
private static ResourceDeserializer declaredTypeResourceDeserializer() {
	TypeResolver declaredTypeTypeResolver = mock(TypeResolver.class);
	
	when(declaredTypeTypeResolver.resolveType(any(Class.class), any(Links.class), any(Configuration.class)))
		.then(new Answer<Class<?>>() {
		
			@Override
			public Class<?> answer(InvocationOnMock invocation) throws Throwable {
				return invocation.getArgumentAt(0, Class.class);
			}
		});
	
	return new ResourceDeserializer(Object.class, declaredTypeTypeResolver, Configuration.build());
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
@Test
public void deserializeReturnsObjectOfResolvedType() throws Exception {
	doReturn(ResolvedType.class).when(typeResolver).resolveType(DeclaredType.class,
		new Links(new Link("http://x.com/1", Link.REL_SELF)), configuration);
	
	Resource<DeclaredType> resource = mapper.readValue(
		"{\"field\":\"x\",\"_links\":{\"self\":{\"href\":\"http://x.com/1\"}}}",
		new TypeReference<Resource<DeclaredType>>() { /* generic type reference */ });
	
	assertThat("class", resource.getContent().getClass(), Matchers.<Class<?>>equalTo(ResolvedType.class));
	assertThat("field", ((ResolvedType) resource.getContent()).getField(), is("x"));
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
public void addSearchLink(Collection<Link> links, Class type) {
            Link collectionLink = repositoryEntityLinks.linkToCollectionResource(type).expand();

    String relBase = collectionLink.getRel();


    Links searchLinks = repositoryEntityLinks.linksToSearchResources(type);

    if (searchLinks == null || searchLinks.isEmpty()) {
        logger.debug("No search links found for class {}", type);
    } else {
        logger.debug("Search links found for class {}: {} ", type, searchLinks);

        String href = collectionLink.getHref() + "/search";
        String rel = relBase + SEARCH_REL_SUFFIX;
        Link searchesLink = new Link(href, rel);

        links.add(searchesLink);

    }
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
private static <T> Resource<T> createResource(Class<T> contentType, ObjectNode sourceTree,
	Links links, ObjectMapper mapper) {
	
	T content = mapper.convertValue(sourceTree, contentType);
	return new Resource<>(content, links);
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
@Override
public Class<?> resolveType(Class<?> declaredType, Links resourceLinks, Configuration configuration) {
	return mockResolver.resolveType(declaredType, resourceLinks, configuration);
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
@Test
public void resolveTypeWithUnderspecifiedResourceTypeInfoThrowsException() {
	thrown.expect(IllegalStateException.class);

	resolver.resolveType(TypeWithUnderspecifiedInfo.class, new Links(), Configuration.build());
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
@Test
public void resolveTypeWithOverspecifiedResourceTypeInfoThrowsException() {
	thrown.expect(IllegalStateException.class);
	
	resolver.resolveType(TypeWithOverspecifiedInfo.class, new Links(), Configuration.build());
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
@Test
public void resolveTypeWithSubtypesAndNoSelfLinkReturnsDeclaredType() {
	Class<?> type = resolver.resolveType(TypeWithSubtypes.class, new Links(), Configuration.build());
	
	assertThat(type, Matchers.<Class<?>>equalTo(TypeWithSubtypes.class));
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
@Override
public void serialize(List<Link> value, JsonGenerator jgen, SerializerProvider provider)
        throws IOException, JsonGenerationException {

    // sort links according to their relation
    Map<String, List<Object>> sortedLinks = new LinkedHashMap<String, List<Object>>();
    List<Link> links = new ArrayList<Link>();

    boolean prefixingRequired = curieProvider != null;
    boolean curiedLinkPresent = false;
    boolean skipCuries = !jgen.getOutputContext().getParent().inRoot();

    Object currentValue = jgen.getCurrentValue();

    if (currentValue instanceof Resources) {
        if (mapper.hasCuriedEmbed((Resources<?>) currentValue)) {
            curiedLinkPresent = true;
        }
    }

    for (Link link : value) {

        if (link.equals(CURIES_REQUIRED_DUE_TO_EMBEDS)) {
            continue;
        }

        String rel = prefixingRequired ? curieProvider.getNamespacedRelFrom(link) : link.getRel();

        if (!link.getRel().equals(rel)) {
            curiedLinkPresent = true;
        }

        if (sortedLinks.get(rel) == null) {
            sortedLinks.put(rel, new ArrayList<Object>());
        }

        links.add(link);

        sortedLinks.get(rel).add(toHalLink(link));
    }

    if (!skipCuries && prefixingRequired && curiedLinkPresent) {

        ArrayList<Object> curies = new ArrayList<Object>();
        curies.add(curieProvider.getCurieInformation(new Links(links)));

        sortedLinks.put("curies", curies);
    }

    TypeFactory typeFactory = provider.getConfig().getTypeFactory();
    JavaType keyType = typeFactory.uncheckedSimpleType(String.class);
    JavaType valueType = typeFactory.constructCollectionType(ArrayList.class, Object.class);
    JavaType mapType = typeFactory.constructMapType(HashMap.class, keyType, valueType);

    MapSerializer serializer = MapSerializer.construct(new String[]{}, mapType, true, null,
            provider.findKeySerializer(keyType, null), new OptionalListJackson2Serializer(property), null);

    serializer.serialize(sortedLinks, jgen, provider);
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
@Override
public Collection<? extends Object> getCurieInformation(Links links) {
	return Collections.unmodifiableCollection(curies.values());
}
 

import org.springframework.hateoas.Links; //导入依赖的package包/类
/**
 * Returns an object to render as the base curie information. Implementations have to make sure, the retunred
 * instances renders as defined in the spec.
 * 
 * @param links the {@link Links} that have been added to the response so far.
 * @return must not be {@literal null}.
 */
Collection<? extends Object> getCurieInformation(Links links);