Variáveis de modelo com ControllerLinkBuilder

StackOverflow https://stackoverflow.com//questions/25017037

  •  21-12-2019
  •  | 
  •  

Pergunta

Eu quero a minha resposta para incluir este:

"keyMaps":{
  "href":"http://localhost/api/keyMaps{/keyMapId}",
  "templated":true
 }

Isso é fácil de conseguir:

add(new Link("http://localhost/api/keyMaps{/keyMapId}", "keyMaps"));

Mas, claro, eu prefiro usar o ControllerLinkBuilder, como este:

add(linkTo(methodOn(KeyMapController.class).getKeyMap("{keyMapId}")).withRel("keyMaps"));

O problema é que pelo tempo que a variável "{keyMapId}" atinge o UriTemplate construtor, ela foi incluída em uma URL codificada:

http://localhost/api/keyMaps/%7BkeyMapId%7D

Assim UriTemplate construtor não reconhecê-lo como contendo uma variável.

Como posso persuadir ControllerLinkBuilder que eu quero usar variáveis de modelo?

Foi útil?

Solução

Começando com este commit:

https://github.com/spring-projects/spring-hateoas/commit/2daf8aabfb78b6767bf27ac3e473832c872302c7

Você pode agora passar null onde path é o esperado.Ele trabalha para mim, sem soluções.

resource.add(linkTo(methodOn(UsersController.class).someMethod(null)).withRel("someMethod"));

E o resultado:

    "someMethod": {
        "href": "http://localhost:8080/api/v1/users/{userId}",
        "templated": true
    },

Verifique, também, problemas relacionados com: https://github.com/spring-projects/spring-hateoas/issues/545

Outras dicas

Ele olha para mim como o estado atual de Primavera-HATEOAS não permitir que esta via ControllerLinkBuilder (Gostaria muito de ser provado errado), então eu implementou esta me usando as seguintes classes para modelagem de parâmetros de consulta:

public class TemplatedLinkBuilder {

    private static final TemplatedLinkBuilderFactory FACTORY = new TemplatedLinkBuilderFactory();
    public static final String ENCODED_LEFT_BRACE = "%7B";
    public static final String ENCODED_RIGHT_BRACE = "%7D";

    private UriComponentsBuilder uriComponentsBuilder;

    TemplatedLinkBuilder(UriComponentsBuilder builder) {
        uriComponentsBuilder = builder;
    }

    public static TemplatedLinkBuilder linkTo(Object invocationValue) {
        return FACTORY.linkTo(invocationValue);
    }

    public static <T> T methodOn(Class<T> controller, Object... parameters) {
        return DummyInvocationUtils.methodOn(controller, parameters);
    }

    public Link withRel(String rel) {
        return new Link(replaceTemplateMarkers(uriComponentsBuilder.build().toString()), rel);
    }

    public Link withSelfRel() {
        return withRel(Link.REL_SELF);
    }

    private String replaceTemplateMarkers(String encodedUri) {
        return encodedUri.replaceAll(ENCODED_LEFT_BRACE, "{").replaceAll(ENCODED_RIGHT_BRACE, "}");
    }

}

e

public class TemplatedLinkBuilderFactory {

    private final ControllerLinkBuilderFactory controllerLinkBuilderFactory;

    public TemplatedLinkBuilderFactory() {
        this.controllerLinkBuilderFactory = new ControllerLinkBuilderFactory();
    }

    public TemplatedLinkBuilder linkTo(Object invocationValue) {
        ControllerLinkBuilder controllerLinkBuilder = controllerLinkBuilderFactory.linkTo(invocationValue);
        UriComponentsBuilder uriComponentsBuilder = controllerLinkBuilder.toUriComponentsBuilder();

        Assert.isInstanceOf(DummyInvocationUtils.LastInvocationAware.class, invocationValue);
        DummyInvocationUtils.LastInvocationAware invocations = (DummyInvocationUtils.LastInvocationAware) invocationValue;
        DummyInvocationUtils.MethodInvocation invocation = invocations.getLastInvocation();
        Object[] arguments = invocation.getArguments();
        MethodParameters parameters = new MethodParameters(invocation.getMethod());

        for (MethodParameter requestParameter : parameters.getParametersWith(RequestParam.class)) {
            Object value = arguments[requestParameter.getParameterIndex()];
            if (value == null) {
                uriComponentsBuilder.queryParam(requestParameter.getParameterName(), "{" + requestParameter.getParameterName() + "}");
            }
        }
        return new TemplatedLinkBuilder(uriComponentsBuilder);
    }
}

Que incorpora o normal ControllerLinkBuilder e, em seguida, usa uma lógica similar para analisar para @RequestParam anotada parâmetros que são nulos e adicione-as para os parâmetros de consulta.Além disso, nosso cliente resuses estas modelo de URIs para realizar mais solicitações para o servidor.Para alcançar este objectivo e não precisa de se preocupar com excluindo as não utilizadas modelo params, eu tenho que realizar a operação inversa (troca de {params} com null), o que eu estou fazendo, usando um personalizado Primavera RequestParamMethodArgumentResolver como segue

public class TemplatedRequestParamResolver extends RequestParamMethodArgumentResolver {

    public TemplatedRequestParamResolver() {
        super(false);
    }

    @Override
    protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest webRequest) throws Exception {
        Object value = super.resolveName(name, parameter, webRequest);
        if (value instanceof Object[]) {
            Object[] valueAsCollection = (Object[])value;
            List<Object> resultList = new LinkedList<Object>();
            for (Object collectionEntry : valueAsCollection) {
                if (nullifyTemplatedValue(collectionEntry) != null) {
                    resultList.add(collectionEntry);
                }
            }
            if (resultList.isEmpty()) {
                value = null;
            } else {
                value = resultList.toArray();
            }
        } else{
            value = nullifyTemplatedValue(value);
        }
        return value;
    }

    private Object nullifyTemplatedValue(Object value) {
        if (value != null && value.toString().startsWith("{") && value.toString().endsWith("}")) {
            value = null;
        }
        return value;
    }

}

Também isso precisa para substituir o existente RequestParamMethodArgumentResolver o que eu faço com:

@Configuration
public class ConfigureTemplatedRequestParamResolver {

    private @Autowired RequestMappingHandlerAdapter adapter;

    @PostConstruct
    public void replaceArgumentMethodHandlers() {
        List<HandlerMethodArgumentResolver> argumentResolvers = new ArrayList<HandlerMethodArgumentResolver>(adapter.getArgumentResolvers());
        for (int cursor = 0; cursor < argumentResolvers.size(); ++cursor) {
            HandlerMethodArgumentResolver handlerMethodArgumentResolver = argumentResolvers.get(cursor);
            if (handlerMethodArgumentResolver instanceof RequestParamMethodArgumentResolver) {
                argumentResolvers.remove(cursor);
                argumentResolvers.add(cursor, new TemplatedRequestParamResolver());
                break;
            }
        }
        adapter.setArgumentResolvers(argumentResolvers);
    }

}

Infelizmente, apesar de { e } são caracteres válidos em um modelo URI, eles não são válidas em um URI, o que pode ser um problema para o seu código de cliente, dependendo de quão rigoroso é.Eu prefiro muito mais um ideal solução criada para a Primavera-HATEOAS!

Com versões mais recentes do spring-hateoas você pode fazer o seguinte:

UriComponents uriComponents = UriComponentsBuilder.fromUri(linkBuilder.toUri()).build();
UriTemplate template = new UriTemplate(uriComponents.toUriString())
   .with("keyMapId", TemplateVariable.SEGMENT);

vai te dar: http://localhost:8080/bla{/keyMapId}",

Fizemos o mesmo problema.Solução alternativa geral, é que nós temos a nossa própria LinkBuilder classe com um monte de estática ajudantes.Modelo queridos parecido com este:

public static Link linkToSubcategoriesTemplated(String categoryId){

    return new Link(
        new UriTemplate(
            linkTo(methodOn(CategoryController.class).subcategories(null, null, categoryId))
                .toUriComponentsBuilder().build().toUriString(),
            // register it as variable
            getBaseTemplateVariables()
        ),
        REL_SUBCATEGORIES
    );
}

private static TemplateVariables getBaseTemplateVariables() {
    return new TemplateVariables(
        new TemplateVariable("page", TemplateVariable.VariableType.REQUEST_PARAM),
        new TemplateVariable("sort", TemplateVariable.VariableType.REQUEST_PARAM),
        new TemplateVariable("size", TemplateVariable.VariableType.REQUEST_PARAM)
    );
}

Isso é para expor os parâmetros de um controlador de resposta de um PagedResource.

em seguida, na controladores nós chamamos isso de um acrescentar um withRel conforme necessário.

De acordo com a este problema comentário, isso será corrigido em uma versão futura da primavera-hateoas.

Por agora, há um menu drop-em substituição por ControllerLinkBuilder disponível a partir de de.escalon.hypermedia:spring-hateoas-ext no Maven Central.

Agora eu posso fazer isso:

import static de.escalon.hypermedia.spring.AffordanceBuilder.*

...

add(linkTo(methodOn(KeyMapController.class).getKeyMap(null)).withRel("keyMaps"));

Eu passo null como o valor do parâmetro para indicar eu quero usar uma variável de modelo.O nome da variável é automaticamente retirado do controlador.

Eu precisava de incluir um link com o modelo de variáveis na raiz de uma mola de dados resto aplicação, para obter o acesso através de traverson para um oauth2 token.Este está funcionando bem, talvez útil:

@Component
class RepositoryLinksResourceProcessor implements ResourceProcessor<RepositoryLinksResource> {

    @Override
    RepositoryLinksResource process(RepositoryLinksResource resource) {

        UriTemplate uriTemplate =  new UriTemplate(
                ControllerLinkBuilder.
                        linkTo(
                                TokenEndpoint,
                                TokenEndpoint.getDeclaredMethod("postAccessToken", java.security.Principal, Map )).
                        toUriComponentsBuilder().
                        build().
                        toString(),
                new TemplateVariables([
                        new TemplateVariable("username", TemplateVariable.VariableType.REQUEST_PARAM),
                        new TemplateVariable("password", TemplateVariable.VariableType.REQUEST_PARAM),
                        new TemplateVariable("clientId", TemplateVariable.VariableType.REQUEST_PARAM),
                        new TemplateVariable("clientSecret", TemplateVariable.VariableType.REQUEST_PARAM)
                ])
        )

        resource.add(
                new Link( uriTemplate,
                        "token"
                )
        )

        return resource
    }
}

Com base nos comentários anteriores eu ter implementado um método de ajuda genérico (contra primavera-hateoas-0.20.0) como um "temporário" solução alternativa.A aplicação leva em conta apenas RequestParameters e está longe de ser otimizadas ou bem testado.Ele pode ser útil para algumas outras pobre alma, viajando no mesmo buraco de coelho que: 

public static Link getTemplatedLink(final Method m, final String rel) {
    DefaultParameterNameDiscoverer disco = new DefaultParameterNameDiscoverer();

    ControllerLinkBuilder builder = ControllerLinkBuilder.linkTo(m.getDeclaringClass(), m);
    UriTemplate uriTemplate = new UriTemplate(UriComponentsBuilder.fromUri(builder.toUri()).build().toUriString());
    Annotation[][] parameterAnnotations = m.getParameterAnnotations();

    int param = 0;
    for (Annotation[] parameterAnnotation : parameterAnnotations) {
        for (Annotation annotation : parameterAnnotation) {
            if (annotation.annotationType().equals(RequestParam.class)) {
                RequestParam rpa = (RequestParam) annotation;
                String parameterName = rpa.name();
                if (StringUtils.isEmpty(parameterName)) parameterName = disco.getParameterNames(m)[param];
                uriTemplate = uriTemplate.with(parameterName, TemplateVariable.VariableType.REQUEST_PARAM);
            }
        }
        param++;
    }
    return new Link(uriTemplate, rel);
}
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top