Building Location-Based Services in Java

Location-based services (LBS) enable applications to provide context-aware features based on geographic position. This comprehensive guide covers implementing LBS in Java including geocoding, reverse geocoding, proximity search, geofencing, and real-time tracking.

Architecture Overview

Java Application → Location Services → External APIs → Geocoding/Reverse Geocoding → Google Maps/OpenStreetMap → Spatial Database → PostGIS/MySQL Spatial → Real-time Processing → Kafka/Redis → Mobile Integration → GPS/Beacons

Prerequisites and Setup

Maven Dependencies

<properties> <spring.boot.version>3.1.0</spring.boot.version> <hibernate.version>6.2.5.Final</hibernate.version> <postgis.version>2021.1.0</postgis.version> </properties> <dependencies> <!-- Spring Boot --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>${spring.boot.version}</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> <version>${spring.boot.version}</version> </dependency> <!-- Spatial Databases --> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-spatial</artifactId> <version>${hibernate.version}</version> </dependency> <dependency> <groupId>org.postgresql</groupId> <artifactId>postgresql</artifactId> <version>42.6.0</version> </dependency> <dependency> <groupId>net.postgis</groupId> <artifactId>postgis-jdbc</artifactId> <version>${postgis.version}</version> </dependency> <!-- Geospatial Libraries --> <dependency> <groupId>org.locationtech.jts</groupId> <artifactId>jts-core</artifactId> <version>1.19.0</version> </dependency> <dependency> <groupId>com.google.maps</groupId> <artifactId>google-maps-services</artifactId> <version>2.2.0</version> </dependency> <!-- Caching --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>${spring.boot.version}</version> </dependency> <!-- JSON Processing --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.15.2</version> </dependency> </dependencies>

Configuration Properties

# Database Configuration spring.datasource.url=jdbc:postgresql://localhost:5432/location_db spring.datasource.username=postgres spring.datasource.password=password # Hibernate Spatial spring.jpa.properties.hibernate.dialect=org.hibernate.spatial.dialect.postgis.PostgisDialect spring.jpa.hibernate.ddl-auto=update # Google Maps API google.maps.api.key=your-google-maps-api-key google.maps.geocoding.url=https://maps.googleapis.com/maps/api/geocode/json # Redis Configuration spring.redis.host=localhost spring.redis.port=6379 # Application Settings location.service.cache.enabled=true location.service.cache.ttl=3600 geofencing.radius.meters=100 proximity.search.max-results=50

Core Location Models

1. Location Entities

package com.yourapp.location.model; import jakarta.persistence.*; import org.locationtech.jts.geom.Point; import org.hibernate.annotations.Type; import java.time.LocalDateTime; @Entity @Table(name = "locations") public class Location { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = "user_id") private String userId; @Column(columnDefinition = "geography(Point,4326)") private Point coordinates; @Column(name = "latitude") private Double latitude; @Column(name = "longitude") private Double longitude; @Column(name = "accuracy") private Double accuracy; @Column(name = "altitude") private Double altitude; @Column(name = "speed") private Double speed; @Column(name = "bearing") private Double bearing; @Column(name = "timestamp") private LocalDateTime timestamp; @Column(name = "device_id") private String deviceId; @Column(name = "location_source") @Enumerated(EnumType.STRING) private LocationSource source; @Column(name = "created_at") private LocalDateTime createdAt; // Constructors public Location() { this.createdAt = LocalDateTime.now(); } public Location(String userId, double latitude, double longitude) { this(); this.userId = userId; this.latitude = latitude; this.longitude = longitude; } // Getters and Setters public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getUserId() { return userId; } public void setUserId(String userId) { this.userId = userId; } public Point getCoordinates() { return coordinates; } public void setCoordinates(Point coordinates) { this.coordinates = coordinates; } 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 Double getAccuracy() { return accuracy; } public void setAccuracy(Double accuracy) { this.accuracy = accuracy; } public Double getAltitude() { return altitude; } public void setAltitude(Double altitude) { this.altitude = altitude; } public Double getSpeed() { return speed; } public void setSpeed(Double speed) { this.speed = speed; } public Double getBearing() { return bearing; } public void setBearing(Double bearing) { this.bearing = bearing; } public LocalDateTime getTimestamp() { return timestamp; } public void setTimestamp(LocalDateTime timestamp) { this.timestamp = timestamp; } public String getDeviceId() { return deviceId; } public void setDeviceId(String deviceId) { this.deviceId = deviceId; } public LocationSource getSource() { return source; } public void setSource(LocationSource source) { this.source = source; } public LocalDateTime getCreatedAt() { return createdAt; } public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; } } enum LocationSource { GPS, NETWORK, BEACON, MANUAL, FUSED }

2. Geofence Entities

package com.yourapp.location.model; import jakarta.persistence.*; import org.locationtech.jts.geom.Polygon; import java.time.LocalDateTime; import java.util.ArrayList; import java.util.List; @Entity @Table(name = "geofences") public class Geofence { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = "name") private String name; @Column(name = "description") private String description; @Column(columnDefinition = "geography(Polygon,4326)") private Polygon boundary; @Column(name = "center_latitude") private Double centerLatitude; @Column(name = "center_longitude") private Double centerLongitude; @Column(name = "radius_meters") private Double radiusMeters; @Enumerated(EnumType.STRING) @Column(name = "type") private GeofenceType type; @ElementCollection @CollectionTable(name = "geofence_triggers", joinColumns = @JoinColumn(name = "geofence_id")) @Column(name = "trigger_type") @Enumerated(EnumType.STRING) private List<GeofenceTrigger> triggers = new ArrayList<>(); @Column(name = "is_active") private Boolean isActive = true; @Column(name = "created_at") private LocalDateTime createdAt; @Column(name = "updated_at") private LocalDateTime updatedAt; // Constructors public Geofence() { this.createdAt = LocalDateTime.now(); this.updatedAt = LocalDateTime.now(); } // Getters and Setters public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getDescription() { return description; } public void setDescription(String description) { this.description = description; } public Polygon getBoundary() { return boundary; } public void setBoundary(Polygon boundary) { this.boundary = boundary; } public Double getCenterLatitude() { return centerLatitude; } public void setCenterLatitude(Double centerLatitude) { this.centerLatitude = centerLatitude; } public Double getCenterLongitude() { return centerLongitude; } public void setCenterLongitude(Double centerLongitude) { this.centerLongitude = centerLongitude; } public Double getRadiusMeters() { return radiusMeters; } public void setRadiusMeters(Double radiusMeters) { this.radiusMeters = radiusMeters; } public GeofenceType getType() { return type; } public void setType(GeofenceType type) { this.type = type; } public List<GeofenceTrigger> getTriggers() { return triggers; } public void setTriggers(List<GeofenceTrigger> triggers) { this.triggers = triggers; } public Boolean getActive() { return isActive; } public void setActive(Boolean active) { isActive = active; } public LocalDateTime getCreatedAt() { return createdAt; } public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; } public LocalDateTime getUpdatedAt() { return updatedAt; } public void setUpdatedAt(LocalDateTime updatedAt) { this.updatedAt = updatedAt; } } enum GeofenceType { CIRCULAR, POLYGON, CUSTOM } enum GeofenceTrigger { ENTRY, EXIT, DWELL, PROXIMITY }

3. Point of Interest (POI)

package com.yourapp.location.model; import jakarta.persistence.*; import org.locationtech.jts.geom.Point; import java.time.LocalDateTime; @Entity @Table(name = "points_of_interest") public class PointOfInterest { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = "name") private String name; @Column(name = "description") private String description; @Column(name = "category") private String category; @Column(name = "subcategory") private String subcategory; @Column(columnDefinition = "geography(Point,4326)") private Point coordinates; @Column(name = "latitude") private Double latitude; @Column(name = "longitude") private Double longitude; @Column(name = "address") private String address; @Column(name = "city") private String city; @Column(name = "state") private String state; @Column(name = "country") private String country; @Column(name = "postal_code") private String postalCode; @Column(name = "phone") private String phone; @Column(name = "website") private String website; @Column(name = "rating") private Double rating; @Column(name = "price_level") private Integer priceLevel; @Column(name = "is_active") private Boolean isActive = true; @Column(name = "created_at") private LocalDateTime createdAt; @Column(name = "updated_at") private LocalDateTime updatedAt; // Constructors, Getters and Setters public PointOfInterest() { this.createdAt = LocalDateTime.now(); this.updatedAt = LocalDateTime.now(); } // Getters and Setters public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getDescription() { return description; } public void setDescription(String description) { this.description = description; } public String getCategory() { return category; } public void setCategory(String category) { this.category = category; } public String getSubcategory() { return subcategory; } public void setSubcategory(String subcategory) { this.subcategory = subcategory; } public Point getCoordinates() { return coordinates; } public void setCoordinates(Point coordinates) { this.coordinates = coordinates; } 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 String getAddress() { return address; } public void setAddress(String address) { this.address = address; } public String getCity() { return city; } public void setCity(String city) { this.city = city; } public String getState() { return state; } public void setState(String state) { this.state = state; } public String getCountry() { return country; } public void setCountry(String country) { this.country = country; } public String getPostalCode() { return postalCode; } public void setPostalCode(String postalCode) { this.postalCode = postalCode; } public String getPhone() { return phone; } public void setPhone(String phone) { this.phone = phone; } public String getWebsite() { return website; } public void setWebsite(String website) { this.website = website; } public Double getRating() { return rating; } public void setRating(Double rating) { this.rating = rating; } public Integer getPriceLevel() { return priceLevel; } public void setPriceLevel(Integer priceLevel) { this.priceLevel = priceLevel; } public Boolean getActive() { return isActive; } public void setActive(Boolean active) { isActive = active; } public LocalDateTime getCreatedAt() { return createdAt; } public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; } public LocalDateTime getUpdatedAt() { return updatedAt; } public void setUpdatedAt(LocalDateTime updatedAt) { this.updatedAt = updatedAt; } }

Core Location Services

1. Geocoding Service

package com.yourapp.location.service; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Service; import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; import java.util.HashMap; import java.util.Map; @Service public class GeocodingService { @Value("${google.maps.api.key}") private String googleMapsApiKey; @Value("${google.maps.geocoding.url}") private String geocodingUrl; private final RestTemplate restTemplate; private final ObjectMapper objectMapper; public GeocodingService(RestTemplate restTemplate, ObjectMapper objectMapper) { this.restTemplate = restTemplate; this.objectMapper = objectMapper; } /** * Geocode an address to coordinates */ public GeocodingResult geocodeAddress(String address) { try { String url = UriComponentsBuilder.fromHttpUrl(geocodingUrl) .queryParam("address", address) .queryParam("key", googleMapsApiKey) .toUriString(); String response = restTemplate.getForObject(url, String.class); JsonNode root = objectMapper.readTree(response); if ("OK".equals(root.path("status").asText())) { JsonNode location = root.path("results").get(0).path("geometry").path("location"); double lat = location.path("lat").asDouble(); double lng = location.path("lng").asDouble(); JsonNode addressComponents = root.path("results").get(0).path("address_components"); String formattedAddress = root.path("results").get(0).path("formatted_address").asText(); return parseAddressComponents(lat, lng, formattedAddress, addressComponents); } else { throw new GeocodingException("Geocoding failed: " + root.path("status").asText()); } } catch (Exception e) { throw new GeocodingException("Geocoding request failed", e); } } /** * Reverse geocode coordinates to address */ public GeocodingResult reverseGeocode(double latitude, double longitude) { try { String latLng = latitude + "," + longitude; String url = UriComponentsBuilder.fromHttpUrl(geocodingUrl) .queryParam("latlng", latLng) .queryParam("key", googleMapsApiKey) .toUriString(); String response = restTemplate.getForObject(url, String.class); JsonNode root = objectMapper.readTree(response); if ("OK".equals(root.path("status").asText())) { JsonNode result = root.path("results").get(0); String formattedAddress = result.path("formatted_address").asText(); JsonNode addressComponents = result.path("address_components"); return parseAddressComponents(latitude, longitude, formattedAddress, addressComponents); } else { throw new GeocodingException("Reverse geocoding failed: " + root.path("status").asText()); } } catch (Exception e) { throw new GeocodingException("Reverse geocoding request failed", e); } } private GeocodingResult parseAddressComponents(double lat, double lng, String formattedAddress, JsonNode addressComponents) { GeocodingResult result = new GeocodingResult(); result.setLatitude(lat); result.setLongitude(lng); result.setFormattedAddress(formattedAddress); Map<String, String> components = new HashMap<>(); for (JsonNode component : addressComponents) { String longName = component.path("long_name").asText(); JsonNode types = component.path("types"); for (JsonNode type : types) { String typeName = type.asText(); components.put(typeName, longName); switch (typeName) { case "street_number": result.setStreetNumber(longName); break; case "route": result.setStreetName(longName); break; case "locality": result.setCity(longName); break; case "administrative_area_level_1": result.setState(longName); break; case "country": result.setCountry(longName); break; case "postal_code": result.setPostalCode(longName); break; } } } result.setAddressComponents(components); return result; } public static class GeocodingResult { private double latitude; private double longitude; private String formattedAddress; private String streetNumber; private String streetName; private String city; private String state; private String country; private String postalCode; private Map<String, String> addressComponents; // Getters and Setters 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 String getFormattedAddress() { return formattedAddress; } public void setFormattedAddress(String formattedAddress) { this.formattedAddress = formattedAddress; } public String getStreetNumber() { return streetNumber; } public void setStreetNumber(String streetNumber) { this.streetNumber = streetNumber; } public String getStreetName() { return streetName; } public void setStreetName(String streetName) { this.streetName = streetName; } public String getCity() { return city; } public void setCity(String city) { this.city = city; } public String getState() { return state; } public void setState(String state) { this.state = state; } public String getCountry() { return country; } public void setCountry(String country) { this.country = country; } public String getPostalCode() { return postalCode; } public void setPostalCode(String postalCode) { this.postalCode = postalCode; } public Map<String, String> getAddressComponents() { return addressComponents; } public void setAddressComponents(Map<String, String> addressComponents) { this.addressComponents = addressComponents; } } public static class GeocodingException extends RuntimeException { public GeocodingException(String message) { super(message); } public GeocodingException(String message, Throwable cause) { super(message, cause); } } }

2. Distance Calculation Service

package com.yourapp.location.service; import org.springframework.stereotype.Service; @Service public class DistanceCalculationService { private static final double EARTH_RADIUS_KM = 6371.0; private static final double EARTH_RADIUS_MILES = 3959.0; /** * Calculate distance between two points using Haversine formula */ public double calculateDistance(double lat1, double lon1, double lat2, double lon2, DistanceUnit unit) { double dLat = Math.toRadians(lat2 - lat1); double dLon = Math.toRadians(lon2 - lon1); double a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2)) * Math.sin(dLon / 2) * Math.sin(dLon / 2); double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); double radius = unit == DistanceUnit.MILES ? EARTH_RADIUS_MILES : EARTH_RADIUS_KM; return radius * c; } /** * Calculate distance between two points in meters */ public double calculateDistanceInMeters(double lat1, double lon1, double lat2, double lon2) { return calculateDistance(lat1, lon1, lat2, lon2, DistanceUnit.KILOMETERS) * 1000; } /** * Check if a point is within a radius of another point */ public boolean isWithinRadius(double centerLat, double centerLon, double pointLat, double pointLon, double radiusMeters) { double distance = calculateDistanceInMeters(centerLat, centerLon, pointLat, pointLon); return distance <= radiusMeters; } /** * Calculate bearing between two points */ public double calculateBearing(double lat1, double lon1, double lat2, double lon2) { double lat1Rad = Math.toRadians(lat1); double lat2Rad = Math.toRadians(lat2); double dLonRad = Math.toRadians(lon2 - lon1); double y = Math.sin(dLonRad) * Math.cos(lat2Rad); double x = Math.cos(lat1Rad) * Math.sin(lat2Rad) - Math.sin(lat1Rad) * Math.cos(lat2Rad) * Math.cos(dLonRad); double bearing = Math.toDegrees(Math.atan2(y, x)); return (bearing + 360) % 360; } /** * Calculate destination point given distance and bearing */ public Coordinate calculateDestination(double startLat, double startLon, double distanceMeters, double bearing) { double angularDistance = distanceMeters / (EARTH_RADIUS_KM * 1000); double bearingRad = Math.toRadians(bearing); double startLatRad = Math.toRadians(startLat); double startLonRad = Math.toRadians(startLon); double destLatRad = Math.asin(Math.sin(startLatRad) * Math.cos(angularDistance) + Math.cos(startLatRad) * Math.sin(angularDistance) * Math.cos(bearingRad)); double destLonRad = startLonRad + Math.atan2( Math.sin(bearingRad) * Math.sin(angularDistance) * Math.cos(startLatRad), Math.cos(angularDistance) - Math.sin(startLatRad) * Math.sin(destLatRad) ); double destLat = Math.toDegrees(destLatRad); double destLon = Math.toDegrees(destLonRad); return new Coordinate(destLat, destLon); } public enum DistanceUnit { KILOMETERS, MILES } public static class Coordinate { private final double latitude; private final double longitude; public Coordinate(double latitude, double longitude) { this.latitude = latitude; this.longitude = longitude; } public double getLatitude() { return latitude; } public double getLongitude() { return longitude; } } }

3. Proximity Search Service

package com.yourapp.location.service; import com.yourapp.location.model.PointOfInterest; import com.yourapp.location.repository.PointOfInterestRepository; import org.locationtech.jts.geom.Coordinate; import org.locationtech.jts.geom.GeometryFactory; import org.locationtech.jts.geom.Point; import org.locationtech.jts.geom.PrecisionModel; import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; import org.springframework.stereotype.Service; import java.util.List; @Service public class ProximitySearchService { private final PointOfInterestRepository poiRepository; private final GeometryFactory geometryFactory; private final DistanceCalculationService distanceService; public ProximitySearchService(PointOfInterestRepository poiRepository, DistanceCalculationService distanceService) { this.poiRepository = poiRepository; this.distanceService = distanceService; this.geometryFactory = new GeometryFactory(new PrecisionModel(), 4326); } /** * Find points of interest within radius */ public List<PointOfInterest> findPOIsWithinRadius(double latitude, double longitude, double radiusMeters, String category) { Point centerPoint = createPoint(latitude, longitude); if (category != null && !category.isEmpty()) { return poiRepository.findByCategoryAndLocationWithinRadius( category, centerPoint, radiusMeters); } else { return poiRepository.findByLocationWithinRadius(centerPoint, radiusMeters); } } /** * Find nearest points of interest */ public List<PointOfInterest> findNearestPOIs(double latitude, double longitude, int limit, String category) { Point centerPoint = createPoint(latitude, longitude); if (category != null && !category.isEmpty()) { return poiRepository.findNearestByCategory(centerPoint, category, Pageable.ofSize(limit)); } else { return poiRepository.findNearest(centerPoint, Pageable.ofSize(limit)); } } /** * Search POIs by name within radius */ public List<PointOfInterest> searchPOIsByName(String name, double latitude, double longitude, double radiusMeters) { Point centerPoint = createPoint(latitude, longitude); return poiRepository.findByNameContainingAndLocationWithinRadius( name, centerPoint, radiusMeters); } /** * Find POIs along a route */ public List<PointOfInterest> findPOIsAlongRoute(double startLat, double startLon, double endLat, double endLon, double maxDistanceFromRoute, String category) { // Create a buffer around the route line and search within that area Point startPoint = createPoint(startLat, startLon); Point endPoint = createPoint(endLat, endLon); // This would require more complex spatial querying // For simplicity, we'll search within the bounding box of the route double minLat = Math.min(startLat, endLat); double maxLat = Math.max(startLat, endLat); double minLon = Math.min(startLon, endLon); double maxLon = Math.max(startLon, endLon); return poiRepository.findWithinBoundingBox(minLat, maxLat, minLon, maxLon, category); } /** * Calculate distances to all found POIs */ public List<POIWithDistance> calculateDistancesToPOIs(double userLat, double userLon, List<PointOfInterest> pois) { return pois.stream() .map(poi -> { double distance = distanceService.calculateDistanceInMeters( userLat, userLon, poi.getLatitude(), poi.getLongitude()); return new POIWithDistance(poi, distance); }) .sorted((p1, p2) -> Double.compare(p1.getDistance(), p2.getDistance())) .toList(); } private Point createPoint(double latitude, double longitude) { Coordinate coordinate = new Coordinate(longitude, latitude); return geometryFactory.createPoint(coordinate); } public static class POIWithDistance { private final PointOfInterest poi; private final double distance; public POIWithDistance(PointOfInterest poi, double distance) { this.poi = poi; this.distance = distance; } public PointOfInterest getPoi() { return poi; } public double getDistance() { return distance; } } }

4. Geofencing Service

package com.yourapp.location.service; import com.yourapp.location.model.Geofence; import com.yourapp.location.model.GeofenceTrigger; import com.yourapp.location.model.Location; import com.yourapp.location.repository.GeofenceRepository; import org.locationtech.jts.geom.Coordinate; import org.locationtech.jts.geom.GeometryFactory; import org.locationtech.jts.geom.Point; import org.locationtech.jts.geom.PrecisionModel; import org.springframework.stereotype.Service; import java.time.LocalDateTime; import java.util.ArrayList; import java.util.List; @Service public class GeofencingService { private final GeofenceRepository geofenceRepository; private final GeometryFactory geometryFactory; private final DistanceCalculationService distanceService; public GeofencingService(GeofenceRepository geofenceRepository, DistanceCalculationService distanceService) { this.geofenceRepository = geofenceRepository; this.distanceService = distanceService; this.geometryFactory = new GeometryFactory(new PrecisionModel(), 4326); } /** * Check location against all active geofences */ public List<GeofenceEvent> checkGeofences(Location location) { List<GeofenceEvent> events = new ArrayList<>(); Point locationPoint = createPoint(location.getLatitude(), location.getLongitude()); List<Geofence> activeGeofences = geofenceRepository.findActiveGeofences(); for (Geofence geofence : activeGeofences) { GeofenceEvent event = checkGeofence(location, locationPoint, geofence); if (event != null) { events.add(event); } } return events; } /** * Check single geofence */ private GeofenceEvent checkGeofence(Location location, Point locationPoint, Geofence geofence) { boolean isInside = geofence.getBoundary().contains(locationPoint); // For circular geofences, we can also check distance if (geofence.getType() == GeofenceType.CIRCULAR) { double distance = distanceService.calculateDistanceInMeters( geofence.getCenterLatitude(), geofence.getCenterLongitude(), location.getLatitude(), location.getLongitude()); isInside = distance <= geofence.getRadiusMeters(); } // Check for entry/exit events based on previous state // This would require storing previous location states // For simplicity, we'll just check current state if (isInside) { if (geofence.getTriggers().contains(GeofenceTrigger.ENTRY)) { return createGeofenceEvent(location, geofence, GeofenceTrigger.ENTRY, "Entered geofence"); } } else { if (geofence.getTriggers().contains(GeofenceTrigger.EXIT)) { return createGeofenceEvent(location, geofence, GeofenceTrigger.EXIT, "Exited geofence"); } } return null; } /** * Create circular geofence */ public Geofence createCircularGeofence(String name, double centerLat, double centerLon, double radiusMeters, List<GeofenceTrigger> triggers) { Geofence geofence = new Geofence(); geofence.setName(name); geofence.setType(GeofenceType.CIRCULAR); geofence.setCenterLatitude(centerLat); geofence.setCenterLongitude(centerLon); geofence.setRadiusMeters(radiusMeters); geofence.setTriggers(triggers); // Create circular boundary (simplified as a point with radius for querying) // In practice, you'd create a proper circular polygon Point centerPoint = createPoint(centerLat, centerLon); geofence.setBoundary(createCircularPolygon(centerPoint, radiusMeters)); return geofenceRepository.save(geofence); } /** * Check if location is inside any geofence */ public boolean isInsideAnyGeofence(double latitude, double longitude) { Point locationPoint = createPoint(latitude, longitude); List<Geofence> containingGeofences = geofenceRepository.findGeofencesContainingPoint(locationPoint); return !containingGeofences.isEmpty(); } /** * Get geofences containing location */ public List<Geofence> getContainingGeofences(double latitude, double longitude) { Point locationPoint = createPoint(latitude, longitude); return geofenceRepository.findGeofencesContainingPoint(locationPoint); } private GeofenceEvent createGeofenceEvent(Location location, Geofence geofence, GeofenceTrigger trigger, String message) { GeofenceEvent event = new GeofenceEvent(); event.setUserId(location.getUserId()); event.setGeofenceId(geofence.getId()); event.setGeofenceName(geofence.getName()); event.setTrigger(trigger); event.setLocation(location); event.setMessage(message); event.setTimestamp(LocalDateTime.now()); return event; } private Point createPoint(double latitude, double longitude) { Coordinate coordinate = new Coordinate(longitude, latitude); return geometryFactory.createPoint(coordinate); } private org.locationtech.jts.geom.Polygon createCircularPolygon(Point center, double radiusMeters) { // Simplified implementation - in practice, create a proper circular polygon // with multiple points to approximate a circle Coordinate[] coordinates = new Coordinate[33]; // 32-sided polygon + closure for (int i = 0; i < 32; i++) { double angle = Math.toRadians(i * 11.25); // 11.25 degrees per segment double latOffset = (radiusMeters / 111320) * Math.cos(angle); double lonOffset = (radiusMeters / (111320 * Math.cos(Math.toRadians(center.getY())))) * Math.sin(angle); coordinates[i] = new Coordinate( center.getX() + lonOffset, center.getY() + latOffset ); } coordinates[32] = coordinates[0]; // Close the polygon return geometryFactory.createPolygon(coordinates); } public static class GeofenceEvent { private String userId; private Long geofenceId; private String geofenceName; private GeofenceTrigger trigger; private Location location; private String message; private LocalDateTime timestamp; // Getters and Setters public String getUserId() { return userId; } public void setUserId(String userId) { this.userId = userId; } public Long getGeofenceId() { return geofenceId; } public void setGeofenceId(Long geofenceId) { this.geofenceId = geofenceId; } public String getGeofenceName() { return geofenceName; } public void setGeofenceName(String geofenceName) { this.geofenceName = geofenceName; } public GeofenceTrigger getTrigger() { return trigger; } public void setTrigger(GeofenceTrigger trigger) { this.trigger = trigger; } public Location getLocation() { return location; } public void setLocation(Location location) { this.location = location; } public String getMessage() { return message; } public void setMessage(String message) { this.message = message; } public LocalDateTime getTimestamp() { return timestamp; } public void setTimestamp(LocalDateTime timestamp) { this.timestamp = timestamp; } } }

Repository Interfaces

1. Location Repository

package com.yourapp.location.repository; import com.yourapp.location.model.Location; import org.locationtech.jts.geom.Point; import org.springframework.data.domain.Pageable; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.query.Param; import org.springframework.stereotype.Repository; import java.time.LocalDateTime; import java.util.List; @Repository public interface LocationRepository extends JpaRepository<Location, Long> { List<Location> findByUserIdOrderByTimestampDesc(String userId); List<Location> findByUserIdAndTimestampBetween(String userId, LocalDateTime start, LocalDateTime end); @Query("SELECT l FROM Location l WHERE l.userId = :userId ORDER BY l.timestamp DESC") List<Location> findLatestByUser(@Param("userId") String userId, Pageable pageable); @Query(value = "SELECT * FROM locations WHERE " + "ST_DWithin(coordinates, ST_SetSRID(ST_MakePoint(:longitude, :latitude), 4326), :radius) " + "AND user_id = :userId ORDER BY timestamp DESC", nativeQuery = true) List<Location> findByUserAndLocationWithinRadius(@Param("userId") String userId, @Param("latitude") double latitude, @Param("longitude") double longitude, @Param("radius") double radiusMeters); @Query(value = "SELECT * FROM locations WHERE " + "ST_DWithin(coordinates, :point, :radius) " + "ORDER BY timestamp DESC", nativeQuery = true) List<Location> findByLocationWithinRadius(@Param("point") Point point, @Param("radius") double radiusMeters); }

2. POI Repository

package com.yourapp.location.repository; import com.yourapp.location.model.PointOfInterest; import org.locationtech.jts.geom.Point; import org.springframework.data.domain.Pageable; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.query.Param; import org.springframework.stereotype.Repository; import java.util.List; @Repository public interface PointOfInterestRepository extends JpaRepository<PointOfInterest, Long> { List<PointOfInterest> findByCategory(String category); List<PointOfInterest> findByCategoryAndIsActiveTrue(String category); @Query(value = "SELECT * FROM points_of_interest WHERE " + "ST_DWithin(coordinates, :point, :radius) " + "AND is_active = true " + "ORDER BY ST_Distance(coordinates, :point)", nativeQuery = true) List<PointOfInterest> findByLocationWithinRadius(@Param("point") Point point, @Param("radius") double radiusMeters); @Query(value = "SELECT * FROM points_of_interest WHERE " + "ST_DWithin(coordinates, :point, :radius) " + "AND category = :category " + "AND is_active = true " + "ORDER BY ST_Distance(coordinates, :point)", nativeQuery = true) List<PointOfInterest> findByCategoryAndLocationWithinRadius(@Param("category") String category, @Param("point") Point point, @Param("radius") double radiusMeters); @Query(value = "SELECT * FROM points_of_interest WHERE " + "name ILIKE %:name% " + "AND ST_DWithin(coordinates, :point, :radius) " + "AND is_active = true " + "ORDER BY ST_Distance(coordinates, :point)", nativeQuery = true) List<PointOfInterest> findByNameContainingAndLocationWithinRadius(@Param("name") String name, @Param("point") Point point, @Param("radius") double radiusMeters); @Query(value = "SELECT * FROM points_of_interest WHERE " + "latitude BETWEEN :minLat AND :maxLat " + "AND longitude BETWEEN :minLon AND :maxLon " + "AND (:category IS NULL OR category = :category) " + "AND is_active = true " + "ORDER BY ST_Distance(coordinates, ST_SetSRID(ST_MakePoint((:minLon + :maxLon)/2, (:minLat + :maxLat)/2), 4326))", nativeQuery = true) List<PointOfInterest> findWithinBoundingBox(@Param("minLat") double minLat, @Param("maxLat") double maxLat, @Param("minLon") double minLon, @Param("maxLon") double maxLon, @Param("category") String category); @Query("SELECT p FROM PointOfInterest p WHERE " + "p.isActive = true ORDER BY " + "ST_Distance(p.coordinates, :point)") List<PointOfInterest> findNearest(@Param("point") Point point, Pageable pageable); @Query("SELECT p FROM PointOfInterest p WHERE " + "p.category = :category AND p.isActive = true ORDER BY " + "ST_Distance(p.coordinates, :point)") List<PointOfInterest> findNearestByCategory(@Param("point") Point point, @Param("category") String category, Pageable pageable); }

3. Geofence Repository

package com.yourapp.location.repository; import com.yourapp.location.model.Geofence; import org.locationtech.jts.geom.Point; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.query.Param; import org.springframework.stereotype.Repository; import java.util.List; @Repository public interface GeofenceRepository extends JpaRepository<Geofence, Long> { List<Geofence> findByIsActiveTrue(); @Query("SELECT g FROM Geofence g WHERE g.isActive = true") List<Geofence> findActiveGeofences(); @Query(value = "SELECT * FROM geofences WHERE " + "ST_Contains(boundary, :point) " + "AND is_active = true", nativeQuery = true) List<Geofence> findGeofencesContainingPoint(@Param("point") Point point); @Query(value = "SELECT * FROM geofences WHERE " + "ST_DWithin(boundary, :point, :tolerance) " + "AND is_active = true", nativeQuery = true) List<Geofence> findGeofencesNearPoint(@Param("point") Point point, @Param("tolerance") double tolerance); List<Geofence> findByTypeAndIsActiveTrue(com.yourapp.location.model.GeofenceType type); }

REST API Controllers

1. Location Controller

package com.yourapp.location.controller; import com.yourapp.location.model.Location; import com.yourapp.location.service.GeocodingService; import com.yourapp.location.service.ProximitySearchService; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.util.List; import java.util.Map; @RestController @RequestMapping("/api/location") public class LocationController { private final GeocodingService geocodingService; private final ProximitySearchService proximitySearchService; public LocationController(GeocodingService geocodingService, ProximitySearchService proximitySearchService) { this.geocodingService = geocodingService; this.proximitySearchService = proximitySearchService; } @PostMapping("/geocode") public ResponseEntity<?> geocodeAddress(@RequestBody Map<String, String> request) { try { String address = request.get("address"); GeocodingService.GeocodingResult result = geocodingService.geocodeAddress(address); return ResponseEntity.ok(result); } catch (Exception e) { return ResponseEntity.badRequest().body( Map.of("error", "Geocoding failed", "message", e.getMessage()) ); } } @PostMapping("/reverse-geocode") public ResponseEntity<?> reverseGeocode(@RequestBody Map<String, Object> request) { try { double lat = (Double) request.get("latitude"); double lng = (Double) request.get("longitude"); GeocodingService.GeocodingResult result = geocodingService.reverseGeocode(lat, lng); return ResponseEntity.ok(result); } catch (Exception e) { return ResponseEntity.badRequest().body( Map.of("error", "Reverse geocoding failed", "message", e.getMessage()) ); } } @GetMapping("/pois/nearby") public ResponseEntity<?> findNearbyPOIs( @RequestParam double latitude, @RequestParam double longitude, @RequestParam(defaultValue = "1000") double radius, @RequestParam(required = false) String category, @RequestParam(defaultValue = "10") int limit) { try { List<ProximitySearchService.POIWithDistance> pois = proximitySearchService.calculateDistancesToPOIs( latitude, longitude, proximitySearchService.findNearestPOIs(latitude, longitude, limit, category) ); return ResponseEntity.ok(pois); } catch (Exception e) { return ResponseEntity.badRequest().body( Map.of("error", "Failed to find nearby POIs", "message", e.getMessage()) ); } } @GetMapping("/pois/within-radius") public ResponseEntity<?> findPOIsWithinRadius( @RequestParam double latitude, @RequestParam double longitude, @RequestParam double radius, @RequestParam(required = false) String category) { try { List<ProximitySearchService.POIWithDistance> pois = proximitySearchService.calculateDistancesToPOIs( latitude, longitude, proximitySearchService.findPOIsWithinRadius(latitude, longitude, radius, category) ); return ResponseEntity.ok(pois); } catch (Exception e) { return ResponseEntity.badRequest().body( Map.of("error", "Failed to find POIs within radius", "message", e.getMessage()) ); } } @GetMapping("/distance") public ResponseEntity<?> calculateDistance( @RequestParam double lat1, @RequestParam double lon1, @RequestParam double lat2, @RequestParam double lon2, @RequestParam(defaultValue = "KILOMETERS") String unit) { try { // Implementation would use DistanceCalculationService return ResponseEntity.ok().build(); } catch (Exception e) { return ResponseEntity.badRequest().body( Map.of("error", "Distance calculation failed", "message", e.getMessage()) ); } } }

2. Geofencing Controller

package com.yourapp.location.controller; import com.yourapp.location.model.Geofence; import com.yourapp.location.model.GeofenceTrigger; import com.yourapp.location.model.Location; import com.yourapp.location.service.GeofencingService; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.util.List; import java.util.Map; @RestController @RequestMapping("/api/geofencing") public class GeofencingController { private final GeofencingService geofencingService; public GeofencingController(GeofencingService geofencingService) { this.geofencingService = geofencingService; } @PostMapping("/check") public ResponseEntity<?> checkGeofences(@RequestBody Location location) { try { List<GeofencingService.GeofenceEvent> events = geofencingService.checkGeofences(location); return ResponseEntity.ok(events); } catch (Exception e) { return ResponseEntity.badRequest().body( Map.of("error", "Geofence check failed", "message", e.getMessage()) ); } } @PostMapping("/circular") public ResponseEntity<?> createCircularGeofence(@RequestBody Map<String, Object> request) { try { String name = (String) request.get("name"); double centerLat = (Double) request.get("centerLat"); double centerLon = (Double) request.get("centerLon"); double radius = (Double) request.get("radius"); @SuppressWarnings("unchecked") List<String> triggerStrings = (List<String>) request.get("triggers"); List<GeofenceTrigger> triggers = triggerStrings.stream() .map(GeofenceTrigger::valueOf) .toList(); Geofence geofence = geofencingService.createCircularGeofence( name, centerLat, centerLon, radius, triggers); return ResponseEntity.ok(geofence); } catch (Exception e) { return ResponseEntity.badRequest().body( Map.of("error", "Failed to create geofence", "message", e.getMessage()) ); } } @GetMapping("/containing") public ResponseEntity<?> getContainingGeofences( @RequestParam double latitude, @RequestParam double longitude) { try { List<Geofence> geofences = geofencingService.getContainingGeofences(latitude, longitude); return ResponseEntity.ok(geofences); } catch (Exception e) { return ResponseEntity.badRequest().body( Map.of("error", "Failed to get containing geofences", "message", e.getMessage()) ); } } }

Advanced Features

1. Real-time Location Tracking

package com.yourapp.location.service; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.stereotype.Service; import java.util.concurrent.TimeUnit; @Service public class RealTimeLocationService { private final RedisTemplate<String, Object> redisTemplate; private static final String LOCATION_KEY_PREFIX = "location:user:"; private static final long LOCATION_TTL = 300; // 5 minutes public RealTimeLocationService(RedisTemplate<String, Object> redisTemplate) { this.redisTemplate = redisTemplate; } /** * Update user's real-time location */ public void updateUserLocation(String userId, double latitude, double longitude) { String key = LOCATION_KEY_PREFIX + userId; UserLocation location = new UserLocation(userId, latitude, longitude, System.currentTimeMillis()); redisTemplate.opsForValue().set(key, location, LOCATION_TTL, TimeUnit.SECONDS); // Also update geospatial index for proximity queries redisTemplate.opsForGeo().add("user_locations", new org.springframework.data.geo.Point(longitude, latitude), userId); } /** * Get user's current location */ public UserLocation getUserLocation(String userId) { String key = LOCATION_KEY_PREFIX + userId; return (UserLocation) redisTemplate.opsForValue().get(key); } /** * Find users near location */ public List<UserLocation> findUsersNearLocation(double latitude, double longitude, double radiusMeters) { // Convert meters to Redis GEO units (kilometers) double radiusKm = radiusMeters / 1000.0; List<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<Object>> results = redisTemplate.opsForGeo().radius("user_locations", new org.springframework.data.geo.Point(longitude, latitude), new org.springframework.data.geo.Distance(radiusKm, org.springframework.data.geo.Metrics.KILOMETERS)); return results.stream() .map(geoLocation -> { String userId = (String) geoLocation.getName(); return getUserLocation(userId); }) .filter(Objects::nonNull) .toList(); } public static class UserLocation { private String userId; private double latitude; private double longitude; private long timestamp; public UserLocation(String userId, double latitude, double longitude, long timestamp) { this.userId = userId; this.latitude = latitude; this.longitude = longitude; this.timestamp = timestamp; } // Getters and Setters public String getUserId() { return userId; } public void setUserId(String userId) { this.userId = userId; } 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 long getTimestamp() { return timestamp; } public void setTimestamp(long timestamp) { this.timestamp = timestamp; } } }

2. Route Optimization Service

package com.yourapp.location.service; import org.springframework.stereotype.Service; import java.util.ArrayList; import java.util.List; @Service public class RouteOptimizationService { private final DistanceCalculationService distanceService; public RouteOptimizationService(DistanceCalculationService distanceService) { this.distanceService = distanceService; } /** * Calculate optimal route using nearest neighbor algorithm */ public Route calculateOptimalRoute(double startLat, double startLon, List<RoutePoint> destinations) { if (destinations.isEmpty()) { return new Route(List.of(new RoutePoint(startLat, startLon, "Start")), 0); } List<RoutePoint> unvisited = new ArrayList<>(destinations); List<RoutePoint> route = new ArrayList<>(); route.add(new RoutePoint(startLat, startLon, "Start")); RoutePoint current = route.get(0); double totalDistance = 0; while (!unvisited.isEmpty()) { RoutePoint nearest = findNearestPoint(current, unvisited); double distance = distanceService.calculateDistanceInMeters( current.getLatitude(), current.getLongitude(), nearest.getLatitude(), nearest.getLongitude()); totalDistance += distance; route.add(nearest); unvisited.remove(nearest); current = nearest; } // Return to start double returnDistance = distanceService.calculateDistanceInMeters( current.getLatitude(), current.getLongitude(), startLat, startLon); totalDistance += returnDistance; return new Route(route, totalDistance); } private RoutePoint findNearestPoint(RoutePoint from, List<RoutePoint> points) { RoutePoint nearest = null; double minDistance = Double.MAX_VALUE; for (RoutePoint point : points) { double distance = distanceService.calculateDistanceInMeters( from.getLatitude(), from.getLongitude(), point.getLatitude(), point.getLongitude()); if (distance < minDistance) { minDistance = distance; nearest = point; } } return nearest; } public static class Route { private final List<RoutePoint> points; private final double totalDistance; public Route(List<RoutePoint> points, double totalDistance) { this.points = points; this.totalDistance = totalDistance; } public List<RoutePoint> getPoints() { return points; } public double getTotalDistance() { return totalDistance; } } public static class RoutePoint { private final double latitude; private final double longitude; private final String name; public RoutePoint(double latitude, double longitude, String name) { this.latitude = latitude; this.longitude = longitude; this.name = name; } public double getLatitude() { return latitude; } public double getLongitude() { return longitude; } public String getName() { return name; } } }

Best Practices

Spatial Indexing: Ensure proper spatial indexes on coordinate columns
Error Handling: Implement comprehensive error handling for location services
Caching: Cache geocoding results and frequent spatial queries
Privacy: Implement location data anonymization and retention policies
Performance: Use connection pooling and query optimization for spatial databases
Accuracy: Handle different location sources and accuracy levels appropriately
Battery Optimization: For mobile apps, implement efficient location updates
Compliance: Ensure GDPR and other privacy regulation compliance for location data

This comprehensive location-based services implementation provides a solid foundation for building sophisticated location-aware applications in Java, covering everything from basic geocoding to advanced real-time tracking and geofencing.

Java Observability, Logging Intelligence & AI-Driven Monitoring (APM, Tracing, Logs & Anomaly Detection)

https://macronepal.com/blog/beyond-metrics-observing-serverless-and-traditional-java-applications-with-thundra-apm/
Explains using Thundra APM to observe both serverless and traditional Java applications by combining tracing, metrics, and logs into a unified observability platform for faster debugging and performance insights.

https://macronepal.com/blog/dynatrace-oneagent-in-java-2/
Explains Dynatrace OneAgent for Java, which automatically instruments JVM applications to capture metrics, traces, and logs, enabling full-stack monitoring and root-cause analysis with minimal configuration.

https://macronepal.com/blog/lightstep-java-sdk-distributed-tracing-and-observability-implementation/
Explains Lightstep Java SDK for distributed tracing, helping developers track requests across microservices and identify latency issues using OpenTelemetry-based observability.

https://macronepal.com/blog/honeycomb-io-beeline-for-java-complete-guide-2/
Explains Honeycomb Beeline for Java, which provides high-cardinality observability and deep query capabilities to understand complex system behavior and debug distributed systems efficiently.

https://macronepal.com/blog/lumigo-for-serverless-in-java-complete-distributed-tracing-guide-2/
Explains Lumigo for Java serverless applications, offering automatic distributed tracing, log correlation, and error tracking to simplify debugging in cloud-native environments. (Lumigo Docs)

https://macronepal.com/blog/from-noise-to-signals-implementing-log-anomaly-detection-in-java-applications/
Explains how to detect anomalies in Java logs using behavioral patterns and machine learning techniques to separate meaningful incidents from noisy log data and improve incident response.

https://macronepal.com/blog/ai-powered-log-analysis-in-java-from-reactive-debugging-to-proactive-insights/
Explains AI-driven log analysis for Java applications, shifting from manual debugging to predictive insights that identify issues early and improve system reliability using intelligent log processing.

https://macronepal.com/blog/titliel-java-logging-best-practices/
Explains best practices for Java logging, focusing on structured logs, proper log levels, performance optimization, and ensuring logs are useful for debugging and observability systems.

https://macronepal.com/blog/seeking-a-loguru-for-java-the-quest-for-elegant-and-simple-logging/
Explains the search for simpler, more elegant logging frameworks in Java, comparing modern logging approaches that aim to reduce complexity while improving readability and developer experience.