Proximity alerts notify users or systems when a target enters or exits a defined geographical area. This capability is crucial for location-based services, security systems, logistics tracking, and real-time monitoring applications. Let's explore how to build robust proximity alert systems in Java.
Why Proximity Alerts in Java?
Key use cases:
- Geofencing - Virtual boundaries for assets and people
- Location-based Marketing - Notify customers near retail locations
- Fleet Management - Monitor vehicle entry/exit from designated areas
- Security Systems - Alert when assets move outside safe zones
- Smart Cities - Traffic management and public safety notifications
Core Proximity Detection Engine
1. Geographical Calculations Service
@Service
@Slf4j
public class GeoCalculationService {
private static final double EARTH_RADIUS_METERS = 6371000; // Earth's radius in meters
/**
* Calculate distance between two points using Haversine formula
*/
public double calculateDistance(Location point1, Location point2) {
double lat1 = Math.toRadians(point1.getLatitude());
double lon1 = Math.toRadians(point1.getLongitude());
double lat2 = Math.toRadians(point2.getLatitude());
double lon2 = Math.toRadians(point2.getLongitude());
double dLat = lat2 - lat1;
double dLon = lon2 - lon1;
double a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
Math.cos(lat1) * Math.cos(lat2) *
Math.sin(dLon / 2) * Math.sin(dLon / 2);
double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
return EARTH_RADIUS_METERS * c;
}
/**
* Check if point is within circular geofence
*/
public boolean isPointInCircle(Location point, Location center, double radiusMeters) {
double distance = calculateDistance(point, center);
return distance <= radiusMeters;
}
/**
* Check if point is within polygon using ray casting algorithm
*/
public boolean isPointInPolygon(Location point, List<Location> polygon) {
if (polygon.size() < 3) {
throw new IllegalArgumentException("Polygon must have at least 3 points");
}
boolean inside = false;
int n = polygon.size();
for (int i = 0, j = n - 1; i < n; j = i++) {
Location vertexI = polygon.get(i);
Location vertexJ = polygon.get(j);
if (((vertexI.getLatitude() > point.getLatitude()) != (vertexJ.getLatitude() > point.getLatitude())) &&
(point.getLongitude() < (vertexJ.getLongitude() - vertexI.getLongitude()) *
(point.getLatitude() - vertexI.getLatitude()) /
(vertexJ.getLatitude() - vertexI.getLatitude()) + vertexI.getLongitude())) {
inside = !inside;
}
}
return inside;
}
/**
* Check if point is within rectangle defined by northwest and southeast corners
*/
public boolean isPointInRectangle(Location point, Location northwest, Location southeast) {
return point.getLatitude() <= northwest.getLatitude() &&
point.getLatitude() >= southeast.getLatitude() &&
point.getLongitude() >= northwest.getLongitude() &&
point.getLongitude() <= southeast.getLongitude();
}
/**
* Calculate bearing between two points
*/
public double calculateBearing(Location start, Location end) {
double lat1 = Math.toRadians(start.getLatitude());
double lon1 = Math.toRadians(start.getLongitude());
double lat2 = Math.toRadians(end.getLatitude());
double lon2 = Math.toRadians(end.getLongitude());
double dLon = lon2 - lon1;
double y = Math.sin(dLon) * Math.cos(lat2);
double x = Math.cos(lat1) * Math.sin(lat2) -
Math.sin(lat1) * Math.cos(lat2) * Math.cos(dLon);
double bearing = Math.toDegrees(Math.atan2(y, x));
return (bearing + 360) % 360; // Normalize to 0-360
}
/**
* Calculate destination point given distance and bearing
*/
public Location calculateDestination(Location start, double bearing, double distanceMeters) {
double lat1 = Math.toRadians(start.getLatitude());
double lon1 = Math.toRadians(start.getLongitude());
double bearingRad = Math.toRadians(bearing);
double angularDistance = distanceMeters / EARTH_RADIUS_METERS;
double lat2 = Math.asin(Math.sin(lat1) * Math.cos(angularDistance) +
Math.cos(lat1) * Math.sin(angularDistance) * Math.cos(bearingRad));
double lon2 = lon1 + Math.atan2(Math.sin(bearingRad) * Math.sin(angularDistance) * Math.cos(lat1),
Math.cos(angularDistance) - Math.sin(lat1) * Math.sin(lat2));
return new Location(Math.toDegrees(lat2), Math.toDegrees(lon2));
}
}
2. Geofence Management Service
@Service
@Slf4j
public class GeofenceService {
private final GeoCalculationService geoCalculator;
private final GeofenceRepository geofenceRepository;
private final Map<String, CachedGeofence> geofenceCache = new ConcurrentHashMap<>();
public GeofenceService(GeoCalculationService geoCalculator, GeofenceRepository geofenceRepository) {
this.geoCalculator = geoCalculator;
this.geofenceRepository = geofenceRepository;
loadGeofencesIntoCache();
}
public Geofence createGeofence(CreateGeofenceRequest request) {
Geofence geofence = Geofence.builder()
.id(UUID.randomUUID().toString())
.name(request.getName())
.description(request.getDescription())
.type(request.getType())
.coordinates(request.getCoordinates())
.radius(request.getRadius())
.isActive(true)
.createdAt(Instant.now())
.updatedAt(Instant.now())
.metadata(request.getMetadata())
.build();
Geofence saved = geofenceRepository.save(geofence);
cacheGeofence(saved);
log.info("Created geofence: {}", saved.getName());
return saved;
}
public List<GeofenceCheckResult> checkLocationAgainstGeofences(Location location, String deviceId) {
List<GeofenceCheckResult> results = new ArrayList<>();
for (CachedGeofence cachedGeofence : geofenceCache.values()) {
if (!cachedGeofence.isActive()) {
continue;
}
boolean isInside = checkPointInGeofence(location, cachedGeofence);
GeofenceCheckResult result = GeofenceCheckResult.builder()
.geofenceId(cachedGeofence.getId())
.geofenceName(cachedGeofence.getName())
.deviceId(deviceId)
.location(location)
.isInside(isInside)
.checkedAt(Instant.now())
.build();
results.add(result);
}
return results;
}
public GeofenceTransition checkGeofenceTransition(Location currentLocation,
Location previousLocation,
String deviceId) {
List<GeofenceCheckResult> currentResults = checkLocationAgainstGeofences(currentLocation, deviceId);
List<GeofenceCheckResult> previousResults = checkLocationAgainstGeofences(previousLocation, deviceId);
for (GeofenceCheckResult current : currentResults) {
for (GeofenceCheckResult previous : previousResults) {
if (current.getGeofenceId().equals(previous.getGeofenceId())) {
boolean wasInside = previous.isInside();
boolean isNowInside = current.isInside();
if (wasInside && !isNowInside) {
return GeofenceTransition.builder()
.type(TransitionType.EXIT)
.geofenceId(current.getGeofenceId())
.geofenceName(current.getGeofenceName())
.deviceId(deviceId)
.location(currentLocation)
.transitionTime(Instant.now())
.build();
} else if (!wasInside && isNowInside) {
return GeofenceTransition.builder()
.type(TransitionType.ENTER)
.geofenceId(current.getGeofenceId())
.geofenceName(current.getGeofenceName())
.deviceId(deviceId)
.location(currentLocation)
.transitionTime(Instant.now())
.build();
}
}
}
}
return null; // No transition detected
}
public List<Geofence> findGeofencesNearLocation(Location location, double radiusMeters) {
return geofenceCache.values().stream()
.filter(CachedGeofence::isActive)
.filter(geofence -> isGeofenceNearLocation(geofence, location, radiusMeters))
.map(this::mapToGeofence)
.collect(Collectors.toList());
}
private boolean checkPointInGeofence(Location location, CachedGeofence geofence) {
switch (geofence.getType()) {
case CIRCLE:
Location center = geofence.getCoordinates().get(0);
return geoCalculator.isPointInCircle(location, center, geofence.getRadius());
case POLYGON:
return geoCalculator.isPointInPolygon(location, geofence.getCoordinates());
case RECTANGLE:
if (geofence.getCoordinates().size() == 2) {
return geoCalculator.isPointInRectangle(location,
geofence.getCoordinates().get(0), geofence.getCoordinates().get(1));
}
return false;
default:
log.warn("Unknown geofence type: {}", geofence.getType());
return false;
}
}
private boolean isGeofenceNearLocation(CachedGeofence geofence, Location location, double radiusMeters) {
// For circles, check distance to center
if (geofence.getType() == GeofenceType.CIRCLE) {
Location center = geofence.getCoordinates().get(0);
double distance = geoCalculator.calculateDistance(location, center);
return distance <= (radiusMeters + geofence.getRadius());
}
// For polygons and rectangles, check if any vertex is within radius
return geofence.getCoordinates().stream()
.anyMatch(vertex -> geoCalculator.calculateDistance(location, vertex) <= radiusMeters);
}
private void loadGeofencesIntoCache() {
List<Geofence> activeGeofences = geofenceRepository.findByIsActiveTrue();
activeGeofences.forEach(this::cacheGeofence);
log.info("Loaded {} geofences into cache", activeGeofences.size());
}
private void cacheGeofence(Geofence geofence) {
geofenceCache.put(geofence.getId(), mapToCachedGeofence(geofence));
}
private CachedGeofence mapToCachedGeofence(Geofence geofence) {
return CachedGeofence.builder()
.id(geofence.getId())
.name(geofence.getName())
.type(geofence.getType())
.coordinates(geofence.getCoordinates())
.radius(geofence.getRadius())
.isActive(geofence.isActive())
.metadata(geofence.getMetadata())
.build();
}
private Geofence mapToGeofence(CachedGeofence cached) {
return Geofence.builder()
.id(cached.getId())
.name(cached.getName())
.type(cached.getType())
.coordinates(cached.getCoordinates())
.radius(cached.getRadius())
.isActive(cached.isActive())
.metadata(cached.getMetadata())
.build();
}
}
Proximity Alert Engine
1. Real-time Alert Service
@Service
@Slf4j
public class ProximityAlertService {
private final GeofenceService geofenceService;
private final AlertNotificationService notificationService;
private final AlertRepository alertRepository;
private final DeviceTrackingService deviceTrackingService;
// Track device states to detect transitions
private final Map<String, DeviceGeofenceState> deviceStates = new ConcurrentHashMap<>();
public ProximityAlertService(GeofenceService geofenceService,
AlertNotificationService notificationService,
AlertRepository alertRepository,
DeviceTrackingService deviceTrackingService) {
this.geofenceService = geofenceService;
this.notificationService = notificationService;
this.alertRepository = alertRepository;
this.deviceTrackingService = deviceTrackingService;
}
@Async
public void processLocationUpdate(LocationUpdate update) {
try {
String deviceId = update.getDeviceId();
Location currentLocation = update.getLocation();
// Get previous location for transition detection
Location previousLocation = deviceTrackingService.getLastKnownLocation(deviceId);
if (previousLocation != null) {
// Check for geofence transitions
GeofenceTransition transition = geofenceService.checkGeofenceTransition(
currentLocation, previousLocation, deviceId);
if (transition != null) {
handleGeofenceTransition(transition, update);
}
}
// Check for proximity to points of interest
checkProximityToPointsOfInterest(currentLocation, deviceId, update.getTimestamp());
// Update device tracking
deviceTrackingService.updateDeviceLocation(deviceId, currentLocation, update.getTimestamp());
} catch (Exception e) {
log.error("Failed to process location update for device: {}", update.getDeviceId(), e);
}
}
public void checkProximityToTarget(Location deviceLocation, Location targetLocation,
String deviceId, String targetId, double alertRadius) {
double distance = geoCalculator.calculateDistance(deviceLocation, targetLocation);
if (distance <= alertRadius) {
ProximityAlert alert = ProximityAlert.builder()
.id(UUID.randomUUID().toString())
.deviceId(deviceId)
.targetId(targetId)
.targetType("LOCATION")
.distance(distance)
.deviceLocation(deviceLocation)
.targetLocation(targetLocation)
.alertRadius(alertRadius)
.triggeredAt(Instant.now())
.build();
triggerProximityAlert(alert);
}
}
public void monitorDeviceProximity(String deviceId, String targetDeviceId, double alertRadius) {
Location deviceLocation = deviceTrackingService.getLastKnownLocation(deviceId);
Location targetLocation = deviceTrackingService.getLastKnownLocation(targetDeviceId);
if (deviceLocation != null && targetLocation != null) {
checkProximityToTarget(deviceLocation, targetLocation, deviceId, targetDeviceId, alertRadius);
}
}
@Scheduled(fixedRate = 30000) // Check every 30 seconds
public void performScheduledProximityChecks() {
log.info("Performing scheduled proximity checks");
// Check all active devices against all geofences
Map<String, Location> activeDevices = deviceTrackingService.getActiveDevices();
activeDevices.forEach((deviceId, location) -> {
try {
List<GeofenceCheckResult> results = geofenceService.checkLocationAgainstGeofences(location, deviceId);
results.forEach(this::processGeofenceCheckResult);
} catch (Exception e) {
log.error("Failed to check proximity for device: {}", deviceId, e);
}
});
}
private void handleGeofenceTransition(GeofenceTransition transition, LocationUpdate update) {
log.info("Geofence {} detected: device {} {}",
transition.getGeofenceName(), transition.getDeviceId(), transition.getType());
// Create alert
GeofenceAlert alert = GeofenceAlert.builder()
.id(UUID.randomUUID().toString())
.deviceId(transition.getDeviceId())
.geofenceId(transition.getGeofenceId())
.geofenceName(transition.getGeofenceName())
.transitionType(transition.getType())
.location(transition.getLocation())
.triggeredAt(transition.getTransitionTime())
.metadata(update.getMetadata())
.build();
// Save alert
alertRepository.save(alert);
// Send notifications
notificationService.sendGeofenceAlert(alert);
// Update device state
updateDeviceGeofenceState(transition.getDeviceId(), transition.getGeofenceId(),
transition.getType() == TransitionType.ENTER);
}
private void checkProximityToPointsOfInterest(Location location, String deviceId, Instant timestamp) {
// Implementation would check against predefined points of interest
// This is a simplified example
List<PointOfInterest> nearbyPOIs = pointOfInterestService.findNearby(location, 1000); // 1km radius
for (PointOfInterest poi : nearbyPOIs) {
double distance = geoCalculator.calculateDistance(location, poi.getLocation());
if (distance <= poi.getNotificationRadius()) {
triggerPointOfInterestAlert(deviceId, poi, distance, timestamp);
}
}
}
private void processGeofenceCheckResult(GeofenceCheckResult result) {
// Update device state and detect state changes
DeviceGeofenceState deviceState = deviceStates.computeIfAbsent(
result.getDeviceId(), id -> new DeviceGeofenceState(id));
boolean stateChanged = deviceState.updateGeofenceState(
result.getGeofenceId(), result.isInside(), result.getCheckedAt());
if (stateChanged) {
// Handle state change (e.g., send notification for continuous monitoring)
log.debug("Geofence state changed for device {} in geofence {}",
result.getDeviceId(), result.getGeofenceName());
}
}
private void triggerProximityAlert(ProximityAlert alert) {
alertRepository.save(alert);
notificationService.sendProximityAlert(alert);
log.info("Proximity alert triggered: device {} is {}m from target {}",
alert.getDeviceId(), alert.getDistance(), alert.getTargetId());
}
private void triggerPointOfInterestAlert(String deviceId, PointOfInterest poi,
double distance, Instant timestamp) {
POIProximityAlert alert = POIProximityAlert.builder()
.id(UUID.randomUUID().toString())
.deviceId(deviceId)
.poiId(poi.getId())
.poiName(poi.getName())
.poiType(poi.getType())
.distance(distance)
.triggeredAt(timestamp)
.build();
alertRepository.save(alert);
notificationService.sendPOIProximityAlert(alert);
}
private void updateDeviceGeofenceState(String deviceId, String geofenceId, boolean isInside) {
DeviceGeofenceState state = deviceStates.computeIfAbsent(
deviceId, id -> new DeviceGeofenceState(id));
state.updateGeofenceState(geofenceId, isInside, Instant.now());
}
}
Notification Service
1. Multi-channel Alert Notification
@Service
@Slf4j
public class AlertNotificationService {
private final EmailService emailService;
private final SMSService smsService;
private final PushNotificationService pushService;
private final WebSocketService webSocketService;
private final AlertTemplateService templateService;
public AlertNotificationService(EmailService emailService, SMSService smsService,
PushNotificationService pushService,
WebSocketService webSocketService,
AlertTemplateService templateService) {
this.emailService = emailService;
this.smsService = smsService;
this.pushService = pushService;
this.webSocketService = webSocketService;
this.templateService = templateService;
}
public void sendGeofenceAlert(GeofenceAlert alert) {
// Get notification preferences for the device/user
NotificationPreferences preferences = getNotificationPreferences(alert.getDeviceId());
// Prepare notification message
String message = templateService.generateGeofenceAlertMessage(alert);
String subject = templateService.generateGeofenceAlertSubject(alert);
// Send via configured channels
if (preferences.isEmailEnabled()) {
sendEmailAlert(alert, subject, message, preferences.getEmailRecipients());
}
if (preferences.isSmsEnabled()) {
sendSMSAlert(alert, message, preferences.getPhoneNumbers());
}
if (preferences.isPushEnabled()) {
sendPushAlert(alert, message, preferences.getDeviceTokens());
}
// Always send to WebSocket for real-time dashboard updates
sendWebSocketAlert(alert, message);
log.info("Sent geofence alert notifications for device: {}", alert.getDeviceId());
}
public void sendProximityAlert(ProximityAlert alert) {
NotificationPreferences preferences = getNotificationPreferences(alert.getDeviceId());
String message = templateService.generateProximityAlertMessage(alert);
if (preferences.isPushEnabled()) {
sendPushAlert(alert, message, preferences.getDeviceTokens());
}
sendWebSocketAlert(alert, message);
log.debug("Sent proximity alert for device: {}", alert.getDeviceId());
}
public void sendPOIProximityAlert(POIProximityAlert alert) {
// For POI alerts, we might want different notification rules
String message = templateService.generatePOIAlertMessage(alert);
sendPushAlert(alert, message, getDeviceTokens(alert.getDeviceId()));
sendWebSocketAlert(alert, message);
}
public void sendBulkAlerts(List<Alert> alerts) {
// Group alerts by device for efficient notification
Map<String, List<Alert>> alertsByDevice = alerts.stream()
.collect(Collectors.groupingBy(Alert::getDeviceId));
alertsByDevice.forEach((deviceId, deviceAlerts) -> {
if (deviceAlerts.size() > 1) {
// Send consolidated alert for multiple events
sendConsolidatedAlert(deviceId, deviceAlerts);
} else {
// Send individual alert
sendGeofenceAlert((GeofenceAlert) deviceAlerts.get(0));
}
});
}
private void sendEmailAlert(Alert alert, String subject, String message, List<String> recipients) {
try {
EmailRequest emailRequest = EmailRequest.builder()
.to(recipients)
.subject(subject)
.body(message)
.template("geofence-alert")
.variables(Map.of("alert", alert))
.build();
emailService.sendEmail(emailRequest);
} catch (Exception e) {
log.error("Failed to send email alert for device: {}", alert.getDeviceId(), e);
}
}
private void sendSMSAlert(Alert alert, String message, List<String> phoneNumbers) {
for (String phoneNumber : phoneNumbers) {
try {
SMSRequest smsRequest = SMSRequest.builder()
.to(phoneNumber)
.message(message)
.build();
smsService.sendSMS(smsRequest);
} catch (Exception e) {
log.error("Failed to send SMS alert to: {}", phoneNumber, e);
}
}
}
private void sendPushAlert(Alert alert, String message, List<String> deviceTokens) {
for (String deviceToken : deviceTokens) {
try {
PushNotificationRequest pushRequest = PushNotificationRequest.builder()
.deviceToken(deviceToken)
.title("Proximity Alert")
.body(message)
.data(Map.of(
"alertId", alert.getId(),
"type", alert.getType(),
"timestamp", alert.getTriggeredAt().toString()
))
.build();
pushService.sendNotification(pushRequest);
} catch (Exception e) {
log.error("Failed to send push alert to device token: {}", deviceToken, e);
}
}
}
private void sendWebSocketAlert(Alert alert, String message) {
try {
WebSocketMessage wsMessage = WebSocketMessage.builder()
.type("PROXIMITY_ALERT")
.payload(Map.of(
"alert", alert,
"message", message,
"timestamp", Instant.now().toString()
))
.build();
webSocketService.sendToUser(alert.getDeviceId(), wsMessage);
} catch (Exception e) {
log.error("Failed to send WebSocket alert for device: {}", alert.getDeviceId(), e);
}
}
private void sendConsolidatedAlert(String deviceId, List<Alert> alerts) {
// Implementation for consolidated alerts (multiple events in one notification)
String consolidatedMessage = templateService.generateConsolidatedAlertMessage(alerts);
NotificationPreferences preferences = getNotificationPreferences(deviceId);
if (preferences.isPushEnabled()) {
// Send consolidated push notification
}
log.info("Sent consolidated alert for {} events to device: {}", alerts.size(), deviceId);
}
private NotificationPreferences getNotificationPreferences(String deviceId) {
// In practice, this would fetch from database or user preferences service
return NotificationPreferences.builder()
.emailEnabled(true)
.smsEnabled(false)
.pushEnabled(true)
.emailRecipients(List.of("[email protected]"))
.phoneNumbers(List.of())
.deviceTokens(List.of("device-token-" + deviceId))
.build();
}
private List<String> getDeviceTokens(String deviceId) {
// Implementation would fetch from device registry
return List.of("device-token-" + deviceId);
}
}
Data Models
1. Core Domain Models
@Data
@Builder
public class Location {
private Double latitude;
private Double longitude;
private Double altitude;
private Float accuracy;
private Float speed;
private Float bearing;
private Instant timestamp;
public Location() {}
public Location(Double latitude, Double longitude) {
this.latitude = latitude;
this.longitude = longitude;
this.timestamp = Instant.now();
}
}
@Data
@Builder
public class Geofence {
private String id;
private String name;
private String description;
private GeofenceType type;
private List<Location> coordinates;
private Double radius; // For circular geofences
private boolean isActive;
private Instant createdAt;
private Instant updatedAt;
private Map<String, Object> metadata;
}
@Data
@Builder
public class GeofenceCheckResult {
private String geofenceId;
private String geofenceName;
private String deviceId;
private Location location;
private boolean isInside;
private Instant checkedAt;
}
@Data
@Builder
public class GeofenceTransition {
private TransitionType type;
private String geofenceId;
private String geofenceName;
private String deviceId;
private Location location;
private Instant transitionTime;
}
@Data
@Builder
public abstract class Alert {
private String id;
private String deviceId;
private AlertType type;
private Location location;
private Instant triggeredAt;
private Map<String, Object> metadata;
}
@Data
@Builder
public class GeofenceAlert extends Alert {
private String geofenceId;
private String geofenceName;
private TransitionType transitionType;
}
@Data
@Builder
public class ProximityAlert extends Alert {
private String targetId;
private String targetType;
private Location targetLocation;
private Double distance;
private Double alertRadius;
}
@Data
@Builder
public class LocationUpdate {
private String deviceId;
private Location location;
private Instant timestamp;
private Map<String, Object> metadata;
}
// Enums
public enum GeofenceType {
CIRCLE, POLYGON, RECTANGLE
}
public enum TransitionType {
ENTER, EXIT, DWELL, LEFT
}
public enum AlertType {
GEOFENCE_ENTER, GEOFENCE_EXIT, PROXIMITY, POI_NEARBY, FENCE_VIOLATION
}
// Supporting classes
@Data
@Builder
public class CachedGeofence {
private String id;
private String name;
private GeofenceType type;
private List<Location> coordinates;
private Double radius;
private boolean isActive;
private Map<String, Object> metadata;
}
@Data
public class DeviceGeofenceState {
private String deviceId;
private Map<String, Boolean> geofenceStates; // geofenceId -> isInside
private Instant lastUpdate;
public DeviceGeofenceState(String deviceId) {
this.deviceId = deviceId;
this.geofenceStates = new HashMap<>();
this.lastUpdate = Instant.now();
}
public boolean updateGeofenceState(String geofenceId, boolean isInside, Instant timestamp) {
Boolean previousState = geofenceStates.put(geofenceId, isInside);
this.lastUpdate = timestamp;
return previousState == null || previousState != isInside;
}
public boolean isInsideGeofence(String geofenceId) {
return geofenceStates.getOrDefault(geofenceId, false);
}
}
@Data
@Builder
public class NotificationPreferences {
private boolean emailEnabled;
private boolean smsEnabled;
private boolean pushEnabled;
private List<String> emailRecipients;
private List<String> phoneNumbers;
private List<String> deviceTokens;
}
REST Controller
1. Proximity Alert API
@RestController
@RequestMapping("/api/proximity")
@Slf4j
public class ProximityAlertController {
private final ProximityAlertService alertService;
private final GeofenceService geofenceService;
private final AlertRepository alertRepository;
public ProximityAlertController(ProximityAlertService alertService,
GeofenceService geofenceService,
AlertRepository alertRepository) {
this.alertService = alertService;
this.geofenceService = geofenceService;
this.alertRepository = alertRepository;
}
@PostMapping("/location-update")
public ResponseEntity<Void> processLocationUpdate(@RequestBody LocationUpdate update) {
try {
alertService.processLocationUpdate(update);
return ResponseEntity.accepted().build();
} catch (Exception e) {
log.error("Failed to process location update", e);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
}
@PostMapping("/geofences")
public ResponseEntity<Geofence> createGeofence(@RequestBody CreateGeofenceRequest request) {
try {
Geofence geofence = geofenceService.createGeofence(request);
return ResponseEntity.status(HttpStatus.CREATED).body(geofence);
} catch (Exception e) {
log.error("Failed to create geofence", e);
return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
}
}
@PostMapping("/check-proximity")
public ResponseEntity<ProximityCheckResponse> checkProximity(@RequestBody ProximityCheckRequest request) {
try {
List<GeofenceCheckResult> results = geofenceService.checkLocationAgainstGeofences(
request.getLocation(), request.getDeviceId());
ProximityCheckResponse response = ProximityCheckResponse.builder()
.deviceId(request.getDeviceId())
.location(request.getLocation())
.checkedAt(Instant.now())
.results(results)
.build();
return ResponseEntity.ok(response);
} catch (Exception e) {
log.error("Failed to check proximity", e);
return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
}
}
@GetMapping("/alerts/{deviceId}")
public ResponseEntity<List<Alert>> getDeviceAlerts(
@PathVariable String deviceId,
@RequestParam(defaultValue = "24") Integer hours) {
try {
Instant since = Instant.now().minus(hours, ChronoUnit.HOURS);
List<Alert> alerts = alertRepository.findByDeviceIdAndTriggeredAtAfter(deviceId, since);
return ResponseEntity.ok(alerts);
} catch (Exception e) {
log.error("Failed to get alerts for device: {}", deviceId, e);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
}
@PostMapping("/monitor-device-proximity")
public ResponseEntity<Void> monitorDeviceProximity(@RequestBody DeviceProximityRequest request) {
try {
alertService.monitorDeviceProximity(
request.getDeviceId(),
request.getTargetDeviceId(),
request.getAlertRadius()
);
return ResponseEntity.accepted().build();
} catch (Exception e) {
log.error("Failed to setup device proximity monitoring", e);
return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
}
}
@GetMapping("/geofences/nearby")
public ResponseEntity<List<Geofence>> findNearbyGeofences(
@RequestParam Double lat, @RequestParam Double lng,
@RequestParam(defaultValue = "1000") Double radiusMeters) {
try {
Location location = new Location(lat, lng);
List<Geofence> geofences = geofenceService.findGeofencesNearLocation(location, radiusMeters);
return ResponseEntity.ok(geofences);
} catch (Exception e) {
log.error("Failed to find nearby geofences", e);
return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
}
}
// Request DTOs
@Data
public static class CreateGeofenceRequest {
private String name;
private String description;
private GeofenceType type;
private List<Location> coordinates;
private Double radius;
private Map<String, Object> metadata;
}
@Data
public static class ProximityCheckRequest {
private String deviceId;
private Location location;
}
@Data
@Builder
public static class ProximityCheckResponse {
private String deviceId;
private Location location;
private Instant checkedAt;
private List<GeofenceCheckResult> results;
}
@Data
public static class DeviceProximityRequest {
private String deviceId;
private String targetDeviceId;
private Double alertRadius;
}
}
Configuration
1. Application Properties
# application.yml proximity: alert: enabled: true check-interval: 30000 max-geofence-radius: 50000 notification: email-enabled: true sms-enabled: false push-enabled: true geofence: cache-enabled: true cache-refresh-interval: 300000 spring: task: execution: pool: core-size: 10 max-size: 50 queue-capacity: 1000
Best Practices
- Performance Optimization - Use spatial indexes for geofence queries
- Scalability - Implement distributed caching for device states
- Accuracy - Consider using more precise geographical calculations for critical applications
- Battery Optimization - Adjust location update frequency based on use case
- Error Handling - Implement robust error handling for location services
- Privacy - Ensure compliance with data protection regulations
- Monitoring - Track alert volumes and system performance
Conclusion
Implementing proximity alerts in Java enables powerful location-aware applications across various domains. By leveraging the patterns shown here, developers can:
- Create Virtual Boundaries - Implement geofencing for security and monitoring
- Enable Real-time Notifications - Alert users based on location changes
- Optimize Operations - Monitor asset movements and fleet locations
- Enhance User Experience - Provide context-aware services
- Ensure Safety - Monitor restricted areas and safety zones
The combination of geographical calculations, real-time processing, and multi-channel notifications creates a comprehensive proximity alert system that can scale from simple location tracking to complex enterprise monitoring solutions.
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.