Tomcat implements only a small subset of Java EE

Apache Tomcat and Eclipse Jetty are two competing implementations of the Servlet, JavaServer Pages, and a very few other specifications defined in Java EE. But Java EE defines dozens more specs that are not implemented in these products. Both of these products are quite popular, as they deliver just enough of Java EE to meet the needs of many people.

So you cannot specify the full Java EE API in your POM. Tomcat lacks an implementation for most of that API.

For more details, see my Answer to the Question, Java EE Web Profile vs Java EE Full Platform. Look especially for my section, Servlet-oriented (Tomcat & Jetty).

You can indeed build Vaadin web apps using only Tomcat or Jetty. I have delivered such apps myself, running very well when deployed to Apache Tomcat. And some of the default POMs for Vaadin include a Maven action to run Jetty within your IDE. We use that in the Steps section below.

Looking at the URL in your first sentence, I see you started your project by downloading the Skeleton Starter for CDI. “CDI” is Contexts and Dependency Injection, one of the many Java EE specs not implemented by Tomcat. Thus the POM being set for full Java EE API.

➥ You can download a different Skeleton Starter without CDI, and without the full Java EE API.

You said:

new to all of this and struggling quite a bit so any help is really greatly appreciated! :)

Yes, tooling for web apps, web containers, Maven/Gradle, Vaadin, Java, Servlets, and IDEs is complicated, fussy, frustrating, and annoying. And even worse, all of that is constantly changing! All I can say is be persistent, be stubborn, and keep at it. And search Stack Overflow repeatedly — many issues and aspects have been covered here, some of it by me with my own trials and tribulations.

Steps

Here is an outline of steps, but not really an entire tutorial.

Be sure to check for tutorials on the Vaadin.com site, as well as on YouTube. In particular, Marcus Hellberg has been posting good tutorials lately. Also, if you really get stuck, the Vaadin Ltd company sells consulting and training services.

If you have a Mac with Apple Silicon (M1 chip) rather than Intel, be sure you have Rosetta 2 installed. Installing an Intel-only app such as Unicode Checker will prompt the installation. The issue here is that Vaadin employs some JavaScript tools (Node.js & npm) that are still Intel-only, even now, a year later, in late 2021.

Download skeleton-starter-flow-14

On the Start page at Vaadin.com, click the link further down for downloading a plain Java starter. On the next page, look for that Vaadin 14 - plain Java block. Notice that we do not want the Vaadin 14 - Spring Boot block, nor the Vaadin 14 - CDI block.

The link in that block downloads skeleton-starter-flow-14 folder. You may change the name, and relocate that folder to the usual place for your IDE projects.

First run

Open that downloaded folder in your IDE. Wait a moment as Maven does its thing, unpacking, downloading, etc. In the mean time, read the README.md page.

After Maven quiets, build the project as-is. You IDE likely has a way to invoke Maven in its GUI. IntelliJ for example has a Maven tool pane. There we should run clean, then install.

If you get an error "No valid Maven installation found.", see this Question, and this Answer instructing you to switch "Maven wrapper" setting to "Bundled Maven". Yes, this is one of the many stupid speed bumps in all this tooling.

If you get an error "Cannot access defaults field of Properties", see this Question with this Answer, leading to this Maven documentation page telling you what to add to your POM. Yes, another of the many stupid speed bumps in tooling. Make Maven reprocess the POM — in IntelliJ this means clicking the tiny floating little windoid with a tiny Maven logo.

When you get your clean & install to run successfully, then you are ready to run the web app. In IntelliJ, I go to that Maven tool pane, then navigate to Project base for Vaadin > Plugins > jetty > jetty:run. Wait a few minutes, especially the first time as more items may need to be downloaded, and various tools utilized by Vaadin must run.

Eventually you will see a message on the console stating "Started Jetty Server". This means you can switch to your web browser, and point to http://localhost:8080/. There you should see the sample app, prompting for your name, with a "Say hello" button. Try that field and button, to make sure it all works.

Now go back to the IDE. Stop the Jetty web container. In IntelliJ, I click the red square icon in upper right corner of the overall window.

Java 16

Update: Java 16 is now at end-of-life. I recommend you move to Java 17, the current Long-Term Support (LTS) version.

You want to use Java 16, so we need to go back to our POM again. Replace these two lines:

        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>

… with:

        <maven.compiler.source>16</maven.compiler.source>
        <maven.compiler.target>16</maven.compiler.target>

Or with this "release" tag that works in later versions of Maven tooling:

        <maven.compiler.release>16</maven.compiler.release>

Save the POM file. Make Maven reload this edited POM. In IntelliJ this means clicking the tiny floating little windoid with a tiny Maven logo.

Do another Maven clean & install for good measure.

You might update:

        <jetty.version>9.4.43.v20210629</jetty.version>

… or:

        <jetty.version>10.0.6</jetty.version>

… as well as the following items. Your IDE may be able to look up latest version numbers. In IntelliJ, delete the version number and press Control+Space (on macOS, if I recall correctly).

        <!-- https://mvnrepository.com/artifact/io.github.bonigarcia/webdrivermanager -->
        <dependency>
            <groupId>io.github.bonigarcia</groupId>
            <artifactId>webdrivermanager</artifactId>
            <version>4.4.3</version>
            <scope>test</scope>
        </dependency>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
            </plugin>

                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-failsafe-plugin</artifactId>
                        <version>3.0.0-M5</version>

Save the edits to your POM. Make your IDE reprocess that POM. Do another Maven clean & install. Maybe ask the IDE to rebuild the project, for good luck. Then run the web app with that jetty:run action. Point your web browser to http://localhost:8080/. And your app should run again.

Example POM

Here is my finalized POM.

<?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>com.example</groupId>
    <artifactId>project-base</artifactId>
    <name>Project base for Vaadin</name>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <maven.compiler.source>16</maven.compiler.source>
        <maven.compiler.target>16</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <failOnMissingWebXml>false</failOnMissingWebXml>

        <vaadin.version>14.6.8</vaadin.version>
        <jetty.version>9.4.43.v20210629</jetty.version>
    </properties>

    <repositories>
        <!-- The order of definitions matters. Explicitly defining central here to make sure it has the highest priority. -->

        <!-- Main Maven repository -->
        <repository>
            <id>central</id>
            <url>https://repo.maven.apache.org/maven2</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
        <!-- Repository used by many Vaadin add-ons -->
        <repository>
            <id>Vaadin Directory</id>
            <url>https://maven.vaadin.com/vaadin-addons</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

    <pluginRepositories>
        <!-- Maven Central repository requires https:// to access -->
        <pluginRepository>
            <id>central</id>
            <url>https://repo.maven.apache.org/maven2</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.vaadin</groupId>
                <artifactId>vaadin-bom</artifactId>
                <type>pom</type>
                <scope>import</scope>
                <version>${vaadin.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>com.vaadin</groupId>
            <!-- Replace artifactId with vaadin-core to use only free components -->
            <artifactId>vaadin</artifactId>
            <exclusions>
                <!-- Webjars are only needed when running in Vaadin 13 compatibility mode -->
                <exclusion>
                    <groupId>com.vaadin.webjar</groupId>
                    <artifactId>*</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.webjars.bowergithub.insites</groupId>
                    <artifactId>*</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.webjars.bowergithub.polymer</groupId>
                    <artifactId>*</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.webjars.bowergithub.polymerelements</groupId>
                    <artifactId>*</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.webjars.bowergithub.vaadin</groupId>
                    <artifactId>*</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.webjars.bowergithub.webcomponents</groupId>
                    <artifactId>*</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- Added to provide logging output as Vaadin uses -->
        <!-- the unbound SLF4J no-operation (NOP) logger implementation -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>com.vaadin</groupId>
            <artifactId>vaadin-testbench</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/io.github.bonigarcia/webdrivermanager -->
        <dependency>
            <groupId>io.github.bonigarcia</groupId>
            <artifactId>webdrivermanager</artifactId>
            <version>4.4.3</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <!-- Basil added-->
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.3.1</version>
                </plugin>
            </plugins>
        </pluginManagement>

        <defaultGoal>jetty:run</defaultGoal>
        <plugins>
            <!-- Basil added-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.3.1</version>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
            </plugin>
            <!-- Jetty plugin for easy testing without a server -->
            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>${jetty.version}</version>
                <configuration>
                    <!-- If using IntelliJ IDEA with autocompilation, this
                    might cause lots of unnecessary compilations in the
                    background.-->
                    <scanIntervalSeconds>2</scanIntervalSeconds>
                    <!-- Use war output directory to get the webpack files -->
                    <webAppConfig>
                        <allowDuplicateFragmentNames>true</allowDuplicateFragmentNames>
                    </webAppConfig>
                </configuration>
            </plugin>


            <!--
                Take care of synchronizing java dependencies and imports in
                package.json and main.js files.
                It also creates webpack.config.js if not exists yet.
            -->
            <plugin>
                <groupId>com.vaadin</groupId>
                <artifactId>vaadin-maven-plugin</artifactId>
                <version>${vaadin.version}</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>prepare-frontend</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

    <profiles>
        <profile>
            <!-- Production mode is activated using -Pproduction -->
            <id>production</id>
            <properties>
                <vaadin.productionMode>true</vaadin.productionMode>
            </properties>

            <dependencies>
                <dependency>
                    <groupId>com.vaadin</groupId>
                    <artifactId>flow-server-production-mode</artifactId>
                </dependency>
            </dependencies>

            <build>
                <plugins>
                    <plugin>
                        <groupId>com.vaadin</groupId>
                        <artifactId>vaadin-maven-plugin</artifactId>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>build-frontend</goal>
                                </goals>
                                <phase>compile</phase>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>

        <profile>
            <id>it</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.eclipse.jetty</groupId>
                        <artifactId>jetty-maven-plugin</artifactId>
                        <version>${jetty.version}</version>
                        <configuration>
                            <scanIntervalSeconds>0</scanIntervalSeconds>
                            <stopPort>8081</stopPort>
                            <stopWait>5</stopWait>
                            <stopKey>${project.artifactId}</stopKey>
                        </configuration>
                        <executions>
                            <execution>
                                <id>start-jetty</id>
                                <phase>pre-integration-test</phase>
                                <goals>
                                    <goal>deploy-war</goal>
                                </goals>
                            </execution>
                            <execution>
                                <id>stop-jetty</id>
                                <phase>post-integration-test</phase>
                                <goals>
                                    <goal>stop</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>

                    <!-- Runs the integration tests (*IT) after the server is started -->
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-failsafe-plugin</artifactId>
                        <version>3.0.0-M5</version>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>integration-test</goal>
                                    <goal>verify</goal>
                                </goals>
                            </execution>
                        </executions>
                        <configuration>
                            <trimStackTrace>false</trimStackTrace>
                            <enableAssertions>true</enableAssertions>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>
</project>

Tomcat

If running well, stop the Jetty server again. Now, we can try Tomcat 9.0.52.

Look in the target folder of your project. You should find WAR file, named something like project-base-1.0-SNAPSHOT.war. Copy that file to the webapps folder of Tomcat. Rename as desired, such as demo.war.

Start Tomcat. Point your browser to http://localhost:8080/. You should see the "Apache Tomcat/9.0.52" page.

Point your browser to http://localhost:8080/demo/ with demo matching your name on the WAR file. You should see the example Vaadin app running. Voilà!

Hopefully that helps you along a bit further in your Vaadin work.