Understanding Code Smells And How Refactoring Can Help - TechTarget

Refactoring techniques for code smells

Refactoring encompasses several code hygiene practices. When it comes to eliminating code smells, however, there are three particularly effective techniques: one that focuses on methods, another that focuses on the method calls and a third that focuses on classes.

Composing methods

Composing aims to eliminate redundant methods. There are two ways developers can do this:

1. Break code down into smaller blocks. Isolate fragmented code, extract it and place it into a separate method.
2. Identify broken or unnecessary methods, as well as the calls to those methods. Replace the method calls with the method's actual code, and then delete the original method.

Simplifying method calls

The next technique is to simplify method calls that, over time, have become buried in large amounts of code that are daunting to work with. Programmers have several ways to simplify method calls, including the following:

• Adding or removing certain parameters.
• Renaming methods with ambiguous names.
• Separating queries from the modifying component.
• Parameterizing methods and introducing parameter objects.
• Removing the methods that assign objects certain values.
• Replacing the parameter with explicit methods or calls.

Refactoring by abstraction

Finally, refactoring by abstraction comes into play when large chunks of code contain duplications or redundancies. There are two techniques that constitute this approach, both of which focus on class inheritance:

1. Pull up. The code behind methods that are shared among an entire group of subclasses is extracted into a superclass.
2. Push down. Method code that lives within a superclass but is only used by a few of the subclasses is pushed down to those respective subclasses.

Consider the code snippet in Figure 1 that illustrates two classes: FileLogger and DbLogger. As the names suggest, FileLogger is responsible for logging data to a file, and DbLogger logs data to a database.

The IsLogMessageValid method returns true if the log message is valid and false if it is not. In this case, a log message is not considered valid if it contains a null or empty string. Likewise, the log message is considered invalid if it contains any sensitive data, such as a Social Security or credit card number.

Unfortunately, this approach is a little redundant. Coders need to write the same logic twice -- one for each of the two classes -- to check if the log messages are valid.

A better way is to refactor these two classes and create an abstract class. In Figure 2, the IsLogMessageValid method has moved to an abstract class, which helps mitigate potential code redundancy.