类似滴滴打车，多辆小车在地图上平滑移动的实现，基于百度地图实现（轨迹已画好）

最新推荐文章于 2023-06-17 13:19:40 发布
最新推荐文章于 2023-06-17 13:19:40 发布
阅读量5.8k 收藏 11
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30651537/article/details/53258797
版权

参考百度地图demo：轨迹运行demo展示，类名TrackShowDemo。百度TrackShowDemo类里只实现了一个完整的轨迹运行，并且是将所有的经纬点放在一个数组里，我觉得直接放在一个List集合里更好点。

先看一下完整的百度demo

/*
 * Copyright (C) 2016 Baidu, Inc. All Rights Reserved.
 */
package baidumapsdk.demo.map;

import android.app.Activity;
import android.graphics.Color;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;

import com.baidu.mapapi.map.BaiduMap;
import com.baidu.mapapi.map.BitmapDescriptorFactory;
import com.baidu.mapapi.map.MapStatus;
import com.baidu.mapapi.map.MapStatusUpdateFactory;
import com.baidu.mapapi.map.MapView;
import com.baidu.mapapi.map.Marker;
import com.baidu.mapapi.map.MarkerOptions;
import com.baidu.mapapi.map.OverlayOptions;
import com.baidu.mapapi.map.Polyline;
import com.baidu.mapapi.map.PolylineOptions;
import com.baidu.mapapi.model.LatLng;

import java.util.ArrayList;
import java.util.List;

import baidumapsdk.demo.R;

/**
 * 轨迹运行demo展示
 */
public class TrackShowDemo extends Activity {
    private MapView mMapView;
    private BaiduMap mBaiduMap;
    private Polyline mPolyline;
    private Marker mMoveMarker;
    private Handler mHandler;


    // 通过设置间隔时间和距离可以控制速度和图标移动的距离
    private static final int TIME_INTERVAL = 80;
    private static final double DISTANCE = 0.00002;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mMapView = (MapView) findViewById(R.id.bmapView);
        mMapView.onCreate(this, savedInstanceState);
        mBaiduMap = mMapView.getMap();
        MapStatus.Builder builder = new MapStatus.Builder();
        builder.target(new LatLng(40.056865, 116.307766));
        builder.zoom(19.0f);
        mBaiduMap.setMapStatus(MapStatusUpdateFactory.newMapStatus(builder.build()));
        mHandler = new Handler(Looper.getMainLooper());
        drawPolyLine();
        moveLooper();
    }

    private void drawPolyLine() {

        List<LatLng> polylines = new ArrayList<LatLng>();
        for (int index = 0; index < latlngs.length; index++) {
            polylines.add(latlngs[index]);
        }

        polylines.add(latlngs[0]);
        PolylineOptions polylineOptions = new PolylineOptions().points(polylines).width(10).color(Color.RED);

        mPolyline = (Polyline) mBaiduMap.addOverlay(polylineOptions);
        OverlayOptions markerOptions;
        markerOptions = new MarkerOptions().flat(true).anchor(0.5f, 0.5f)
                .icon(BitmapDescriptorFactory.fromResource(R.drawable.arrow)).position(polylines.get(0))
                .rotate((float) getAngle(0));
        mMoveMarker = (Marker) mBaiduMap.addOverlay(markerOptions);

    }

    /**
     * 根据点获取图标转的角度
     */
    private double getAngle(int startIndex) {
        if ((startIndex + 1) >= mPolyline.getPoints().size()) {
            throw new RuntimeException("index out of bonds");
        }
        LatLng startPoint = mPolyline.getPoints().get(startIndex);
        LatLng endPoint = mPolyline.getPoints().get(startIndex + 1);
        return getAngle(startPoint, endPoint);
    }

    /**
     * 根据两点算取图标转的角度
     */
    private double getAngle(LatLng fromPoint, LatLng toPoint) {
        double slope = getSlope(fromPoint, toPoint);
        if (slope == Double.MAX_VALUE) {
            if (toPoint.latitude > fromPoint.latitude) {
                return 0;
            } else {
                return 180;
            }
        }
        float deltAngle = 0;
        if ((toPoint.latitude - fromPoint.latitude) * slope < 0) {
            deltAngle = 180;
        }
        double radio = Math.atan(slope);
        double angle = 180 * (radio / Math.PI) + deltAngle - 90;
        return angle;
    }

    /**
     * 根据点和斜率算取截距
     */
    private double getInterception(double slope, LatLng point) {

        double interception = point.latitude - slope * point.longitude;
        return interception;
    }

    /**
     * 算斜率
     */
    private double getSlope(LatLng fromPoint, LatLng toPoint) {
        if (toPoint.longitude == fromPoint.longitude) {
            return Double.MAX_VALUE;
        }
        double slope = ((toPoint.latitude - fromPoint.latitude) / (toPoint.longitude - fromPoint.longitude));
        return slope;

    }

    @Override
    protected void onResume() {
        super.onResume();
        mMapView.onResume();
    }

    @Override
    protected void onPause() {
        super.onPause();
        mMapView.onPause();
    }


    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        mMapView.onSaveInstanceState(outState);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mMapView.onDestroy();
        mBaiduMap.clear();
    }

    /**
     * 计算x方向每次移动的距离
     */
    private double getXMoveDistance(double slope) {
        if (slope == Double.MAX_VALUE) {
            return DISTANCE;
        }
        return Math.abs((DISTANCE * slope) / Math.sqrt(1 + slope * slope));
    }

    /**
     * 循环进行移动逻辑
     */
    public void moveLooper() {
        new Thread() {

            public void run() {

                while (true) {

                    for (int i = 0; i < latlngs.length - 1; i++) {


                        final LatLng startPoint = latlngs[i];
                        final LatLng endPoint = latlngs[i + 1];
                        mMoveMarker
                                .setPosition(startPoint);

                        mHandler.post(new Runnable() {
                            @Override
                            public void run() {
                                // refresh marker's rotate
                                if (mMapView == null) {
                                    return;
                                }
                                mMoveMarker.setRotate((float) getAngle(startPoint,
                                        endPoint));
                            }
                        });
                        double slope = getSlope(startPoint, endPoint);
                        // 是不是正向的标示
                        boolean isReverse = (startPoint.latitude > endPoint.latitude);

                        double intercept = getInterception(slope, startPoint);

                        double xMoveDistance = isReverse ? getXMoveDistance(slope) : -1 * getXMoveDistance(slope);


                        for (double j = startPoint.latitude; !((j > endPoint.latitude) ^ isReverse);
                             j = j - xMoveDistance) {
                            LatLng latLng = null;
                            if (slope == Double.MAX_VALUE) {
                                latLng = new LatLng(j, startPoint.longitude);
                            } else {
                                latLng = new LatLng(j, (j - intercept) / slope);
                            }

                            final LatLng finalLatLng = latLng;
                            mHandler.post(new Runnable() {
                                @Override
                                public void run() {
                                    if (mMapView == null) {
                                        return;
                                    }
                                    mMoveMarker.setPosition(finalLatLng);
                                }
                            });
                            try {
                                Thread.sleep(TIME_INTERVAL);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }

                    }
                }
            }

        }.start();
    }

    private static final LatLng[] latlngs = new LatLng[] {
            new LatLng(40.055826, 116.307917),
            new LatLng(40.055916, 116.308455),
            new LatLng(40.055967, 116.308549),
            new LatLng(40.056014, 116.308574),
            new LatLng(40.056440, 116.308485),
            new LatLng(40.056816, 116.308352),
            new LatLng(40.057997, 116.307725),
            new LatLng(40.058022, 116.307693),
            new LatLng(40.058029, 116.307590),
            new LatLng(40.057913, 116.307119),
            new LatLng(40.057850, 116.306945),
            new LatLng(40.057756, 116.306915),
            new LatLng(40.057225, 116.307164),
            new LatLng(40.056134, 116.307546),
            new LatLng(40.055879, 116.307636),
            new LatLng(40.055826, 116.307697),
    };

}

改造后的：

package com.xpro.ibusalmoner.activity;

import java.util.ArrayList;
import java.util.List;

import android.app.Activity;
import android.graphics.Color;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;

import com.baidu.mapapi.SDKInitializer;
import com.baidu.mapapi.map.BaiduMap;
import com.baidu.mapapi.map.BitmapDescriptorFactory;
import com.baidu.mapapi.map.MapStatus;
import com.baidu.mapapi.map.MapStatusUpdateFactory;
import com.baidu.mapapi.map.MapView;
import com.baidu.mapapi.map.Marker;
import com.baidu.mapapi.map.MarkerOptions;
import com.baidu.mapapi.map.OverlayOptions;
import com.baidu.mapapi.map.Polyline;
import com.baidu.mapapi.map.PolylineOptions;
import com.baidu.mapapi.model.LatLng;
import com.xpro.ibusalmoner.R;

/**
 * 轨迹运行demo展示
 */
public class SeeMapActivity extends Activity {
    private MapView mMapView;
    private BaiduMap mBaiduMap;
    private Polyline mPolyline;
//    private Marker mMoveMarker;
    private Handler mHandler;
    
    private List<List<LatLng>> tuoche;
    private List<LatLng> latlngs1;//拖车1经纬度集合
    private List<LatLng> latlngs2;//拖车2经纬度集合
    
    // 通过设置间隔时间和距离可以控制速度和图标移动的距离
    private static final int TIME_INTERVAL = 80;
    private static final double DISTANCE = 0.00009;
//    private static final double DISTANCE = 0.00002;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        SDKInitializer.initialize(getApplicationContext());
        setContentView(R.layout.activity_seemap);
        mMapView = (MapView) findViewById(R.id.bmapView);
        mBaiduMap = mMapView.getMap();
        MapStatus.Builder builder = new MapStatus.Builder();
        builder.target(new LatLng(31.9695208489,118.7736524881));//故障车当前位置
        builder.zoom(19.0f);
        mBaiduMap.setMapStatus(MapStatusUpdateFactory.newMapStatus(builder.build()));
        mHandler = new Handler(Looper.getMainLooper());
        
        initData();
        
        for(int i=0;i<tuoche.size();i++){
        	drawPolyLine(tuoche.get(i));
//        	moveLooper(tuoche.get(i));
        }
    }

    private void drawPolyLine(List<LatLng> polylines) {

    			polylines.add(polylines.get(0));//将轨迹连成一个完整的环形
    	
	            PolylineOptions polylineOptions = new PolylineOptions().points(polylines).width(10).color(Color.RED);
	            mPolyline = (Polyline) mBaiduMap.addOverlay(polylineOptions);
	            OverlayOptions markerOptions;
	            markerOptions = new MarkerOptions().flat(true).anchor(0.5f, 0.5f)
	                    .icon(BitmapDescriptorFactory.fromResource(R.drawable.arrow)).position(polylines.get(0))
	                    .rotate((float) getAngle(0));
	            
	            //mMoveMarker局部变量，一辆小车一个移动箭头
	            Marker mMoveMarker = (Marker) mBaiduMap.addOverlay(markerOptions);
	            
	            moveLooper(polylines,mMoveMarker);
    }

    /**
     * 循环进行移动逻辑
     */
    public void moveLooper(final List<LatLng> polylines,final Marker mMoveMarker) {
    		new Thread() {
                public void run() {
                    while (true) {
                        for (int i = 0; i < polylines.size() - 1; i++) {
                            final LatLng startPoint = polylines.get(i);
                            final LatLng endPoint = polylines.get(i+1);
                            Log.e("--", startPoint.latitude+"/"+startPoint.longitude);
                            mMoveMarker.setPosition(startPoint);
                            mHandler.post(new Runnable() {
                                @Override
                                public void run() {
                                    // refresh marker's rotate
                                    if (mMapView == null) {
                                        return;
                                    }
                                    mMoveMarker.setRotate((float) getAngle(startPoint,
                                            endPoint));
                                }
                            });
                            double slope = getSlope(startPoint, endPoint);
                            // 是不是正向的标示
                            boolean isReverse = (startPoint.latitude > endPoint.latitude);

                            double intercept = getInterception(slope, startPoint);

                            double xMoveDistance = isReverse ? getXMoveDistance(slope) : -1 * getXMoveDistance(slope);


                            for (double j = startPoint.latitude; !((j > endPoint.latitude) ^ isReverse);
                                 j = j - xMoveDistance) {
                                LatLng latLng = null;
                                if (slope == Double.MAX_VALUE) {
                                    latLng = new LatLng(j, startPoint.longitude);
                                } else {
                                    latLng = new LatLng(j, (j - intercept) / slope);
                                }

                                final LatLng finalLatLng = latLng;
                                mHandler.post(new Runnable() {
                                    @Override
                                    public void run() {
                                        if (mMapView == null) {
                                            return;
                                        }
                                        mMoveMarker.setPosition(finalLatLng);//走完一圈回到起点
                                    }
                                });
                                try {
                                    Thread.sleep(TIME_INTERVAL);
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                            }

                        }
                    }
                }

            }.start();
    }

    //拖车经纬度集合
    public void initData(){
    	
    	tuoche=new ArrayList<List<LatLng>>();
    	latlngs1=new ArrayList<LatLng>(); //第一辆车经纬度集合
    	latlngs2=new ArrayList<LatLng>();//第二辆车经纬度集合
    	
    	latlngs1.add(new LatLng(31.9697048489,118.7748744881));
    	latlngs1.add(new LatLng(31.9702354581,118.7747304881));
    	latlngs1.add(new LatLng(31.9874731546,118.7744525592));
    	latlngs1.add(new LatLng(31.9961700713,118.7757586264));
    	latlngs1.add(new LatLng(32.0048694174,118.7774854183));
    	latlngs1.add(new LatLng(32.0037307114,118.7824144492));
    	latlngs1.add(new LatLng(31.9962609086,118.7872986406));
    	latlngs1.add(new LatLng(31.9944540133,118.7914938260));
    	latlngs1.add(new LatLng(31.9906570133,118.7968118260));
    	
    	latlngs2.add(new LatLng(31.9733642960,118.7662912632));
    	latlngs2.add(new LatLng(31.9735350000,118.7557740000));
    	latlngs2.add(new LatLng(31.9714564110,118.7504893514));
    	latlngs2.add(new LatLng(31.9755604110,118.7513513514));
    	latlngs2.add(new LatLng(31.9767854110,118.7518543514));
    	latlngs2.add(new LatLng(31.9776434110,118.7491953514));
    	latlngs2.add(new LatLng(31.9812311339,118.7433553933));
    	
    	tuoche.add(latlngs1);
    	tuoche.add(latlngs2);
    }
    
    /**
     * 根据点获取图标转的角度
     */
    private double getAngle(int startIndex) {
        if ((startIndex + 1) >= mPolyline.getPoints().size()) {
            throw new RuntimeException("index out of bonds");
        }
        LatLng startPoint = mPolyline.getPoints().get(startIndex);
        LatLng endPoint = mPolyline.getPoints().get(startIndex + 1);
        return getAngle(startPoint, endPoint);
    }

    /**
     * 根据两点算取图标转的角度
     */
    private double getAngle(LatLng fromPoint, LatLng toPoint) {
        double slope = getSlope(fromPoint, toPoint);
        if (slope == Double.MAX_VALUE) {
            if (toPoint.latitude > fromPoint.latitude) {
                return 0;
            } else {
                return 180;
            }
        }
        float deltAngle = 0;
        if ((toPoint.latitude - fromPoint.latitude) * slope < 0) {
            deltAngle = 180;
        }
        double radio = Math.atan(slope);
        double angle = 180 * (radio / Math.PI) + deltAngle - 90;
        return angle;
    }

    /**
     * 根据点和斜率算取截距
     */
    private double getInterception(double slope, LatLng point) {

        double interception = point.latitude - slope * point.longitude;
        return interception;
    }

    /**
     * 算斜率
     */
    private double getSlope(LatLng fromPoint, LatLng toPoint) {
        if (toPoint.longitude == fromPoint.longitude) {
            return Double.MAX_VALUE;
        }
        double slope = ((toPoint.latitude - fromPoint.latitude) / (toPoint.longitude - fromPoint.longitude));
        return slope;

    }

    @Override
    protected void onResume() {
        super.onResume();
        mMapView.onResume();
    }

    @Override
    protected void onPause() {
        super.onPause();
        mMapView.onPause();
    }


    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
//        mMapView.onSaveInstanceState(outState);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mMapView.onDestroy();
        mBaiduMap.clear();
    }

    /**
     * 计算x方向每次移动的距离
     */
    private double getXMoveDistance(double slope) {
        if (slope == Double.MAX_VALUE) {
            return DISTANCE;
        }
        return Math.abs((DISTANCE * slope) / Math.sqrt(1 + slope * slope));
    }
    
}


资源与“类似滴滴打车，多辆小车在地图上平滑移动的实现，基于百度地图实现（无轨迹）”文章资源相同，只需下载一份就好。

代码传送门



qq_30651537
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
实现GPS一辆或多辆小车在百度地图上显示驾驶路线
KimHoooooooo
07-06 6889
通过百度地图API实现一辆车或多辆车在地图上行驶，实现车辆监控，并显示驾驶路线。效果图如下： 本demo是通过ajax获取后台的经纬度，将经纬度传递给小车，小车不断移动，并调用百度地图API的画线函数，实现小车路线的显示。 部分代码如下： <%@page language="java" import="java.util.*" pageEnco...
javascript 3种百度地图车辆平滑移动，轨迹回放，多车同时平滑移动
12-26
javascript 3种百度地图车辆平滑移动，轨迹回放，多车同时平滑移动
类似滴滴打车，多辆小车在地图上平滑移动的实现，基于百度地图实现（轨迹已画好版和无轨迹版）
11-22
类似滴滴打车，多辆小车在地图上平滑移动的实现，基于百度地图实现（轨迹已画好版和无轨迹版）http://blog.csdn.net/qq_30651537/article/details/53262052
【百度地图API】如何利用地图API制作汽车沿道路行驶的动画？——如何获得道路层数据...
weixin_33806914的博客
07-12 475
有几个做汽车导航的朋友问我说，他们想在地图上制作一辆车沿着道路行驶的动画。可是，百度地图的道路数据并没有公开。所以，应该怎么办呢？ 一、 我们先来学习如何把百度地图“弄”出来。把下面这段代码保存为htm格式，用浏览器打开，就能看到百度地图了。  &lt;html&gt;&lt;head&gt;&lt;meta http-equiv="Content-Type" content="text...
类似滴滴打车，多辆小车在地图上平滑移动的实现，基于百度地图实现（无轨迹）
qq_30651537的博客
11-21 5587
参考百度地图demo：轨迹运行demo展示，类名TrackShowDemo。百度TrackShowDemo类里只实现了一个完整的轨迹运行，并且是将所有的经纬点放在一个数组里，我觉得直接放在一个List集合里更好点。
百度地图小车移动
a865074284的博客
10-12 4229
基于百度地图，覆盖物（小车）平滑移动 先看一下效果 直接贴上源码 import android.app.Activity; import android.os.Bundle; import android.os.Handler; import android.os.Looper; import com.baidu.mapapi.map.BaiduMap; import com.ba
百度地图JavascriptApi Marker平滑移动及车头指向行径方向
zhanggx512的博客
05-02 2447
https://www.cnblogs.com/peixuanzhihou/p/6540086.html
类似滴滴打车，多辆小车在地图上平滑移动的实现，基于百度地图实现（轨迹已画好和无轨迹）
11-12
在Android开发中，实现类似滴滴打车应用的功能，即在地图上显示多个小车并让它们平滑移动，是一项常见的需求。本项目基于百度地图API，提供了完整的源码实现，包括车辆已有轨迹和无轨迹两种情况。下面我们将深入探讨...
地图聚合+滴滴打车小车平滑移动实现
11-12
地图聚合是指将多个地理位置数据点整合到地图上，以更直观的方式展示信息，而滴滴打车小车平滑移动则是模拟车辆在地图上的实时轨迹效果。这里我们将详细探讨这两个知识点。 首先，地图聚合。在Android中，通常我们...
基于 Java+Android车辆运动轨迹平滑移动(高仿DD打车)最佳实践
最新发布
06-07
【作品名称】：基于 Java+Android车辆运动轨迹平滑移动(高仿DD打车)最佳实践 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目...
javascript 实现百度地图车辆图标平滑移动，轨迹回放，多车同时平滑移动
谢泽的网络日志
05-23 4933
记录一下百度地图平滑移动的js功能 <html lang="en"> <head> <meta charset="utf-8" /> <title>轨迹回放</title> <style type="text/css"> body, html{width: 100%;height: ...
在vue中使用 百度地图
rolinabc的博客
04-09 1299
本篇文章主要讲述, 如何在vue项目中集成百度地图 1.首先找到你项目底下的index.html入口文件,这个根据不同的版本,所以存在的位置是不同的,具体如下: a.路径如下: 项目名/public/index.html b.路径如下: 项目名/index.html 找到index文件后,导入百度地...
百度地图——显示小车轨迹动画回放
little xian的博客
09-23 1万+
百度地图，Android显示车辆轨迹动画 初次设计想就用百度自带的显示覆盖物的方式，计算两个坐标点的距离，添加短距离的坐标点，然后在密密麻麻的坐标点之间显示，隐藏覆盖物，形成移动的视觉效果。 后来发现会创建较大的内存，而且效果不佳。 最后选择添加View的方法，利用addView方法添加小车的view，利用Android动画，同步和异步结合显示小车运行。 主要几个注意点和方案是：
基于百度地图API实现的一个车辆模拟器
09-14 1166
需要实现一个车辆模拟器，在地图上按照一条线路来驾驶，模拟器需要通过MQTT与服务器进行通讯，发送车辆当前的GPS坐标，速度等信息。服务器根据车辆的位置，以及当前地图区域上的网络状况，提前预测车辆将要到达区域的网络状况，并采取相应的行动（例如调整网络参数等）并发送消息通知模拟器。 模拟器的实现 模拟器的界面是基于百度地图来实现的一个前端页面，这里需要实现几个功能： 1. 与服务器的通讯 通过websocket接口与一个MQTT服务器通信，实时上报车辆的信息到一个主题，并且订阅另外一个主题来获取服务器的
仿滴滴打车的平滑移动附近车辆效果实现全流程，基于高德地图
热门推荐
伊万-张的博客
03-18 2万+
开端： 打开滴滴打车APP，会发现地图上的车辆显示的十分形象，车辆会在路上平滑的加减速，转向停车什么的 有种即时战略的感觉，看起来挺有趣： 为了研究这个效果如何实现，我开始了探索之旅： 一.探索阶段： 1.旧版平滑移动 首先找到的是百度“高德地图平滑移动”结果里的这个文： http://lbs.amap.com/smart/transportation/skill
Vue中使用百度地图做路径分析并根据起终点坐标模拟道路里程桩
L863683305的博客
03-28 3689
1.我们先要在vue中引入百度地图的API 第一步：在vue中的index.html文件中加上一个script标签： <script type="text/javascript" src="//api.map.baidu.com/api?v=2.0&ak=你在百度地图申请的秘钥"></script> 第二步：在你的build>webpack.base.con...
如何将小车标注在百度地图上并且设置车头方向
oTingFeng1234的博客
07-01 3904
如何将小车标注在百度地图上并且设置车头方向 首先，需要在项目中引入百度地图的API 第二步，将百度地图嵌入到项目中 第三步，将小车标注在地图中 第四步，设置车头的方向 <html lang="en"> <head> <meta charset="utf-8" /> <title>轨迹回放(路书)</title> <style type="text/css"> body, html { width: 10
前端Vue仿滴滴打车百度地图定位查找附近出租车或门店信息(更新版)
chenchuang0128的博客
06-17 930
打车打车
Vue2租车高德地图项目经验分享
qq_45163356的博客
06-22 484
11
"基于SSM MySQL技术的网约车用户服务平台设计与实现
该平台的设计和实现旨在提供类似于滴滴打车或高德打车的专业打车和接单服务。用户只需在平台上注册为会员用户，就可以通过个人后台的打车功能进行网约车服务。此外，用户还可以查看历史订单，了解近期的打车记录，并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值