零零天

智能停——基于云计算的停车服务平台

目录
1.系统功能概述 3
2.系统设计 3
2.1系统总体架构 3
2.2收费规则设计 5
2.3核心功能模块 1
3.系统功能操作说明 1
3.1用户操作 1
3.1.1 登录 1
3.1.2 注册 3
3.1.3 忘记密码 4
3.2停车场管理员 6
3.2.1 首页 6
3.2.2 停车场管理 8
3.2.3 设备管理 19
3.2.4 车辆管理 21
3.2.5 报表管理 23
3.2.6 公告发布 29
3.3系统管理员 31
3.3.1 首页 31
3.3.2 停车场管理 32
3.3.3 统计分析 33
3.3.4 用户数据 43
4.源代码 46
4.1服务端 46
Service实现层 213
POJO类 297
Fare收费规则模块 396
Constant常量 430
Utils工具类 434
程序入口 488
Mapper层 491
Mapper Xml编写 512
配置文件 614
config 框架配置 619
conf 项目配置 634
项目依赖 638
4.2客户端 642
4.2.1 用户界面UI 642
4.2.2 组件 651
4.2.3 页面 668
4.2.4 路由配置 668
4.2.5项目总配置 674
4.2.6项目入口文件 677

1.系统概述
利用物联网、移动互联网通信技术和云计算技术，建设一体化的停车服务平台，实现的主要功能包括：通过扫车牌，实现车辆的自动入场、计（时）费，以及自动收费和出场功能，全程.实现停车场的无人值守，降低运营成本；借助云端服务，通过集中托管各停车场的位置、停车位数量等信息，并实时采集各停车场的可用停车位的数量等信息，为移动终端用户实时查询并推荐可用的停车位，且基于位置服务，为移动终端用户导航到所预约或预定停车位所在的停车场，这在一定程度上缓解停车难的问题；基于大数据分析，统计并发布区域内各个停车场的使用状况，含使用效率、繁忙时段等信息，移动终端用户可根据查询到的停车场使用状况，有助于满足其合理出行的需要，以及引导停车场的配套建设和规划的有效性。

2.系统设计
2.1系统总体架构
系统架构如图2-1所示，主要分为三层，分别为：客户层、应用层、数据层。
图2-1 系统结构图
（1）客户层
主要实现协议为HTTP和Socket，HTTP是实现App与服务器的交互，Socket主要是实现传输芯片（硬件端）与服务器的实时交互。
（2）应用层
会话层：主要用Nginx来进行路由控制以及转发服务：主要是置于TOMCAT中得java程序提供的RestApi和WebService。
业务逻辑：主要由Java编写的逻辑代码，包括数据查询，报表管理，数据监听，收费规则管理等其他的一些公共的逻辑。
（3）数据层
数据访问：主要是利用Spring jdbc/Redis来进行数据访问。
数据存储：Redis缓存+Mysql存储，Redis主要是存放停车场实时更新的数据信息。Mysql主要存储，实时性不太强的信息。

应用层执行架构：
服务器操作系统为Centos6.2,
Nginx:负载均衡，路由分发。
Tomcat：运行Java后台服务程序
数据执行架构：
服务器操作系统为Centos6.2,以及Redis缓存，Mysql数据库。

2.2收费规则设计
利用停车场现有设备（摄像头），获取到车辆信息进行处理，对车辆进行自动识别，识别到车辆信息和停车动作后，调用云端服务功能，验证该车辆订单，完成自动扣费，收费系统架构图如图2-2所示。
图2-2 收费系统架构图

扣费的方式：支付宝、微信、银行卡均可。（根据默认扣费方式自动收费）
时长收费规则：按照停车时间长度收费。
前N小时收费：该规则包含免费收费段（免费段），和优惠收费段，停车场可自定义该两端的收费段，可以通过调节收费段只需要“免费段”，“优惠段”
阶梯收费段：停车场可在该段细粒度定义时间间隔及间隔的收费标准
超过阶梯收费区域：用户的停车时间超过阶梯收费规则可按该段收费规则收费

时制收费规则：
对于每天可以划分不同时间段进行收费，大致分为“凌晨”，“早上”，“中午”，“下午”，“傍晚”，“深夜”，停车场可根据需要，在各个时段指定收费规则
收费规则折扣指定：各个阶段的收费规则都可以定义，“折扣”，“额定优惠”，“单元收费”，“阶段最大收费”，几个指标来组合制定出“活动价”，“高峰期时段价”，等等
额定优惠：指一次性优惠一定的金额。
单元收费：指定计费单元，N元/U小时中U的大小。
阶段最大收费：指定阶梯收费阶段中最多的费用。

停车场可以综合上述收费标准，可以制定出满足各自需求的收费标准，特别是在不同的时段（“高峰期”，“低潮区”，“正常区”），以及推出各种活动（“活动价”）等上打造更方便，灵活，快速，高效的收费系统。

2.3核心功能模块
主要由停车场用户模块和网站管理模块
停车场管理员：主要由停车场信息管理，收费管理，报表管理
系统管理员：主要管理停车场和用户信息已经对停车场应用的授权管理

3.系统功能操作说明
3.1用户操作
3.1.1 登录
用户进入系统登录页面，用户输入用户名以及登录密码，选取自己的用户类型（系统默认为停车场管理员），用户正确填写信息后登录进系统。
其它功能：
1、自动登录：用户勾选自动登录则允许网页记住密码，下次登录可填写用户名直接登录。
2、立即注册：用户若无账户信息可选择立即注册功能，注册新账号。
3、忘记密码：若忘记密码可选择忘记密码功能，找回密码。
登录界面如图2-1所示。

图2-1 登录系统
选取用户类型如图2-2所示。

图2-2用户类型选取

在登录填写信息时未正确输入相关信息，会有相关提示。如图2-3所示。

图2-3 登录界面
3.1.2 注册
停车场管理员用户进入系统注册页面，用户输入用户名、手机号，登录密码、再次确认的密码、短信验证码（用户输入手机号后点击发送按钮可获取短信验证码），用户正确填写所有信息后在本系统注册新帐号。
其它功能：
1、记住密码：用户勾选记住密码则允许网页记住密码，下次登录可填写用户名直接登录。
2、直接登录：用户切换到登录界面登录帐号。
3、忘记密码：若忘记密码可选择忘记密码功能，找回密码。
注册界面如图2-4所示。

图2-4 注册界面
在注册填写信息时未正确输入相关信息，会有相关提示。如图2-5所示。

图2-5 注册界面
3.1.3 忘记密码
停车场管理员用户进入密码重置页面，用户输入手机号，新密码、再次确认的密码、短信验证码（用户输入手机号后点击发送按钮可获取短信验证码），用户正确填写所有信息后在本系统注册新帐号。
其它功能：
1、立即注册：用户若无账户信息可选择立即注册功能，注册新账号。
2、自动登录：用户勾选自动登录则允许网页记住密码，下次登录可填写用户名直接登录。
3、立即登录：用户切换到登录界面登录帐号。
密码重置页面如图2-6所示。

图2-6 密码重置界面
在重置密码填写信息时未正确输入相关信息，会有相关提示。如图2-7所示。

图2-7 密码重置界面

3.2停车场管理员
3.2.1 首页
停车场管理员进入系统首页，首页导航功能包括：
1、帐号信息显示与操作
1）帐号名称：查看账户信息
2）安全设置：设置帐号相关信息
3）退出帐号：退出当前登录
2、停车场：切换到管理停车场界面
3、设备管理：管理停车场车位
4、车辆管理：管理停车场来往车辆
5、报表管理：查看停车场相关数据报表
6、公告发布：发布相关停车场公告
7、导航条：显示当前所在页面
停车场管理员操作首页如图2-8所示。

图2-8 停车场管理员操作首页
帐号服务如图2-9所示。

图2-9 帐号服务
导航条如图2-10所示。

图2-10 导航条
3.2.2 停车场管理
3.2.2.1 新增停车场
停车场管理员选中新增停车场，即->“新增停车场”，可增加所管理的停车场。
需要输入的信息有停车场名称、所在区域、详细地址、停车场营业执照、停车位、停车场类型、停车场负责人、经营人的身份证号以及关于停车场的简单描述。如图2-11所示。

图2-11 新增停车场

用户选择停车场所在区域，如图2-12所示。

图2-12 选择所在区域

用户上传营业执照，如图2-13、图2-14所示。

图2-13 上传营业执照

图2-14 上传营业执照

正确填写相关信息后添加停车场成功。如图2-15所示。

图2-15 添加成功
3.2.2.2 查看停车场信息
停车场管理员选中停车场信息，即->“停车场信息”，可查看所管理的停车场的相关信息。
停车场管理员帐号下并未有停车场信息时，点击添加停车场可切换至添加停车场信息页面。停车场信息界面如图2-16所示。

图2-16 停车场信息

停车场管理员账号下已存有停车场信息时，可查看到所管理的停车场编号、停车场名称、所在地址、计价方式、停车位、停车场类型、停车场负责人、经营人身份证号和停车场简述。
点击编辑按钮可编辑该停车场信息，点击删除按钮可删除该条停车场信息。
停车场界面信息如图2-17所示。

图2-17 停车场信息

用户选择编辑停车场信息功能，修改已存在停车场信息。
可修改的信息包括停车场名称、停车场地址、详细地址、停车位、停车场类型、停车场负责人、经营人的身份证号以及关于停车场的简单描述。修改完成且信息无误后点击确认按钮则保存新信息，点击取消则放弃编辑停车场信息。
编辑停车场信息界面如图2-18所示。

图2-18 编辑停车场信息

用户选择删除停车场信息功能，删除已存在停车场信息。
选择删除停车场信息，系统会再次确认，若确定则继续删除，若放弃则关闭页面。如图2-19所示。

图2-19 是否删除停车场

选择确认删除停车场信息，删除停车场成功，如图2-20所示。

图2-20 成功删除停车场信息
3.2.2.3 停车场收费
停车场管理员选中收费标准，即->“收费标准”，可设置所管理的停车场的收费规则。
停车场管理员需要输入：
1、停车场编号
2、用户类型
3、收费类型（选择用户类型后出现对应的收费类型）
4、收费细则（选择收费类型后出现对应的收费细则）
5、收费折扣（选择收费类型后出现收费折扣输入框）
收费初始界面如图2-21所示。

图2-21 收费

停车场管理员需要对不同用户类型设置相应的收费规则，选择用户类型，可选择的用户类型有临时用户、期卡用户、充值卡用户。界面如图2-22所示。

图2-22 选择卡用户类型

1）临时用户
停车场管理员选择为临时用户设置规则，即->“临时用户”，可设置的规则有按阶段收费、按时收费、按天收费。如图2-23所示。

图2-23 临时卡收费类型

停车场管理员选择设置按阶段收费，即->“按阶段收费”，停车场管理员填写收费细则，填写时间段、该时间段对应的收费。点击“＋”按钮后添加下一阶段，默认下一阶段起始时间为上一阶段结束的时间。如图2-24 图2-25所示。

图2-24 临时卡按阶段收费

图2-25 临时卡按阶段收费

停车场管理员选择设置按时收费，即->“按时收费”，停车场管理员填写收费细则，输入按时收费的收费价格。如图2-26所示。

图2-26 临时卡按时收费

停车场管理员选择设置按天收费，即->“按天收费”，停车场管理员填写收费细则，输入按天收费的收费价格。如图2-27所示。

图2-27 临时卡按天收费
2）期卡用户
停车场管理员选择为期卡用户设置规则，即->“期卡用户”，可设置的规则有按月收费、按季收费、按年收费。如图2-28所示。

图2-28 期卡收费类型

停车场管理员选择设置按月收费，即->“按月收费”，停车场管理员填写收费细则，输入按月收费的收费价格。如图2-29所示。

图2-29 期卡按月收费

停车场管理员选择设置按季收费，即->“按季收费”，停车场管理员填写收费细则，输入按季收费的收费价格。如图2-30所示。

图2-30 期卡按季收费

停车场管理员选择设置按年收费，即->“按年收费”，停车场管理员填写收费细则，输入按年收费的收费价格。如图2-31所示。

图2-31 期卡按年收费
3）充值卡用户
停车场管理员选择为充值卡用户设置规则，即->“充值卡用户”，填写用户收费细则。如图2-32所示。

图3-32 充值卡收费

3.2.3 设备管理
3.2.3.1 车位状态管理
停车场管理员选中停车场信息，即->“车位状态管理”，可查看所管理的停车场的相关设备信息。包括停车场的总车位数、剩余车位数、预订车位数、车位状态以及停车场内每个车位的实时情况。
车位实时情况包括车位所属片区、片区号、泊位号、泊位状态、所在车辆的车牌号（若无车辆则不现实）、预订的车牌号（若无预订则不显示）。
其它功能：
1、输入内容可检索停车场指定车位信息。
2、选择表格操作栏编辑选项对该条车位信息进行编辑。
3、选择表格操作栏移除选项对该条车位信息进行移除。
停车场信息界面如图2-33所示。

图2-33 停车场设备信息

停车场车位信息界面如图2-34所示。

图2-34 停车场车位信息界面

选择蓝色编辑按钮，可批量管理车位信息。如图2-35所示。

图2-35 批量管理
3.2.3.2 泊车流水
停车场管理员选中泊车流水，即->“泊车流水”，可查看所管理的停车场的泊车流水信息。泊车流水信息包括该流水的所属片区、片区号、泊位号、泊位状态、变化时间、是否预订、相关车牌号、进／出／预订情况。
其它功能：
1、表格底操作区域可选择每页信息条数、前往指定页面。
2、输入内容可检索停车场指定车位信息。
3、选择表格操作栏编辑选项对该条泊车流水信息进行编辑。
4、选择表格操作栏移除选项对该条泊车流水信息进行移除。
停车场泊车流水如图2-36所示。

图2-36 泊车流水

3.2.4 车辆管理
3.2.4.1 会员车辆
停车场管理员选中会员车辆，即->“会员车辆”，可查看所管理的停车场的会员车辆信息。会员车辆信息包括车辆的车牌号、车辆品牌、所属帐号、所属人姓名、所属人身份证号、添加时间、停放次数。
其它功能：
1、表格底操作区域可选择每页信息条数、前往指定页面。
2、输入内容可检索停车场指定车位信息。
3、选择表格操作栏拉黑选项拉黑该车。
4、选择表格操作栏编辑选项对该条信息进行编辑。
5、选择表格操作栏移除选项对该条信息进行移除。
会员车辆信息界面如图2-37所示。

图2-37 停车场会员车辆
3.2.4.2 黑名单
停车场管理员选中黑名单，即->“黑名单”，可查看所管理的停车场的黑名单车辆信息。黑名单车辆信息包括车辆的车牌号、欠费金额、欠费时间、欠费次数。
其它功能：
1、表格底操作区域可选择每页信息条数、前往指定页面。
2、输入内容可检索停车场指定车位信息。
3、选择表格操作栏查看选项查看具体信息。
4、选择表格操作栏编辑选项对该条信息进行编辑。
5、选择表格操作栏移除选项对该条信息进行移除。
黑名单车辆信息界面如图2-38所示。

图2-38 停车场黑名单
3.2.5 报表管理
3.2.5.1 泊车报表
停车场管理员选中泊车报表，即->“泊车报表”，查看所管理的停车场指定时间内的泊车信息报表（默认时间为一周），可查看的报表如下：
1、停车场的泊车次走势图。
2、停车场的泊车评价分析图。
3、停车场的泊车访客类型占比图。
4、停车场的累积泊车次。
5、停车场的累积评价次。
6、停车场泊车次最少的时间。
7、停车场泊车次最多的时间。
8、停车场的平均泊车次。
其它功能：选择时间按钮指定查看的时间段（一周、一月、一年）
泊车报表如图2-39 图2-40所示。

图2-39 泊车报表界面

图2-40 泊车报表界面

泊车次走势图，可查看指定时间段的泊车次数。
1、图数据：
1）纵坐标：泊车次。
2）横坐标：指定时间的构成单位。
3）红线：泊车次。停车场指定时间段的所有泊车次数总和。
2、图功能：
1）移动鼠标在指定时间查看详细信息，包括对应车次与时间
2）选择时间按钮指定查看的时间段（一周、一月、一年）
如图2-41所示。

图2-41 泊车次走势图

泊车评价分析图，可查看指定时间段的泊车评价报表。
1、图数据：
1）红色块：不满意
2）蓝黑色块：还行
3）绿色块：一般
4）橙色块：满意
5）青色块：非常满意
2、图功能：
1）移动鼠标在指定色块查看详细信息，包括对应人次与占比
2）选择时间按钮指定查看的时间段（一周、一月、一年）
如图2-42所示。

图4-42 泊车评价分析

泊车访客类型占比图，可查看指定时间段的泊车访客类型占比。
1、图数据：
1）红色块：临时用户
2）蓝黑色块：期卡用户
3）绿色块：充值卡用户
2、图功能：
1）移动鼠标在指定色块查看详细信息，包括对应人次与占比
2）选择时间按钮指定查看的时间段（一周、一月、一年）
如图2-43所示。

图4-43 访客类型占比图
3.2.5.1 收入流水
停车场管理员选中收入流水，即->“收入流水”，查看所管理的停车场指定时间内的收入流水报表（默认时间为一周），可查看的报表如下：
1、停车场的收入流水走势图。
2、停车场的收入构成单元图。
3、停车场的收入来源占比图。
4、停车场的充值卡持有人数。
5、停车场的期卡持有人数。
6、停车场临时卡停车次数。
其它功能：选择时间按钮指定查看的时间段（一周、一月、一年）
收入流水报表如图4-44 图4-45所示。

图4-44 收入流水界面

图4-45 收入流水界面

停车场收入流水走势图，可查看指定时间段的收入情况。
1、图数据：
1）纵坐标：泊车次。
2）横坐标：指定时间的构成单位。
3）红线：停车场收入。停车场指定时间段的停车场收入总和。
2、图功能：
1）移动鼠标在指定时间查看详细信息，包括对应收入与时间
2）选择时间按钮指定查看的时间段（一周、一月、一年）
如图2-46所示。

图2-46 停车场收入

停车场收入构成单元图，可查看指定时间段的收入构成单元。
1、图数据：
1）纵坐标：停车场收入，单位：元。
2）横坐标：收入总值、临时卡占值、期卡占值、充值卡占值。
2、图功能：
1）移动鼠标在指定时间查看详细信息，包括对应组成成分与收入
2）选择时间按钮指定查看的时间段（一周、一月、一年）
如图2-47所示。

图2-47 收入构成单元
停车场收入来源占比图，可查看指定时间段的收入来源占比。
1、图数据：
1）红色块：临时卡
2）蓝黑色块：期卡
3）绿色块：充值卡
2、图功能：
1）移动鼠标在指定色块查看详细信息，包括对应收入与占比
2）选择时间按钮指定查看的时间段（一周、一月、一年）
如图2-48所示。

图4-48 收入来源占比图
3.2.6 公告发布
3.2.6.1 发布公告
停车场管理员选中发布公告，即->“发布公告”，可发布停车场的公告。
需要输入的信息有公告名称、发布人、所见区域、公告类型、公告内容，还可上传相关附件。如图2-49所示。

图2-49 发布公告

编辑公告内容，停车场管理员选择添加内容，即->“添加内容”，添加公告内容。如图2-50 图2-51所示。

图2-50 编辑初始页面

图2-51 编辑公告界面
3.2.6.2 已发公告
管理员选中已发公告，即->“已发公告”，可查看停车场已经发布的公告。
停车场已发公告界面如图2-52所示。

图2-52 已发公告界面
3.3系统管理员
3.3.1 首页
系统管理员进入系统首页，首页导航功能包括：
1、帐号信息显示与操作
1）帐号名称：查看账户信息
2）安全设置：设置帐号相关信息
3）退出帐号：退出当前登录
2、停车场管理：切换到管理停车场界面
3、统计分析：管理停车场车位
4、用户数据：管理停车场来往车辆
5、系统设置：查看停车场相关数据报表
6、公告发布：发布相关停车场公告
7、导航条：显示当前所在页面
系统管理员操作首页如图2-53所示。

图2-53 系统管理员操作界面

3.3.2 停车场管理
系统管理员选中停车场数据，即->“停车场数据”，可查看系统所管理的停车场的相关信息。包括停车场序号、停车场地区号、停车场名称、停车场所在区域、停车位、创建时间。
其它功能：
1、表格底操作区域可选择每页信息条数、前往指定页面。
2、输入内容可检索指定停车场信息。
3、选择表格操作栏编辑选项对该条停车场数据信息进行编辑。
4、选择表格操作栏移除选项对该条停车场数据信息进行移除。
停车场数据信息如图2-54所示。

图2-54 停车场数据界面
3.3.3 统计分析
3.3.3.1 系统推广
系统管理员选中系统推广，即->“系统推广”，查看本系统的推广信息报表。可查看的报表如下：
1、地区推广柱状图。
2、地区推广各地图。
3、系统注册占比图。
3、系统注册最多停车场的城市及注册个数。
4、系统推广率最高的停车场的城市及推广比。
系统推广报表如图2-55 图2-56所示。

图2-55 系统推广报表

图2-56 系统推广报表

地区推广柱状图，可查看各地区已注册的和未注册的停车场。
1、图数据：
1）纵坐标：停车场个数。
2）横坐标：中国各大城市。
3）蓝色柱块：对应城市已注册的停车场个数。
4）灰色柱块：对应城市未注册的停车场个数
2、图功能：
1）移动鼠标在指定柱块查看详细信息，包括对应地区与（未）注册个数
2）鼠标拖拽图放缩柱状图
3）双击色块隐藏该色块
4）图右上方图标功能
数据视图：点击查看该图的各项数据列表
还原：还原为未拖拽前的默认图像
保存图片：将图表保存为图片储存在本地
地区推广柱状图如图2-57所示。

图2-57 地区推广柱状图

只显示未注册数据信息。如图2-58所示。

图2-58 未注册地区推广柱状图

查看柱状图数据视图，如图2-59所示。

图2-59 数据视图

地区推广各地图，可在地图上查看各地区已注册的和未注册的停车场。移动鼠标在指定柱块查看详细信息，包括对应地区与（未）注册个数。如图2-60所示。

图2-60地区推广各地图

系统注册占比图，可查看系统注册占比。
1、图数据：
1）红色块：不满意
2）绿色块：一般
2、图功能：
1）移动鼠标在指定色块查看详细信息，包括对应注册次与占比
如图2-61所示。

图2-61 系统总体注册率
3.3.3.2 资源数据分析
系统管理员选中资源数据分析，即->“资源数据分析”，查看本系统的资源数据。
1、图数据：
1）纵坐标：泊车次。
2）横坐标：指定时间的构成单位。
3）红线：泊车次。所有停车场指定时间段的所有泊车次数总和。
2、图功能：
1）移动鼠标在指定时间查看详细信息，包括对应车次与时间
2）选择时间按钮指定查看的时间段（一周、一月、一年）
系统资源数据报表如图2-62所示。

图2-62 系统总泊车次
3.3.3.3 访问数据分析
系统管理员选中访问数据分析，即->“访问数据分析”，查看本系统的访问数据分析报表。可查看的报表如下：
1、访问系统人次走势图。
2、新注册用户走势图。
3、用户评价分析图。
4、管理员评价分析图。
5、停车场类型占比图。
系统资源数据报表如图2-63图2-64所示。

图6-23

图2-64

访问系统人次走势图，可查看指定时间段的访问系统人次。
1、图数据：
1）纵坐标：访问系统人次。
2）横坐标：指定时间的构成单位。
3）折线：指定时间段的访问系统人次。
2、图功能：
1）移动鼠标在指定时间查看详细信息，包括对应访问人次与时间
2）选择时间按钮指定查看的时间段（一周、一月、一年）
如图2-65所示。

图2-65 访问系统人次图

新注册用户走势图，可查看指定时间段的新注册用户人次。
1、图数据：
1）纵坐标：新注册用户人次。
2）横坐标：指定时间的构成单位。
3）折线：指定时间段的新注册用户人次。
2、图功能：
1）移动鼠标在指定时间查看详细信息，包括对应新注册用户人次与时间
2）选择时间按钮指定查看的时间段（一周、一月、一年）
如图2-66所示。

图2-66 新用户注册人次图

用户评价分析图，可查看指定时间段的用户评价报表。
1、图数据：
1）红色块：不满意
2）蓝黑色块：还行
3）绿色块：一般
4）橙色块：满意
5）青色块：非常满意
2、图功能：
1）移动鼠标在指定色块查看详细信息，包括对应人次与占比
2）选择时间按钮指定查看的时间段（一周、一月、一年）
如图2-67所示。

图2-67用户评价分析图

管理员评价分析图，可查看指定时间段的管理员评价报表。
1、图数据：
1）红色块：不满意
2）蓝黑色块：还行
3）绿色块：一般
4）橙色块：满意
5）青色块：非常满意
2、图功能：
1）移动鼠标在指定色块查看详细信息，包括对应人次与占比
2）选择时间按钮指定查看的时间段（一周、一月、一年）
如图2-68所示。

图2-68管理员评价分析图

停车场类型占比图，可查看指定时间段的停车场类型占比。
1、图数据：
1）红色块：公共停车场
2）蓝黑色块：私有停车场
3）绿色块：专用停车场
2、图功能：
1）移动鼠标在指定色块查看详细信息，包括对应停车场个数与占比
如图2-69所示。

图2-69停车场类型占比图
3.3.4 用户数据
3.3.4.1 停车场管理员
系统管理员选中停车场管理员，即->“停车场管理员”，可查看所管理的停车场管理员信息。停车场管理员信息包括姓名、所属停车场、密码、联系电话、身份证号、性别、年龄。
其它功能：
1、表格底操作区域可选择每页信息条数、前往指定页面。
2、输入内容可检索管理员指定管理员信息。
3、选择表格操作栏查看选项查看该条管理员详细信息。
4、选择表格操作栏编辑选项对该条信息进行编辑。
5、选择表格操作栏移除选项对该条信息进行移除。
停车场管理员信息界面如图2-70所示。

图2-70 停车场管理员信息
3.3.4.2 注册用户
系统管理员选中注册用员，即->“注册用员”，可查看所管理的注册用员信息。注册用员信息包括账户、电话、创建时间、费用、积分、身份证号、信誉度。
其它功能：
1、表格底操作区域可选择每页信息条数、前往指定页面。
2、输入内容可检索管理员指定注册用员信息。
3、选择表格操作栏查看选项查看该条注册用户详细信息。
4、选择表格操作栏编辑选项对该条信息进行编辑。
5、选择表格操作栏移除选项对该条信息进行移除。
停车场管理员信息界面如图2-71所示

图2-71 注册系统用户信息

4.源代码
4.1服务端
Controller层
socket
Instructions
package com.cloud.station.controller.socket;

import com.alibaba.fastjson.JSONArray;
import com.cloud.station.pojo.DepotInfo;
import com.cloud.station.pojo.DepotStationState;
import com.cloud.station.pojo.dto.CarDTO;
import com.cloud.station.service.*;
import com.cloud.station.service.cache.SocketManager;
import com.cloud.station.service.redis.StationStateRedis;
import com.cloud.station.utils.BeanTools;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;

import java.io.PrintStream;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;

/**

指令处理
*/
public class Instructions{
public Map devicesMap = new HashMap<>();//链接设备状态 appId-key
//相关指令
public final static String SYS_CHBT = “SYS+CHBT”;//获取心跳时间(单位秒)
public final static String DAT_LOCKED_0=“DAT+LOCKED=0”;//锁住指定车位
public final static String DAT_LOCKED_1=“DAT+LOCKED=1”;//解锁车位
public final static String DAT_UPSUM=“DAT+UPSNUM”;//更新数据(车位总数量)
public final static String DATA_LEFT=“DAT+LEFT”;//剩余数量
public final static String SYS_REST=“SYS+REST”;//重置模块设置信息

public final static String DAT_TIME_INTERVAL = “DAT+TTL”;//每多少毫秒同步一次数据

public final static String SYS_CLOSED=“SYS+CLOSED”;//断开连接

private static ApplicationContext applicationContext = null;
@Autowired
SocketManager socketManager;

@Autowired
StationOrderService stationOrderService;
@Autowired
DepotInfoService depotStationService;

PrintStream out = null;
Socket socket = null;

public Instructions() {

}
public Instructions(Socket socket,PrintStream out) {
this.out = out;
this.socket = socket;
}
//保存连接
private void saveConnection(Socket socket){
//如果是新的socket
Socket socket_ = this.socketManager.get(socket.getInetAddress().toString());
if(socket_!=null) socketManager.add(socket);
}

public void parse(String cmd){
//1.进行认证
// out.println(“recived:”+cmd);

 StationStateRedis stationStateRedis = (StationStateRedis) BeanTools.getBean(StationStateRedis.class);
 stationOrderService = (StationOrderService)BeanTools.getBean(StationOrderService.class);
 PayService payService = (PayService) BeanTools.getBean(PayService.class);
 depotStationService = (DepotInfoService) BeanTools.getBean(DepotInfoService.class);

 if(cmd.contains("number")){//收到的是车牌信息
      CarDTO carDTO = JSONArray.parseObject(cmd,CarDTO.class);
       if(carDTO.getEndTime()!=null && carDTO.getEndTime()>0){//计算
            float cusumMoney = payService.pay(carDTO.getStationId(),carDTO.getNumber());
            out.println(cusumMoney);//总消费金额
       }else{//添加
             //TODO 余额不足未处理
          Integer rst = stationOrderService.addByCarNum(carDTO.getStationId(),carDTO.getNumber());
          if(rst==1)out.println("OK");
          else {
              //TODO 查询黑名单 如果存在过则不能进入
              out.println("ERROR");
          }
       }
 }else if(cmd.contains("stationId")){
       DepotStationState depotStationState = JSONArray.parseObject(cmd,DepotStationState.class);
       stationStateRedis.save(depotStationState);
  }else if("ST+NUM".equals(getKeyFromCmd(cmd))){//获取停车场的数量(ST+NUM)
     String stationId_ = getValueFromCmd("ST+NUM",cmd);
     try{
         DepotInfo depotInfo = (DepotInfo) depotStationService.findByPrimaryKey(Long.valueOf(stationId_));
         out.println(depotInfo.getStationNum());
     }catch (Exception e){
         out.println("ERROR");
     }
 }else if("ST+LEFT".equals(getKeyFromCmd(cmd))){//获取当前停车场剩余数
     String stationId_ = getValueFromCmd("ST+LEFT",cmd);
     try{
         DepotStationState depotStationState = stationStateRedis.getByKey(Long.valueOf(stationId_));
         if(depotStationState!=null){
             out.println(depotStationState.getLeft());
         }else{
             DepotInfo depotInfo = (DepotInfo) depotStationService.findByPrimaryKey(Long.valueOf(stationId_));
             out.println(depotInfo.getStationNum());
         }

     }catch (Exception e){
         out.println("ERROR");
     }
 }

}

/**

从指令中提取值
格式 key:value
@param key 指令key
@param str 字符串
@return
*/
public String getValueFromCmd(String key,String str){
String cmd = null;//指令值
String str_ = str.trim();//去除前后空格
if(!str_.startsWith(key)) return null;

if(!str_.contains("?) return null;

cmd = str_.substring(str.indexOf(":")+1);
return cmd.trim();
}

/**

从指令中得到KEY
@param cmd
@return
*/
public String getKeyFromCmd(String cmd){
String cmd_ = cmd.trim();
if(cmd_.contains("?){
return cmd_.substring(0,cmd_.lastIndexOf("?).trim();
}else{
return cmd.trim();
}
}

}

SocketOperate
package com.cloud.station.controller.socket;

import org.springframework.beans.factory.annotation.Autowired;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Date;

/**

多线程处理socket接收的数据
*/
public class SocketOperate extends Thread{
private Socket socket;
@Autowired

public SocketOperate(Socket socket) {
this.socket=socket;
}
@SuppressWarnings(“unused”)
public void run()
{
PrintStream out = null;
BufferedReader buf =null;
Instructions instructions = null;
boolean flag =true;
try{
while(flag){
//获取Socket的输出流，用来向客户端发送数据
out = new PrintStream(socket.getOutputStream());
//获取Socket的输入流，用来接收从客户端发送过来的数据
buf = new BufferedReader(new InputStreamReader(socket.getInputStream()));
instructions = new Instructions(socket,out);
//接收从客户端发送过来的数据
String str = buf.readLine();
```
         if(str == null || "".equals(str)){
             flag = false;
         }else{
             instructions.parse(str);
         }
     }
     out.close();
     socket.close();
```

// socket.setSoTimeout(30000);//设置读操作超时时间30 s
}catch(Exception ex){
out.println(“Connection closed;”);
flag = false;
ex.printStackTrace();
}
}
}

SocketServiceLoader
package com.cloud.station.controller.socket;

import com.cloud.station.service.cache.SocketManager;
import org.springframework.beans.factory.annotation.Autowired;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

/**

将socket service随tomcat启动
@author zhangzhongwen

*/
@WebListener
public class SocketServiceLoader implements ServletContextListener{
//socket server 线程
private SocketThread socketThread;

@Override
public void contextDestroyed(ServletContextEvent arg0) {
    System.out.println("liting: contextDestroyed");
    if(null!=socketThread && !socketThread.isInterrupted())
    {
        socketThread.closeSocketServer();
        socketThread.interrupt();
    }
}

@Override
public void contextInitialized(ServletContextEvent arg0) {
    System.out.println("liting: contextInitialized");

    if(null==socketThread)
    {
        //新建线程类
        socketThread=new SocketThread(null);
        //启动线程
        socketThread.start();
    }
}

}

SocketThread
package com.cloud.station.controller.socket;

import com.cloud.station.conf.ConfigurationManager;
import com.cloud.station.constant.ConstantsKey;
import com.cloud.station.service.cache.SocketManager;
import org.springframework.beans.factory.annotation.Autowired;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**

socket 线程类
@author zhangzhongwen

*/
public class SocketThread extends Thread{
private ServerSocket serverSocket = null;

public SocketThread(ServerSocket serverScoket){
    try {
        if(null == serverSocket){
            this.serverSocket = new ServerSocket(8899);//TODO 这里要使用配置文件进行配置
            System.out.println("socket start");
        }
    } catch (Exception e) {
        System.out.println("SocketThread创建socket服务出错");
        e.printStackTrace();
    }

}

public void run(){

    while(!this.isInterrupted()){
        try {
            Socket socket = null;
            socket = serverSocket.accept();
            if(null != socket){
                //处理接受的数据
                new SocketOperate(socket).start();
            }

// socket.setSoTimeout(300000);

        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}


public void closeSocketServer(){
    try {
        if(null!=serverSocket && !serverSocket.isClosed())
        {
            serverSocket.close();
        }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

}

websocket
StationSateWebSocket
package com.cloud.station.controller.websocket;

import com.alibaba.fastjson.JSONArray;
import com.cloud.station.pojo.dto.AddressDTO;
import com.cloud.station.pojo.dto.MapAddressDTO;
import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;

/**

停车场状态信息WebSocket
*/
@ServerEndpoint("/station/websoket")
@Component
public class StationSateWebSocket {

//静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
private static int onlineCount = 0;

//与某个客户端的连接会话，需要通过它来给客户端发送数据
private Session session;

//处理线程
private StationStateThread stationStateThread;
/**
- 连接建立成功调用的方法
- @param session 可选的参数。session为与某个客户端的连接会话，需要通过它来给客户端发送数据
  */
  @OnOpen
  public void onOpen(Session session){
  this.session = session;
  addOnlineCount(); //在线数加1
}

/**
- 连接关闭调用的方法
  */
  @OnClose
  public void onClose(){
  subOnlineCount(); //在线数减1
  try {
  session.close();
  } catch (IOException e) {
  e.printStackTrace();
  }
  stationStateThread.shut();
  }
/**
- 收到客户端消息后调用的方法
- @param address 客户端发送过来的消息
- @param session 可选的参数
  */
  @OnMessage
  public void onMessage(String address, Session session,@PathParam(“client-id”) String clientId) {
  AddressDTO addressDTO = JSONArray.parseObject(address,AddressDTO.class);
  try{
  if(stationStateThread==null)stationStateThread = new StationStateThread(session,addressDTO);
  if(session.isOpen() && stationStateThread!=null)stationStateThread.start();
  }catch (Exception e){
  try {
  session.close();
  } catch (IOException e1) {
  e1.printStackTrace();
  }
  }
}

/**
- 发生错误时调用
- @param session
- @param error
  */
  @OnError
  public void onError(Session session, Throwable error){
  try {
  session.close();
  } catch (IOException e) {
  e.printStackTrace();
  }
  stationStateThread.shut();
  error.printStackTrace();
  }
public static synchronized int getOnlineCount() {
return onlineCount;
}

public static synchronized void addOnlineCount() {
StationSateWebSocket.onlineCount++;
}

public static synchronized void subOnlineCount() {
StationSateWebSocket.onlineCount–;
}
}

StationStateThread
package com.cloud.station.controller.websocket;

import com.alibaba.fastjson.JSONObject;
import com.cloud.station.algorithm.Distance;
import com.cloud.station.pojo.DepotInfo;
import com.cloud.station.pojo.DepotStationState;
import com.cloud.station.pojo.dto.AddressDTO;
import com.cloud.station.pojo.dto.Position;
import com.cloud.station.pojo.dto.StationStateDTO;
import com.cloud.station.service.DepotInfoService;
import com.cloud.station.service.redis.StationStateRedis;
import com.cloud.station.utils.BeanTools;

import javax.websocket.Session;
import java.io.IOException;
import java.util.*;

/**

停车场状态信息线程
*/
public class StationStateThread extends Thread{
private Session session;
private boolean isRunning;

private DepotInfoService depotInfoService;
StationStateRedis stationStateRedis;

private AddressDTO addressDTO;//封装的地址类
public StationStateThread(Session session,AddressDTO addressDTO) {
this.session = session;
this.addressDTO = addressDTO;

 //从spring容器中获取bean
 depotInfoService = (DepotInfoService) BeanTools.getBean(DepotInfoService.class);

 if(session.isOpen() && addressDTO!=null)
     this.isRunning = true;
 else
     this.isRunning = false;

}

@Override
public void run() {
stationStateRedis = (StationStateRedis) BeanTools.getBean(StationStateRedis.class);
List list = init();//获取数据
List stateList = new ArrayList<>();//状态信息
while (isRunning){
if(!session.isOpen()){
isRunning = false;
}else{

         try {
             Thread.sleep(1000);

             //监控当前车位状态
             stateList.clear();
             for(DepotInfo di:list){
                 StationStateDTO ss = new StationStateDTO();

                 DepotStationState ds = stationStateRedis.getByKey(di.getId());//获取状态信息

                 if(ds!=null){
                     ss.setLeft(ds.getLeft());
                 }else{
                     ss.setLeft(di.getStationNum());
                 }
                 ss.setStationId(di.getId());
                 ss.setLastTime(new Date().getTime());
                 stateList.add(ss);
             }


             StationStateDTO css = new StationStateDTO();
             DepotStationState currrentDs = stationStateRedis.getByKey(addressDTO.getSid());
             if(currrentDs!=null){
                 css.setLeft(currrentDs.getLeft());
             }else{
                 DepotInfo depotInfo = (DepotInfo) depotInfoService.findByPrimaryKey(addressDTO.getSid());
                 css.setLeft(depotInfo.getStationNum());
             }
             css.setStationId(addressDTO.getSid());
             css.setLastTime(new Date().getTime());



             Map map = new HashMap();
             map.put("state_info",stateList);
             map.put("count",1);
             map.put("current",css);
             this.session.getBasicRemote().sendText(JSONObject.toJSONString(map));

         } catch (Exception e) {
             e.printStackTrace();
         }
     }

 }

}

public void shut(){
this.isRunning = false;
}

public List getDataFromDB(Double lat,Double lng,Double distance){
//计算范围
Position position = Distance.calcPosition(lat,lng,distance);
List list =depotInfoService.getByLatAndLon(position,addressDTO.getPage(),addressDTO.getLimit());

 if(list.isEmpty() || list.size()

 }
 /** 
     
      首次进入获得数据
 */
 public List init(){ 
 //重数据库查询
 List list = getDataFromDB(addressDTO.getLat(),addressDTO.getLng(),
 addressDTO.getDistance());
 Double distance = addressDTO.getDistance();//当前搜索范围
 Double max_distance = 2*addressDTO.getDistance();//TODO 最大搜索范围 暂定2倍距离
 while(list==null){//如果没有找到则扩大范围查找
 distance+=addressDTO.getStep();//扩大范围
 list = getDataFromDB(addressDTO.getLat(),addressDTO.getLng(),distance);
  if(distance>=max_distance)break;//达到最大搜索范围后还没有就跳出循环
 }
 try { 
 Map map = new HashMap();
 map.put(“station_info”,list);
 map.put(“count”,0);
 map.put(“current”,depotInfoService.findByPrimaryKey(addressDTO.getSid()));
 this.session.getBasicRemote().sendText(JSONObject.toJSONString(map));
 } catch (IOException e) { 
 e.printStackTrace();
 }
 return list;
 }
 }

 
  WebSocketConfig
 package com.cloud.station.controller.websocket; 
  import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.socket.server.standard.ServerEndpointExporter; 
  @Configuration
 public class WebSocketConfig { 
 //TODO 使用springboot内置的容器时要打开注释，发布到tomcat时要注释掉
 // @Bean
 // public ServerEndpointExporter serverEndpointExporter() { 
 // return new ServerEndpointExporter();
 // }
 } 
  AdminController
 package com.cloud.station.controller; 
  import com.cloud.station.constant.Code;
 import com.cloud.station.constant.ConstantsKey;
 import com.cloud.station.constant.HttpCode;
 import com.cloud.station.pojo.AdminInfo;
 import com.cloud.station.pojo.DepotAdminInfo;
 import com.cloud.station.pojo.UserInfo;
 import com.cloud.station.service.AdminInfoService;
 import com.cloud.station.service.UserInfoService;
 import com.cloud.station.utils.BeanUtils;
 import com.cloud.station.utils.CommonUtils;
 import com.cloud.station.utils.ParamValidUtils;
 import com.cloud.station.utils.PasswordUtils;
 import com.cloud.station.utils.result.JSONReturn;
 import com.cloud.station.utils.result.JSONType;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.bind.annotation.RestController; 
  import javax.servlet.http.HttpServletRequest;
 import java.util.Date;
 import java.util.List; 
  @RestController
 @RequestMapping("/v1/admin")
 public class AdminController { 
 @Autowired
 private AdminInfoService adminInfoService; 
  /**
 * 管理员登陆
 * @param request
 * account 账号
 * password 密码
 * @return
 */
 @RequestMapping(value = “/login”, method = RequestMethod.POST)
 public JSONType login(HttpServletRequest request) { 
 try { 
 String account = request.getParameter(“account”);// 账号
 String password = request.getParameter(“pwd”);// 密码
 if(ParamValidUtils.isEmpty(account) || ParamValidUtils.isEmpty(password))
 return JSONReturn.error(HttpCode.PARAMETER_MISSING,“username and password are required”); 
       // 2.根据账户查询存储的密码
     String realPassword = adminInfoService.getPasswordByAccount(account);
     AdminInfo adminInfo= adminInfoService.getDepotAdminInfoByAccount(account);
     if(realPassword==null || !PasswordUtils.check(realPassword,password))
        return JSONReturn.error(Code.ERROR,"login failed");

     request.getSession().setAttribute(ConstantsKey.LOGIN_SESSION_TOKEN,account);
     return JSONReturn.success(adminInfo.getId());
  } catch (Exception e) {
     return JSONReturn.error(HttpCode.LOGIN_FAILE, "login failed");
  }
 
  } 
  /**
 * 管理员添加
 * @param request
 * userInfo User 实体属性
 * @return
 */
 @RequestMapping(value = “/add”, method = RequestMethod.POST)
 @ResponseBody
 public JSONType register(HttpServletRequest request) {  
       return JSONReturn.success();
 
  } 
  /**
 * 获取管理员基本信息
 *
 * @param request
 * @return
 */
 @RequestMapping(value = “/info”, method = RequestMethod.GET)
 @ResponseBody
 public JSONType getUserInfo(HttpServletRequest request) { 
 try{ 
 Integer uid = Integer.valueOf(request.getParameter(“uid”));
 AdminInfo adminInfo = (AdminInfo) adminInfoService.findByPrimaryKey(uid);
 return JSONReturn.success(adminInfo);
 }catch (Exception e){ 
 return JSONReturn.error(HttpCode.UNEXPETED_ERROR,“unexpeted error”);
 }
 }
 } 
  AppController
 package com.cloud.station.controller; 
  import com.cloud.station.conf.ConfigurationManager;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody; 
  import javax.servlet.http.HttpServletRequest; 
  /** 
   
    @className: AppController
  
    @data: 2018-03-06
  
    @lastModify: 2018-03-06
  
    @description: APP Controller
  
    @version v1
 */
 @Controller
 @RequestMapping("/v1/app")
 public class AppController { 
 public static String APK_UPLOAD_DIR = “apk.upload.dir” ;
 /** 
     
     获取APP的版本 
     @return 版本信息
 */
 @RequestMapping(value = “/v”, method = RequestMethod.GET)
 @ResponseBody
 public Object getVersion(HttpServletRequest request){ 
 //TODO /v1/app/v
 return “success”;
 } 
    
 /** 
     
     更具平台和版本下载APK文件 
     @method POST 
     @url /v1/app/app 
     @param request 
               platform[String]  平台
  
               v[String]          版本
  
     @return 下载
 */
 @RequestMapping(value = “/app”, method = RequestMethod.POST)
 @ResponseBody
 public Object dowonloadApp(HttpServletRequest request){ 
 //TODO /v1/app/app
 return null;
 } 
    
 /** 
     
      上传APK安装包
  
      @method POST
  
      @url /v1/app/upload
  
      @param request
  
               platform[String]  平台
  
               v[String]          版本
  
      @return 下载
 */
 @RequestMapping(value = “/upload”, method = RequestMethod.POST)
 @ResponseBody
 public Object uploadApp(HttpServletRequest request){ 
 String dir = ConfigurationManager.getProperty(APK_UPLOAD_DIR);
 //TODO /v1/app/upload
 return null;
 }
 }
  
    
  
   
  CarInfoController
 package com.cloud.station.controller; 
  import com.alibaba.fastjson.JSON;
 import com.cloud.station.conf.ConfigurationManager;
 import com.cloud.station.constant.Code;
 import com.cloud.station.constant.HttpCode;
 import com.cloud.station.pojo.CarInfo;
 import com.cloud.station.service.CarInfoService;
 import com.cloud.station.service.StationOrderService;
 import com.cloud.station.utils.BeanUtils;
 import com.cloud.station.utils.ParamValidUtils;
 import com.cloud.station.utils.result.JSONReturn;
 import com.cloud.station.utils.result.JSONType;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody; 
  import javax.servlet.http.HttpServletRequest;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map; 
  /** 
   
    @className: CarInfoController
  
    @data: 2018-03-06
  
    @lastModify: 2018-03-06
  
    @description: APP Controller
  
    @version v1
 */
 @Controller
 @RequestMapping("/v1/carinfo")
 public class CarInfoController { 
 @Autowired
 CarInfoService carInfoService;
 @Autowired
 StationOrderService stationOrderService;
 /** 
     
      查询
  
      @param request
  
      @return
 */
 @RequestMapping(value = “/get”, method = RequestMethod.GET)
 @ResponseBody
 public JSONType getByNum(HttpServletRequest request){ 
 try{ 
 CarInfo carInfo = new CarInfo();
 String carNumber =request.getParameter(“carNumber”);
 String carNumberType =request.getParameter(“carNumberType”);
 String carType =request.getParameter(“carType”);
 String carXH =request.getParameter(“carXH”);
 String carYear =request.getParameter(“carYear”);
 String carColor =request.getParameter(“carColor”);
 String code =request.getParameter(“code”);
  if(!ParamValidUtils.isEmpty(carNumber))carInfo.setCarNumber(carNumber);
 if(!ParamValidUtils.isEmpty(carNumberType))carInfo.setCarNumberType(carNumberType);
 if(!ParamValidUtils.isEmpty(carType))carInfo.setCarType(carType);
 if(!ParamValidUtils.isEmpty(carXH))carInfo.setCarXH(carXH);
 if(!ParamValidUtils.isEmpty(carYear))carInfo.setCarYear(Integer.valueOf(carYear));
 if(!ParamValidUtils.isEmpty(carColor))carInfo.setCarColor(carColor);
 if(!ParamValidUtils.isEmpty(code))carInfo.setCode(code);

 if(carInfo==null)
     return JSONReturn.error(HttpCode.PARAMETER_MISSING,"parameter missing");
 String page_ = request.getParameter("page");
 String limit_ = request.getParameter("limit");

 if(ParamValidUtils.isEmpty(page_))page_="1";
 if(ParamValidUtils.isEmpty(limit_))limit_="20";

 Integer page = Integer.valueOf(page_);
 Integer limit = Integer.valueOf(limit_);

 if(ParamValidUtils.isEmpty(page_))page=1;
 if(ParamValidUtils.isEmpty(limit_))limit=20;

 List list = carInfoService.get(carInfo,page,limit);
 Long total = carInfoService.count(carInfo);
 Map result = new HashMap();
 result.put("data",list);
 result.put("total",total);
 result.put("pageIndex",page);
 result.put("pageSize",list.size());

 return !list.isEmpty() ? JSONReturn.success(result):
         JSONReturn.error(HttpCode.NOT_EXSITS,"empty");
 }catch (Exception e){ 
 return JSONReturn.error(HttpCode.UNEXPETED_ERROR,“unexpeted error”);
 }
 }
  
    
 /** 
     
      绑定车牌
  
      @param request
  
      @return
 */
 @RequestMapping(value = “/bind”, method = RequestMethod.POST)
 @ResponseBody
 public JSONType bindCarNumber(HttpServletRequest request){ 
 try{ 
 CarInfo carInfo = BeanUtils.toObject(request,CarInfo.class);
 System.out.println(carInfo);
 if(carInfo==null)
 return JSONReturn.error(HttpCode.PARAMETER_MISSING,“parameter missing”);
  if(ParamValidUtils.isEmpty(request.getParameter("carNumber"))||
         ParamValidUtils.isEmpty(request.getParameter("userId")))
     return JSONReturn.error(HttpCode.PARAMETER_MISSING,"parameter missing");

 carInfo.setId(null);
 carInfo.setCurrentUsed(0L);

 CarInfo carInfo_ = new CarInfo();
 carInfo_.setCarNumber(carInfo.getCarNumber());
 List list = carInfoService.get(carInfo_,1,1);
 if(!list.isEmpty()){
     return JSONReturn.error(Code.ERROR,"resource is exsist");
 }

 Integer rst = carInfoService.add(carInfo);
 return rst>0 ? JSONReturn.success(rst):
         JSONReturn.error(Code.ERROR,"failed");
 }catch (Exception e){ 
 return JSONReturn.error(HttpCode.UNEXPETED_ERROR,“unexpeted error”);
 }
 }
  
    
 @RequestMapping(value = “/addcn”, method = RequestMethod.POST)
 @ResponseBody
 public JSONType addCarNumber(HttpServletRequest request){ 
 try{ 
 CarInfo carInfo = BeanUtils.toObject(request,CarInfo.class);
 int stat = carInfoService.add(carInfo);
 return JSONReturn.success(stat);
 }catch (Exception e){ 
 return JSONReturn.error(HttpCode.UNEXPETED_ERROR,“error”);
 }
 }
 @RequestMapping(value = “/unbind”, method = RequestMethod.POST)
 @ResponseBody
 public JSONType unBind(HttpServletRequest request){ 
 //TODO 绑定车牌
 return JSONReturn.success(“未实现”);
 }
 @RequestMapping(value = “/history”, method = RequestMethod.GET)
 @ResponseBody
 public JSONType history(HttpServletRequest request){ 
 try{ 
 String carNum = request.getParameter(“carNum”);
 List list = stationOrderService.getHistory(carNum);
 return JSONReturn.success(list);
 }catch (Exception e){ 
 return JSONReturn.error(HttpCode.UNEXPETED_ERROR,“error”);
 }
 }
 }
  
   
  CarNumberBlackListController
 package com.cloud.station.controller; 
  import com.alibaba.fastjson.JSON;
 import com.cloud.station.constant.HttpCode;
 import com.cloud.station.pojo.CarNumberBlacklist;
 import com.cloud.station.service.CarNumberBlackListService;
 import com.cloud.station.utils.BeanUtils;
 import com.cloud.station.utils.ParamValidUtils;
 import com.cloud.station.utils.result.JSONReturn;
 import com.cloud.station.utils.result.JSONType;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody; 
  import javax.servlet.http.HttpServletRequest;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map; 
  @Controller
 @RequestMapping("/v1/carblacklist")
 public class CarNumberBlackListController {  
  @Autowired
CarNumberBlackListService carNumberBlackListService;

@RequestMapping(value = "/add", method = RequestMethod.POST)
@ResponseBody
public JSONType add(HttpServletRequest request){
    try{
        CarNumberBlacklist carNumberBlacklist = BeanUtils.toObject(request,CarNumberBlacklist.class);
        if(carNumberBlacklist==null)
            return JSONReturn.error(HttpCode.INVALIED_AUTHORITY,"invalied");
        if(carNumberBlacklist.getCarNum()==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"car number required");
        int rst = 0;

         carNumberBlacklist.setOweTime(new Date().getTime());
         carNumberBlacklist.setId(null);
         carNumberBlacklist.setOweAmount(0);
         carNumberBlacklist.setDisposeTime(new Date().getTime());
         carNumberBlacklist.setOweMoneyTime(1L);
         rst = carNumberBlackListService.save(carNumberBlacklist);
        return rst>0 ? JSONReturn.success(rst) :
                JSONReturn.error(HttpCode.INVALIED_AUTHORITY,"failed");
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
    }

}

@RequestMapping(value = "/update", method = RequestMethod.POST)
@ResponseBody
public JSONType update(HttpServletRequest request){
    try{
        CarNumberBlacklist carNumberBlacklist = BeanUtils.toObject(request,CarNumberBlacklist.class);
        if(carNumberBlacklist==null)
            return JSONReturn.error(HttpCode.INVALIED_AUTHORITY,"invalied");
        if(carNumberBlacklist.getId()==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"id required");

        carNumberBlacklist.setDisposeTime(new Date().getTime());
        int rst = carNumberBlackListService.update(carNumberBlacklist);

        return rst>0 ? JSONReturn.success(rst) :
                JSONReturn.error(HttpCode.INVALIED_AUTHORITY,"failed");
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
    }
}
@RequestMapping(value = "/del/id", method = RequestMethod.POST)
@ResponseBody
public JSONType deleteById(HttpServletRequest request){
    try{
        String id_ = request.getParameter("id");
        if(ParamValidUtils.isEmpty(id_))
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"id required");

        int rst = carNumberBlackListService.deleteByPrimaryKey(Long.valueOf(id_));
        return rst>0 ? JSONReturn.success(rst) :
                JSONReturn.error(HttpCode.INVALIED_AUTHORITY,"failed");
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
    }
}

@RequestMapping(value = "/get/id", method = RequestMethod.GET)
@ResponseBody
public JSONType getById(HttpServletRequest request){
    try{
        String id_ = request.getParameter("id");
        if(ParamValidUtils.isEmpty(id_))
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"id required");

        CarNumberBlacklist carNumberBlacklist = (CarNumberBlacklist) carNumberBlackListService.findByPrimaryKey(Long.valueOf(id_));
        return carNumberBlacklist!=null ? JSONReturn.success(carNumberBlacklist) :
                JSONReturn.error(HttpCode.INVALIED_AUTHORITY,"failed");
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
    }
}

/**
 * 根据车牌查询
 * @param request
 * @return
 */
@RequestMapping(value = "/get/number", method = RequestMethod.GET)
@ResponseBody
public JSONType getByCarNumber(HttpServletRequest request){
    try{
        String page_ = request.getParameter("page");
        String limit_ = request.getParameter("limit");
        String carNum = request.getParameter("carNum");

        if(ParamValidUtils.isEmpty(page_))page_="1";
        if(ParamValidUtils.isEmpty(limit_))limit_="20";

        if(ParamValidUtils.isEmpty(carNum))
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"car number required");

        Integer page = Integer.valueOf(page_);
        Integer limit = Integer.valueOf(limit_);

        List list = carNumberBlackListService.getByCarNumber(carNum,page,limit);

        Long total = carNumberBlackListService.countFilterByCarNum(carNum);
        Map map = new HashMap();
        map.put("data",list);
        map.put("total",total);
        return (list!=null && !list.isEmpty()) ? JSONReturn.success(map) :
                JSONReturn.error(HttpCode.RESULT_EMPTY,"empty");
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
    }
}
 
  } 
  DepotAdminController
 package com.cloud.station.controller; 
  import com.cloud.station.constant.Code;
 import com.cloud.station.constant.ConstantsKey;
 import com.cloud.station.constant.HttpCode;
 import com.cloud.station.pojo.AdminInfo;
 import com.cloud.station.pojo.DepotAdminInfo;
 import com.cloud.station.pojo.UserInfo;
 import com.cloud.station.service.DepotAdminInfoService;
 import com.cloud.station.service.UserInfoService;
 import com.cloud.station.utils.BeanUtils;
 import com.cloud.station.utils.CommonUtils;
 import com.cloud.station.utils.ParamValidUtils;
 import com.cloud.station.utils.PasswordUtils;
 import com.cloud.station.utils.result.JSONReturn;
 import com.cloud.station.utils.result.JSONType;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.bind.annotation.RestController; 
  import javax.servlet.http.HttpServletRequest;
 import java.util.Date;
 import java.util.List; 
  @RestController
 @RequestMapping("/v1/depot/admin")
 public class DepotAdminController { 
 @Autowired
 private DepotAdminInfoService depotAdminInfoService; 
  /**
 * 管理员登陆
 * @param request
 * account 账号
 * password 密码
 * @return
 */
 @RequestMapping(value = “/login”, method = RequestMethod.POST)
 public JSONType login(HttpServletRequest request) { 
 try { 
 String account = request.getParameter(“account”);// 账号
 String password = request.getParameter(“pwd”);// 密码
 if(ParamValidUtils.isEmpty(account) || ParamValidUtils.isEmpty(password))
 return JSONReturn.error(HttpCode.PARAMETER_MISSING,“username and password are required”); 
       // 2.根据账户查询存储的密码
     String realPassword = depotAdminInfoService.getPasswordByAccount(account);
     DepotAdminInfo depotAdminInfo= depotAdminInfoService.getDepotAdminInfoByAccount(account);
     if(realPassword==null || !PasswordUtils.check(realPassword,password))
        return JSONReturn.error(Code.ERROR,"login failed");

     request.getSession().setAttribute(ConstantsKey.LOGIN_SESSION_TOKEN,account);
     return JSONReturn.success(depotAdminInfo.getId());
  } catch (Exception e) {
     return JSONReturn.error(HttpCode.LOGIN_FAILE, "login failed");
  }
 
  } 
  /**
 * 管理员注册
 * @param request
 * userInfo User 实体属性
 * @return
 */
 @RequestMapping(value = “/reg”, method = RequestMethod.POST)
 @ResponseBody
 public JSONType register(HttpServletRequest request) { 
 try { 
 DepotAdminInfo depotAdminInfo = BeanUtils.toObject(request,DepotAdminInfo.class); 
       /**
      * 必要参数验证
      * a.账号不能为空
      * b.密码不能为空
      */
     if(ParamValidUtils.isEmpty(depotAdminInfo.getAccount()) || ParamValidUtils.isEmpty(depotAdminInfo.getPwd()))
        return JSONReturn.error(HttpCode.PARAMETER_MISSING,"parameter missing");

     String newPwd = PasswordUtils.encrpty(depotAdminInfo.getPwd());// 密码加密处理

     depotAdminInfo.setPwd(newPwd);
     // id为自动增长
     depotAdminInfo.setId(null);
     depotAdminInfo.setCreateTime(new Date().getTime());


     // 3.持久化数据
     List list=  depotAdminInfoService.findByName(depotAdminInfo.getAccount());
     if(list!=null && list.size()>0){//用户存在
        return JSONReturn.error(HttpCode.RESOURCE_EXSISTS,"already exsists");
     }
     Integer result = depotAdminInfoService.save(depotAdminInfo);

     return result > 0 ? JSONReturn.success() : JSONReturn.error(
           Code.ERROR, "register failed");

  } catch (Exception e) {
     e.printStackTrace();
     return JSONReturn.error(HttpCode.UNEXPETED_ERROR, "unexpeted error");
  }
 
  } 
  /**
 * 获取管理员基本信息
 *
 * @param request
 * @return
 */
 @RequestMapping(value = “/info”, method = RequestMethod.GET)
 @ResponseBody
 public JSONType getUserInfo(HttpServletRequest request) { 
 try{ 
 Integer uid = Integer.valueOf(request.getParameter(“uid”));
 DepotAdminInfo depotAdminInfo = (DepotAdminInfo) depotAdminInfoService.findByPrimaryKey(uid);
 return JSONReturn.success(depotAdminInfo);
 }catch (Exception e){ 
 return JSONReturn.error(HttpCode.UNEXPETED_ERROR,“unexpeted error”);
 }
 }
 } 
  DepotInfoController
 package com.cloud.station.controller; 
  import com.alibaba.fastjson.JSON;
 import com.cloud.station.algorithm.Distance;
 import com.cloud.station.constant.Code;
 import com.cloud.station.constant.HttpCode;
 import com.cloud.station.pojo.Address;
 import com.cloud.station.pojo.DepotInfo;
 import com.cloud.station.pojo.dto.Position;
 import com.cloud.station.service.AddressService;
 import com.cloud.station.service.DepotInfoService;
 import com.cloud.station.service.redis.StationStateRedis;
 import com.cloud.station.utils.BeanUtils;
 import com.cloud.station.utils.ParamValidUtils;
 import com.cloud.station.utils.result.JSONReturn;
 import com.cloud.station.utils.result.JSONType;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody; 
  import javax.servlet.http.HttpServletRequest;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map; 
  @Controller
 @RequestMapping("/v1/station")
 public class DepotInfoController {  
  @Autowired
 private DepotInfoService depotInfoService;
 @Autowired
 AddressService addressService;
 @Autowired
 StationStateRedis stationStateRedis; 
  /**
 * 添加停车场信息
 *
 * @param request
 * @return
 */
 @RequestMapping(value = “/add”, method = RequestMethod.POST)
 @ResponseBody
 public JSONType save(HttpServletRequest request) { 
 try{ 
 DepotInfo depotInfo = BeanUtils.toObject(request,DepotInfo.class);
 Address address = BeanUtils.toObject(request,Address.class);
 Integer stationNum = depotInfo.getStationNum();// 车位总数 
       //车位<0时
     if (stationNum==null || stationNum<0){
        depotInfo.setStationNum(0);
     }

     //如果名称为空或者用户ID为空
     if(ParamValidUtils.isEmpty(depotInfo.getName()) ||
           depotInfo.getUserId()==null)
        return JSONReturn.error(HttpCode.PARAMETER_MISSING,"parameter missing");


     depotInfo.setId(null);
     depotInfo.setCreateTime(new Date().getTime());
     address.setCreateTime(new Date().getTime());



     // 3.持久化数据
     //保存地址
     List addressList = addressService.find(address);
     if(addressList==null || addressList.isEmpty()){
        addressService.save(address);
        addressList = addressService.find(address);
     }

     Long id = Long.valueOf(addressList.get(0).getId());
     if(id!=null)
        depotInfo.setAddressId(id);
 
  // List list = depotInfoService.find(depotInfo);
 // if(list!=null && list.size()>0){//数据存在
 // return JSONReturn.error(HttpCode.RESOURCE_EXSISTS,“failed”);
 // } 
       Integer result = depotInfoService.save(depotInfo);

     return result > 0 ? JSONReturn.success() : JSONReturn.error(Code.ERROR,
           "add failed");
  }catch (Exception e){
     return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
  }
 
  } 
  /**
 * 根据主键id修改停车场基本信息
 *
 * @param request
 * @return
 */
 @RequestMapping(value = “/edit”, method = RequestMethod.POST)
 @ResponseBody
 public JSONType update(HttpServletRequest request) { 
 try{ 
 DepotInfo depotInfo = BeanUtils.toObject(request,DepotInfo.class);
 if(depotInfo.getId()==null ||
 depotInfo.getUserId()==null ||
 depotInfo.getAddressId()==null ||
 depotInfo.getStationNum()<0)
 return JSONReturn.error(HttpCode.PARAMETER_INVALIED,“paramter invalied”); 
       Address address = (Address) addressService.findByPrimaryKey(depotInfo.getAddressId());
     if(address==null)
        return JSONReturn.error(HttpCode.NOT_EXSITS,"address is not exsist");

     // 3.修改停车场信息
     DepotInfo depotInfo_ = (DepotInfo) depotInfoService.findByPrimaryKey(depotInfo.getId());
     if (depotInfo==null) return JSONReturn.error(HttpCode.RESULT_EMPTY,"empty");

     Integer result = depotInfoService.update(depotInfo);
     return result > 0 ? JSONReturn.success() : JSONReturn.error(Code.ERROR,
           "Update failed");
  }catch (Exception e){
     return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
  }
 
  } 
  /**
 * 根据主键获取停车场信息
 *
 * @param request
 * @return
 */
 @RequestMapping(value = “/get”, method = RequestMethod.GET)
 @ResponseBody
 public JSONType select(HttpServletRequest request) { 
 try { 
 // 1.获取请求参数
 Integer depotInfoId = Integer.parseInt(request.getParameter(“id”));// 停车场主键id 
       // 2.根据主键获取停车场信息
     DepotInfo depotInfo = (DepotInfo) depotInfoService
           .findByPrimaryKey(depotInfoId);
     
     return depotInfo != null ? JSONReturn.success(depotInfo) : JSONReturn.error(
           Code.ERROR, "empty");

  } catch (Exception e) {
     return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
  }
 
  } 
  /**
 * 分页查询停车场信息
 * @param request
 * @return
 */
 @RequestMapping(value = “/list/address”, method = RequestMethod.GET)
 @ResponseBody
 public JSONType getByPage(HttpServletRequest request) { 
 try{ 
 Integer page = Integer.valueOf(request.getParameter(“page”));//当前页
 Integer limit = Integer.valueOf(request.getParameter(“limit”));//每页条数 
       page = page == null ? 1 : page;//默认1
     limit = limit == null ? 20 : limit;//默认为20
     List list = depotInfoService.findByPage(page,limit);
     Long total = depotInfoService.count();//总条数
     Map result = new HashMap();
     result.put("data",list);
     result.put("total",total);
     result.put("pageIndex",page);
     result.put("pageSize",limit);

     return list!=null ? JSONReturn.success(result) :
           JSONReturn.empty("empty");

  }catch (Exception e){
     return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpected error");
  }
 
  } 
  /**
 * 根据经纬度查询指定范围的停车场信息
 * @param request
 * @return
 */
 @RequestMapping(value = “/get/position”, method = RequestMethod.GET)
 @ResponseBody
 public JSONType getByPosition(HttpServletRequest request) { 
 try{ 
 Double lat = Double.valueOf(request.getParameter(“lat”));//精度
 Double lng = Double.valueOf(request.getParameter(“lng”));//纬度
 Double len = Double.valueOf(request.getParameter(“len”));//范围
 Integer page = Integer.valueOf(request.getParameter(“page”));
 Integer limit = Integer.valueOf(request.getParameter(“limit”));
 Integer step = Integer.valueOf(request.getParameter(“step”));//TODO 暂未使用步进发 
       if(lat<=0 || lng<=0 || len<=0) return JSONReturn.error(HttpCode.PARAMETER_MISSING,"parameter missing");

     Position position = Distance.calcPosition(lat,lng,len);
     List list = depotInfoService.getByLatAndLon(position,page,limit);
     if(list.isEmpty() || list.size()
 
  } 
  /**
 * TODO 停车场预约
 * @param request
 * @return
 */
 @RequestMapping(value = “/order”, method = RequestMethod.POST)
 @ResponseBody
 public JSONType orderStation(HttpServletRequest request) { 
 try{ 
 Long userId = Long.valueOf(request.getParameter(“uid”));//用户ID
 Long stationId = Long.valueOf(request.getParameter(“sid”));//停车场ID
 //1.查询停车场信息 如果存在
 //2.查询用户 如果存在
 //3.用户的余额不能少于停车场的费用
 //4.余额 不足调用支付宝接口充值
 return JSONReturn.success();
 }catch (Exception e){ 
 return JSONReturn.error(HttpCode.UNEXPETED_ERROR,“unexpeted error”);
 } 
  } 
  /**
 * 根据停车场管理员的id获取所有的停车场
 * @param request
 * @return
 */
 @RequestMapping(value = “/list”, method = RequestMethod.GET)
 @ResponseBody
 public JSONType getAll(HttpServletRequest request) { 
 try{ 
 String uid = request.getParameter(“uid”);
 if(ParamValidUtils.isEmpty(uid))
 return JSONReturn.error(HttpCode.PARAMETER_MISSING,“uid is required”); 
       DepotInfo depotInfo = new DepotInfo();
     depotInfo.setUserId(Long.valueOf(uid));
     List list = depotInfoService.find(depotInfo);
     return JSONReturn.success(list);
  }catch (Exception e){
     return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
  }
 
  } 
  @RequestMapping(value = “/del”, method = RequestMethod.POST)
 @ResponseBody
 public JSONType delete(HttpServletRequest request) { 
 try{ 
 String id = request.getParameter(“id”);
 if(ParamValidUtils.isEmpty(id))
 return JSONReturn.error(HttpCode.PARAMETER_MISSING,“id is required”); 
       Integer rst = depotInfoService.deleteByPrimaryKey(Long.valueOf(id));
     return rst>0 ? JSONReturn.success() :
           JSONReturn.error("failed");
  }catch (Exception e){
     return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
  }
 
  }
 } 
  DepotStationController
 package com.cloud.station.controller; 
  import com.cloud.station.constant.Code;
 import com.cloud.station.pojo.DepotStation;
 import com.cloud.station.service.DepotStationService;
 import com.cloud.station.utils.BeanUtils;
 import com.cloud.station.utils.result.JSONReturn;
 import com.cloud.station.utils.result.JSONType;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody; 
  import javax.servlet.http.HttpServletRequest;
 import java.util.Date; 
  /** 
   
    @className: StationController
  
    @data: 2018-03-06
  
    @lastModify: 2018-03-06
  
    @description: 停车场车位Controller
  
    @version v1
 */
 @Controller
 @RequestMapping("/v1/station/parking")
 public class DepotStationController { 
 @Autowired
 private DepotStationService depotStationService;
 /** 
     
      添加停车场车位基本信息
  
      
      @param request
  
             depotStation 实体属性
  
      @return
 */
 @RequestMapping(value = “/add”, method = RequestMethod.POST)
 @ResponseBody
 public JSONType addDepotStation(HttpServletRequest request) { 
 try { 
 DepotStation depotStation = BeanUtils.toObject(request,DepotStation.class);
 // 1.持久化数据
 depotStation.setId(null);// 主键
 depotStation.setCreateTime(new Date().getTime());
 //TODO 要判断有没有重复的code
 Integer result = depotStationService.save(depotStation);
 return result > 0 ? JSONReturn.success() : JSONReturn.error(
 Code.ERROR, “Add failed”);
 } catch (Exception e) { 
 return JSONReturn.error(Code.ERROR, “failed”);
 }
 }
  
    
 /** 
     
      删除停车场车位信息
  
      
      @param request
  
      @return
 */
 @RequestMapping(value = “/del”, method = RequestMethod.POST)
 @ResponseBody
 public JSONType delById(HttpServletRequest request) { 
 try { 
 // 1.获取请求参数
 Integer depotStationId = Integer.parseInt(request
 .getParameter(“id”));// 停车场车位id
 // 2.更据主键删除停车场信息
 Integer result = depotStationService
 .deleteByPrimaryKey(depotStationId);
 return result > 0 ? JSONReturn.success() : JSONReturn.error(
 Code.ERROR, “Deleted failed”);
 } catch (Exception e) { 
 return JSONReturn.error(Code.ERROR, “failed”);
 }
 }
  
    
 /** 
     
      根据主键修改停车场车位基本信息
  
      
      @param request
  
      @return
 */
 @RequestMapping(value = “/edit”, method = RequestMethod.POST)
 @ResponseBody
 public JSONType update(HttpServletRequest request, DepotStation depotStation) { 
 try { 
 // 1.获取请求参数
 Long depotStationId = Long.parseLong(request.getParameter(“id”));// 主键id
 // 2.修改停车场车位信息
 depotStation.setCreateTime(new Date().getTime());
 Integer result = depotStationService.update(depotStation);
 return result > 0 ? JSONReturn.success() : JSONReturn.error(
 Code.ERROR, “failed”);
 } catch (Exception e) { 
 return JSONReturn.error(Code.ERROR, “failed”);
 }
 }
  
    
 /** 
     
      根据主键获取停车场车位信息
  
      @param request
  
      @return
 */
 @RequestMapping(value = “/get”, method = RequestMethod.GET)
 @ResponseBody
 public JSONType select(HttpServletRequest request) { 
 try { 
 // 1.获取请求参数
 Integer depotStationId = Integer.parseInt(request
 .getParameter(“id”));// 停车场主键id
 // 2.根据主键获取停车场车位信息
 DepotStation depotStation = (DepotStation) depotStationService
 .findByPrimaryKey(depotStationId);
 return depotStation != null ? JSONReturn.success(depotStation) : JSONReturn
 .error(Code.ERROR, “not exist.”);
 } catch (Exception e) { 
 return JSONReturn.error(Code.ERROR, “failed”);
 }
 }
 }
  
    
  
   
  FareController
 package com.cloud.station.controller; 
  import com.cloud.station.constant.Code;
 import com.cloud.station.constant.HttpCode;
 import com.cloud.station.pojo.FareRule;
 import com.cloud.station.service.FareService;
 import com.cloud.station.utils.BeanUtils;
 import com.cloud.station.utils.ParamValidUtils;
 import com.cloud.station.utils.result.JSONReturn;
 import com.cloud.station.utils.result.JSONType;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody; 
  import javax.servlet.http.HttpServletRequest;
 import java.util.Date;
 import java.util.List; 
  @Controller
 @RequestMapping("/v1/fare")
 public class FareController {  
  @Autowired
FareService fareService;

@RequestMapping(value = "/add", method = RequestMethod.POST)
@ResponseBody
public JSONType add(HttpServletRequest request){
    try{
        FareRule fareRule = BeanUtils.toObject(request,FareRule.class);

        if(fareRule==null){
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"paramter missing");
        }
        if(fareRule.getStationId()==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"station id required");
        if(fareRule.getUserId()==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"user id required");

        fareRule.setId(null);
        fareRule.setCreateTime(new Date().getTime());

        //查询当前停车场是否有正在使用的规则
        FareRule fareRule_ = fareService.getUsedByStationId(fareRule.getStationId());

        if(fareRule_!=null){
            fareRule.setUsed(0);//强制设置成未使用
        }

        Integer rst = fareService.save(fareRule);

        if(fareRule_==null)//如果不存在
            return rst==1 ? JSONReturn.success(Code.SUCCESS,"success") :
                    JSONReturn.error(Code.ERROR,"failed");
        else
            return rst==1 ? JSONReturn.success(HttpCode.RESOURCE_RESET,"used is seted UNUSED") :
                    JSONReturn.error(Code.ERROR,"failed");
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
    }

}

@RequestMapping(value = "/del", method = RequestMethod.POST)
@ResponseBody
public JSONType deleteById(HttpServletRequest request){
    try{
        String id_ = request.getParameter("id");
        if(ParamValidUtils.isEmpty(id_))
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"id required");

        int rst = fareService.deleteByPrimaryKey(Long.valueOf(id_));

        return rst>0 ? JSONReturn.success(rst) :
                JSONReturn.error(Code.ERROR,"failed");
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
    }
}

@RequestMapping(value = "/get", method = RequestMethod.GET)
@ResponseBody
public JSONType getById(HttpServletRequest request){
    try{
        String id_ = request.getParameter("id");
        if(ParamValidUtils.isEmpty(id_))
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"id required");

        FareRule fareRule = (FareRule) fareService.findByPrimaryKey(Long.valueOf(id_));

        return fareRule!=null ? JSONReturn.success(fareRule) :
                JSONReturn.error(Code.ERROR,"failed");
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
    }
}

@RequestMapping(value = "/update", method = RequestMethod.POST)
@ResponseBody
public JSONType update(HttpServletRequest request){
    try{
        FareRule fareRule = BeanUtils.toObject(request,FareRule.class);
        if(fareRule==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"error");
        if(fareRule.getId()==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"id requied");
        if(fareRule.getUserId()==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"user id requied");
        if(fareRule.getStationId()==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"station id requied");

        FareRule fareRule_ = fareService.getUsedByStationId(fareRule.getStationId());

        if(fareRule_!=null){
            fareRule.setUsed(0);
        }

        int rst = fareService.update(fareRule);

        if(fareRule_==null)
            return rst>0 ? JSONReturn.success() :
                    JSONReturn.error(Code.ERROR,"failed");
        else
            return rst>0 ? JSONReturn.success("used will be seted 0") :
                    JSONReturn.error(Code.ERROR,"failed");
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
    }
}

/**
 * 查询所有
 * @param request
 * @return
 */
@RequestMapping(value = "/list", method = RequestMethod.GET)
@ResponseBody
public JSONType getAll(HttpServletRequest request){
    try{
        String stationId_ = request.getParameter("uid");
        if(ParamValidUtils.isEmpty(stationId_))
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"sid required");

        List list = fareService.getAll(Long.valueOf(stationId_));


        return !list.isEmpty() ? JSONReturn.success(list) :
                JSONReturn.error(HttpCode.RESULT_EMPTY,"empty");
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
    }
}

/**
 * 设置规则为当前使用的规则
 * @param request
 * @return
 */
@RequestMapping(value = "/update/used", method = RequestMethod.POST)
@ResponseBody
public JSONType updateUsed(HttpServletRequest request){
    try{
        String id_ = request.getParameter("id");
        String used_ = request.getParameter("used");

        Integer used = Integer.valueOf(used_);

        if(ParamValidUtils.isEmpty(id_))
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"id required");

        //used必须是0或者1
        if(used!=0 && used!=1)
            return JSONReturn.error(HttpCode.INVALIED_AUTHORITY,"used valied");

        FareRule fareRule = (FareRule) fareService.findByPrimaryKey(Long.valueOf(id_));
        FareRule usedFareRule = fareService.getUsedByStationId(fareRule.getStationId());

        if(usedFareRule!=null){//存在规则正在被使用
            if(used==1){//修改
                usedFareRule.setUsed(0);
                fareRule.setUsed(1);
            }else{
                fareRule.setUsed(0);
            }
            fareService.update(usedFareRule);
        }else{
            fareRule.setUsed(used);
        }


        int rst = fareService.update(fareRule);

        return rst>0 ? JSONReturn.success("success") :
                JSONReturn.error(Code.ERROR,"failed");
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
    }
}
 
  } 
  FriendController
 package com.cloud.station.controller; 
  import com.cloud.station.constant.Code;
 import com.cloud.station.constant.HttpCode;
 import com.cloud.station.pojo.Friend;
 import com.cloud.station.service.FriendService;
 import com.cloud.station.utils.BeanUtils;
 import com.cloud.station.utils.ParamValidUtils;
 import com.cloud.station.utils.result.JSONReturn;
 import com.cloud.station.utils.result.JSONType;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody; 
  import javax.servlet.http.HttpServletRequest;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map; 
  @Controller
 @RequestMapping("/v1/friend")
 public class FriendController {  
  @Autowired
FriendService friendService;

@RequestMapping(value = "/add", method = RequestMethod.POST)
@ResponseBody
public JSONType addFriend(HttpServletRequest request){
    try{
        Friend friend = BeanUtils.toObject(request,Friend.class);
        if(friend.getFrendId()==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"friend id required");
        if(friend.getMyId()==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"my id required");
        if(friend.getRelative()==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"relative required");

        if(friend.getMyId()==friend.getFrendId())
            return JSONReturn.error(HttpCode.INVALIED_AUTHORITY,"parameter invalied");

        friend.setId(null);
        friend.setCreateTime(new Date().getTime());

        List friendList = friendService.find(friend);

        int rst = 0;
        if(friendList==null || friendList.isEmpty()){
            rst = friendService.save(friend);
        }else{
            Friend friend_ = friendList.get(0);
            friend_.setCreateTime(new Date().getTime());
            friend_.setRelative(friend.getRelative());

            rst = friendService.update(friend_);
        }

        return rst>0 ? JSONReturn.success(rst) :
                JSONReturn.error(Code.ERROR,"failed");

    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
    }
}

@RequestMapping(value = "/del", method = RequestMethod.POST)
@ResponseBody
public JSONType delFriend(HttpServletRequest request){
    try{
        Friend friend = BeanUtils.toObject(request,Friend.class);

        if(friend==null)
            return JSONReturn.error(HttpCode.INVALIED_AUTHORITY,"invalied");
        if(friend.getMyId()==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"user id required");
        if(friend.getFrendId()==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"friend id required");

        List friendList = friendService.find(friend);

        if(friendList==null || friendList.isEmpty()){
            return JSONReturn.error(HttpCode.RESULT_EMPTY,"not exsist");
        }

        int rst = friendService.deleteByPrimaryKey(friendList.get(0).getId());

        return rst>0 ? JSONReturn.success(rst) :
                JSONReturn.error(Code.ERROR,"failed");
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
    }
}

@RequestMapping(value = "/update", method = RequestMethod.POST)
@ResponseBody
public JSONType update(HttpServletRequest request){
    try{
        Friend friend = BeanUtils.toObject(request,Friend.class);
        if(friend.getFrendId()==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"friend id required");
        if(friend.getMyId()==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"my id required");
        if(friend.getRelative()==null)
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"relative required");

        if(friend.getMyId()==friend.getFrendId())
            return JSONReturn.error(HttpCode.INVALIED_AUTHORITY,"parameter invalied");

        List friendList = friendService.find(friend);

        if(friendList==null || friendList.isEmpty()){
            return JSONReturn.error(HttpCode.NOT_EXSITS,"empty");
        }

        friend.setId(friendList.get(0).getId());

        int rst = friendService.update(friend);

        return rst>0 ? JSONReturn.success(rst) :
                JSONReturn.error(Code.ERROR,"failed");
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
    }
}

@RequestMapping(value = "/list", method = RequestMethod.GET)
@ResponseBody
public JSONType getFriendList(HttpServletRequest request){
    try{
        String page_ = request.getParameter("page");
        String limit_ = request.getParameter("limit");
        String myId_ = request.getParameter("myId");
        String relative_ = request.getParameter("relative");
        String unrelative_ = request.getParameter("unrelative");
        if(ParamValidUtils.isEmpty(page_))page_="1";
        if(ParamValidUtils.isEmpty(limit_))limit_ = "20";

        if(ParamValidUtils.isEmpty(myId_))
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"user id requied");


        Integer page = Integer.valueOf(page_);
        Integer limit = Integer.valueOf(limit_);
        Long myId = Long.valueOf(myId_);
        Integer relative = null;
        Integer unrelative = null;

        if(ParamValidUtils.isNotEmpty(relative_))relative = Integer.valueOf(relative_);
        if(ParamValidUtils.isNotEmpty(unrelative_))unrelative = Integer.valueOf(unrelative_);


        List list = friendService.getFriendList(myId,relative,unrelative,page,limit);
        Long total = friendService.countByFilter(myId,relative,unrelative);
        Map map = new HashMap();
        map.put("data",list);
        map.put("total",total);
        return (list!=null && list.size()>0) ? JSONReturn.success(map) :
                JSONReturn.error(HttpCode.RESULT_EMPTY,"empty");
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"unexpeted error");
    }
}
 
  } 
  PayController
 package com.cloud.station.controller; 
  import com.cloud.station.constant.HttpCode;
 import com.cloud.station.service.PayService;
 import com.cloud.station.utils.ParamValidUtils;
 import com.cloud.station.utils.result.JSONReturn;
 import com.cloud.station.utils.result.JSONType;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.bind.annotation.RestController; 
  import javax.servlet.http.HttpServletRequest;
 import java.util.Date; 
  @RestController
 @RequestMapping("/v1/pay")
 public class PayController {  
  @Autowired
PayService payService;
/**
 * 收费
 * @param request
 * @return
 */
@RequestMapping(value = "/p", method = RequestMethod.POST)
@ResponseBody
public JSONType updateUsed(HttpServletRequest request){
    try{
        String uid = request.getParameter("uid");//用户ID
        String carNum = request.getParameter("carNum");//车牌
        if(ParamValidUtils.isEmpty(carNum))
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"paramter missing");

        float leftMoney = payService.pay(carNum,new Date().getTime());
        return JSONReturn.success(leftMoney);
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"error");
    }

}
 
  } 
  StationOrderController
 package com.cloud.station.controller; 
  import com.cloud.station.constant.HttpCode;
 import com.cloud.station.mapper.StationOrderMapper;
 import com.cloud.station.pojo.StationOrder;
 import com.cloud.station.utils.ParamValidUtils;
 import com.cloud.station.utils.result.JSONReturn;
 import com.cloud.station.utils.result.JSONType;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.bind.annotation.RestController; 
  import javax.servlet.http.HttpServletRequest;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map; 
  @RestController
 @RequestMapping("/v1/stationorder")
 public class StationOrderController {  
  @Autowired
StationOrderMapper stationOrderMapper;

/**
 * 根据停车场ID获取使用停车场的用户信息
 * @param request
 * @return
 */
@RequestMapping(value = "/users", method = RequestMethod.GET)
@ResponseBody
public JSONType getAllUsers(HttpServletRequest request){
    try{
        String stationId = request.getParameter("stationId");
        String page = request.getParameter("page");
        String limit = request.getParameter("limit");

        if(ParamValidUtils.isEmpty(stationId))
            return JSONReturn.error(HttpCode.PARAMETER_MISSING,"paramter missing");

        if(ParamValidUtils.isEmpty(page))page="1";
        if(ParamValidUtils.isEmpty(limit))limit="20";

        StationOrder stationOrder = new StationOrder();
        stationOrder.setStationId(Long.valueOf(stationId));

        List list = stationOrderMapper.findUserByEntity(stationOrder,Integer.valueOf(page),Integer.valueOf(limit));

        Map map = new HashMap();
        map.put("total",stationOrderMapper.count());
        map.put("data",list);
        return JSONReturn.success(map);
    }catch (Exception e){
        return JSONReturn.error(HttpCode.UNEXPETED_ERROR,"error");
    }

}
 
  } 
  UserController
 package com.cloud.station.controller; 
  import com.alibaba.fastjson.JSON;
 import com.cloud.station.constant.Code;
 import com.cloud.station.constant.ConstantsKey;
 import com.cloud.station.constant.HttpCode;
 import com.cloud.station.pojo.UserInfo;
 import com.cloud.station.service.UserInfoService;
 import com.cloud.station.utils.BeanUtils;
 import com.cloud.station.utils.CommonUtils;
 import com.cloud.station.utils.ParamValidUtils;
 import com.cloud.station.utils.PasswordUtils;
 import com.cloud.station.utils.result.JSONReturn;
 import com.cloud.station.utils.result.JSONType;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.bind.annotation.RestController; 
  import javax.servlet.http.HttpServletRequest;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map; 
  @RestController
 @RequestMapping("/v1/user")
 public class UserController { 
 @Autowired
 private UserInfoService userInfoService; 
  /**
 * 用户登陆
 * @param request
 * account 账号
 * password 密码
 * @return
 */
 @RequestMapping(value = “/login”, method = RequestMethod.POST)
 public JSONType login(HttpServletRequest request) { 
 try { 
 String username = (String) request.getSession().getAttribute(ConstantsKey.LOGIN_SESSION_TOKEN);
 if(username!=null)
 return JSONReturn.success(); 
       String account = request.getParameter("account");// 账号
     String password = request.getParameter("pwd");// 密码
     if(ParamValidUtils.isEmpty(account) || ParamValidUtils.isEmpty(password))
        return JSONReturn.error(HttpCode.PARAMETER_MISSING,"username and password are required");

     // 2.根据账户查询存储的密码
     String realPassword = userInfoService.getPasswordByAccount(account);
     UserInfo userInfo = userInfoService.getUserInfoByAccount(account);
     if(realPassword==null || !PasswordUtils.check(realPassword,password))
        return JSONReturn.error(Code.ERROR,"login failed");

     request.getSession().setAttribute(ConstantsKey.LOGIN_SESSION_TOKEN,account);
     return JSONReturn.success(userInfo.getId());
  } catch (Exception e) {
     return JSONReturn.error(HttpCode.LOGIN_FAILE, "login failed");
  }
 
  } 
  /**
 * 用户注册
 * @param request
 * userInfo User 实体属性
 * @return
 */
 @RequestMapping(value = “/reg”, method = RequestMethod.POST)
 @ResponseBody
 public JSONType register(HttpServletRequest request) { 
 try { 
 UserInfo userInfo = BeanUtils.toObject(request,UserInfo.class); 
       /**
      * 必要参数验证
      * a.账号不能为空
      * b.密码不能为空
      */
     if(ParamValidUtils.isEmpty(userInfo.getAccount()) || ParamValidUtils.isEmpty(userInfo.getPwd()))
        return JSONReturn.error(HttpCode.PARAMETER_MISSING,"parameter missing");

     // 1.验证手机号格式
     if (!CommonUtils.isTel(userInfo.getAccount()))
        return JSONReturn.error(Code.ERROR, "register failed");

     String oldPwd = userInfo.getPwd();

     // 2.密码长度验证
     if (!PasswordUtils.checkLength(oldPwd))// 密码长度不符合要求
        return JSONReturn.error(HttpCode.PARAMETER_INVALIED,
              "password invalied");
     String newPwd = PasswordUtils.encrpty(oldPwd);// 密码加密处理

     userInfo.setPwd(newPwd);
     // id为自动增长
     userInfo.setId(null);
     userInfo.setCreateTime(new Date().getTime());
     // 金额精确到小数点后两位
     userInfo.setMoney(CommonUtils.keepDecimalDigits(userInfo.getMoney()));

     // 3.持久化数据
     List list=  userInfoService.findByName(userInfo.getAccount());
     if(list!=null && list.size()>0){//用户存在
        return JSONReturn.error(HttpCode.RESOURCE_EXSISTS,"already exsists");
     }
     Integer result = userInfoService.save(userInfo);

     return result > 0 ? JSONReturn.success() : JSONReturn.error(
           Code.ERROR, "register failed");

  } catch (Exception e) {
     e.printStackTrace();
     return JSONReturn.error(HttpCode.UNEXPETED_ERROR, "unexpeted error");
  }
 
  } 
  /**
 * 获取用户基本信息
 *
 * @param request
 * @return
 */
 @RequestMapping(value = “/info”, method = RequestMethod.GET)
 @ResponseBody
 public JSONType getUserInfo(HttpServletRequest request) { 
 // 1.获取请求参数
 // = (String) request.getSession().getAttribute(ConstantsKey.LOGIN_SESSION_TOKEN);
 String uid = request.getParameter(“uid”);
 if(ParamValidUtils.isEmpty(uid)){ 
 return JSONReturn.error(HttpCode.PARAMETER_MISSING,“id is required”);
 } 
    // 2.更据用户名查询用户基本信息
  UserInfo userInfo = (UserInfo) userInfoService.findByPrimaryKey(Long.valueOf(uid));

  return userInfo != null ? JSONReturn.success(userInfo) : JSONReturn
        .error(HttpCode.NOT_EXSITS, "empty");
 
  } 
  @RequestMapping(value = “/list”, method = RequestMethod.GET)
 @ResponseBody
 public JSONType getUserList(HttpServletRequest request) { 
 try{ 
 String page_ = request.getParameter(“page”);
 String limit_ = request.getParameter(“limit”);
 String type_ = request.getParameter(“type”); 
       Integer page = Integer.valueOf(page_);
     Integer limit = Integer.valueOf(limit_);
     Integer type = Integer.valueOf(type_);//管理员类型

     if(ParamValidUtils.isEmpty(page_))page=1;
     if(ParamValidUtils.isEmpty(limit_))limit=20;

     List list = null;
     Long total = 0L;
     list = userInfoService.findByPage(page, limit);
     total = userInfoService.count();

     Map result = new HashMap();
     result.put("data",list);
     result.put("total",total);
     result.put("pageIndex",page);
     result.put("pageSize",limit);

     return !list.isEmpty() ? JSONReturn.success(result):
           JSONReturn.error("empty");
  }catch (Exception e){
     return JSONReturn.error(HttpCode.UNEXPETED_ERROR, "unexpeted error");
  }
 
  } 
  /**
 * 根据账号查询
 * @param request
 * @return
 */
 @RequestMapping(value = “/get/account”, method = RequestMethod.GET)
 @ResponseBody
 public JSONType getByAccount(HttpServletRequest request) { 
 String account = request.getParameter(“account”);
 if(ParamValidUtils.isEmpty(account))
 return JSONReturn.error(HttpCode.PARAMETER_MISSING, “account required”); 
    UserInfo userInfo = userInfoService.getUserInfoByAccount(account);

  return userInfo!=null ? JSONReturn.success(userInfo) :
        JSONReturn.error(HttpCode.NOT_EXSITS,"empty");
 
  }
 } 
  Service层
 Redis
 StationStateRedis
 package com.cloud.station.service.redis; 
  import com.cloud.station.constant.ConstantsKey;
 import com.cloud.station.pojo.CarNumberUsed;
 import com.cloud.station.pojo.DepotInfo;
 import com.cloud.station.pojo.DepotStationState;
 import com.cloud.station.pojo.dto.CarDTO;
 import com.cloud.station.pojo.dto.Position;
 import com.cloud.station.service.DepotInfoService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.cache.annotation.CachePut;
 import org.springframework.data.redis.connection.SortParameters;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.data.redis.core.query.SortQuery;
 import org.springframework.stereotype.Service; 
  import java.util.*;
 import java.util.concurrent.TimeUnit; 
  /** 
   
    停车场动态信息
 */
 @Service
 public class StationStateRedis { 
 @Autowired
 private RedisTemplate redisTemplate;
 @Autowired
 DepotInfoService depotInfoService;
 public void save(DepotStationState depotStationState){ 
 if(depotStationState==null)return;
 //TODO 要定时更新数据到数据库
 String key = ConstantsKey.STATION_STATE_PREFIX+depotStationState.getStationId()+"";
  //停车场信息
 DepotInfo depotInfo=null;


 boolean exists=redisTemplate.hasKey(key);
 if(exists){//如果缓存中存在
     DepotStationState temp = (DepotStationState) redisTemplate.opsForValue().get(key);
     if(temp.getDepotInfo()==null){//如果没有停车场的信息则从数据库中查询出来
         //查询
         depotInfo = (DepotInfo) depotInfoService.findByPrimaryKey(temp.getStationId());
     }else{
         depotInfo = temp.getDepotInfo();
     }
 }else{
     depotInfo = (DepotInfo) depotInfoService.findByPrimaryKey(depotStationState.getStationId());
 }
 depotStationState.setDepotInfo(depotInfo);

 redisTemplate.opsForValue().getAndSet(key,depotStationState);
 }
 /** 
     
     存储车牌信息 
     @param carDTO
 */
 public void saveCarNumber(CarDTO carDTO){ 
 redisTemplate.opsForValue().getAndSet(carDTO.getNumber(),carDTO);
 } 
    
 /** 
     
     根据主键查询 
     @param key_ 
     @return
 */
 public DepotStationState getByKey(Object key_){ 
 String key = ConstantsKey.STATION_STATE_PREFIX+key_;
 boolean exists=redisTemplate.hasKey(key);
 if(exists)
 return (DepotStationState) redisTemplate.opsForValue().get(key);
 else
 return null;
 } 
    
 /** 
     
      根据经纬度从缓存查询
  
      @param position 位置信息
  
      @param n 个数
  
      @return
 */
 public List getByLatAndLon(Position position,Integer n){ 
 List list = new ArrayList<>();//容器
 List temp = new ArrayList<>();//临时容器
 Set s = redisTemplate.keys(ConstantsKey.STATION_STATE_PREFIX+"*");
 Iterator iterator = s.iterator();
 while (iterator.hasNext()){//获取所有内容到临时容器中
 String key = (String) iterator.next();
 DepotStationState depotStationState = (DepotStationState) redisTemplate.opsForValue().get(key);
 temp.add(depotStationState);
 }
 //TODO redis数据排序
 Collections.sort(temp, new Comparator() { 
 @Override
 public int compare(DepotStationState o1, DepotStationState o2) { 
 return o2.getLeft()-o1.getLeft();
 }
 });
 Integer i = 0;
 for(DepotStationState ds:temp){ 
 DepotInfo depotInfo = ds.getDepotInfo();
 if(depotInfo!=null){ 
 Double lat = depotInfo.getLatitude();
 Double lng = depotInfo.getLongitude();
 if(lat>=position.getLeftBottomLat() && lat<=position.getLeftTopLat() &&
 lng>position.getLeftTopLng() && lng<=position.getRightTopLng()){ 
 list.add(depotInfo);
 i++;
 if(i>=n)break;
 }
 }
 }
 return list;
 }
  
    
  
   
  } 
  cache
 impl
 SocketManagerImple
 package com.cloud.station.service.cache.impl; 
  import com.cloud.station.service.cache.SocketManager;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.cache.CacheManager;
 import org.springframework.cache.annotation.CacheEvict;
 import org.springframework.cache.annotation.CachePut;
 import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Service; 
  import java.net.Socket;
 import java.util.*; 
  @Service(“socketManager”)
 public class SocketManagerImple implements SocketManager{ 
 private final Map enties = new HashMap<>();
 private final String NAMESPACE = “socketManager”;
 @Autowired
 private CacheManager cacheManager; 
  @Override
@CachePut(cacheNames = NAMESPACE)
public void add(Socket socket) {
    enties.put(socket.getInetAddress().toString(), socket);
}

@Override
@CacheEvict(cacheNames = NAMESPACE)
public void delete(String key) {
     enties.remove(key);
}

@Override
public void clear() {
    //TODO 清空所有的Socket连接未实现
}

@Override
@Cacheable(cacheNames = NAMESPACE)
public Socket get(String key) {
    return enties.get(key);
}

@Override
@CachePut(cacheNames = NAMESPACE)
public void update(Socket socket) {
    enties.put(socket.getInetAddress().toString(),socket);
}

@Override
public Integer count() {
    return enties.size();
}

@Override
@Cacheable(cacheNames = NAMESPACE)
public List getOtherSocket(Socket socket) {
    List list = new ArrayList();
    String key = socket.getInetAddress().toString();

    Iterator iterator=enties.values().iterator();
    while (iterator.hasNext()){
        list.add(iterator.next());
    }
    return list;
}
 
  } 
  SocketManager
 package com.cloud.station.service.cache; 
  import java.net.Socket;
 import java.util.List;
 import java.util.Map; 
  /** 
   
    socket连接管理类
 */
 public interface SocketManager { 
 public void add(Socket socket);//z增加一个socket
 public void delete(String key);//删除一个socket
 public void clear();//清空所有的Socket连接
 public Socket get(String key);//根据key查询指定的Socket
 public void update(Socket socket);//更新
 public Integer count();//统计总数
 public List getOtherSocket(Socket socket);//获得其他的Socket连接
 }
  
   
  AddressService
 package com.cloud.station.service; 
  import java.util.List; 
  import org.springframework.stereotype.Service; 
  import com.cloud.station.base.BaseService;
 import com.cloud.station.pojo.Address;
 import com.cloud.station.pojo.UserInfo; 
  /** 
   
   @className: AddressService 
   @data: 2018-03-07 
   @lastModify: 2018-03-07 
   @description: 地址信息 service接口
 */
 public interface AddressService extends BaseService {  
   
  } 
  AdminInfoService
 package com.cloud.station.service; 
  import java.util.List; 
  import com.cloud.station.pojo.DepotAdminInfo;
 import org.springframework.stereotype.Service; 
  import com.cloud.station.base.BaseService;
 import com.cloud.station.pojo.Address;
 import com.cloud.station.pojo.AdminInfo;
 import com.cloud.station.pojo.UserInfo; 
  /** 
   
    @className: AdminInfoService
  
    @data: 2018-03-07
  
    @lastModify: 2018-03-07
  
    @description: 系统管理员service接口
 /
 public interface AdminInfoService extends BaseService { 
 /* 
     
     根据用户名查询密码 
     @param account 
     @return
 */
 public String getPasswordByAccount(String account); 
    
 /** 
     
     根据用户名查询用户的基本信息 
     @param account 
     @return
 */
 public AdminInfo getDepotAdminInfoByAccount(String account);
 } 
    
  
   
  AppService
 package com.cloud.station.service; 
  import com.cloud.station.base.BaseService; 
  /** 
   
    @className: AppService
  
    @data: 2018-03-06
  
    @lastModify: 2018-03-06
  
    @description: 手机APP公共Service接口
 */
 public interface AppService extends BaseService { 
 /** 
     
     获取对应平台最新的APP版本 
     @param platform 平台 
     @return
 */
 public String getLastVersion(String platform); 
    
 /** 
     
     更新手机APP版本 
     @param platform 平台 
     @param version 版本 
     @return
 */
 public String updateApp(String platform, String version); 
    
 /** 
     
     下载APP 
     @param platform 平台 
     @param version 版本 
     @return
 */
 public String dowloadApp(String platform, String version);
 } 
    
  
   
  CarInfoService
 package com.cloud.station.service; 
  import com.cloud.station.pojo.CarInfo; 
  import java.util.List; 
  public interface CarInfoService {  
  /**
 * 根据实体查询
 * @return
 */
public List get(CarInfo carInfo,Integer page,Integer limit);

/**
 * 统计总记录数
 * @param carInfo
 * @return
 */
public Long count(CarInfo carInfo);

/**
 * 添加
 * @param carInfo
 * @return
 */
public Integer add(CarInfo carInfo);
 
  } 
  CarNumberBlackListService
 package com.cloud.station.service; 
  import com.cloud.station.base.BaseService;
 import com.cloud.station.pojo.CarNumberBlacklist; 
  import java.util.List; 
  public interface CarNumberBlackListService extends BaseService{  
  /**
 * 根据车牌查询
 * @param carNumber
 * @return
 */
public List getByCarNumber(String carNumber,Integer page,Integer limit);


public Long countFilterByCarNum(String carNum);
 
  } 
  DepotAdminInfoService
 package com.cloud.station.service; 
  import java.util.List; 
  import org.springframework.stereotype.Service; 
  import com.cloud.station.base.BaseService;
 import com.cloud.station.pojo.Address;
 import com.cloud.station.pojo.AdminInfo;
 import com.cloud.station.pojo.DepotAdminInfo;
 import com.cloud.station.pojo.UserInfo; 
  /** 
   
    @className: DepotAdminInfoService
  
    @data: 2018-03-07
  
    @lastModify: 2018-03-07
  
    @description: 停车场管理员service接口
 */
 public interface DepotAdminInfoService extends BaseService { 
 /** 
     
     根据用户名查询密码 
     @param account 
     @return
 */
 public String getPasswordByAccount(String account); 
    
 /** 
     
     根据用户名查询用户的基本信息 
     @param account 
     @return
 */
 public DepotAdminInfo getDepotAdminInfoByAccount(String account);
 } 
    
  
   
  DepotFareStandardService
 package com.cloud.station.service; 
  import com.cloud.station.pojo.CarInfo; 
  /** 
   
    收费标准Service
 */
 public interface DepotFareStandardService { 
 /** 
     
     根据车信息计费 
     @param carInfo 
     @return
 */
 public Float calculateFare(CarInfo carInfo);
 } 
    
  
   
  DepotInfoService
 package com.cloud.station.service; 
  import java.util.List; 
  import com.cloud.station.pojo.dto.Position;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service; 
  import com.cloud.station.base.BaseService;
 import com.cloud.station.mapper.DepotInfoMapper;
 import com.cloud.station.pojo.Address;
 import com.cloud.station.pojo.AdminInfo;
 import com.cloud.station.pojo.DepotAdminInfo;
 import com.cloud.station.pojo.DepotInfo;
 import com.cloud.station.pojo.UserInfo; 
  /** 
   
   @className: DepotInfoService 
   @data: 2018-03-07 
   @lastModify: 2018-03-07 
   @description: 停车场基本信息service接口
 */ 
   
  public interface DepotInfoService extends BaseService {  
  /**
 * 根据经纬度查询
 * @param position 经纬度范围
 * @param skip   跳过记录条数
 * @param limit  每页条数
 * @return
 */
public List getByLatAndLon(Position position, int skip, int limit);

/**
 * 根据经纬度查询
 * @param lat 中心经纬
 * @Param lng  中心纬度
 * @Param dis  中心覆盖距离
 * @param skip   跳过记录条数
 * @param limit  每页条数
 * @return
 */
public List getByLatAndLon(double lat,double lng,double dis, int skip, int limit);

/**
 * 根据车牌查找实体
 * @param carNum
 * @return
 */
public DepotInfo getByCarNumber(String carNum);
 
  } 
  DepotStationService
 package com.cloud.station.service; 
  import java.util.List; 
  import org.springframework.stereotype.Service; 
  import com.cloud.station.base.BaseService;
 import com.cloud.station.pojo.DepotStation;
 import com.cloud.station.pojo.DepotState; 
  /** 
   
   @className: DepotStateService 
   @data: 2018-03-07 
   @lastModify: 2018-03-07 
   @description: 停车场车位信息service接口
 */ 
   
  public interface DepotStationService extends BaseService {  
  } 
  DepotStationStateService
 package com.cloud.station.service; 
  import com.cloud.station.base.BaseService;
 import com.cloud.station.pojo.dto.MapAddressDTO;
 import java.util.List; 
  public interface DepotStationStateService extends BaseService{  
  /**
 * 根据地址查找停车场的状态信息包括停车场的基本信息
 * @param mapAddressDTO
 * @return
 */
public List findByMapAddress(MapAddressDTO mapAddressDTO);
 
  } 
  FareService
 package com.cloud.station.service; 
  import com.cloud.station.base.BaseService;
 import com.cloud.station.fare.entity.Rule;
 import com.cloud.station.pojo.FareRule; 
  import java.util.List; 
  public interface FareService extends BaseService{  
  /**
 * 查询停车场当前正在使用的规则
 * @param stationId
 * @return
 */
public FareRule getUsedByStationId(Long stationId);

/**
 * 根据停车场ID查询所有
 * @param stationId
 * @return
 */
public List getAll(Long stationId);

/**
 * 停车场计费
 * @param rule
 * @return
 */
public float calc(Rule rule);
 
  } 
  FriendService
 package com.cloud.station.service; 
  import com.cloud.station.base.BaseService;
 import com.cloud.station.pojo.ex.FriendEx;
 import org.apache.ibatis.annotations.Param; 
  import java.util.List; 
  public interface FriendService extends BaseService{  
  /**
 * 获取好友列表
 * @param myId
 * @param relative
 * @param unrelative
 * @param page
 * @param limit
 * @return
 */
public List getFriendList(Long myId,Integer relative,
                                    Integer unrelative,Integer page,
                                    Integer limit);

/**
 * 条件查询总数
 * @param myId
 * @param relative
 * @param unrelative
 * @return
 */
public Long  countByFilter(Long myId,Integer relative,
                                    Integer unrelative);
 
  } 
  PayService
 package com.cloud.station.service; 
  /** 
   
    @className: PayService
  
    @data: 2018-03-10
  
    @lastModify: 2018-03-10
  
    @description: 账号充值Service
 */
 public interface PayService { 
 /** 
     
     根据车牌扣费 
     @param carNumber 车牌 
     @param endTime 结束时间 
     @return
 */
 public float pay(String carNumber,Long endTime); 
    
 /** 
     
     根据停车和停车场ID付款 
     @param stationId 
     @param carNum 
     @return 返回总消费金额
 */
 public float pay(Long stationId,String carNum);
 } 
    
  
   
  StationOrderService
 package com.cloud.station.service; 
  import com.cloud.station.pojo.StationOrder; 
  import java.util.List; 
  public interface StationOrderService {  
  /**
 * 添加订单
 * @param stationId
 * @param carNumber
 * @return
 */
public Integer addByCarNum(Long stationId,String carNumber);

/**
 * 更新实体
 * @param stationOrder
 * @return
 */
public Integer update(StationOrder stationOrder);

/**
 * 根据车牌查询
 * @param carNum
 * @return
 */
public StationOrder getByCarNumber(String carNum);

/**
 * 根据停车场ID和车牌查询
 * @param stationId
 * @param carNum
 * @return
 */
public StationOrder getByStationIdAndCarNuber(Long stationId,String carNum);

/**
 * 查看历史信息
 * @param carNum
 * @return
 */
public List getHistory(String carNum);
 
  } 
  UserInfoService
 package com.cloud.station.service; 
  import java.util.List; 
  import com.cloud.station.base.BaseService;
 import com.cloud.station.pojo.UserInfo; 
  /** 
   
    @className: UserInfoService
  
    @data: 2018-03-07
  
    @lastModify: 2018-03-07
  
    @description: 用户基本信息 service接口
 /
 public interface UserInfoService extends BaseService { 
 /* 
     
     根据用户名查询密码 
     @param account 
     @return
 */
 public String getPasswordByAccount(String account); 
    
 /** 
     
     根据用户名查询用户的基本信息 
     @param account 
     @return
 */
 public UserInfo getUserInfoByAccount(String account); 
    
 /** 
     
     增加一条记录 
     @param userInfo 实体 
     @return 影响记录条数
 */
 public Integer save(UserInfo userInfo); 
    
  
   
  } 
  Service实现层
 AddressServiceImpl
 package com.cloud.station.service.impl; 
  import com.cloud.station.base.impl.BaseServiceImpl;
 import com.cloud.station.mapper.AddressMapper;
 import com.cloud.station.service.AddressService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service; 
  import java.util.List; 
  @Service(“addressService”)
 public class AddressServiceImpl extends BaseServiceImpl implements AddressService {  
  @Autowired
AddressMapper addressMapper;
/**
 * 查询
 *
 * @param entity 实体
 * @return List    集合
 * @
 */
@Override
public List find(Object entity) {
    try {
        return addressMapper.find(entity);
    } catch (Exception e) {
        return null;
    }
}

/**
 * 增加一条记录
 *
 * @param entity 实体
 * @return 影响记录条数
 * @
 */
@Override
public Integer save(Object entity) {
    try {
        return addressMapper.insert(entity);
    } catch (Exception e) {
        return 0;
    }
}

/**
 * 更具主键查询一条记录
 *
 * @param obj 主键
 * @return 对象实体
 * @
 */
@Override
public Object findByPrimaryKey(Object obj) {
    try {
        return addressMapper.findByPrimaryKey(obj);
    } catch (Exception e) {
        return null;
    }
}
 
  } 
  AdminInfoServiceImpl
 package com.cloud.station.service.impl; 
  import com.cloud.station.base.impl.BaseServiceImpl;
 import com.cloud.station.mapper.AdminInfoMapper;
 import com.cloud.station.pojo.AdminInfo;
 import com.cloud.station.service.AdminInfoService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service; 
  @Service(“adminInfoService”)
 public class AdminInfoServiceImpl extends BaseServiceImpl implements AdminInfoService{  
  @Autowired
AdminInfoMapper adminInfoMapper;
/**
 * 根据用户名查询密码
 *
 * @param account
 * @return
 */
@Override
public String getPasswordByAccount(String account) {
    try {
        return adminInfoMapper.findPasswordByAccount(account);
    } catch (Exception e) {
        return null;
    }
}

/**
 * 根据用户名查询用户的基本信息
 *
 * @param account
 * @return
 */
@Override
public AdminInfo getDepotAdminInfoByAccount(String account) {
    try{
        return (AdminInfo) (adminInfoMapper.findByName(account)).get(0);
    }catch(Exception e){
        return null;
    }
}

/**
 * 更具主键查询一条记录
 *
 * @param obj 主键
 * @return 对象实体
 * @
 */
@Override
public Object findByPrimaryKey(Object obj) {
    try {
        return adminInfoMapper.findByPrimaryKey(obj);
    } catch (Exception e) {
        return null;
    }
}
 
  } 
  AppServiceImpl
 package com.cloud.station.service.impl; 
  import com.cloud.station.base.impl.BaseServiceImpl;
 import com.cloud.station.service.AppService; 
  import java.util.List; 
  /** 
   
    @className: AppServiceImpl
  
    @data: 2018-03-06
  
    @lastModify: 2018-03-06
  
    @description: 手机APP公共Service实现类
 */
 public class AppServiceImpl extends BaseServiceImpl implements AppService{ 
 /** 
     
     获取对应平台最新的APP版本 
      
     @param platform 平台 
     @return
 */
 @Override
 public String getLastVersion(String platform) { 
 //从数据库查询
 return null;
 } 
    
 /** 
     
     更新手机APP版本 
     @param platform 平台 
     @param version 版本 
     @return
 */
 @Override
 public String updateApp(String platform,String version){ 
 //TODO 实现APK下载更新
 //暂时不用实现
 return null;
 } 
    
 /** 
     
     下载APP 
      
     @param platform 平台 
     @param version 版本 
     @return
 */
 @Override
 public String dowloadApp(String platform, String version) { 
 //TODO 下载APK
 //暂时不用实现
 return null;
 } 
    
 //Override
 /** 
     
     增加一条记录 
      
     @param entity 实体 
     @return 影响记录条数 
     @
 */
 @Override
 public Integer save(Object entity) { 
 return super.save(entity);
 } 
    
 /** 
     
     删除一条记录 
      
     @param pk 主键或对象 
     @return 影响记录条数 
     @
 */
 @Override
 public Integer delete(Object pk) { 
 return super.delete(pk);
 } 
    
 /** 
     
     更新一条记录 
      
     @param entity 实体 
     @return 影响记录条数 
     @
 */
 @Override
 public Integer update(Object entity) { 
 return super.update(entity);
 } 
    
 /** 
     
     查询 
      
     @param entity 实体 
     @return List 集合 
     @
 */
 @Override
 public List find(Object entity) { 
 return super.find(entity);
 } 
    
 /** 
     
     增加或更新一条记录 
      
     @param entity 实体 
     @return 影响记录条数 
     @
 */
 @Override
 public Integer saveOrUpdate(Object entity) { 
 return super.saveOrUpdate(entity);
 } 
    
 /** 
     
     根据主键删除一条记录 
      
     @param pk 主键 
     @return 影响记录条数 
     @
 */
 @Override
 public Integer deleteByPrimaryKey(Object pk) { 
 return super.deleteByPrimaryKey(pk);
 } 
    
 /** 
     
     根据名称删除 
      
     @param name 
     @return 
     @
 */
 @Override
 public Integer deleteByName(String name) { 
 return super.deleteByName(name);
 } 
    
 /** 
     
     更具主键查询一条记录 
      
     @param obj 主键 
     @return 对象实体 
     @
 */
 @Override
 public Object findByPrimaryKey(Object obj) { 
 return super.findByPrimaryKey(obj);
 }
 } 
    
  
   
  CarInfoServiceImpl
 package com.cloud.station.service.impl; 
  import com.cloud.station.base.impl.BaseServiceImpl;
 import com.cloud.station.mapper.CarInfoMapper;
 import com.cloud.station.pojo.CarInfo;
 import com.cloud.station.service.AppService;
 import com.cloud.station.service.CarInfoService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service; 
  import java.util.List; 
  /** 
   
    @className: AppServiceImpl
  
    @data: 2018-03-06
  
    @lastModify: 2018-03-06
  
    @description: 手机APP公共Service实现类
 */
 @Service(“carInfoService”)
 public class CarInfoServiceImpl implements CarInfoService{ 
 @Autowired
 CarInfoMapper carInfoMapper;
 /** 
     
     根据实体查询 
      
     @param carInfo 
     @return
 */
 @Override
 public List get(CarInfo carInfo,Integer page,Integer limit) { 
 try { 
 return carInfoMapper.find(carInfo,(page-1)*limit,limit);
 } catch (Exception e) { 
 return null;
 }
 } 
    
 /** 
     
     统计总记录数 
      
     @param carInfo 
     @return
 */
 @Override
 public Long count(CarInfo carInfo) { 
 try { 
 return carInfoMapper.count(carInfo);
 } catch (Exception e) { 
 return 0L;
 }
 } 
    
 /** 
     
     添加 
      
     @param carInfo 
     @return
 */
 @Override
 public Integer add(CarInfo carInfo) { 
 try { 
 return carInfoMapper.insert(carInfo);
 } catch (Exception e) { 
 return 0;
 }
 }
 } 
    
  
   
  CarNumberBlackListServiceImpl
 package com.cloud.station.service.impl; 
  import com.cloud.station.base.impl.BaseServiceImpl;
 import com.cloud.station.mapper.CarNumberBlacklistMapper;
 import com.cloud.station.pojo.CarNumberBlacklist;
 import com.cloud.station.service.CarNumberBlackListService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service; 
  import java.util.List; 
  @Service(“carNumberBlackListService”)
 public class CarNumberBlackListServiceImpl extends BaseServiceImpl
 implements CarNumberBlackListService{  
  @Autowired
CarNumberBlacklistMapper carNumberBlacklistMapper;

/**
 * 根据车牌查询
 *
 * @param carNumber
 * @return
 */
@Override
public List getByCarNumber(String carNumber,Integer page,Integer limit) {
    try {
        return carNumberBlacklistMapper.getByCarNumber(carNumber,(page-1)*limit,limit);
    } catch (Exception e) {
        return null;
    }
}

@Override
public Long countFilterByCarNum(String carNum) {
    try {
        return carNumberBlacklistMapper.countByFilterCarNum(carNum);
    } catch (Exception e) {
        return 0L;
    }
}

/**
 * 更新一条记录
 *
 * @param entity 实体
 * @return 影响记录条数
 * @
 */
@Override
public Integer update(Object entity) {
    try {
        return carNumberBlacklistMapper.update(entity);
    } catch (Exception e) {
        return 0;
    }
}

/**
 * 增加一条记录
 *
 * @param entity 实体
 * @return 影响记录条数
 * @
 */
@Override
public Integer save(Object entity) {
    try {
        return carNumberBlacklistMapper.insert(entity);
    } catch (Exception e) {
        return 0;
    }
}

/**
 * 根据主键删除一条记录
 *
 * @param pk 主键
 * @return 影响记录条数
 * @
 */
@Override
public Integer deleteByPrimaryKey(Object pk) {
    try {
        return carNumberBlacklistMapper.deleteByPrimaryKey(pk);
    } catch (Exception e) {
        return 0;
    }
}

/**
 * 更具主键查询一条记录
 *
 * @param obj 主键
 * @return 对象实体
 * @
 */
@Override
public Object findByPrimaryKey(Object obj) {
    try {
        return carNumberBlacklistMapper.findByPrimaryKey(obj);
    } catch (Exception e) {
        return null;
    }
}
 
  } 
  DepotAdminInfoServiceImpl
 package com.cloud.station.service.impl; 
  import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service; 
  import com.cloud.station.base.impl.BaseServiceImpl;
 import com.cloud.station.mapper.DepotAdminInfoMapper;
 import com.cloud.station.pojo.AdminInfo;
 import com.cloud.station.pojo.DepotAdminInfo;
 import com.cloud.station.service.DepotAdminInfoService; 
  @Service(“depotAdminInfoService”)
 public class DepotAdminInfoServiceImpl extends BaseServiceImpl implements DepotAdminInfoService{  
  @Autowired
 private DepotAdminInfoMapper depotAdminInfoMapper; 
  /**
 * 增加一条记录
 *
 * @param entity 实体
 * @return 影响记录条数
 * @
 */
 @Override
 public Integer save(Object entity) { 
 try { 
 Integer result = depotAdminInfoMapper.insert(entity);
 return result;
 } catch (Exception e) { 
 return 0;//插入异常，返回0
 }
 } 
  /**
 * 根据主键删除一条记录
 * @param id
 * @return 影响记录条数
 */
 public Integer delete(Integer id) { 
 try { 
 Integer result = depotAdminInfoMapper.deleteByPrimaryKey(id);
 return result;
 } catch (Exception e) { 
 return 0;//删除异常，返回0
 }
 } 
  /**
 * 根据主键更新一条记录
 * @param depotAdminInfo
 * @return
 */
 public Integer update(DepotAdminInfo depotAdminInfo) { 
 try { 
 Integer result = depotAdminInfoMapper.update(depotAdminInfo);
 return result;
 } catch (Exception e) { 
 return 0;//更新异常，返回0
 }
 } 
  /**
 * 更具主键查询一条记录
 *
 * @param obj 主键
 * @return 对象实体
 * @
 */
 @Override
 public Object findByPrimaryKey(Object obj) { 
 try { 
 return depotAdminInfoMapper.findByPrimaryKey(obj);
 } catch (Exception e) { 
 return null;//查询异常，返回0
 }
 } 
  /**************************************
   * depotAdminInfoService
  *************************************/
/**
 * 根据账号查询密码
 * @param account
 * @return
 */
  public String getPasswordByAccount(String account) {
     try {
        String password = depotAdminInfoMapper.findPasswordByAccount(account);
        return password;
     } catch (Exception e) {
        return null;
     }
  }
 
  /**
 * 根据用户名查询用户的基本信息
 *
 * @param account
 * @return
 */
 @Override
 public DepotAdminInfo getDepotAdminInfoByAccount(String account) { 
 try{ 
 return (DepotAdminInfo) (depotAdminInfoMapper.findByName(account)).get(0);
 }catch(Exception e){ 
 return null;
 }
 }
 } 
  DepotFareStandardServiceImpl
 package com.cloud.station.service.impl; 
  import com.cloud.station.pojo.CarInfo;
 import com.cloud.station.pojo.DepotFareStandard;
 import com.cloud.station.service.DepotFareStandardService; 
  public class DepotFareStandardServiceImpl implements DepotFareStandardService{ 
 /**
 * 根据车信息计费
 *
 * @param carInfo
 * @return
 */
 @Override
 public Float calculateFare(CarInfo carInfo) { 
 return null;
 } 
  } 
  DepotInfoServiceImpl
 package com.cloud.station.service.impl; 
  import com.cloud.station.algorithm.Distance;
 import com.cloud.station.pojo.dto.Position;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service; 
  import com.cloud.station.base.impl.BaseServiceImpl;
 import com.cloud.station.mapper.DepotInfoMapper;
 import com.cloud.station.pojo.DepotInfo;
 import com.cloud.station.service.DepotInfoService; 
  import java.util.ArrayList;
 import java.util.List;
 import java.util.Map; 
  @Service(“depotInfoService”)
 public class DepotInfoServiceImpl extends BaseServiceImpl
 implements DepotInfoService{  
  @Autowired
 private DepotInfoMapper depotInfoMapper; 
  /**
 * 增加一条记录
 * @param entity 实体
 * @return 影响记录条数
 * @
 */
 @Override
 public Integer save(Object entity){ 
 try{ 
 Integer result = depotInfoMapper.insert(entity);
 return result;
 }catch(Exception e){ 
 return 0;
 } 
  } 
  /**
 * 更新一条记录
 * @param entity 实体
 * @return 影响记录条数
 */
 @Override
 public Integer update(Object entity){ 
 try{ 
 Integer result = depotInfoMapper.update(entity);
 return result;
 }catch(Exception e){ 
 return 0;
 }
 } 
  /**
 * 根据主键删除一条记录
 * @param id 主键
 * @return 影响记录条数
 * @
 */
 public Integer deleteByPrimaryKey(Integer id){ 
 try{ 
 Integer result = depotInfoMapper.deleteByPrimaryKey(id);
 return result;
 }catch(Exception e){ 
 return 0;
 }
 } 
  /**
 * 更具主键查询一条记录
 *
 * @param obj 主键
 * @return 对象实体
 * @
 */
 @Override
 public Object findByPrimaryKey(Object obj) { 
 try{ 
 return depotInfoMapper.findByPrimaryKey(obj);
 }catch(Exception e){ 
 return null;
 }
 } 
  /**
 * 根据名称精确查找
 *
 * @param name 名称
 * @return
 * @
 */
 @Override
 public List findByName(String name) { 
 try { 
 return depotInfoMapper.findByName(name);
 } catch (Exception e) { 
 return null;
 }
 } 
  /**
 * 分页查询
 *
 * @param skip 跳过记录数
 * @param limit 每页记录查询条数
 * @return 集合
 * @
 */
 @Override
 public List findByPage(Integer skip, Integer limit) { 
 try { 
 return depotInfoMapper.findByPage((skip-1)*limit,limit);
 } catch (Exception e) { 
 return null;
 }
 } 
  /**
 * 根据经纬度查询
 *
 * @param position 经纬度范围
 * @param skip 跳过记录条数
 * @param limit 每页条数
 * @return
 */
 public List getByLatAndLon(Position position, int skip, int limit) { 
 try { 
 return depotInfoMapper.findByLatAndLon(position,(skip-1)*limit,limit);
 } catch (Exception e) { 
 return null;
 }
 } 
  /**
 * 根据经纬度查询
 *
 * @param lat 中心经纬
 * @param lng
 * @param dis
 * @param skip 跳过记录条数
 * @param limit 每页条数 @Param lng 中心纬度
 * @return
 * @Param dis 中心覆盖距离
 */
 @Override
 public List getByLatAndLon(double lat, double lng, double dis, int skip, int limit) { 
 Position position = Distance.calcPosition(lat,lng,dis);
 try { 
 return depotInfoMapper.findByLatAndLon(position,(skip-1)*limit,limit);
 } catch (Exception e) { 
 return null;
 }
 } 
  /**
 * 根据车牌查找实体
 *
 * @param carNum
 * @return
 */
 @Override
 public DepotInfo getByCarNumber(String carNum) { 
 DepotInfo depotInfo = new DepotInfo();
 depotInfo.setName(carNum);
 return (DepotInfo) find(depotInfo);
 } 
  /**
 * 查询
 *
 * @param entity 实体
 * @return List 集合
 * @
 */
 @Override
 public List find(Object entity) { 
 try { 
 return depotInfoMapper.find(entity);
 } catch (Exception e) { 
 return null;
 }
 } 
  /**
 * 根据主键删除一条记录
 *
 * @param pk 主键
 * @return 影响记录条数
 * @
 */
 @Override
 public Integer deleteByPrimaryKey(Object pk) { 
 try { 
 return depotInfoMapper.deleteByPrimaryKey(pk);
 } catch (Exception e) { 
 return 0;
 }
 } 
  /**
 * 统计总记录条数
 *
 * @return 总记录数
 * @
 */
 @Override
 public Long count() { 
 try { 
 return depotInfoMapper.count();
 } catch (Exception e) { 
 return 0L;
 }
 }
 } 
  DepotStationServiceImpl
 package com.cloud.station.service.impl; 
  import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service; 
  import com.cloud.station.base.impl.BaseServiceImpl;
 import com.cloud.station.mapper.DepotStationMapper;
 import com.cloud.station.pojo.DepotStation;
 import com.cloud.station.service.DepotStationService;
 import com.cloud.station.service.DepotStationService; 
  @Service(“depotStationService”)
 public class DepotStationServiceImpl extends BaseServiceImpl implements
 DepotStationService {  
  @Autowired
 private DepotStationMapper depotStationMapper; 
  /**
 * 增加一条记录
 *
 * @param entity 实体
 * @return 影响记录条数
 * @
 */
 @Override
 public Integer save(Object entity) { 
 try { 
 return depotStationMapper.insert(entity);
 } catch (Exception e) { 
 return 0;
 }
 } 
  /**
 * 更新一条记录
 *
 * @param entity 实体
 * @return 影响记录条数
 * @
 */
 @Override
 public Integer update(Object entity) { 
 try { 
 Integer result = depotStationMapper.update(entity);
 return result;
 } catch (Exception e) { 
 return 0;
 }
 } 
  /**
 * 根据主键删除一条记录
 *
 * @param pk 主键
 * @return 影响记录条数
 * @
 */
 @Override
 public Integer deleteByPrimaryKey(Object pk) { 
 try { 
 Integer result = depotStationMapper.deleteByPrimaryKey(pk);
 return result;
 } catch (Exception e) { 
 return 0;
 }
 } 
  /**
 * 更具主键查询一条记录
 *
 * @param obj 主键
 * @return 对象实体
 * @
 */
 @Override
 public Object findByPrimaryKey(Object obj) { 
 try {  
       return depotStationMapper.findByPrimaryKey(obj);
  } catch (Exception e) {
     return null;
  }
 
  }
 } 
  DepotStationStateServiceImpl
 package com.cloud.station.service.impl; 
  import com.cloud.station.base.impl.BaseServiceImpl;
 import com.cloud.station.mapper.DepotStationStateMapper;
 import com.cloud.station.pojo.DepotStationState;
 import com.cloud.station.pojo.dto.MapAddressDTO;
 import com.cloud.station.service.DepotStationStateService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service; 
  import java.util.List;
 import java.util.ListIterator; 
  @Service(“depotStationStateService”)
 public class DepotStationStateServiceImpl extends BaseServiceImpl implements DepotStationStateService {  
  @Autowired
DepotStationStateMapper depotStationStateMapper;
/**
 * 增加一条记录
 *
 * @param entity 实体
 * @return 影响记录条数
 * @
 */
@Override
public Integer save(Object entity) {
    try {
       return depotStationStateMapper.insert(entity);
    } catch (Exception e) {
        return 0;
    }
}

/**
 * 增加或更新一条记录
 *
 * @param entity 实体
 * @return 影响记录条数
 * @
 */
@Override
public Integer saveOrUpdate(Object entity) {
    Integer rst = 0;
    try {
        DepotStationState depotStationState = (DepotStationState) depotStationStateMapper.find(entity);

        if(depotStationState!=null)
            rst =depotStationStateMapper.update(entity);
        else
            rst = depotStationStateMapper.insert(entity);
    } catch (Exception e) {
        rst = 0;
    }
    return rst;
}

/**
 * 根据地址查找停车场的状态信息包括停车场的基本信息
 *
 * @param mapAddressDTO
 * @return
 */
@Override
public List findByMapAddress(MapAddressDTO mapAddressDTO) {

    return null;
}
 
  } 
  FareServiceImpl
 package com.cloud.station.service.impl; 
  import com.cloud.station.base.impl.BaseServiceImpl;
 import com.cloud.station.fare.api.ChargeApi;
 import com.cloud.station.fare.entity.Rule;
 import com.cloud.station.mapper.FareRuleMapper;
 import com.cloud.station.pojo.FareRule;
 import com.cloud.station.service.FareService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service; 
  import java.util.List; 
  @Service(“fareService”)
 public class FareServiceImpl extends BaseServiceImpl implements FareService{  
  @Autowired
FareRuleMapper fareRuleMapper;

/**
 * 增加一条记录
 *
 * @param entity 实体
 * @return 影响记录条数
 * @
 */
@Override
public Integer save(Object entity) {
    try {
        return fareRuleMapper.insert(entity);
    } catch (Exception e) {
        return 0;
    }
}

/**
 * 查询停车场当前正在使用的规则
 *
 * @param stationId
 * @return
 */
@Override
public FareRule getUsedByStationId(Long stationId) {
    try {
        return fareRuleMapper.getUsedByStationId(stationId);
    } catch (Exception e) {
        return null;
    }
}

/**
 * 根据停车场ID查询所有
 *
 * @param stationId
 * @return
 */
@Override
public List getAll(Long stationId) {
    try {
        return fareRuleMapper.getAll(stationId);
    } catch (Exception e) {
        return null;
    }
}

/**
 * 停车场计费
 *
 * @param rule
 * @return
 */
@Override
public float calc(Rule rule) {
    return (new ChargeApi(rule)).calc();
}

/**
 * 根据主键删除一条记录
 *
 * @param pk 主键
 * @return 影响记录条数
 * @
 */
@Override
public Integer deleteByPrimaryKey(Object pk) {
    try {
        return fareRuleMapper.deleteByPrimaryKey(pk);
    } catch (Exception e) {
        return 0;
    }
}

/**
 * 更具主键查询一条记录
 *
 * @param obj 主键
 * @return 对象实体
 * @
 */
@Override
public Object findByPrimaryKey(Object obj) {
    try {
        return fareRuleMapper.findByPrimaryKey(obj);
    } catch (Exception e) {
        return null;
    }
}

/**
 * 更新一条记录
 *
 * @param entity 实体
 * @return 影响记录条数
 * @
 */
@Override
public Integer update(Object entity) {
    try {
        return fareRuleMapper.update(entity);
    } catch (Exception e) {
        return 0;
    }
}
 
  } 
  FriendServiceImpl
 package com.cloud.station.service.impl; 
  import com.cloud.station.base.impl.BaseServiceImpl;
 import com.cloud.station.mapper.FriendMapper;
 import com.cloud.station.pojo.ex.FriendEx;
 import com.cloud.station.service.FriendService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service; 
  import java.util.List; 
  @Service(“friendService”)
 public class FriendServiceImpl extends BaseServiceImpl implements FriendService {  
  @Autowired
FriendMapper friendMapper;

/**
 * 增加一条记录
 *
 * @param entity 实体
 * @return 影响记录条数
 * @
 */
@Override
public Integer save(Object entity) {
    try {
        return friendMapper.insert(entity);
    } catch (Exception e) {
        return 0;
    }
}

/**
 * 更新一条记录
 *
 * @param entity 实体
 * @return 影响记录条数
 * @
 */
@Override
public Integer update(Object entity) {
    try {
        return friendMapper.update(entity);
    } catch (Exception e) {
        return 0;
    }
}

/**
 * 查询
 *
 * @param entity 实体
 * @return List    集合
 * @
 */
@Override
public List find(Object entity) {
    try {
        return friendMapper.find(entity);
    } catch (Exception e) {
        return null;
    }
}

/**
 * 根据主键删除一条记录
 *
 * @param pk 主键
 * @return 影响记录条数
 * @
 */
@Override
public Integer deleteByPrimaryKey(Object pk) {
    try {
        return friendMapper.deleteByPrimaryKey(pk);
    } catch (Exception e) {
        return 0;
    }
}


/**
 * 获取好友列表
 *
 * @param myId
 * @param relative
 * @param unrelative
 * @param page
 * @param limit
 * @return
 */
@Override
public List getFriendList(Long myId, Integer relative, Integer unrelative, Integer page, Integer limit)  {
    try {
        return friendMapper.getFriendList(myId,relative,unrelative,(page-1)*limit,limit);
    } catch (Exception e) {
        return null;
    }
}

/**
 * 条件查询总数
 *
 * @param myId
 * @param relative
 * @param unrelative
 * @return
 */
@Override
public Long countByFilter(Long myId, Integer relative, Integer unrelative) {
    try {
        return friendMapper.countByFilter(myId,relative,unrelative);
    } catch (Exception e) {
        return 0L;
    }
}
 
  } 
  PayServiceImpl
 package com.cloud.station.service.impl; 
  import com.cloud.station.fare.api.ChargeApi;
 import com.cloud.station.fare.entity.Rule;
 import com.cloud.station.mapper.CarInfoMapper;
 import com.cloud.station.mapper.CarNumberUsingMapper;
 import com.cloud.station.mapper.UserInfoMapper;
 import com.cloud.station.pojo.*;
 import com.cloud.station.service.FareService;
 import com.cloud.station.service.PayService;
 import com.cloud.station.service.StationOrderService;
 import org.apache.catalina.User;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service; 
  import java.util.Date; 
  @Service(“payService”)
 public class PayServiceImpl implements PayService{  
  @Autowired
CarInfoMapper carInfoMapper;

@Autowired
UserInfoMapper userInfoMapper;

@Autowired
CarNumberUsingMapper carNumberUsingMapper;

@Autowired
StationOrderService stationOrderService;

@Autowired
FareService fareService;
/**
 * 根据车牌扣费
 *
 * @param carNumber
 * @return
 */
@Override
public float pay(String carNumber,Long endTime) {
    try {
        //1.根据车牌查询车牌的信息
        CarInfo carInfo = carInfoMapper.getByCarNumber(carNumber);
        //2.查出使用车牌的用户信息
        UserInfo userInfo = (UserInfo) userInfoMapper.findByPrimaryKey(carInfo.getCurrentUsed());
        //3.查询出当前车牌的使用情况
        CarNumberUsing  carNumberUsing = (CarNumberUsing) carNumberUsingMapper.getByCarNumberId(carInfo.getId(),1);

        Long usedTimeMs = carNumberUsing.getEndTime()-endTime;//使用时间(毫秒)

        //计算费用
        float money = calculate(usedTimeMs);

        //计算余额
        float leftMoney = userInfo.getMoney()-money;
        leftMoney = Float.valueOf(String.format("%.2f",leftMoney));//保留两位小数
        if(leftMoney>=0){
            //更新用户数据
            userInfo.setMoney(leftMoney);
            //增加信誉
            userInfo.setReputationPoints(userInfo.getReputationPoints()+5);//TODO 增加信誉度
            userInfoMapper.update(userInfo);

            //更新车牌使用数据
            carNumberUsing.setEndTime(endTime);//更新数据
            carNumberUsing.setState(2);
            carNumberUsingMapper.update(carNumberUsing);

            //更新当前使用车牌数据
            carInfo.setCurrentUsed(0L);
            carInfoMapper.update(carInfo);

            return leftMoney;
        }

        //余额不足
        //更新使用车牌数据
        carNumberUsing.setState(3);
        carNumberUsing.setEndTime(endTime);
        carNumberUsingMapper.update(carNumberUsing);


        //更新车牌数据
        carInfo.setCurrentUsed(0L);
        carInfoMapper.update(carInfo);

        //更新用户数据
        userInfo.setMoney(leftMoney);//余额复数
        userInfo.setReputationPoints(userInfo.getReputationPoints()-5);TODO 扣除信誉度 增加一个不良记录
        userInfoMapper.update(userInfo);
        return leftMoney;
    } catch (Exception e) {
       return -1;
    }
}

/**
 * 根据停车和停车场ID付款
 *
 * @param stationId
 * @param carNum
 * @return
 */
@Override
public float pay(Long stationId, String carNum) {
    //1.获取车牌信息
    StationOrder stationOrder = stationOrderService.getByStationIdAndCarNuber(stationId,carNum);

    if(stationOrder==null)return -1;
    //如果订单已被处理
    if(stationOrder.getEndTime()>0 ||
            stationOrder.getState()==StationOrder.NORMAL ||
            stationOrder.getUserId()!=null)
        return -1;

    //2.根据车牌找到当前使用者的用户信息
    try {
        //找到当前使用者相关的车主绑定的车牌信息
        CarInfo carInfo = carInfoMapper.getByCarNumber(carNum);
        //当前使用者的用户信息
        UserInfo userInfo = (UserInfo) userInfoMapper.findByPrimaryKey(carInfo.getCurrentUsed());

        int usedTimeMs = Integer.valueOf((int) ((new Date().getTime()-stationOrder.getCreateTime())/1000/60/60));//使用时间(毫秒)
        /**
         * 计算费用
         */
        //1.获得计费规则
        FareRule fareRule = fareService.getUsedByStationId(stationId);
        Rule rule = new Rule();
        rule.setRule(fareRule.getRule());
        rule.setMode(fareRule.getMode());
        rule.setTotalTime(usedTimeMs);
        rule.setStartTime(stationOrder.getCreateTime()/1000/60/60);//小时数
        rule.setEndTime((new Date().getTime())/1000/60/60);
 
  // rule.setEndTime(1523671463702L+86060*1000);8小时
 float fareTotal = (new ChargeApi(rule)).calc();//总费用 
          if(usedTimeMs>=0){//时间有效
            float leftMoney = userInfo.getMoney()-fareTotal;//扣除后用户余额

            //扣费
            //1.用户余额不足
            if(leftMoney<=0){
                userInfo.setReputationPoints(reputationPoint(userInfo,0));//计算信誉度

                stationOrder.setState(StationOrder.UNDO_MONEY);//欠费
            }else{//用户余额够
                userInfo.setRankPoints(rankPoint(userInfo));//计算积分
                userInfo.setReputationPoints(reputationPoint(userInfo,1));//计算信誉度

                stationOrder.setState(StationOrder.NORMAL);
            }
            //用户余额
            userInfo.setMoney(leftMoney);

            //更新用户信息
            userInfoMapper.update(userInfo);

            //更新车牌信息
            carInfo.setCurrentUsed(0L);//释放当前使用者
            carInfoMapper.update(carInfo);

            //更新订单信息
            stationOrder.setEndTime(new Date().getTime());
            stationOrder.setUserId(userInfo.getId());
            stationOrderService.update(stationOrder);

            return fareTotal;//返回消费
        }
        return -1;
    } catch (Exception e) {
        e.printStackTrace();
        return -1;
    }
}

/**
 * 计算费用
 * @param starTime
 * @return
 */
private float calculate(float starTime){
    //TODO 计算总费用
    return 10;
}


/**
 * 支付宝扣费
 * @return
 */
private boolean alipay(){

    return true;
}

//

/**
 * TODO 计算信誉度
 * @param userInfo 用户信息
 * @param mode 模式0:余额不足   1:余额足
 * @return
 */
private float reputationPoint(UserInfo userInfo,Integer mode){
    return userInfo.getReputationPoints()-5;
}

//TODO 计算积分
private float rankPoint(UserInfo userInfo){
    return userInfo.getRankPoints()+5;
}
 
  } 
  下一章

智能停——基于云计算的停车服务平台

你可能感兴趣的:(Java项目,java,项目)