The forum controller prints the "Hello World" output but also a statistic on the number of users in the forum. Dig into the controller class and see where this number came from.

Open the file - src/main/java/com/crio/springdatabyte/controller/ForumController.java and look for this snippet of code.

@GetMapping("/stats")
public ResponseEntity<String> stats() {
 Stats stats = service.getForumStats();
 String message = "<p>Hello!</p>"
     + "<div><b>Forum stats</b></div>"
     + "<div>---------------</div>"
     + "<div>Number of users: " + stats.getNumUsers() + "</div>";

 return ResponseEntity.ok().body(message);
}

What is happening is that when we request the /stats url, it is intercepted by the method above and the output is sent to the browser. So the natural question to ask is where are the stats coming from?

The line responsible for that is service.getForumStats(). A quick peek into ForumServiceImpl.java will lead you to ForumRepositoryServiceImpl.java. This is where you can see the code that talks to the database.

@Override

public Stats getForumStats() {

 List<UserEntity> users = userRepository.findAll();


 return new Stats(users.size());

}

This time, the line of interest is userRepository.findAll().

And once more, you can take a quick peek into the UserRepository.java file to see the implementation, except for one problem… There’s no implementation!

Unlike the other times where there was an interface and a corresponding implementation, for the repository class, there is only an interface. Where does the implementation come from?

Spring Data provides it. The interface acts as a marker to help you capture the types you need to work with. And the method name is parsed by Spring to generate the query internally. If you observe the interface, it extends MongoRepository<UserEntity, Integer>.

The "types" here are UserEntity and Integer. UserEntity is the entity to manage (The Entity is a presentation of the row or document in the table or collection in your database). Integer is the id of the managed entity object, in this case it is an integer. Also note, the entity class must be marked with @Document for MongoDB to signify to Spring that it must manage it.

The other big advantage is that this repository pattern is an abstraction for different databases. This means, you can use a technology specific abstraction for different databases. The one you are using is MongoRepository, but you can use JpaRepository for relational databases such as MySQL.

The method name you have invoked is the findAll() method Spring Data knows you have invoked the findAll() method, from the mongo repository class, then it generates the appropriate query automatically and sends it to the database that the server connects to using the details in application.properties file.

Phew! That’s a lot of things that are happening under the hood.

That is precisely the advantage of using this pattern. Spring manages the hard work of query generation, connecting and disconnecting to databases and so on so that you can simply invoke one method and continue to focus on the business logic.

So much for the introduction. Next, you will see how to handle querying using this powerful abstraction.