精华内容
下载资源
问答
  • WiFi附近人从空气中嗅探无线信号,创新性解决两类问题:一是企业对自己无线路由器上网管控和安全问题。重点解决社交软件聊天内容、加密邮件内容、上网行为和无线注入四大核心
  • 此文章针对去年写的Java基于Redis实现“附近的人 这篇文章进行优化

    此文章是针对去年写的Java基于Redis实现“附近的人 进行业务优化!

    核心源码

    public class NearbyPO {
    	@NotNull(message = "id值不能为空")
    	private Integer id;
    	@NotBlank(message = "名称不能为空")
    	private String name;
    	@NotNull(message = "城市编码不能为空")
    	private Integer cityCode;
    	@NotNull(message = "地区编码不能为空")
    	private Integer adCode;
    	@NotNull(message = "经度不能为空")
    	private Double longitude;
    	@NotNull(message = "纬度不能为空")
    	private Double latitude;
    
    	/**
    	 * 保存时间,不依赖前端传参
    	 */
    	private Long saveTime;
    }
    
    // 附近的人最新版
    public Result<List<NearbyBO>> nearbyNew(NearbyPO paramObj) {
    	// 缓存key值
    	String cacheKey = String.format(NEARBY_CACHE_KEY, paramObj.getCityCode(), paramObj.getAdCode());
    	long currentTimeMillis = System.currentTimeMillis();
    
    	// 设置当前用户缓存时间
    	paramObj.setSaveTime(currentTimeMillis);
    
    	// 使用hash更加快速的定位到用户缓存信息,便于删除更新
    	redisDao.hset(cacheKey, paramObj.getId() + "", JSONObject.toJSONString(paramObj));
    
    	// 从当前地区缓存中获取全部用户(包括用户自己)
    	Map<String, String> cacheAll = redisDao.hGetAll(cacheKey);
    	if (cacheAll.isEmpty() || cacheAll.size() == 1) {
    		return new Result<List<NearbyBO>>(true, new ArrayList<>());
    	}
    
    	// 结果集,-1是要排除用户自己
    	List<NearbyBO> result = new ArrayList<NearbyBO>(cacheAll.size() - 1);
    
    	for (String item : cacheAll.keySet()) {
    		NearbyPO cacheData = JSONObject.parseObject(cacheAll.get(item), NearbyPO.class);
    
    		// 计算缓存时长
    		long twoDayMinute = (cacheData.getSaveTime() - currentTimeMillis) / 60000;
    		// 八小时有效
    		if (twoDayMinute > 480) {
    			// 被动触发删除过期缓存
    			redisDao.hdel(cacheKey, paramObj.getId() + "");
    			continue;
    		}
    		// 排除用户自己
    		if (paramObj.getId().equals(cacheData.getId())) {
    			continue;
    		}
    		// 计算两坐标点距离
    		double distance = countDistance(paramObj.getLongitude(), paramObj.getLatitude(), cacheData.getLongitude(),
    				cacheData.getLatitude());
    		// 10KM之内有效
    		if (distance > 10000) {
    			continue;
    		}
    		result.add(new NearbyBO(cacheData.getId(), cacheData.getName(), distance));
    	}
    	return new Result<List<NearbyBO>>(true, result);
    }
    

    源码下载(资源1分,包含去年的实现源码):https://download.csdn.net/download/qq_19260029/10701010
    ,没有积分的可评论留下邮箱私发。

    测试访问地址:

    1. http://localhost:8080/nearby_new?id=1&name=不羁鱼&cityCode=440300&adCode=440305&longitude=113.9672334290&latitude=22.5829485425
    2. http://localhost:8080/nearby_new?id=2&name=王力宏&cityCode=440300&adCode=440305&longitude=113.9672334290&latitude=22.5229485425

    end

    推荐文章:
    MyBatis基于Spring-boot集成通用Mapper以及pagehelper分页插件
    RedisDesktopManager连接远程Linux系统的Redis服务
    Spring boot基于Redis缓存商城分类,商品信息

    展开全文
  • 附近的人”在社交类APP已成为标配的功能,Low一点的实现方式可以把坐标存至关系型数据库,通过计算的坐标点距离实现,这种计算可行但计算速度远不及内存操作级别的NoSql数据库。基于Redis数据库实现附近的人信息...

    “附近的人”在社交类APP已成为标配的功能,Low一点的实现方式可以把坐标存至关系型数据库,通过计算的坐标点距离实现,这种计算可行但计算速度远不及内存操作级别的NoSql数据库。

    基于Redis数据库实现附近的人信息缓存,服务由Spring-boot框架搭建。

    控制器(Controller)类

    @RestController
    public class Controller {
    
        @Autowired
        private NearbyBiz nearbyBiz;
    
        @RequestMapping
        public String helloWord() {
            return "HelloWord";
        }
    
        // 附近的人
        @RequestMapping(value = "nearby")
        public Result<List<NearbyBO>> nearby(@Valid NearbyPO paramObj) {
            return nearbyBiz.nearby(paramObj);
        }
    }

    业务类

    @Service
    public class NearbyBiz {
    
        /** 2017-09-01 毫秒值/1000 (秒) **/
        private static final int BASE_SORT_NUM = 1504195200;
    
        /** 最大距离 **/
        private static final int MAX_DISTANCE = 3000;
    
        /** 8小时(秒) **/
        private static final int EIGHT_HOUR_SECOND = 60 * 60 * 8;
    
        /** 附近的人缓存key值,p1-城市编号,p2-地区编号 **/
        private static final String NEARBY_CACHE_KEY = "nearby_%s_%s";
    
        /** 附近的人用户缓存key值,p1-城市编号,p2-地区编号,p3-用户id **/
        private static final String NEARBY_USER_CACHE_KEY = "nearby_user_%s_%s_%s";
    
        @Autowired
        private RedisDao redisDao;
    
        // 线程池
        @Autowired
        private ThreadPoolTaskExecutor threadPoolTaskExecutor;
    
        // 附近的人
        public Result<List<NearbyBO>> nearby(NearbyPO paramObj) {
            int nowSortNum = (int) (new Date().getTime() / 1000);
            // 此处仅为了减低排序的序号( 获取缓存集合最大排序下标)
            int endIndex = nowSortNum - BASE_SORT_NUM;
    
            // 缓存key值
            String cacheKey = String.format(NEARBY_CACHE_KEY, paramObj.getCityCode(), paramObj.getAdCode());
    
            // 取同一城市地区&&八小时区间范围数据(八小时之前缓存数据会删除)
            Set<String> redisNearby = redisDao.getSetByKeyAndScore(cacheKey, endIndex - EIGHT_HOUR_SECOND, endIndex);
    
            // 开启新线程写入数据(让主线程“专心”处理主业务)
            threadPoolTaskExecutor.execute(new InsertCache(paramObj, cacheKey, endIndex));
    
            if (redisNearby.size() == 0)
                return new Result<List<NearbyBO>>(false, "附近查无用户", null);
    
            List<NearbyBO> result = new ArrayList<NearbyBO>(redisNearby.size());
            boolean oneself = true;
            for (String item : redisNearby) {
                NearbyPO cacheNearby = JSONObject.parseObject(item, NearbyPO.class);
                // 缓存里可能有用户自己
                if (cacheNearby.getId().intValue() == paramObj.getId())
                    continue;
                double distance = countDistance(paramObj.getLongitude(), paramObj.getLatitude(), cacheNearby.getLongitude(),
                        cacheNearby.getLatitude());
                // 大于限定距离
                if (distance > MAX_DISTANCE)
                    continue;
                result.add(new NearbyBO(cacheNearby.getId(), cacheNearby.getName(), distance));
                oneself = false;
            }
            if (oneself)
                return new Result<List<NearbyBO>>(false, "附近查无用户", null);
            return new Result<List<NearbyBO>>(true, "获取成功", result);
        }
    
        // 把用户定位信息写入缓存
        private class InsertCache implements Runnable {
            // 用户提交的最新坐标信息
            private NearbyPO paramObj;
            // “附近的人”缓存集合key
            private String cacheKey;
            // 获取缓存集合最大排序下标
            private Integer endIndex;
    
            public InsertCache(NearbyPO paramObj, String cacheKey, Integer endIndex) {
                this.paramObj = paramObj;
                this.cacheKey = cacheKey;
                this.endIndex = endIndex;
            }
    
            @Override
            public void run() {
                String userCacheKey = String.format(NEARBY_USER_CACHE_KEY, paramObj.getCityCode(), paramObj.getAdCode(),
                        paramObj.getId());
                String cacheNewData = JSONObject.toJSONString(paramObj);
                String cacheUserPosition = redisDao.getOneStringByKey(userCacheKey);
                // 确保用户坐标信息缓存清除慢于“附近的人”坐标信息
                redisDao.setOneStringByKey(userCacheKey, cacheNewData, EIGHT_HOUR_SECOND + 60);
    
                // 保存用户坐标信息至“附近的人”缓存集合
                redisDao.addOneStringToZSet(cacheKey, cacheNewData, cacheUserPosition, endIndex);
            }
    
        }
    
        /**
         * 计算两经纬度点之间的距离(单位:米)
         * 
         * @param longitude1
         *            坐标1经度
         * @param latitude1
         *            坐标1纬度
         * @param longitude2
         *            坐标2经度
         * @param latitude2
         *            坐标1纬度
         * @return
         */
        private static double countDistance(double longitude1, double latitude1, double longitude2, double latitude2) {
            double radLat1 = Math.toRadians(latitude1);
            double radLat2 = Math.toRadians(latitude2);
            double a = radLat1 - radLat2;
            double b = Math.toRadians(longitude1) - Math.toRadians(longitude2);
            double s = 2 * Math.asin(Math.sqrt(
                    Math.pow(Math.sin(a / 2), 2) + Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)));
            s = s * 6378137.0;
            s = Math.round(s * 10000) / 10000;
            return s;
        }
    }

    Redis接口类

    public interface RedisDao {
    
        /**
         * 
         * 根据key值获取String
         * 
         * @param key
         * @return
         */
        public String getOneStringByKey(String key);
    
        /**
         * 
         * 缓存一个String
         * 
         * @param key
         * @param value
         * @param timeoutSeconds
         */
        public void setOneStringByKey(String key, String value, int timeoutSeconds);
    
        /**
         * 在获取元素下标区间之外的元素会被删除
         * 
         * @param key
         * @param beginScore
         *            获取元素的排序开始下标
         * @param endScore
         *            获取元素的排序结束下标
         * @return 指定排序下标范围内的元素
         */
        public Set<String> getSetByKeyAndScore(String key, int beginScore, int endScore);
    
        /**
         * 
         * @param key
         * @param newVal
         *            新值
         * @param oldVal
         *            旧值(非空则删除元素)
         * @param score
         *            排序(使用时间基准值来判断是否删除元素)
         */
        public void addOneStringToZSet(String key, String newVal, String oldVal, double score);
    
    }

    Redis实现类

    @Repository
    public class RedisDaoImpl implements RedisDao {
    
        @Autowired
        protected RedisTemplate<String, String> redisTemplate;
    
        @Override
        public String getOneStringByKey(String key) {
            return redisTemplate.opsForValue().get(key);
        }
    
        @Override
        public void setOneStringByKey(String key, String value, int timeoutSeconds) {
            redisTemplate.opsForValue().set(key, value, timeoutSeconds, TimeUnit.SECONDS);
        }
    
        @Override
        public Set<String> getSetByKeyAndScore(String key, int beginScore, int endScore) {
            redisTemplate.opsForZSet().removeRangeByScore(key, 1, beginScore - 1);
            return redisTemplate.opsForZSet().rangeByScore(key, beginScore, endScore);
        }
    
        @Override
        public void addOneStringToZSet(String key, String newVal, String oldVal, double score) {
            if (oldVal != null)
                redisTemplate.opsForZSet().remove(key, oldVal);
            redisTemplate.opsForZSet().add(key, newVal, score);
        }
    }

    入参类(省略get,set方法)

    public class NearbyPO {
        @NotNull(message = "id值不能为空")
        private Integer id;
        @NotBlank(message = "名称不能为空")
        private String name;
        @NotNull(message = "城市编码不能为空")
        private Integer cityCode;
        @NotNull(message = "地区编码不能为空")
        private Integer adCode;
        @NotNull(message = "经度不能为空")
        private Double longitude;
        @NotNull(message = "纬度不能为空")
        private Double latitude;
    }

    出参类(省略get,set方法)

    public class NearbyBO {
        //用户id
        private Integer id;
        //用户名称
        private String name;
        //距离
        private Double distance;
    }

    出参统一封装类(省略get,set方法)

    public class Result<T> {
        private boolean success = true;
        private String msg = "";
        private T data = null;
    
        public Result() {
            super();
        }
    
        public Result(boolean success) {
            super();
            this.success = success;
        }
    
        public Result(boolean success, T data) {
            super();
            this.success = success;
            this.data = data;
        }
    
        public Result(boolean success, String msg, T data) {
            super();
            this.success = success;
            this.msg = msg;
            this.data = data;
        }
    }

    参考数据

    深圳市cityCode:440300
    深圳市-福田区adCode:440304
    深圳市-南山区adCode:440305

    1号用户在深圳南山区定位

    http://localhost:8080/nearby?id=1&name=1号用户&cityCode=440300&adCode=440305&longitude=113.9572334290&latitude=22.5829485425

    Redis缓存
    1

    把1号用户定位信息缓存至“深圳市-南山区”附近的人集合(nearby_440300_440305【固定前缀+城市编号+区编号】),并保存用户当前的定位信息(TTL为8小时+60秒,有效保存用户最新定位信息的同时设置了过期时间,为缓存数据库的过期数据提供支持)

    请求结果

    {"success":false,"msg":"附近查无用户","data":null}

    当前深圳市南山区只有1号用户使用附近的人,所以查无用户

    2号用户在深圳南山区定位

    http://localhost:8080/nearby?id=2&name=2号用户&cityCode=440300&adCode=440305&longitude=113.9582334290&latitude=22.5829485425

    Redis缓存
    2

    把2号用户定位信息追加至“深圳市-南山区”附近的人集合,并保存2号用户当前的定位信息

    请求结果

    {"success":true,"msg":"获取成功","data":[{"id":1,"name":"1号用户","distance":102.0}]}

    匹配到1号用户,距离为102米

    1号用户在深圳福田区定位

    http://localhost:8080/nearby?id=1&name=1号用户&cityCode=440300&adCode=440304&longitude=114.0180015564&latitude=22.5471230766

    Redis缓存
    这里写图片描述

    把1号用户定位信息缓存至“深圳市-福田区”附近的人集合,并保存1号用户在福田区的定位信息;不影响1号用户在南山区附近的人缓存信息

    请求结果

    {"success":false,"msg":"附近查无用户","data":null}

    福田区当前只有1号用户定位,所以查无附近的人

    1号用户在深圳南山区再次定位请求

    http://localhost:8080/nearby?id=1&name=1号用户&cityCode=440300&adCode=440305&longitude=113.9572334290&latitude=22.5829485425

    Redis缓存
    这里写图片描述

    1号用户在南山区重新定位,刷新定位信息(nearby_user_440300_440305_1【固定前缀+城市编号+区编号+用户id】)

    请求结果

    {"success":true,"msg":"获取成功","data":[{"id":2,"name":"2号用户","distance":102.0}]}}

    2号用户附近的人定位信息并没过期(缓存8小时),附近的人匹配到2号用户

    深圳南山区“附近的人”集合Redis缓存信息
    5

    项目源码下载(3分)http://download.csdn.net/download/qq_19260029/9976148

    更多文章:
    Spring boot基于Redis缓存商城分类,商品信息
    Eclipse新建Spring-boot项目,打包部署并输出HelloWord

    展开全文
  • 附近的人功能

    2014-03-31 20:05:55
    越来越多的Android应用都加入了“附近的人”的功能,比如微信、陌陌、淘宝等,今天分享一个demo,简单的来实现这一功能。主要原理为:手机端上传gps数据到服务器,服务器从数据库中查询其他用户的gps数据,分别计算2...

    越来越多的Android应用都加入了“附近的人”的功能,比如微信、陌陌、淘宝等,今天分享一个demo,简单的来实现这一功能。主要原理为:手机端上传gps数据到服务器,服务器从数据库中查询其他用户的gps数据,分别计算2个pgs之间的距离,然后将计算好的数据返回给手机,手机进行展示。

    源码下载地址: https://github.com/feicien/studydemo
    手机端项目:NearByDemo
    服务器端项目:NearbyServerDemo

    手机端代码讲解:
    MainActivity是项目的入口Activity

    1
    2
    3
    4
    5
    6
    7
    8
    9
    @Override
    protected void onCreate(Bundle savedInstanceState) {
          boolean first = getSharedPreferences( "userinfo", Context.MODE_PRIVATE ).getBoolean( "first", false);
          if (!first) {
                    Intent intent = new Intent( this, LoginActivity.class );
                    startActivity(intent);
          }
              ....
         }
    

    查看附近的人,是需要使用用户信息的,因此在OnCreate方法中先判断用户是不是第一次打开应用,如果是第一次打开应用,跳转到LoginActivity,进行用户信息登记:
    用户信息登记

    之后便进入MainActivity:
    主界面

    点击ActionBar上的附近的人,便会显示从服务器获取到的用户信息(目前服务器是把所有用户信息全部返回):
    附近的人列表

    请求网络使用的是Google在IO大会上才推出的Volley.

    服务器端是使用Java web编写的。在这里不详细介绍了。计算距离的逻辑是从Android的提供的接口(Location.distanceBetween)中拔来的,应该是最精确的方法了

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    public static double computeDistance(double lat1, double lon1,
                 double lat2, double lon2) {
                 // Based on http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf
                 // using the "Inverse Formula" (section 4)
    
                 int MAXITERS = 20;
                 // Convert lat/long to radians
                 lat1 *= Math.PI / 180.0;
                 lat2 *= Math.PI / 180.0;
                 lon1 *= Math.PI / 180.0;
                 lon2 *= Math.PI / 180.0;
    
                 double a = 6378137.0; // WGS84 major axis
                 double b = 6356752.3142; // WGS84 semi-major axis
                 double f = (a - b) / a;
                 double aSqMinusBSqOverBSq = (a * a - b * b) / (b * b);
    
                 double L = lon2 - lon1;
                 double A = 0.0;
                 double U1 = Math.atan((1.0 - f) * Math.tan(lat1));
                 double U2 = Math.atan((1.0 - f) * Math.tan(lat2));
    
                 double cosU1 = Math.cos(U1);
                 double cosU2 = Math.cos(U2);
                 double sinU1 = Math.sin(U1);
                 double sinU2 = Math.sin(U2);
                 double cosU1cosU2 = cosU1 * cosU2;
                 double sinU1sinU2 = sinU1 * sinU2;
    
                 double sigma = 0.0;
                 double deltaSigma = 0.0;
                 double cosSqAlpha = 0.0;
                 double cos2SM = 0.0;
                 double cosSigma = 0.0;
                 double sinSigma = 0.0;
                 double cosLambda = 0.0;
                 double sinLambda = 0.0;
    
                 double lambda = L; // initial guess
                 for (int iter = 0; iter < MAXITERS; iter++) {
                     double lambdaOrig = lambda;
                     cosLambda = Math.cos(lambda);
                     sinLambda = Math.sin(lambda);
                     double t1 = cosU2 * sinLambda;
                     double t2 = cosU1 * sinU2 - sinU1 * cosU2 * cosLambda;
                     double sinSqSigma = t1 * t1 + t2 * t2; // (14)
                     sinSigma = Math.sqrt(sinSqSigma);
                     cosSigma = sinU1sinU2 + cosU1cosU2 * cosLambda; // (15)
                     sigma = Math.atan2(sinSigma, cosSigma); // (16)
                     double sinAlpha = (sinSigma == 0) ? 0.0 :
                         cosU1cosU2 * sinLambda / sinSigma; // (17)
                     cosSqAlpha = 1.0 - sinAlpha * sinAlpha;
                     cos2SM = (cosSqAlpha == 0) ? 0.0 :
                         cosSigma - 2.0 * sinU1sinU2 / cosSqAlpha; // (18)
    
                     double uSquared = cosSqAlpha * aSqMinusBSqOverBSq; // defn
                     A = 1 + (uSquared / 16384.0) * // (3)
                         (4096.0 + uSquared *
                          (-768 + uSquared * (320.0 - 175.0 * uSquared)));
                     double B = (uSquared / 1024.0) * // (4)
                         (256.0 + uSquared *
                          (-128.0 + uSquared * (74.0 - 47.0 * uSquared)));
                     double C = (f / 16.0) *
                         cosSqAlpha *
                         (4.0 + f * (4.0 - 3.0 * cosSqAlpha)); // (10)
                     double cos2SMSq = cos2SM * cos2SM;
                     deltaSigma = B * sinSigma * // (6)
                         (cos2SM + (B / 4.0) *
                          (cosSigma * (-1.0 + 2.0 * cos2SMSq) -
                           (B / 6.0) * cos2SM *
                           (-3.0 + 4.0 * sinSigma * sinSigma) *
                           (-3.0 + 4.0 * cos2SMSq)));
    
                     lambda = L +
                         (1.0 - C) * f * sinAlpha *
                         (sigma + C * sinSigma *
                          (cos2SM + C * cosSigma *
                           (-1.0 + 2.0 * cos2SM * cos2SM))); // (11)
    
                     double delta = (lambda - lambdaOrig) / lambda;
                     if (Math.abs(delta) < 1.0e-12) {
                         break;
                     }
                 }
    
                 return  b * A * (sigma - deltaSigma);
    }
    

    下面再提供了一种更简单的方法(感谢@L给未来的自己)

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    public static double getDistance(double lat1,double longt1 , double lat2,double longt2
                ) {
            double PI = 3.14159265358979323; // 圆周率
            double R = 6371229; // 地球的半径
    
            double x, y, distance;
            x = (longt2 - longt1) * PI * R
                    * Math.cos(((lat1 + lat2) / 2) * PI / 180) / 180;
            y = (lat2 - lat1) * PI * R / 180;
            distance = Math.hypot(x, y);
    
            return distance;
        }
    

    这里是把地球当成圆球来处理的

    1
    2
    3
    4
    5
    System.out.println(getDistance(34.8082342, 113.6125439, 34.8002478, 113.659779));
    System.out.println(computeDistance(34.8082342, 113.6125439, 34.8002478, 113.659779));
    
    4403.3428631300785
    4412.121706417052
    

    经过测试,对于4千米的2点,相差为10米左右,误差是可以接受的,因此推荐使用该方法。

    声明:eoe文章著作权属于作者,受法律保护,转载时请务必以超链接形式附带如下信息

    原文作者: 灰尘

    原文地址: http://my.eoe.cn/isnull/archive/4846.html

    展开全文
  • 电脑版微信bluestacks安装详细教程 微信摇一摇 自动打招呼 QQ全自动附近的人打招呼软件下载地址合集
  • 不多说,就这尾箱体验,已经能让想起诗和远方感觉了。胶着中,轩辕奖评审团回到最初贾可建议,就是否支持两个大奖再进行一次投票。消费者逐渐也开始认同500公里以上高续航里程电动车。此外,该车采用...

    电动车一直是欧洲车市的亮点,彭博预测,2020年第四季度,电动车销量(包括混动、插电式混动和纯电动车)将首次超过柴油车。

    ·电动博士智能机器人导购,自动讲解产品和技术。

    别的不多说,就这尾箱的体验,已经能让人想起诗和远方的感觉了。

    胶着中,轩辕奖评审团回到最初贾可建议,就是否支持两个大奖再进行一次投票。

    消费者逐渐也开始认同500公里以上的高续航里程的电动车。

    此外,该车采用了双边双出的排气布局,并用镀铬饰件装饰,兼具运动、时尚感。

    3林肯的下一步可能陈安宁很清楚,如今林肯的变化早就不是销量数字的突变或者是产品快速赋能那么简单了。

    高端化挑战向高端化迈进,是中国汽车企业共同的目标。

    随后他又表示,如果所有汽车都变成电动汽车,那么日本到夏天时将发生电力短缺的情况。

    第三个方面,面对起飞的中国,福特必须要有原汁原味的创新能力,这就出现了创新中心等一系列举措。

    现款回旋镖尾灯也被取消,整体看起来中规中矩,没有现款车型那么激进了。

    展开全文无线充电生态系统中许多参与者的目标是建立一个标准。

    特别是经历了2020年后,我们深刻的理解到,我们必须对企业自我生存有足够危机感,需要深刻的思考和讨论,准备应对的计划和办法。

    赛马机制是提高内部产品成功概率的有效手段,在国内很多互联网公司都存在。

    展开全文
  • 最新版微信 QQ附近的人自动打招呼,保证无毒,下载完成按文件里的步骤安装,否则无法正常运行,如果出现无法授权,请仔细看文件里的说明。请勿用于商业目的 后果自负!
  • ( 电脑版微信bluestacks安装详细教程+微信摇一摇+自动打招呼+QQ全自动附近的人打招呼软件下载地址合集
  • 文件名称: map下载 收藏√ [5 4 3 2 1]开发工具: Java文件大小: 7427 KB上传时间: 2016-08-12下载次数: 0提 供 者: Jack详细说明:百度地图定位,显示周围的人,类似于E代驾的首页效果-Baidu map positioning, ...
  • 越来越多的Android应用都加入了“附近的人”的功能,比如微信、陌陌、淘宝等,今天分享一个demo,简单的来实现这一功能。主要原理为:手机端上传gps数据到服务器,服务器从数据库中查询其他用户的gps数据,分别计算2...
  • 1. 要实现"附近的人" 这功能,然后就研究了下: (1)首先要做的就是要获取到自己当前位置的经纬度(编程获取手机GPS定位模块的信息,进而获取自己当前位置的经纬度) (2)然后就是上传自己的数据给服务器 (3)...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 231
精华内容 92
关键字:

下载附近的人