Create a Controller class called com.packt.microservices.geolocation.GeoLocationController.java, which will be responsible for basic CRUD operations for the geolocation of all users:

        package com.packt.microservices.geolocation; 
 
        import org.springframework.web.bind.annotation.RequestMapping; 
        import org.springframework.web.bind.annotation.RestController; 
 
        @RestController 
        @RequestMapping("/geolocation") 
        public class GeoLocationController { 
 
        } 

There are two things to note here. The @RestController annotation indicates that we are going to use this controller to expose our REST APIs. It implicitly adds the @ResponseBody annotation to all controller methods as that is something you would want to do when exposing your REST APIs using Spring MVC. The @RequestMapping annotation specifies where your HTTP resource is located. We are setting @RequestMapping on the controller level to apply it to all controller methods.

Before we jump into creating our APIs, we will need some classes for the domain object and service. Let's start with creating our domain object. Assume that our GeoLocation consists latitude and longitude. We will be defining both latitude and longitude as double to provide better precision. Now we will have to say which user's geolocation it is. So we might want to add a userId. We also need to say at what time the user was at the geolocation. So we might want to add a timestamp in EPOCH time format. The timestamp will be of type long. This is how your plain old java object (POJO) class will look:

        package com.packt.microservices.geolocation; 

        import java.io.Serializable; 
        import java.util.UUID; 
 
          public class GeoLocation implements Serializable { 
 
            private static final long serialVersionUID = 1L; 
   
           private double latitude; 
           private double longitude; 
           private UUID userId; 
           private long timestamp; 
   
          public double getLatitude() { 
            return latitude; 
          } 
   
          public void setLatitude(double latitude) { 
            this.latitude = latitude; 
          } 
   
          public double getLongitude() { 
           return longitude; 
          } 
   
          public void setLongitude(double longitude) { 
            this.longitude = longitude; 
          } 
   
          public UUID getUserId() { 
           return userId; 
          } 
   
          public void setUserId(UUID userId) { 
           this.userId = userId; 
          } 
   
         public long getTimestamp() { 
          return timestamp; 
         } 
   
         public void setTimestamp(long timestamp) { 
          this.timestamp = timestamp; 
         } 
        } 

As you can see, we have used the java.util.UUID class to represent the userId, assuming that this UUID uniquely identifies a user. We will not be creating the user POJO as it is out of scope for this recipe.

In an ideal scenario, one would be using a NoSQL or relational database to store the geolocations. In this case, NoSQL sounds more suitable due to several reasons, including the fact that our data is time series data, in JSON format, unstructured but will change over time and we will have a humongous amount of data.

For simplicity purposes, we will be storing our geolocations in an in-memory java.util.List<GeoLocation> collection. Let's create our repository that holds all our geolocation objects, com.packt.microservices.geolocation.GeoLocationRepository.java:

        package com.packt.microservices.geolocation; 
 
        import java.util.ArrayList; 
        import java.util.Collections; 
        import java.util.List; 
 
        import org.springframework.stereotype.Repository; 
 
        @Repository 
        public class GeoLocationRepository { 
 
          private List<GeoLocation> geolocations = new
          ArrayList<GeoLocation>(); 
   
            public void addGeoLocation(GeoLocation geolocation) { 
              geolocations.add(geolocation); 
            } 
   
           public List<GeoLocation> getGeoLocations() { 
              return Collections.unmodifiableList(geolocations); 
           } 
         } 

Now let's take a look at how your Service interface will look:

        package com.packt.microservices.geolocation; 
 
        import java.util.List; 
 
        public interface GeoLocationService { 
 
          public GeoLocation create(GeoLocation geolocation); 
          public List<GeoLocation> findAll(); 
        }  

Both our repository and service have a very simple interface. Ideally in real-time applications, you might want to add more complicated methods that not only perform CRUD operations but also sort, filter, select only specific fields, and so on. Now let's take a look at our com.packt.microservices.geolocation.GeoLocationServiceImpl.java class:

        package com.packt.microservices.geolocation; 
 
        import java.util.List; 
 
        import org.springframework.beans.factory.annotation.Autowired; 
 
        import org.springframework.stereotype.Service; 
 
        @Service 
        public class GeoLocationServiceImpl implements
        GeoLocationService { 
   
          @Autowired 
          private GeoLocationRepository repository; 
 
          @Override 
          public GeoLocation create(GeoLocation geolocation) { 
           repository.addGeoLocation(geolocation); 
           return geolocation; 
          } 
 
          @Override 
          public List<GeoLocation> findAll() { 
            return repository.getGeoLocations(); 
          } 
        }

Now that our domain and service classes are all set to go, let's modify our Controller class to save and find geolocations. Add the following snippet into your Controller class body:

        @Autowired
        private GeoLocationService service;

        @RequestMapping(method = RequestMethod.POST, produces = "application/json", consumes = "application/json")
        public GeoLocation create(@RequestBody GeoLocation geolocation) {
          return service.create(geolocation);
        }
  
        @RequestMapping(method = RequestMethod.GET, produces = "application/json")
        public List<GeoLocation> findAll() {
          return service.findAll();
        } 

Let's try to create two geolocations using the POST API and later try to retrieve them using the GET method. Execute the following cURL commands in your terminal one by one:

      curl -H "Content-Type: application/json" -X POST -d'{"timestamp": 1468203975, "userId": "f1196aac-470e-11e6-beb8-9e71128cae77", "latitude": 41.803488, "longitude": -88.144040}' http://localhost:8080/geolocation

This should give you an output similar to the following (pretty-printed for readability):

        { 
         "latitude": 41.803488, 
         "longitude": -88.14404, 
         "userId": "f1196aac-470e-11e6-beb8-9e71128cae77", 
         "timestamp": 1468203975 
        } 
 
 
        curl -H "Content-Type: application/json" -X POST -d '{"timestamp": 1468203975, "userId": "f1196aac-470e-11e6-beb8-9e71128cae77", "latitude": 9.568012, "longitude": 77.962444}' http://localhost:8080/geolocation

This should give you an output similar to the following (pretty-printed for readability):

{
          "latitude": 9.568012,
          "longitude": 77.962444,
          "userId": "f1196aac-470e-11e6-beb8-9e71128cae77",
          "timestamp": 1468203975
        }

To verify whether your entities were stored correctly, execute the following cURL command:

      curl http://localhost:8080/geolocation

This should give you an output similar to the following (pretty-printed for readability):

        [ 
        { 
          "latitude": 41.803488, 
          "longitude": -88.14404, 
          "userId": "f1196aac-470e-11e6-beb8-9e71128cae77", 
          "timestamp": 1468203975 
        }, 
        { 
          "latitude": 9.568012, 
          "longitude": 77.962444, 
          "userId": "f1196aac-470e-11e6-beb8-9e71128cae77", 
          "timestamp": 1468203975 
        } 
        ]