Lazy Loading

[code5123]

public class Person {

    private final String name;
    private final Lazy<Address> address;

    public Person(String name) {
        this.name = name;
        this.address = Lazy.of(() -> new Address("123 Main Street", "Anytown", "CA", 94001));
    }

    public String getName() {
        return name;
    }

    public Address getAddress() {
        return address.get();
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", address=" + address.get() +
                '}';
    }
}
public class Address {
    private String streetAddress;
    private Lazy<String> city;
    private Lazy<String> state;
    private Lazy<Integer> zipCode;

    public Address(String streetAddress) {
        this.streetAddress = streetAddress;
    }

    public String getStreetAddress() {
        return streetAddress;
    }

    public String getCity() {
        if (city == null) {
            city = Lazy.of(() -> "Anytown");
        }
        return city.get();
    }

    public String getState() {
        if (state == null) {
            state = Lazy.of(() -> "CA");
        }
        return state.get();
    }

    public int getZipCode() {
        if (zipCode == null) {
            zipCode = Lazy.of(() -> 94001);
        }
        return zipCode.get();
    }

    @Override
    public String toString() {
        return "Address{" +
                "streetAddress='" + streetAddress + '\'' +
                ", city='" + getCity() + '\'' +
                ", state='" + getState() + '\'' +
                ", zipCode=" + getZipCode() +
                '}';
    }
}
public class DataRoot {
    private final HashMap<Long, Lazy<Person>> persons = new HashMap<>();
public HashMap<Long, Lazy<Person>> getPersonsMap getPerson() {
        return persons
    }
}

Can I load a city for a specific Person without first loading the Person and Address?
getStateForPerson(String personName)
getPerson(String personName)
Can I load the entire person object, even if its variables are lazy, without doing a separate get on the lazy variables?

[hg-ms]

Hello,

Can I load a city for a specific Person without first loading the Person and Address?

No, in your object graph the city is only accessible via Person -> Address -> City.
But you may add additional structures that add the possibility to do such a lockup e.g., an additional HashMap.

Can I load the entire person object, even if its variables are lazy, without doing a separate get on the lazy variables?

No, to do so you need to remove the Lazy Reference.

Here are some more details on Lazy-References and how they work:
With Microstream you’re working on an Object-Graph where objects are nodes and references edges. When Microstream starts it will load the whole graph into memory starting at the designated root object. As this may be more data then desired, we added the Lazy-Reference. They are a barrier, every time when Microstream encounters an LR* during a load operation it will stop loading the referenced Object. An explicit “get” call loads the data behind a LR.
Unloading LR depends on the Java-GC. If there is any java object referencing the lazy referenced object it can’t be unloaded.
It is ok to have more the one object referencing a LR.
Using LR with small objects is not recommended as every LR introduces some overhead like memory usage. In case of small objects this overhead may lager then the saved resources. It’s much more effective to lazy load whole collections.

*Lazy-Reference

[code5123]

@hg-ms thank you so much for clarification
public class Person {
private String name;
private int age;
private List

addresses;

public Person(String name, int age) {
    this.name = name;
    this.age = age;
    this.addresses = new ArrayList<>();
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

public List<Address> getAddresses() {
    return addresses;
}

public void setAddresses(List<Address> addresses) {
    this.addresses = addresses;
}

public void addAddress(Address address) {
    addresses.add(address);
}

public void displayInfo() {
    System.out.println("Name: " + name);
    System.out.println("Age: " + age);
    System.out.println("Addresses:");
    for (Address address : addresses) {
        System.out.println("- " + address);
    }
}

class Address {
private String street;
private String city;

public Address(String street, String city) {
    this.street = street;
    this.city = city;
}

@Override
public String toString() {
    return street + ", " + city;
}

}
public class DataRoot {
private final HashMap<String, Lazy> persons = new HashMap<>();
public HashMap<String, Lazy> getPersonsMap getPerson() {
return persons
}
}
DataRoot data = storagemanager.root();

data.getPersonsMap.entrySet().stream()
.filter(entry -> entry.getKey().equals(personName))
.findFirst()
.map(entry -> entry.getValue().get())
.map(Person::getAddress)
.ifPresent(addressList ->
addressList.stream()
.filter(address -> address.getCity() == city1)
.findFirst()
.ifPresent(address -> address.setCity(city2));

I am using stream api to update the city of an address corresponding to a specific individual.
It is loading all of the addresses, not just the one I want to update. Is there a way to load the specific address that has to be updated from the list? (without using HashMap for address)
The size of the data storage file is larger than the actual size of the Person JSON. are we storing some metadata also?

[hg-ms]

You’re welcome.

Let me give you some more general information how Microstream works.
Microstream works differently to the most well-known databases.
When working with Microstream you’re working with one large java object-graph in memory instead of entities fetched from DB, this graph is also the source of truth. Working with that object graph is just plain java independent of Microstream. Microstream is just used for persistence, not querying data.
Loading data only happen at startup or if a Lazy-Reference loads data.

If you process data with java streams api there is no need to load data as it is already in memory.

Regarding the file size:
The storage files contain the whole object graph. This is user data and references between objects.
In addition store operations will only append data, existing data will not be overridden. Removing data will be done by custom garbage collection mechanism.