Business Guide to Build Web Applications with Java

Java Web Development Environment Setup

Before writing a single line of code, your development environment needs to be in place. Java web development doesn’t require anything exotic, but setting it up properly can save hours of debugging later. And if your team lacks in-house experience, it’s worth exploring how to hire the right Java developer to help you establish a stable, scalable environment from the start.

Primarily, you'll need three things: a JDK, an IDE, and a web server.

1. Install the Right JDK

First, make sure that you have the latest stable version of the Java Development Kit (JDK). Java 21 is currently a popular long-term support version, but the newer version Java 24 is also widely adopted, depending on project needs. Install the one that best fits your requirements, but aim for at least Java 21 to stay compatible with most modern Java frameworks.

2. Choose an IDE That Fits Your Workflow

The best IDE is the one that makes you productive. Don't feel pressured to stick with a single "official" tool. Here are some top contenders, each with distinct strengths, for your Java and web development needs:

Eclipse IDE for Enterprise Java and Web Developers

Eclipse is a long-standing favorite for enterprise-grade Java development. It comes packed with built-in tools for Java EE (Jakarta EE), servlet development, JSPs, and Maven. If you're deep into traditional, large-scale Java applications, Eclipse offers robust, integrated support, making it a familiar and powerful environment.

IntelliJ IDEA (Community or Ultimate)

IntelliJ IDEA is celebrated for its intelligent code suggestions and advanced features. It provides exceptional support for Spring Boot and modern web technologies, anticipating your needs with smart code completion and powerful refactoring tools. The Ultimate edition offers comprehensive support for a wide range of web frameworks, making it a favorite for full-stack developers.

VS Code

Visual Studio Code is a lightweight, flexible, and highly customizable editor. While not a full IDE out of the box, installing Java extensions transforms it into a capable environment for web app development. Its speed, vast extension marketplace, and built-in Git integration make it an excellent choice for developers who prefer a snappier experience and work across multiple technologies.

3. Set Up a Local Server

To get your Java web applications up and running, you'll need a servlet container or an application server. These environments handle your code and serve it up to the web. Here are the top picks:

Apache Tomcat

This is a lightweight and widely used servlet container, perfect for applications built primarily with servlets and JSPs. Tomcat is a go-to for its simplicity, fast startup, and huge community support, making it easy to deploy and manage your web apps.

Jetty

Jetty stands out for being highly embeddable, meaning you can easily integrate it directly into your Java applications. It's also super efficient and fast, making it ideal for microservices, testing, or when you need a server with a small footprint and modern protocol support like HTTP/2.

Spring Boot DevTools

If you're using Spring Boot, you're already set. Spring Boot apps come with an embedded server (usually Tomcat). Adding DevTools gives you incredible hot reload capabilities and automatic restarts when you make code changes. This dramatically speeds up development by giving you instant feedback without manual restarts.

Step-by-Step Tutorial to Build Web Application with Java

Now that all your perquisites are taken care of it's time to build your web application. In this section, we'll walk through the core steps to build a basic Java-based web application using IntelliJ IDEA, servlets, and JSP. This gives you a strong foundation before diving into more complex frameworks like Spring.

Step 1: Install IntelliJ IDEA

Download IntelliJ IDEA: Go to the IntelliJ IDEA download page and choose the Community Edition (free) or the Ultimate Edition (paid).

Install IntelliJ IDEA: Run the downloaded installer and follow the on-screen instructions.

Step 2: Install Java Development Kit (JDK)

If you don’t have JDK installed yet:

1. Download the latest version of JDK.

2. Install it following the instructions for your operating system.

3. Set the JAVA_HOME environment variable to the location where you installed the JDK.

Step 3: Install Apache Tomcat

Apache Tomcat is a popular servlet container that will help run your Java web application.

1. Download Tomcat from the official Tomcat download page.

2. Extract it to a folder on your machine.

3. Note the path to your Tomcat installation folder for later.

Step 4: Create a New Project in IntelliJ IDEA

1. Open IntelliJ IDEA and click on New Project.

2. In the New Project wizard:

• Choose Java (make sure to select an appropriate SDK version).

• Uncheck any unnecessary project templates like "Create Git repository" or "Add sample code."

• Click Next.

3. Name your project (e.g., MyWebApp) and select a project location.

4. Click Finish.

Step 5: Set Up the Web Module

• Go to File > Project Structure (or press Ctrl+Alt+Shift+S).

• Select Modules under Project Settings.

• Click on the + icon and choose Web.

• Set the Content Root to the folder where your project is located (if not already).

• Click Apply and then OK.

Step 6: Set Up Apache Tomcat in IntelliJ

1. Go to the Run/Debug Configurations: In the top-right corner of IntelliJ, click on the drop-down menu (where you usually select the configuration to run) and click Edit Configurations.

2. Add Tomcat Server:

• Click the + icon and choose Tomcat Server > Local.

• Name your configuration (e.g., Tomcat Local).

• In the Deployment tab, click the + and choose Artifact.

• Select your web module (e.g., MyWebApp: war exploded).

• In the Server tab, set the Tomcat Home to the folder where you installed Apache Tomcat.

3. Click Apply and then OK.

Step 7: Add Servlet to Your Project

1. Create a Servlet:

• Right-click on the src directory of your project, go to New > Java Class and name it HelloServlet.

• Make it extend HttpServlet and override the doGet method:

import java.io.*;

import javax.servlet.*;

import javax.servlet.http.*;

public class HelloServlet extends HttpServlet {

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        response.setContentType("text/html");

        PrintWriter out = response.getWriter();

        out.println("<html><body>");

        out.println("<h1>Hello, World!</h1>");

        out.println("</body></html>");

    }

}

2. Map the Servlet in web.xml:

• In the src > main > webapp > WEB-INF folder, create or edit the web.xml file.

• Add the following servlet mapping:

<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">

    <servlet>

        <servlet-name>HelloServlet</servlet-name>

        <servlet-class>com.mywebapp.HelloServlet</servlet-class>

    </servlet>

    <servlet-mapping>

        <servlet-name>HelloServlet</servlet-name>

        <url-pattern>/hello</url-pattern>

    </servlet-mapping>

</web-app>

Step 8: Create JSP Page (Optional)

To create a JSP page for displaying dynamic content:

1. Add a JSP Page:

• In the src > main > webapp folder, create a new file named index.jsp.

• Add the following basic HTML code:

<html>

<body>

    <h2>Welcome to My Java Web Application!</h2>

</body>

</html>

Step 9: Build the Application

1. Compile the Code: Click on Build > Build Project or use the shortcut Ctrl+F9 to compile the project.

2. Deploy the Application:

• In the top-right corner, click the green play button or Run > Run 'Tomcat Local'.

Step 10: Test the Application

1. Access the Application: Open a browser and navigate to:

• For the servlet: http://localhost:8080/MyWebApp/hello

• For the JSP page (if created): http://localhost:8080/MyWebApp/index.jsp

You should see:

• "Hello, World!" for the servlet.

• The message from index.jsp if you created it.

Deep Dive into Java and Web Development Technologies

That was a basic web app that we just built with Java. However, it can get more complex with tools and frameworks. You can use Java for web development in different ways. For example, Netflix utilizes Java for its microservices architecture. The platform is built around a microservices model where each service is a distinct Java-based application running in the cloud.

Let’s break down the most important technologies that make modern Java web development productive and scalable:

1. Servlets and JSP (JavaServer Pages)

Servlets and JSP (JavaServer Pages) are fundamental to Java web development. Part of the Jakarta EE stack, they define how Java handles web requests and generates dynamic HTML on the server.

• Servlets process incoming HTTP requests and formulate responses. They manage the low-level details of web communication.

• JSP allows embedding Java code directly into HTML using special tags. This blends server-side logic with the presentation layer.

While crucial for understanding Java's web history and still found in some legacy or smaller apps, modern production applications typically use higher-level frameworks that abstract this complexity.

2. Spring Framework and Spring Boot

For current Java web application development, Spring Boot is the leading choice. Built on the Spring Framework, it drastically simplifies configuration and setup, enabling rapid development of production-ready applications.

Spring Boot's widespread adoption stems from key advantages:

• Embedded Servers: It includes built-in servers like Tomcat or Jetty, allowing applications to run as standalone Java programs. This streamlines deployment.

• Integrated REST Support: Spring Boot simplifies building RESTful APIs, ideal for backends interacting with JavaScript frontends or mobile apps.

• Auto-configuration and Dependency Injection: These features automatically configure the application based on included libraries and manage component relationships, reducing boilerplate code.

• Seamless Integrations: "Starter" dependencies allow easy integration of features like databases, security, and messaging with minimal setup.

For microservices, RESTful APIs, or scalable web backends, Spring Boot is the primary framework for efficient development and deployment.

3. Java Persistence API (JPA) and Hibernate

Interacting with databases is vital for web applications. JPA (Java Persistence API), often implemented via Hibernate, provides an Object-Relational Mapping (ORM) solution. This allows Java objects to seamlessly map to database tables. Developers interact with data using Java objects, not raw SQL.

This approach offers significant benefits:

• Less SQL: Focus on Java objects and their relationships, reducing the need for extensive SQL queries.

• Object-Oriented Data Management: Data is managed as domain-specific objects (e.g., User, Product), aligning with application logic.

• Advanced Features: JPA and Hibernate handle transaction management, lazy loading (fetching data only when needed), and caching (improving performance), contributing to robust and performant applications.

Using JPA with Hibernate is the standard for efficient and maintainable database interactions in Java web applications.

4. Frontend Templating with Thymeleaf

While many modern web apps separate frontend and backend, server-rendered HTML remains relevant. Thymeleaf is a sophisticated, modern alternative to JSP for generating dynamic web pages, especially within the Spring ecosystem.

5. REST APIs with Spring MVC or Spring WebFlux

Today, most interactive web applications rely on REST APIs for communication. These APIs enable your Java backend to send data (usually JSON) to separate frontend applications (like React, Angular) or mobile clients. Spring MVC and Spring WebFlux are the primary Spring frameworks for building these powerful APIs.

6. Build Tools: Maven and Gradle

Build tools like Maven and Gradle are essential in Java development. They manage project tasks: handling dependencies, compiling code, running tests, and packaging applications. You need one for any significant Java project.

• Maven: An established tool using XML-based configuration. It follows "convention over configuration," simplifying setup with predefined structures. It's stable, widely supported, and has a large plugin ecosystem.

• Gradle: A modern, flexible alternative using Kotlin or Groovy-based scripting for configurations. It's known for faster incremental builds and greater customization. 

Both integrate smoothly with IDEs like IntelliJ IDEA and are crucial for CI/CD (Continuous Integration/Continuous Delivery) pipelines, automating your development workflow.

7. Testing Libraries: JUnit and Mockito

Building robust web applications requires rigorous testing. The Java ecosystem offers excellent tools: primarily JUnit and Mockito. Integrating testing tools from the start is crucial for stable, maintainable code.

• JUnit: The industry-standard for unit tests (validating individual code components) and integration tests (verifying interactions between application parts). It provides annotations and assertions for efficient test execution.

• Mockito: A powerful mocking framework. It creates "mock" objects, simulating real dependencies. This helps isolate tests, allowing component testing without real external dependencies, causing issues.

Spring Boot provides strong testing support with built-in annotations and configurations. Good testing practices build confidence in your app's production behavior.

Common Pitfalls in Java Web Development

Despite mature and extensive ecosystem, developing web applications with Java is not without its challenges. Developers frequently encounter common pitfalls that can lead to many issues even security vulnerabilities. To avoid that you need to identify and avoid those mistakes early.

1. Overengineering Simple Features

Java's inherent flexibility can sometimes encourage developers to create overly complex solutions for straightforward problems. This often results in bloated codebases, increased complexity, and slower development cycles. The best approach is to prioritize simplicity. Leverage established design patterns when appropriate, but resist the urge to over-architect for basic functionalities.

2. Ignoring Dependency Management

Ineffective use of build tools like Maven or Gradle can introduce significant problems. These include version conflicts among libraries or unnecessary bloat within your application's final package. It is crucial to explicitly define dependency versions in your build configuration. Furthermore, understanding your project's transitive dependencies—those brought in by other libraries—is essential to prevent unforeseen issues and maintain a lean application.

3. Mixing Business Logic with View Code

A common architectural misstep is embedding core business logic directly within presentation layers, such as JSP pages, or within controller methods. This practice leads to code that is difficult to read, maintain, and test. Adhere strictly to a layered architecture. Business logic should reside in dedicated service layers, ensuring that view components remain solely responsible for rendering data and maintaining a clean separation of concerns.

4. Neglecting Security Practices

Java provides robust security features, but their effectiveness depends entirely on proper implementation. Frequent errors include hardcoding sensitive credentials, failing to validate user input adequately, or overlooking HTTPS usage, even in development environments. Always adhere to established security best practices. This includes using environment variables for sensitive data and rigorously applying input sanitization and validation to protect against common vulnerabilities.

5. Poor Exception Handling

Improper exception handling can severely hinder debugging efforts and mask underlying issues. Common mistakes involve "swallowing" exceptions (catching them without any action) or using overly broad catch(Exception e) blocks. Instead, employ precise exception types to catch specific errors. Always log exceptions meaningfully, including stack traces and contextual information, to facilitate effective troubleshooting and problem resolution.

Wrap Up

Java's enduring presence in the web development landscape has been a remarkable journey. From its robust backend capabilities to its sophisticated modern tools, versatile frameworks and inherent security features, Java is a reliable programming language to build a web app.

In this guide, we walked through step by step on how to build web application with Java, how to set up your environment, and what core technologies are used in Java web application.

If you're looking to accelerate development or need expertise for a larger project, you can always hire Java developers to bring technical depth and industry experience to the table.