Avec le Printemps, puis-je faire une option variable de chemin d'accès?

Avec Spring 3.0, puis-je disposer en option d'une variable de chemin d'accès?

Par exemple

@RequestMapping(value = "/json/{type}", method = RequestMethod.GET)
public @ResponseBody TestBean testAjax(
        HttpServletRequest req,
        @PathVariable String type,
        @RequestParam("track") String track) {
    return new TestBean();
}

Ici, je voudrais /json/abc ou /json appel à la même méthode.

Une solution évidente déclarer type comme un paramètre de la requête:

@RequestMapping(value = "/json", method = RequestMethod.GET)
public @ResponseBody TestBean testAjax(
        HttpServletRequest req,
        @RequestParam(value = "type", required = false) String type,
        @RequestParam("track") String track) {
    return new TestBean();
}

et puis /json?type=abc&track=aa ou /json?track=rr travaillera

InformationsquelleAutor Shamik | 2011-02-04

rest spring

170

Vous ne pouvez pas avoir en option des variables de chemin, mais vous pouvez avoir deux méthodes de contrôleur qui garde le même code de service:
```
@RequestMapping(value = "/json/{type}", method = RequestMethod.GET)
public @ResponseBody TestBean typedTestBean(
        HttpServletRequest req,
        @PathVariable String type,
        @RequestParam("track") String track) {
    return getTestBean(type);
}

@RequestMapping(value = "/json", method = RequestMethod.GET)
public @ResponseBody TestBean testBean(
        HttpServletRequest req,
        @RequestParam("track") String track) {
    return getTestBean();
}
```
- C'est une raison impérieuse pas pour utiliser les variables de chemin d'accès, à mon avis. La combinatoire prolifération peut rapidement sortir de la main.
- En fait non pas parce que le chemin ne peut être que complexe tout en étant rempli avec des composants en option. Si vous avez plus d'un ou max deux option chemin d'éléments, vous devriez sérieusement envisager de passer un peu de paramètres de la requête.
- Et pour certaines personnes, avoir le deuxième contrôleur d'appel de la méthode la première méthode de contrôleur peut fonctionner aussi bien, si, par exemple, les différents paramètre peut être fourni par d'autres moyens
- Veuillez envisager de mettre à jour votre réponse, au lieu de créer deux méthodes de contrôleur dans une version plus récente de Printemps, nous pouvons simplement utiliser @RequestMapping avec deux valeurs comme: stackoverflow.com/questions/17821731/...
InformationsquelleAutor earldouglas
94

Si vous utilisez Printemps 4.1 et Java 8, vous pouvez utiliser java.util.Optional qui est pris en charge dans @RequestParam, @PathVariable, @RequestHeader et @MatrixVariable dans Spring MVC -
```
@RequestMapping(value = {"/json/{type}", "/json" }, method = RequestMethod.GET)
public @ResponseBody TestBean typedTestBean(
    @PathVariable Optional<String> type,
    @RequestParam("track") String track) {      
    if (type.isPresent()) {
        //type.get() will return type value
        //corresponds to path "/json/{type}"
    } else {
        //corresponds to path "/json"
    }       
}
```
- - vous sûr que cela fonctionnerait? Votre propre réponse ici suggère que le contrôleur ne pas être frappé si {type} est absent de la voie. Je pense que PathVariable Carte serait une meilleure approche, ou à l'aide des contrôleurs distincts.
- Oui si vous avez juste "/json/{type}" et le type n'est pas présent, il ne sera pas hit (comme mon liés répondre à l'indique), mais ici vous avez value = {"/json/{type}", "/json" }. Donc si quelqu'un correspond à la méthode du contrôleur seront frappés.
- Est-il possible que la même valeur, etc., type serait RequestParam et RequestParam trop?
- Il fonctionne, mais de toute façon le contrôleur de fonction ne sera pas appelé parce qu'il s'attend à un paramètre, il y
- Cela fonctionne, et depuis le Printemps 4.3.3, vous pouvez aussi aller avec @PathVariable(required = false) et d'obtenir la valeur null si la variable n'est pas présente.
InformationsquelleAutor Aniket Thakur
73

Ce n'est pas bien connu que vous pouvez également injecter une Carte des variables de chemin d'accès en utilisant le @PathVariable annotation. Je ne sais pas si cette fonctionnalité est disponible au Printemps 3.0 ou s'il a été ajouté plus tard, mais voici une autre façon de résoudre le exemple:
```
@RequestMapping(value={ "/json/{type}", "/json" }, method=RequestMethod.GET)
public @ResponseBody TestBean typedTestBean(
    @PathVariable Map<String, String> pathVariables,
    @RequestParam("track") String track) {

    if (pathVariables.containsKey("type")) {
        return new TestBean(pathVariables.get("type"));
    } else {
        return new TestBean();
    }
}
```
- merci, Au printemps 4.2 fonctionne comme prévu
- Je l'utilise tout le temps .C'est pratique lorsque je veux une seule méthode pour gérer les différents types d'uri ex:{ "/json/{type}","/json/{type}/{xyz}","/json/{type}/{abc}", "/json/{type}/{abc}/{quelque chose}","/json" }
InformationsquelleAutor Paul Wardrip
24

Vous pouvez utiliser un :
```
@RequestParam(value="somvalue",required=false)
```
pour facultatif params plutôt qu'un pathVariable
- C'est la version spécifique, il me semble. Pas aller pour le Printemps 3.
- Actuellement l'utilisation de cette méthode pour un printemps 3.1 projet, et les docs disent que cela fonctionne pour 2,5+, de sorte que cela fonctionne bien pour le Printemps 3. EDIT: source.
- Vrai, mais ce n'est pas ce que la question est à propos. À l'aide de demande paramètres est en effet mentionné dans la question que "Une évidente solution de contournement", mais la question elle-même est sur le chemin paramètres. Ce n'est pas une solution pour l'option chemin d'accès paramètres.
- PathVariable et RequestParam sont différents.
InformationsquelleAutor Maleck13

Printemps 5 /Spring Boot 2 exemples:

blocage

@GetMapping({"/dto-blocking/{type}", "/dto-blocking"})
public ResponseEntity<Dto> getDtoBlocking(
        @PathVariable(name = "type", required = false) String type) {
    if (StringUtils.isEmpty(type)) {
        type = "default";
    }
    return ResponseEntity.ok().body(dtoBlockingRepo.findByType(type));
}

réactif

@GetMapping({"/dto-reactive/{type}", "/dto-reactive"})
public Mono<ResponseEntity<Dto>> getDtoReactive(
        @PathVariable(name = "type", required = false) String type) {
    if (StringUtils.isEmpty(type)) {
        type = "default";
    }
    return dtoReactiveRepo.findByType(type).map(dto -> ResponseEntity.ok().body(dto));
}

InformationsquelleAutor wildloop

3

Cochez cette Le Printemps 3 WebMVC - Facultatif Variables De Chemin D'Accès. Il montre un article de faire une extension à AntPathMatcher pour activer l'option variables de chemin d'accès et peut être de l'aide. Tous les crédits à Sebastian Herold pour la publication de l'article.

InformationsquelleAutor Uresh Kuruhuri

Exemple simplifié de Nicolai Ehmann commentaire et wildloop réponse (Printemps 4.3.3+), vous pouvez utiliser required = false maintenant:

  @RequestMapping(value = {"/json/{type}", "/json" }, method = RequestMethod.GET)
  public @ResponseBody TestBean testAjax(@PathVariable(required = false) String type) {
    if (type != null) {
      //...
    }
    return new TestBean();
  }

InformationsquelleAutor rogerdpack

-4

$.ajax({
            type : 'GET',
            url : '${pageContext.request.contextPath}/order/lastOrder',
            data : {partyId : partyId, orderId :orderId},
            success : function(data, textStatus, jqXHR) });

@RequestMapping(value = "/lastOrder", method=RequestMethod.GET)
public @ResponseBody OrderBean lastOrderDetail(@RequestParam(value="partyId") Long partyId,@RequestParam(value="orderId",required=false) Long orderId,Model m ) {}

Vous pouvez éditer un texte dans votre réponse, en expliquant pourquoi vous pensez que cela contribue à résoudre le problème à la main (4 ans plus tard).
Ne serait pas aider. La réponse est complètement faux.

InformationsquelleAutor Ankush Mundada

Vous devez vous connecter pour publier un commentaire.