如何在Spring Boot Data REST中实现基于双Slug的资源标识配置？

这个场景我之前也碰到过——Spring Data REST默认的EntityLookup确实只支持单一标识符的映射，不过我们可以通过两种靠谱的方案实现双slug（category-slug + item-slug）的资源定位，下面给你详细拆解：

方案一：自定义BackendIdConverter（推荐） #

这是最贴合Spring Data REST设计思路的方案，通过自定义ID转换器来解析和生成复合slug，不需要手写大量控制器代码。

1. 实现BackendIdConverter接口 #

创建一个转换器类，负责把URL中的复合slug拆分成可用的标识符，同时把Item实体转换成对应的slug组合：

import org.springframework.data.rest.webmvc.spi.BackendIdConverter;
import org.springframework.stereotype.Component;
import java.io.Serializable;

@Component
public class ItemBackendIdConverter implements BackendIdConverter {

    private static final String SLUG_SEPARATOR = "/";

    @Override
    public Serializable fromRequestId(String id, Class<?> entityType) {
        // 拆分URL中的复合slug，比如"electronics/laptop" -> ["electronics", "laptop"]
        String[] slugParts = id.split(SLUG_SEPARATOR);
        if (slugParts.length != 2) {
            throw new IllegalArgumentException("无效的Item标识符格式，应为：category-slug/item-slug");
        }
        // 返回自定义的复合标识符对象，用于后续Repository查询
        return new ItemCompositeSlug(slugParts[0], slugParts[1]);
    }

    @Override
    public String toRequestId(Serializable id, Class<?> entityType) {
        // 将Item实体转换为URL用的复合slug
        Item item = (Item) id;
        return String.format("%s/%s", item.getCategory().getSlug(), item.getSlug());
    }

    @Override
    public boolean supports(Class<?> entityType) {
        // 仅对Item实体生效
        return Item.class.equals(entityType);
    }

    // 自定义复合标识符类，需实现Serializable
    public static class ItemCompositeSlug implements Serializable {
        private final String categorySlug;
        private final String itemSlug;

        public ItemCompositeSlug(String categorySlug, String itemSlug) {
            this.categorySlug = categorySlug;
            this.itemSlug = itemSlug;
        }

        // Getter方法
        public String getCategorySlug() { return categorySlug; }
        public String getItemSlug() { return itemSlug; }
    }
}

2. 调整ItemRepository查询方法 #

确保你的ItemRepository有能接收两个slug参数的查询方法：

import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;

public interface ItemRepository extends JpaRepository<Item, Long> {
    // 参数顺序要和ItemCompositeSlug中的属性顺序一致
    Optional<Item> findByCategorySlugAndSlug(String categorySlug, String itemSlug);
}

3. 配置RepositoryRestConfiguration #

在配置类中禁用Item的默认EntityLookup，并注册自定义转换器：

import org.springframework.context.annotation.Configuration;
import org.springframework.data.rest.core.config.RepositoryRestConfiguration;
import org.springframework.data.rest.webmvc.config.RepositoryRestConfigurer;
import org.springframework.web.cors.CorsRegistry;

@Configuration
public class RestConfig implements RepositoryRestConfigurer {

    private final ItemBackendIdConverter itemBackendIdConverter;

    // 注入自定义转换器
    public RestConfig(ItemBackendIdConverter itemBackendIdConverter) {
        this.itemBackendIdConverter = itemBackendIdConverter;
    }

    @Override
    public void configureRepositoryRestConfiguration(RepositoryRestConfiguration config, CorsRegistry cors) {
        // 保留你原来的Category EntityLookup配置
        config.withEntityLookup()
              .forRepository(CategoryRepository.class, Category::getSlug, CategoryRepository::findBySlug);

        // 禁用Item的默认EntityLookup，改用自定义转换器
        config.withEntityLookup().forRepository(ItemRepository.class, null, null);

        // 注册自定义的ID转换器
        config.getIdConverters().add(itemBackendIdConverter);
    }
}

方案二：自定义RepositoryRestController（适合复杂自定义场景） #

如果需要对Item的请求做更多自定义逻辑，可以手写控制器来处理复合slug的请求：

import org.springframework.hateoas.Resource;
import org.springframework.hateoas.EntityLinks;
import org.springframework.http.ResponseEntity;
import org.springframework.data.rest.webmvc.RepositoryRestController;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@RepositoryRestController
@RequestMapping("/items")
public class CustomItemController {

    private final ItemRepository itemRepository;
    private final EntityLinks entityLinks;

    public CustomItemController(ItemRepository itemRepository, EntityLinks entityLinks) {
        this.itemRepository = itemRepository;
        this.entityLinks = entityLinks;
    }

    @GetMapping("/{categorySlug}/{itemSlug}")
    public ResponseEntity<Resource<Item>> getItem(@PathVariable String categorySlug, @PathVariable String itemSlug) {
        return itemRepository.findByCategorySlugAndSlug(categorySlug, itemSlug)
                .map(item -> new Resource<>(item,
                        entityLinks.linkToSingleResource(Item.class, item.getId()),
                        entityLinks.linkToCollectionResource(Item.class)))
                .map(ResponseEntity::ok)
                .orElse(ResponseEntity.notFound().build());
    }

    // 可按需实现PUT、DELETE等其他HTTP方法
}

方案对比 #

• 方案一：完全复用Spring Data REST的自动CRUD逻辑，代码简洁，符合框架设计，推荐优先使用。
• 方案二：适合需要额外业务逻辑处理的场景，但需要手动实现每个CRUD接口，代码量较大。

内容的提问来源于stack exchange，提问作者Jesse Brands