Refactoring using Functional Programming

What

Why

How

• file (of type — xml | property | json ..) and
• property names of values to extract
• dynamic map (replaces the dynamic map key (if) found in the property values, with corresponding map values.)

1. Extract properties from given file (Extract method should support file types like — xml, property, json.)
2. Replace placeholders with dynamic values

• Procedural
• Object Oriented
• Functional

Procedural

• main method reads file content and calls extract method.
• extract method parses the content based on type, using an if condition that calls the
  specific parse method and extracts the properties and returns these
  properties.
• main method now call replace method to replace the placeholders with its dynamic values.

• Add another if else block in ‘extract’ method.

1. Ease to write when extensions/modification are limited.

1. This causes a bottleneck on the extract method. In a team of developers, constant updates to a single entity by all the developers will result in merge conflicts.
2. The extract method will increase in size as extensions are added. This will make it less readable.
3. Having business logic interspersed with your I/O operations will result in unit test cases that will need actual resource versus a mock.
4. The resource I/O operations code cannot be reused in other parts of the code as it is tightly coupled to the business logic.

Object Oriented

ResourceHandler

replace ()

extract()

replace()

• handle(). This contains the business logic, which for our purposes can be as simple as:

public Map handle() {
  extract();
  replace();
}

• protected abstract void extract() - contains logic to extract properties from file
• private void replace() - contains logic to replace properties from dynamic map

• XmlResource
• JsonResource
• PropertiesResource

1. This structure allows to add new extensions without modifying the base ‘handler’ method, that is invoked to extract and replace properties. So child classes cannot corrupt the business logic.
2. There is no more a bottleneck on the extract method as it was with the
   procedural code. Now each custom extract method has it’s own
   implementation in it’s own class. This will reduce the possible
   merge-conflicts between multiple developers working on different custom extract implementation.
3. Object ‘ResourceHandler’ is closed for modification while being open for extension. This is one of the pillars of the SOLID
   principle. For example if, ResourceHandler is shared as jar, it can
   still be extended to support additional resource types, but the
   underlying base logic is still restricted.

1. The IO logic to extract properties for given type, is still coupled to the
   business logic, due to the structure of the Base class. As the only
   public method is handle, which calls the extract method and replace
   method. So we cannot use extract in isolation.

Functional

class ExtractReplace {
  private Map extracted_properties;

  public ExtractReplace(File file, List properties,Map dynamic, ResourceHandler handler) {
    Map props = handler.extract(file, properties);
    extracted_properties = replace(props, dynamic);
  }

  private Map replace(Map properties, Map dynamic) {...}
  @Override
  public String toString() {
    return extracted_properties.toString();
  }
}

class ExtractReplace{
  private Map extracted_properties;

  static class Builder {
    private File file;
    private List properties;
    private Map dynamic;
    private ResourceHandler handler;
    static Builder getInstance(File file, List properties, Map dynamic){
      this.file = file;
      this.properties = properties;
      this.dynamic = dynamic;
      if (file.getName().endsWith(".json"))
        this.handler = new JsonHandler();
      else if(file.getName().endsWith(".xml"))
        this.handler = new XmlHandler();
  }
    public ExtractReplace build() {
      new ExtractReplace(this);
    }
  }
  private ExtractReplace(Builder builder) {
    Map props = builder.handler.extract(builder.file, builder.properties);
  }
  private Map replace(Map properties, Map dynamic) { ... }

  @Override
  public String toString(){
    return extracted_properties.toString();
  }
}

1. Over and above the advantages that are provided by Object Oriented approach, this also separates the extraction logic from the business logic. Hence you can reuse this extract method.
2. You can follow a structured approach by creating different implementation classes of ResourceHandler, which can be resused.
3. You can also follow a adhoc anonymous approach using Lambda functions. This is useful if you are not reusing the extraction logic else where and want to reduce the structural complexity.

Final Notes