@RequestMapping 没有正确映射

Question

我的问题是，当我在 CommentController 类上方使用注释 @RequestMapping("/adverts/{id}") 时，我可以同时使用（即）localhost:8080/adverts/1/comments 和 localhost:8080/comments 来访问此类。如何禁用到达localhost:8080/comments？谢谢。

@RestController
class CommentController {

    private final CommentRepository commentRepository;
    private final AdvertRepository advertRepository;
    private final CommentModelAssembler assembler;

    CommentController(CommentRepository commentRepository, AdvertRepository advertRepository, CommentModelAssembler assembler) {
        this.commentRepository = commentRepository;
        this.advertRepository = advertRepository;
        this.assembler = assembler;
    }

    @GetMapping("/adverts/{advertId}/comments")
    CollectionModel<EntityModel<Comment>> all() {
        List<EntityModel<Comment>> comments =
                commentRepository.findAll().stream()
                        .map(assembler::toModel)
                        .collect(Collectors.toList());
        return CollectionModel.of(comments,
                linkTo(methodOn(CommentController.class).all()).withSelfRel());
    }

    @PostMapping("/adverts/{advertId}/comments")
    Comment newComment(@RequestBody Comment newComment) {
        return commentRepository.save(newComment);
    }

    @GetMapping("/adverts/{advertId}/comments/{id}")
    EntityModel<Comment> one(@PathVariable Long id) {
        Comment comment = commentRepository.findById(id)
                .orElseThrow(() -> new CommentNotFoundException(id));
        return assembler.toModel(comment);
    }

    @PutMapping("/adverts/{advertId}//comments/{id}")
    Comment replaceComment(@RequestBody Comment newComment,
                          @PathVariable Long id) {
        return commentRepository.findById(id)
                .map(comment -> {
                    comment.setAdvertId(newComment.getAdvertId());
                    comment.setComment(newComment.getComment());
                    return commentRepository.save(comment);
                })
                .orElseGet(() -> {
                    newComment.setId(id);
                    return commentRepository.save(newComment);
                });
    }

    @DeleteMapping("/adverts/{advertId}/comments/{id}")
    void deleteComment(@PathVariable Long id) {
        commentRepository.deleteById(id);
    }
}

@Component
public class CommentModelAssembler implements RepresentationModelAssembler<Comment, EntityModel<Comment>> {

    @Override
    public EntityModel<Comment> toModel(Comment comment) {
        return EntityModel.of(comment,
                linkTo(methodOn(CommentController.class).one(comment.getId())).withSelfRel(),
                linkTo(methodOn(CommentController.class).all()).withRel("comments"));
    }
}

@RestController
class UserController {

    private final UserRepository repository;
    private final UserModelAssembler assembler;

    UserController(UserRepository repository, UserModelAssembler assembler) {
        this.repository = repository;
        this.assembler = assembler;
    }

    @GetMapping("/users")
    CollectionModel<EntityModel<User>> all() {
        List<EntityModel<User>> users =
                repository.findAll().stream()
                        .map(assembler::toModel)
                        .collect(Collectors.toList());
        return CollectionModel.of(users,
                linkTo(methodOn(UserController.class).all()).withSelfRel());
    }

    @PostMapping("/users")
    User newUser(@RequestBody User newUser) {
        return repository.save(newUser);
    }

    @GetMapping("/users/{id}")
    EntityModel<User> one(@PathVariable Long id) {
        User user = repository.findById(id)
                .orElseThrow(() -> new UserNotFoundException(id));
        return assembler.toModel(user);
    }

    @PutMapping("/users/{id}")
    User replaceUser(@RequestBody User newUser,
                     @PathVariable Long id) {
        return repository.findById(id)
                .map(user -> {
                    user.setName(newUser.getName());
                    user.setRole(newUser.getRole());
                    user.setBoughtVehicles(newUser.getBoughtVehicles());
                    user.setSoldVehicles(newUser.getSoldVehicles());
                    return repository.save(user);
                })
                .orElseGet(() -> {
                    newUser.setId(id);
                    return repository.save(newUser);
                });
    }

    @DeleteMapping("/users/{id}")
    void deleteUser(@PathVariable Long id) {
        repository.deleteById(id);
    }
}

@RestController
class AdvertController {

    private final AdvertRepository repository;
    private final AdvertsModelAssembler assembler;

    AdvertController(AdvertRepository repository, AdvertsModelAssembler assembler) {
        this.repository = repository;
        this.assembler = assembler;
    }

    @GetMapping("/adverts")
    CollectionModel<EntityModel<Advert>> all() {
        List<EntityModel<Advert>> adverts =
                repository.findAll().stream()
                .map(assembler::toModel)
                .collect(Collectors.toList());
        return CollectionModel.of(adverts,
                linkTo(methodOn(AdvertController.class).all()).withSelfRel());
    }

    @PostMapping("/adverts")
    Advert newAdvert(@RequestBody Advert newAdvert) {
        return repository.save(newAdvert);
    }

    @GetMapping("/adverts/{id}")
    EntityModel<Advert> one(@PathVariable Long id) {
        Advert advert = repository.findById(id)
                .orElseThrow(() -> new AdvertNotFoundException(id));
        return assembler.toModel(advert);
    }

    @PutMapping("/adverts/{id}")
    Advert replaceAdvert(@RequestBody Advert newAdvert,
                         @PathVariable Long id) {
        return repository.findById(id)
                .map(advert -> {
                    advert.setAutoCategory(newAdvert.getAutoCategory());
                    advert.setAutoName(newAdvert.getAutoName());
                    advert.setAutoModel(newAdvert.getAutoModel());
                    advert.setComments(newAdvert.getComments());
                    return repository.save(advert);
                })
                .orElseGet(() -> {
                    newAdvert.setId(id);
                    return repository.save(newAdvert);
                });
    }

    @DeleteMapping("/adverts/{id}")
    void deleteAdvert(@PathVariable Long id) {
        repository.deleteById(id);
    }
}

localhost:8080/comments 结果：

{
  "_embedded" : {
    "comments" : [ {
      "advertId" : 1,
      "comment" : "That's a nice car!",
      "_links" : {
        "self" : {
          "href" : "http://localhost:8080/comments/3"
        },
        "comment" : {
          "href" : "http://localhost:8080/comments/3"
        }
      }
    }, {
      "advertId" : 2,
      "comment" : "What a nice color of the car!",
      "_links" : {
        "self" : {
          "href" : "http://localhost:8080/comments/4"
        },
        "comment" : {
          "href" : "http://localhost:8080/comments/4"
        }
      }
    } ]
  },
  "_links" : {
    "self" : {
      "href" : "http://localhost:8080/comments"
    },
    "profile" : {
      "href" : "http://localhost:8080/profile/comments"
    }
  },
  "page" : {
    "size" : 20,
    "totalElements" : 2,
    "totalPages" : 1,
    "number" : 0
  }
}

Answer 1

您的localhost:8080/comments API 似乎来自不同的控制器，而不是您发布的这个。

更新： 如果您只想查看每个用户的评论，可以按照以下方式更改控制器定义，使其更通用和简单：

@RestController
@RequestMapping("/adverts")
class CommentController {

更新 2： 您需要更新您的控制器 URL 映射。通常，我们为特定的控制器/目的定义一个通用的 url-name。就像你的 CommonController 一样，你可以这样做：

@RestController
    @RequestMapping("/common")
    class CommentController {

查看名称/commom。然后，在此控制器下，添加其他 API，例如 /comments/all、/comments/{id}、/comments/others。要访问这些控制器方法，您必须遵循此层次结构，例如： /common/comments/all 或 /common/comments/1 AdvertController 也是如此：

@RestController
@RequestMapping("/advert")
class AdvertController {

再次检查常见的 url-name /advert。此控制器下的 API 将具有如下命名： /all, '/{id}'。要访问此控制器方法，请以这种方式使用 URL： /advert/all, /advert/1 这应该清楚你的想法。 一件事，我已经从我展示的 url-example 中排除了 base-url localhost:8080 部分，请注意添加这个。 希望，这将达到您的目的。