• Java项目：SSM汽车维修管理系统源码

    作者主页：夜未央5788

     简介：Java领域优质创作者、Java项目、学习资料、技术互助

    文末获取源码

    项目介绍

    源码描述：
    一、源码介绍
    汽车维修管理系统源码使用ssm框架，maven，bootsrap,mysql实现，带数据库。
    二、主要功能
    分为2个角色，管理员和顾客；
    顾客登录后，操作我的车辆，预约订单，历史订单；
    管理员登录后，操作订单管理，员工管理，机位管理，用户管理，零件管理。

    由于本程序规模不大，可供课程设计，毕业设计学习演示之用

    环境需要

    1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。
    2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA;
    3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可
    4.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS；
    5.是否Maven项目: 是；

    6.数据库：MySql 5.7/8.0等版本均可；

    技术栈

    1. 后端：Spring springmvc mybatis

    2. 前端：JSP+css+javascript+jQuery+bootstrap+layui

    使用说明

    1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件；
    2. 使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven;
    若为maven项目，导入成功后请执行maven clean;maven install命令，配置tomcat
    3. 将项目中jdbc.properties配置文件中的数据库配置改为自己的配置，然后运行；
    4. 运行成功后，在浏览器中输入：http://localhost:8080/
    管理员账号密码：admin/admin

    用户账号密码：user/123456

    运行截图

    用户角色

     

     

     

     

    管理员角色

     

     

     

     

     

     

    相关代码 

    CarController

    1. package com.chillax.controller;
    2.  
    3. import java.util.HashMap;
    4. import java.util.List;
    5. import java.util.Map;
    6.  
    7. import javax.annotation.Resource;
    8. import javax.servlet.http.HttpServletRequest;
    9. import javax.servlet.http.HttpServletResponse;
    10. import javax.servlet.http.HttpSession;
    11.  
    12. import org.springframework.stereotype.Controller;
    13. import org.springframework.ui.Model;
    14. import org.springframework.web.bind.annotation.RequestMapping;
    15. import org.springframework.web.bind.annotation.ResponseBody;
    16.  
    17. import com.chillax.bean.Car;
    18. import com.chillax.bean.User;
    19. import com.chillax.service.CarService;
    20. import com.chillax.utils.BaseController;
    21. import com.chillax.utils.DateUtils;
    22. import com.chillax.utils.StringUtil;
    23. import com.chillax.utils.TableData;
    24. @Controller
    25. @RequestMapping("/car")
    26. public class CarController extends BaseController {
    27. 	
    28. 	@Resource
    29. 	private CarService carService;
    30. 	/**页面跳转*/
    31. 	@RequestMapping("/list")
    32. 	public String workList(HttpServletRequest request,HttpSession session){
    33. 		String tag = request.getParameter("tag");
    34. 		request.setAttribute("tag", tag);
    35. 		return "car/car_list";
    36. 	}
    37. 	/**数据获取*/
    38. 	@RequestMapping("/getData")
    39. 	@ResponseBody
    40. 	public String getData(HttpServletResponse response,HttpServletRequest request,String carName){
    41. 		Integer offset = Integer.parseInt(request.getParameter("offset"));//开始条数
    42. 		Integer limit = Integer.parseInt(request.getParameter("limit"));//每页条数
    43. 		Map paramMap=new HashMap();
    44. 		String tag = request.getParameter("tag");
    45. 		User userOn=(User)request.getSession().getAttribute("userOn");
    46. 		if(!StringUtil.isEmpty(tag)){
    47. 			paramMap.put("tag", tag);//tag 标注是否查出在维修车辆 tag=1 不查出
    48. 		}
    49. 		paramMap.put("userId", userOn.getuId());
    50. 		paramMap.put("carName", carName);
    51. 		List cars = carService.selectAllByUser(paramMap);
    52. 		return TableData.getJson2Table(cars, offset, limit);
    53. 	}
    54. 	/**编辑零件信息 */
    55. 	@RequestMapping("/edit")
    56. 	public String editWork(HttpServletRequest request,Model model){
    57. 		try {
    58. 			String id = request.getParameter("id");
    59. 			Car car = new Car();
    60. 			if(StringUtil.isNotEmpty(id)){
    61. 				car = carService.selectByPrimaryKey(id);
    62. 			}
    63. 			model.addAttribute("car", car);
    64. 		} catch (Exception e) {
    65. 			e.printStackTrace();
    66. 		}
    67. 		return "car/car_edit";
    68. 	}
    69. 	@RequestMapping("/add")
    70. 	@ResponseBody
    71. 	public Integer addWorker(HttpServletRequest request,Car car){
    72. 		int record=0;
    73. 		User user=(User)request.getSession().getAttribute("userOn");
    74. 		if( StringUtil.isEmpty(car.getCarId())){
    75. 			/*设置关联用户id*/
    76. 			car.setUserId(user.getuId());
    77. 			car.setCarId(StringUtil.getStringId());
    78. 			record= carService.insertSelective(car);
    79. 		}else{
    80. 			record= carService.updateByPrimaryKeySelective(car);
    81. 		}
    82. 		return record;
    83. 	}
    84. 	/**删除机床*/
    85. 	@RequestMapping("/delById")
    86. 	@ResponseBody
    87. 	public Integer deleteWorker(HttpServletRequest request){
    88. 		String ids = request.getParameter("id");
    89. 		if(StringUtil.isNotEmpty(ids)){
    90. 			String[] sIds = ids.split(",");
    91. 			for (String sId : sIds) {
    92. 				carService.deleteByPrimaryKey(sId);
    93. 			}
    94. 			return 1;
    95. 		}else{
    96. 			return 0;
    97. 		}
    98. 	}
    99. 	
    100. 	@RequestMapping("/selectCar")
    101. 	@ResponseBody
    102. 	public Integer selectCar(HttpServletRequest request,HttpSession session,String carId){
    103. 		if(!StringUtil.isEmpty(carId)){
    104. 			Car preCar = carService.selectByPrimaryKey(carId);
    105. 			session.setAttribute("preCar", preCar);
    106. 		}
    107. 		return 1;
    108. 	}
    109. 	
    110. 	
    111. 	@RequestMapping("/getCarTypeData")
    112. 	@ResponseBody
    113. 	public List> getCarTypeData(HttpServletRequest request,String month){
    114. 		if(StringUtil.isEmpty(month)){
    115. 			month=DateUtils.getYearMonths(1).get(0);
    116. 		}
    117. 		Map map=new HashMap();
    118. 		map.put("date",month);
    119. 		List> list = carService.selectCarTypeData(map);
    120. 		return list;
    121. 	}
    122. }

    OrderController

    1. package com.chillax.controller;
    2.  
    3. import java.text.ParseException;
    4. import java.text.SimpleDateFormat;
    5. import java.util.Date;
    6. import java.util.HashMap;
    7. import java.util.List;
    8. import java.util.Map;
    9.  
    10. import javax.annotation.Resource;
    11. import javax.servlet.http.HttpServletRequest;
    12. import javax.servlet.http.HttpServletResponse;
    13. import javax.servlet.http.HttpSession;
    14.  
    15. import org.springframework.stereotype.Controller;
    16. import org.springframework.web.bind.annotation.RequestMapping;
    17. import org.springframework.web.bind.annotation.ResponseBody;
    18.  
    19. import com.alibaba.fastjson.JSONArray;
    20. import com.alibaba.fastjson.JSONObject;
    21. import com.chillax.bean.Car;
    22. import com.chillax.bean.Order;
    23. import com.chillax.bean.OrderPart;
    24. import com.chillax.bean.OrderWorker;
    25. import com.chillax.bean.Part;
    26. import com.chillax.bean.SStation;
    27. import com.chillax.bean.User;
    28. import com.chillax.bean.Worker;
    29. import com.chillax.service.CarService;
    30. import com.chillax.service.OrderPartService;
    31. import com.chillax.service.OrderService;
    32. import com.chillax.service.OrderWorkerService;
    33. import com.chillax.service.PartService;
    34. import com.chillax.service.StationService;
    35. import com.chillax.service.WorkerService;
    36. import com.chillax.utils.BaseController;
    37. import com.chillax.utils.DateUtils;
    38. import com.chillax.utils.StringUtil;
    39.  
    40. @Controller
    41. @RequestMapping("/order")
    42. public class OrderController extends BaseController {
    43.  
    44. 	private final Integer WARNING_COUNT=20;
    45. 	
    46. 	@Resource
    47. 	private CarService carService;
    48.  
    49. 	@Resource
    50. 	private StationService stationService;
    51.  
    52. 	@Resource
    53. 	private PartService partService;
    54. 	@Resource
    55. 	private OrderPartService orderPartService;
    56. 	
    57. 	@Resource
    58. 	private OrderWorkerService orderWorkerService;
    59.  
    60. 	@Resource
    61. 	private WorkerService workerService;
    62.  
    63. 	@Resource
    64. 	private OrderService orderService;
    65.  
    66. 	/** 页面跳转 预定页面 */
    67. 	@RequestMapping("/toPreOrder")
    68. 	public String toPreOrder(HttpServletRequest request, HttpSession session,
    69. 			String carId) {
    70. 		return "order/preOrder";
    71. 	}
    72.  
    73. 	/** 订单预定 */
    74. 	@RequestMapping("/preOrder")
    75. 	@ResponseBody
    76. 	public Integer preOrder(HttpServletRequest request, HttpSession session,
    77. 			String imgurls, String arriveTime, String desc) {
    78. 		// User user=(User)session.getAttribute("userOn");
    79. 		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    80. 		Date arrDate = null;
    81. 		try {
    82. 			arrDate = format.parse(arriveTime);
    83. 		} catch (ParseException e) {
    84. 			e.printStackTrace();
    85. 		}
    86. 		Car car = (Car) session.getAttribute("preCar");
    87. 		car.setCarState(1);
    88. 		int updateCar = carService.updateByPrimaryKeySelective(car);
    89. 		Order order = new Order();
    90. 		order.setOrderId(StringUtil.getStringId());
    91. 		order.setCarId(car.getCarId());
    92. 		order.setoDescribe(desc);
    93. 		// 0 预约中 1预约成功 2正在执行 3完成 4拒绝
    94. 		order.setoState("0");
    95. 		order.setArriveTime(arrDate);
    96. 		order.setOrdertime(new Date());
    97. 		order.setImgUrls(imgurls);
    98. 		int updateOrder = orderService.insertSelective(order);
    99. 		return updateOrder+updateCar;
    100. 	}
    101.  
    102. 	/** 订单操作 */
    103. 	@RequestMapping("/manage")
    104. 	public String manageOrder(HttpServletRequest request, HttpSession session,String orderId) {
    105. 		Map paramMap=new HashMap();
    106. 		paramMap.put("orderId", orderId);
    107. 		//通过id查出只能是一条数据
    108.  		List> order = orderService.selectOrderByAttr(paramMap);
    109.  		String[] imgurls = order.get(0).get("imgUrls").toString().split(",");
    110.  		//查询所有待使用的机床
    111.  		List stations=stationService.selectAll(new HashMap(){{put("s_state", "完好待使用");}});
    112.  		//查询所有空闲的工人 state=1空闲 2在忙 0离职
    113.  		List workers = workerService.selectWorkersByAttr(new Worker(){{setwState(1);}});
    114.  		//查询所有可使用零件
    115.  		List parts = partService.selectAll();
    116.  		request.setAttribute("imgurls",imgurls);
    117.  		request.setAttribute("dealOrder",order.get(0));
    118.  		request.setAttribute("stations",stations);
    119.  		request.setAttribute("workers",workers);
    120.  		request.setAttribute("parts",parts);
    121.  		return "order/manageOrder";
    122. 	}
    123. 	
    124. 	/** 页面跳转 */
    125. 	@RequestMapping("/list")
    126. 	public String workList(HttpServletRequest request, HttpSession session,String state) {
    127. 		Map paramMap=new HashMap();
    128. 		paramMap.put("state", state);
    129.  		List> order = orderService.selectOrderByAttr(paramMap);
    130.  		session.setAttribute("order", order);
    131.  		request.setAttribute("state", state);
    132. 		return "order/order_list";
    133. 	}
    134.  
    135. 	/**  */
    136. 	@RequestMapping("/accept")
    137. 	@ResponseBody
    138. 	public String acceptOrder(HttpServletResponse response,HttpServletRequest request,String orderId,
    139. 			String remark,String stationId) {
    140. 		String success="1";
    141. 		//获取订单id 机床id 员工id集合 零件id num集合
    142. 		String selectedWorker=request.getParameter("selectedWorker");
    143. 		String[] workers = selectedWorker.split(",");
    144. 		String selParts=request.getParameter("parts");
    145. 		JSONArray parts=JSONArray.parseArray(selParts);
    146. 		//修改订单状态 修改机床状态 更新order-worker order-part表
    147. 		try {
    148. 				
    149. 				Order order = orderService.selectByPrimaryKey(orderId);
    150. 				order.setStationId(Integer.parseInt(stationId));
    151. 				order.setoState("1");//1进行中
    152. 				order.setRemark(remark);
    153. 				order.setBegintime(new Date());
    154. 				orderService.updateByPrimaryKeySelective(order);//更新order
    155. 				
    156. 				SStation station = stationService.selectByPrimaryKey(Integer.parseInt(stationId));
    157. 				station.setsState("完好在使用");
    158. 				stationService.updateByPrimaryKeySelective(station);
    159. 				for(int i=0;i
    160. 					JSONObject jo = parts.getJSONObject(i);
    161. 					String pId = jo.get("id").toString();
    162. 					 int num = Integer.parseInt(jo.get("num").toString());
    163. 					orderPartService.insert(new OrderPart(orderId, pId,num));
    164. 					Part part = partService.selectByPrimaryKey(pId);
    165. 					part.setPartNum(part.getPartNum()-num);
    166. 					partService.updateByPrimaryKeySelective(part);
    167. 				}
    168. 				
    169. 				for(String id :workers){
    170. 					orderWorkerService.insert(new OrderWorker(orderId,id));
    171. 					Worker worker = workerService.selectByPrimaryKey(id);
    172. 					worker.setwState(0);//忙碌
    173. 					workerService.updateByPrimaryKeySelective(worker);
    174. 				}
    175. 				
    176. 		} catch (Exception e) {
    177. 			success="0";
    178. 		}
    179. 		return success;
    180. 	}
    181.  
    182. 	/** 修改订单*/
    183. 	@RequestMapping("/edit")
    184. 	public String edit(HttpServletRequest request,String orderId){
    185. 		Map paramMap=new HashMap();
    186. 		paramMap.put("orderId", orderId);
    187. 		//通过id查出只能是一条数据
    188.  		List> order = orderService.selectOrderByAttr(paramMap);
    189.  		String[] imgurls = order.get(0).get("imgUrls").toString().split(",");
    190.  		//查询机床
    191.     	SStation station = stationService.selectByPrimaryKey(Integer.parseInt(order.get(0).get("s_id").toString()));
    192.  		//查询工人 0在忙 1 空闲
    193.  		List> selWorkers = orderWorkerService.selectByOrderId(order.get(0).get("o_id").toString());
    194.  		//查询所有零件
    195.  		List> selParts = orderPartService.selectByOrderId(order.get(0).get("o_id").toString());
    196.  		
    197.  		//查询所有待使用的机床
    198.  		List stations=stationService.selectAll(new HashMap(){{put("s_state", "完好待使用");}});
    199.  		//查询所有空闲的工人 state=1空闲 2在忙 0离职
    200.  		List workers = workerService.selectWorkersByAttr(new Worker(){{setwState(1);}});
    201.  		//查询所有可使用零件
    202.  		List parts = partService.selectAll();
    203.  		
    204.  		request.setAttribute("imgurls",imgurls);
    205.  		request.setAttribute("dealOrder",order.get(0));
    206.  		request.setAttribute("stations",stations);
    207.  		request.setAttribute("workers",workers);
    208.  		request.setAttribute("parts",parts);
    209.  		request.setAttribute("station",station);//已选中station
    210.  		request.setAttribute("selWorkers",selWorkers);
    211.  		request.setAttribute("selParts",selParts);
    212.  		request.setAttribute("readonly", 0);//非只读
    213.  		return "order/orderDetail";
    214. 	}
    215. 	
    216. 	/** 订单详情*/
    217. 	@RequestMapping("/detail")
    218. 	public String detail(HttpServletRequest request,String orderId){
    219. 		Map paramMap=new HashMap();
    220. 		paramMap.put("orderId", orderId);
    221. 		//通过id查出只能是一条数据
    222.  		List> order = orderService.selectOrderByAttr(paramMap);
    223.  		Map orderMap = order.get(0);
    224.  		String[] imgurls = orderMap.get("imgUrls").toString().split(",");
    225.  		if (orderMap.get("s_id")==null) {
    226.  			request.setAttribute("station",null);
    227.  			request.setAttribute("selWorkers",null);
    228.  			request.setAttribute("selParts",null);
    229.  		}else{
    230.  			//查询机床
    231.  			SStation station = stationService.selectByPrimaryKey(Integer.parseInt(orderMap.get("s_id").toString()));
    232.  			//查询工人 0在忙 1 空闲
    233.  			List> workers = orderWorkerService.selectByOrderId(orderMap.get("o_id").toString());
    234.  			//查询所有零件
    235.  			List> parts = orderPartService.selectByOrderId(orderMap.get("o_id").toString());
    236.  			request.setAttribute("station",station);
    237.  			request.setAttribute("selWorkers",workers);
    238.  			request.setAttribute("selParts",parts);
    239.  		}
    240.  		request.setAttribute("imgurls",imgurls);
    241.  		request.setAttribute("dealOrder",order.get(0));
    242.  		request.setAttribute("readonly", 1);//只读
    243. 		return "order/orderDetail";
    244. 	}
    245. 	/** 订单*/
    246. 	@RequestMapping("/userOrder")
    247. 	public String userOrder(HttpServletRequest request,HttpSession sessions){
    248. 		User user= (User)sessions.getAttribute("userOn");
    249. 		Map paramMap=new HashMap();
    250. 		paramMap.put("userId", user.getuId());
    251. 		List> orders = orderService.selectOrderByAttr(paramMap);//返回用户的多个订单
    252. 		request.setAttribute("orders", orders);
    253. 		return "order/userOrder";
    254. 	}
    255. 	@RequestMapping("/done")
    256. 	@ResponseBody
    257. 	public String doneOrder(HttpServletResponse response,HttpServletRequest request,String orderId) {
    258. 		String msg="1";
    259. 		//更新  1订单状态 2更新机床 3更新员工状态 4更新车辆状态
    260. 		List> ws = orderWorkerService.selectByOrderId(orderId);
    261. 		Order order = orderService.selectByPrimaryKey(orderId);
    262. 		try {
    263. 			//1
    264. 			order.setEndtime(new Date());
    265. 			order.setoState("2");//2完成
    266. 			orderService.updateByPrimaryKeySelective(order);
    267. 			//2
    268. 			SStation station = stationService.selectByPrimaryKey(order.getStationId());
    269. 			station.setsState("完好待使用");
    270. 			stationService.updateByPrimaryKeySelective(station);
    271. 			//4
    272. 			Car car = carService.selectByPrimaryKey(order.getCarId());
    273. 			car.setCarState(0);
    274. 			carService.updateByPrimaryKeySelective(car);
    275. 			//3
    276. 			for (Map map : ws) {
    277. 				String wId= (String)map.get("w_id");
    278. 				Worker worker = workerService.selectByPrimaryKey(wId);
    279. 				worker.setwState(1);//1空闲
    280. 				workerService.updateByPrimaryKeySelective(worker);
    281. 			}
    282. 		} catch (Exception e) {
    283. 			msg="0";
    284. 		}
    285. 		return msg;
    286. 	}
    287. 	
    288. 	/** 订单*/
    289. 	@RequestMapping("/home")
    290. 	public String homePage(HttpServletRequest request,HttpSession sessions){
    291. 		List> list= orderService.selectOrderByAttr(new HashMap(){{put("state", 0);}});
    292. 		request.setAttribute("count", list.size());
    293. 		List yearMonths = DateUtils.getYearMonths(6);//获取半年日期
    294. 		request.setAttribute("yearMonths", yearMonths);
    295. 		
    296. 		List parts = partService.selectAll();
    297. 		for (int i = 0; i < parts.size(); i++) {
    298. 			if(parts.get(i).getPartNum()>parts.get(i).getWarning()){
    299. 				parts.remove(i);
    300. 			}
    301. 		}
    302. 		request.setAttribute("parts", parts);
    303. 		return "home";
    304. 	}
    305. 	/**  */
    306. 	@RequestMapping("/reject")
    307. 	@ResponseBody
    308. 	public String rejectOrder(HttpServletRequest request,String orderId,String remark) {
    309. 		String success="1";
    310. 		//获取订单id 机床id 员工id集合 零件id num集合
    311. 		//修改订单状态 修改机床状态 更新order-worker order-part表
    312. 		try {
    313. 				
    314. 				Order order = orderService.selectByPrimaryKey(orderId);
    315. 				order.setoState("2");//3拒绝
    316. 				order.setRemark(remark);
    317. 				order.setEndtime(new Date());
    318. 				orderService.updateByPrimaryKeySelective(order);//更新order
    319. 				Car car = carService.selectByPrimaryKey(order.getCarId());
    320. 				car.setCarState(0);
    321. 				carService.updateByPrimaryKeySelective(car);
    322. 		} catch (Exception e) {
    323. 			success="0";
    324. 		}
    325. 		return success;
    326. 	}
    327.  
    328. }

    如果也想学习本系统，下面领取。关注并回复：238ssm 

  • 相关阅读:
    有哪些原因会导致excel文档损坏打不开?
    uniapp 设置重写uni-body-page样式，输入字母转大写
    chatgpt赋能python：Python随机选择数字
    Mac OS 使用ScreenCaptureKit进行窗口抓取和系统声音抓取
    webpack构建vue项目 基础09之生产环境 打包为zip文件 与 public静态文件的copy
    自己写了个Java RMI（远程方法调用）的实现案例
    通过浏览器打开某个应用程序
    算法笔记（1）线段树
    强化学习与视觉语言模型之间的碰撞，UC伯克利提出语言奖励调节LAMP框架
    在Vue3中使用Element Plus Icon图标的几种方式
  • 原文地址：https://blog.csdn.net/hanyunlong1989/article/details/127602588