when the tuckey urlrewrite will support jakarta and alternatives of tuckey urlrewrite

Question

Currently tuckey urlrewrite internally uses javax so im facing type mismatch error between jakarta and javax as my project uses jakarta to support tomcat 10.

So i wanted to know when the tuckey urlrewrite package is migrated to jakarta.

I want to know whether there are any other packages which can we used to replace tuckey urlrewrite to support UrlRewrite functionality in spring application.

Answer 1

If you are using Tomcat you should use it's built-in rewrite valve. https://tomcat.apache.org/tomcat-10.1-doc/rewrite.html

Answer 2

According to the issue it should now work with version 5.1.1 without a classifier:

<dependency>
  <groupId>org.tuckey</groupId>
  <artifactId>urlrewritefilter</artifactId>
  <version>5.1.1</version>
</dependency>

See maven repo here

https://github.com/paultuckey/urlrewritefilter/issues/251

Answer 3

It seems someone already published the package changing in Maven Central Repo using a personal groupId, not with the org.tuckey. Actually it will be necessary to do the work unless someone here have the credentials to publish on org.tuckey groupId. It works like a protected domain.

So I downloaded the regular and the Jakarta classifier jar files. The corrections are there but I've not tested it yet.

The direct link to the Maven Repo is:

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

And the compiled jar files:

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

And the dependency declaration to put into pom.xml:

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

To be clear: I AM NOT THE CODE'S AUTHOR. Just sharing what I found about that.

Answer 4

The UrlRewriteFilter Jakarta issue is taking too long imo. Also the last Maven repo update of this project is from 2012.

If you only need simple url rewriting, then you could implement it yourself. It only takes some basic regular expression and Servlet skills, and it doesn't require a lot of coding.

Here is an example. I haven't fully tested it. It's written in Kotlin, but it shouldn't be hard to create Java code from it.

@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)
    }
}