代驾小程序开发实战：核心代码实现-平芜编程栈

随着移动互联网的普及，代驾小程序因其轻量便捷的特点受到用户青睐。本文将深入探讨代驾小程序的开发实现，通过具体代码示例展示核心功能的实现方法。

一、开发环境搭建

技术栈选择

前端：微信小程序 + Taro多端框架
数据库：MySQL + Redis
地图服务：腾讯位置服务
推送服务：微信模板消息

项目结构设计

daiJia-project/
├── daiJia-miniprogram/ # 小程序前端
├── daiJia-backend/ # 后端服务
├── daiJia-admin/ # 管理后台
└── daiJia-driver/ # 司机端

二、用户端核心功能实现

1. 用户定位与地址选择

// 小程序端定位代码示例
class LocationService {
// 获取用户当前位置
async getCurrentLocation() {
return new Promise((resolve, reject) => {
wx.getLocation({
type: 'gcj02',
success: (res) => {
const location = {
latitude: res.latitude,
longitude: res.longitude,
accuracy: res.accuracy
};
this.reverseGeocode(location).then(resolve);
},
fail: reject
});
});
}

// 逆地址解析
async reverseGeocode(location) {
const qqMap = require('./libs/qqmap-wx-jssdk.min.js');
const mapSDK = new qqMap({
key: 'YOUR_MAP_KEY'
});

return new Promise((resolve) => {
mapSDK.reverseGeocoder({
location: location,
success: (res) => {
resolve({
...location,
address: res.result.address,
formatted_address: res.result.formatted_addresses.recommend
});
}
});
});
}

// 地址搜索自动补全
async searchAddress(keyword) {
const url = `https://apis.map.qq.com/ws/place/v1/suggestion`;
const params = {
keyword,
region: '全国',
key: 'YOUR_MAP_KEY'
};

const res = await wx.request({
url,
data: params
});

return res.data.data;
}
}

// 在页面中使用
Page({
data: {
currentAddress: '',
addressList: []
},

onLoad() {
this.locationService = new LocationService();
this.initLocation();
},

async initLocation() {
try {
const location = await this.locationService.getCurrentLocation();
this.setData({
currentAddress: location.formatted_address
});
} catch (error) {
console.error('获取位置失败:', error);
}
},

async onSearchInput(e) {
const keyword = e.detail.value;
if (keyword.length > 1) {
const list = await this.locationService.searchAddress(keyword);
this.setData({ addressList: list });
}
}
});

2. 订单创建与状态管理

// 后端订单服务核心代码
@Service
@Slf4j
public class OrderServiceImpl implements OrderService {

@Autowired
private OrderMapper orderMapper;

@Autowired
private RedisTemplate<String, Object> redisTemplate;

@Autowired
private DriverService driverService;

@Autowired
private MessageService messageService;

/**
* 创建代驾订单
*/
@Override
@Transactional(rollbackFor = Exception.class)
public OrderDTO createOrder(OrderCreateRequest request) {
// 1. 参数验证
validateOrderRequest(request);

// 2. 价格计算
BigDecimal estimatedPrice = calculatePrice(request);

// 3. 创建订单实体
Order order = new Order();
order.setOrderNo(generateOrderNo());
order.setUserId(request.getUserId());
order.setStartAddress(request.getStartAddress());
order.setEndAddress(request.getEndAddress());
order.setStartLocation(request.getStartLocation());
order.setEndLocation(request.getEndLocation());
order.setEstimatedPrice(estimatedPrice);
order.setStatus(OrderStatus.WAITING_DRIVER);
order.setCreateTime(new Date());

// 4. 保存订单
orderMapper.insert(order);

// 5. 寻找附近司机
List<Driver> nearbyDrivers = findNearbyDrivers(
request.getStartLocation(),
5.0 // 5公里范围内
);

// 6. 推送订单给司机
pushOrderToDrivers(order, nearbyDrivers);

// 7. 返回订单信息
return convertToDTO(order);
}

/**
* 智能匹配司机算法
*/
private List<Driver> findNearbyDrivers(Location location, double radius) {
// 使用Redis GEO查找附近司机
String geoKey = "driver:locations";
GeoResults<RedisGeoCommands.GeoLocation<Object>> results =
redisTemplate.opsForGeo().radius(
geoKey,
new Circle(
new Point(location.getLongitude(), location.getLatitude()),
new Distance(radius, Metrics.KILOMETERS)
)
);

List<Driver> drivers = new ArrayList<>();
for (GeoResult<RedisGeoCommands.GeoLocation<Object>> result : results) {
String driverId = (String) result.getContent().getName();
Driver driver = driverService.getDriverById(driverId);
if (driver != null && driver.getStatus() == DriverStatus.AVAILABLE) {
drivers.add(driver);
}
}

// 根据评分、距离等排序
return drivers.stream()
.sorted(Comparator
.comparing(Driver::getRating).reversed()
.thenComparing(d -> calculateDistance(d.getLocation(), location)))
.limit(10)
.collect(Collectors.toList());
}

/**
* 计算代驾价格
*/
private BigDecimal calculatePrice(OrderCreateRequest request) {
// 基础起步价
BigDecimal basePrice = new BigDecimal("39.00");

// 计算距离
double distance = calculateDistance(
request.getStartLocation(),
request.getEndLocation()
);

// 距离费用（3公里后每公里5元）
BigDecimal distancePrice = BigDecimal.ZERO;
if (distance > 3) {
distancePrice = new BigDecimal((distance - 3) * 5);
}

// 时段加价（夜间23:00-6:00）
BigDecimal timeSurcharge = getTimeSurcharge();

// 动态加价（高峰时段）
BigDecimal surgeMultiplier = getSurgeMultiplier();

// 总价计算
BigDecimal total = basePrice
.add(distancePrice)
.add(timeSurcharge)
.multiply(surgeMultiplier)
.setScale(2, RoundingMode.HALF_UP);

return total;
}

/**
* 司机接单处理
*/
@Override
@Transactional
public OrderDTO acceptOrder(String orderId, String driverId) {
// 使用分布式锁防止重复接单
String lockKey = "order:accept:" + orderId;
RLock lock = redissonClient.getLock(lockKey);

try {
if (lock.tryLock(3, 10, TimeUnit.SECONDS)) {
Order order = orderMapper.selectById(orderId);
if (order == null) {
throw new BusinessException("订单不存在");
}

if (order.getStatus() != OrderStatus.WAITING_DRIVER) {
throw new BusinessException("订单已被接单");
}

// 更新订单状态
order.setDriverId(driverId);
order.setStatus(OrderStatus.DRIVER_ACCEPTED);
order.setAcceptTime(new Date());
orderMapper.updateById(order);

// 更新司机状态
driverService.updateDriverStatus(driverId, DriverStatus.ON_ORDER);

// 发送推送通知
messageService.sendOrderAcceptedMessage(order);

return convertToDTO(order);
} else {
throw new BusinessException("系统繁忙，请稍后重试");
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new BusinessException("接单失败");
} finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}

/**
* 订单状态机
*/
@Override
public boolean updateOrderStatus(String orderId, OrderStatus newStatus) {
Order order = orderMapper.selectById(orderId);
OrderStatus currentStatus = order.getStatus();

// 验证状态转换是否合法
if (!isValidTransition(currentStatus, newStatus)) {
log.error("无效的状态转换: {} -> {}", currentStatus, newStatus);
return false;
}

// 更新状态
order.setStatus(newStatus);
order.setUpdateTime(new Date());

// 根据状态执行相应操作
switch (newStatus) {
case DRIVER_ARRIVED:
order.setArriveTime(new Date());
messageService.sendDriverArrivedMessage(order);
break;
case TRIP_STARTED:
order.setStartTime(new Date());
messageService.sendTripStartedMessage(order);
break;
case TRIP_COMPLETED:
order.setEndTime(new Date());
calculateFinalPrice(order);
messageService.sendTripCompletedMessage(order);
break;
case PAYMENT_COMPLETED:
order.setPaymentTime(new Date());
settleDriverIncome(order);
break;
}

return orderMapper.updateById(order) > 0;
}

/**
* 订单状态转换验证
*/
private boolean isValidTransition(OrderStatus from, OrderStatus to) {
Map<OrderStatus, Set<OrderStatus>> validTransitions = new HashMap<>();

validTransitions.put(OrderStatus.WAITING_DRIVER,
Set.of(OrderStatus.DRIVER_ACCEPTED, OrderStatus.CANCELLED));

validTransitions.put(OrderStatus.DRIVER_ACCEPTED,
Set.of(OrderStatus.DRIVER_ARRIVED, OrderStatus.CANCELLED));

validTransitions.put(OrderStatus.DRIVER_ARRIVED,
Set.of(OrderStatus.TRIP_STARTED, OrderStatus.CANCELLED));

validTransitions.put(OrderStatus.TRIP_STARTED,
Set.of(OrderStatus.TRIP_COMPLETED));

validTransitions.put(OrderStatus.TRIP_COMPLETED,
Set.of(OrderStatus.PAYMENT_COMPLETED));

Set<OrderStatus> allowed = validTransitions.get(from);
return allowed != null && allowed.contains(to);
}
}

// 订单状态枚举
public enum OrderStatus {
WAITING_DRIVER("等待接单"),
DRIVER_ACCEPTED("司机已接单"),
DRIVER_ARRIVED("司机已到达"),
TRIP_STARTED("行程开始"),
TRIP_COMPLETED("行程结束"),
PAYMENT_COMPLETED("支付完成"),
CANCELLED("已取消"),
COMPLAINT("投诉中"),
REFUNDED("已退款");

private final String description;

OrderStatus(String description) {
this.description = description;
}
}

三、实时通信实现

WebSocket实时位置同步

// 小程序端WebSocket实现
class RealTimeService {
constructor() {
this.socket = null;
this.reconnectAttempts = 0;
this.maxReconnectAttempts = 5;
}

connect(userId, orderId) {
return new Promise((resolve, reject) => {
const wsUrl = `wss://your-domain.com/ws?userId=${userId}&orderId=${orderId}`;

this.socket = wx.connectSocket({
url: wsUrl,
success: () => {
this.bindEvents();
resolve();
},
fail: reject
});
});
}

bindEvents() {
wx.onSocketOpen(() => {
console.log('WebSocket连接已打开');
this.reconnectAttempts = 0;
});

wx.onSocketMessage((res) => {
const message = JSON.parse(res.data);
this.handleMessage(message);
});

wx.onSocketError((error) => {
console.error('WebSocket错误:', error);
this.reconnect();
});

wx.onSocketClose(() => {
console.log('WebSocket连接已关闭');
this.reconnect();
});
}

sendLocation(location) {
const message = {
type: 'location_update',
data: {
latitude: location.latitude,
longitude: location.longitude,
timestamp: Date.now()
}
};

if (this.socket && this.socket.readyState === 1) {
wx.sendSocketMessage({
data: JSON.stringify(message)
});
}
}

reconnect() {
if (this.reconnectAttempts < this.maxReconnectAttempts) {
this.reconnectAttempts++;
setTimeout(() => {
console.log(`尝试重新连接，第${this.reconnectAttempts}次`);
this.connect();
}, 3000 * this.reconnectAttempts);
}
}
}

四、安全与性能优化

1. 接口安全设计

// JWT认证拦截器
@Component
public class JwtInterceptor implements HandlerInterceptor {

@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response,
Object handler) {
String token = request.getHeader("Authorization");

if (StringUtils.isEmpty(token)) {
throw new AuthenticationException("未提供认证令牌");
}

try {
Claims claims = JwtUtil.parseToken(token);
String userId = claims.getSubject();

// 验证用户状态
User user = userService.getUserById(userId);
if (user == null || user.getStatus() != UserStatus.NORMAL) {
throw new AuthenticationException("用户状态异常");
}

// 将用户信息存入请求上下文
RequestContext.setCurrentUser(user);

return true;
} catch (Exception e) {
throw new AuthenticationException("认证失败");
}
}
}

2. 数据库性能优化

-- 订单表分表策略
CREATE TABLE orders_202401 (
id BIGINT PRIMARY KEY,
order_no VARCHAR(32) UNIQUE,
user_id BIGINT,
driver_id BIGINT,
status TINYINT,
-- 其他字段...
INDEX idx_user_status (user_id, status),
INDEX idx_driver_status (driver_id, status),
INDEX idx_create_time (create_time)
) ENGINE=InnoDB PARTITION BY RANGE (YEAR(create_time)) (
PARTITION p2023 VALUES LESS THAN (2024),
PARTITION p2024 VALUES LESS THAN (2025),
PARTITION p2025 VALUES LESS THAN (2026)
);

五、测试与部署

单元测试示例

@SpringBootTest
class OrderServiceTest {

@Autowired
private OrderService orderService;

@Test
void testCreateOrder() {
OrderCreateRequest request = new OrderCreateRequest();
request.setUserId("123456");
request.setStartAddress("北京市海淀区");
request.setEndAddress("北京市朝阳区");

OrderDTO order = orderService.createOrder(request);

assertNotNull(order);
assertEquals("123456", order.getUserId());
assertEquals(OrderStatus.WAITING_DRIVER, order.getStatus());
}
}

Docker部署配置

# docker-compose.yml
version: '3.8'
services:
mysql:
image: mysql:8.0
environment:
MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
volumes:
- mysql_data:/var/lib/mysql
ports:
- "3306:3306"

redis:
image: redis:7-alpine
ports:
- "6379:6379"

backend:
build: ./daiJia-backend
ports:
- "8080:8080"
depends_on:
- mysql
- redis
environment:
SPRING_PROFILES_ACTIVE: prod