Tomcat and Weld: Faces on a Servlet Container

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>bookshelf</artifactId>
  <version>1.0.0</version>
  <packaging>war</packaging>

  <properties>
    <maven.compiler.release>17</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <failOnMissingWebXml>false</failOnMissingWebXml>
    <mojarra.version>4.1.17</mojarra.version>
    <myfaces.version>4.1.4</myfaces.version>
    <weld.version>6.0.4.Final</weld.version>
    <hibernate-validator.version>9.1.4.Final</hibernate-validator.version>
    <parsson.version>1.1.9</parsson.version>
    <jandex.version>3.6.0</jandex.version>
  </properties>

  <dependencies>
    <!-- Compile-time APIs only. Tomcat supplies Servlet and EL; Weld (below) supplies the CDI API. -->
    <dependency>
      <groupId>jakarta.platform</groupId>
      <artifactId>jakarta.jakartaee-web-api</artifactId>
      <version>11.0.0</version>
      <scope>provided</scope>
    </dependency>

    <!-- Tomcat 11 ships Jakarta Annotations 3.0; keep the copies pulled in by Weld and Mojarra out of the WAR -->
    <dependency>
      <groupId>jakarta.annotation</groupId>
      <artifactId>jakarta.annotation-api</artifactId>
      <version>3.0.0</version>
      <scope>provided</scope>
    </dependency>

    <!-- CDI container: the shaded artifact carries the CDI API, Weld core and the servlet integration -->
    <dependency>
      <groupId>org.jboss.weld.servlet</groupId>
      <artifactId>weld-servlet-shaded</artifactId>
      <version>${weld.version}</version>
    </dependency>

    <!-- Optional: lets Weld scan bean archives faster than with reflection -->
    <dependency>
      <groupId>io.smallrye</groupId>
      <artifactId>jandex</artifactId>
      <version>${jandex.version}</version>
    </dependency>

    <!-- Optional: Bean Validation provider (needed for constraints on Faces input) -->
    <dependency>
      <groupId>org.hibernate.validator</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>${hibernate-validator.version}</version>
    </dependency>

    <!-- Optional: Jakarta JSON Processing, needed by Mojarra only when f:websocket is used -->
    <dependency>
      <groupId>org.eclipse.parsson</groupId>
      <artifactId>parsson</artifactId>
      <version>${parsson.version}</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>bookshelf</finalName>
  </build>

  <profiles>
    <profile>
      <id>mojarra</id>
      <activation>
        <activeByDefault>true</activeByDefault>
      </activation>
      <dependencies>
        <dependency>
          <groupId>org.glassfish</groupId>
          <artifactId>jakarta.faces</artifactId>
          <version>${mojarra.version}</version>
        </dependency>
      </dependencies>
    </profile>
    <profile>
      <id>myfaces</id>
      <dependencies>
        <dependency>
          <groupId>org.apache.myfaces.core</groupId>
          <artifactId>myfaces-api</artifactId>
          <version>${myfaces.version}</version>
        </dependency>
        <dependency>
          <groupId>org.apache.myfaces.core</groupId>
          <artifactId>myfaces-impl</artifactId>
          <version>${myfaces.version}</version>
        </dependency>
      </dependencies>
    </profile>
  </profiles>
</project>

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_1.xsd"
         version="6.1">
  <servlet>
    <servlet-name>facesServlet</servlet-name>
    <servlet-class>jakarta.faces.webapp.FacesServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>facesServlet</servlet-name>
    <url-pattern>*.xhtml</url-pattern>
  </servlet-mapping>
  <context-param>
    <param-name>jakarta.faces.PROJECT_STAGE</param-name>
    <param-value>Production</param-value>
  </context-param>
  <context-param>
    <param-name>jakarta.faces.ENABLE_WEBSOCKET_ENDPOINT</param-name>
    <param-value>true</param-value>
  </context-param>
  <welcome-file-list>
    <welcome-file>catalogue.xhtml</welcome-file>
  </welcome-file-list>

  <!-- Declares the BeanManager reference that META-INF/context.xml defines (see the BeanManager section) -->
  <resource-env-ref>
    <resource-env-ref-name>BeanManager</resource-env-ref-name>
    <resource-env-ref-type>jakarta.enterprise.inject.spi.BeanManager</resource-env-ref-type>
  </resource-env-ref>
</web-app>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="https://jakarta.ee/xml/ns/jakartaee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/beans_4_1.xsd"
       version="4.1" bean-discovery-mode="annotated"/>

<?xml version="1.0" encoding="UTF-8"?>
<faces-config xmlns="https://jakarta.ee/xml/ns/jakartaee"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-facesconfig_4_1.xsd"
              version="4.1">
  <application>
    <resource-bundle>
      <base-name>org.example.bookshelf.messages</base-name>
      <var>msg</var>
    </resource-bundle>
  </application>
</faces-config>

INFO [main] EnhancedListener.onStartup WELD-ENV-001008: Initialize Weld using ServletContainerInitializer
INFO [main] WeldStartup.<clinit> WELD-000900: 6.0.4 (Final)
INFO [main] DiscoveryStrategyFactory.create WELD-ENV-000020: Using jandex for bean discovery
INFO [main] WeldStartup.startContainer WELD-000101: Transactional services not available. Injection of @Inject UserTransaction not available. Transactional observers will be invoked synchronously.
INFO [main] TomcatContainer.initialize WELD-ENV-001100: Tomcat 7+ detected, CDI injection will be available in Servlets, Filters and Listeners.
INFO [main] ConfigureListener.contextInitialized Initializing Mojarra 4.1.17 for context '/bookshelf'
INFO [main] Version.<clinit> HV000001: Hibernate Validator 9.1.4.Final

package org.example.bookshelf.web;

import jakarta.enterprise.context.RequestScoped;
import jakarta.inject.Named;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;

/** A short reader note: Bean Validation constraints are checked by Faces in Process Validations. */
@Named
@RequestScoped
public class NoteBean {

    @NotBlank
    @Size(max = 200)
    private String text;
    private String saved;

    public String getText() { return text; }
    public void setText(String text) { this.text = text; }
    public String getSaved() { return saved; }

    public void save() {
        saved = "Saved " + text.length() + " characters.";
    }
}

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="jakarta.faces.html"
      xmlns:ui="jakarta.faces.facelets">
<ui:composition template="/WEB-INF/templates/layout.xhtml">
  <ui:define name="title">Reader note</ui:define>
  <ui:define name="content">
    <h:form id="noteForm">
      <h:messages id="msgs"/>
      <h:inputTextarea id="text" value="#{noteBean.text}"/>
      <h:commandButton id="save" value="Save" action="#{noteBean.save}"/>
      <p><h:outputText id="saved" value="#{noteBean.saved}"/></p>
    </h:form>
  </ui:define>
</ui:composition>
</html>

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="jakarta.faces.html"
      xmlns:f="jakarta.faces.core">
<h:head>
  <title>New arrivals</title>
  <script>
    function onArrival(message) {
      document.getElementById('status').textContent = 'Update: ' + message;
    }
  </script>
</h:head>
<h:body>
  <f:websocket channel="arrivals" scope="application" onmessage="onArrival"/>
  <p id="status">Waiting for new arrivals.</p>
</h:body>
</html>

package org.example.bookshelf.web;

import jakarta.faces.push.Push;
import jakarta.faces.push.PushContext;
import jakarta.inject.Inject;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;

/** Tells every open catalogue page that the shelf changed. Protect it with a security constraint in a real application. */
@WebServlet("/arrivals/announce")
public class AnnounceServlet extends HttpServlet {

    @Inject
    @Push(channel = "arrivals")
    private PushContext arrivals;

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        arrivals.send("catalogue-changed");
        resp.setStatus(HttpServletResponse.SC_NO_CONTENT);
    }
}

import java.net.CookieManager;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.WebSocket;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/** Opens the page's WebSocket, triggers the push and prints the raw frame: java ArrivalsClient.java http://localhost:8080/bookshelf */
public class ArrivalsClient {

    public static void main(String[] args) throws Exception {
        String base = args[0];
        HttpClient client = HttpClient.newBuilder().cookieHandler(new CookieManager()).build();
        String html = client.send(HttpRequest.newBuilder(URI.create(base + "/arrivals.xhtml")).build(),
                HttpResponse.BodyHandlers.ofString()).body();
        // The f:websocket tag renders a call such as faces.push.init('id','/bookshelf/jakarta.faces.push/arrivals?token', ...)
        Matcher m = Pattern.compile("faces\\.push\\.init\\('[^']*','([^']*)'").matcher(html);
        if (!m.find()) {
            System.out.println("no faces.push.init in the page: is ENABLE_WEBSOCKET_ENDPOINT set?");
            return;
        }
        String path = m.group(1);
        URI socket = URI.create(path.startsWith("/")
                ? "ws://" + URI.create(base).getAuthority() + path : path);

        CountDownLatch received = new CountDownLatch(1);
        WebSocket ws = client.newWebSocketBuilder().buildAsync(socket, new WebSocket.Listener() {
            @Override
            public void onOpen(WebSocket webSocket) {
                System.out.println("open");
                webSocket.request(1);
            }

            @Override
            public CompletionStage<?> onText(WebSocket webSocket, CharSequence data, boolean last) {
                System.out.println("raw frame: " + data);
                received.countDown();
                return null;
            }
        }).get(5, TimeUnit.SECONDS);

        Thread.sleep(500);
        int status = client.send(HttpRequest.newBuilder(URI.create(base + "/arrivals/announce"))
                .POST(HttpRequest.BodyPublishers.noBody()).build(), HttpResponse.BodyHandlers.discarding()).statusCode();
        System.out.println("announce status " + status);
        System.out.println(received.await(5, TimeUnit.SECONDS) ? "received" : "timeout");
        ws.sendClose(WebSocket.NORMAL_CLOSURE, "done");
    }
}

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="jakarta.faces.html"
      xmlns:c="jakarta.tags.core"
      xmlns:fn="jakarta.tags.functions">
<h:head><title>JSTL check</title></h:head>
<h:body>
  <p id="out">c:if = <c:if test="#{true}">yes</c:if>,
     c:forEach = <c:forEach items="#{['a', 'b']}" var="x">#{x}</c:forEach>,
     fn:toUpperCase = #{fn:toUpperCase('abc')}</p>
</h:body>
</html>

mvn clean package                       # Mojarra: target/bookshelf.war
mvn clean package -P myfaces            # MyFaces: target/bookshelf.war (overwrites the first)

curl -fLO https://dlcdn.apache.org/tomcat/tomcat-11/v11.0.26/bin/apache-tomcat-11.0.26.tar.gz
curl -fLO https://dlcdn.apache.org/tomcat/tomcat-11/v11.0.26/bin/apache-tomcat-11.0.26.tar.gz.sha512
shasum -a 512 -c apache-tomcat-11.0.26.tar.gz.sha512        # must print: apache-tomcat-11.0.26.tar.gz: OK
tar xzf apache-tomcat-11.0.26.tar.gz

export CATALINA_HOME="$PWD/apache-tomcat-11.0.26"
export CATALINA_BASE="$PWD/bookshelf-base"
mkdir -p "$CATALINA_BASE"/{conf,logs,temp,webapps,work}
cp "$CATALINA_HOME"/conf/* "$CATALINA_BASE"/conf/
cp target/bookshelf.war "$CATALINA_BASE"/webapps/
"$CATALINA_HOME"/bin/catalina.sh run                        # Ctrl+C stops it

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>bookshelf-launcher</artifactId>
  <version>1.0.0</version>

  <properties>
    <maven.compiler.release>17</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <tomcat.version>11.0.26</tomcat.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.apache.tomcat.embed</groupId>
      <artifactId>tomcat-embed-core</artifactId>
      <version>${tomcat.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.tomcat.embed</groupId>
      <artifactId>tomcat-embed-el</artifactId>
      <version>${tomcat.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.tomcat.embed</groupId>
      <artifactId>tomcat-embed-websocket</artifactId>
      <version>${tomcat.version}</version>
    </dependency>
    <!-- the default web.xml that addWebapp installs declares the JSP servlet -->
    <dependency>
      <groupId>org.apache.tomcat.embed</groupId>
      <artifactId>tomcat-embed-jasper</artifactId>
      <version>${tomcat.version}</version>
    </dependency>
  </dependencies>
</project>

package org.example.bookshelf.launcher;

import java.io.File;
import org.apache.catalina.startup.Tomcat;

/** Starts an exploded Bookshelf WAR in embedded Tomcat: EmbeddedBookshelf target/bookshelf 8080 */
public class EmbeddedBookshelf {

    public static void main(String[] args) throws Exception {
        File webapp = new File(args[0]).getAbsoluteFile();
        Tomcat tomcat = new Tomcat();
        tomcat.setBaseDir(new File("target/tomcat").getAbsolutePath());
        tomcat.setPort(Integer.parseInt(args[1]));
        tomcat.getConnector();
        if (args.length > 2 && args[2].equals("naming")) {
            tomcat.enableNaming(); // JNDI is off in embedded Tomcat unless you ask for it
        }
        tomcat.addWebapp("/bookshelf", webapp.getPath());
        tomcat.start();
        tomcat.getServer().await();
    }
}

mvn package                                                    # in launcher/, compiles the class
mvn -q dependency:build-classpath -Dmdep.outputFile=cp.txt     # the Tomcat classpath
java -cp "target/classes:$(cat cp.txt)" org.example.bookshelf.launcher.EmbeddedBookshelf ../bookshelf/target/bookshelf 8080

curl -fLO https://repo1.maven.org/maven2/org/eclipse/jetty/jetty-home/12.1.14/jetty-home-12.1.14.tar.gz
tar xzf jetty-home-12.1.14.tar.gz
export JETTY_HOME="$PWD/jetty-home-12.1.14"

mkdir jetty-base && cd jetty-base
java -jar "$JETTY_HOME"/start.jar --add-modules=http,ee11-deploy,ee11-annotations,ee11-cdi,ee11-apache-jsp,ee11-websocket-jakarta
cp /path/to/bookshelf.war webapps/
java -jar "$JETTY_HOME"/start.jar jetty.http.port=8080