Add Java Servlet filter

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Prerender
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,111 @@
+# prerender-java
+
+Jakarta Servlet Filter for [Prerender.io](https://prerender.io). Intercepts requests from bots and crawlers and serves prerendered HTML, so your JavaScript-rendered app is fully indexable by search engines and social media scrapers.
+
+Compatible with any **Jakarta EE** application server — Tomcat 10+, Jetty 11+, Spring Boot 3+, Quarkus, Micronaut.
+
+Requires **Java 17+**.
+
+## Installation
+
+### Maven
+
+```xml
+<dependency>
+    <groupId>io.prerender</groupId>
+    <artifactId>prerender-java</artifactId>
+    <version>1.0.0</version>
+</dependency>
+```
+
+### Gradle
+
+```groovy
+implementation 'io.prerender:prerender-java:1.0.0'
+```
+
+## Setup
+
+### Option 1: Environment variables (recommended)
+
+```bash
+export PRERENDER_TOKEN=your-token
+```
+
+Register the filter in `web.xml`:
+
+```xml
+<filter>
+    <filter-name>PrerenderFilter</filter-name>
+    <filter-class>io.prerender.PrerenderFilter</filter-class>
+</filter>
+<filter-mapping>
+    <filter-name>PrerenderFilter</filter-name>
+    <url-pattern>/*</url-pattern>
+</filter-mapping>
+```
+
+### Option 2: web.xml init-params
+
+```xml
+<filter>
+    <filter-name>PrerenderFilter</filter-name>
+    <filter-class>io.prerender.PrerenderFilter</filter-class>
+    <init-param>
+        <param-name>prerenderToken</param-name>
+        <param-value>your-token</param-value>
+    </init-param>
+</filter>
+<filter-mapping>
+    <filter-name>PrerenderFilter</filter-name>
+    <url-pattern>/*</url-pattern>
+</filter-mapping>
+```
+
+### Spring Boot
+
+```java
+@Bean
+public FilterRegistrationBean<PrerenderFilter> prerenderFilter() {
+    FilterRegistrationBean<PrerenderFilter> registration = new FilterRegistrationBean<>();
+    registration.setFilter(new PrerenderFilter());
+    registration.addUrlPatterns("/*");
+    registration.setOrder(Ordered.HIGHEST_PRECEDENCE);
+    return registration;
+}
+```
+
+Set `PRERENDER_TOKEN` as an environment variable before starting the app.
+
+## Settings
+
+| Setting | Init-param | Env var | Default |
+|---------|------------|---------|---------|
+| Token | `prerenderToken` | `PRERENDER_TOKEN` | none |
+| Service URL | `prerenderServiceUrl` | `PRERENDER_SERVICE_URL` | `https://service.prerender.io/` |
+
+Init-params take precedence over environment variables.
+
+## Self-hosted Prerender
+
+```bash
+export PRERENDER_SERVICE_URL=http://your-prerender-server:3000
+```
+
+## How it works
+
+Requests are prerendered when **all** of the following are true:
+
+- The HTTP method is `GET`
+- The `User-Agent` matches a known bot/crawler (Googlebot, Bingbot, Twitterbot, GPTBot, ClaudeBot, etc.)  
+  — OR the URL contains `_escaped_fragment_`  
+  — OR the `X-Bufferbot` header is present
+- The URL does not end with a static asset extension (`.js`, `.css`, `.png`, etc.)
+
+Everything else passes through to your normal servlet chain.
+
+If the Prerender service is unreachable, the filter falls back gracefully and serves the normal response.
+
+## License
+
+MIT

pom.xml

@@ -0,0 +1,78 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>io.prerender</groupId>
+    <artifactId>prerender-java</artifactId>
+    <version>1.0.0</version>
+    <packaging>jar</packaging>
+
+    <name>prerender-java</name>
+    <description>Jakarta Servlet Filter for prerendering JavaScript-rendered pages via Prerender.io</description>
+    <url>https://github.com/prerender/integrations</url>
+
+    <licenses>
+        <license>
+            <name>MIT License</name>
+            <url>https://opensource.org/licenses/MIT</url>
+        </license>
+    </licenses>
+
+    <scm>
+        <connection>scm:git:git@github.com:prerender/integrations.git</connection>
+        <developerConnection>scm:git:git@github.com:prerender/integrations.git</developerConnection>
+        <url>https://github.com/prerender/integrations</url>
+    </scm>
+
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>jakarta.servlet</groupId>
+            <artifactId>jakarta.servlet-api</artifactId>
+            <version>6.0.0</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>5.10.2</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>5.11.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-junit-jupiter</artifactId>
+            <version>5.11.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.wiremock</groupId>
+            <artifactId>wiremock</artifactId>
+            <version>3.5.4</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.2.5</version>
+            </plugin>
+        </plugins>
+    </build>
+</project>

src/main/java/io/prerender/PrerenderConfig.java

@@ -0,0 +1,59 @@
+package io.prerender;
+
+import java.util.List;
+
+class PrerenderConfig {
+
+    static final List<String> CRAWLER_USER_AGENTS = List.of(
+        "googlebot", "yahoo", "bingbot", "baiduspider",
+        "facebookexternalhit", "twitterbot", "rogerbot", "linkedinbot",
+        "embedly", "quora link preview", "showyoubot", "outbrain",
+        "pinterest", "slackbot", "w3c_validator", "perplexity",
+        "oai-searchbot", "chatgpt-user", "gptbot", "claudebot", "amazonbot"
+    );
+
+    static final List<String> EXTENSIONS_TO_IGNORE = List.of(
+        ".js", ".css", ".xml", ".less", ".png", ".jpg", ".jpeg", ".gif",
+        ".pdf", ".doc", ".txt", ".ico", ".rss", ".zip", ".mp3", ".rar",
+        ".exe", ".wmv", ".avi", ".ppt", ".mpg", ".mpeg", ".tif", ".wav",
+        ".mov", ".psd", ".ai", ".xls", ".mp4", ".m4a", ".swf", ".dat",
+        ".dmg", ".iso", ".flv", ".m4v", ".torrent", ".ttf", ".woff", ".svg"
+    );
+
+    private static final String DEFAULT_SERVICE_URL = "https://service.prerender.io/";
+
+    private final String token;
+    private final String serviceUrl;
+
+    PrerenderConfig(String token, String serviceUrl) {
+        this.token = token;
+        this.serviceUrl = (serviceUrl != null && !serviceUrl.isBlank())
+            ? serviceUrl
+            : DEFAULT_SERVICE_URL;
+    }
+
+    static PrerenderConfig fromInitParams(String initToken, String initServiceUrl) {
+        return new PrerenderConfig(
+            resolve(initToken, "PRERENDER_TOKEN"),
+            resolve(initServiceUrl, "PRERENDER_SERVICE_URL")
+        );
+    }
+
+    private static String resolve(String initParam, String envVar) {
+        return (initParam != null && !initParam.isBlank()) ? initParam : System.getenv(envVar);
+    }
+
+    String getToken() { return token; }
+
+    String getServiceUrl() { return serviceUrl; }
+
+    static boolean isBot(String userAgent) {
+        String ua = userAgent.toLowerCase();
+        return CRAWLER_USER_AGENTS.stream().anyMatch(ua::contains);
+    }
+
+    static boolean isStaticAsset(String path) {
+        String lower = path.toLowerCase();
+        return EXTENSIONS_TO_IGNORE.stream().anyMatch(lower::endsWith);
+    }
+}

src/main/java/io/prerender/PrerenderFilter.java

@@ -0,0 +1,105 @@
+package io.prerender;
+
+import jakarta.servlet.Filter;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.FilterConfig;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class PrerenderFilter implements Filter {
+
+    private static final Logger logger = Logger.getLogger(PrerenderFilter.class.getName());
+
+    private HttpClient httpClient;
+    private PrerenderConfig config;
+
+    public PrerenderFilter() {}
+
+    PrerenderFilter(HttpClient httpClient, PrerenderConfig config) {
+        this.httpClient = httpClient;
+        this.config = config;
+    }
+
+    @Override
+    public void init(FilterConfig filterConfig) {
+        this.httpClient = HttpClient.newHttpClient();
+        this.config = PrerenderConfig.fromInitParams(
+            filterConfig.getInitParameter("prerenderToken"),
+            filterConfig.getInitParameter("prerenderServiceUrl")
+        );
+    }
+
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
+            throws IOException, ServletException {
+        HttpServletRequest httpReq = (HttpServletRequest) request;
+        HttpServletResponse httpRes = (HttpServletResponse) response;
+
+        if (!shouldPrerender(httpReq)) {
+            chain.doFilter(request, response);
+            return;
+        }
+
+        try {
+            sendPrerendered(httpReq, httpRes);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            chain.doFilter(request, response);
+        } catch (IOException e) {
+            logger.log(Level.WARNING, "Prerender service unreachable, falling back", e);
+            chain.doFilter(request, response);
+        }
+    }
+
+    @Override
+    public void destroy() {}
+
+    private boolean shouldPrerender(HttpServletRequest request) {
+        if (!"GET".equalsIgnoreCase(request.getMethod())) return false;
+        if (PrerenderConfig.isStaticAsset(request.getRequestURI())) return false;
+        if (request.getParameter("_escaped_fragment_") != null) return true;
+        if (request.getHeader("X-Bufferbot") != null) return true;
+        String ua = request.getHeader("User-Agent");
+        return ua != null && !ua.isBlank() && PrerenderConfig.isBot(ua);
+    }
+
+    private void sendPrerendered(HttpServletRequest request, HttpServletResponse response)
+            throws IOException, InterruptedException {
+        HttpResponse<String> prerenderResponse = httpClient.send(
+            buildPrerenderRequest(buildApiUrl(request), request.getHeader("User-Agent")),
+            HttpResponse.BodyHandlers.ofString()
+        );
+        response.setStatus(prerenderResponse.statusCode());
+        response.getWriter().write(prerenderResponse.body());
+    }
+
+    private String buildApiUrl(HttpServletRequest request) {
+        String serviceUrl = config.getServiceUrl();
+        if (!serviceUrl.endsWith("/")) serviceUrl += "/";
+        String url = request.getRequestURL().toString();
+        String qs = request.getQueryString();
+        return serviceUrl + (qs != null && !qs.isBlank() ? url + "?" + qs : url);
+    }
+
+    private HttpRequest buildPrerenderRequest(String apiUrl, String userAgent) {
+        HttpRequest.Builder builder = HttpRequest.newBuilder()
+            .uri(URI.create(apiUrl))
+            .header("User-Agent", userAgent != null ? userAgent : "")
+            .GET();
+        if (config.getToken() != null && !config.getToken().isBlank()) {
+            builder.header("X-Prerender-Token", config.getToken());
+        }
+        return builder.build();
+    }
+}