How to Install Apache Tomcat 9 (on Windows, macOS, Ubuntu) and Get Started with Java Servlet Programming
- 1. Introduction
- 1.1 Web Application (Webapp)
- 1.2 Hypertext Transfer Protocol (HTTP)
- 1.3 Apache Tomcat HTTP Server
- 2. How to Install Tomcat and Get Started with Java Servlet Programming
- 2.1 STEP 0: Create a Directory to Keep all your Works
- 2.2 STEP 1: Download and Install Tomcat
- 2.3 STEP 2: Create an Environment Variable JAVA_HOME
- 2.4 STEP 3: Configure the Tomcat Server
- 2.5 STEP 4: Start Tomcat Server
- 2.6 STEP 5: Develop and Deploy a WebApp
- 2.7 STEP 6: Write a “Hello-world” Java Servlet
- 2.8 STEP 7: Write a Database Servlet
- 2.9 (Obsolete and Don’t Do)(Prior to Tomcat 7) Deploying Servlets using web.xml
- 3. A Full-Stack Web Developer
- 4. (Skip Unless…) How to Debug?
- 4.1 …Cannot Start Tomcat after Installation
- 4.2 …Cannot Access the Tomcat Server From Browser
- 4.3 …Java Servlet Errors
- 4.4 …Java Database Servlet Errors
1. Introduction
1.1 Web Application (Webapp)
A web application (or webapp), unlike standalone application, runs over the Internet. Examples of webapps are google, amazon, facebook and twitter. A webapp is typically a 3-tier (or multi-tier) client-server database application run over the Internet as illustrated in the diagram below. It comprises five components:- HTTP Server: E.g., Apache HTTP Server, Apache Tomcat Server, Microsoft Internet Information Server (IIS), nginx, Google Web Server (GWS), and others.
- HTTP Client (or Web Browser): E.g., Internet Explorer (MSIE), FireFox, Chrome, Safari, and others.
- Database: E.g., Open-source MySQL, PostgreSQL, Apache Derby, mSQL, SQLite, OpenOffice’s Base; Commercial Oracle, IBM DB2, SAP SyBase, Microsoft SQL Server, Microsoft Access; and others.
- Client-Side Programs: Could be written in HTML Form, JavaScript, and others.
- Server-Side Programs: Could be written in Java Servlet/JSP, ASP, PHP, Perl, Python, JavaScript, and others.

A typical use case is:
- A user, via a web browser (HTTP client), issues a URL request to an HTTP server to start a webapp.
- The HTTP server returns an HTML form (client-side program), which is loaded and rendered in the client’s browser.
- The user fills up the query criteria inside the form and submits the form.
- The client-side program sends the query parameters to a server-side program.
- The server-side program receives the query parameters, queries the database based on these parameters, and returns the query result to the client-side program.
- The client-side program receives the query result and displays on the browser.
- The process repeats for the next request-response.
1.2 Hypertext Transfer Protocol (HTTP)
- HTTP is an application layer protocol runs over TCP/IP. The IP provides support for routing and addressing (via a unique IP address for machines connected to the Internet); while TCP supports multiplexing via 64K ports from port number 0 to 65535. The default port number assigned to HTTP is TCP port 80. (Notes: TCP Port numbers below 1024 are reserved for popular protocols such as HTTP, FTP, SMTP; Port numbers 1024 and above could be used for applications.)
- HTTP is an asynchronous request-response application-layer protocol. A client sends a request message to the server. The server then returns a response message to the client. In other words, HTTP is a pull protocol, a client pulls a page from the server (instead of server pushes pages to the clients).
- The syntax of the message is defined in the HTTP specification.

1.3 Apache Tomcat HTTP Server
Apache Tomcat is a Java-capable HTTP server, which could execute special Java programs known as “Java Servlet” and “Java Server Pages (JSP)”. Tomcat is an open-source project, under the “Apache Software Foundation” (which also provides the most use, open-source, industrial-strength Apache HTTP Server). The mother site for Tomcat is http://tomcat.apache.org. Alternatively, you can find tomcat via the Apache mother site @ http://www.apache.org. Tomcat was originally written by James Duncan Davison (then working in Sun) in 1998, based on an earlier Sun’s server called Java Web Server (JWS). It began at version 3.0 after JWS 2.1 it replaced. Sun subsequently made Tomcat open-source and gave it to Apache. The various Tomcat releases are:- Tomcat 3.0 (1999): Reference Implementation (RI) for Servlet 2.2 and JSP 1.1.
- Tomcat 4.1 (Sep 2002): RI for Servlet 2.3 and JSP 1.2.
- Tomcat 5.0 (Dec 2003): RI for Servlet 2.4 and JSP 2.0.
- Tomcat 6.0 (Feb 2007): RI for Servlet 2.5 and JSP 2.1.
- Tomcat 7.0 (Jan 2011): RI for Servlet 3.0, JSP 2.2 and EL 2.2.
- Tomcat 8.0 (Jun 2014): RI for Servlet 3.1, JSP 2.3, EL 3.0 and WebSocket 1.0. Tomcat 8.5 (June 2016) supports HTTP/2, OpenSSL, TLS virtual hosting and JASPIC 1.1.
- Tomcat 9.0 (Jan 2018): RI for Servlet 4.0, JSP 2.3, EL 3.0, WebSocket 1.0, JASPIC 1.1.
- Tomcat 10.0 (???):
2. How to Install Tomcat and Get Started with Java Servlet Programming
2.1 STEP 0: Create a Directory to Keep all your Works
I shall assume that you have created a directory called “c:\myWebProject
” (for Windows) or “~\myWebProject
” (for macOS) in your earlier exercises. Do it otherwise. This step is important; otherwise, you will be out-of-sync with this article and will not be able to find your files later.
2.2 STEP 1: Download and Install Tomcat
For Windows
- Goto http://tomcat.apache.org ⇒ Under “Tomcat 9.0.{xx} Released”, where {xx} is the latest update number ⇒ Click “Download” ⇒ Under “9.0.{xx}” ⇒ Binary Distributions ⇒ Core ⇒ “
zip
” (e.g., “apache-tomcat-9.0.{xx}.zip
“, about 11 MB). - UNZIP (right-click ⇒ Extract All) the downloaded file into your project directory “
c:\myWebProject
“. Tomcat shall be unzipped into directory “c:\myWebProject\apache-tomcat-9.0.{xx}
“. - For EASE OF USE, we shall shorten and rename this directory to “
c:\myWebProject\tomcat
“.
.
For macOS
- Goto http://tomcat.apache.org ⇒ Under “Tomcat 9.0.{xx} Released”, where {xx} is the latest update number ⇒ Click “Download” ⇒ Under “9.0.{xx}”⇒ Binary distribution ⇒ Core ⇒ “
tar.gz
” (e.g., “apache-tomcat-9.0.{xx}.tar.gz
“, about 10.5 MB). - To install Tomcat:
- Double-click the downloaded tarball (e.g., “
apache-tomcat-9.0.{xx}.tar.gz
“) to expand it into a folder (e.g., “apache-tomcat-9.0.{xx}
“). - Move the extracted folder (e.g., “
apache-tomcat-9.0.{xx}
“) to your project directory “~/myWebProject
“. - For EASE OF USE, we shall shorten and rename this folder to “tomcat”, i.e., “
~/myWebProject/tomcat
“.
- Double-click the downloaded tarball (e.g., “
.
For Ubuntu
Read “How to Install Tomcat on Ubuntu“. You need to switch between these two articles.
For academic learning, I recommend “zip
” (or “tar.gz
“) package, as you could simply delete the entire directory when Tomcat is no longer needed (without running any un-installer). You are free to move or rename the Tomcat’s installed directory. You can install (unzip) multiple copies of Tomcat in the same machine.
Tomcat’s Sub-Directories
Take a quick look at the Tomcat installed directory. It contains the these sub-directories:- bin: contains the binaries and scripts (e.g.,
startup.bat
andshutdown.bat
for Windows;startup.sh
andshutdown.sh
for Unixes and macOS). - conf: contains the system-wide configuration files, such as
server.xml
,web.xml
, andcontext.xml
. - webapps: contains the webapps to be deployed. You can also place the WAR (Webapp Archive) file for deployment here.
- lib: contains the Tomcat’s system-wide library JAR files, accessible by all webapps. You could also place external JAR file (such as MySQL JDBC Driver) here.
- logs: contains Tomcat’s log files. You may need to check for error messages here.
- work: Tomcat’s working directory used by JSP, for JSP-to-Servlet conversion.
2.3 STEP 2: Create an Environment Variable JAVA_HOME
(For Windows)
You need to create an environment variable (system variable available to all applications) called “JAVA_HOME
“, and set it to your JDK installed directory.
Follow the steps HERE!
(For macOS)
Skip this step. No need to do anything.
2.4 STEP 3: Configure the Tomcat Server
The Tomcat configuration files, in XML format, are located in the “conf
” sub-directory of your Tomcat installed directory, e.g. “c:\myWebProject\tomcat\conf
” (for Windows) or “~/myWebProject/tomcat/conf
” (for macOS). The important configuration files are:
server.xml
web.xml
context.xml
Step 3(a) “conf\server.xml” – Set the TCP Port Number
Use a programming text editor (e.g., Sublime Text, Atom) to open the configuration file “server.xml
“.
The default TCP port number configured in Tomcat is 8080, you may choose any number between 1024 and 65535, which is not used by existing applications. We shall choose 9999 in this article. (For production server, you should use port 80, which is pre-assigned to HTTP server as the default port number.)
Locate the following lines (around Line 69) that define the HTTP connector, and change port="8080"
to port="9999"
.
port="9999" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />
Step 3(b) “conf\web.xml” – Enable Directory Listing
Again, use a programming text editor to open the configuration file “web.xml
“.
We shall enable directory listing by changing “listings
” from “false
” to “true
” for the “default
” servlet. This is handy for test system, but not for production system for security.
Locate the following lines (around Line 122) that define the “default
” servlet; and change the “listings
” from “false
” to “true
“.
default org.apache.catalina.servlets.DefaultServlet debug 0 listings true 1
Step 3(c) “conf\context.xml” – Enabling Automatic Reload
We shall add the attributereloadable="true"
to the
element to enable automatic reload after code changes. Again, this is handy for test system but not recommended for production, due to the overhead of detecting changes.
Locate the
start element (around Line 19), and change it to
.
reloadable="true">
......
......
2.5 STEP 4: Start Tomcat Server
The Tomcat’s executable programs and scripts are kept in the “bin
” sub-directory of the Tomcat installed directory.
Step 4(a) Start Server
For Windows
I shall assume that Tomcat is installed in “c:\myWebProject\tomcat
“. Launch a CMD shell and issue:
c: // Change drive cd \myWebProject\tomcat\bin // Change directory to your Tomcat's binary directory startup // Run startup.bat to start tomcat server
For macOS
I assume that Tomcat is installed in “
A new Tomcat console window appears (with Java’s coffee-cup logo as icon). Study the messages on the console. Look out for the Tomcat’s port number. Double check that Tomcat is running on port 9999 as configured.
Error messages will be sent to this console. ~/myWebProject/tomcat
“. To start the Tomcat server, open a new “Terminal” and issue:
cd ~/myWebProject/tomcat/bin // Change directory to your Tomcat's binary directory ./catalina.sh run // Run catalina.sh to start tomcat server
System.out.println()
issued by your Java servlets will also be sent to this console.
............ ............ xxxxx INFO [main] org.apache.coyote.AbstractProtocol.start Starting ProtocolHandler ["http-nio-9999"] xxxxx INFO [main] org.apache.coyote.AbstractProtocol.start Starting ProtocolHandler ["ajp-nio-8009"] xxxxx INFO [main] org.apache.catalina.startup.Catalina.start Server startup in [1325] ms(Skip Unless …) Cannot Start Tomcat: Read “How to Debug“.
Step 4(b) Start a Client to Access the Server
Start a browser (Firefox, Chrome) as an HTTP client. Issue URL “http://localhost:9999
” to access the Tomcat server’s welcome page. The hostname “localhost
” (with IP address of 127.0.0.1
) is meant for local loop-back testing within the same machine. For users on the other machines over the net, they have to use the server’s IP address or DNS domain name in the form of “http://serverHostnameOrIPAddress:9999
“.

(Optional) Try issuing URL
http://localhost:9999/examples
to view the servlet and JSP examples. Try running some of the servlet examples.
Step 4(c) Shutdown Server
For Windows
You can shutdown the tomcat server by either:- Press Ctrl-C on the Tomcat console; OR
- Run “
\bin\shutdown.bat
” script. Open a new “cmd” and issue:c: // Change the current drive cd \myWebProject\tomcat\bin // Change directory to your Tomcat's binary directory shutdown // Run shutdown.bat to shutdown the server
For macOS
To shutdown the Tomcat server:
WARNING: You MUST properly shutdown the Tomcat. DO NOT kill the CAT by pushing the window’s “CLOSE” button.
- Press Control-C (NOT Command-C) on the Tomcat console; OR
- Run the “
/bin/shutdown.sh
” script. Open a new “Terminal” and issue:cd ~/myWebProject/tomcat/bin // Change current directory to Tomcat's bin directory ./shutdown.sh // Run shutdown.sh to shutdown the server
2.6 STEP 5: Develop and Deploy a WebApp
Step 5(a) Create the Directory Structure for your WebApp

Let’s call our first webapp “
hello
“. Goto Tomcat’s “webapps
” sub-directory and create the following directory structure for your webapp “hello
” (as illustrated). The directory names are case-sensitive!!
- Under Tomcat’s “
webapps
“, create your webapp’s root directory “hello
” (i.e., “\webapps\hello
“). - Under “
hello
“, create a sub-directory “WEB-INF
” (case sensitive, a “dash” not an underscore) (i.e., “\webapps\hello\WEB-INF
“). - Under “
WEB-INF
“, create a sub-sub-directory “classes
” (case sensitive, plural) (i.e., “\webapps\hello\WEB-INF\classes
“).
- “
hello
“: The is called the context root (or document base directory) of your webapp. You should keep all your HTML files and resources visible to the web users (e.g., HTMLs, CSSs, images, scripts, JSPs) under this context root. - “
hello/WEB-INF
“: This directory, although under the context root, is not visible to the web users. This is where you keep your application’s web descriptor file “web.xml
“. - “
hello/WEB-INF/classes
“: This is where you keep all the Java classes such as servlet class-files.
hello
webapp. Check the Tomcat’s console to confirm that “hello
” application has been properly deployed:
...... xxxxx INFO [main] org.apache.catalina.startup.HostConfig.deployDirectory Deploying web application directory [xxx\webapps\hello] xxxxx INFO [main] org.apache.catalina.startup.HostConfig.deployDirectory Deployment of web application directory [xxx\webapps\hello] has finished in [38] ms ......You can issue the following URL to access the web application “
hello
“:
http://localhost:9999/helloYou should see the directory listing of the directory “
\webapps\hello
“, which shall be empty at this point of time. Take note that we have earlier enabled directory listing in “web.xml
“. Otherwise, you will get an error “404 Not Found”.
Step 5(b) Write a Welcome Page
Create the following HTML page and save as “HelloHome.html
” in your webapp’s root directory “hello
“.
1 2 3 4 5 6 7 |
My Name is so and so. This is my HOME. |
http://localhost:9999/hello/HelloHome.html

hello
“:
http://localhost:9999/helloThe server will return the directory listing of your base directory. You can then click on “
HelloHome.html
“.
Rename “HelloHome.html
” to “index.html
“, and issue a directory request again:
http://localhost:9999/helloNow, the server will redirect the directory request to “
index.html
“, if the root directory contains an “index.html
“, instead of serving the directory listing.
You can check out the home page of your peers by issuing:
http://YourPeerHostnameOrIPAddr:9999/hello http://YourPeerHostnameOrIPAddr:9999/hello/HelloHome.htmlwith a valid “
YourPeerHostnameOrIPAddr
“, provided that your peer has started his tomcat server and his firewall does not block your access. You can use command such as “ipconfig
” (Windows), “ifconfig
” (macOS and Unix) to find your IP address.
(Skip Unless…) The likely errors are “Unable to Connect”, “Internet Explorer cannot display the web page”, and “404 File Not Found”. Read “How to Debug” section.
2.7 STEP 6: Write a “Hello-world” Java Servlet
A servlet is Java program that runs inside a Java-capable HTTP Server, such as Apache Tomcat. A web user invokes a servlet by issuing an appropriate URL from a web browser (HTTP client). Before you proceed, I shall assume that you are familiar with Java Programming and have installed the followings:- JDK (Read “How to install JDK and Get Started“).
- A programming text editor, such as Sublime Text or Atom.
Step 6(a) Write a “Hello-world” Java Servlet
A Java servlet is a Java program that runs inside a HTTP server. A web user invokes a servlet by issuing a URL from a browser (or HTTP client). In this example, we are going to write a Java servlet calledHelloServlet
, which says “Hello, world!”. We will configure such that web users can invoke this servlet by issuing URL http://ip_addr:port/hello/sayhello
from their browser, as illustrated:

HelloServlet.java
” and save it under your application “classes
” directory (i.e., “\webapps\hello\WEB-INF\classes\HelloServlet.java
“). This servlet says “Hello”, echoes some request information, and prints a random number upon each request.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
// To save as "\webapps\hello\WEB-INF\classes\HelloServlet.java" import java.io.*; import javax.servlet.*; import javax.servlet.http.*; import javax.servlet.annotation.*; @WebServlet("/sayhello") // Configure the request URL for this servlet (Tomcat 7/Servlet 3.0 upwards) public class HelloServlet extends HttpServlet { // The doGet() runs once per HTTP GET request to this servlet. @Override public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { // Set the response MIME type of the response message response.setContentType("text/html"); // Allocate a output writer to write the response message into the network socket PrintWriter out = response.getWriter(); // Write the response message, in an HTML page out.println(""); out.println("“); out.println(“”); out.println(“”); out.println(” Hello, world!“); // says Hello // Echo client’s request information out.println(” Request URI: ” + request.getRequestURI() + ” “); out.println(” Protocol: ” + request.getProtocol() + ” “); out.println(” PathInfo: ” + request.getPathInfo() + ” “); out.println(” Remote Address: ” + request.getRemoteAddr() + ” “); // Generate a random number upon each request out.println(” A Random Number: ” + Math.random() + “ “); out.println(”");
out.close(); // Always close the output writer
}
}
|
HelloServlet
to URL “/sayhello
” via annotation @WebServlet("/sayhello")
, which is applicable to Tomcat 7 onwards. In other words, the full URL shall be http://ip_addr:port/hello/sayhello
to trigger this HelloServlet
.
Step 6(b) Compiling the Servlet (DIFFICULT)
We need the Java Servlet API to compile the servlet. Servlet API is NOT part of JDK. Tomcat provides a copy in/lib/servlet-api.jar
. We need to include this JAR file in the compilation via the -cp
(classpath) option as follows:
(For Windows)
// Assume that Tomcat is installed in c:\myWebProject\tomcat // Change directory to the Java source directory c: cd \myWebProject\tomcat\webapps\hello\WEB-INF\classes // Compile javac -cp .;c:\myWebProject\tomcat\lib\servlet-api.jar HelloServlet.java
(For macOS)
The output of the compilation is “// Assume that Tomcat is installed in ~/myWebProject/tomcat // Change directory to the Java source directory cd ~/myWebProject/tomcat/webapps/hello/WEB-INF/classes // Compile - Need to use $HOME instead of ~ in the "javac" command javac -cp .:$HOME/myWebProject/tomcat/lib/servlet-api.jar HelloServlet.java
HelloServlet.class
“.
Use your “File Explorer” to check the “webapps/hello/WEB-INF/classes
” folder to make sure that “HelloServlet.class
” has been created in the right place.
Step 6(c) Invoke the Servlet
Restart your Tomcat Server (just in case …). To invoke this servlet, start a browser, and issue the request URL configured as follows:http://localhost:9999/hello/sayhelloYou shall see the output of the servlet displayed in your web browser. Refresh the browser, you shall see a new random number upon each refresh. In other word, the
doGet()
method of the servlet runs once per request.
View Page Source
(For Firefox and Chrome) Right-click the page ⇒ “View Page Source” to look at the output received by the web browser (which is returned by the server). Take note that the web browser receives only the output of the servlet (generated via theout.println()
statements). The client has no access to the servlet source codes (which may contain confidential information).
(For macOS’s Safari browser) You need to enable “Developer Menu” under the “Preferences” to enable the “View Source” menu.
Hello, world!
Request URI: /hello/sayhello Protocol: HTTP/1.1 PathInfo: null Remote Address: 127.0.0.1 A Random Number: 0.3523682325749493 (Skip Unless…) The likely errors are “404 File Not Found” and “500 Internal Server Error”. Read “How to debug” Section.(Optional) Inspecting HTTP Request and Response Messages
When you enter a URL (e.g.,http://localhost:9999/hello/sayhello
) on a web browser, an HTTP GET request message is sent to the server; and the server returns a response message for display on the web browser. You can inspect the request and response messages via Web browser’s Developer Tool.
For Firefox/Chrome, press F12 (called F12 debugger) to enable “Web Console” or “Developer Tool”. Choose “Console” or “Network” pane. Enter URL http://localhost:9999/hello/sayhello
(or refresh). Enable “Net” (not in Gray). Expand the link http://localhost:9999/hello/sayhello
. A HTTP message consists of a header and a body. Inspect the request header and body; as well as the response header and body.
The request message header is as follows:
GET http://localhost:9999/hello/sayhello HTTP/1.1 Host: localhost:9999 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 Accept-Encoding: gzip, deflate Accept-Language: en-US,en;q=0.5 Cache-Control:max-age=0 Connection: keep-alive Upgrade-Insecure-Requests: 1 User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0For this request, there is no request message body. The response message header is as follows:
HTTP/1.1 200 OK Date: xxx, xx xxx xxxx xx:xx:xx xxx Content-Length: 286 Content-Type: text/html;charset=ISO-8859-1The response message body is as follows:
Hello, world!
Request URI: /hello/sayhello Protocol: HTTP/1.1 PathInfo: null Remote Address: 0:0:0:0:0:0:0:1 A Random Number: 0.44802807692555682.8 STEP 7: Write a Database Servlet
This section assumes that you are familiar with “Java database programming” and “MySQL database server”. Otherwise, read “Java Database Program” and “How to Install MySQL and Get Started“, respectively.Step 7(a) Setup a Database on MySQL (Already done in the MySQL exercises)
Start your MySQL server. Take note of the server’s port number. I shall assume that the MySQL server is running on port3306
, whereas the Tomcat is running on port 9999
.
// For Windows: I shall assume that MySQL is installed in "c:\myWebProject\mysql" c: cd \myWebProject\mysql\bin mysqld --console // For macOS // Use graphical control at "System Preferences" -> MySQLStart a MySQL client. I shall assume that there is a user called “
myuser
” with password “xxxx
“.
// For Windows: I shall assume that MySQL is installed in "c:\myWebProject\mysql" c: cd \myWebProject\mysql\bin mysql -u myuser -p // For macOS: I shall assume that MySQL is installed in "/usr/local/mysql" cd /usr/local/mysql/bin ./mysql -u myuser -pRun the following SQL statements to create a database called “
ebookshop
“, with a table called “books
” with 5 columns: id
, title
, author
, price
, qty
.
create database if not exists ebookshop; use ebookshop; drop table if exists books; create table books ( id int, title varchar(50), author varchar(50), price float, qty int, primary key (id)); insert into books values (1001, 'Java for dummies', 'Tan Ah Teck', 11.11, 11); insert into books values (1002, 'More Java for dummies', 'Tan Ah Teck', 22.22, 22); insert into books values (1003, 'More Java for more dummies', 'Mohammad Ali', 33.33, 33); insert into books values (1004, 'A Cup of Java', 'Kumar', 55.55, 55); insert into books values (1005, 'A Teaspoon of Java', 'Kevin Jones', 66.66, 66); select * from books;
Step 7(b) Install MySQL JDBC Driver (Already done in the previous JDBC exercises)
You need to download MySQL JDBC driver if you have not done so. Read “Installing the MySQL JDBC Driver“.Step 7(c) Copy the MySQL JDBC Drive to Tomcat’s “lib” (IMPORTANT!!!)
Copy the MySQL JDBC DriverJAR
file “mysql-connector-java-8.0.{xx}.jar
” into Tomcat’s lib
directory, i.e., “c:\myWebProject\tomcat\lib
” (for Windows) or “~\myWebProject\tomcat\lib
” (macOS).
Step 7(d) Write a Client-side HTML Form
Let’s write an HTML script to create a query form with 3 checkboxes and a submit button, as illustrated below. Save the HTML file as “querybook.html
” in your application root directory “\webapps\hello
”.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Yet Another Bookshop |
http://localhost:9999/hello/querybook.htmlCheck a box (e.g., “Tan Ah Teck”) and click the “Search” button. You are expected to get an error “404 File Not Found”, as you have yet to write the server-side program. But observe the URL in the browser’s navigation bar, reproduced as follows:
http://localhost:9999/hello/query?author=Tan+Ah+Teck
The URL request consists of two part: a URL corresponding to the “action
” attribute of the
Latest version tested: Tomcat 9.0.30, MySQL 8.0.19, JDK 13.0.1, Windows 10, macOS 10.15, Ubuntu 18.04LTS
Last modified: February, 2020
Original link here
Original link here