Spring Boot Abstract Classes

[malte-baumann]

So this is potentially a bug or just me not knowing what's going on under the hood.

The Problem I am trying to solve

I have an Interface which has lets say 10 Methods. But I just want to toggle 1 of them. (So one of them is annotated with @Toggle().)
That means I have two implementation Classes which have 9 times the same duplicated Methods and just 1 Method which is different. One is the old, one is the new implementation.

My Solution

The Solution I came up with is the following. I have created an abstract class which holds the common default methods and implements the Interface. Then I created two classes which extends the abstract class. These I have annotated with @Service(). These classes then just implement the one Method I want to toggle.

The Problem which now occurs

This solution does not work. Whatever the Feature Toggle state is, I am always getting the old implementation and not the alterBean (new Implementation)

Ideas?

Does any one have an Idea whats going on? Or is there a better way of minimizing the duplicated code?

[andreas-unleash]

Hi @malte-baumann ,

So If I understand you correctly you have the abstract class implementing the interface and then the concrete classes with the 'toggle-able' function extend the abstract class.

Sounds very reasonable. I can think of a few ways of avoiding duplication (eg. separate the interfaces) but it all depends on your context and use-case

Would you be willing to share some code? A minimal repo reproducing?

[malte-baumann]

Here is a minimal example https://github.com/malte-baumann/unleash-abstract-class-spring

[andreas-unleash]

This is how I would separate the code to achieve something similar to what you want that works without using an abstract class:

public interface CommonFeatureDemoService {
    String common();
}


public interface FeatureDemoService extends CommonFeatureDemoService {
    @Toggle(name = "demo-toggle", alterBean = "featureNewService")
    String featureDemo();
}

public class CommonFeatureDemoServiceImpl implements CommonFeatureDemoService {
    @Override
    public String common() {
        return "common";
    }
}

@Service("featureNewService")
public class FeatureDemoNewServiceImpl extends CommonFeatureDemoServiceImpl implements FeatureDemoService {
    @Override
    public String featureDemo() {
        return "In new implementation...";
    }
}

@Service("featureOldService")
public class FeatureDemoOldServiceImpl extends CommonFeatureDemoServiceImpl implements FeatureDemoService {
    @Override
    public String featureDemo() {
        return "In old implementation...";
    }
}

[malte-baumann]

I actually didn't know you can extend an interface lol.
The disadvantage though is that you now have two Service Classes for one Service.

[andreas-unleash]

You still will inject FeatureDemoService (as the final all inclusive interface), but the internals are a bit different to achieve what you want. Separating the concerns all together would be ideal. The advantage of this approach is that it allows for adding/moving more 'toggle-able' functions from one to the other as needed.

[malte-baumann]

Yeah you are right about that. I overlooked that you extended the CommonFeatureDemoServiceImpl.
That indeed works. I think I would still prefer an abstract class in the sense of readability.

[andreas-unleash]

You can keep the separation as you have it as long as your final concrete classes (also) implement the interface with the 'toggle-able' function