DEV Community: Quang Hieu (Bee)

Learn about the priority levels of config files and distinguish between .yaml and .properties files in Java Spring Boot.

Quang Hieu (Bee) — Mon, 03 Mar 2025 17:45:07 +0000

Hello everyone! Today, I will guide you through the priority levels of configuration files in a Java Spring Boot project and the differences between .yaml and .properties files. Let’s dive in!

1. Priority Levels of Configuration Files

In Spring Boot, configuration files can be placed in various locations, each with its own priority level. The common structure of configuration files in a project is as follows:

The structure of configuration files in the project will be arranged in the following order of priority:

2. Checking the Priority Levels

To test if the priority levels work as described, I changed the port in several configuration files:

File 1: port 8080

File 2: port 8081

File 3: port 8082

File 4: port 8083

After running the application, the port that was set is 8080.

Then, I deleted the outermost configuration file and ran the application again. The result showed the port as 8081.

Similarly, you can test with the remaining configuration files.

Isn’t it amazing? From these examples, we can clearly distinguish the priority of configuration files in a project.

3. Differentiating .properties and .yaml Files
In Java Spring Boot, both .properties and .yaml files are used to configure the application. However, they have some differences:

.properties
- Simple "key-value" structure.
- Stores data as strings. For complex data types, additional processing is required.
- Example:

server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb

.yaml:
- Hierarchical structure, making it easy to read and organize complex information.
- Supports multiple data types (strings, numbers, arrays, objects, booleans), making the configuration more flexible.
- Example

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb

4. Priority Levels When Both .properties and .yaml Files Exist

Let’s say we have both .properties and .yaml files in the project. Let’s check the priority level:

File .properties: port 8083

File .yaml: port 8084

After running the application, the port that was set is 8083.

Conclusion

From the examples above, you should now have a clearer understanding of the priority levels of configuration files in Spring Boot and the differences between .properties and .yaml. I hope this article helps you gain more useful knowledge. If you found it helpful, don’t forget to leave me a reaction!

If you found this article useful and interesting, please share it with your friends and family. I hope you found it helpful. Thanks for reading 🙏

Let's get connected! You can find me on:

Medium: Quang Hieu (Bee) -- Medium
Dev: Quang Hieu (Bee) -- Dev
Linkedin: Quang Hieu (Bee) -- Linkedin
Buy Me a Coffee: Quang Hieu (Bee) -- buymeacoffee

Gin and router example

Quang Hieu (Bee) — Mon, 08 Jul 2024 17:34:09 +0000

Install Gin with the following command:

go get -u github.com/gin-gonic/gin

After installation, we proceed to code in the “main.go” file with a simple function as follows:

package main

import (
  "net/http"

  "github.com/gin-gonic/gin"
)

func main() {
  r := gin.Default()
  r.GET("/ping", func(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{
      "message": "pong",
    })
  })
  r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
}

Then run the main file with the following command:

go run cmd/server/main.go

Note: Depending on your folder organization, the command to run the main.go file may differ from mine. I have introduced how to organize the structure in the article: here

After running the above command, we will receive the following result:

Great, let's try calling the ping endpoint with the following command:

curl http://localhost:8080/ping

The result received will be:

Now, let's try to split the simple router:

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    v1 := r.Group("/v1")
    {
        v1.GET("/ping", Pong) // curl http://localhost:8080/v1/ping
    }
    r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
}

func Pong(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{
        "message": "pong",
    })
}

Note: After changing the code as above, remember to run the command: "go run cmd/server/main.go" to apply the new code.

Next, let's try running the new router with the following command:

curl http://localhost:8080/v1/ping

The result received will be:

Now, let's try to get the parameter from Param:

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    v1 := r.Group("/v1")
    {
        v1.GET("/ping/:name", Pong) // curl http://localhost:8080/v1/ping
    }
    r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
}

func Pong(c *gin.Context) {
    name := c.Param("name")
    c.JSON(http.StatusOK, gin.H{
        "message": "pong:::: " + name,
    })
}

Note: After changing the code as above, remember to run the command: "go run cmd/server/main.go" to apply the new code.

Try to get the param with the following command:

curl http://localhost:8080/v1/ping/hieunguyen

The result received will be:

Next, we will try to get the parameter from the Query:

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    v1 := r.Group("/v1")
    {
        v1.GET("/ping", Pong) // curl http://localhost:8080/v1/ping
    }
    r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
}

func Pong(c *gin.Context) {
    id := c.Query("id")
    c.JSON(http.StatusOK, gin.H{
        "message": "pong:::: " + id,
    })
}

Note: After changing the code as above, remember to run the command: "go run cmd/server/main.go" to apply the new code.

Try to get the query with the following command:

curl http://localhost:8080/v1/ping\?id=12345

The result received will be:

You can directly refer to Gin on GitHub with the following link:here

Give me a reaction and a follow for motivation 😘

If you found this article useful and interesting, please share it with your friends and family. I hope you found it helpful. Thanks for reading 🙏

Let's get connected! You can find me on:

Medium: Quang Hieu (Bee) -- Medium
Dev: Quang Hieu (Bee) -- Dev
Linkedin: Quang Hieu (Bee) -- Linkedin
Buy Me a Coffee: Quang Hieu (Bee) -- buymeacoffee

Backend Project Structure Go

Quang Hieu (Bee) — Sun, 07 Jul 2024 16:22:21 +0000

Hi everyone, today I want to share a Go project structure that I have used and found useful. This project structure is suitable for medium and small projects, and even large projects. The way folders and files are organized in this project structure is similar to other programming languages such as NodeJS or Java. This helps everyone to have a more comprehensive and easier understanding when learning about Go. I hope it will be useful and here is my Go project structure.

.
├── cmd/               # Contains executable applications
│   ├── cli/           # Command-line application
│   ├── cronjob/       # Scheduled jobs
│   └── server/        # Server application
│      └── main.go     # Run the application
├── config/            # Configuration for applications
│   └── config.yaml    # Main configuration file
├── docs/              # Project documentation
├── global/            # Global variables
├── internal/          # Internal packages
│   ├── controller/    # Handle client requests
│   ├── initialize/    # Initialize necessary components
│   ├── middlewares/   # Server middlewares
│   ├── models/        # Structs representing data
│   ├── repo/          # Query data from the database
│   ├── routers/       # Define routes for the server
│   ├── service/       # Handle business logic
├── migrations/        # Database migration scripts
├── pkg/               # Reusable packages
│   ├── logger/        # Logging for the application
│   ├── response/      # Handle response to the client
│   ├── setting/       # Application settings
│   └── utils/         # Utility functions
├── scripts/           # Development support scripts
├── tests/             # Test cases for the application
├── third_party/       # Third-party libraries
├── .gitignore         # Git ignore file
├── go.mod             # Go dependencies management
├── go.sum             # Contains checksums of dependencies
├── LICENSE            # Project license
└── README.md          # Project description

This is the result of my project structure on Visual Studio Code

If you found this article useful and interesting, please share it with your friends and family. I hope you found it helpful. Thanks for reading 🙏

Let's get connected! You can find me on:

Medium: Quang Hieu (Bee) -- Medium
Dev: Quang Hieu (Bee) -- Dev
Linkedin: Quang Hieu (Bee) -- Linkedin
Buy Me a Coffee: Quang Hieu (Bee) -- buymeacoffee

Initialize a Go project with “go-blueprint”

Quang Hieu (Bee) — Tue, 25 Jun 2024 17:47:18 +0000

Step-by-step guide to initiating a Go project. Make sure you have Go installed on your machine. You can download it from the official Go website 👉 https://golang.org/dl/
Step 1: Open terminal:

Step 2: Install go-blueprint with the following command:

go install github.com/melkeydev/go-blueprint@latest

Step 3: Open the "go-blueprint" tool on the browser with the following link:

https://go-blueprint.dev/

Step 4: Fill in the necessary information of the project into the form such as projectName, database, framework, and some advanced options if used:

From the information we filled in the form, we will receive an order as shown in the picture.

Step 5: Copy the command, paste it into the terminal and press enter:

go-blueprint create --name my_project --framework gin --driver mongo

If you encounter the "command not found" error as below, follow the next steps in step 5. Otherwise, you can proceed to step 6

Step 5.1: Run command:

GOPATH=$HOME/go

Step 5.2: Run command:

PATH=$PATH:/usr/local/go/bin:$GOPATH/bin

So it's already fixed. You can refer to the error at the link: here

Step 5.3: Then run the command:

go-blueprint create --name my_project --framework gin --driver mongo

Step 6: When run successfully, we will get results as shown:

Step 7: Open the project with Visual Studio Code

Enter the "my_project" directory using the command

cd my_project

Open the project quickly with Visual Studio Code using command

code .

This is the result received

That's a great tool. So we have successfully initiated a Go project with "go-blueprint". To continue running the project we just initiated, we perform the following steps

Step 8: Open the main.go file in the cmd/api folder and add the following line:

fmt.Println("Hello, World!")

Step 9: Open terminal and run command:

make run

We have finally completed the initialization of the Go project and successfully ran the project.

You can refer to "Go-blueprint" here 👉 Go-blueprint

If you found this article useful and interesting, please share it with your friends and family. I hope you found it helpful. Thanks for reading 🙏

Let's get connected! You can find me on:

Medium: Quang Hieu (Bee) -- Medium
Dev: Quang Hieu (Bee) -- Dev
Linkedin: Quang Hieu (Bee) -- Linkedin
Buy Me a Coffee: Quang Hieu (Bee) -- buymeacoffee