基于SSM的汽车维修管理软件设计与实现

目 录
摘要 I
Abstract II
1 绪论 1
1.1 课题研究的背景 1
1.2 课题研究的现状 1
1.3 课题研究的意义 1
1.4 文档的内容 2
2 开发工具及相关技术 3
2.1 Eclipse工具 3
2.2 WebStorm工具 3
2.3 Navicat for MySQL工具 3
2.4 Java技术 3
2.5 Spring技术 3
3 需求分析 4
3.1 需求陈述 4
3.2 业务建模 4
3.2.1 业务流程 4
3.2.2 业务用例建模 5
3.2.3 业务活动图 6
3.2.4 业务静态建模 7
4 系统设计 8
4.1 体系结构设计 8
4.2 系统总体设计 8
4.3 系统功能设计 9
4.3.1 车辆接待功能 9
4.3.2 维修项目登记 11
4.3.3 维修领料 13
4.3.4 质检完工 15
4.3.5 消费结算 17
4.4 数据库设计 19
4.4.1 数据库逻辑结构设计 19
4.4.2 数据表设计 19
4.5 安全性设计 28
5 系统实现 31
5.1 登录页面的实现 31
5.2 后台首页的实现 31
5.3 车辆接待的实现 32
5.3.1 车辆接待信息填写页面的实现 32
5.3.2 添加用户的实现 33
5.3.2 选择用户的实现 33
5.4 维修项目登记的实现 34
5.4.1 维修项目登记主页面实现 34
5.4.2 维修项目登记的实现 34
5.4.3 维修材料登记页面的实现 35
5.5 维修领料的实现 35
5.6 质检完工的实现 36
5.7 消费结算的实现 36
5.8 采购配件的实现 37
5.9 库存管理的实现 37
5.10 供应商信息管理的实现 38
5.11 客户资料管理的实现 38
5.12 系统基础数据配置的实现 39
5.13 系统用户管理的实现 39
5.14 修改密码的实现 40
5.15 数据备份还原的实现 40
6 系统测试 41
6.1 车辆接待模块选择用户功能测试 41
6.2 车辆接待模块选择添加用户功能能测试 41
6.3 车辆接待模块分配维修人员和质检人员功能测试 42
6.4 车辆接待模块添加维修单功能测试 42
结论 43
致谢 44
参考文献 45
3 需求分析
3.1 需求陈述
汽车维修管理系统是针对维修厂日常运营管理而设计的一款软件。该软件需要能够帮助修理厂从维修接待、维修检测施工、维修领料、质检核算等环节实现自动化，帮助维修厂的工作人员提高工作效率，减少出错的概率，使汽车维修厂能够平稳高效运营，提升修理厂的经济效益。同时该系统需要能够帮助维修厂统计的营业效益，用图表统计的方式让数据更加生动的展现出来。该系统核心模块有客户的接待模块、维修登记模块、维修领料模块、维修质检模块和支付结算模块。这些模块共通组成了汽车维修厂所真正需要的一个B/S架构的在线管理系统。
3.2 业务建模
3.2.1 业务流程
1.车辆接待：汽车修理厂的工作人员接待新的客户，当有车辆到汽修厂时，需要进行用户信息的登记。首先工作人员先查看本维修厂是否有当前的客户，如果有当前的客户就继续登记车辆的其他信息，如果没有登录则需要重新记录用户的信息形成用户的档案。在确定了用户信息之后，需要登记车主描述的车辆状况的信息，登记汽车上的贵重物品，与用户核实是否需要清洁车辆、查看旧件、检查备胎等业务，确定用户最终提车的时间。然后工作人员会安排当前汽车修理厂的相关的维修人员和质检人员。用户拿到发票等待汽车的维修完成。没有其他的异常情况进入下一个业务环节。
2.维修项目登记：维修人员了解当前自己维修的任务有哪些，查看维修订单，了解客户描述的车辆的状况，然后进行汽车的检测，记录当前的车辆需要维修的项目以备最终的支付结算。同时维修人员需要对自己维修工作中对于当前车辆所要用到的零件进行登记，并由维修人员拿到的零件领取单去零件仓库领取相关的材料，来完成最终的维修任务。维修人员在维修完毕并确定无误后可交接给质检人员进行相关维修项目的质检，观察维修项目是否合格。维修人员如果还未曾领取材料则到第三个步骤进行维修材料的领取。维修完毕后则进入第五个步骤质检完工的环节。
3.维修领料：在第二步骤的操作中，维修人员在登记了自己所要领取的材料之后，需要进行材料的领取。领取材料后需要对领取人、领取材料的时间、领取材料的名称以及领取材料的数量进行登记，进行后续的操作。如果发现零件库存不够则通知相关的采购人员进行原材料的采购工作，如果材料数量足够则用户领取材料继续第二个步骤维修项目登记的环节。
4.采购配件：当维修人员进行领取材料的时候，发现材料库存量不足则需要进行材料的采购工作，采购员拿到相关的待采购的订单后，进行采购订单的业务环节，期间采购需要记录下采购的商家、零件的名称、采购的价格、采购的日期以及采购的单价等信息，方便财务管理和后续的业务操作。采购完成后，待维修人员进行维修材料的领取。没有异常情况，进行后续的业务操作。
5.质检完工：维修人员在交接给维修质检人员时，质检人员需要查看质检人员登记的维修项目有哪些，根据维修项目进行质检，对于质检不通过的需要告知维修人员哪里还存在问题，退回给维修人员继续维修直至维修质检完全通过。当该订单所有的内容经过维修并且已经维修通过的时候，本文转载自http://www.biyezuopin.vip/onews.asp?id=12654该笔订单就进入到的维修支付的阶段，如果没有质检通过，则退回到第二个步骤维修登记部分。
6.消费结算：作为最后一个部分支付部分，该部分为用户到维修厂进行提车，用户对自己的汽车进行订单的支付功能，工作人员会列出用户当前所有的登记过的维修项目的费用和已经使用过相关零件材料的费用进行合计。顾客针对自己的订单完成支付。整个维修过程，从接单、维修、支付提车就结束了。

package com.javaweb.controller;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Properties;

import javax.servlet.http.HttpServletRequest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import com.javaweb.service.impl.ServiceFactory;
import com.javaweb.utils.BaseController;
import com.javaweb.utils.CreateFileUtil;
import com.javaweb.utils.MyWebUtils;
import com.javaweb.utils.StringUtils;
import com.javaweb.views.UserView;

/**
 * 系统管理
 * 
 * @author PengChan
 *
 */
@Controller
@RequestMapping("/base")
@Scope("prototype")
public class SystemManageController extends BaseController {
	
	private static final Logger logger = LoggerFactory.getLogger(SystemManageController.class);
	
	// 数据库名称
	public static String databasename = "";
	// mysql安装的地址
	public static String mysqldump = "";
	// 数据库用户名
	public static String username="";
	// 数据库密码
	public static String password = "";
	// mysqlexe
	public static String mysqlexe="";
	
	static{
		try {
			Properties properties = new Properties();
			properties.load(SystemManageController.class.getResourceAsStream("/jdbc.properties"));
			databasename = properties.getProperty("databasename");
			mysqldump = properties.getProperty("mysqldump");
			username = properties.getProperty("username");
			password = properties.getProperty("password"); 
			mysqlexe = properties.getProperty("mysqlexe");
		} catch (Exception e) {
			logger.error("读取mysql备份还原配置失败");
		}
	}

	

	@InitBinder
	public void initBinder(WebDataBinder binder) {
		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		dateFormat.setLenient(false);
		binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));
	}

	@Autowired
	private ServiceFactory serviceFactory;

	/**
	 * 查询所有的用户
	 * 
	 * @param status
	 * @param page
	 * @param rows
	 * @return
	 */
	@RequestMapping("/queryUser")
	@ResponseBody
	public String queryUser(String status, Integer page, Integer rows, String key) {
		return responseSuccess(serviceFactory.getSystemManageService().queryAllUser(page, rows, status, key));
	}

	/**
	 * 用户信息管理 operation:c:创建,u:更新,d:删除
	 * 
	 * @return
	 */
	@RequestMapping("/{operation}/modiUser")
	@ResponseBody
	public String modiUser(UserView userView, String allprivileges, @PathVariable("operation") String operation) {
		boolean flag = false;
		if (org.apache.commons.lang.StringUtils.isNotBlank(operation)) {
			try {
				int[] myprivileges = null;
				logger.info("===========================>allprivileges：" + allprivileges);
				if (org.apache.commons.lang.StringUtils.isNotBlank(allprivileges)) {
					String[] privileges = allprivileges.split(",");
					myprivileges = new int[privileges.length];
					for (int i = 0; i < myprivileges.length; i++) {
						myprivileges[i] = StringUtils.getIntegerValue(privileges[i], -1);
					}
				}
				flag = serviceFactory.getSystemManageService().modifyUser(userView, myprivileges, operation);
			} catch (Exception e) {
				logger.error("用户信息管理异常!");
			}
		}
		return responseSuccess(flag);
	}

	/**
	 * 查询所有的权限
	 * 
	 * @return
	 */
	@RequestMapping("/queryAllPrivilege")
	@ResponseBody
	public String queryAllPrivilege() {
		return responseArraySuccess(serviceFactory.getSystemManageService().queryAllPermission());
	}

	/**
	 * 查询所有的部门
	 * 
	 * @return
	 */
	@RequestMapping("/queryAllSector")
	@ResponseBody
	public String queryAllSector() {
		return responseArraySuccess(serviceFactory.getSystemManageService().queryAllSectors());
	}

	/**
	 * 查询所有用户的权限
	 * 
	 * @param accountnumber
	 * @return
	 */
	@RequestMapping("/queryAllUserPrivilege")
	@ResponseBody
	public String queryAllUserPrivilege(String accountnumber) {
		return responseArraySuccess(serviceFactory.getSystemManageService().queryAllUserPer(accountnumber));
	}

	/**
	 * 修改用户密码
	 * 
	 * @param accountid
	 * @return
	 */
	@RequestMapping("/modiPass")
	@ResponseBody
	public String modiPass(String pass, HttpServletRequest request) {
		boolean flag = false;
		String accountnumber = MyWebUtils.getCurrentUser(request).getAccountnumber();
		flag = serviceFactory.getSystemManageService().modifyPass(pass, accountnumber);
		return responseSuccess(flag);
	}
	
	
	/**
	 * 数据库备份
	 * 
	 * @param location
	 * @return
	 */
	@RequestMapping("/databaseBF")
	@ResponseBody
	public String databaseBF(String location, HttpServletRequest request) {		
		boolean flag = false;
		if(org.apache.commons.lang.StringUtils.isNotBlank(location)){
			try {
	            Runtime rt = Runtime.getRuntime();
	 
	            // 调用 调用mysql的安装目录的命令
	            Process child = rt
	                    .exec(mysqldump+" -h localhost -u"+username+" -p"+password+" "+databasename);
	            // 设置导出编码为utf-8。这里必须是utf-8
	            // 把进程执行中的控制台输出信息写入.sql文件，即生成了备份文件。注：如果不对控制台信息进行读出，则会导致进程堵塞无法运行
	            InputStream in = child.getInputStream();// 控制台的输出信息作为输入流
	 
	            InputStreamReader xx = new InputStreamReader(in, "utf-8");
	            // 设置输出流编码为utf-8。这里必须是utf-8，否则从流中读入的是乱码
	 
	            String inStr;
	            StringBuffer sb = new StringBuffer("");
	            String outStr;
	            // 组合控制台输出信息字符串
	            BufferedReader br = new BufferedReader(xx);
	            while ((inStr = br.readLine()) != null) {
	                sb.append(inStr + "\r\n");
	            }
	            outStr = sb.toString();
	 
	            // 要用来做导入用的sql目标文件：
	            CreateFileUtil.createFile(location);
	            File objfile = new File(location); 
	            FileOutputStream fout = new FileOutputStream(objfile);
	            OutputStreamWriter writer = new OutputStreamWriter(fout, "utf-8");
	            writer.write(outStr);
	            writer.flush();
	            in.close();
	            xx.close();
	            br.close();
	            writer.close();
	            fout.close();  
	            flag = true;
	        } catch (Exception e) { 
	           logger.info("数据库备份操作失败!");
	        }
		} 
		return flag?responseSuccess(flag):responseFail("数据库备份操作失败！");
	}
	

	/**
	 * 数据库还原
	 * 
	 * @param location
	 * @return
	 */
	@RequestMapping("/databaseHY")
	@ResponseBody
	public String databaseHY(HttpServletRequest request,@RequestParam("refreshfile")MultipartFile multipartFile) {		
		boolean flag = false;
		  try {
	            Runtime runtime = Runtime.getRuntime();
	            Process process = runtime
	                    .exec(mysqlexe+" -hlocalhost -u"+username+" -p"+password+" --default-character-set=utf8 "+databasename);
	            OutputStream outputStream = process.getOutputStream();
	            BufferedReader br = new BufferedReader(new InputStreamReader(
	                    multipartFile.getInputStream(), "utf-8"));
	            String str = null;
	            StringBuffer sb = new StringBuffer();
	            while ((str = br.readLine()) != null) {
	                sb.append(str + "\r\n");
	            }
	            str = sb.toString();
	          
	            OutputStreamWriter writer = new OutputStreamWriter(outputStream,
	                    "utf-8");
	            writer.write(str);
	            writer.flush();
	            outputStream.close();
	            br.close();
	            writer.close();
	            logger.info("===========>执行完毕!");
	            flag = true;
	        } catch (Exception e) {  
	            logger.info("数据库还原操作失败!");
	        }
		return flag?responseSuccess(flag):responseFail("数据库还原操作失败！");
	}
}