Software Development

Constructing a To-Do Listing With MongoDB and Golang – DZone – Uplaza

uPlaza News

Hello, there! Many have puzzled how a easy process sheet or functions that present such performance work. On this article, I invite you to contemplate how one can write your small service in Go in a few hours and put all the pieces in a database.

Let’s begin our journey with Golang and MongoDB.

Why Golang?

 

I wish to present the keys:

  • Minimalistic design and quick compilation
  • Sturdy concurrency mannequin with Goroutines and channels
  • Enormous ecosystem
  • Cross-platform from the field

One other issue is to not spend a lot time finding out libraries or open-source options. In my case, I wish to create a microservice that may work virtually out of the field. The Golang programming language has all the pieces for this.

I’ll word, nevertheless, that the language is already wealthy in very cool initiatives that clear up many issues for the developer. Tasks akin to: 

  1. Gin: Excessive-performance HTTP net framework 
  2. Viper: Configuration answer (JSON, properties, YML information) for Go functions
  3. GORM: ORM library
  4. Protocol Buffers (Protobuf): The easiest way to serialize structured knowledge

We won’t assessment them inside the article’s framework, however maybe I’ll write one thing about them later. With Protobuf, I’ve already written an fascinating article, “From JSON to FlatBuffers: Enhancing Performance in Data Serialization.”

Set up

Putting in Go Language

Go to golang.org and obtain. Then, go to the terminal and verify it.

IDE

Simply set up VS Code (it is free).

After which add the Golang extension:

Kind your first code:

bundle foremost

import "fmt"

func foremost() {
   fmt.Println("Hello, World!")
}

And run it:

That is it! The following step is to decide on the most suitable choice to gather our knowledge.

Our Activity Construction

I feel our first construction needs to be actually easy. Let’s begin with 3 fields:

  1. Title (textual content)
  2. Description (textual content) 
  3. Standing (bool)

 JSON file as a reference:

{     
  "title": "Go to the groceries",     
  "description": "Purchase milk, eggs, and bread",     
  "completed": false 
}

Why MongoDB?

 We have to acquire knowledge for our duties and be versatile. We needn’t create a schema or relationship between one thing.

  1. Versatile Schema
  2. Scalability: It helps horizontal scaling.
  3. Wealthy Question Language

For our small service, we are able to run it as docker-compose.

# Use root/instance as consumer/password credentials
model: '3.1'

companies:

 mongo:
   picture: mongo
   ports:
     - "27017:27017"
   surroundings:
     MONGO_INITDB_ROOT_USERNAME: root
     MONGO_INITDB_ROOT_PASSWORD: instance

I favor Compass GUI for working with our knowledge (collections, databases, and many others.). Obtain it right here.

Simply run it and set your credentials to “Advanced options.” It really works completely and may help you discover issues and optimize requests in case you want them.

System Design (Actually Small)

For our service, after all, the most suitable choice is to create CRUD (Create, Learn, Replace, Delete) strategies, one thing like this (with out delete):

http.HandleFunc("/api/v1/add", todoHandler.AddTask)
http.HandleFunc("/api/v1/get-all", todoHandler.GetAllTasks)
http.HandleFunc("/api/v1/update", todoHandler.UpdateTask)
http.HandleFunc("/api/v1/complete", todoHandler.CompleteTask)

I wish to use the best way to separate all tasks by folders.

  • Handler – HTTP layer
  • Mannequin – Buildings for knowledge
  • Use circumstances – Enterprise layers with service and repository

The challenge construction could be like this:

todo-list/
│
├── cmd/
│   └── foremost.go
├── pkg/
│   └── handler
│      └── add_task.go
│      └── http_handler.go
│      └── complite_task.go
│      └── get_all_task.go
│      └── update_task.go
│   └── mapper
│       └── process.go
│   └── mannequin
│        └── process.go
│   └── usecase
│        └── process
│           └── repository
│               └── add_task.go
│               └── complite_task.go
│               └── get_all_task.go
│               └── mongo_repositiry.go
│               └── repository.go
│               └── update_task.go
│           └── service
│               └── add_task.go
│               └── complite_task.go
│               └── get_all_task.go
│               └── service.go
│               └── update_task.go
└── go.mod

As we are able to see, we’ve a “go.mod” file, however what’s it? It’s a packer supervisor or dependency supervisor. We are able to set up and add exterior libs and use them as nicely. For our instance, we’d like a few instructions utilizing “go mod”.

  1. Init our app -> go mod init todo-service . We are going to init all the pieces; the dependency supervisor will create information and add all the pieces we’d like.
  2. Add further dependency utilizing go mod add "link". 

You possibly can learn extra on the Go Modules Reference web page.

Then, let’s concentrate on just one technique — including duties. For additional exploration and full code examples, go to the GitHub repository Golang Workshop.

Connection to MongoDB

Utilizing solely two dependencies, we are able to create a connection:

	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"

In fact, we have to add it to our service. Please use the instructions:

go get "go.mongodb.org/mongo-driver/mongo"

and 

go get "go.mongodb.org/mongo-driver/mongo/options"

Then, write a bit of code:

func foremost() {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	// Set MongoDB consumer choices
	clientOptions := choices.Consumer().ApplyURI("mongodb://localhost:27017").SetAuth(choices.Credential{
		Username: "root",
		Password: "example",
	})

	consumer, err := mongo.Join(ctx, clientOptions)
	if err != nil {
		log.Deadly(err)
	}

	err = consumer.Ping(ctx, nil)
	if err != nil {
		log.Deadly(err)
	}

	log.Println("Connected to MongoDB!")
}

Information buildings for our app:

bundle mannequin

import "go.mongodb.org/mongo-driver/bson/primitive"

kind Activity struct {
    ID         string `json:"id"`
    Title      string `json:"title"`
    Desciption string `json:"description"`
    Accomplished  bool   `json:"completed"`
}

kind MongoTask struct {
    ID         primitive.ObjectID `json:"id" bson:"_id"`
    Title      string             `json:"title"`
    Desciption string             `json:"description"`
    Accomplished  bool               `json:"completed"`
}
  • Activity – for HTTP request, MongoTask – for MongoDB layer: Utilizing two buildings is simple as a result of typically we needn’t ship further knowledge to our customers. For instance, we would have a secret discipline, like a username, which we should conceal.

1. Repository layer:

kind Repository interface {
    AddTask(ctx context.Context, process mannequin.MongoTask) error
}

func (r *MongoRepository) AddTask(ctx context.Context, process mannequin.MongoTask) error {
	process.ID = primitive.NewObjectID()


	_, err := r.assortment.InsertOne(ctx, process)
}

2. Service layer:

kind TodoService interface {
	AddTask(ctx context.Context, process mannequin.Activity) error
}

func (s *Service) AddTask(ctx context.Context, process mannequin.Activity) error {
	return s.Repo.AddTask(ctx, mapper.MapToDto(process))
}

3. Handler layer (to course of HTTP requests):

func (h *Handler) AddTask(w http.ResponseWriter, r *http.Request) {
	ctx := context.Background()

	var process mannequin.Activity
	err := json.NewDecoder(r.Physique).Decode(&process)
	if err != nil {
		http.Error(w, "Invalid request body", http.StatusBadRequest)
		return
	}

	err = h.Service.AddTask(ctx, process)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusCreated)
}

Now, we have to set up the database connection and initialize the “layers” dependency within the foremost.go file.

func foremost() {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	// Set MongoDB consumer choices
	clientOptions := choices.Consumer().ApplyURI("mongodb://localhost:27017").SetAuth(choices.Credential{
		Username: "root",
		Password: "example",
	})

	consumer, err := mongo.Join(ctx, clientOptions)
	if err != nil {
		log.Deadly(err)
	}

	err = consumer.Ping(ctx, nil)
	if err != nil {
		log.Deadly(err)
	}

	log.Println("Connected to MongoDB!")

	// Initialize repository, service, and handler
	todoRepo := repository.NewMongoRepository(consumer)
	todoService := service.NewService(todoRepo)
	todoHandler := handler.NewHandler(todoService)

	// Arrange routes
	http.HandleFunc("/api/v1/add", todoHandler.AddTask)

	// Create a server
	srv := &http.Server{
		Addr:    ":8080",
		Handler: nil,
	}
  // todo: run service and shutdown
}

And take a look at it with the request:

# curl -X POST http://localhost:8080/add
#-H "Content-Type: application/json"
#-d '{
#    "id": 1,
#    "title": "Buy groceries",
#    "completed": false
#}'
POST http://localhost:8080/api/v1/add
Content material-Kind: software/json

{
 "title": "Add description to the structure",
 "description": "your desc here..."
}

That is all. Then, we should add and implement new strategies, and our service will likely be able to work.

Conclusion

We have created a small, but strong process administration service utilizing Golang and MongoDB.

As we are able to see, if we have to construct a small service, we do it actually quick with out many obstacles. In my case, I would love to make use of MongoDB as the primary database if I’ve paperwork. It is simply straightforward to handle.

It may also be famous that it will be no worse in different programming languages. In some locations, it is even quicker. For instance, in case you use Python and FastAPI – and right here I could disagree with you. The Golang language continues to be primarily based on the paradigms of programming languages like C++ and Java, the place there’s OOP.  Such code and methodology can help you maintain the code as clear and clear as attainable.

For a begin, will probably be good to consolidate such components as a base, which can allow you to perceive TDD and different methodologies. I will even word that to keep away from overloading the article with metrics and textual content, I omitted evaluating efficiency with different languages. I’ll word that Golang has no issues with this, and having written the primary perform, you already run it in your thread. You possibly can simply discover comparisons on the Web, together with benchmarks.

For additional exploration and full code examples, go to the GitHub repository (linked earlier).

Thanks and take care!

TAGGED:
Share This Article
Leave a comment

Leave a Reply

Your email address will not be published. Required fields are marked *

Exit mobile version