【业务方案设计】高拓展性停车计费能力设计

最新推荐文章于 2025-02-04 16:49:18 发布
最新推荐文章于 2025-02-04 16:49:18 发布
阅读量1k 收藏 30
点赞数 24
分类专栏： 技术方案分析与抉择 文章标签： 系统设计 算法设计 业务分析 停车计费 停车计费系统
本文为ATFWUS原创，允许转载，但请附上作者署名和本文链接
本文链接：https://blog.csdn.net/ATFWUS/article/details/143139640
版权

停过各种各样的停车场，每次从停车场出来总是在想，这里面的计费能力是怎么设计的？有没有一种通用的结构能满足市面上几乎所有的停车计费规则，只需更改少量配置即可修改停车策略。本文从业务问题出发，深入分析停车计费这一场景的业务问题，提出了一种高拓展性的解决方案。

文章目录

1.业务分析

不难发现，市面上大多使用的停车计费系统都是购买的三方服务，如宜泊、智泊等，有少量的商城会自己开发停车计费的能力（主要为了对接自家的会员和积分权益），如龙湖天街等。

从这些三方服务的公司考虑，他们追求的就是系统拓展性非常强，多一个购买方，只需修改少量配置即可完成交付，这样成本才是最低的。

我们可以从日常生活中所看到的各种各样的停车计费规则去倒退一下，他们的计费能力，到底是怎样设计的，下面列举一些常见的停车计费规则：

  • 1.按次计费。（如 xx 景区，一次 20 块，一般来说也会有有效时期，比如一天算一次，本质来说也是按时间计费，只不过计费的单位比较长）
  • 2.时间均等计费：3 元一小时或者 2 元半小时等等。（主要是计费的最小单位不同，有的按 30 分钟计费，有的按 60 分钟计费，还有的按 120 分钟甚至 240 分钟计费）
  • 3.时间差异计费：首小时 5 元，后续每 半小时 2 元等等。（主要是有一个首段计费差异）
  • 4.分时段收费：白天（8:00-19:00）按首 5 元，后续半小时 2 元，一晚上（8:00-19:00）10 元等等。（主要是分时的策略不同）
  • 5.按天计费：停车时间到当日 24:00 为一日。

参考一些图片：
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

还有一些其他的附属规则，如不满 15 分钟免费，每天封顶 100 元，永久封顶 2000 元等。缴费后 15 分钟内离场不属于停车计费核心能力设计一环，缴费后该段计费已经结束，只需在离场的时候判断是不是在 15 分钟内，超过了重新计费即可。

需要注意的是，这只是分析了一些常见的计费规则，也有一些非常罕见并且和上述差异比较大的一些规则，工作日和节假日计费完全不同，不同等级的会员免费的时长不一样。
这些规则与常见的规则不太相同，如果要想在一个通用的设计中兼容这些规则，会使整个设计变得很复杂，软件设计也需要在拓展性和复杂性之间有所平衡。
我们可以使用通用设计+额外特殊逻辑的方式来解决这些比较少见的规则，比如：

  • 1.计费前依据是否是节假日进入不同配置的计费逻辑中。
  • 2.计费后依据会员的等级来进行一定费用的减免。

对于不同类型的车辆同样也适用：如蓝牌、绿牌调用的策略不同。

等等还有很多，如果通用设计+额外特殊逻辑的方式仍然无法解决的，那最好的办法是加一种策略的代码，比如在 java 中多增加一个策略的实现类，成本也不会太高，因为需要添加的代码的场景本身就非常之少。

2.核心配置设计

综合上面的分析，实际上第一种情况按次计费可以算入时间均等计费中（24 小时算一次），第二种又可以算入第三种中（首小时的计费规则和后续规则都相同），第三种又可以算入第四种中（白天和晚上的计费规则相同），第五种因为时间维度变为自然日了，有所区别。

需要思考的问题是，是不是要将前四种都统一到一套规则中？

我认为最好不要统一，原因如下：

  • 1.统一会使得逻辑太过通用，代码可读性差，遇到问题更难解决。
  • 2.这些规则理论上属于不同的实体，当面向用户展示的时候，直接展示不同的计费规则更符合用户的需求。（如果按照一套通用规则使用，则面向用户展示的时候还需要转换成更易理解的文字计费规则）

那么我们可以将上述的五套规则中的核心变量提取出来：

  • 1.按次计费。核心变量是单次有效期和单次费用。
  • 2.时间均等计费。核心变量是计费单位和单位费用。
  • 3.时间差异计费。核心变量是首次计费单位、首次费用、后续计费单位、后续费用。（市面上大部分都只有这两个差异，如果有更多差异，需要额外增加一种策略。）
  • 4.分时段收费。核心变量是分时段 1（例如白天）、分时段 1 计费规则（上述 2 或3）、分时段 2（例如晚上）、分时段 2 计费规则（上述 2 或 3）。
  • 5.自然日收费。核心变量是单自然日费用。
  • 其余统一的核心变量是免费时长、每日封顶费用、永久封顶费用。

核心配置如下：

{
  "billingType": "time",  // 计费类型，可选 "perEntry", "time", "variableTime", "timePeriod", "daily"
  "perEntryConfig": {
    "singleEntryDurationMinutes": 1440,  // 单次有效期，单位为分钟，1440 表示1天
    "singleEntryFee": 20.0  // 单次费用
  },
  "timeConfig": {
    "billingUnitMinutes": 60,  // 计费单位，例如 60 表示每小时
    "unitFee": 3.0  // 每单位费用
  },
  "variableTimeConfig": {
    "firstUnitMinutes": 60,  // 首次计费单位，例如 60 表示首小时
    "firstUnitFee": 5.0,  // 首次计费的费用
    "subsequentUnitMinutes": 30,  // 后续计费单位，例如 30 表示每半小时
    "subsequentUnitFee": 2.0  // 后续计费的费用
  },
  "timePeriodConfig": {
    "periods": [
      {
        "startTime": "08:00",  // 分时段开始时间
        "endTime": "19:00",  // 分时段结束时间
        "billingType": "variableTime",  // 该时段的计费类型，可选 "time" 或 "variableTime"
        "billingConfig": {  // 时段内的计费配置，根据类型而定
          "firstUnitMinutes": 60,
          "firstUnitFee": 5.0,
          "subsequentUnitMinutes": 30,
          "subsequentUnitFee": 2.0
        }
      },
      {
        "startTime": "19:00",
        "endTime": "08:00",
        "billingType": "time",
        "billingConfig": {
          "billingUnitMinutes": 60,
          "unitFee": 10.0
        }
      }
    ]
  },
  "dailyConfig": {
    "dailyFee": 50.0  // 每天封顶费用
  },
  "additionalRules": {
    "freeMinutes": 15,  // 免费时长
    "dailyCap": 100.0,  // 每日封顶费用
    "totalCap": 2000.0  // 永久封顶费用
  }
}

3.代码实现

我们可以搭配策略模式和装饰器模式将上述的核心配置进行落地实现。这里配置从 json 文件中读取，实际业务中应该是从配置中心拉取。

3.1 停车计费策略接口

/**
 * @ClassName: ParkingFeeStrategy
 * @description: 停车计费策略接口
 * @author: atfwus
 * @date: 2024.10.22
 * @version: 1.0
 */
public interface ParkingFeeStrategy {
    BigDecimal calculateFee(LocalDateTime entryTime, LocalDateTime exitTime);
}

3.2 按次计费策略

/**
 * @ClassName: PerEntryRateStrategy
 * @description: 按次计费策略
 * @author: atfwus
 * @date: 2024.10.22
 * @version: 1.0
 */
import java.math.BigDecimal;
import java.time.Duration;
import java.time.LocalDateTime;

public class PerEntryRateStrategy implements ParkingFeeStrategy {
    private final long validDurationMinutes;
    private final BigDecimal perEntryFee;

    public PerEntryRateStrategy(long validDurationMinutes, BigDecimal perEntryFee) {
        this.validDurationMinutes = validDurationMinutes;
        this.perEntryFee = perEntryFee;
    }

    @Override
    public BigDecimal calculateFee(LocalDateTime entryTime, LocalDateTime exitTime) {
        long totalMinutes = Duration.between(entryTime, exitTime).toMinutes();
        long entries = (totalMinutes / validDurationMinutes) + 1; // 超过一个有效期按多次计算
        return perEntryFee.multiply(BigDecimal.valueOf(entries));
    }
}

3.3 时间均等计费策略

/**
 * @ClassName: FixedIntervalRateStrategy
 * @description: 时间均等计费策略
 * @author: atfwus
 * @date: 2024.10.22
 * @version: 1.0
 */
import java.math.BigDecimal;
import java.time.Duration;
import java.time.LocalDateTime;

public class FixedIntervalRateStrategy implements ParkingFeeStrategy {
    private final BigDecimal unitFee;
    private final long unitDurationMinutes;

    public FixedIntervalRateStrategy(BigDecimal unitFee, long unitDurationMinutes) {
        this.unitFee = unitFee;
        this.unitDurationMinutes = unitDurationMinutes;
    }

    @Override
    public BigDecimal calculateFee(LocalDateTime entryTime, LocalDateTime exitTime) {
        long totalMinutes = Duration.between(entryTime, exitTime).toMinutes();
        long units = (totalMinutes + unitDurationMinutes - 1) / unitDurationMinutes; // 向上取整
        return unitFee.multiply(BigDecimal.valueOf(units));
    }
}

3.4 时间差异计费策略

/**
 * @ClassName: VariableRateStrategy
 * @description: 时间差异计费策略
 * @author: atfwus
 * @date: 2024.10.22
 * @version: 1.0
 */
import java.math.BigDecimal;
import java.time.Duration;
import java.time.LocalDateTime;

public class VariableRateStrategy implements ParkingFeeStrategy {
    private final BigDecimal firstUnitFee;
    private final BigDecimal subsequentUnitFee;
    private final long firstUnitMinutes;
    private final long subsequentUnitMinutes;

    public VariableRateStrategy(BigDecimal firstUnitFee, BigDecimal subsequentUnitFee, long firstUnitMinutes, long subsequentUnitMinutes) {
        this.firstUnitFee = firstUnitFee;
        this.subsequentUnitFee = subsequentUnitFee;
        this.firstUnitMinutes = firstUnitMinutes;
        this.subsequentUnitMinutes = subsequentUnitMinutes;
    }

    @Override
    public BigDecimal calculateFee(LocalDateTime entryTime, LocalDateTime exitTime) {
        long totalMinutes = Duration.between(entryTime, exitTime).toMinutes();

        if (totalMinutes <= firstUnitMinutes) {
            return firstUnitFee;
        }

        long remainingMinutes = totalMinutes - firstUnitMinutes;
        long subsequentUnits = (remainingMinutes + subsequentUnitMinutes - 1) / subsequentUnitMinutes; // 向上取整
        return firstUnitFee.add(subsequentUnitFee.multiply(BigDecimal.valueOf(subsequentUnits)));
    }
}

3.5 分时段计费

/**
 * @ClassName: TimePeriodRateStrategy
 * @description: 分时段计费策略
 * @author: atfwus
 * @date: 2024.10.22
 * @version: 1.0
 */
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.List;

public class TimePeriodRateStrategy implements ParkingFeeStrategy {
    private final List<TimePeriod> timePeriods;

    public TimePeriodRateStrategy(List<TimePeriod> timePeriods) {
        this.timePeriods = timePeriods;
    }

    @Override
    public BigDecimal calculateFee(LocalDateTime entryTime, LocalDateTime exitTime) {
        BigDecimal totalFee = BigDecimal.ZERO;
        LocalDateTime currentTime = entryTime;

        // 按时段计算停车费用
        while (currentTime.isBefore(exitTime)) {
            for (TimePeriod period : timePeriods) {
                if (period.isWithinPeriod(currentTime.toLocalTime())) {
                    // 计算当前时段的结束时间
                    LocalDateTime periodEndTime = currentTime.with(period.getEndTime());
                    if (periodEndTime.isAfter(exitTime)) {
                        periodEndTime = exitTime;
                    }

                    // 计算该时段内的费用
                    BigDecimal feeForPeriod = period.getBillingStrategy().calculateFee(currentTime, periodEndTime);
                    totalFee = totalFee.add(feeForPeriod);
                    currentTime = periodEndTime;
                    break;
                }
            }
        }

        return totalFee;
    }

    // 内部类定义时段和对应的计费规则
    public static class TimePeriod {
        private final LocalTime startTime;
        private final LocalTime endTime;
        private final ParkingFeeStrategy billingStrategy;

        public TimePeriod(LocalTime startTime, LocalTime endTime, ParkingFeeStrategy billingStrategy) {
            this.startTime = startTime;
            this.endTime = endTime;
            this.billingStrategy = billingStrategy;
        }

        public boolean isWithinPeriod(LocalTime time) {
            if (startTime.isBefore(endTime)) {
                return time.isAfter(startTime) && time.isBefore(endTime);
            } else {
                // 跨天情况，例如 20:00 到次日 08:00
                return time.isAfter(startTime) || time.isBefore(endTime);
            }
        }

        public LocalTime getEndTime() {
            return endTime;
        }

        public ParkingFeeStrategy getBillingStrategy() {
            return billingStrategy;
        }
    }
}

3.6 自然日计费策略

/**
 * @ClassName: PerDayRateStrategy
 * @description: 自然日计费策略
 * @author: atfwus
 * @date: 2024.10.22
 * @version: 1.0
 */
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

public class PerDayRateStrategy implements ParkingFeeStrategy {
    private final BigDecimal dailyRate;

    public PerDayRateStrategy(BigDecimal dailyRate) {
        this.dailyRate = dailyRate;
    }

    @Override
    public BigDecimal calculateFee(LocalDateTime entryTime, LocalDateTime exitTime) {
        long days = ChronoUnit.DAYS.between(entryTime.toLocalDate(), exitTime.toLocalDate());
        return dailyRate.multiply(BigDecimal.valueOf(days + 1)); // +1 是因为跨天停车也算一天
    }
}

3.7 免费时长装饰器

/**
 * @ClassName: FreeMinutesDecorator
 * @description: 免费时长装饰器
 * @author: atfwus
 * @date: 2024.10.22
 * @version: 1.0
 */
import java.math.BigDecimal;
import java.time.Duration;
import java.time.LocalDateTime;

public class FreeMinutesDecorator implements ParkingFeeStrategy {
    private final ParkingFeeStrategy wrappedStrategy;
    private final long freeMinutes;

    public FreeMinutesDecorator(ParkingFeeStrategy wrappedStrategy, long freeMinutes) {
        this.wrappedStrategy = wrappedStrategy;
        this.freeMinutes = freeMinutes;
    }

    @Override
    public BigDecimal calculateFee(LocalDateTime entryTime, LocalDateTime exitTime) {
        long totalMinutes = Duration.between(entryTime, exitTime).toMinutes();
        if (totalMinutes <= freeMinutes) {
            return BigDecimal.ZERO;
        }
        return wrappedStrategy.calculateFee(entryTime, exitTime);
    }
}

3.8 每日封顶装饰器

/**
 * @ClassName: DailyCappedFeeDecorator
 * @description: 每日封顶装饰器
 * @author: atfwus
 * @date: 2024.10.22
 * @version: 1.0
 */
import java.math.BigDecimal;
import java.time.LocalDateTime;

public class DailyCappedFeeDecorator implements ParkingFeeStrategy {
    private final ParkingFeeStrategy wrappedStrategy;
    private final BigDecimal dailyCap;

    public DailyCappedFeeDecorator(ParkingFeeStrategy wrappedStrategy, BigDecimal dailyCap) {
        this.wrappedStrategy = wrappedStrategy;
        this.dailyCap = dailyCap;
    }

    @Override
    public BigDecimal calculateFee(LocalDateTime entryTime, LocalDateTime exitTime) {
        BigDecimal fee = wrappedStrategy.calculateFee(entryTime, exitTime);
        return fee.min(dailyCap);
    }
}

3.9 总封顶装饰器

/**
 * @ClassName: TotalCappedFeeDecorator
 * @description: 总封顶装饰器
 * @author: atfwus
 * @date: 2024.10.22
 * @version: 1.0
 */
import java.math.BigDecimal;
import java.time.LocalDateTime;

public class TotalCappedFeeDecorator implements ParkingFeeStrategy {
    private final ParkingFeeStrategy wrappedStrategy;
    private final BigDecimal totalCap;

    public TotalCappedFeeDecorator(ParkingFeeStrategy wrappedStrategy, BigDecimal totalCap) {
        this.wrappedStrategy = wrappedStrategy;
        this.totalCap = totalCap;
    }

    @Override
    public BigDecimal calculateFee(LocalDateTime entryTime, LocalDateTime exitTime) {
        BigDecimal fee = wrappedStrategy.calculateFee(entryTime, exitTime);
        return fee.min(totalCap);
    }
}

3.10 停车计费配置

/**
 * @ClassName: ParkingConfig
 * @description: 停车计费配置
 * @author: atfwus
 * @date: 2024.10.22
 * @version: 1.0
 */
import java.math.BigDecimal;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;

public class ParkingConfig {
    public String billingType;  // "perEntry", "time", "variableTime", "timePeriod", "daily"
    public PerEntryConfig perEntryConfig;
    public TimeConfig timeConfig;
    public VariableTimeConfig variableTimeConfig;
    public TimePeriodConfig timePeriodConfig;
    public DailyConfig dailyConfig;
    public AdditionalRules additionalRules;

    // 根据配置构建相应的计费策略
    public ParkingFeeStrategy buildStrategy() {
        ParkingFeeStrategy strategy = null;

        switch (billingType) {
            case "perEntry":
                strategy = new PerEntryRateStrategy(
                        perEntryConfig.singleEntryDurationMinutes,
                        BigDecimal.valueOf(perEntryConfig.singleEntryFee)
                );
                break;
            case "time":
                strategy = new FixedIntervalRateStrategy(
                        BigDecimal.valueOf(timeConfig.unitFee),
                        timeConfig.billingUnitMinutes
                );
                break;
            case "variableTime":
                strategy = new VariableRateStrategy(
                        BigDecimal.valueOf(variableTimeConfig.firstUnitFee),
                        BigDecimal.valueOf(variableTimeConfig.subsequentUnitFee),
                        variableTimeConfig.firstUnitMinutes,
                        variableTimeConfig.subsequentUnitMinutes
                );
                break;
            case "timePeriod":
            List<TimePeriodRateStrategy.TimePeriod> timePeriods = new ArrayList<>();
            for (TimePeriodConfig.Period period : timePeriodConfig.periods) {
                ParkingFeeStrategy periodStrategy;
                if ("time".equals(period.billingType)) {
                    periodStrategy = new FixedIntervalRateStrategy(
                            BigDecimal.valueOf(period.billingConfig.unitFee),
                            period.billingConfig.billingUnitMinutes
                    );
                } else {
                    periodStrategy = new VariableRateStrategy(
                            BigDecimal.valueOf(period.billingConfig.firstUnitFee),
                            BigDecimal.valueOf(period.billingConfig.subsequentUnitFee),
                            period.billingConfig.firstUnitMinutes,
                            period.billingConfig.subsequentUnitMinutes
                    );
                }
                timePeriods.add(new TimePeriodRateStrategy.TimePeriod(
                        LocalTime.parse(period.startTime),
                        LocalTime.parse(period.endTime),
                        periodStrategy
                ));
            }
            strategy = new TimePeriodRateStrategy(timePeriods);
            break;
            case "daily":
                strategy = new PerDayRateStrategy(
                        BigDecimal.valueOf(dailyConfig.dailyFee)
                );
                break;
        }

        // 应用附加规则
        if (strategy != null) {
            if (additionalRules != null) {
                if (additionalRules.freeMinutes > 0) {
                    strategy = new FreeMinutesDecorator(strategy, additionalRules.freeMinutes);
                }
                if (additionalRules.dailyCap != null) {
                    strategy = new DailyCappedFeeDecorator(strategy, BigDecimal.valueOf(additionalRules.dailyCap));
                }
                if (additionalRules.totalCap != null) {
                    strategy = new TotalCappedFeeDecorator(strategy, BigDecimal.valueOf(additionalRules.totalCap));
                }
            }
        }

        return strategy;
    }

    // 内部类用于解析 JSON 配置
    public static class PerEntryConfig {
        public long singleEntryDurationMinutes;
        public double singleEntryFee;
    }

    public static class TimeConfig {
        public long billingUnitMinutes;
        public double unitFee;
    }

    public static class VariableTimeConfig {
        public long firstUnitMinutes;
        public double firstUnitFee;
        public long subsequentUnitMinutes;
        public double subsequentUnitFee;
    }

    public static class TimePeriodConfig {
        public List<Period> periods;

        public static class Period {
            public String startTime;
            public String endTime;
            public String billingType;
            public BillingConfig billingConfig;
        }

        public static class BillingConfig {
            public long billingUnitMinutes;
            public double unitFee;
            public long firstUnitMinutes;
            public double firstUnitFee;
            public long subsequentUnitMinutes;
            public double subsequentUnitFee;
        }
    }

    public static class DailyConfig {
        public double dailyFee;
    }

    public static class AdditionalRules {
        public int freeMinutes;
        public Double dailyCap;
        public Double totalCap;
    }
}

3.11 停车计费配置文件

{
  "billingType": "variableTime",
  "perEntryConfig": {
    "singleEntryDurationMinutes": 1440,
    "singleEntryFee": 20.0
  },
  "timeConfig": {
    "billingUnitMinutes": 60,
    "unitFee": 3.0
  },
  "variableTimeConfig": {
    "firstUnitMinutes": 60,
    "firstUnitFee": 10.0,
    "subsequentUnitMinutes": 30,
    "subsequentUnitFee": 3.0
  },
  "timePeriodConfig": {
    "periods": [
      {
        "startTime": "08:00",
        "endTime": "19:00",
        "billingType": "variableTime",
        "billingConfig": {
          "firstUnitMinutes": 60,
          "firstUnitFee": 5.0,
          "subsequentUnitMinutes": 30,
          "subsequentUnitFee": 2.0
        }
      },
      {
        "startTime": "19:00",
        "endTime": "08:00",
        "billingType": "time",
        "billingConfig": {
          "billingUnitMinutes": 60,
          "unitFee": 10.0
        }
      }
    ]
  },
  "dailyConfig": {
    "dailyFee": 50.0
  },
  "additionalRules": {
    "freeMinutes": 15,
    "dailyCap": 100.0,
    "totalCap": 2000.0
  }
}

3.12 测试

/**
 * @ClassName: Main
 * @description: 测试
 * @author: atfwus
 * @date: 2024.10.22
 * @version: 1.0
 */
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.math.BigDecimal;
import java.time.LocalDateTime;

public class Main {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        File jsonFile = new File("parkingConfig.json");

        // 解析 JSON 文件
        ParkingConfig config = mapper.readValue(jsonFile, ParkingConfig.class);

        // 根据配置生成计费策略
        ParkingFeeStrategy strategy = config.buildStrategy();

        // 测试计费
        LocalDateTime entryTime = LocalDateTime.of(2024, 10, 15, 10, 0);
        LocalDateTime exitTime = LocalDateTime.of(2024, 10, 15, 18, 0);
        BigDecimal fee = strategy.calculateFee(entryTime, exitTime);
        System.out.println("总费用: " + fee);
    }
}

3.13 测试结果

总费用: 52.0

注意：上述代码未经过完善的单元测试和系统测试，如要用于生产环境，请先进行完善的测试。

4.总结

这种设计的高拓展性在于：

  • JSON 配置可以轻松设置和调整不同的计费规则，包括按次、时间均等、时间差异、分时段、按天等各种策略。
  • 策略模式和装饰器模式结合使得每种计费策略可以灵活组合，也可以添加额外规则如免费时长、封顶费用等。

ATFWUS 2024-10-22

业务流程的设计 (附加案例)
wnrun的博客
02-16 2万+
业务流程图,功能流程图,页面流程图,泳道图
停车场管理系统的设计与实现 毕业设计-附源码82061
Vxin_CXSJ881的博客
06-20 3071
停车场管理系统主要功能模块包括系统用户（管理员、停车用户）、模块管理（车辆信息、公告信息、挪车通知、停车位信息、车场区域、车位预约、车辆入库、车辆出库）等，采取面对对象的开发模式进行软件的开发和硬体的架设，能很好的满足实际使用的需求，完善了对应的软体架设以及程序编码的工作，采取Mysql作为后台数据的主要存储单元，采用springboot框架、Java技术、Ajax技术进行业务系统的编码及其开发，实现了本系统的全部功能。
Python小区停车场车辆计费管理系统的设计与实现
豆包程序员
01-17 605
Python版本：python3.7.7框架支持：flask/django开发软件：PyCharm浏览器：谷歌浏览器数据库：mysql数据库工具：Navicat。
汽车出入库的计时计费系统设计
qq_42443558的博客
04-08 7579
\documentclass{article} \ProvidesPackage{zhfontcfg} \begin{document} \end{document} \documentclass{article} \ProvidesPackage{zhfontcfg} \begin{document} \end{document}
基于springboot的停车场管理系统—计算机毕业设计源码82061
weixin_bysj1330的博客
07-26 583
停车场管理系统主要功能模块包括系统用户（管理员、停车用户）、模块管理（车辆信息、公告信息、挪车通知、停车位信息、车场区域、车位预约、车辆入库、车辆出库）等，采取Mysql作为后台数据的主要存储单元，采用springboot框架、Java技术、Ajax技术进行业务系统的编码及其开发
MVC 停车场管理系统java jsp 程序设计 课程设计 毕业设计-附源码02141
qq_42394862的博客
02-25 2086
MVC 停车场管理系统 java jsp 程序设计 课程设计 毕业设计-附源码02142
基于车牌识别算法的停车场管理系统-毕业设计源码03363
weixin_ZYKJ985的博客
02-04 553
本停车场管理系统基于先进的车牌识别算法，结合了图像处理技术，旨在提高停车场的管理效率和用户体验。系统能够实现对车辆进出的自动识别和记录，有效解决传统停车场管理中存在的人工查验和排队等问题。 通过车牌识别算法，系统能够实现对停车场内车辆的实时监测和统计，提供实时停车位信息和车辆流量分析，帮助停车场管理员进行智能化管理和调度，提升停车体验和管理效率。 基于车牌识别技术的停车场管理系统不仅提升了停车场的管理水平和服务质量，也有效减少了人力成本和提高了停车场的利用率。系统的应用将为城市交通管理和停车场运营.....
基于单片机的停车场车位管理系统设计
weixin_44453694的博客
07-14 1764
停车场车位管理系统是日常中随处可见的一种智能化车位管理技术，使用该技术可以提高车位管理效率，从而减轻人员车位管理工作负荷。本系统集成车牌识别、自动放行、自助缴费等技术，并且具备车位占用状态实时监测与车位数量实时统计、查询等功能，相比与传统停车场车位管理，本系统提高了车位管理效率，并且资源得以充分利用。本系统使用车牌号识别技术，自动识别进出场车辆的车牌号信息，能够有效的提高车辆进程效率。同时，本系统支持车位信息监测，可以及时的为车主搜寻空闲车位，避免了车主盲目寻找车位的烦恼。
Java毕设- 【基于SSM的停车场收费系统】附源码_Java练手项目_Java毕业设计
YMESSI0820的博客
08-10 318
本系统开发了一款基于Spring MVC + Spring + MyBatis开源框架，以及Tomcat和MySQL等技术支撑的智能停车场管理系统。该系统采用智慧化、信息化和自动化的方式，实现了对停车场管理的全方位监控与管理，有效减轻了人工压力，避免了人为错误带来的问题，同时也节省了人力成本。此外，该系统还具备灵活性和拓展性，能够满足不同需求主体的个性化要求，提高了停车场管理的安全性和效率。
智能停车计费系统 2024免费JAVA毕设
02-08
智能停车计费系统是一种现代化的停车管理解决方案，它通过集成计算机技术、网络通信技术、数据库技术以及物联网技术，实现对停车位的实时监控和管理，提供更为便捷和高效的停车服务。2024免费毕业设计成品是专为...
[matlab程序系统设计]MATLAB车牌出入库识别（GUI界面，计时计费，停车位计算，倾斜矫正）.zip
01-23
MATLAB车牌出入库识别系统是一种基于MATLAB平台开发的综合车牌识别软件，它集成了图形...MATLAB车牌出入库识别系统提供了一个功能全面、易于操作、可拓展性强的车牌管理解决方案，适合各类用户学习、实践和研究使用。
无人停车场计费系统毕业设计教程
本资源是一套关于无人停车场计费系统设计与实现的完整解决方案，适合用于多种场景，包括课程设计、个人DIY项目、毕业设计以及参加相关比赛。资源内容丰富，包含一篇10000字以上的毕业设计论文（Word文档版），以及...
javaee电子商城系统课程设计样本.doc
05-01
javaee电子商城系统课程设计样本.doc
scratch少儿编程逻辑思维游戏源码-糖果大爆险.zip
最新发布
05-01
scratch少儿编程逻辑思维游戏源码-糖果大爆险.zip
spring-boot-2.7.2.jar中文-英文对照文档.zip
05-01
# 压缩文件中包含： 中文-英文对照文档 jar包下载地址 Maven依赖 Gradle依赖 源代码下载地址 # 本文件关键字： jar中文-英文对照文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册 # 使用方法： 解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。 # 特殊说明： ·本文档为人性化翻译，精心制作，请放心使用。 ·只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等； ·不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。 # 温馨提示： （1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）； （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件；
spring-boot-1.3.6.RELEASE.jar中文-英文对照文档.zip
05-01
# 压缩文件中包含： 中文-英文对照文档 jar包下载地址 Maven依赖 Gradle依赖 源代码下载地址 # 本文件关键字： jar中文-英文对照文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册 # 使用方法： 解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。 # 特殊说明： ·本文档为人性化翻译，精心制作，请放心使用。 ·只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等； ·不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。 # 温馨提示： （1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）； （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件；
GIS安装施工综合方案.doc
05-01
GIS安装施工综合方案.doc
基于PHP+CSS+JS+MySQL的选题系统源码——B/S架构下多角色登录与权限管理
05-01
内容概要：本文详细介绍了选题系统源码，涵盖PHP、CSS、JavaScript和MySQL四种核心技术。系统采用B/S架构，支持管理员、审核员、教师和学生四种身份登录，每种身份有独立的功能权限。文中提供了详细的环境搭建指南，如使用phpStudy和Navicat进行项目管理和数据库操作。此外，还展示了关键代码片段，如登录验证、权限管理、数据库设计以及界面优化方法。同时，针对性能优化提出了建议，如解决N+1查询问题的方法。 适合人群：适用于有一定编程基础，尤其是对PHP和Web开发感兴趣的开发者和技术爱好者。 使用场景及目标：① 学习并掌握B/S架构的应用开发流程；② 实践多角色登录和权限管理的具体实现；③ 提升Web应用的界面优化和用户体验；④ 掌握数据库设计和性能优化技巧。 其他说明：本文不仅提供了完整的代码示例，还包括了详细的开发文档和支持材料，帮助读者快速上手并深入理解整个项目的构建过程。
scratch少儿编程逻辑思维游戏源码-下水道冒险猫.zip
05-01
scratch少儿编程逻辑思维游戏源码-下水道冒险猫.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ATFWUS

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值