tuckey urlrewrite 将支持 jakarta 和 tuckey urlrewrite 的替代品

Question

目前 tuckey urlrewrite 内部使用 javax，所以我面临着 jakarta 和 javax 之间的类型不匹配错误，因为我的项目使用 jakarta 来支持 tomcat 10。

所以我想知道tuckey urlrewrite 包何时迁移到雅加达。

我想知道是否有其他包可以用来替换tuckey urlrewrite以支持spring应用程序中的UrlRewrite功能。

Answer 1

根据项目页面，您应该使用像 htis 这样的分类器：

<dependency>
  <groupId>org.tuckey</groupId>
  <artifactId>urlrewritefilter</artifactId>
  <version>4.0.4</version>
  <classifier>jakarta</classifier>
</dependency>

或

implementation 'org.tuckey:urlrewritefilter:4.0.4:jakarta'

但是在我写这篇文章的时候，包还没有上传到mavencentral，正如问题中报告的那样。

Answer 2

如果您使用 Tomcat，您应该使用它的内置重写阀。 https://tomcat.apache.org/tomcat-10.1-doc/rewrite.html

Answer 3

似乎有人已经使用个人 groupId 而不是使用

org.tuckey

在 Maven Central Repo 中发布了软件包更改。实际上，除非这里有人有资格在

org.tuckey

groupId 上发布，否则这项工作是必要的。它的工作原理就像一个受保护的域。

所以我下载了常规和 Jakarta 分类器 jar 文件。修正已经存在，但我还没有测试过。

Maven Repo 的直接链接是：

https://central.sonatype.com/artifact/de.knightsoft-net/urlrewritefilter/4.0.4.1/versions

以及编译好的jar文件：

https://repo1.maven.org/maven2/de/knightsoft-net/urlrewritefilter/4.0.4.1/

以及要放入 pom.xml 的依赖声明：

<dependency>
    <groupId>de.knightsoft-net</groupId>
    <artifactId>urlrewritefilter</artifactId>
    <version>4.0.4.1</version>
    <classifier>jakarta</classifier>
</dependency>

需要明确的是：我不是代码的作者。只是分享我的发现。

Answer 4

在我看来，UrlRewriteFilter Jakarta 问题花费的时间太长。此外，该项目的最后一次 Maven 存储库更新是从 2012 年开始的。

如果你只需要简单的url重写，那么你可以自己实现。只需要一些基本的正则表达式和 Servlet 技能，并且不需要大量编码。

这是一个例子。我还没有完全测试过。它是用 Kotlin 编写的，但用它创建 Java 代码应该不难。

@Component
@Order(1)
class UrlRewriteFilter : Filter {
    override fun doFilter(sRequest: ServletRequest, sResponse: ServletResponse, chain: FilterChain) {
        val request = sRequest as HttpServletRequest
        val response = sResponse as HttpServletResponse

        val rewriteMatch = rewrite(getFullUri(request), rules)

        when (rewriteMatch.responseType) {
            ResponseType.NORMAL -> chain.doFilter(request, sResponse)
            ResponseType.TEMPORARY_REDIRECT -> sendRedirect(response, rewriteMatch.resultUri, true)
            ResponseType.PERMANENT_REDIRECT -> sendRedirect(response, rewriteMatch.resultUri, false)
            ResponseType.FORWARD -> {
                val dispatcher = request.getRequestDispatcher(rewriteMatch.resultUri)
                dispatcher.forward(request, response)
            }
        }
    }

    private fun getFullUri(request: HttpServletRequest): String {
        return if (request.queryString == null) {
            request.requestURI
        } else {
            "${request.requestURI}?${request.queryString}"
        }
    }

    private fun sendRedirect(response: HttpServletResponse, uri: String, temporary: Boolean) {
        response.setHeader("Location", uri)
        if (temporary) {
            response.status = HttpServletResponse.SC_MOVED_TEMPORARILY
        } else {
            response.status = HttpServletResponse.SC_MOVED_PERMANENTLY
        }
    }
}

val rules = listOf(
    Rule(false, ResponseType.PERMANENT_REDIRECT, RegexReplaceRewriter(Pattern.compile("/sales/customer.php\\?id=(\\d+)"), "/sales/customer/$1")),
    Rule(false, ResponseType.TEMPORARY_REDIRECT, RegexReplaceRewriter(Pattern.compile("/sales/customer.php\\?name=(.*)"), "/sales/customer/$1/name")),
)

fun rewrite(uri: String, rules: List<Rule>): RewriteMatch {
    var rewrittenUri = uri
    var currentRule: Rule? = null

    for (rule in rules) {
        val rewrite = rule.rewriter.rewrite(rewrittenUri)
        if (rewrite != null) {
            rewrittenUri = rewrite
            currentRule = rule

            if (rule.isLast) {
                break
            }
        }
    }

    return if (currentRule == null) {
        RewriteMatch(uri, ResponseType.NORMAL)
    } else {
        RewriteMatch(rewrittenUri, currentRule.responseType)
    }
}

enum class ResponseType {
    NORMAL, TEMPORARY_REDIRECT, PERMANENT_REDIRECT, FORWARD
}

data class RewriteMatch(
    val resultUri: String,
    val responseType: ResponseType
)

data class Rule(
    val isLast: Boolean,
    val responseType: ResponseType,
    val rewriter: Rewriter
)

fun interface Rewriter {
    fun rewrite(uri: String): String?
}

class RegexReplaceRewriter(
    private val matchingUriPattern: Pattern,
    private val replacement: String,
) : Rewriter {
    override fun rewrite(uri: String): String? {
        val matcher = matchingUriPattern.matcher(uri)
        if (! matcher.find()) {
            return null
        }
        return matcher.replaceAll(replacement)
    }
}