Swift : Factory Pattern

Factory pattern can come in handy when you want to reduce the dependency of a class on other classes. On the other hand, it encapsulates the object creation process and users can simply pass in parameters to a generic factory class without knowing how the objects are actually being created. Also, it gives you a clean code.

Let’s begin by creating a protocol (You can achieve the same with a superclass too but I like protocol as it enforces certain rules to the classes that are confirming). If you don’t know protocol, then please go refer my article on the topic.

protocol Human {

    var name : String {get set}

    func run()

    func eat()

    func sleep()

}

Since we have our protocol ready let’s create two classes named Soldier and Civilian.

class Soldier{

}

class Civilian{

}

Now it’s time to conform to the protocol Human to these classes and implement the methods.

class Soldier : Human{

    var name: String

    init(SoldierName soldiername : String) {

        self.name = soldiername

    }

    func run() {

        print("soldier \(name) is running")

    }

    func eat() {

        print("soldider  \(name) is eating")

    }

    func sleep() {

        print("soldider  \(name) is sleeping")

    }

}

class Civilian : Human {

    var name: String

    

    init(CivilianName civilianName : String) {

         self.name = civilianName

    }

    func run() {

        print("\(name) is running")

    }

    func eat() {

        print("\(name) is eating")

    }

    func sleep() {

         print("\(name) is sleeping")

    }

}

Now before actually creating our factory class, we need a way to specify the factory class about the object that we intend to create(i.e whether we want to create a civilian object or soldier object). That’s why we are going to create an enum as below.

enum HumanTypes{

    case Soldier

    case Civilian

}

Awesome..! Now it’s time to create our factory class.

class HumanFactory{

    

    private static var sharedHumanFactory = HumanFactory()

    class func shared() -> HumanFactory {

        return sharedHumanFactory

    }

    func getHuman(HumanType humanType : HumanTypes, HumanName humanName : String)->Human{

        switch humanType {

            case .Soldier:

                return Soldier(SoldierName: humanName)

            case .Civilian:

                return Civilian(CivilianName: humanName)

        }

    }





}

Let me explain what happens in the HumanFactory class. First, we are creating a private static instance of the HumanFactory class and we let other classes access it via the shared() function. This pattern is generally known as a singleton. Though it’s totally not necessary to use a Singleton here, I’d like to make things look smooth and clean 😉.

Since our infrastructure is ready we can simply create an instance of Civilians or Soldiers by simply using the factory class.

Here how it’s done.

let soldier = HumanFactory.shared().getHuman(HumanType: .Soldier, HumanName: "Jay")

soldier.sleep()

//soldider  Jay is sleeping

let civilian = HumanFactory.shared().getHuman(HumanType: .Civilian, HumanName: "Saman")

civilian.run()

//Saman is running

If we put together everything we did so far in one single playground file, it’ll be something as below.

So I hope you’ll create and use factory pattern in your projects in the future.