Spring data, inheritance and mongodb

I am trying to understand how to do this right.

Consider the following situation:

I want to persist this model to mongodb.

Option 1:
Should I persist Professor and Student to different collections (tables)?

Option 2:
Do I put them into a personsDao collection and save type of person and all other specialised properties (from Professor AND Student classes) in there. And when I retrieve the data from the db, I cast it into correct classes?

Which would mean, I just have one @Repository interface.

I think both options are valid ways to go, but I prefer Option 1. So it's good to have the abstract person class on the code base and dividing professor and student into different tables (db layer) makes it much easier handling custom properties, later on.

Using Option 2 - Single PersonRespoitory

Apparently, you can use Option 2 as both entities have the same properties which you have declared in Person(abstract class). Though it makes sense to apply this approach in your current design, you need to consider thinking about future aspects as well.

> Do I put them into a personsDao collection and save the type of person and all other specialised properties (from Professor AND Student classes) in there.

Yes! you can use only one repository to store both types of entities and add a property (type) in your Person. Your Person class should look like this,

public abstract class Person {
 
    // common properties
	
	private PersonType type;
	
	// getters/ setters
	
	public enum PersonType {
	    STUDENT, PROFESSOR
	}
}

> And when I retrieve the data from the DB, I cast it into correct classes?

Casting into appropriate classes seems promising, but I suggest you do not so. Why?

Let's say you have getAllStudents, saveStudent methods and possibly they might be look like this,

public List<Student> getAllStudents() {	    
	return personRespository.findAllByType(PersonType.STUDENT)
	            .map(person -> ((Student) person))
				.collect(Collections.toList());

}

public Student saveStudent(Student student) {
	Person person = new Person();
	person.setType(PersonType.STUDENT);
	
	//copy other properties to the person
	
	Person stored = personRespository.save(person);
	
	return ((Student) stored);
}

What do you think over these methods? And assume about all other CRUD methods along with Professor ones. Instead of doing so, just use Person and remove both redundant entities. As you have type property to distinguish among them, both children classes are no longer needed and refactored methods may look like this,

public List<Person> getAllStudents() {	    
	return personRespository.findAll();
}

public Person saveStudent(Person person) {
	person.setType(PersonType.STUDENT);
	return personRespository.save(person);
}

Seems much better, right?

Using Option 1 - Separate Repository for Student and Professor

> Should I persist Professor and Student to different collections (tables)?

It seems irrelevant and redundant to manage two repositories for two entities where all properties remain the same but it's not. When you have to enhance your entity in future, let's say, Student has to relate with ScoreSheet or Professor with Class - is it possible to adopt with your design? Not possible, right? Though these may not be necessary for the current requirement - you can have flexibility separating them. As well as, the separate repository will be cleaner, the mapping will be no longer needed, will have a single responsibility for each entity.

public List<Student> getAllStudents() {	    
	return studentRespository.findAll();
}

public Student save(Student person) {
	return studentRespository.save(person);
}

It depends upon your requirement and design to choose one of the approaches - but I prefer to go with the first option.