SpringBoot与ZooKeeper整合，实现智能停车计费体系

智能停车计费体系通太过布式锁技能确保在多台服务器环境下，同一辆车的计费操作不会发生冲突，从而包管计费的正确性和同等性。
关键点

1. 高并发处理

• 需求: 停车场大概有大量的车辆同时进出，尤其是在高峰时段。
  
• 办理方案: 使用分布式架构和高效的数据库管理来处理高并发哀求。
  

2. 数据同等性

• 需求: 确保在多台服务器环境下，同一辆车的计费操作不会发生冲突。
  
• 办理方案: 使用分布式锁（如ZooKeeper）来包管数据的同等性和正确性。
  

3. 实时性

• 需求: 需要快速相应车辆的进失事件，并及时计算费用。
  
• 办理方案: 优化算法和数据库查询，确保低耽误。
  

使用ZooKeeper的利益

1. 分布式锁

• 包管数据同等性: 在多台服务器同时处理车辆进出记载的情况下，使用ZooKeeper的分布式锁可以确保同一辆车的计费操作在同一时间只能由一台服务器处理。这避免了并发问题，包管了计费的正确性和同等性。
  
• 防止重复计费: 如果没有分布式锁，大概会出现同一辆车多次被不同服务器计费的情况，导致重复收费或计费错误。
  

2. 高可用性

• 容错本领: ZooKeeper本身是一个高可用的服务，即使某一台ZooKeeper节点故障，其他节点仍然可以继续提供服务。这进步了整个体系的稳定性和可靠性。
  
• 负载平衡: 分布式锁机制可以资助均匀分配任务到不同的服务器上，进步体系的团体性能和相应速度。
  

3. 易于扩展

• 动态增长服务器: 随着业务的增长，可以通过简单地增长更多的服务器来处理更多的哀求。ZooKeeper可以轻松管理这些新增的服务器，并确保它们能够正确协同工作。
  
• 机动性: 添加新的功能或调整现有逻辑时，ZooKeeper的分布式特性使得这些更改更轻易实现和部署。
  

4. 简化协调过程

• 同一协调: ZooKeeper提供了一种集中式的协调机制，使得多个服务器之间的通讯和同步变得简单和高效。不再需要复杂的自定义协议或手动协调逻辑。
  
• 轻量级: ZooKeeper的设计目标是轻量级且高性能，适合在各种规模的应用中使用。
  

5. 监控和日志

• 实时监控: ZooKeeper提供了丰富的监控工具和API，可以实时监控集群的状态和健康状态。
  
• 审计日志: 可以通过ZooKeeper的日志功能跟踪所有对共享资源的操作，便于审计和故障排查。
  

代码实操

1.         <!-- Spring Boot Starter Web for RESTful services -->
2.         <dependency>
3.             <groupId>org.springframework.boot</groupId>
4.             <artifactId>spring-boot-starter-web</artifactId>
5.         </dependency>
7.         <!-- Apache Curator for ZooKeeper interaction -->
8.         <dependency>
9.             <groupId>org.apache.curator</groupId>
10.             <artifactId>curator-framework</artifactId>
11.             <version>${curator.version}</version>
12.         </dependency>
13.         <dependency>
14.             <groupId>org.apache.curator</groupId>
15.             <artifactId>curator-recipes</artifactId>
16.             <version>${curator.version}</version>
17.         </dependency>
19.         <!-- Lombok for reducing boilerplate code -->
20.         <dependency>
21.             <groupId>org.projectlombok</groupId>
22.             <artifactId>lombok</artifactId>
23.             <optional>true</optional>
24.         </dependency>

复制代码

application.properties

1. zookeeper.connect-string=localhost:2181

复制代码

ZookeeperConfig.java

1. package com.example.parking.config;
3. import org.apache.curator.framework.CuratorFramework;
4. import org.apache.curator.framework.CuratorFrameworkFactory;
5. import org.apache.curator.retry.ExponentialBackoffRetry;
6. import org.springframework.beans.factory.annotation.Value;
7. import org.springframework.context.annotation.Bean;
8. import org.springframework.context.annotation.Configuration;
10. /**
11.  * 配置ZooKeeper连接。
12.  */
13. @Configuration
14. publicclass ZookeeperConfig {
16.     @Value("${zookeeper.connect-string}")
17.     private String zkConnectString;
19.     /**
20.      * 创建并返回一个CuratorFramework实例。
21.      * @return CuratorFramework实例
22.      */
23.     @Bean(initMethod = "start", destroyMethod = "close")
24.     public CuratorFramework curatorFramework() {
25.         return CuratorFrameworkFactory.newClient(zkConnectString, new ExponentialBackoffRetry(1000, 3));
26.     }
27. }

复制代码

ParkingController.java

1. package com.example.parking.controller;
3. import com.example.parking.model.ParkingRequest;
4. import com.example.parking.service.ParkingService;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.http.ResponseEntity;
7. import org.springframework.web.bind.annotation.*;
9. /**
10.  * 提供HTTP接口用于车辆进入和离开停车场的操作。
11.  */
12. @RestController
13. @RequestMapping("/parking")
14. publicclass ParkingController {
16.     @Autowired
17.     private ParkingService parkingService;
19.     /**
20.      * 车辆进入停车场。
21.      * @param request 包含车辆ID的请求对象
22.      * @return 成功或失败的消息
23.      */
24.     @PostMapping("/enter")
25.     public ResponseEntity<String> enterParkingLot(@RequestBody ParkingRequest request) {
26.         boolean success = parkingService.enterParkingLot(request.getCarId());
27.         if (success) {
28.             return ResponseEntity.ok("Vehicle entered parking lot.
29. ");
30.         } else {
31.             return ResponseEntity.badRequest().body("Failed to enter parking lot.");
32.         }
33.     }
35.     /**
36.      * 车辆离开停车场。
37.      * @param request 包含车辆ID和停留时间的请求对象
38.      * @return 成功或失败的消息
39.      */
40.     @PostMapping("/leave")
41.     public ResponseEntity<String> leaveParkingLot(@RequestBody ParkingRequest request) {
42.         long durationInMinutes = request.getDurationInMinutes();
43.         boolean success = parkingService.leaveParkingLot(request.getCarId(), durationInMinutes);
44.         if (success) {
45.             return ResponseEntity.ok("Vehicle left parking lot. Fee calculated and stored.
46. ");
47.         } else {
48.             return ResponseEntity.badRequest().body("Failed to leave parking lot.");
49.         }
50.     }
51. }

复制代码

ParkingDao.java

1. package com.example.parking.dao;
3. import com.example.parking.entity.ParkingRecord;
4. import org.springframework.stereotype.Repository;
6. import java.util.HashMap;
7. import java.util.Map;
9. /**
10.  * 数据访问对象，负责存储和检索停车记录。
11.  */
12. @Repository
13. publicclass ParkingDao {
15.     privatefinal Map<String, ParkingRecord> records = new HashMap<>();
17.     /**
18.      * 记录车辆进入停车场的时间。
19.      * @param carId 车辆ID
20.      * @return 是否成功记录
21.      */
22.     public boolean saveEntry(String carId) {
23.         if (!records.containsKey(carId)) {
24.             records.put(carId, new ParkingRecord(carId));
25.             returntrue;
26.         }
27.         returnfalse;
28.     }
30.     /**
31.      * 获取指定车辆的停车记录。
32.      * @param carId 车辆ID
33.      * @return 停车记录
34.      */
35.     public ParkingRecord getRecord(String carId) {
36.         return records.get(carId);
37.     }
39.     /**
40.      * 移除指定车辆的停车记录。
41.      * @param carId 车辆ID
42.      * @return 是否成功移除
43.      */
44.     public boolean removeRecord(String carId) {
45.         return records.remove(carId) != null;
46.     }
47. }

复制代码

ParkingRecord.java

1. package com.example.parking.entity;
3. import java.time.LocalDateTime;
5. /**
6.  * 实体类，表示一辆车的停车记录。
7.  */
8. publicclass ParkingRecord {
10.     private String carId;
11.     private LocalDateTime entryTime;
13.     /**
14.      * 构造函数，初始化停车记录。
15.      * @param carId 车辆ID
16.      */
17.     public ParkingRecord(String carId) {
18.         this.carId = carId;
19.         this.entryTime = LocalDateTime.now();
20.     }
22.     /**
23.      * 获取车辆ID。
24.      * @return 车辆ID
25.      */
26.     public String getCarId() {
27.         return carId;
28.     }
30.     /**
31.      * 获取车辆进入停车场的时间。
32.      * @return 进入时间
33.      */
34.     public LocalDateTime getEntryTime() {
35.         return entryTime;
36.     }
37. }

复制代码

ParkingRequest.java

1. package com.example.parking.model;
3. /**
4.  * 请求模型，包含车辆ID和停留时间。
5.  */
6. publicclass ParkingRequest {
8.     private String carId;
9.     privatelong durationInMinutes;
11.     // Getters and Setters
12.     /**
13.      * 获取车辆ID。
14.      * @return 车辆ID
15.      */
16.     public String getCarId() {
17.         return carId;
18.     }
20.     /**
21.      * 设置车辆ID。
22.      * @param carId 车辆ID
23.      */
24.     public void setCarId(String carId) {
25.         this.carId = carId;
26.     }
28.     /**
29.      * 获取停留时间（分钟）。
30.      * @return 停留时间
31.      */
32.     public long getDurationInMinutes() {
33.         return durationInMinutes;
34.     }
36.     /**
37.      * 设置停留时间（分钟）。
38.      * @param durationInMinutes 停留时间
39.      */
40.     public void setDurationInMinutes(long durationInMinutes) {
41.         this.durationInMinutes = durationInMinutes;
42.     }
43. }

复制代码

ParkingService.java

1. package com.example.parking.service;
3. /**
4.  * 接口定义了进入和离开停车场的方法。
5.  */
6. public interface ParkingService {
8.     /**
9.      * 车辆进入停车场。
10.      * @param carId 车辆ID
11.      * @return 是否成功进入
12.      */
13.     boolean enterParkingLot(String carId);
15.     /**
16.      * 车辆离开停车场。
17.      * @param carId 车辆ID
18.      * @param durationInMinutes 停留时间（分钟）
19.      * @return 是否成功离开
20.      */
21.     boolean leaveParkingLot(String carId, long durationInMinutes);
22. }

复制代码

ParkingServiceImpl.java

1. package com.example.parking.service.impl;
3. import com.example.parking.dao.ParkingDao;
4. import com.example.parking.entity.ParkingRecord;
5. import com.example.parking.service.ParkingService;
6. import org.apache.curator.framework.CuratorFramework;
7. import org.apache.curator.framework.recipes.locks.InterProcessMutex;
8. import org.springframework.beans.factory.annotation.Autowired;
9. import org.springframework.stereotype.Service;
11. import java.util.concurrent.TimeUnit;
13. /**
14.  * 实现了ParkingService接口的具体逻辑，并使用ZooKeeper的互斥锁来保证同一辆车的计费操作不会被并发执行。
15.  */
16. @Service
17. publicclass ParkingServiceImpl implements ParkingService {
19.     privatefinal CuratorFramework client;
20.     privatefinal ParkingDao parkingDao;
22.     @Autowired
23.     public ParkingServiceImpl(CuratorFramework client, ParkingDao parkingDao) {
24.         this.client = client;
25.         this.parkingDao = parkingDao;
26.     }
28.     /**
29.      * 车辆进入停车场。
30.      * @param carId 车辆ID
31.      * @return 是否成功进入
32.      */
33.     @Override
34.     public boolean enterParkingLot(String carId) {
35.         return parkingDao.saveEntry(carId);
36.     }
38.     /**
39.      * 车辆离开停车场。
40.      * @param carId 车辆ID
41.      * @param durationInMinutes 停留时间（分钟）
42.      * @return 是否成功离开
43.      */
44.     @Override
45.     public boolean leaveParkingLot(String carId, long durationInMinutes) {
46.         InterProcessMutex lock = new InterProcessMutex(client, "/locks/" + carId);
48.         try {
49.             if (lock.acquire(10, TimeUnit.SECONDS)) {
50.                 try {
51.                     if (!enterParkingLot(carId)) {
52.                         returnfalse;
53.                     }
55.                     ParkingRecord record = parkingDao.getRecord(carId);
56.                     double fee = calculateFee(record, durationInMinutes);
57.                     System.out.println("Calculated fee for " + carId + ": $" + fee);
58.                     // Logic to store the fee in a database or other storage system
59.                     parkingDao.removeRecord(carId);
60.                     returntrue;
61.                 } finally {
62.                     lock.release();
63.                 }
64.             } else {
65.                 System.err.println("Could not acquire lock for " + carId);
66.                 returnfalse;
67.             }
68.         } catch (Exception e) {
69.             e.printStackTrace();
70.             returnfalse;
71.         }
72.     }
74.     /**
75.      * 计算停车费用。
76.      * @param record 停车记录
77.      * @param durationInMinutes 停留时间（分钟）
78.      * @return 停车费用
79.      */
80.     private double calculateFee(ParkingRecord record, long durationInMinutes) {
81.         double ratePerMinute = 0.5;
82.         return durationInMinutes * ratePerMinute;
83.     }
84. }

复制代码

ParkingApplication.java

1. package com.example.parking;
3. import org.springframework.boot.SpringApplication;
4. import org.springframework.boot.autoconfigure.SpringBootApplication;
6. /**
7.  * Spring Boot应用的主类。
8.  */
9. @SpringBootApplication
10. public class ParkingApplication {
12.     public static void main(String[] args) {
13.         SpringApplication.run(ParkingApplication.class, args);
14.     }
15. }

复制代码

测试结果

   “  确保ZooKeeper服务器正在运行。
  车辆进入停车场

1. http://localhost:8080/parking/enter   
2.      {
3.        "carId": "A123"
4.      }

复制代码

• 相应:
  1. Vehicle entered parking lot.

  复制代码

车辆离开停车场

1. http://localhost:8080/parking/leave
2.      {
3.        "carId": "A123",
4.        "durationInMinutes": 60
5.      }

复制代码

• 相应:
  1. Vehicle left parking lot. Fee calculated and stored.

  复制代码
• 控制台输出:
  1. Calculated fee for A123: $30.0

  复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。