基于Springboot+Vue实现智慧停车场管理系统_spring boot 停车场管理系统源码

作者：小丑西瓜9 | 2024-04-05 06:40:36

踩

spring boot 停车场管理系统源码

作者主页：编程指南针

作者简介：Java领域优质创作者、CSDN博客专家、CSDN内容合伙人、掘金特邀作者、阿里云博客专家、51CTO特邀作者、多年架构师设计经验、腾讯课堂常驻讲师

主要内容：Java项目、Python项目、前端项目、人工智能与大数据、简历模板、学习资料、面试题库、技术互助

收藏点赞不迷路关注作者有好处

文末获取源码

项目编号：BS-XX-175

一，环境介绍

语言环境：Java: jdk1.8

数据库：Mysql: mysql5.7

应用服务器：Tomcat: tomcat8.5.31

开发工具：IDEA或eclipse

开发技术：Springboot+Vue+车牌识别OCR

二，项目简介

本项目主要基于Springboot+Vue开发实现了一个多功能智慧停车场服务管理系统。系统可以根据不同的单位设置不同的停车场，根据各停车场分类实现车牌自动识、自动计时扣费等相关功能，并根据车辆是包月车还是临时车来分类别管理。用户主要分为系统管理员和各单管理员，分配的各单位管理员登录后可以管理自己单的停车场信息以及车辆停放计费信息等。同时系统还提供完美的数据统计功能，以及基本的用户管理、角色管理、停车场管理、汽车管理、缴费信息管理、车辆识别管理、菜单管理和日志记录管理等功能。

三，系统展示

系统登录：

后台管理首页

合作单位管理

账户管理

停车场管理

车辆管理

扫描识别车辆

停车记录

缴费信息

菜单管理

四，核心代码展示


package com.park.service.sys.impl;
 
import com.park.common.constant.Constant;
import com.park.common.utils.PageUtils;
import com.park.dao.sys.SysRoleMapper;
import com.park.entity.sys.SysRoleEntity;
import com.park.service.sys.SysRoleMenuService;
import com.park.service.sys.SysRoleService;
import com.park.service.sys.SysUserRoleService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import java.util.*;
 
/**
 * 角色管理
 *
 * @author Administrator
 */
@Service
public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRoleEntity> implements SysRoleService {
 
    @Autowired
    protected SysRoleMenuService sysRoleMenuService;
    @Autowired
    protected SysUserRoleService sysUserRoleService;
 
    @Override
    public PageUtils selectByPage(Map<String, Object> params) {
        long page = Long.parseLong((String) params.get(Constant.PAGE));
        long limit = Long.parseLong((String) params.get(Constant.LIMIT));
        String roleName = (String) params.get("roleName");
        Page<SysRoleEntity> pages = new Page<>(page, limit);
        QueryWrapper<SysRoleEntity> wrapper = new QueryWrapper<>();
        wrapper.orderByDesc("create_time");
        wrapper.like(StringUtils.isNotBlank(roleName), "role_name", roleName);
        IPage<SysRoleEntity> list = baseMapper.selectPage(pages, wrapper);
        return new PageUtils(list);
    }
 
 
    @Override
    public Set<String> getUserRoles(Long userId) {
        List<String> roleList = baseMapper.getUserRoles(userId);
        //用户权限列表
        Set<String> roleSet = new HashSet<>();
        for (String roles : roleList) {
            if (StringUtils.isBlank(roles)) {
                continue;
            }
            roleSet.addAll(Arrays.asList(roles.trim().split(",")));
        }
        return roleSet;
    }
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveRole(SysRoleEntity entity) {
        //保存角色
        baseMapper.insert(entity);
        //保存角色菜单关系
        sysRoleMenuService.saveOrUpdate(entity.getRoleId(), entity.getMenuIdList());
    }
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateRole(SysRoleEntity entity) {
        //更新角色
        updateById(entity);
        //更新角色菜单关系
        sysRoleMenuService.saveOrUpdate(entity.getRoleId(), entity.getMenuIdList());
    }
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delete(Long[] ids) {
        //删除角色
        baseMapper.deleteBatchIds(Arrays.asList(ids));
 
        //删除角色用户关系
        sysUserRoleService.deleteByRoleIds(ids);
 
        //删除角色菜单关系
        sysRoleMenuService.deleteByRoleIds(ids);
 
    }
    @Override
    public List<SysRoleEntity> getRoleList(long type){
        return baseMapper.getRoleList(type);
    }
}


package com.park.modules.controller.sys;
 
import com.park.common.annotation.SysLog;
import com.park.common.utils.PageUtils;
import com.park.common.utils.R;
import com.park.common.validator.Assert;
import com.park.common.validator.ValidatorUtils;
import com.park.entity.sys.*;
import com.park.modules.base.AbstractController;
import com.park.service.sys.AgentInfoService;
import com.park.shiro.ShiroUtils;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang.ArrayUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
 
import java.util.*;
/*
    1.控制器所有的方法都是返回json格式的数据，通过RestController注解实现
    2.函数的接口名称是通过RequestMapping，PostMapping，GetMapping等注解实现
    3.权限是通过RequiresPermissions实现,权限的名称是通过菜单配置的
    4.文件的上传路径是通过Value注解读取配置文件的参数
    5.所有方法的返回值都是通过R类返回的
    6.所有的控制器都继承AbstractController，通过shiro返回当前登录的用户信息
    7.所有的控制器都是通过Autowired注解返回数据库操作的类
 */
 
@RestController
@RequestMapping("/sys/agent")
public class AgentInfoController extends AbstractController {
    @Autowired
    private AgentInfoService agentInfoService;
    @Value("${upload.absPath}")
    String absPath;
    @Value("${upload.excel}")
    String excel;
 
    @PostMapping("/list")
    @RequiresPermissions("sys:agent:list")
    public R list(@RequestBody Map<String, Object> params) {
        if(getUser().getUserType()==2){
            return R.error("对不起，单位管理员没有权限。");
        }
        PageUtils pageList = agentInfoService.getPageList(params);
        return R.ok().put("data", pageList);
    }
    @PostMapping("/save")
    @RequiresPermissions("sys:agent:save")
    public R saveOrUpdate(@RequestBody AgentInfoEntity agent){
        ValidatorUtils.validateEntity(agent);
        agentInfoService.saveOrUpdate(agent);
 
        return R.ok();
    }
    @ApiOperation("单位信息")
    @GetMapping("/myInfo")
    public R myInfo() {
        AgentInfoEntity agent = agentInfoService.getEntityById(getUser().getAgentId());
        Assert.isNull(agent, "系统中没有该单位");
        return R.ok().put("data", agent);
    }
    @ApiOperation("获取单位信息")
    @GetMapping("/info/{agentId}")
    @RequiresPermissions("sys:agent:info")
    public R info(@PathVariable("agentId") Long agentId) {
        AgentInfoEntity agent = agentInfoService.getEntityById(agentId);
        Assert.isNull(agent, "系统中没有该单位");
        return R.ok().put("data", agent);
    }
    @SysLog("添加单位")
    @PostMapping("/add")
    @ApiOperation("添加单位")
    @RequiresPermissions("sys:agent:add")
    public R add(@RequestBody AgentInfoEntity entity,MultipartFile file1) {
        ValidatorUtils.validateEntity(entity);
        entity.setRegisterTime(new Date());
        SysUserEntity user = ShiroUtils.getUser();
        entity.setManagerName(user.getUsername());
        try {
            agentInfoService.save(entity);
        }catch(Exception e) {
            return R.error("存在重复的单位编号");
        }
        return R.ok();
    }
 
 
    @SysLog("编辑单位")
    @PutMapping("/edit")
    @ApiOperation("编辑单位")
    @RequiresPermissions("sys:agent:info")
    public R edit(@RequestBody AgentInfoEntity entity) {
        ValidatorUtils.validateEntity(entity);
        AgentInfoEntity agent = agentInfoService.getEntityById(entity.getAgentId());
        if(entity.getAgentIcon()==null || entity.getAgentIcon().equals("")){
            entity.setAgentIcon(agent.getAgentIcon());
        }
        entity.setRegisterTime(agent.getRegisterTime());
        entity.setManagerName(ShiroUtils.getUser().getUsername());
        agentInfoService.updateById(entity);
        return R.ok();
    }
    @SysLog("修改单位信息")
    @PutMapping("/editMyInfo")
    @ApiOperation("编辑单位")
    public R editMyInfo(@RequestBody AgentInfoEntity entity) {
        agentInfoService.editMyInfo(entity);
        return R.ok();
    }
 
    @SysLog("删除单位")
    @DeleteMapping("/del")
    @ApiOperation("删除单位")
    @RequiresPermissions("sys:agent:del")
    public R del(@RequestBody Long[] ids) {
 
        if (ArrayUtils.contains(ids, getAgentId())) {
            return R.error("当前单位不能删除");
        }
        agentInfoService.removeByIds(Arrays.asList(ids));
        return R.ok();
    }
    @PostMapping("/exportExcel")
    @RequiresPermissions("sys:agent:list")
    //导出单位信息
    public R expInit(@RequestBody Map<String, Object> params) throws Exception{
 
        List<AgentInfoEntity> agentList = agentInfoService.getExcelList(params);
        String path=excel;
        path=new com.park.utils.ExportToExcel().ExpAgent(agentList,path, 3);
        return R.ok().put("data",path);
    }
}


package com.park.modules.controller.sys;
import com.park.common.annotation.SysLog;
import com.park.common.utils.R;
import com.park.common.validator.ValidatorUtils;
import com.park.entity.sys.AgentInfoEntity;
import com.park.entity.sys.CameraInfoVo;
import com.park.entity.sys.CarParkVo;
import com.park.entity.sys.SysUserEntity;
import com.park.modules.base.AbstractController;
import com.park.service.sys.AgentInfoService;
import com.park.service.sys.CameraInfoService;
import com.park.service.sys.CarInfoService;
import com.park.service.sys.CarParkService;
import com.park.shiro.ShiroUtils;
import io.swagger.annotations.ApiOperation;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
 
import javax.servlet.http.HttpServletRequest;
import java.util.*;
 
@RestController
@RequestMapping("/sys/camera")
public class CameraController extends AbstractController {
    @Autowired
    private CameraInfoService cameraService;
    @Autowired
    private CarParkService parkService;
    @PostMapping("/list")
    @RequiresPermissions("sys:camera:list")
    public R list(@RequestBody Map<String, Object> params) {
        List<CameraInfoVo> cameraList = cameraService.getList(params);
        return R.ok().put("data", cameraList);
    }
 
    @ApiOperation("获取摄像头信息")
    @GetMapping("/info/{cameraInfoId}")
    @RequiresPermissions("sys:camera:info")
    public R info(@PathVariable("cameraInfoId") Long cameraInfoId) {
        CameraInfoVo camera = null;
        if(cameraInfoId>0) {
            camera = cameraService.getById(cameraInfoId);
        }
 
        return R.ok().put("data", camera);
    }
    @SysLog("添加摄像头")
    @PostMapping("/add")
    @ApiOperation("添加摄像头")
    @RequiresPermissions("sys:camera:add")
    public R add(@RequestBody CameraInfoVo entity, HttpServletRequest request){
        CarParkVo park = parkService.getById(entity.getCarParkId());
        entity.setAgentId(park.getAgentId());
        entity.setCreaterTime(new Date());
        SysUserEntity user = ShiroUtils.getUser();
        entity.setCreater(user.getUsername());
        try {
            cameraService.save(entity);
        }catch (Exception e){
            return R.error("IP地址重复。");
        }
        return R.ok();
    }
 
 
    @SysLog("编辑摄像头")
    @PutMapping("/edit")
    @ApiOperation("编辑摄像头")
    @RequiresPermissions("sys:camera:info")
    public R edit(@RequestBody CameraInfoVo entity, HttpServletRequest request) throws Exception {
        ValidatorUtils.validateEntity(entity);
        CameraInfoVo user = cameraService.getById(entity.getCameraInfoId());
        entity.setAgentId(user.getAgentId());
        entity.setCreater(user.getCreater());
        entity.setCreaterTime(user.getCreaterTime());
        try {
            cameraService.updateById(entity);
        }catch (Exception e){
            return R.error("IP地址重复。");
        }
        return R.ok();
    }
 
    @SysLog("删除摄像头")
    @DeleteMapping("/del")
    @ApiOperation("删除摄像头")
    @RequiresPermissions("sys:camera:del")
    public R del(@RequestBody Long[] ids) {
        cameraService.removeByIds(Arrays.asList(ids));
        return R.ok();
    }
}

五，相关作品展示

基于Java开发、Python开发、PHP开发、C#开发等相关语言开发的实战项目

基于Nodejs、Vue等前端技术开发的前端实战项目

基于微信小程序和安卓APP应用开发的相关作品

基于51单片机等嵌入式物联网开发应用

基于各类算法实现的AI智能应用

基于大数据实现的各类数据管理和推荐系统

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】