Persisting / Restoring Subclass of java.util.LinkedHashMap

[Haribou]

I am using MicroStream version 7 with Spring Boot integration. I am encountering an issue with persisting / restoring instances of a subclass of java.util.LinkedHashMap that is referenced in another class designated as a MicroStream Storage root in my Spring Boot application:

public class LimitedSet extends LinkedHashMap<String, Boolean>
{
	private int capacityField;
	
	public LimitedSet(int capacity)
	{
		capacityField = capacity;
	}
	
	@Override
  	protected boolean removeEldestEntry(Entry<String, Boolean> eldest)
  	{
  	  	return size() > capacityField;
  	}
}

@Storage
public class StateData
{
	private static final int MAX_NUM_SET_ENTRIES = 5;
	
	@Autowired
	private transient StorageManager storageManager;
	
	private Set<String> stateDataField;
	
	public StateData()
	{
		stateDataField = Collections.newSetFromMap(new LimitedSet(MAX_NUM_SET_ENTRIES));
		
		System.out.println("Created StateData");
	}

	public Set<String> getStateData()
	{
		return stateDataField;
	}
	
	public void save()
	{
		storageManager.store(stateDataField);
		System.out.println("Persisted state data with " + stateDataField.size() + " entries");
	}
}

When restarting the Spring Boot application that contains the code above, the stateDataField is an empty set instead of containing entries that were added to it in the previous execution of the Spring Boot application. You can fork, build, and run the entire application from this GitHub repo.

Interestingly, if I modify the constructor for StateData() above as follows, then the object persistence works as expected (except that I really would like to use LimitedSet instead):

        public StateData()
	{
		stateDataField = new HashSet<String>();
		
		System.out.println("Created StateData");
	}

Does anybody have any idea why instances of the LimitedSet class are not persisted or loaded as expected?

[hg-ms]

The problem arises because you extended the LinkedHashMap class. The LinkedHashMap requires a specialized type-handler because of its complexity that can’t be handled by our generic type-handler any more.
The private SetFromMap type retuned from Collections.newSetFromMap() may need a custom type- handler too.

You have two options to solve that:

1. Write a custom type-handlers for your LimitedSet class and SetFromMap class. But be aware that might be a very challenging task.
2. Instead of extending the LinkedHashMap use a composition. That way you can avoid writing custom type handlers. This is most likely the simplest solution.

When using the HashSet everything works because we provide a specialized handler for that class by default.

[Haribou]

Thank you for looking into this issue, @hg-ms, and for your insights here.

[Haribou]

I replaced the original LimitedSet class with LimitedSet2 and StateData with StateData2 to eliminate subclassing of LinkedHashMap and the call to Collections.newSetFromMap. LimitedSet2 now only contains a reference to a LinkedHashSet, for which MicroStream has a type handler (see https://docs.microstream.one/manual/storage/addendum/specialized-type-handlers.html):

package com.avaya.microstream;

import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

public class LimitedSet2
{
	private final static int CAPACITY = 5;
	
	private final Set<String> storage = new LinkedHashSet<>();
	
	public void add(String setElement)
	{
		Iterator<String> storageIterator;
		
		if (storage.size() == CAPACITY)
		{
			storageIterator = storage.iterator();
			storageIterator.next();
			storageIterator.remove();
		}
		storage.add(setElement);
	}
	
	public boolean contains(String setEelement) 
	{
		return storage.contains(setEelement);
	}
	
	public int size()
	{
		return storage.size();
	}
	
	public String getContent()
	{
		return String.join("\n", storage);
	}
}

package com.avaya.microstream;

import org.springframework.beans.factory.annotation.Autowired;

import one.microstream.integrations.spring.boot.types.Storage;
import one.microstream.storage.types.StorageManager;

@Storage
public class StateData2
{
	@Autowired
	private transient StorageManager storageManager;
	
	private LimitedSet2 stateDataField;
	
	public StateData2()
	{
		stateDataField = new LimitedSet2(); 
		
		System.out.println("Created StateData");
	}

	public LimitedSet2 getLimitedSet()
	{
		return stateDataField;
	}
	
	public void save()
	{
		storageManager.store(stateDataField);
		System.out.println("Persisted state data with " + stateDataField.size() + " entries");
	}
}

However, I am still seeing the same issue as before, which is that the LimitedSet2 either does not get persisted in the call to StateData2.save() or that it does not get correctly loaded with the persisted data when the Spring Boot application is restarted. Am I missing something obvious?

[hg-ms]

To persist the added data, you need to store the modified object.
In your case is this the field storage of the LimitedSet2 class.

Here is why:
At the first start the storage will persist the new StateData2 as root. It will also persist all objects referenced from that as they have not been stored before.
After that a default store on the StateData2 does not store the already persisted LimitedSet2 because it applies a lazy storing strategy.
see https://docs.microstream.one/manual/storage/storing-data/lazy-eager-full.html for some more details.

[Haribou]

Thank you, I had missed the distinction between lazy and eager storing.