A more generic approach to defining DataRoot?

[Soromeister]

Hi everyone,

I am looking for guidance on how I can get a more generic approach to defining my root objects.

At the moment, I am using Micronaut framework with its EclipseStore integration and have something like this:

@Getter
@Singleton
public class DataRoot {

  private final Map<TSID, Customer> customers = new ConcurrentHashMap<>();
  private final Map<TSID, Profile> profiles = new ConcurrentHashMap<>();
  ...
}

This forces me to work with concrete implementations of each object's Repository implementation, so I have:

• CustomerService, which implements CustomerRepository;
• ProfileService, which implements ProfileRepository;
• And so on ...

Problem is that now I have duplicate code in each of these service classes, taking for example creation of a new element, I am simply getting a new element, verifying whether it's already present in the storage and then, generate a new TSID, followed by storing the element either via @StoreParam, @StoreReturn or manually invoking storageManager.storeRoot().

I am trying to approach this from a generic point of view, so I made a BaseRepository, BaseService and so on to deliver a more generic approach, however, I am currently stuck with the DataRoot class fields.

I actually require the structure to be like this, having ROOT > customers > ... and then ROOT > profiles > ... and so on (when I use the EclipseStore Client GUI, this is how they show up).

I tried a more generic approach to this by declaring my DataRoot as below:

@Getter
@Singleton
public class DataRoot {
  private final Map<Class<? extends Entity>, Map<TSID, ? extends Entity>> entities = new ConcurrentHashMap<>();

  public <E extends Entity> Map<TSID, E> getEntityMap(Class<E> entityClass) {
    return (Map<TSID, E>) entities.computeIfAbsent(entityClass, _ -> new ConcurrentHashMap<>());
  }
}

Now, in my BaseService, I am simply passing the entity class to glue it to the actual entity:

  private final RootProvider<DataRoot> rootProvider;
  private final Class<E> entityClass;

  protected Map<TSID, E> getEntityMap() {
    return rootProvider.root().getEntityMap(entityClass);
  }

With this, in something like my SocialService, I pass on the entity class:

  private final RootProvider<DataRoot> rootProvider;
  private final StorageManager storageManager;

  public SocialService(RootProvider<DataRoot> rootProvider, StorageManager storageManager) {
    super(rootProvider, Social.class);
    this.rootProvider = rootProvider;
    this.storageManager = storageManager;
  }

I can somewhat de-duplicate my code, but now I have this in the data representation:

How can I avoid getting the full package + class name as a key and instead have it look just like before?
Instead of ROOT > entities > [0] > <k, v> I need it to be ROOT > entities > customers > <TSID, Customer> and then ROOT > entities > socials > <TSID, Social> and so on.

If my approach is completely wrong, please suggest the best way to handle this, given that I'll be adding more entities to my application.