Writing a Go-Based Microservice for Rating and Review Management

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Project Setup
  4. Creating the Rating and Review Microservice
  5. Implementing Endpoints
  6. Database Integration
  7. Testing
  8. Conclusion

Introduction

In this tutorial, we will learn how to build a Go-based microservice for rating and review management. By the end of this tutorial, you will have a working microservice that allows users to rate and review various items. We will cover topics such as creating endpoints, integrating with a database, and testing the microservice.

Prerequisites

Before starting this tutorial, you should have basic knowledge of the Go programming language, including Go syntax, functions, and packages. Additionally, you should have Go installed on your machine. If you need help with installing Go, please refer to the official Go documentation for your operating system.

Project Setup

First, let’s create a new directory for our project. Open your terminal and run the following command to create a new directory:

mkdir rating-and-review-service

Navigate to the newly created directory:

cd rating-and-review-service

Initialize a new Go module:

go mod init github.com/your-username/rating-and-review-service

This will create a new Go module with the specified module path.

Creating the Rating and Review Microservice

Now that we have our project set up, let’s create the main file for our microservice. Create a new file named main.go in your project directory.

package main

import (
	"log"
	"net/http"
)

func main() {
	// Start the server
	log.Fatal(http.ListenAndServe(":8080", nil))
}

In the above code, we import the necessary packages and define a main function. The http.ListenAndServe function starts the HTTP server on port 8080.

Implementing Endpoints

Now, let’s implement the endpoints for rating and reviewing items. We will use the popular Gorilla Mux router to handle routing in our microservice.

First, let’s install the Gorilla Mux package by running the following command:

go get -u github.com/gorilla/mux

Next, import the Gorilla Mux package in main.go:

import (
	"github.com/gorilla/mux"
)

Inside the main function, initialize a new router:

// Initialize router
router := mux.NewRouter()

Now, let’s define our first endpoint for rating an item. Add the following code inside the main function:

router.HandleFunc("/items/{id}/rating", rateItem).Methods("POST")

In the above code, we define a route /items/{id}/rating that accepts a POST request. The rateItem function will handle this route.

Next, let’s define the rateItem function:

func rateItem(w http.ResponseWriter, r *http.Request) {
	// Implement rating logic here
	
	// Send response
	w.WriteHeader(http.StatusOK)
	w.Write([]byte("Item rated successfully"))
}

Inside the rateItem function, you can implement the logic for rating an item. For now, we are sending a simple response indicating that the item was rated successfully.

Similarly, you can define endpoints for other operations like reviewing an item or getting the average rating of an item.

Database Integration

To store the ratings and reviews, let’s integrate our microservice with a PostgreSQL database using the database/sql package.

First, install the PostgreSQL driver for Go by running the following command:

go get -u github.com/lib/pq

Next, import the necessary packages in main.go:

import (
	"database/sql"
	"fmt"
	"log"

	"github.com/gorilla/mux"
	_ "github.com/lib/pq"
)

Inside the main function, create a new database connection:

// Database connection string
const (
	host     = "localhost"
	port     = 5432
	user     = "postgres"
	password = "<your-password>"
	dbname   = "rating_and_review"
)

// Database connection
db, err := sql.Open("postgres", fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", host, port, user, password, dbname))
if err != nil {
	log.Fatal(err)
}
defer db.Close()

Make sure to replace <your-password> with the actual password for your PostgreSQL database.

Now, let’s update the rateItem function to save the rating in the database:

func rateItem(w http.ResponseWriter, r *http.Request) {
	// Parse request parameters
	params := mux.Vars(r)
	itemID := params["id"]
	rating := r.FormValue("rating")
	review := r.FormValue("review")

	// Insert rating into database
	_, err := db.Exec("INSERT INTO ratings (item_id, rating, review) VALUES ($1, $2, $3)", itemID, rating, review)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte("Failed to rate item"))
		return
	}

	// Send response
	w.WriteHeader(http.StatusOK)
	w.Write([]byte("Item rated successfully"))
}

In the above code, we parse the id, rating, and review parameters from the request. Then, we insert the rating into the database using the db.Exec function.

Testing

To test our microservice, we can use Go’s built-in testing framework. Create a new file named main_test.go in the same directory and add the following code:

package main

import (
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
)

func TestRateItem(t *testing.T) {
	// Create request body
	body := strings.NewReader("rating=5&review=Great item")

	// Create request
	req, err := http.NewRequest("POST", "/items/1/rating", body)
	if err != nil {
		t.Fatal(err)
	}

	// Create response recorder
	rr := httptest.NewRecorder()

	// Serve request
	handler := http.HandlerFunc(rateItem)
	handler.ServeHTTP(rr, req)

	// Check the response status code
	if rr.Code != http.StatusOK {
		t.Errorf("expected status %v but got %v", http.StatusOK, rr.Code)
	}

	// Check the response body
	expected := "Item rated successfully"
	if rr.Body.String() != expected {
		t.Errorf("expected %v but got %v", expected, rr.Body.String())
	}
}

In the above code, we define a test function TestRateItem that sends a POST request to the /items/1/rating endpoint with the specified rating and review. We then check if the response status code and body match the expected values.

To run the test, execute the following command in your terminal:

go test -v

If everything is implemented correctly, you should see the test passing.

Conclusion

In this tutorial, we learned how to build a Go-based microservice for rating and review management. We covered topics such as creating endpoints, integrating with a database, and testing the microservice. You should now have a solid foundation to extend this microservice and add more functionality as per your requirements.

Remember to always follow best practices and design patterns while developing microservices, such as using proper error handling, abstraction, and modularization. Happy coding!

Published:

Related Articles