如何基于OAuth权限调用不同方法？同映射按权限分发请求方案咨询

嘿，我来帮你搞定这个问题——你现在写的代码直接运行肯定会报错！因为Spring MVC在注册请求映射的时候，根本不会考虑你加的@PreAuthorize注解，它只认请求路径和HTTP方法，两个@GetMapping用同一个路径的话，启动阶段就会提示重复映射。不过别担心，有几种靠谱的解决方案，我给你拆解清楚：

方案1：单方法内部按权限分支（最省心） #

这是最直接的做法：把两个逻辑合并到一个@GetMapping方法里，先用@PreAuthorize确保用户只有COMMITTEE或ADMIN权限才能进来，然后在方法内部判断当前用户的具体权限，返回对应的结果。

示例代码：

@RestController
@RequestMapping("/test")
public class TestResource {

    @GetMapping
    @PreAuthorize("hasAnyAuthority('COMMITTEE', 'ADMIN')")
    public String testBasedOnAuthority(Authentication authentication) {
        Collection<? extends GrantedAuthority> userAuthorities = authentication.getAuthorities();
        
        // 先判断ADMIN权限（如果有多个权限重叠的情况，优先级可以自己调）
        if (userAuthorities.stream().anyMatch(auth -> auth.getAuthority().equals("ADMIN"))) {
            return "This is a test. Custom result for admin.";
        } 
        // 再判断COMMITTEE权限
        else if (userAuthorities.stream().anyMatch(auth -> auth.getAuthority().equals("COMMITTEE"))) {
            return "This is a test. Custom result for committee.";
        }
        // 这里其实可以不用写，因为@PreAuthorize已经把其他用户挡在外面了
        return "Unknown authority";
    }
}

这种方式的好处是代码简洁、易维护，适合两个逻辑差异不大的场景。

方案2：自定义请求匹配条件（保持方法分离） #

如果你希望把两个逻辑的方法分开写，不想混在一起，可以通过自定义Spring MVC的RequestMappingCondition来实现——让Spring在匹配请求时，不仅看路径和HTTP方法，还要结合用户的权限。

具体代码实现 #

首先定义一个注解，用来标记方法对应的权限：

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface AuthorityMapping {
    String value(); // 传入权限标识，比如"ADMIN"
}

然后实现权限匹配条件：

public class AuthorityRequestCondition implements RequestCondition<AuthorityRequestCondition> {

    private final String requiredAuthority;

    public AuthorityRequestCondition(String authority) {
        this.requiredAuthority = authority;
    }

    @Override
    public AuthorityRequestCondition combine(AuthorityRequestCondition other) {
        // 我们只在方法上用这个注解，所以直接返回方法上的条件
        return new AuthorityRequestCondition(other.requiredAuthority);
    }

    @Override
    public AuthorityRequestCondition getMatchingCondition(HttpServletRequest request) {
        // 从SecurityContext获取当前用户的权限
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        if (auth != null && auth.getAuthorities().stream()
                .anyMatch(authItem -> authItem.getAuthority().equals(this.requiredAuthority))) {
            return this; // 权限匹配，返回当前条件
        }
        return null; // 不匹配则返回null，Spring会跳过这个方法
    }

    @Override
    public int compareTo(AuthorityRequestCondition other, HttpServletRequest request) {
        // 如果多个方法都匹配（比如用户同时有ADMIN和COMMITTEE权限），定义优先级
        // 这里让ADMIN权限的方法优先匹配
        return "ADMIN".equals(other.requiredAuthority) ? 1 : -1;
    }
}

接下来自定义HandlerMapping，把权限条件加入到请求匹配逻辑：

public class AuthorityRequestMappingHandlerMapping extends RequestMappingHandlerMapping {

    @Override
    protected RequestCondition<?> getCustomMethodCondition(Method method) {
        // 检查方法上是否有@AuthorityMapping注解
        AuthorityMapping annotation = AnnotationUtils.findAnnotation(method, AuthorityMapping.class);
        return annotation != null ? new AuthorityRequestCondition(annotation.value()) : null;
    }
}

最后配置Spring MVC使用这个自定义的HandlerMapping：

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureHandlerMappings(List<HandlerMapping> handlerMappings) {
        // 把自定义的HandlerMapping放在最前面，确保优先使用
        handlerMappings.add(0, authorityRequestMappingHandlerMapping());
    }

    @Bean
    public AuthorityRequestMappingHandlerMapping authorityRequestMappingHandlerMapping() {
        AuthorityRequestMappingHandlerMapping mapping = new AuthorityRequestMappingHandlerMapping();
        mapping.setOrder(0);
        return mapping;
    }
}

现在你的TestResource就可以写成这样，保持方法分离：

@RestController
@RequestMapping("/test")
public class TestResource {

    @GetMapping
    @AuthorityMapping("COMMITTEE")
    @PreAuthorize("hasAuthority('COMMITTEE')") // 双重保障，防止权限绕过
    public String testForCommittee() {
        return "This is a test. Custom result for committee.";
    }

    @GetMapping
    @AuthorityMapping("ADMIN")
    @PreAuthorize("hasAuthority('ADMIN')")
    public String testForAdmin() {
        return "This is a test. Custom result for admin.";
    }
}

这种方式的好处是代码结构清晰，适合两个逻辑比较复杂、需要各自维护的场景，但实现起来相对繁琐一点。

方案3：服务层按权限拆分（解耦业务逻辑） #

如果你想把权限和业务逻辑进一步解耦，可以把不同权限对应的逻辑抽到不同的服务类里，然后在控制器里根据权限调用对应的服务。

具体代码实现 #

先定义服务接口和不同权限的实现类：

public interface TestService {
    String getTestResult();
}

// ADMIN权限对应的服务
@Component
@PreAuthorize("hasAuthority('ADMIN')")
public class AdminTestService implements TestService {
    @Override
    public String getTestResult() {
        return "This is a test. Custom result for admin.";
    }
}

// COMMITTEE权限对应的服务
@Component
@PreAuthorize("hasAuthority('COMMITTEE')")
public class CommitteeTestService implements TestService {
    @Override
    public String getTestResult() {
        return "This is a test. Custom result for committee.";
    }
}

然后在控制器里根据用户权限获取对应的服务并调用：

@RestController
@RequestMapping("/test")
public class TestResource {

    @Autowired
    private ApplicationContext context;

    @GetMapping
    @PreAuthorize("hasAnyAuthority('COMMITTEE', 'ADMIN')")
    public String test() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        TestService targetService;
        
        if (authentication.getAuthorities().stream().anyMatch(auth -> auth.getAuthority().equals("ADMIN"))) {
            targetService = context.getBean(AdminTestService.class);
        } else {
            targetService = context.getBean(CommitteeTestService.class);
        }
        
        return targetService.getTestResult();
    }
}

这种方式把业务逻辑和权限控制分开，适合业务逻辑比较复杂、需要独立维护的场景。

内容的提问来源于stack exchange，提问作者Rome Joseph Santos