Docker to the Rescue: Fixing “Connection Refused” Errors for Java Applications and Databases

Are you tired of encountering the frustrating “java.net.ConnectException: Connection refused” error when running your Java applications and databases using Docker? You’re not alone! In this article, we’ll dive into the world of Docker and explore the solutions to this pesky problem, ensuring your applications and databases run smoothly on ports 8088, 8089, and 5432.

Understanding the Error: What’s Going On?

Before we dive into the solutions, let’s quickly understand what’s happening behind the scenes. The “Connection Refused” error occurs when your Java application attempts to connect to a service (in this case, a database) running on a specific port, but the connection is refused by the service. This can happen due to a variety of reasons, including:

• The service is not running or is not listening on the expected port.
• The service is running, but the port is not exposed or is blocked by a firewall.
• There’s a mismatch in the port numbers between the application and the service.

Setting Up Docker for Your Java Applications and Database

To resolve the “Connection Refused” error, we’ll need to set up Docker containers for our Java applications and database. If you’re new to Docker, don’t worry; we’ll take it one step at a time.

Step 1: Install Docker (If You Haven’t Already)

Head over to the Docker installation page and follow the instructions to install Docker on your machine.

Step 2: Create a Dockerfile for Your Java Application

Create a new file named `Dockerfile` in the root of your Java application project with the following contents:

FROM openjdk:8
COPY . /app
WORKDIR /app
EXPOSE 8088
CMD ["java", "-jar", "your-app.jar"]

Here’s a brief explanation of the Dockerfile:

• `FROM openjdk:8`: We’re using the official OpenJDK 8 image as our base image.
• `COPY . /app`: We’re copying the current directory (our Java application) into the `/app` directory in the container.
• `WORKDIR /app`: We’re setting the working directory to `/app`.
• `EXPOSE 8088`: We’re exposing port 8088 for our Java application.
• `CMD [“java”, “-jar”, “your-app.jar”]`: We’re setting the default command to run our Java application using the `java` command.

Step 3: Create a Docker Compose File for Your Database

Create a new file named `docker-compose.yml` in the root of your project with the following contents:

version: '3'
services:
  db:
    image: postgres
    environment:
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
      POSTGRES_DB: mydb
    ports:
      - "5432:5432"

Here’s a brief explanation of the docker-compose file:

• `version: ‘3’`: We’re using Docker Compose version 3.
• `services:`: We’re defining a service named `db`.
• `image: postgres`: We’re using the official Postgres image.
• `environment:`: We’re setting environment variables for our Postgres database.
• `ports:`: We’re exposing port 5432 from the container and mapping it to port 5432 on the host machine.

Building and Running Your Docker Containers

Now that we have our Dockerfile and docker-compose file, let’s build and run our containers!

Step 1: Build Your Java Application Container

Run the following command to build your Java application container:

docker build -t myapp .

This command will create a Docker image with the name `myapp` using the instructions in your Dockerfile.

Step 2: Start Your Database Container

Run the following command to start your database container:

docker-compose up -d

This command will start your Postgres database container in detached mode (i.e., in the background).

Step 3: Start Your Java Application Container

Run the following command to start your Java application container:

docker run -p 8088:8088 myapp

This command will start your Java application container, mapping port 8088 from the container to port 8088 on the host machine.

Configuring Your Java Application to Connect to the Database

Now that our containers are running, we need to configure our Java application to connect to the database.

Step 1: Update Your Database Connection URL

In your Java application, update your database connection URL to point to the Postgres container:

jdbc:postgresql://db:5432/mydb

Here, we’re using the `db` service name from our docker-compose file as the hostname.

Step 2: Update Your Java Application to Use the Exposed Ports

In your Java application, update your code to use the exposed ports:

server.port=8088

Here, we’re setting the server port to 8088, which is exposed by our Docker container.

Troubleshooting the “Connection Refused” Error

If you’re still experiencing the “Connection Refused” error, here are some troubleshooting tips:

• Check that your database container is running and listening on port 5432.
• Verify that your Java application is using the correct database connection URL and port.
• Make sure that the port 8088 is not being used by another process on your host machine.
• Check the Docker container logs for any errors or issues.

Conclusion

With these steps, you should now have a Dockerized Java application and database running smoothly on ports 8088, 8089, and 5432. Remember to expose the correct ports, use the correct database connection URL, and troubleshoot any issues that arise. Happy coding!

Port	Service
8088	Java Application
8089	Optional – Additional Java Application
5432	Postgres Database

Remember to replace the placeholders (e.g., `your-app.jar`, `myuser`, `mypassword`, `mydb`) with your actual values.

By following this guide, you should be able to resolve the “java.net.ConnectException: Connection refused” error and get your Java applications and database running smoothly using Docker.

Frequently Asked Question

If you’re struggling with “java.net.ConnectException: Connection refused” error when running applications on ports 8088 and 8089, and connecting to a database on port 5432 using Docker, don’t worry! We’ve got you covered.