Search for a command to run...
I'm a passionate Software Engineer developing highly scalable and robust web applications using object-oriented programming techniques and design patterns, with hands-on experience including methodologies and best practices like Continuous Integration and Delivery, Clean Code, Test-Driven Development, Refactoring, N-tier Systems and Cloud based Distributed Applications under the Microservice Architecture.
No comments yet. Be the first to comment.
In this series, I will explain some of the basic software arquitecture design patterns and their corresponding implementation in the Go programming language.
The Go programming language, or Golang, is well-known for its simplicity, performance, and support for concurrency. However, like any language, writing efficient, maintainable, and readable code in Go requires adherence to certain best practices. Her...
Testing is a crucial part of software development, ensuring that your code works as expected and reducing the number of bugs and issues. In Go, testing is built into the language, making it straightforward to write tests. This blog post will provide ...
Go, often celebrated for its simplicity and efficiency, is a language designed with performance in mind. However, like any other language, writing performant Go applications requires understanding its nuances and leveraging the right tools and techni...
Error handling is a critical aspect of writing robust and reliable software applications. In Go, error handling is designed to be explicit, making it easier to identify and address potential issues. In this blog post, we'll explore the best practices...
Microservices architecture has gained immense popularity due to its flexibility, scalability, and resilience. Among the myriad of languages suitable for building microservices, Go (Golang) stands out for its simplicity, performance, and built-in supp...
The Factory Method design pattern solves the problem of creating objects without specifying their concrete classes. It provides an interface to create them in a parent class but allows child classes to change the type of objects that will be created.
Factory Method defines a method that should be used instead of the new operator. Child classes can override this method to change the class of the objects that will be created.
Here's a diagram to better understand it:
So, as you can see it is almost impossible to implement the classic Factory Method pattern in Go, mostly because we don't have some basic OOP features, like classes and inheritance. But, we can still implement a basic version of the pattern, called the Simple Factory. To do this we can make use of composition in Go since the end goal of it is the same as that of inheritance, so instead of inheriting features from a parent class, larger objects are composed of other objects and thereby use their functionality.
Here's how it looks like in Go:
So we're not going to deep dive into a "real world" example right now, since the idea here is to better understand the concept behind the pattern, so what we're going to do is to translate the diagram above into real code, so you can get a grasp on how it would look like (I'll give you some tips below on when it'll be a good idea to use the Factory Method design pattern).
product_interface.go
package factory
type ProductInterface interface {
MakeSomething(string) string
}
product.go
package factory
type Product struct {
name string
}
func (p *Product) MakeSomething(feature string) string {
return feature + " " + p.name
}
producta.go
package factory
type ProductA struct {
Product
}
func NewProductA() ProductInterface {
return &ProductA{
Product: Product{
name: "Product A",
},
}
}
productb.go
package factory
type ProductB struct {
Product
}
func NewProductB() ProductInterface {
return &ProductB{
Product: Product{
name: "Product B",
},
}
}
creator.go
package factory
type ProductType int
const (
ProductAType ProductType = 1 << iota
ProductBType
)
func NewProduct(t ProductType) ProductInterface {
switch t {
case ProductAType:
return NewProductA()
case ProductBType:
return NewProductB()
default:
return NewProductA()
}
}
main.go
package main
import (
"fmt"
"github.com/arielcr/factory-method-go/factory"
)
func main() {
productA := factory.NewProduct(factory.ProductAType)
fmt.Println(productA.MakeSomething("Awesome"))
productB := factory.NewProduct(factory.ProductBType)
fmt.Println(productB.MakeSomething("Nice"))
}
Here is the complete code repo.
When you don't know the exact types of objects your code should work with: since there is a separation from the code that creates the product from the one that actually uses it, it's easier to extend the construction code from the rest of the code. So if you want to add a new product type you just need to create the appropriate implementation.
When you want to provide a way to extend your code when it's used by other users: it's easier for other developers to add additional functionality to your code since all that is needed is to add new classes (structs).