Over a million developers have joined DZone.

Design Patterns with Scala: GoF Creational Pattern - Factory Operation (GoF: Factory)

· Integration Zone

Build APIs from SQL and NoSQL or Salesforce data sources in seconds. Read the Creating REST APIs white paper, brought to you in partnership with CA Technologies.

As the word is coming more and more to its nature, distributed ones, the ability to implement most common design patter is more then expected and needed. Design patterns are trying to fulfill such motivation and enable understanding of the application behavior design.

As one of Scala motivation is to enable parallelism, let's take a brief look how to implement one of the popular design pattern: "Factory operation design pattern"

Factory operation design pattern provides the way how to construct object of the specific type. The intent is to hide an object instantiation from a client which support flexibility in such instantiation process (decide which class will be instantiated).

Let's show over the simple example how such Factory method deals with the issue of the different type of object creation

UnivProduct trait is the abstract super type of objects which will be produced by object ProductFactory.

trait UnivProduct {
  val name: String
  val value: Any
}

By having defined abstraction UnivProduct we can create two concrete classes which can be instantiated by object ProductFactory latter.

UnivProductOne:

case class UnivProductOne(i: Int) extends UnivProduct{
  val name:String = "MyIntegerProduct"
  val value:Int = i
  override def toString = "name= "+ name +" val= " + value
}

UnivProductTwo:

case class UnivProductTwo(s: String) extends UnivProduct {
  val name:String = "MyStringProduct"
  val value:String = s
  override def toString = "name= "+ name +" val= " + value
}

Now we create FactoryOperation trait which provides us the specification of the methods (behaviour) that ProductFactory object must provide.

trait FactoryOperation {
  def create(a: Any): UnivProduct
}

Then we define ProductFactory object in following way:

object ProductFactory extends FactoryOperation{
  implicit def create(a: Any): UnivProduct = a match {
    case s: String => UnivProductTwo(s)
    case i: Int => UnivProductOne(i)
  }
}

which simplifies the access to the Factory with limiting ability to employ different Product Factories (can by fixed by implementing factory of factories). The methods create in ProductFactory object is marked as implicit (inserted by compiler).

At the end we create the singleton Scala object FactoryTest to put all together and see the result

object FactoryTest {
  private val logger = LoggerFactory.getLogger(getClass)

  def main(args: Array[String]): Unit = {
    val productA: UnivProduct = ProductFactory.create("Mirage")
    logger.debug("ProductA name= " + productA.name + " value= " + productA.value)
    logger.debug("ProductA toString= " + productA)

    val productB:UnivProduct = ProductFactory.create(22)
    logger.debug("ProductB name= " + productB.name + " value= " + productB.value)
    logger.debug("ProductB toString= " + productB)

    val productC: UnivProduct = "Tanja"
    logger.debug("ProductC name= " + productC.name + " value= " + productC.value)
    logger.debug("ProductC toString= " + productC)

    val productD: UnivProduct = 5
    logger.debug("ProductD name= " + productD.name + " value= " + productD.value)
    logger.debug("ProductD toString= " + productD)
  }
}

and now let's see expected output

ProductA name= MyStringProduct value= Mirage
ProductA toString= name= MyStringProduct val= Mirage
ProductB name= MyIntegerProduct value= 22
ProductB toString= name= MyIntegerProduct val= 22
ProductC name= MyStringProduct value= Tanja
ProductC toString= name= MyStringProduct val= Tanja
ProductD name= MyIntegerProduct value= 5
ProductD toString= name= MyIntegerProduct val= 5

Enjoy using Factory Operation Design patter and my GitHub is still in progress as I want to much more to share over my blog .

The Integration Zone is brought to you in partnership with CA Technologies.  Use CA Live API Creator to quickly create complete application backends, with secure APIs and robust application logic, in an easy to use interface.

Topics:

Opinions expressed by DZone contributors are their own.

The best of DZone straight to your inbox.

SEE AN EXAMPLE
Please provide a valid email address.

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.
Subscribe

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}