goblin VS Echo

Up until now, I have been using a homemade HTTP router called goblin in my application, but since the ServeMux functionality has been expanded in Go1.22, I have started using ServeMux. It became so.

Regarding bmf-san/goblin, we found that it is a proprietary extension of the tri-tree, which is not very optimized and has poor performance compared to other HTTP Routers. (We will do our best to improve it...)

When I decided to improve the performance of goblin, a homebrew HTTP Router, I tried to work on performance improvement in Go, so I write about my approach and the efforts I put into practice.

goblin

goblin is an HTTP router made by golang based on the trie tree.

From the above code, if you read the net / http code with the following points in mind, you can see what to implement. - Where and how the multiplexer registers handlers, and what are the specifications for matching URLs and patterns? - How to create a handler (whether there is a variation of handler creation, what interface should be satisfied) Details [bmf-tech.com-Chapter 3 HTTP Server Code Reading] (https://bmf-tech.com/posts/net%EF%BC%8Fhttp%E3%81%A7%E3%81%A4 % E3% 81% 8F% E3% 82% 8BHTTP% E3% 83% AB% E3% 83% BC% E3% 82% BF% E3% 83% BC% E8% 87% AA% E4% BD% 9C% E5 % 85% A5% E9% 96% 80 #% E7% AC% AC3% E7% AB% A0HTTP% E3% 82% B5% E3% 83% BC% E3% 83% 90% E3% 83% BC% E3% 81% AE% E3% 82% B3% E3% 83% BC% E3% 83% 89% E3% 83% AA% E3% 83% BC% E3% 83% 87% E3% 82% A3% E3% 83% B3% E3% 82% B0), so please refer to it if you have time. # Implementation As I introduced at the beginning, the HTTP router implemented this time is in the following repository. [bmf-san/introduction-to-golang-http-router-made-with-net-http] (https://github.com/bmf-san/introduction-to-golang-http-router-made-with- net-http /) This time we will implement a simple HTTP router that "supports method-based routing". * Since it is a summary version, detailed explanation of the code is omitted. Method-based routing means that you can register URLs by HTTP method. In the function of Go standard package only, if you want to route by method, you need to implement conditional branching in the handler. `` `go // ex. func indexHandler (w http.ResponseWriter, r * http.Request) { switch r.Method { case http.MethodGet: // do something ... case http.MethodPost: // do something ... ... default: default: `` ``` This time, we will implement it only with the goal of eliminating this trouble. In order to achieve method-based routing, we will adopt a tri-tree-based data structure. Since it is a simple function, a simpler data structure (such as making it possible to use the standard multiplexer function for each method) is fine, but we will adopt it in anticipation of various implementations later. (To be honest, I just simplified the implementation of [bmf-san / goblin] (https://github.com/bmf-san/goblin).) The general things to do in implementing an HTTP router are as follows. - Process to add URL and handler mapping to data structure - https://github.com/bmf-san/introduction-to-golang-http-router-made-with-net-http/blob/main/trie.go#L51 - Process to search for matching data from the mapped data structure (≈ tri-tree-based data structure) - https://github.com/bmf-san/introduction-to-golang-http-router-made-with-net-http/blob/main/trie.go#L93 --Implementation of DSL for registering mapping - Around here https://github.com/bmf-san/introduction-to-golang-http-router-made-with-net-http/blob/main/router.go#L47 - Implementation of function as a multiplexer (≈ implementation of ServeHTTP) - https://github.com/bmf-san/introduction-to-golang-http-router-made-with-net-http/blob/main/router.go#L54 The first thing you want to do to implement is to implement the data structure. ! [tree_for_implementation] (https://user-images.githubusercontent.com/13291041/138551924-ca2e28f5-a0c1-4ae4-ac9f-76d6ee1c46d9.png) It is easier to work if you use the debug function of the editor (using delve in vscode) or write test code to check if it is implemented well. For implementation details, see [bmf-tech.com-Chapter 4 HTTP Router Implementation] (https://bmf-tech.com/posts/net%EF%BC%8Fhttp%E3%81%A7%E3%81] % A4% E3% 81% 8F% E3% 82% 8BHTTP% E3% 83% AB% E3% 83% BC% E3% 82% BF% E3% 83% BC% E8% 87% AA% E4% BD% 9C % E5% 85% A5% E9% 96% 80 #% E7% AC% AC4% E7% AB% A0HTTP% E3% 83% AB% E3% 83% BC% E3% 82% BF% E3% 83% BC% See E3% 81% AE% E5% AE% 9F% E8% A3% 85). # Summary HTTP routers are almost indispensable for creating web applications, and aren't they very much taken care of? My motivation was that I wanted to make something that I used as a matter of course and use it myself. There are already a lot of great HTTP routers out there, so I think one of the real thrills is that it's worth researching. This time I implemented it in Go, but if I understand the mechanism, I think that it can be implemented in languages ​​other than Go. In Go, the interface is provided in a form that makes it easy to extend the function of the standard package, so I felt that it was relatively easy to make by myself. If you are interested in this article, I would be grateful if you could take a look at [bmf-san/goblin] (https://github.com/bmf-san/goblin). Feel free to send an Issue or Pull Request. :D

The author has released an HTTP router package called bmf-san/goblin.

Echo - web framework for Go

The three behaviors I've described that we want all depend on two things, the first of which is "idiomatic error handling". We need to be able to simply return err in our handlers. Unfortunately, the standard libray doesn't give us this. But some third-party frameworks do. The most popular one I'm familiar with is labstack echo, whose HandlerFunc looks like this:

In this tutorial, I will be using the Echo framework to build the backend. You can learn more about Echo here.

____ __ / __/___/ / ___ / _// __/ _ \/ _ \ /___/\__/_//_/\___/ v4.11.1 High performance, minimalist Go web framework https://echo.labstack.com ____________________________________O/_______ O\ ⇨ http server started on [::]:8080

Some of the features: - ✅ Using Vertical Slice Architecture as a high level architecture - ✅ Using Event Driven Architecture on top of RabbitMQ Message Broker with a custom [Event Bus](pkg/messaging/bus/) - ✅ Using Event Sourcing in Audit Based services like [Orders Service](services/orders/) - ✅ Using CQRS Pattern and Mediator Patternon top of Go-MediatR library - ✅ Using Dependency Injection and Inversion of Controlon top of uber-go/fx library - ✅ Using RESTFul api with Echo framework and using swagger with swaggo/swag library - ✅ Using Postgres and EventStoreDB to write databases with fully supports transactions(ACID) - ✅ Using MongoDB and Elastic Search for read databases (NOSQL) - ✅ Using OpenTelemetry for collection Distributed Tracing with using Jaeger and Zipkin - ✅ Using OpenTelemetry for collection Metrics with using Prometheus and Grafana - ✅ Using Unit Test for testing small units with mocking dependent classes and using Mockery for mocking dependencies - ✅ Using End2End Test and Integration Test for testing features with all of their real dependeinces using docker containers (cleanup tests) and testcontainers-go library

If you come from NodeJS background, you may find Echo (https://echo.labstack.com) most similar to express.

Can I try to rewrite it using the following? I'll just hand you the code I don't care about credit, I just enjoy cleaning things up. - https://github.com/spf13/cobra - https://echo.labstack.com/ - SQLite - and not a bunch of if statements

Use a library for HTTP serving, such as Gin, Chi, or Echo. I personally use Chi, as it's just the right level of abstraction for how I like to work. Despite what others say here, don't try to re-implement everything in a modern serving library using the standard library.

Here I'm not really sure what you're referring to: * You can set request timeout and it has nothing to do with whether you handled your error or not. * In most cases you either bubble it up the callstack or do something with error in place you o received it i.e. you switch to default value, retry or sth along those lines. In some cases frameworks like echo will translate error into 5XX response for you if you don't do anything with it in top level handler. * Panics are recoverable. Also in case your handler panics it won't crash entire server -> stdlib HTTP server just closes connection, frameworks might even provide panic handler which will return 5XX instead of nothing. * try/catch doesn't really solve anything I mentioned here ¯_(ツ)_/¯. You just hope somebody caught your exception somewhere else.