停车场系统源码,java停车场系统源码,php停车场系统源码暂时没有

码云地址:https://gitee.com/wangdefu/caraprk_public?_from=gitee_search

源代码已经完全开源,还望大神发现问题多多指点,在下感激不尽,怎么部署和安装环境我已经在后面描述清楚了,这个主要关键还是对接硬件,如果你要改写底层硬件的协议,你用C来对接已经接口,内置到相机中去,这样也可以解决掉不需要场端要架电脑的问题,省掉很多麻烦

源代码开源地址:https://gitee.com/wangdefu/caraprk_public?_from=gitee_search

对接停车场硬件示例代码:

package com.google.gson;

import java.lang.reflect.Type;

import java.sql.Timestamp;

import java.text.DateFormat;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import com.google.gson.internal.$Gson$Preconditions;

import com.google.gson.internal.Excluder;

import com.google.gson.internal.bind.TreeTypeAdapter;

import com.google.gson.internal.bind.TypeAdapters;

import com.google.gson.reflect.TypeToken;

import com.google.gson.stream.JsonReader;

import static com.google.gson.Gson.DEFAULT_COMPLEX_MAP_KEYS;

import static com.google.gson.Gson.DEFAULT_ESCAPE_HTML;

import static com.google.gson.Gson.DEFAULT_JSON_NON_EXECUTABLE;

import static com.google.gson.Gson.DEFAULT_LENIENT;

import static com.google.gson.Gson.DEFAULT_PRETTY_PRINT;

import static com.google.gson.Gson.DEFAULT_SERIALIZE_NULLS;

import static com.google.gson.Gson.DEFAULT_SPECIALIZE_FLOAT_VALUES;

/**

*

Use this builder to construct a {@link Gson} instance when you need to set configuration

* options other than the default. For {@link Gson} with default configuration, it is simpler to

* use {@code new Gson()}. {@code GsonBuilder} is best used by creating it, and then invoking its

* various configuration methods, and finally calling create.

*

*

The following is an example shows how to use the {@code GsonBuilder} to construct a Gson

* instance:

*

*

* Gson gson = new GsonBuilder()

*    .registerTypeAdapter(Id.class, new IdTypeAdapter())

*    .enableComplexMapKeySerialization()

*    .serializeNulls()

*    .setDateFormat(DateFormat.LONG)

*    .setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE)

*    .setPrettyPrinting()

*    .setVersion(1.0)

*    .create();

*

*

*

NOTES:

*

    *

  • the order of invocation of configuration methods does not matter.
  • *

  • The default serialization of {@link Date} and its subclasses in Gson does

    *  not contain time-zone information. So, if you are using date/time instances,

    *  use {@code GsonBuilder} and its {@code setDateFormat} methods.

*

*

* @author Inderjeet Singh

* @author Joel Leitch

* @author Jesse Wilson

*/

public final class GsonBuilder {

  private Excluder excluder = Excluder.DEFAULT;

  private LongSerializationPolicy longSerializationPolicy = LongSerializationPolicy.DEFAULT;

  private FieldNamingStrategy fieldNamingPolicy = FieldNamingPolicy.IDENTITY;

  private final Map> instanceCreators

      = new HashMap>();

  private final List factories = new ArrayList();

  /** tree-style hierarchy factories. These come after factories for backwards compatibility. */

  private final List hierarchyFactories = new ArrayList();

  private boolean serializeNulls = DEFAULT_SERIALIZE_NULLS;

  private String datePattern;

  private int dateStyle = DateFormat.DEFAULT;

  private int timeStyle = DateFormat.DEFAULT;

  private boolean complexMapKeySerialization = DEFAULT_COMPLEX_MAP_KEYS;

  private boolean serializeSpecialFloatingPointValues = DEFAULT_SPECIALIZE_FLOAT_VALUES;

  private boolean escapeHtmlChars = DEFAULT_ESCAPE_HTML;

  private boolean prettyPrinting = DEFAULT_PRETTY_PRINT;

  private boolean generateNonExecutableJson = DEFAULT_JSON_NON_EXECUTABLE;

  private boolean lenient = DEFAULT_LENIENT;

  /**

  * Creates a GsonBuilder instance that can be used to build Gson with various configuration

  * settings. GsonBuilder follows the builder pattern, and it is typically used by first

  * invoking various configuration methods to set desired options, and finally calling

  * {@link #create()}.

  */

  public GsonBuilder() {

  }

  /**

  * Configures Gson to enable versioning support.

  *

  * @param ignoreVersionsAfter any field or type marked with a version higher than this value

  * are ignored during serialization or deserialization.

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  */

  public GsonBuilder setVersion(double ignoreVersionsAfter) {

    excluder = excluder.withVersion(ignoreVersionsAfter);

    return this;

  }

  /**

  * Configures Gson to excludes all class fields that have the specified modifiers. By default,

  * Gson will exclude all fields marked transient or static. This method will override that

  * behavior.

  *

  * @param modifiers the field modifiers. You must use the modifiers specified in the

  * {@link java.lang.reflect.Modifier} class. For example,

  * {@link java.lang.reflect.Modifier#TRANSIENT},

  * {@link java.lang.reflect.Modifier#STATIC}.

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  */

  public GsonBuilder excludeFieldsWithModifiers(int... modifiers) {

    excluder = excluder.withModifiers(modifiers);

    return this;

  }

  /**

  * Makes the output JSON non-executable in Javascript by prefixing the generated JSON with some

  * special text. This prevents attacks from third-party sites through script sourcing. See

  * Gson Issue 42

  * for details.

  *

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @since 1.3

  */

  public GsonBuilder generateNonExecutableJson() {

    this.generateNonExecutableJson = true;

    return this;

  }

  /**

  * Configures Gson to exclude all fields from consideration for serialization or deserialization

  * that do not have the {@link com.google.gson.annotations.Expose} annotation.

  *

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  */

  public GsonBuilder excludeFieldsWithoutExposeAnnotation() {

    excluder = excluder.excludeFieldsWithoutExposeAnnotation();

    return this;

  }

  /**

  * Configure Gson to serialize null fields. By default, Gson omits all fields that are null

  * during serialization.

  *

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @since 1.2

  */

  public GsonBuilder serializeNulls() {

    this.serializeNulls = true;

    return this;

  }

  /**

  * Enabling this feature will only change the serialized form if the map key is

  * a complex type (i.e. non-primitive) in its serialized JSON

  * form. The default implementation of map serialization uses {@code toString()}

  * on the key; however, when this is called then one of the following cases

  * apply:

  *

  *

Maps as JSON objects

  * For this case, assume that a type adapter is registered to serialize and

  * deserialize some {@code Point} class, which contains an x and y coordinate,

  * to/from the JSON Primitive string value {@code "(x,y)"}. The Java map would

  * then be serialized as a {@link JsonObject}.

  *

  *

Below is an example:

  *

  {@code

  *  Gson gson = new GsonBuilder()

  *      .register(Point.class, new MyPointTypeAdapter())

  *      .enableComplexMapKeySerialization()

  *      .create();

  *

  *  Map original = new LinkedHashMap();

  *  original.put(new Point(5, 6), "a");

  *  original.put(new Point(8, 8), "b");

  *  System.out.println(gson.toJson(original, type));

  * }

  * The above code prints this JSON object:

  {@code

  *  {

  *    "(5,6)": "a",

  *    "(8,8)": "b"

  *  }

  * }

  *

  *

Maps as JSON arrays

  * For this case, assume that a type adapter was NOT registered for some

  * {@code Point} class, but rather the default Gson serialization is applied.

  * In this case, some {@code new Point(2,3)} would serialize as {@code

  * {"x":2,"y":5}}.

  *

  *

Given the assumption above, a {@code Map} will be

  * serialize as an array of arrays (can be viewed as an entry set of pairs).

  *

  *

Below is an example of serializing complex types as JSON arrays:

  *

 {@code

  *  Gson gson = new GsonBuilder()

  *      .enableComplexMapKeySerialization()

  *      .create();

  *

  *  Map original = new LinkedHashMap();

  *  original.put(new Point(5, 6), "a");

  *  original.put(new Point(8, 8), "b");

  *  System.out.println(gson.toJson(original, type));

  * }

  *

  * The JSON output would look as follows:

  *

  {@code

  *  [

  *    [

  *      {

  *        "x": 5,

  *        "y": 6

  *      },

  *      "a"

  *    ],

  *    [

  *      {

  *        "x": 8,

  *        "y": 8

  *      },

  *      "b"

  *    ]

  *  ]

  * }

  *

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @since 1.7

  */

  public GsonBuilder enableComplexMapKeySerialization() {

    complexMapKeySerialization = true;

    return this;

  }

  /**

  * Configures Gson to exclude inner classes during serialization.

  *

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @since 1.3

  */

  public GsonBuilder disableInnerClassSerialization() {

    excluder = excluder.disableInnerClassSerialization();

    return this;

  }

  /**

  * Configures Gson to apply a specific serialization policy for {@code Long} and {@code long}

  * objects.

  *

  * @param serializationPolicy the particular policy to use for serializing longs.

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @since 1.3

  */

  public GsonBuilder setLongSerializationPolicy(LongSerializationPolicy serializationPolicy) {

    this.longSerializationPolicy = serializationPolicy;

    return this;

  }

  /**

  * Configures Gson to apply a specific naming policy to an object's field during serialization

  * and deserialization.

  *

  * @param namingConvention the JSON field naming convention to use for serialization and

  * deserialization.

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  */

  public GsonBuilder setFieldNamingPolicy(FieldNamingPolicy namingConvention) {

    this.fieldNamingPolicy = namingConvention;

    return this;

  }

  /**

  * Configures Gson to apply a specific naming policy strategy to an object's field during

  * serialization and deserialization.

  *

  * @param fieldNamingStrategy the actual naming strategy to apply to the fields

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @since 1.3

  */

  public GsonBuilder setFieldNamingStrategy(FieldNamingStrategy fieldNamingStrategy) {

    this.fieldNamingPolicy = fieldNamingStrategy;

    return this;

  }

  /**

  * Configures Gson to apply a set of exclusion strategies during both serialization and

  * deserialization. Each of the {@code strategies} will be applied as a disjunction rule.

  * This means that if one of the {@code strategies} suggests that a field (or class) should be

  * skipped then that field (or object) is skipped during serialization/deserialization.

  *

  * @param strategies the set of strategy object to apply during object (de)serialization.

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @since 1.4

  */

  public GsonBuilder setExclusionStrategies(ExclusionStrategy... strategies) {

    for (ExclusionStrategy strategy : strategies) {

      excluder = excluder.withExclusionStrategy(strategy, true, true);

    }

    return this;

  }

  /**

  * Configures Gson to apply the passed in exclusion strategy during serialization.

  * If this method is invoked numerous times with different exclusion strategy objects

  * then the exclusion strategies that were added will be applied as a disjunction rule.

  * This means that if one of the added exclusion strategies suggests that a field (or

  * class) should be skipped then that field (or object) is skipped during its

  * serialization.

  *

  * @param strategy an exclusion strategy to apply during serialization.

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @since 1.7

  */

  public GsonBuilder addSerializationExclusionStrategy(ExclusionStrategy strategy) {

    excluder = excluder.withExclusionStrategy(strategy, true, false);

    return this;

  }

  /**

  * Configures Gson to apply the passed in exclusion strategy during deserialization.

  * If this method is invoked numerous times with different exclusion strategy objects

  * then the exclusion strategies that were added will be applied as a disjunction rule.

  * This means that if one of the added exclusion strategies suggests that a field (or

  * class) should be skipped then that field (or object) is skipped during its

  * deserialization.

  *

  * @param strategy an exclusion strategy to apply during deserialization.

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @since 1.7

  */

  public GsonBuilder addDeserializationExclusionStrategy(ExclusionStrategy strategy) {

    excluder = excluder.withExclusionStrategy(strategy, false, true);

    return this;

  }

  /**

  * Configures Gson to output Json that fits in a page for pretty printing. This option only

  * affects Json serialization.

  *

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  */

  public GsonBuilder setPrettyPrinting() {

    prettyPrinting = true;

    return this;

  }

  /**

  * By default, Gson is strict and only accepts JSON as specified by

  * RFC 4627. This option makes the parser

  * liberal in what it accepts.

  *

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @see JsonReader#setLenient(boolean)

  */

  public GsonBuilder setLenient() {

    lenient = true;

    return this;

  }

  /**

  * By default, Gson escapes HTML characters such as < > etc. Use this option to configure

  * Gson to pass-through HTML characters as is.

  *

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @since 1.3

  */

  public GsonBuilder disableHtmlEscaping() {

    this.escapeHtmlChars = false;

    return this;

  }

  /**

  * Configures Gson to serialize {@code Date} objects according to the pattern provided. You can

  * call this method or {@link #setDateFormat(int)} multiple times, but only the last invocation

  * will be used to decide the serialization format.

  *

  *

The date format will be used to serialize and deserialize {@link java.util.Date}, {@link

  * java.sql.Timestamp} and {@link java.sql.Date}.

  *

  *

Note that this pattern must abide by the convention provided by {@code SimpleDateFormat}

  * class. See the documentation in {@link java.text.SimpleDateFormat} for more information on

  * valid date and time patterns.

  *

  * @param pattern the pattern that dates will be serialized/deserialized to/from

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @since 1.2

  */

  public GsonBuilder setDateFormat(String pattern) {

    // TODO(Joel): Make this fail fast if it is an invalid date format

    this.datePattern = pattern;

    return this;

  }

  /**

  * Configures Gson to to serialize {@code Date} objects according to the style value provided.

  * You can call this method or {@link #setDateFormat(String)} multiple times, but only the last

  * invocation will be used to decide the serialization format.

  *

  *

Note that this style value should be one of the predefined constants in the

  * {@code DateFormat} class. See the documentation in {@link java.text.DateFormat} for more

  * information on the valid style constants.

  *

  * @param style the predefined date style that date objects will be serialized/deserialized

  * to/from

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @since 1.2

  */

  public GsonBuilder setDateFormat(int style) {

    this.dateStyle = style;

    this.datePattern = null;

    return this;

  }

  /**

  * Configures Gson to to serialize {@code Date} objects according to the style value provided.

  * You can call this method or {@link #setDateFormat(String)} multiple times, but only the last

  * invocation will be used to decide the serialization format.

  *

  *

Note that this style value should be one of the predefined constants in the

  * {@code DateFormat} class. See the documentation in {@link java.text.DateFormat} for more

  * information on the valid style constants.

  *

  * @param dateStyle the predefined date style that date objects will be serialized/deserialized

  * to/from

  * @param timeStyle the predefined style for the time portion of the date objects

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @since 1.2

  */

  public GsonBuilder setDateFormat(int dateStyle, int timeStyle) {

    this.dateStyle = dateStyle;

    this.timeStyle = timeStyle;

    this.datePattern = null;

    return this;

  }

  /**

  * Configures Gson for custom serialization or deserialization. This method combines the

  * registration of an {@link TypeAdapter}, {@link InstanceCreator}, {@link JsonSerializer}, and a

  * {@link JsonDeserializer}. It is best used when a single object {@code typeAdapter} implements

  * all the required interfaces for custom serialization with Gson. If a type adapter was

  * previously registered for the specified {@code type}, it is overwritten.

  *

  *

This registers the type specified and no other types: you must manually register related

  * types! For example, applications registering {@code boolean.class} should also register {@code

  * Boolean.class}.

  *

  * @param type the type definition for the type adapter being registered

  * @param typeAdapter This object must implement at least one of the {@link TypeAdapter},

  * {@link InstanceCreator}, {@link JsonSerializer}, and a {@link JsonDeserializer} interfaces.

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  */

  @SuppressWarnings({"unchecked", "rawtypes"})

  public GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) {

    $Gson$Preconditions.checkArgument(typeAdapter instanceof JsonSerializer

        || typeAdapter instanceof JsonDeserializer

        || typeAdapter instanceof InstanceCreator

        || typeAdapter instanceof TypeAdapter);

    if (typeAdapter instanceof InstanceCreator) {

      instanceCreators.put(type, (InstanceCreator) typeAdapter);

    }

    if (typeAdapter instanceof JsonSerializer || typeAdapter instanceof JsonDeserializer) {

      TypeToken typeToken = TypeToken.get(type);

      factories.add(TreeTypeAdapter.newFactoryWithMatchRawType(typeToken, typeAdapter));

    }

    if (typeAdapter instanceof TypeAdapter) {

      factories.add(TypeAdapters.newFactory(TypeToken.get(type), (TypeAdapter)typeAdapter));

    }

    return this;

  }

  /**

  * Register a factory for type adapters. Registering a factory is useful when the type

  * adapter needs to be configured based on the type of the field being processed. Gson

  * is designed to handle a large number of factories, so you should consider registering

  * them to be at par with registering an individual type adapter.

  *

  * @since 2.1

  */

  public GsonBuilder registerTypeAdapterFactory(TypeAdapterFactory factory) {

    factories.add(factory);

    return this;

  }

  /**

  * Configures Gson for custom serialization or deserialization for an inheritance type hierarchy.

  * This method combines the registration of a {@link TypeAdapter}, {@link JsonSerializer} and

  * a {@link JsonDeserializer}. If a type adapter was previously registered for the specified

  * type hierarchy, it is overridden. If a type adapter is registered for a specific type in

  * the type hierarchy, it will be invoked instead of the one registered for the type hierarchy.

  *

  * @param baseType the class definition for the type adapter being registered for the base class

  *        or interface

  * @param typeAdapter This object must implement at least one of {@link TypeAdapter},

  *        {@link JsonSerializer} or {@link JsonDeserializer} interfaces.

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @since 1.7

  */

  @SuppressWarnings({"unchecked", "rawtypes"})

  public GsonBuilder registerTypeHierarchyAdapter(Class baseType, Object typeAdapter) {

    $Gson$Preconditions.checkArgument(typeAdapter instanceof JsonSerializer

        || typeAdapter instanceof JsonDeserializer

        || typeAdapter instanceof TypeAdapter);

    if (typeAdapter instanceof JsonDeserializer || typeAdapter instanceof JsonSerializer) {

      hierarchyFactories.add(TreeTypeAdapter.newTypeHierarchyFactory(baseType, typeAdapter));

    }

    if (typeAdapter instanceof TypeAdapter) {

      factories.add(TypeAdapters.newTypeHierarchyFactory(baseType, (TypeAdapter)typeAdapter));

    }

    return this;

  }

  /**

  * Section 2.4 of JSON specification disallows

  * special double values (NaN, Infinity, -Infinity). However,

  * Javascript

  * specification (see section 4.3.20, 4.3.22, 4.3.23) allows these values as valid Javascript

  * values. Moreover, most JavaScript engines will accept these special values in JSON without

  * problem. So, at a practical level, it makes sense to accept these values as valid JSON even

  * though JSON specification disallows them.

  *

  *

Gson always accepts these special values during deserialization. However, it outputs

  * strictly compliant JSON. Hence, if it encounters a float value {@link Float#NaN},

  * {@link Float#POSITIVE_INFINITY}, {@link Float#NEGATIVE_INFINITY}, or a double value

  * {@link Double#NaN}, {@link Double#POSITIVE_INFINITY}, {@link Double#NEGATIVE_INFINITY}, it

  * will throw an {@link IllegalArgumentException}. This method provides a way to override the

  * default behavior when you know that the JSON receiver will be able to handle these special

  * values.

  *

  * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern

  * @since 1.3

  */

  public GsonBuilder serializeSpecialFloatingPointValues() {

    this.serializeSpecialFloatingPointValues = true;

    return this;

  }

  /**

  * Creates a {@link Gson} instance based on the current configuration. This method is free of

  * side-effects to this {@code GsonBuilder} instance and hence can be called multiple times.

  *

  * @return an instance of Gson configured with the options currently set in this builder

  */

  public Gson create() {

    List factories = new ArrayList(this.factories.size() + this.hierarchyFactories.size() + 3);

    factories.addAll(this.factories);

    Collections.reverse(factories);

    Collections.reverse(this.hierarchyFactories);

    factories.addAll(this.hierarchyFactories);

    addTypeAdaptersForDate(datePattern, dateStyle, timeStyle, factories);

    return new Gson(excluder, fieldNamingPolicy, instanceCreators,

        serializeNulls, complexMapKeySerialization,

        generateNonExecutableJson, escapeHtmlChars, prettyPrinting, lenient,

        serializeSpecialFloatingPointValues, longSerializationPolicy, factories);

  }

  private void addTypeAdaptersForDate(String datePattern, int dateStyle, int timeStyle,

      List factories) {

    DefaultDateTypeAdapter dateTypeAdapter;

    if (datePattern != null && !"".equals(datePattern.trim())) {

      dateTypeAdapter = new DefaultDateTypeAdapter(datePattern);

    } else if (dateStyle != DateFormat.DEFAULT && timeStyle != DateFormat.DEFAULT) {

      dateTypeAdapter = new DefaultDateTypeAdapter(dateStyle, timeStyle);

    } else {

      return;

    }

    factories.add(TreeTypeAdapter.newFactory(TypeToken.get(Date.class), dateTypeAdapter));

    factories.add(TreeTypeAdapter.newFactory(TypeToken.get(Timestamp.class), dateTypeAdapter));

    factories.add(TreeTypeAdapter.newFactory(TypeToken.get(java.sql.Date.class), dateTypeAdapter));

  }

}

功能介绍】:

①兼容市面上主流的多家相机,理论上兼容所有硬件,可灵活扩展,②相机识别后数据自动上传到云端并记录,校验相机唯一id和硬件序列号,防止非法数据录入,③用户手机查询停车记录详情可自主缴费(支持微信,支付宝,银行接口支付,支持每个停车场指定不同的商户进行收款),支付后出场在免费时间内会自动抬杆。④支持app上查询附近停车场(导航,可用车位数,停车场费用,优惠券,评分,评论等),可预约车位。⑤断电断网支持岗亭人员使用app可接管硬件进行停车记录的录入。

【技术架构】:

后端开发语言java,框架oauth2+springboot2+doubble2.7.3,数据库mysql/mongodb/redis,即时通讯底层框架netty4,安卓和ios均为原生开发,后台管理模板vue-typescript-admin-template,文件服务fastDFS,短信目前仅集成阿里云短信服务。为千万级数据而生,千万级用户无忧,目前真实用户40w无压力,大数据时代物联网必备

【开源情况】:

代码完全开源,不存在授权问题,完全自主原创,不存在任何后门,不使用任何第三方私有jar包,性能和安全完全自主可控,想怎么耍就这么耍,就是这么任性,后续更新的话本人会持续更新部署教程。代码专业规范,新手看得懂,高手喜欢用。本系统完全免费

【部署环境】:

目前仅测试linux环境一切正常,win环境没部署过,演示地址在本文章末尾

【关于作者】:

屌丝码农一枚,4年前曾就职于开发停车场系统的公司,发现目前国内该领域垄断,技术过于陈旧,没有一个规范,故个人用来接近1年的时间在业余时间开发出这种系统,现代化标准的互联网应用,定位大型物联网大数据云平台系统,存在不足之处还望多多提宝贵意见,让我们打破市场垄断,让物联网应用更好的服务生活社会

软件架构

一、技术构成简述 (一)编程语言与架构简述 1.开发语言 (1)服务端 服务端语言目前均采用java语言开发,jdk版本要求1.8+。开发框架为springboot2+dubbo,鉴权采用oauth2,DB操作框架Mybaits,即时通讯底层框架与协议netty4

(2)客户端 目前我们主要客户端分为三个场景,分别为安卓,ios,微信公众号。安卓与ios均为原生开发,H5页面web端框架为vue

(3)后台管理 后台管理前端框架采用的是主流的vue element admin(TypeScript版本),分层清晰,官方文档完整,社区活跃

2.数据存储 (1)重要数据存储 重要数据均采用mysql进行存储,支持部署主从,大部分数据尽可能进行事务处理,确保数据容灾性

(2)一般数据存储 非重要性数据例如聊天内容,系统消息通知,广告等数据均存储于mongodb数据库中

(3)缓存数据存储 微小量缓存会存在mysql中,例如评论的前N条评论快照会超小量进行字段适当冗余,在提高存储性价比情况下大大提高数据的查询能力。其它大部分数据缓存均存储于redis数据中

3.性能与安全 (1)性能解决方案 架构与技术解决方案均为本团队一线5年开发经验总结,目前我们正在接触的项目真实用户40w+,毫无压力,我们系统采用的架构与技术均在仔细多方面综合考虑后多次调整,采用更加合理,性能更佳的模式与解决方案

(2)安全解决方案 所有请求均需携带jwt串token进行访问,每个接口服务和管理服务均需配置公钥文件且具有jwt串token合法性校验能力,用户权限服务携带私钥文件负责密钥生成

4.架构与生命力 (1)采用架构 本系统采用阿里巴巴微服务框架dubbo来进行实现微服务提供能力,追求高性能,高可用,超细粒度独立微服务,相同服务可以动态灵活增加与减少,支持不停机发布新版本服务。每个服务之间均为独立存在,互不影响。例如短信发送,支付,订单,停车场系统接口,停车场后台管理,停车场提供者服务等均为独立的服务。

(2)架构潜力 整个系统众多服务分工明确,细粒度微服务,实现真正的插拔服务,功能的删减或停用,新增等均可在不破坏和入侵原来系统的前提下满足新的开发需求

5.二次开发说明 (1)适用客户对象 ①本身有互联网it编程技术和经验或者拥有技术团队的。 ②不具备第一个条件但是费用预算比较充足,二次开发需求少或者愿意支付高额定制费的 (2)团队要求 服务器运维,安卓与ios开发者,web前端开发者,java实际开发经验2年+开发者

(3)技术要求 过硬的java编程能力,网络编程能力,数据库设计与优化能力,架构设计能力,微服务思维能力,成熟的前端技术开发能力,中大型系统部署与运营能力

(4)硬件要求 Linux操作系统,4核8G(最低)5M带宽,可多台服务器中的微服务指向统一微服务调度中心(本系统微服务调度中心管理平台zookeeper)

(二)软件与硬件数据交互简述 1.硬件端 (1)目前解决方案 封装工具类,兼容市场主流硬件设备,只负责各类硬件数据封装为统一数据结构。硬件发包目前多为http主动推送数据,被动接受服务端返回指令

(2)未来解决方案 改造主流厂商硬件底层服务系统,新增硬件规范的合法身份数据,采用长连接进行数据交互,保证数据与指令的实时性与可靠性得到更好的保障

2.服务端 (1)被动处理硬件数据 中间件处理各类前端数据,接收硬件推送数据,解析,计算,做出相应反馈

(2)主动通知硬件发生事件行为 长连接推送指令,例如开闸,实时动态配置硬件数据等,

二、常规功能简述 (一)基础功能 1.硬件管理 支持单个硬件管理与记录,硬件在线状态,维修与进度记录等。与指定停车场出入口进行绑定,均有记录GPS位置

2.停车场管理 不同时段费用配置,每日封顶因素综合参与动态计费,也支持静态+每日上限计费。支持查询附近停车场功能

3.停车记录管理 详细记录产生时间,地点,进出口位置,进出时间,异常数据实时推送与快速处理

4.支付机构管理 每个停车场的支付账号均可以独立配置,支持同一个停车场使用多家支付机构进行支付,例如支付宝,微信,银联等。

5.支付与优惠活动管理 支付宝与微信,银联都均支持免密支付(无感支付)。本系统自带优惠券功能,支持支持多种套餐自定义与用户进行快捷手机上下单随时购买

(二)特色功能 1.异常数据实时推送,汇报,及时处理,提前预知与通知 2.即时通讯功能(IM聊天沟通) 性能,架构,优化等均参考微信聊天功能机制进行开发

3.行业好友与圈子 让该应用不止只能停车,还能交到志同道合的行业知音,让应用更有温度

4.商城与营销功能 此功能主要考虑到使用者有运营周边的兴趣和能力,在商城和广告营销上进行盈利

安装教程

安装JDK1.8+

安装MySQL5.6+ 安装MongoDB 安装Redis 安装FastDFS 安装Zookeeper

将打包好的代码上传到服务器上,直接运行jar包即可

使用说明(swagger2文档)

【用户基础数据相关】:http://139.9.155.149:8080/swagger-ui.html 【停车场相关】:http://139.9.155.149:8089/swagger-ui.html 【短信】:http://139.9.155.149:8085/swagger-ui.html 【文件上传】:http://139.9.155.149:8088/swagger-ui.html 【支付相关】:http://139.9.155.149:8096/swagger-ui.html

参与贡献

Fork 本仓库

新建 Feat_xxx 分支

提交代码

新建 Pull Request

演示地址

http://139.9.155.149 admin 123456

如果您发现有代码有什么不足之处请跟我留言

你可能感兴趣的:(停车场系统源码,java停车场系统源码,php停车场系统源码暂时没有)