Skip to main content Link Menu Expand (external link) Document Search Copy Copied
Syntax Savvy

Deploying Java Applications on a Web Server or in the Cloud

Header Image

Ahoy there, matey! So, you’ve built yourself a fine Java application, and now it’s time to set sail and deploy it to the world. In this article, we’ll navigate through the waters of web servers and application servers to help you hoist your app on the internet. Grab your spyglass and let’s begin our adventure!

Web Server and Application Server

Before we weigh anchor, it’s important to understand the difference between a web server and an application server. These two types of servers are the heart and soul of any online application, and they work together to deliver your Java app to the end user.

Web Server

A web server is like a trusty pirate ship that sails the seas of the internet, delivering static content to web browsers. It can handle HTTP requests and return static files like HTML, CSS, JavaScript, images, and other media. Web servers are built for speed and efficiency, ensuring that your content reaches its destination quickly and without delay.

Popular web servers include Apache HTTP Server, Nginx, and Microsoft Internet Information Services (IIS). Here’s a simple example of how a web server might handle a request for an HTML file:

// The web server receives an HTTP request for "index.html"
GET /index.html HTTP/1.1
Host: www.example.com

// The web server locates the file and responds with the content
HTTP/1.1 200 OK
Content-Type: text/html

<!DOCTYPE html>
<html>
<head>
    <title>Ahoy, World!</title>
</head>
<body>
    <h1>Ahoy, World!</h1>
</body>
</html>

Application Server

While a web server is like a swift pirate ship, an application server is more like a bustling pirate island where dynamic content is generated. Application servers are designed to execute server-side code and return dynamic content, such as the result of a database query or data manipulation.

In the world of Java, application servers often use servlets and JavaServer Pages (JSP) to create dynamic content. Popular Java application servers include Apache Tomcat, WildFly (formerly JBoss), and IBM WebSphere.

Here’s an example of how an application server might handle a request for a servlet that generates a dynamic “Hello, World!” message:

// The application server receives an HTTP request for the "HelloWorldServlet"
GET /HelloWorldServlet HTTP/1.1
Host: www.example.com

// The application server executes the servlet code and responds with the generated content
HTTP/1.1 200 OK
Content-Type: text/html

<!DOCTYPE html>
<html>
<head>
    <title>Ahoy, World!</title>
</head>
<body>
    <h1>Ahoy, World! The time be: 12:34 PM</h1>
</body>
</html>

Web Server and Application Server: Working Together

Web servers and application servers may seem like two different islands, but they can work together to create a seamless experience for your users. Web servers can act as a reverse proxy, forwarding requests for dynamic content to an application server and returning the generated response. This allows you to use the speed and efficiency of a web server for static content and the power of an application server for dynamic content.

In the Java world, you might configure a web server like Nginx or Apache to work alongside an application server like Tomcat, creating a powerful and flexible environment for deploying your application.

Now that you understand the difference between a web server and an application server, you’re ready to set sail on the rest of your deployment journey! In the followingsections, we’ll explore deployment descriptors, learn how to deploy your Java application to a web server, and even venture into the mystical realm of cloud deployment. So batten down the hatches, me hearties, and let’s embark on this exciting voyage together!

Deployment Descriptors

Now that we’ve got our bearings with web servers and application servers, it’s time to chart a course for the mysterious land of deployment descriptors. Deployment descriptors are like treasure maps, guiding our application server on how to deploy and configure our Java application.

What be a Deployment Descriptor?

A deployment descriptor is an XML file that provides configuration information for your Java web application. In the world of servlets and JavaServer Pages (JSP), this file is commonly known as web.xml. The web.xml file resides in the WEB-INF directory of your application’s WAR file, which be the package we’ll use to deploy our app.

Deployment descriptors contain important information like:

  • Servlet and filter definitions
  • Servlet and filter mappings
  • URL patterns
  • Session configuration
  • Security settings

Here be an example of a simple web.xml deployment descriptor for a Java web application:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                             http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
    <servlet>
        <servlet-name>PirateServlet</servlet-name>
        <servlet-class>com.example.PirateServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>PirateServlet</servlet-name>
        <url-pattern>/pirate</url-pattern>
    </servlet-mapping>
</web-app>

In this example, we define a servlet named PirateServlet with the class com.example.PirateServlet. We also map the servlet to the URL pattern /pirate, meaning it will handle requests for http://www.example.com/pirate.

Customizing Your Treasure Map

Every pirate’s treasure map is unique, and so too are deployment descriptors. You can customize your web.xml file to include additional configuration options that suit your application’s needs. Some of these options include:

  • Initializing servlets with custom parameters
  • Defining error pages for specific HTTP status codes
  • Configuring session timeout values
  • Implementing security constraints and user authentication

Here’s an example of a web.xml file with additional configuration options:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                             http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
    <servlet>
        <servlet-name>PirateServlet</servlet-name>
        <servlet-class>com.example.PirateServlet</servlet-class>
        <init-param>
            <param-name>parrotName</param-name>
            <param-value>Polly</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>PirateServlet</servlet-name>
        <url-pattern>/pirate</url-pattern>
    </servlet-mapping>
    <session-config>
        <session-timeout>30</session-timeout>
    </session-config>
    <error-page>
        <error-code>404</error-code>
        <location>/WEB-INF/error/404.html</location</error-page>
    <security-constraint>
        <web-resource-collection>
            <web-resource-name>Protected Area</web-resource-name>
            <url-pattern>/protected/*</url-pattern>
        </web-resource-collection>
        <auth-constraint>
            <role-name>crew-member</role-name>
        </auth-constraint>
    </security-constraint>
    <login-config>
        <auth-method>FORM</auth-method>
        <form-login-config>
            <form-login-page>/login.jsp</form-login-page>
            <form-error-page>/login-error.jsp</form-error-page>
        </form-login-config>
    </login-config>
    <security-role>
        <role-name>crew-member</role-name>
    </security-role>
</web-app>

In this more advanced example, we’ve added an init-param element to our PirateServlet definition, which initializes the servlet with a custom parameter named parrotName and a value of “Polly”. We’ve also set a session-timeout of 30 minutes, specified a custom error page for 404 errors, and added security constraints to protect certain parts of the application.

Anchors Aweigh!

With a proper deployment descriptor in place, your application server will have all the guidance it needs to deploy your Java web application. While sailing the treacherous seas of web development can be a challenge, a well-configured web.xml file can help you navigate safely through the storm.

In the next section, we’ll hoist the Jolly Roger and set sail toward deploying our application to a web server. Stay tuned, mateys!

</error-page>

</web-app>


In this enhanced treasure map, we've added an initialization parameter called `parrotName` with the value "Polly" for our `PirateServlet`. We've also set a session timeout of 30 minutes and specified a custom error page for 404 errors.

### Deploying to a Web Server

Ahoy, matey! It's time to hoist the Jolly Roger and deploy our Java web application to a web server. In this section, we'll explore how to deploy a Java web application using Tomcat, a popular open-source web server and servlet container.

#### Step 1: Install Tomcat

First, you'll need to install Tomcat on your local machine or a remote server. Follow the instructions on the [Apache Tomcat website](https://tomcat.apache.org/) for your specific operating system.

#### Step 2: Package Your Java Web Application

Next, we need to package our Java web application as a WAR file. If you're using a build tool like Maven or Gradle, you can run the appropriate command to generate the WAR file:

- **Maven**: `mvn package`
- **Gradle**: `gradle war`

This will create a WAR file in the `target` (Maven) or `build/libs` (Gradle) directory of your project.

#### Step 3: Deploy the WAR File

With Tomcat installed and our WAR file in hand, it's time to deploy our application. Follow these steps to deploy your Java web application to Tomcat:

1. Locate the Tomcat installation directory, often referred to as `$CATALINA_HOME` or `%CATALINA_HOME%`. This is where you installed Tomcat in step 1.
2. Find the `webapps` directory within the Tomcat installation directory. This is where Tomcat looks for web applications to deploy.
3. Copy your WAR file to the `webapps` directory. For example, if your WAR file is named `pirate-app.war`, you would copy it to `$CATALINA_HOME/webapps/pirate-app.war`.
4. Start Tomcat by running the `startup.sh` script (Unix/Linux/macOS) or the `startup.bat` script (Windows) located in the `bin` directory of your Tomcat installation. This will launch Tomcat and automatically deploy your WAR file.

#### Step 4: Access Your Java Web Application

Once Tomcat is running and your application is deployed, you can access your Java web application by navigating to the appropriate URL in your web browser. The URL will typically be in the following format:

http://localhost:8080/pirate-app


Replace `localhost` with the domain or IP address of your server if you deployed your application remotely. The `8080` is the default port number for Tomcat, and `pirate-app` is the context path of your application, which is derived from the name of your WAR file.

And with that, ye've successfully deployed your Java web application to a web server! Now go forth and sail the high seas of web development, ye swashbuckling developer!

### Deploying to the Cloud

Now that we've conquered the seven seas of local web servers, let's set sail for the vast ocean of cloud computing! Deploying your Java web application to the cloud can provide numerous benefits, such as improved scalability, performance, and reliability. In this section, we'll explore how to deploy your application to the cloud using the popular platform-as-a-service (PaaS) provider, Heroku.

#### Step 1: Sign Up for a Heroku Account

First, navigate to the [Heroku website](https://www.heroku.com/) and sign up for a free account.

#### Step 2: Install the Heroku CLI

To manage your Heroku applications and deploy your code, you'll need to install the [Heroku CLI](https://devcenter.heroku.com/articles/heroku-cli). Follow the installation instructions for your specific operating system.

#### Step 3: Log in to Your Heroku Account

After installing the Heroku CLI, open a terminal or command prompt and run the following command to log in to your Heroku account:

heroku login


This will prompt you to enter your Heroku email and password.

#### Step 4: Prepare Your Java Web Application for Heroku

Before deploying your application to Heroku, you'll need to make a few adjustments:

1. Add a `Procfile` to the root directory of your project. This file tells Heroku how to run your application. For a Java web application using Tomcat, the `Procfile` should contain the following line:

web: java $JAVA_OPTS -jar target/dependency/webapp-runner.jar –port $PORT target/*.war


2. Add a `system.properties` file to the root directory of your project. This file specifies the Java version Heroku should use. For example, to use Java 11, your `system.properties` file should contain:

java.runtime.version=11


3. If you're using Maven or Gradle, ensure that your `pom.xml` or `build.gradle` file includes the necessary plugins and dependencies for Heroku. For detailed instructions, refer to the Heroku documentation for [Maven](https://devcenter.heroku.com/articles/deploying-java-applications-with-the-heroku-maven-plugin) or [Gradle](https://devcenter.heroku.com/articles/deploying-gradle-apps-on-heroku).

#### Step 5: Deploy Your Java Web Application to Heroku

With your Java web application ready for Heroku, follow these steps to deploy it:

1. In the terminal or command prompt, navigate to the root directory of your project.
2. Run the following command to create a new Heroku application:

heroku create


This command will create a new Heroku application with a randomly generated name and add a Git remote for Heroku to your project.

3. Commit your changes to your local Git repository if you haven't already:

git add . git commit -m “Prepare for Heroku deployment”


4. Deploy your application to Heroku by pushing your code to the Heroku Git remote:

git push heroku master


Heroku will build and deploy your application, and you'll see log messages in your terminal or command prompt.

#### Step 6: Access Your Java Web Application on Heroku

Once your application is deployed, you can access it in your web browser using the URL provided by Heroku. The URL will be in the following format:

https://.herokuapp.com/ ```

Replace <app-name> with the name of your Heroku application.

Congratulations, matey! Ye’ve now successfully deployed your Java webapplication to the cloud. Now, your application can scale and grow as needed, providing a reliable and smooth experience for all your users.

In this article, we’ve explored the differences between web servers and application servers, learned about deployment descriptors, and delved into the process of deploying Java web applications to both local web servers and the cloud using Heroku. Now that you have the skills to navigate the high seas of Java web application deployment, the world is your oyster.

So, hoist the Jolly Roger, chart your course, and set sail for a new world of Java web development adventures! And remember, should you encounter any rough waters along the way, you can always come back to this treasure trove of knowledge for guidance. Safe travels, and may the wind be ever at your back, fellow pirate!