附近卖家实现2.0

最新推荐文章于 2023-02-13 11:13:24 发布
最新推荐文章于 2023-02-13 11:13:24 发布
阅读量791 收藏
点赞数 1
文章标签： 附近企业 微信 附近卖家 距离范围计算 坐标点距离
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/niuch1029291561/article/details/74991301
版权


该接口采用Redis+数据库查询封装实现：使用Redis做距离范围计算，读取当前距离内坐标数据，再进行数据库查询

优点：查询速度大大加快；缺点：处理逻辑复杂，由于Redis里面保存的只有数据主键与经纬度，读取出的数据只有数据主键和距离信息，因此需拿主键与数据库匹配，匹配出的数据未按距离排序，需再做距离排序处理

1.创建RedisUtils类，封装接口信息

package com.jk.util;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.collections.MapUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springside.core.dao.support.Pages;
import cn.framework.dao.JdbcService;
import redis.clients.jedis.GeoCoordinate;
import redis.clients.jedis.GeoRadiusResponse;
import redis.clients.jedis.GeoUnit;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.geo.GeoRadiusParam;
public class RedisUtils {
     
    private final static int ZB_PAGE = 1000;
     
    JdbcService jdbcService;
     
    private final static Logger log = LoggerFactory.getLogger(RedisUtils.class);
     
    /**
     * Redis数据读取接口
     * @title
     * @date 2017年7月11日
     * @author niuchuang
     * @param redisKey
     * @param longitude
     * @param latitude
     * @param distance
     * @param pageNum
     * @param pageSize
     * @return
     */
    public static Object getListMap(String redisKey,Double longitude, Double latitude,Integer distance,Integer pageNum, Integer pageSize){
        Jedis jedis = JedisUtil.getJedis();
        //log.info("并发前对象为:{}", jedis);
        //读取
        List<GeoRadiusResponse> responseList=null;
        try {
            responseList = jedis.georadius(redisKey, longitude, latitude,
                    distance, GeoUnit.M, GeoRadiusParam.geoRadiusParam().withCoord().withDist().sortAscending());
        } catch (Exception e) {
            log.error(e.getMessage());
        }
        //即时释放jedis
        //log.info("关闭jedis:{}", jedis);
        JedisUtil.close(jedis);
        //没有数据时直接返回
        if (responseList==null || responseList.size() == 0) {
            //没有分页参数时直接返回Map信息
            if (pageNum==null || pageSize==null) {
                return new LinkedHashMap<String, Double>();
            }else{
                return new Pages(0, 0, pageSize, new ArrayList<Map>());
            }
        }
        int totalCount = responseList.size();
        //封装
        if (pageNum==null || pageSize==null) {
            //封装为Map
            Map<String, Double> keysAndDistanceMap = new LinkedHashMap<String, Double>();
            for (int i = 0; i < totalCount; i++) {
                GeoRadiusResponse geoRadiusResponse = responseList.get(i);
                //企业编码
                String key = geoRadiusResponse.getMemberByString();
                keysAndDistanceMap.put(key, geoRadiusResponse.getDistance());
            }
            return keysAndDistanceMap;
        }else{
            //分页参数初始化
            pageNum=pageNum!=null && pageNum<=0?1:pageNum;
            Integer startIndex=(pageNum!=null && pageSize!=null)?(pageNum-1)*pageSize:null;
             
            List<Map<String, Object>> list=new ArrayList<Map<String, Object>>();
            /*已做排序处理，此处无需再次处理排序直接分页即可
            for (int i = 0; i < totalCount; i++) {
                GeoRadiusResponse geoRadiusResponse = responseList.get(i);
                //企业编码
                String key = geoRadiusResponse.getMemberByString();
                Map<String, Object> _map = new LinkedHashMap<String, Object>();
                _map.put("qybm", geoRadiusResponse.getMemberByString());
                _map.put("jl_length", geoRadiusResponse.getDistance());
                list.add(_map);
            }
            //排序
            //Collections.sort(list, new DistanceComparator());
            Map<String, Double> keysAndDistanceMap = new LinkedHashMap<String, Double>();
            Integer maxIndex=startIndex+pageSize>totalCount?totalCount:startIndex+pageSize;
            for (int i = startIndex;i<maxIndex && i < pageSize*pageNum; i++) {
                Map _map=list.get(i);
                keysAndDistanceMap.put(MapUtils.getString(_map, "qybm"), MapUtils.getDouble(_map, "jl_length"));
            }*/
            //外层数据查询可能旬在条件限制，故此处直接做分页处理会存在问题
            Integer maxIndex=startIndex+pageSize>totalCount?totalCount:startIndex+pageSize;
            Map<String, Double> keysAndDistanceMap = new LinkedHashMap<String, Double>();
            for (int i = startIndex;i<maxIndex && i < pageSize*pageNum; i++) {
                GeoRadiusResponse geoRadiusResponse = responseList.get(i);
                keysAndDistanceMap.put(geoRadiusResponse.getMemberByString(), geoRadiusResponse.getDistance());
            }
            Pages page = new Pages(startIndex, Integer.valueOf(totalCount+""), pageSize, keysAndDistanceMap);
            return page;
        }
    }
    /**
     * 程序逻辑数据分页封装接口
     * @title
     * @date 2017年7月11日
     * @author niuchuang
     * @param list
     * @param pageNum
     * @param pageSize
     * @return
     */
    public static Pages getPage(List<Map> list,Integer pageNum, Integer pageSize){
        if (list!=null && pageNum!=null && pageSize!=null) {
            pageNum=pageNum!=null && pageNum<=0?1:pageNum;
            Integer startIndex=(pageNum!=null && pageSize!=null)?(pageNum-1)*pageSize:null;
            Integer maxIndex=startIndex+pageSize>list.size()?list.size():startIndex+pageSize;
            List<Map> _list=new ArrayList<Map>();
            for (int i = startIndex;i<maxIndex && i < pageSize*pageNum && list.size()>=i; i++) {
                _list.add(list.get(i));
            }
            Pages page = new Pages(startIndex, Integer.valueOf(list.size()+""), pageSize, _list);
            return page;
        }
        return new Pages(0, 0, pageSize, new ArrayList<Map>());
    }
     
    /**
     * 数据保存Redis接口
     * @title
     * @date 2017年7月11日
     * @author niuchuang
     * @param key
     * @param geoCoordinateMap
     */
    public void addGeoAll(String key,Map<String, GeoCoordinate> geoCoordinateMap){
        Jedis jedis = JedisUtil.getJedis();
        try {
            jedis.geoadd(key, geoCoordinateMap);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //即时释放jedis
            JedisUtil.close(jedis);
        }
    }
    /**
     * 数据保存Redis接口
     * @title
     * @date 2017年7月11日
     * @author niuchuang
     * @param key
     * @param ywId
     * @param dlzbjd
     * @param dlzbwd
     */
    public void addGeo(String key,String ywId,double dlzbjd,double dlzbwd){
        Map<String, GeoCoordinate> geoCoordinateMap = new HashMap<String, GeoCoordinate>();
        GeoCoordinate coordinate = new GeoCoordinate(dlzbjd, dlzbwd);
        geoCoordinateMap.put(ywId, coordinate);
        addGeoAll(key, geoCoordinateMap);
    }
    /**
     * 数据存放Redis接口
     * @title
     * @date 2017年7月11日
     * @author niuchuang
     * @param args
     */
    public void setZbToRedis() {
        String sql="select t.id,t.jd,t.wd from b_qyxx t";
        int count = jdbcService.count(sql,new Object[]{});
        if (count<=0) {
            return;
        }
        Integer pageSize=ZB_PAGE;
        double tmp = (double) count / pageSize;
        int totalBatch = (int) Math.ceil(tmp);
         
        log.info("一共：["+count+"]条数据 共["+totalBatch+"]页");
        //分页进行数据存放
        for (Integer pageNum = 1; pageNum <= totalBatch ; pageNum++ ) {
            pageNum=pageNum!=null && pageNum<=0?1:pageNum;
            Integer startIndex=(pageNum!=null && pageSize!=null)?(pageNum-1)*pageSize:null;
            List<Map> list=jdbcService.dialectBaseQuery(sql, new Object[]{},startIndex,pageSize,null);
            log.info("第：["+(pageNum)+"]页条["+list.size()+"]条数据");
            Map<String, GeoCoordinate> geoCoordinateMap = new HashMap<String, GeoCoordinate>();
            for (Map map : list) {
                GeoCoordinate coordinate = new GeoCoordinate(MapUtils.getDoubleValue(map, "JD"), MapUtils.getDoubleValue(map, "WD"));
                geoCoordinateMap.put(MapUtils.getString(map, "ID"), coordinate);
            }
            //Redis存放数据
            addGeoAll("qy", geoCoordinateMap);
        }
    }
}

2.实现类接口调用 

package com.jk.service;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springside.core.dao.support.Pages;
import com.jk.DistanceComparator;
import com.jk.util.ComUtil;
import com.jk.util.DistanceUtil;
import com.jk.util.RedisUtils;
import cn.framework.dao.JdbcService;
import cn.framework.system.model.SystemDataField;
/**
 * 
 * @author niuchuang
 * @data 2017年4月6日
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public class CycycRedisService {
    private final static Logger log = LoggerFactory.getLogger(CycycRedisService2.class);
     
    private JdbcService jdbcService;
    private Pages getData(Map paramMap, Integer pageNum, Integer pageSize) {
        pageNum=(pageNum==null || pageNum<1)?1:pageNum;
         
        Object valueObject[]=new Object[]{};
         
        String colum="id,qymc,qybm,address,jd,wd";
        StringBuilder sql=new StringBuilder();
        sql.append("select ").append(colum).append(" from b_qyxx qy where 1=1");
         
        String qymc=MapUtils.getString(paramMap, "qymc");
        //对模糊查询进行转译，避免查传入“%”出查询出没有“%”的数据
        if (StringUtils.isNotBlank(qymc)){
            sql.append(" and cyqymc like ? escape '\\'");
            valueObject = ArrayUtils.add(valueObject, "%"+qymc.replaceAll("\\%", "\\\\%")+"%");
        }
         
        //当所属户地区不为空时不做范围限制，直接查询该所属地区内所有数据
        String ssdq = MapUtils.getString(paramMap, "ssdq");
        if (StringUtils.isNotBlank(ssdq) && !"-1".equals(ssdq) && !"440100".equals(ssdq)){
            sql.append(" and ssdq=?");
            valueObject = ArrayUtils.add(valueObject, ssdq);
        }
         
        Double longitude = MapUtils.getDouble(paramMap, "longitude");
        Double latitude = MapUtils.getDouble(paramMap, "latitude");
        Integer dis = MapUtils.getInteger(paramMap, "dis");
        if (longitude!=null && latitude!=null && dis!=null && dis!=-1) {
            //所属户地区不为空时不做范围限制,直接用java代码进行距离范围计算
            if ("1".equals(MapUtils.getString(paramMap, "isPar")) && (StringUtils.isNotBlank(qymc) 
                    || (StringUtils.isNotBlank(ssdq)) && !"-1".equals(ssdq) && !"440100".equals(ssdq))) {
                String ordBy=MapUtils.getString(paramMap, "ordBy");
                if (StringUtils.isBlank(ordBy) || "jl".equals(ordBy)) {
                    paramMap.put("ordBy", "id");
                }
                //排序封装
                setSort(sql, paramMap, true);
                Integer startIndex=(pageNum!=null && pageSize!=null)?(pageNum-1)*pageSize:null;
                //分页读取数据
                Pages page=jdbcService.pagesdQuery(sql.toString(), valueObject, startIndex, pageSize,new SystemDataField());
                List<Map> data=(List) page.getData();
                if (data!=null) {
                    //处理距离范围信息
                    for (Map _dataMap : data) {
                        if (longitude!=null && latitude!=null && dis==null) {
                            _dataMap.put("jl_length", (int)DistanceUtil.distanceSimplify(MapUtils.getDouble(_dataMap, "wd"),MapUtils.getDouble(_dataMap, "jd"), latitude, longitude));
                        }
                    }
                }
                return page;
            }else{
                //采用Redis计算距离信息
                Object redisObj = RedisUtils.getListMap("qy", longitude, latitude, dis, null, null);
                // 没有查到数据则返回空
                Map<String, Double> keysAndDistanceMap = (Map<String, Double>) redisObj;
                if (keysAndDistanceMap == null || keysAndDistanceMap.size() == 0) {
                    return new Pages(0, 0, pageSize, new ArrayList<Map>());
                }
                sql.append(" and (").append(ComUtil.inStringSqlPrepared(keysAndDistanceMap.size(), "id")).append(")");
                valueObject= ArrayUtils.addAll(valueObject, keysAndDistanceMap.keySet().toArray());
                List<Map> list = jdbcService.queryForList(sql.toString(), valueObject, new SystemDataField());
                // 给结果添加上距离
                for (Map map : list) {
                    String ydbm = MapUtils.getString(map, "id");
                    double _dis = 0;
                    if (StringUtils.isNotBlank(ydbm)) {
                        _dis = MapUtils.getDoubleValue(keysAndDistanceMap, ydbm);
                    }
                    map.put("jl_length", (int) _dis);
                }
                // 按照距离进行排序
                if (!"1".equals(MapUtils.getString(paramMap, "allDlzb"))) {
                    int i=setSort(sql, paramMap, true);
                    if (i==0) {
                        Collections.sort(list, new DistanceComparator());
                    }
                }
                Pages page=RedisUtils.getPage(list, pageNum, pageSize);
                return page;
            }
        }else{
            setSort(sql, paramMap, false);
            Integer startIndex=(pageNum!=null && pageSize!=null)?(pageNum-1)*pageSize:null;
            Pages page=jdbcService.pagesdQuery(sql.toString(), valueObject, startIndex, pageSize,new SystemDataField());
            return page;
        }
    }
    /**
     * 
     * @title
     * @date 2017年5月26日
     * @author niuchuang
     * @param sql
     * @param paramMap
     * @param isNullNoSort 是否不默认排序
     * @return
     */
    private int setSort(StringBuilder sql,Map paramMap,boolean isNullNoSort){
        String ordBy=MapUtils.getString(paramMap, "ordBy");
        if(isNullNoSort && ("jl".equals(ordBy) || StringUtils.isBlank(ordBy))){
            return 0;
        }else{
            //综合排序：等级最高，评价最高，离我最近   
            sql.append(" order by ");
            if ("qymc".equals(ordBy)) {//企业名称
                sql.append(" qymc");
            }else if ("zm".equals(ordBy)) {//字母
                sql.append(" nlssort(translate(lower(qymc),'abcdefghjklmnopqrstwxyz','啊八嚓大额发噶哈几卡拉吗呐哦扒七然仨他哇西呀杂'),'NLS_SORT=SCHINESE_PINYIN_M') ");
            }else {//距离
                ordBy="qymc";
                sql.append(" qymc ");
            }
            String ordByType=MapUtils.getString(paramMap, "ordByType","0");
            if("1".equals(ordByType)){
                sql.append(" desc ");
            }else{
                sql.append(" asc ");
            }
            return 1;
        }
    }
    public JdbcService getJdbcService() {
        return jdbcService;
    }
    public void setJdbcService(JdbcService jdbcService) {
        this.jdbcService = jdbcService;
    }
}

3.其他接口信息 

/**
     * 拼接 or in SQL
     * @title
     * @date 2017年5月27日
     * @author niuchuang
     * @param size
     * @param columnName
     * @return
     */
    public static String inStringSqlPrepared(int size, String columnName) {
        StringBuilder codeStB = new StringBuilder();
        double tmp = (double) size / inCount;
        int totalBatch = (int) Math.ceil(tmp);
        for (int i = 1; i <= totalBatch; i++) {
            if (i<totalBatch || size%inCount==0) {
                codeStB.append(" "+columnName+" in (").append(StringUtils.repeat("?,", inCount-1)+"?").append(") or");
            }else{
                codeStB.append(" "+columnName+" in (").append(StringUtils.substringBeforeLast(StringUtils.repeat("?,", size%inCount), ",")).append(")");
            }
        }
        /*
        for (int i = 1; i <= size; i++) {
            codeStB.append(i%inCount==1?" "+columnName+" in (":"").append("?").append(i%inCount==0?") or":i==size?")":",");
        }*/
        if (codeStB.toString().endsWith("or")) {
            codeStB = new StringBuilder(StringUtils.substringBeforeLast(codeStB.toString(), "or"));
        }
        return codeStB.toString();
    }
 
public static double distanceSimplify(Double lat1, Double lng1, Double lat2, Double lng2) {
        if (lat1==null || lng1==null || lat2==null || lng2==null) {
            return 1000000d;
        }else{
            double dx = lng1 - lng2; // 经度差值
            double dy = lat1 - lat2; // 纬度差值
            double b = (lat1 + lat2) / 2.0; // 平均纬度
            double Lx = Math.toRadians(dx) * 6367000.0 * Math.cos(Math.toRadians(b)); // 东西距离
            double Ly = 6367000.0 * Math.toRadians(dy); // 南北距离
            return Math.sqrt(Lx * Lx + Ly * Ly); // 用平面的矩形对角距离公式计算总距离
        }
    }
 
public class DistanceComparator implements Comparator<Map>{
    @Override
    public int compare(Map map, Map t1) {
        double dis1 = MapUtils.getDoubleValue(map, "jl_length");
        double dis2 = MapUtils.getDoubleValue(t1, "jl_length");
        if(dis1 > dis2){
            return 1;
        }else if(dis1 < dis1){
            return -1;
        }
        return 0;
    }
 
}



欣怡
关注
附近的门店功能JAVA版实现
lyzhhh_1985的博客
03-24 2929
文章目录前言一、附近门店功能redis实现mongodb实现总结 前言 最近公司项目需要实现附近的门店功能，通过查询资料发现很多方法都可以实现。 包括Mysql,Redis,Mongodb,PostgreSQL等 其中分别选择了redis和mongodb进行实现。 一、附近门店功能 redis实现 redis4.0.14版本，使用redis自带的geo命令来实现功能。具体的命令详情可参考官方文档 https://redis.io/commands/geoadd 1、引入要使用的jar包，工程是sprin
淘宝卖家订单商品oAuth2.0接口解决方案
weixin_19970108018的博客
08-25 449
为了进行淘宝/天猫平台卖家订单商品oAuth2.0开发，首先我们需要做下面几件事情。 1）注册一个开发者账号 2）然后为每个淘宝应用注册一个应用程序键（App Key) 3）下载淘宝/天猫API的SDK并掌握基本的API基础知识和调用 4）利用SDK接口和对象，传入AppKey或者必要的时候获取并传入SessionKey来进行程序开发。 5）利用淘宝开放平台的文档中心和API测试工具，对接口进行测试。从而了解返回信息，方便程序获取。 6 ) 无需以上五点，可点击注册获取Key和secret 方式一：卖家接口
附近卖家实现1.0
爱兰河少
07-11 267
该接口采用数据库函数读取封装形式 优点：采用ORACLE控件计算函数，距离读取精确，编码简单；缺点：大批量数据（数据达到几十万之后）做附近位置读取时导致数据读取缓慢 实现代码： 1.数据库函数创建： create or replace function get_distance( jd1 number, wd1 number, jd2 number, w
微信公众平台消息接口开发（11）地理位置查询附近商家
weixin_33922670的博客
02-04 392
  一、获取用户地址位置消息 用户发送位置时的消息及格式如下 后台格式： &lt;xml&gt; &lt;ToUserName&gt;&lt;![CDATA[gh_680bdefc8c5d]]&gt;&lt;/ToUserName&gt; &lt;FromUserName&gt;&lt;![CDATA[oIDrpjqASyTPnxRmpS9O_ruZGsfk]]&gt;&lt;...
手机端和Web服务器端计算附近人或商家算法
青年IT男
12-16 155
类似微信的搜索附近的人的功能 在 服务端的实现      前提：根据两个点的经度和纬度计算两点之间的距离，公式见  http://en.wikipedia.org/wiki/Haversine_formula 思路 1）每个用户在服务器端都会保留最后的经度和纬度和时间 查找时，根据当前用户的经度和纬度 对 服务器端 每个用户的经度和纬度 进行计算，有人把上述公式做成mysql 函数放在 sq...
百度搜索附近加盟店等基于LBS云搜索功能的实现
03-04
基于百度LBS的云搜索功能。搜索附近加盟店，或者商家等。可以自定义商家名称，图片，位置等等。功能强大。 详细可见我的博客： http://www.cnblogs.com/shoneworn/p/baidulbs.html
藏经阁-2017双11：交易系统TMF2.0技术揭秘.pdf
08-28
TMF2.0的总体设计原则是Expression Simple Expression Logical Expression，订单商品类目卖家买家"商品" 包含商品标() "99074" and "卖家" 是天猫卖家()item.hasTag(99074) && seller.isBSeller()。 十、热部署配置...
ShopNC多用户商城 V2.0 UTF8.rar
07-07
四、数据导入： 支持淘宝CSV数据的导入功能，方便淘宝卖家迅速入住商城开店经营，替商家节省了时间，为招商降低了门槛。 五、QQ登陆： 留住买家、方便买家是平台增长的核心价值之一，QQ登录为平台注入新活力，降低...
流量优化 流量云平台 v2.0.0.2
11-09
流量云平台v2.0.0.2是一款专为此目的设计的解决方案，旨在帮助电商卖家和网站所有者提高其在线流量的质量和数量。这款工具的核心技术在于其自主开发的浏览器内核和脚本引擎，这两者共同作用，使得平台能够实现对任意...
亚马逊SP-API 2.0 SDK及Seller连接jar包
最新发布
10-11
LWA是基于OAuth 2.0协议的，允许第三方应用安全地获取用户的授权，以便访问亚马逊的特定资源，如卖家账户信息或订单数据。 `sellingpartnerapi-aa-java-2.0.jar`是SP-API 2.0的Java SDK，它包含了一系列的类和方法...
mongodb_整合java_dao,以及用mongodb做附近人,或者是根据经纬多获取附近商家
11-24
mongodb结合java操作数据的代码!以及根据经纬度获取附近的商家,或者是获取附近的人
java实现附近的人功能.zip
07-16
java实现附近的人功能.zipjava实现附近的人功能.zipjava实现附近的人功能.zip
【系统设计】本地生活之附近商家 LBS 服务实现
程序猿周周的博客
11-13 1886
在本章中我们会设计一个系统，用于发现用户附近的一些地方，比如餐厅、酒店、话剧院、博物馆等。
面向对象与闭包综合案例：附近的商家服务与推荐算法
欧阳桫的技术博客
08-20 432
本例结合ES6面向对象语法、设计模式、闭包，完成一个附近商家的自动推荐功能； 案例需求如下： √ 封装一个地理位置类Location，属性x,y， √ 求距离方法：getDistance(anotherLocation)可以计算与另一个地理位置的直线距离 √ 随意造两个地理位置实例，并求它们之间的距离 √ 创建商家类Shop，继承自地理位置类，同时拥有类别属性type、单价属性price，和服务方法serve()，留白等待子类去做具体实现 √ 实现饭馆类Restaurant、超市类Supermarket、
php 微信公众号开发-用百度周边接口找附近的店铺
taotaobaobei的博客
01-17 756
原理：根据微信公众号返回的所在位置+百度经纬度测距离找离自己最近的几个店铺 define("TOKEN", "weixin"); $wechatObj = new wechatCallbackapiTest(); //$wechatObj-&gt;valid(); $wechatObj-&gt;responseMsg(); class wechatCallbackapiTest { publ...
[业务] 关于 "搜索附近几公里的订单/商户" 等业务场景
weixin_33881753的博客
03-31 617
业务背景 在我们平常开发工作中，会遇到如下场景： （1）配送系统需要将一笔订单匹配到附近3公里的骑士 （2）用户需要查看到附近5公里的商户信息 解决思路 方案一：由于我们数据是保存在关系型数据库中的（mysql），因此我们最直观的解决方法便是通过 “纬度与经度每增加0.01度，线性距离便增加1000m” 计算出一批符合规则的经纬度，然后再进行筛选。 double km = 3.0; d...
LBS根据经纬查看附近商家的实现
yianemail的专栏
07-29 7560
现在大多基于地图的应用都有查看附近商家的实现，之前在网上看到别的一些方法，大多是去数据库中查看每条数据库记录的lbs经纬度，然后跟当前经纬度计算距离，在某个范围内的则是周围商家。   数据库记录小还好，如果数据库非常庞大，每条都要做对比，岂不是很耗性能？   地球是圆形，每条纬度不等长。    一 ：如果我们把每条数据库记录lbs信息抽取到一个集合（数组）,然后根据当前位置以及距离（假设周围
Redis Geospatial地理位置
MW
11-24 595
Redis 在 3.2 推出 Geo 类型，该功能可以推算出地理位置信息，两地之间的距离。 文档：https://www.redis.net.cn/order/3687.html 只有六个命令 geoadd：添加地理位置的坐标。 geopos：获取地理位置的坐标。 geodist：计算两个位置之间的距离。 georadius：根据用户给定的经纬度坐标来获取指定范围内的地理位置集合。 georadiusbymember：根据储存在位置集合里面的某个地点获取指定范围内的地理位置集合。 geohash：返回一
redis计算经纬度距离
客官不爱喝酒的博客
02-13 540
注意：redis需要从3.2版本开始才支持。2.游戏查看附件一起玩的人。3.交友app查看附件的人。1.用户查询附近的酒店。
Vue2.0高仿饿了么学习指南：异步数据处理与访问IP优化
开发者需要从JSON文件中读取预设的数据，如卖家信息、商品信息和评级，然后在`webpack.dev.conf.js`中设置API路由。为了使用Vue Resource（Vue 2.x中已弃用，推荐使用axios），需在`main.js`中正确引入，并在dev ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值