开启掘金成长之旅！这是我参与「掘金日新计划 · 2 月更文挑战」的第 12 天，点击查看活动详情
Redis-GEO
在写代驾项目时，完成创建订单，接下来就要寻找附近适合接单的司机。司机端的小程序实时把自己的GPS定位上传，然后定位信息缓存到Redis里面。使用Redis的Geo功能进行筛选。
GEO简介
Redis的Geo主要用于存储地理位置信息，并对存储的信息进行操作。
Redis GEO 操作方法有：
- geoadd：添加地理位置的坐标。
- geopos：获取地理位置的坐标。
- geodist：计算两个位置之间的距离。
- georadius：根据用户给定的经纬度坐标来获取指定范围内的地理位置集合。
- georadiusbymember：根据储存在位置集合里面的某个地点获取指定范围内的地理位置集合。
- geohash：返回一个或多个位置对象的 geohash 值。
下面使用GEOADD命令向Redis里面添加几个景点的定位。
GEOADD china 116.403963 39.915119 tiananmen 116.417876 39.915411 wangfujing 116.404354 39.904748 qianmen
GEORADIUS命令查询距离某个定位点1公里范围以内的景点有哪些。
GEORADIUS china 116.4000 39.9000 1 km WITHDIST
Redis的Geo计算是在内存中完成的，比MySQL的Geo计算快了上千倍。
流程设计
Geo中的无法设置超时时间，想要筛选在线司机，需要额外创建带有超时的缓存。
缓存司机信息使用的Key是driver_online#driverId，对应的Value是接单距离#订单里程范围#定向接单的坐标，超时时间为1分钟。当系统接到订单之后，到Redis上面根据driverId查找缓存，找到了就是在线，找不到则返回无合适司机。
司机端的小程序可以实时上传定位坐标，并且Redis中保存了司机的GEO缓存和上线缓存。那么创建订单的过程中，需要查找附近适合接单的司机。如果有这样的司机，代驾系统才会创建订单，否则就拒绝创建订单。
通过Redis的GEO计算，我们可以查找到客户附近的司机，根据司机设置的接单距离再进行筛选，看是否符合司机的要求，如果查询到合适的，则订单成功创建。
具体实现
通过前端返回的GPS经纬度坐标以及司机接单信息，对其进行处理并存入Redis中。
@Service
public class DriverLocationServiceImpl implements DriverLocationService {
@Resource
private RedisTemplate redisTemplate;
@Override
public void updateLocationCache(Map param) {
long driverId = MapUtil.getLong(param, "driverId");
String latitude = MapUtil.getStr(param, "latitude");
String longitude = MapUtil.getStr(param, "longitude");
//接单范围
int rangeDistance = MapUtil.getInt(param, "rangeDistance");
//订单里程范围
int orderDistance = MapUtil.getInt(param, "orderDistance");
//封装成Point对象缓存到Redis里面
Point point = new Point(Convert.toDouble(longitude), Convert.toDouble(latitude));
/*
* 把司机实时定位缓存到Redis里面，便于Geo定位计算
* Geo是集合形式，如果设置过期时间，所有司机的定位缓存就全都失效了
* 所以只能等司机上线后，更新GEO中的缓存定位
*/
redisTemplate.opsForGeo().add("driver_location", point, driverId + "");
//定向接单地址的经度
String orientateLongitude = null;
if (param.get("orientateLongitude") != null) {
orientateLongitude = MapUtil.getStr(param, "orientateLongitude");
}
//定向接单地址的纬度
String orientateLatitude = null;
if (param.get("orientateLatitude") != null) {
orientateLatitude = MapUtil.getStr(param, "orientateLatitude");
}
//定向接单经纬度的字符串
String orientation = "none";
if (orientateLongitude != null && orientateLatitude != null) {
orientation = orientateLatitude + "," + orientateLongitude;
}
/*
* 为了解决判断哪些司机在线，单独添加一个上线缓存
* 缓存司机的接单设置（定向接单、接单范围、订单总里程）
*/
String temp = rangeDistance + "#" + orderDistance + "#" + orientation;
redisTemplate.opsForValue().set("driver_online#" + driverId, temp, 60, TimeUnit.SECONDS);
}
}
由于腾讯地图使用的是火星坐标，所以先定义一个工具类用于坐标转换:
/**
* 提供了百度坐标（BD09）、国测局坐标（火星坐标，GCJ02）、和WGS84坐标系之间的转换
*/
public class CoordinateTransform {
private static final double x_PI = 3.14159265358979324 * 3000.0 / 180.0;
private static final double PI = 3.1415926535897932384626;
private static final double a = 6378245.0;
private static final double ee = 0.00669342162296594323;
/**
* 百度坐标（BD09）转 GCJ02
*
* @param lng 百度经度
* @param lat 百度纬度
* @return GCJ02 坐标：[经度，纬度]
*/
public static double[] transformBD09ToGCJ02(double lng, double lat) {
double x = lng - 0.0065;
double y = lat - 0.006;
double z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * x_PI);
double theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * x_PI);
double gcj_lng = z * Math.cos(theta);
double gcj_lat = z * Math.sin(theta);
return new double[]{gcj_lng, gcj_lat};
}
/**
* GCJ02 转百度坐标
*
* @param lng GCJ02 经度
* @param lat GCJ02 纬度
* @return 百度坐标：[经度，纬度]
*/
public static double[] transformGCJ02ToBD09(double lng, double lat) {
double z = Math.sqrt(lng * lng + lat * lat) + 0.00002 * Math.sin(lat * x_PI);
double theta = Math.atan2(lat, lng) + 0.000003 * Math.cos(lng * x_PI);
double bd_lng = z * Math.cos(theta) + 0.0065;
double bd_lat = z * Math.sin(theta) + 0.006;
return new double[]{bd_lng, bd_lat};
}
/**
* GCJ02 转 WGS84
*
* @param lng 经度
* @param lat 纬度
* @return WGS84坐标：[经度，纬度]
*/
public static double[] transformGCJ02ToWGS84(double lng, double lat) {
if (outOfChina(lng, lat)) {
return new double[]{lng, lat};
} else {
double dLat = transformLat(lng - 105.0, lat - 35.0);
double dLng = transformLng(lng - 105.0, lat - 35.0);
double radLat = lat / 180.0 * PI;
double magic = Math.sin(radLat);
magic = 1 - ee * magic * magic;
double sqrtMagic = Math.sqrt(magic);
dLat = (dLat * 180.0) / ((a * (1 - ee)) / (magic * sqrtMagic) * PI);
dLng = (dLng * 180.0) / (a / sqrtMagic * Math.cos(radLat) * PI);
double mgLat = lat + dLat;
double mgLng = lng + dLng;
return new double[]{lng * 2 - mgLng, lat * 2 - mgLat};
}
}
/**
* WGS84 坐标 转 GCJ02
*
* @param lng 经度
* @param lat 纬度
* @return GCJ02 坐标：[经度，纬度]
*/
public static double[] transformWGS84ToGCJ02(double lng, double lat) {
if (outOfChina(lng, lat)) {
return new double[]{lng, lat};
} else {
double dLat = transformLat(lng - 105.0, lat - 35.0);
double dLng = transformLng(lng - 105.0, lat - 35.0);
double redLat = lat / 180.0 * PI;
double magic = Math.sin(redLat);
magic = 1 - ee * magic * magic;
double sqrtMagic = Math.sqrt(magic);
dLat = (dLat * 180.0) / ((a * (1 - ee)) / (magic * sqrtMagic) * PI);
dLng = (dLng * 180.0) / (a / sqrtMagic * Math.cos(redLat) * PI);
double mgLat = lat + dLat;
double mgLng = lng + dLng;
return new double[]{mgLng, mgLat};
}
}
/**
* 百度坐标BD09 转 WGS84
*
* @param lng 经度
* @param lat 纬度
* @return WGS84 坐标：[经度，纬度]
*/
public static double[] transformBD09ToWGS84(double lng, double lat) {
double[] lngLat = transformBD09ToGCJ02(lng, lat);
return transformGCJ02ToWGS84(lngLat[0], lngLat[1]);
}
/**
* WGS84 转 百度坐标BD09
*
* @param lng 经度
* @param lat 纬度
* @return BD09 坐标：[经度，纬度]
*/
public static double[] transformWGS84ToBD09(double lng, double lat) {
double[] lngLat = transformWGS84ToGCJ02(lng, lat);
return transformGCJ02ToBD09(lngLat[0], lngLat[1]);
}
private static double transformLat(double lng, double lat) {
double ret = -100.0 + 2.0 * lng + 3.0 * lat + 0.2 * lat * lat + 0.1 * lng * lat + 0.2 * Math.sqrt(Math.abs(lng));
ret += (20.0 * Math.sin(6.0 * lng * PI) + 20.0 * Math.sin(2.0 * lng * PI)) * 2.0 / 3.0;
ret += (20.0 * Math.sin(lat * PI) + 40.0 * Math.sin(lat / 3.0 * PI)) * 2.0 / 3.0;
ret += (160.0 * Math.sin(lat / 12.0 * PI) + 320 * Math.sin(lat * PI / 30.0)) * 2.0 / 3.0;
return ret;
}
;
private static double transformLng(double lng, double lat) {
double ret = 300.0 + lng + 2.0 * lat + 0.1 * lng * lng + 0.1 * lng * lat + 0.1 * Math.sqrt(Math.abs(lng));
ret += (20.0 * Math.sin(6.0 * lng * PI) + 20.0 * Math.sin(2.0 * lng * PI)) * 2.0 / 3.0;
ret += (20.0 * Math.sin(lng * PI) + 40.0 * Math.sin(lng / 3.0 * PI)) * 2.0 / 3.0;
ret += (150.0 * Math.sin(lng / 12.0 * PI) + 300.0 * Math.sin(lng / 30.0 * PI)) * 2.0 / 3.0;
return ret;
}
;
/**
* 判断坐标是否不在国内
*
* @param lng 经度
* @param lat 纬度
* @return 坐标是否在国内
*/
public static boolean outOfChina(double lng, double lat) {
return (lng < 72.004 || lng > 137.8347) || (lat < 0.8293 || lat > 55.8271);
}
}
下面我们实现查询条件合适的接单司机：
@Override
public ArrayList searchBefittingDriverAboutOrder(double startPlaceLatitude, double startPlaceLongitude, double endPlaceLatitude, double endPlaceLongitude, double mileage) {
// 搜索订单起始点5公里以内的司机
Point point = new Point(startPlaceLongitude, startPlaceLatitude);
// 设置GEO距离单位为千米
Metric metric = RedisGeoCommands.DistanceUnit.KILOMETERS;
Distance distance = new Distance(5, metric);
Circle circle = new Circle(point, distance);
// 创建GEO参数
RedisGeoCommands.GeoRadiusCommandArgs args = RedisGeoCommands
.GeoRadiusCommandArgs
.newGeoRadiusArgs() // 结果中包含距离
.includeCoordinates() // 结果中包含坐标
.sortAscending(); // 升序排列
// 执行GEO计算，获得查询结果
GeoResults<RedisGeoCommands.GeoLocation<String>> radius = redisTemplate.opsForGeo().radius("driver_location", circle, args);
ArrayList list = new ArrayList(); // 需要通知的司机列表
if (radius != null) {
Iterator<GeoResult<RedisGeoCommands.GeoLocation<String>>> iterator =
radius.iterator();
while (iterator.hasNext()) {
GeoResult<RedisGeoCommands.GeoLocation<String>> result = iterator.next();
RedisGeoCommands.GeoLocation<String> contenet = result.getContent();
String driverId = contenet.getName();
Point memberPoint = contenet.getPoint(); // 获取对应的经纬度坐标
double dist = result.getDistance().getValue(); // 距离中心点的距离
// 排除不在线司机
if (!redisTemplate.hasKey("driver_online#" + driverId)) {
continue;
}
// 查找该司机的在线缓存
Object obj = redisTemplate.opsForValue().get("driver_online#" + driverId);
// 如果查找的那一刻，缓存超时被清空，就忽略该司机
if (obj == null) {
continue;
}
String value = obj.toString();
String[] temp = value.split("#");
int rangeDistance = Integer.parseInt(temp[0]);
int orderDistance = Integer.parseInt(temp[1]);
String orientation = temp[2];
//判断是否符合接单范围
boolean bool_1 = dist <= rangeDistance;
//判断订单里程是否符合
boolean bool_2 = false;
if (orderDistance == 0) {
bool_2 = true;
} else if (orderDistance == 5 && mileage > 0 && mileage <= 5) {
bool_2 = true;
} else if (orderDistance == 10 && mileage > 5 && mileage <= 10) {
bool_2 = true;
} else if (orderDistance == 15 && mileage > 10 && mileage <= 15) {
bool_2 = true;
} else if (orderDistance == 30 && mileage > 15 && mileage <= 30) {
bool_2 = true;
}
//判断定向接单是否符合
boolean bool_3 = false;
if (!orientation.equals("none")) {
double orientationLatitude = Double.parseDouble(orientation.split(",")[0]);
double orientationLongitude = Double.parseDouble(orientation.split(",")[1]);
//把定向点的火星坐标转换成GPS坐标
double[] location = CoordinateTransform.transformGCJ02ToWGS84(orientationLongitude, orientationLatitude);
GlobalCoordinates point_1 = new GlobalCoordinates(location[1], location[0]);
//把订单终点的火星坐标转换成GPS坐标
location = CoordinateTransform.transformGCJ02ToWGS84(endPlaceLongitude, endPlaceLatitude);
GlobalCoordinates point_2 = new GlobalCoordinates(location[1], location[0]);
//这里不需要Redis的GEO计算，直接用封装函数计算两个GPS坐标之间的距离
GeodeticCurve geoCurve = new GeodeticCalculator().calculateGeodeticCurve(Ellipsoid.WGS84, point_1, point_2);
//如果定向点距离订单终点距离在3公里以内，说明这个订单和司机定向点是顺路的
if (geoCurve.getEllipsoidalDistance() <= 3000) {
bool_3 = true;
}
} else {
bool_3 = true;
}
//匹配接单条件
if (bool_1 && bool_2 && bool_3) {
HashMap map = new HashMap() {{
put("driverId", driverId);
put("distance", dist);
}};
list.add(map); //把该司机添加到需要通知的列表中
}
}
}
return list;
}
