Wrapping methods without Decorator Pattern or AOP

Question

I have a Dao interface which doesn't have any methods defined.

Then I have multiple classes which implement this interface, like PetDao and HouseDao.

For some of the implementation classes, and some of their methods, I need to do an operation.

Let's say this operation is defined in the Operation class, and the method is doOperation().

PetDao has several methods: Pet selectPet(int petId), void insertPet(PetDto pet), and I only want to call doOperation() for insertPet.

HouseDao has several methods: House selectHouse(int houseId), void deleteHouse(int houseId), and I only want to call doOperation() for deleteHouse.

I cannot modify the Dao interface. Neither of these classes are instantiated manually, they are all injected.

I could change PetDao and HouseDao code to statically call doOperation(). But this would mean that the Dao classes would have another responsibility than the originally intended, and that I would have a big impact on the source code (there are multiple Daos with multiple methods that I need to track).

I cannot use the Decorator Pattern because Dao interface does not have any methods.

Are there other options, besides AOP, to achieve this?

Answer 1

Injecting a class isn't really a violation of the Single Responsibility Principle.

The new logic is encapsulated in your Operation class, that's it's responsibility. Calling a dependency doesn't really change what this class responsibile for.

Something like the below isn't really changing the responsibilities of your DAO class.

(forgive the C# syntax)

public class HouseDao:IDao
{
   public HouseDao(Operation myOperation)
   {
      <snip>
      operation = myOperation;
   }

    <snip>

   public void deleteHouse(int houseId)
   {
      //dostuff
      operation.doOperation()   
   }
}

All that said, if you really need an alternative, implementing this as a Visitor (https://www.baeldung.com/java-visitor-pattern) may be more along the lines of what you want.