import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.FileSystemResource;
import org.springframework.web.servlet.function.RouterFunction;
import org.springframework.web.servlet.function.RouterFunctions;
import org.springframework.web.servlet.function.ServerResponse;


@Configuration
public class WebConfig {
    @Bean
    public RouterFunction<ServerResponse> route() {
        return RouterFunctions
                .resources("/static/**", new
                        FileSystemResource("G:/test/test1/test2/static/"));
    }
}

import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceUtils;
import org.springframework.util.Assert;
import org.springframework.util.PathPattern;
import org.springframework.util.PathPatternParser;
import org.springframework.util.StringUtils;
import org.springframework.web.reactive.function.server.ServerRequest;
import reactor.core.publisher.Mono;

import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.charset.StandardCharsets;
import java.util.Optional;
import java.util.function.Function;

/**
 * 一个函数接口实现，用于根据请求路径匹配和查找相应的资源。
 */
class PathResourceLookupFunction implements Function<ServerRequest, Optional<Resource>> {

    /**
     * 用于匹配请求路径的模式。
     */
    private final PathPattern pattern;

    /**
     * 资源的基础位置。
     */
    private final Resource location;

    /**
     * 构造函数，初始化路径模式和资源位置。
     *
     * @param pattern  路径模式字符串，用于匹配请求路径。
     * @param location 资源的基础位置，不能为 null。
     */
    public PathResourceLookupFunction(String pattern, Resource location) {
        // 确保路径模式字符串不为空
        Assert.hasLength(pattern, "'pattern' must not be empty");
        // 确保资源位置不为 null
        Assert.notNull(location, "'location' must not be null");
        // 解析路径模式字符串为 PathPattern 对象
        this.pattern = PathPatternParser.defaultInstance.parse(pattern);
        this.location = location;
    }

    /**
     * 根据服务器请求查找匹配的资源。
     *
     * @param request 服务器请求对象。
     * @return 一个包含匹配资源的 Optional 对象，如果没有匹配则返回 Optional.empty()。
     */
    @Override
    public Optional<Resource> apply(ServerRequest request) {
        // 获取请求路径的 PathContainer
        PathContainer pathContainer = request.requestPath().pathWithinApplication();
        // 如果路径不匹配模式，返回空
        if (!this.pattern.matches(pathContainer)) {
            return Optional.empty();
        }

        // 提取匹配的路径部分
        pathContainer = this.pattern.extractPathWithinPattern(pathContainer);
        // 处理路径，去除不必要的字符
        String path = processPath(pathContainer.value());
        // 如果路径包含百分号，进行 URI 解码
        if (path.contains("%")) {
            path = StringUtils.uriDecode(path, StandardCharsets.UTF_8);
        }
        // 如果路径为空或无效，返回空
        if (!StringUtils.hasLength(path) || isInvalidPath(path)) {
            return Optional.empty();
        }

        try {
            // 在基础位置创建相对路径的资源
            Resource resource = this.location.createRelative(path);
            // 如果资源可读且位于基础位置下，返回该资源
            if (resource.isReadable() && isResourceUnderLocation(resource)) {
                return Optional.of(resource);
            } else {
                return Optional.empty();
            }
        } catch (IOException ex) {
            // 将检查型异常转换为非检查型异常并抛出
            throw new UncheckedIOException(ex);
        }
    }

    /**
     * 处理路径，去除前导和不必要的斜杠，并确保路径有效。
     *
     * @param path 输入的路径字符串。
     * @return 处理后的路径字符串。
     */
    private String processPath(String path) {
        boolean slash = false;
        for (int i = 0; i < path.length(); i++) {
            if (path.charAt(i) == '/') {
                slash = true;
            } else if (path.charAt(i) > ' ' && path.charAt(i) != 127) {
                if (i == 0 || (i == 1 && slash)) {
                    return path;
                }
                // 去除前导无效字符
                path = slash ? "/" + path.substring(i) : path.substring(i);
                return path;
            }
        }
        // 如果路径仅包含斜杠，返回斜杠或空字符串
        return (slash ? "/" : "");
    }

    /**
     * 检查路径是否无效，防止访问受限制的目录或进行路径穿越攻击。
     *
     * @param path 需要检查的路径字符串。
     * @return 如果路径无效则返回 true，否则返回 false。
     */
    private boolean isInvalidPath(String path) {
        // 禁止访问 WEB-INF 和 META-INF 目录
        if (path.contains("WEB-INF") || path.contains("META-INF")) {
            return true;
        }
        // 检查是否包含协议或 URL 前缀，防止绝对路径访问
        if (path.contains(":/")) {
            String relativePath = (path.charAt(0) == '/' ? path.substring(1) : path);
            if (ResourceUtils.isUrl(relativePath) || relativePath.startsWith("url:")) {
                return true;
            }
        }
        // 检查路径是否包含路径穿越序列
        return path.contains("..") && StringUtils.cleanPath(path).contains("../");
    }

    /**
     * 检查资源是否位于基础位置下，防止路径穿越。
     *
     * @param resource 需要检查的资源。
     * @return 如果资源位于基础位置下则返回 true，否则返回 false。
     * @throws IOException 如果读取资源路径时发生 IO 异常。
     */
    private boolean isResourceUnderLocation(Resource resource) throws IOException {
        // 确保资源类型与基础位置一致
        if (resource.getClass() != this.location.getClass()) {
            return false;
        }

        String resourcePath;
        String locationPath;

        // 根据资源类型获取路径
        if (resource instanceof UrlResource) {
            resourcePath = resource.getURL().toExternalForm();
            locationPath = StringUtils.cleanPath(this.location.getURL().toString());
        }
        else if (resource instanceof ClassPathResource classPathResource) {
            resourcePath = classPathResource.getPath();
            locationPath = StringUtils.cleanPath(((ClassPathResource) this.location).getPath());
        }
        else {
            resourcePath = resource.getURL().getPath();
            locationPath = StringUtils.cleanPath(this.location.getURL().getPath());
        }

        // 如果资源路径与基础位置路径相同，返回 true
        if (locationPath.equals(resourcePath)) {
            return true;
        }
        // 确保基础位置路径以斜杠结尾
        locationPath = (locationPath.endsWith("/") || locationPath.isEmpty() ? locationPath : locationPath + "/");
        // 检查资源路径是否以基础位置路径开头
        if (!resourcePath.startsWith(locationPath)) {
            return false;
        }
        // 确保资源路径不包含路径穿越序列
        return !resourcePath.contains("%") ||
                !StringUtils.uriDecode(resourcePath, StandardCharsets.UTF_8).contains("../");
    }

    /**
     * 返回对象的字符串表示，包含路径模式和资源位置。
     *
     * @return 对象的字符串表示。
     */
    @Override
    public String toString() {
        return this.pattern + " -> " + this.location;
    }

}

public static String cleanPath(String path) {
    // 如果路径为空或长度为0，直接返回原路径
    if (!hasLength(path)) {
        return path;
    }

    String normalizedPath;
    // 优化处理：如果路径中包含反斜杠（\），则进行替换
    if (path.indexOf('\\') != -1) {
        // 将双反斜杠替换为单一的文件夹分隔符（通常为 /）
        normalizedPath = replace(path, DOUBLE_BACKSLASHES, FOLDER_SEPARATOR);
        // 将 Windows 特有的文件夹分隔符（\）替换为统一的文件夹分隔符（/）
        normalizedPath = replace(normalizedPath, WINDOWS_FOLDER_SEPARATOR, FOLDER_SEPARATOR);
    } else {
        // 如果没有反斜杠，直接使用原路径
        normalizedPath = path;
    }
    String pathToUse = normalizedPath;

    // 快捷方式：如果路径中不包含点（.），则无需进一步处理，直接返回
    if (pathToUse.indexOf('.') == -1) {
        return pathToUse;
    }

    // 处理路径前缀（例如 "file:"），以避免将其作为路径的一部分进行解析
    int prefixIndex = pathToUse.indexOf(':');
    String prefix = "";
    if (prefixIndex != -1) {
        // 提取前缀（例如 "file:"）
        prefix = pathToUse.substring(0, prefixIndex + 1);
        // 如果前缀中包含文件夹分隔符，说明前缀不合法，忽略前缀
        if (prefix.contains(FOLDER_SEPARATOR)) {
            prefix = "";
        } else {
            // 移除前缀部分，保留后面的路径进行处理
            pathToUse = pathToUse.substring(prefixIndex + 1);
        }
    }
    // 如果路径以文件夹分隔符开头，保留分隔符并移除路径开头的分隔符
    if (pathToUse.startsWith(FOLDER_SEPARATOR)) {
        prefix = prefix + FOLDER_SEPARATOR;
        pathToUse = pathToUse.substring(1);
    }

    // 将路径按文件夹分隔符拆分为数组
    // private static final String FOLDER_SEPARATOR = "/";
    String[] pathArray = delimitedListToStringArray(pathToUse, FOLDER_SEPARATOR);
    // 使用双端队列（Deque）来存储处理后的路径元素
    Deque<String> pathElements = new ArrayDeque<>(pathArray.length);
    int tops = 0; // 记录 ".." 的数量

    // 从路径数组的最后一个元素开始逆序遍历
    for (int i = pathArray.length - 1; i >= 0; i--) {
        String element = pathArray[i];
        if (CURRENT_PATH.equals(element)) {
            // 当前目录（.）无需处理，直接跳过
        } else if (TOP_PATH.equals(element)) {
            // 遇到上一级目录（..），增加 tops 计数
            tops++;
        } else {
            if (tops > 0) {
                // 如果有待消除的上一级目录，减少 tops 计数，忽略当前元素
                tops--;
            } else {
                // 正常的路径元素，添加到队列的前面
                pathElements.addFirst(element);
            }
        }
    }

    // 如果处理后的路径元素数量与原数组相同，说明没有需要清理的部分，直接返回规范化后的路径
    if (pathArray.length == pathElements.size()) {
        return normalizedPath;
    }
    // 保留剩余的上一级目录（..）
    for (int i = 0; i < tops; i++) {
        pathElements.addFirst(TOP_PATH);
    }
    // 如果队列中只有一个空元素，并且前缀不以文件夹分隔符结尾，添加当前目录（.）
    if (pathElements.size() == 1 && pathElements.getLast().isEmpty() && !prefix.endsWith(FOLDER_SEPARATOR)) {
        pathElements.addFirst(CURRENT_PATH);
    }

    // 将队列中的路径元素重新连接为字符串，使用文件夹分隔符作为分隔符
    final String joined = collectionToDelimitedString(pathElements, FOLDER_SEPARATOR);
    // 如果有前缀，则将前缀与连接后的路径组合，否则直接返回连接后的路径
    return prefix.isEmpty() ? joined : prefix + joined;
}