为什么实现了ReactiveAuthorizationManager后，重写的方法verify为什么没有走到，非常奇怪，请老师给与帮助，感谢了。

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.bblian.api.dao.entity.Permission;
import com.bblian.api.dao.mapper.PermissionMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.security.authorization.AuthorizationDecision;
import org.springframework.security.authorization.ReactiveAuthorizationManager;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.web.server.authorization.AuthorizationContext;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;

import java.nio.file.AccessDeniedException;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

@Slf4j
@Component
public class AuthorizationManager implements ReactiveAuthorizationManager<AuthorizationContext> {
    @Autowired
    private PermissionMapper permissionMapper;

    @Override
    public Mono<AuthorizationDecision> check(Mono<Authentication> authentication,
                                             AuthorizationContext authorizationContext) {
        ServerHttpRequest request = authorizationContext.getExchange().getRequest();
        String url = request.getPath().value();
        log.debug("请求的url: {}", url);
        String method = request.getMethod().name();
        log.debug("请求的方法: {}", method);
        if (HttpMethod.OPTIONS.name().equals(method)) {
            return Mono.just(new AuthorizationDecision(true));
        }
        //白名单判断
        LambdaQueryWrapper<Permission> qw = new QueryWrapper<Permission>().lambda();
        qw.eq(Permission::getResource, url);
        List<Permission> permissions = permissionMapper.selectList(qw);
        List<String> roles = permissions.stream().map(i -> "ROLE_" + i.getRole()).collect(Collectors.toList());
        return authentication.map(auth -> {
            Collection<? extends GrantedAuthority> authorities = auth.getAuthorities();
            for (GrantedAuthority authority : authorities) {
                String authorityAuthority = authority.getAuthority();
                if (roles.contains(authorityAuthority)) {
                    log.info(String.format("用户请求API校验通过，GrantedAuthority:{%s}  Url:{%s} ", authorityAuthority, url));
                    return new AuthorizationDecision(true);
                }
            }
            return new AuthorizationDecision(false);
        }).defaultIfEmpty(new AuthorizationDecision(false));
    }

    @Override
    public Mono<Void> verify(Mono<Authentication> authentication, AuthorizationContext object) {
        return check(authentication, object)
                .filter(d -> d.isGranted())
                .switchIfEmpty(Mono.defer(() -> {
                    String body = "当前用户没有访问权限! ";
                    return Mono.error(new AccessDeniedException(body));
                }))
                .flatMap(d -> Mono.empty());
    }
}