Do you know what a class factory is and why is it useful?  Ever considered implementing a class factory in Golang (Google Go) even though Go is not considered fully object oriented in nature? Are you curious about some awesome features in Go other than it’s impressive concurrency capabilities? If any of the these questions interests you, then reading on may be worth your while. This article covers implementing the factory design pattern in Go.

If that’s not your first time visiting my site, then you probably know by now that the Go programming language is a personal favorite of mine and here’s why. I love software design and I love Go. Because I love software design, I had to learn about design patterns. And one of the most popular design patterns is the concept of factory design patterns. In the OOP world, that translates to class factories. To make diving through the tutorial easier, here are the links to the main sections:

• What is a Class Factory
• Where to start in Go?
• Go Structs
• Go Interfaces
• A Class Factory in Golang

 

So what is a class factory?

There are tons of definitions for factories currently in the inter-webs, however in it’s core, the concept is fairly simple. A factory or a class factory if you are in the object oriented world, is a design approach that minimizes the pain of adding future code. But why would we need to add future code to an existing application? because that’s the nature of the software industry, you build something that works for your customer, your customer is happy, then they come back asking for more.

The ultimate purpose of a class factory is to help design software in a way where you have a core piece of code that doesn’t need changing, but still able to handle future code without missing a beat. But how does it accomplish that? read on…

A class factory accomplishes decoupling between old and new code in the object oriented world by using interfaces and inheritance. The code will be divided into three pieces:

1. Core or main code
2. A class factory
3. Concrete classes that implement the same interface or abstract class, they also use the same public function signatures

The core code communicates mostly with the class factory, it asks the class factory for a type. The class factory then instantiates the class that represents that type and returns the parent interface of this class to the core code. The core code then calls functions from the interface. The functions are shared by all the classes that implement the interface, which means that whenever the core code is to ask for a different type, the same functions will still work.  Here is a full example for a class factory in the object oriented world.

Here is a simple diagram showing the flow of logic for a class factory:

For example, imagine a piece of software responsible for turning a home appliance on. Let’s say that -initially- the appliances you were asked to support were only stoves and fridges. But then a year down the line, you were requested to add support for microwaves as well. If you don’t design it well from the beginning, you will need to change a lot of your existing code. However, if you use a class factory design pattern, the core code of the application needs only to worry about two things: 1- Requesting an appliance of a specific type. 2- Turning on the appliance. The class factory will take care of the rest.  The flow of code should look like this:

Core Application code:  myAppliance = ApplianceClassFactory.Get(“Oven”)

Class Factory:    return new OvenClass

Core Application code: myAppliance.TurnOn()

So How can we write a class factory in Go?

First, after some questions that I received after first publishing the article, I need to be clear that Go is not considered a fully object oriented programming language. That means that when I say a class factory in Go, I don’t literally mean a factory of classes, I just use the term class factory out of habit. In Go, it will be more of a factory of structs, which will be covered very shortly.

Second, before you write a class factory in Go, you need to be familiar with two important building blocks of the language, namely: Structs and Interfaces.

What are Go Structs?

Go structs are the Go equivalent of objects, except that they are much, much simpler. Structs can host both variables and functions. The variables inside the struct get specified in the struct definition statement, whereas functions that belong to a struct identify their parent struct in the function signature.

Let’s complement that with an example, suppose we need a struct with three variables: an integer, a string , and a boolean :

type exampleStruct struct{
    num int
    s string
    flag bool
}

Now let’s assume there is a printExampleStruct() function that belongs to our newly created struct:

//function signature to the right of the func keyword indicates the parent struct type
func (s exampleStruct) printExampleStruct(){
    //print the contents of the struct
   fmt.Printf("example struct: num = %v, s = %v,  flag = %v", s.num, s.s, s.flag)
}

To call and use the struct, we simply need to first initialize a variable of that struct type then use it.  The code will look like this:

    myStruct := exampleStruct{ 
	num: 5,
	s: "I am a string variable",
	flag: true,
	}
	
	myStruct.printExampleStruct()

When we add all of that up and package it, our example struct program will look like this:

package main

import "fmt"

type exampleStruct struct{
    num int
    s string
    flag bool
}

func (s exampleStruct) printExampleStruct(){
    fmt.Printf("example struct: num = %v, s = %v,  flag = %v", s.num, s.s, s.flag)
}

func main() {
    myStruct := exampleStruct{ 
	num: 5,
	s: "I am a string variable",
	flag: true,
	}
	
	myStruct.printExampleStruct()
}

See how simple was that?? Now, let’s move to the Go interfaces.

What are Go Interfaces?

Go interfaces are similar in concept to interfaces in mainstream languages like Java or C#. They are in practice a type that defines a set of functions\methods. Since structs act like objects, they typically implement interfaces. The difference in Go is that there are no special keywords and/or braces to indicate that a struct ‘Y’ has inherited interface ‘X’. How it works is that if your struct includes a function that has the same signature as a function inside a defined interface, then your struct implements that interface. Yup, that’s it!!

An interface can be defined simply by the following syntax:

type myInterface interface {
    myFunction() float64
}

So as mentioned earlier, any struct that will implement a function of the same signature will be considered to be a child of the interface, here is how the struct will look like:

type myStruct struct{
    f float64
}

func (s myStruct)myFunction() float64{
	return 455.984
}

A very good example on how interfaces and structs integrate together can be found in Go’s invaluable tour.

Now, with structs and interfaces explained, let’s implement a class factory in Go…

The Go Class Factory

let’s imagine that we were requested to design a program that speaks with multiple types of appliances. The program will either start an appliance or return a description of what the specific appliance does. Say, the current appliance types supported by the program are fridges, and stoves. However, in the future, we may get additional requirements for other appliance types.

In order to design a good piece of software for this purpose, we need to write our program in a way where whenever the customer requests to add more appliances, we won’t need to alter any of our main code. This is when we come into the realization that a class factory would be a good idea for our project.

Let’s start with the core\main application code, Here is what it needs to do for us:

1. Ask the user for their preferred appliance type
2. Use the class factory to retrieve an appliance of that type
3. Turn on the appliance
4. Show a description of what the appliance does

So overall, we need four simple tasks implemented in the core application code. That code should not need any edits in the future even if 500 more appliance types get added the next day. It’s now time to take a shot at it in Go:

First, we will need to import the packages used in our core code. A package in Go is similar to a package in Java or a namespace in C#, a large container for code that is a step or two above the class construct. The first package is the one representing the class factory for our project, which is “ClassFactoryTutorial/Appliances” in my case, and the second package is “fmt” which handles a variety of command line tasks. “fmt” is similar to “System” in Java or “Console” in C#.

Second, we write our main function to implement the four tasks described previously. Here is how the code will look like:

package main

import (
    "ClassFactoryTutorial/Appliances"
	"fmt"
)

func main(){
	//Request the user to enter the appliance type
	fmt.Println("Enter preferred appliance type")

	//use fmt.scan to retrieve the user's input
	var myType int
	fmt.Scan(&myType)

	//Use the class factory to create an appliance of the requested type
	myAppliance, err := Appliances.CreateAppliance(myType)

	//if no errors start the appliance then print it's purpose
	if err==nil{
		myAppliance.Start()
		fmt.Println(myAppliance.GetPurpose())
	} else {
		//if error encountered, print the error
		fmt.Println(err)
	}

}

The “Appliances” keyword used in the above code snippet is our class factory, it is nothing more than a package that contains the functions needed to construct our class factory.

Next, let’s create our appliances class factory in Golang,

First, we will need to define an interface that includes the functions needed by any device type.

Second, we will need to write a function that returns a struct type (again, similar to objects in Go) corresponding to the appliance type passed to the class factory from the core code.

package Appliances

//import errors to log errors when they occur
import "errors"

//The main interface used to describe appliances
type Appliance interface{
    Start()
	GetPurpose() string
}

//Our appliance types
const (
	STOVE = iota
	FRIDGE
)

//Function to create the appliances
func CreateAppliance(t int)(Appliance, error) {
	//Use a switch case to switch between types, if a type exist then error is nil (null)
	switch t{
	case STOVE:
		return new(Stove),nil
	case FRIDGE:
		return new(Fridge),nil
	default:
		//if type is invalid, return an error
		return nil, errors.New("Invalid Appliance Type")
	}
}

The  CreateAppliance() function didn’t need to belong to any specific struct or interface, it just belongs to the “Appliances” package. It’s kinda similar to a static method, if you would like to compare with Java or C#.

The appliance types in the code are enum constants, when “iota” is assigned to the first item in the list, the rest of the items will be increments of 0. That means that type “STOVE” will be equal to 0, and type “FRIDGE” will be equal to 1.

And with that, the main body of our class factory is complete. The next step is to write code to represent our supported appliance types, the STOVE struct for stoves and the FRIDGE struct for fridges. In technical terms, we need to write structs (one more time, like classes) that will implement the functions defined in the “Appliance” interface.

Let’s start with the appliance types, we need to write a piece of code that:

1. Defines an appliance type struct,  “Stove” for stove types or “Fridge” for fridge types
2. Implements the “Start()” and the “GetPurpose()” functions. Again these are the functions defined in our class factory “Appliance” interface. By implementing them, the appliance type struct will become an implementation of the “Appliance” interface so any code addressing the “Appliance” interface will work on the appliance type struct

With the functionality fully defined, let’s jump into the code for the “Stove” struct:

package Appliances

// define a stove struct, the struct contain a string representing the type name
type Stove struct{
    typeName string
}

//The stove struct implements the start() function
func (sv *Stove)Start(){
	sv.typeName = " Stove "
}

//The stove struct implements the GetPurpose() function
func (sv *Stove)GetPurpose() string{
	return "I am a " + sv.typeName + " I cook food!!"
}

Pretty straight forward.

Moving on to the “Fridge” struct, the implementation will be very similar:

package Appliances

// define a fridge struct, the struct contain a string representing the type name
type Fridge struct{
    typeName string
}

//The fridge struct implements the start() function
func (fr *Fridge)Start(){
	 fr.typeName = " Fridge "
}

//The fridge struct implements the start() function
func (fr *Fridge)GetPurpose() string{
	return "I am a " + fr.typeName + " I cool stuff down!!"
}

And with that, the program is complete. The next step is to use it:

Now, let’s say a week later, the customer comes back and asks for your software to support appliances of type microwave, what would we do? Because we designed our application around a class factory, the additions needed to support something new will be fairly easy and straight forward. Here is what is needed if we are to add support for microwaves:

1. Core code (main function) : No change needed
2. Class factory code: add type “MICROWAVE”
3. Add a new struct that represents the microwave device type

Here are the new additions to the class factory code:

//Our appliance types
const (
    STOVE = iota
	FRIDGE
	//Now we support microwaves
	MICROWAVE
)

func CreateAppliance(t int)(Appliance, error) {
	switch t{
	case STOVE:
		return new(Stove),nil
	case FRIDGE:
		return new(Fridge),nil
		//new case added for microwaves
	case MICROWAVE:
		return new(Microwave),nil
	default:
		return nil, errors.New("Invalid Appliance Type")
	}

And here’s the new Microwave struct:

package Appliances

type Microwave struct{
    typeName string
}

func (mr *Microwave)Start(){
	mr.typeName = " Microwave "
}

func (mr *Microwave)GetPurpose() string{
	return "I am a " + mr.typeName + " I heat stuff up!!"
}

And with that out of the way, we come to the end of the tutorial. As you can see, following a good design from the beginning can save you a lot of grief in the future and makes coding efficient. A powerful and fun language like Go makes it even easier.