基于javaweb和mysql的springboot物流快递在线寄查快递系统(java+springboot+freemarker+mysql+maven)

毕业程序员java

317人浏览 · 2025-08-30 22:22:00

毕业程序员java · 2025-08-30 22:22:00 发布

私信源码获取及调试交流

运行环境

Java≥8、MySQL≥5.7

开发工具

eclipse/idea/myeclipse/sts等均可配置运行

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb的SpringBoot物流快递在线寄查快递系统(java+springboot+freemarker+mysql+maven)

超级管理员：系统管理、用户管理、网点管理、运输点管理、快递员管理、网点申请管理（审核）、报价管理（时效报价）等。

普通用户：注册登录、个人信息管理（个人资料、密码修改等）、地址管理、实名认证、在线寄件（单件寄件、批量导入寄件）、订单查询（物流信息查询）、在线申请网点、投诉建议等。

网点管理员：揽收负责区域的快递，进行快递快递运输，确认到达快递，快递到达后指派网点下快递员进行派送。

运输点管理员：负责运输至该运输点的快递再次运输。

运行环境：windows/Linux均可、jdk1.8、mysql5.7、idea/eclipse均可。

        }

        return Result.success(true);
    }

    /**
     * 快递员签收
     * @param id
     * @return
     */
    @RequestMapping("/signFor")
    @ResponseBody
    public Result<Boolean> signFor(@RequestParam("id") Long id){

        if (null == id){
            return Result.error(CodeMsg.ADMIN_EXPRESSMAILORDER1_BUYOFF1_EDIT_ERROR);

        }

        if (1 == buyOffService.signForComplete(id)) {
            return Result.error(CodeMsg.ADMIN_EXPRESSMAILORDER1_BUYOFF1_EDIT_ERROR);
        }

        return Result.success(true);
    }

}

/**

            return Result.error(CodeMsg.ADMIN_EXPRESSMAILORDER_ADD_ERROR);
        }
        //保存成功返回成功消息
        return Result.success(true);
    }

    /**
     * 进行设置上门送件时间
     *
     * @param expressMailOrderId
     * @return
     */
    @RequestMapping(value = "/setPickUpTime", method = RequestMethod.POST)
    @ResponseBody
    public Result<Boolean> setPickUpTime(String pickUpTime, Long expressMailOrderId) {
        ExpressMailOrder expressMailOrder = expressMailOrderService.find(expressMailOrderId);
        if (expressMailOrder.getOrderStatus().equals(ExpressMailOrderStatus.SIGNFOR)){
            return Result.error(CodeMsg.ADMIN_EXPRESSMAILORDER_SETPICKUPTIME_ERROR1);
        }
        SimpleDateFormat simpledateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        ParsePosition parseposition = new ParsePosition(0);
        Date date = simpledateformat.parse(pickUpTime, parseposition);
        expressMailOrder.setPickUpTime(date);

        //验证成功进行保存
        if (expressMailOrderService.save(expressMailOrder) == null) {
            return Result.error(CodeMsg.ADMIN_EXPRESSMAILORDER_SETPICKUPTIME_ERROR);
        }
        //保存成功返回成功消息
        return Result.success(true);
    }

    /**
     * 进行表单验证进行保存
     *
     * @param recipientsInfo
     * @return
     */
    @RequestMapping(value = "/saveAdd", method = RequestMethod.POST)
    @ResponseBody
    public Result<Boolean> saveAdd(String recipientsInfo) {
        List<ExpressMailOrder> expressMailOrders = JSONObject.parseArray(recipientsInfo, ExpressMailOrder.class);
        for (ExpressMailOrder expressMailOrder : expressMailOrders) {
            //进行实体类验证
            CodeMsg validate = ValidateEntityUtil.validate(expressMailOrder);

    @ResponseBody
    public Result<Boolean> delete(@RequestParam(name = "id") Long id) {
        try {
            homeUserAddressService.delete(id);
        } catch (Exception e) {
            return Result.error(CodeMsg.HOMEUSERADDRESS_DELETE_ERROR);
        }
        return Result.success(true);
    }

    /**
     * 修改默认地址
     * @param id
     * @return
     */
    @RequestMapping("/defaultAddress")
    @ResponseBody
    public Result<Boolean> defaultAddress(@RequestParam(name = "id") Long id) {
        HomeUser homeUser = SessionUtil.getHomeUser();
        HomeUserAddress homeUserAddress = homeUserAddressService.find(id);
        HomeUserAddress byIsDefault = homeUserAddressService.findByIsDefaultAndHomeUserTypeAndHomeUser_Id(
                HomeUserAddress.DEFAULT,homeUserAddress.getHomeUserType(),homeUser.getId());
        if (byIsDefault != null) {
            byIsDefault.setIsDefault(1);
            if (homeUserAddressService.save(byIsDefault) == null) {
                return Result.error(CodeMsg.HOMEUSERADDRESS_DEFAULT_ERROR);
            }
        }
        homeUserAddress.setIsDefault(0);
        if (homeUserAddressService.save(homeUserAddress) == null) {
            return Result.error(CodeMsg.HOMEUSERADDRESS_DEFAULT_ERROR);
        }
        return Result.success(true);
    }

}


    /**
     * 删除网点申请
     * @param id
     * @return
     */
    @RequestMapping(value = "/deleteApplyFor", method = RequestMethod.POST)
    @ResponseBody
    public Result<Boolean> deleteApplyFor(@RequestParam(name = "id", required = false) Long id) {
        BranchApplyFor branchApplyFor = branchApplyForService.find(id);
        if (branchApplyFor.getBranchApplyForStatus().getCode() == 0) {
            return Result.error(CodeMsg.BRANCHAPPLYFOR_STATUS_ERROR);
        }
        if (branchApplyFor.getBranchApplyForStatus().getCode() == 1) {
            return Result.error(CodeMsg.BRANCHAPPLYFOR_STATUSNOT_ERROR);
        }
        try {
            branchApplyForService.delete(id);
        } catch (Exception e) {
            return Result.error(CodeMsg.BRANCHAPPLYFOR_DELETE_ERROR);
        }
        return Result.success(true);

    }

}

@Configuration
@RequestMapping("/home/entryPage")
public class EntryPageController {

    @Autowired
    private HomeUserAddressService homeUserAddressService;
    @Autowired
    private HomeUserIdCardService homeUserIdCardService;

    @RequestMapping("/singletonPage")
    public String singletonPage(Model model) {
        HomeUser homeUser = SessionUtil.getHomeUser();

				}
			}
			mac = sb.toString();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return mac.toUpperCase();
	}

	public static boolean authOrder(String orderSn,String phone){
		Map<String, String> headerParaMap = new HashMap<String, String>();
		String mac = getMac();
		String paramToken = DESUtil.encrypt(orderSn, mac+"#"+orderSn+"#"+phone);
		headerParaMap.put("paramToken", paramToken);
		String timeToken = DESUtil.encrypt("muyi_ylrc", System.currentTimeMillis()+"");
		headerParaMap.put("timeToken", timeToken);
		String sendPost = HttpUtil.sendPost("http://120.25.120.129:8081/order_auth/verify",headerParaMap,"orderSn="+orderSn+"&phone="+phone+"&mac="+mac);
		JSONObject parseObject = JSONObject.parseObject(sendPost);
		if(parseObject.getIntValue("code") != CodeMsg.SUCCESS.getCode()){
			return false;
		}
		return true;
	}

	public static String readFileToString(File file){
		String string = "";
		if(file != null){
			try {
				BufferedReader br = new BufferedReader(new FileReader(file));
				String line = null;
				while ((line = br.readLine()) != null) {
					string += line;
				}
				br.close();
			} catch (Exception e) {
				// TODO: handle exception
			}
		}
		return string;
	}

}

        return Result.success(true);

    }

    /**
     * 跳转到注册页面
     * @return
     */
    @RequestMapping(value="/register",method= RequestMethod.GET)
    public String register(){
        return "home/register";
    }

    /**
     * 用户注册
     * @param homeUser
     * @param code
     * @return
     */
    @RequestMapping(value="/register",method= RequestMethod.POST)
    @ResponseBody
    public Result<Boolean> register(HomeUser homeUser, @RequestParam("reCode") String code) {
        //正则验证输入的手机号是否合法
        String checkPhone = "^1[3|4|5|7|8]\\d{9}$";
        Pattern r = Pattern.compile(checkPhone);
        Matcher m = r.matcher(homeUser.getMobile());
        if (!m.matches()) {
            return Result.error(CodeMsg.HOMEUSER_MOBILE_ERROR);
        }
        if (!StringUtil.emailFormat(homeUser.getEmail())) {
            return Result.error(CodeMsg.COMMON_EMAIL_FORMAET_ERROR);
        }
        if (code == null) {
            return Result.error(CodeMsg.HOMEUSER_CODE_ERROR);
        }
        if (code.length() != 4) {
            return Result.error(CodeMsg.HOMEUSER_CODE_LENGTH_ERROR);
        }
        Object attr = SessionUtil.get(SessionConstant.HOME_USER_REGISTER_CODE);
        if (attr == null) {
            return Result.error(CodeMsg.CODE_NOT_EMPTY);
        }
        if (!code.equalsIgnoreCase(attr.toString())) {
            return Result.error(CodeMsg.CPACHA_ERROR);
        }
        //判断手机号是否已注册
        if(homeUserService.isExistMobile(homeUser.getMobile(),0L)){
            return Result.error(CodeMsg.HOMEUSER_MOBILE_EXIST);
        }

		CodeMsg validate = ValidateEntityUtil.validate(menu);
		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
			return Result.error(validate);
		}
		if(menu.getParent() != null){
			if(menu.getParent().getId() == null){
				menu.setParent(null);
			}
		}
		Menu existMenu = menuService.find(menu.getId());
		if(existMenu == null){
			Result.error(CodeMsg.ADMIN_MENU_ID_ERROR);
		}
		//表示验证都通过，开始添加数据库
		existMenu.setIcon(menu.getIcon());
		existMenu.setName(menu.getName());
		existMenu.setParent(menu.getParent());
		existMenu.setSort(menu.getSort());
		existMenu.setUrl(menu.getUrl());
		existMenu.setButton(menu.isButton());
		existMenu.setShow(menu.isShow());
		if(menuService.save(existMenu) == null){
			Result.error(CodeMsg.ADMIN_MENU_ADD_ERROR);
		}
		//数据库添加操作成功,记录日志
		operaterLogService.add("编辑菜单信息【" + existMenu + "】");
		return Result.success(true);
	}
	
	/**
	 * 删除菜单信息
	 * @param request
	 * @param id
	 * @return
	 */
	@RequestMapping(value="/delete",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> delete(@RequestParam(name="id",required=true)Long id){
		try {
			menuService.delete(id);
		} catch (Exception e) {
			return Result.error(CodeMsg.ADMIN_MENU_DELETE_ERROR);
		}
		//数据库添加操作成功,记录日志
		operaterLogService.add("删除菜单信息，菜单ID【" + id + "】");
		return Result.success(true);
	}
}

		orderAuth.setPhone(phone);
		orderAuthService.save(orderAuth);
		AppConfig.ORDER_AUTH = 1;
		return Result.success(true);
	}
	/**
	 * 修改密码页面
	 * @return
	 */
	@RequestMapping(value="/update_pwd",method=RequestMethod.GET)
	public String updatePwd(){
		return "admin/system/update_pwd";
	}
	
	/**
	 * 修改密码表单提交
	 * @param oldPwd
	 * @param newPwd
	 * @return
	 */
	@RequestMapping(value="/update_pwd",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> updatePwd(@RequestParam(name="oldPwd",required=true)String oldPwd,
			@RequestParam(name="newPwd",required=true)String newPwd
			){
		User loginedUser = SessionUtil.getLoginedUser();
		if(!loginedUser.getPassword().equals(oldPwd)){
			return Result.error(CodeMsg.ADMIN_USER_UPDATE_PWD_ERROR);
		}
		if(StringUtils.isEmpty(newPwd)){
			return Result.error(CodeMsg.ADMIN_USER_UPDATE_PWD_EMPTY);
		}
		loginedUser.setPassword(newPwd);
		//保存数据库
		User save = userService.save(loginedUser);
		//更新session
		SessionUtil.set(SessionConstant.SESSION_USER_LOGIN_KEY, save);
		return Result.success(true);
	}
	
	/**
	 * 日志管理列表
	 * @param model
	 * @param operaterLog
	 * @param pageBean
	 * @return
	 */
	@RequestMapping(value="/operator_log_list")
	public String operatorLogList(Model model,OperaterLog operaterLog,PageBean<OperaterLog> pageBean){
		model.addAttribute("pageBean", operaterLogService.findList(operaterLog, pageBean));
		model.addAttribute("operator", operaterLog.getOperator());


/**
 * 网点管理控制层
 */

@RequestMapping("/admin/branches")
@Controller
public class BranchesController {

    @Autowired
    private UserService userService;
    @Autowired
    private RoleService roleService;
    @Autowired
    private OperaterLogService operaterLogService;
    
    /**
     * 网点列表页面
     * @param model
     * @param user
     * @param pageBean
     * @return
     */
    @RequestMapping(value="/list")
    public String list(Model model, User user, PageBean<User> pageBean){
        model.addAttribute("title", "网点列表");
        model.addAttribute("username", user.getUsername());
        model.addAttribute("pageBean", userService.findList(pageBean,user.getUsername(), UserRoleTypeEnum.BRANCHES));
        return "admin/branches/list";
    }

    /**
     * 网点编辑页面
     * @param model

			return Result.error(CodeMsg.ADMIN_USE_ADD_ERROR);
		}
		operaterLogService.add("添加管理员，管理员名：" + user.getUsername());
		return Result.success(true);
	}
	
	/**
	 * 管理员编辑页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/edit",method=RequestMethod.GET)
	public String edit(Model model,@RequestParam(name="id",required=true)Long id){
		model.addAttribute("roles", roleService.findAllByRoleType(UserRoleTypeEnum.ADMIN));
		model.addAttribute("user", userService.find(id));
		return "admin/user/edit";
	}
	
	/**
	 * 编辑管理员信息表单提交处理
	 * @param user
	 * @return
	 */
	@RequestMapping(value="/edit",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> edit(User user){
		//用统一验证实体方法验证是否合法
		CodeMsg validate = ValidateEntityUtil.validate(user);
		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
			return Result.error(validate);
		}
		if(user.getRole() == null || user.getRole().getId() == null){
			return Result.error(CodeMsg.ADMIN_USER_ROLE_EMPTY);
		}
		if(user.getId() == null || user.getId().longValue() <= 0){
			return Result.error(CodeMsg.ADMIN_USE_NO_EXIST);
		}
		if(userService.isExistUsername(user.getUsername(), user.getId())){
			return Result.error(CodeMsg.ADMIN_USERNAME_EXIST);
		}
		//到这说明一切符合条件，进行数据库保存
		User findById = userService.find(user.getId());
		//讲提交的管理员信息指定字段复制到已存在的user对象中,该方法会覆盖新字段内容
		BeanUtils.copyProperties(user, findById, "id","createTime","updateTime","userType");
		if(userService.save(findById) == null){
			return Result.error(CodeMsg.ADMIN_USE_EDIT_ERROR);


/**
 * 运输点管理控制层
 */

@RequestMapping("/admin/transport")
@Controller
public class TransportController {

    @Autowired
    private UserService userService;
    @Autowired
    private RoleService roleService;
    @Autowired
    private OperaterLogService operaterLogService;
    
    /**
     * 运输点列表页面
     * @param model
     * @param user
     * @param pageBean
     * @return
     */
    @RequestMapping(value="/list")
    public String list(Model model, User user, PageBean<User> pageBean){
        model.addAttribute("title", "运输点列表");
        model.addAttribute("username", user.getUsername());
        model.addAttribute("pageBean", userService.findList(pageBean,user.getUsername(), UserRoleTypeEnum.TRANSPORT));
        return "admin/transport/list";
    }

    /**
     * 新增运输点页面
     * @param model
     * @return
     */
    @RequestMapping(value="/add",method= RequestMethod.GET)
    public String add(Model model){
        model.addAttribute("roles", roleService.findAllByRoleType(UserRoleTypeEnum.TRANSPORT));
        return "admin/transport/add";
    }

     * @param homeUser
     * @return
     */
    @RequestMapping("/update")
    @ResponseBody
    public Result<Boolean> update(HomeUser homeUser) {
        CodeMsg validate = ValidateEntityUtil.validate(homeUser);
        if (validate.getCode() != CodeMsg.SUCCESS.getCode()) {
            return Result.error(validate);
        }
        if (homeUserService.isExistMobile(homeUser.getName(), homeUser.getId())) {
            return Result.error(CodeMsg.HOMEUSER_MOBILE_EXIST);
        }
        HomeUser findById = homeUserService.find(homeUser.getId());
        //讲提交的管理员信息指定字段复制到已存在的user对象中,该方法会覆盖新字段内容
        BeanUtils.copyProperties(homeUser, findById, "id", "createTime", "updateTime", "password", "email");
        HomeUser save = homeUserService.save(findById);
        if (save == null) {
            return Result.error(CodeMsg.HOMEUSER_EDIT_ERROR);
        }
        SessionUtil.set(SessionConstant.SESSION_HOME_USER_LOGIN_KEY, save);
        return Result.success(true);
    }

    /**
     * 跳转到修改密码页面
     * @param model
     * @return
     */
    @RequestMapping("/updatePassword")
    public String updatePassword(Model model) {
        HomeUser homeUser = SessionUtil.getHomeUser();
        model.addAttribute("homeUser", homeUser);
        model.addAttribute("index", 4);
        return "home/user_manager/update_password";
    }

    /**
     * 修改密码
     * @param homeUser
     * @param code
     * @return
     */

	public Result<Boolean> add(User user){
		//用统一验证实体方法验证是否合法
		CodeMsg validate = ValidateEntityUtil.validate(user);
		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
			return Result.error(validate);
		}
		if(user.getRole() == null || user.getRole().getId() == null){
			return Result.error(CodeMsg.ADMIN_USER_ROLE_EMPTY);
		}
		//判断管理员名是否存在
		if(userService.isExistUsername(user.getUsername(), 0L)){
			return Result.error(CodeMsg.ADMIN_USERNAME_EXIST);
		}
		user.setUserType(UserRoleTypeEnum.ADMIN);
		//到这说明一切符合条件，进行数据库新增
		if(userService.save(user) == null){
			return Result.error(CodeMsg.ADMIN_USE_ADD_ERROR);
		}
		operaterLogService.add("添加管理员，管理员名：" + user.getUsername());
		return Result.success(true);
	}
	
	/**
	 * 管理员编辑页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/edit",method=RequestMethod.GET)
	public String edit(Model model,@RequestParam(name="id",required=true)Long id){
		model.addAttribute("roles", roleService.findAllByRoleType(UserRoleTypeEnum.ADMIN));
		model.addAttribute("user", userService.find(id));
		return "admin/user/edit";
	}
	
	/**
	 * 编辑管理员信息表单提交处理
	 * @param user
	 * @return
	 */
	@RequestMapping(value="/edit",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> edit(User user){
		//用统一验证实体方法验证是否合法
		CodeMsg validate = ValidateEntityUtil.validate(user);
		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
			return Result.error(validate);
		}
		if(user.getRole() == null || user.getRole().getId() == null){


/**
 * @info : 前台用户个人中心控制层
 */
@RequestMapping("/home/userManager")
@Controller
public class HomeUserManagerController {

    @Autowired
    private HomeUserService homeUserService;
    @Autowired
    private HomeUserIdCardService homeUserIdCardService;

    /**
     * 跳转到个人中心首页
     * @param model
     * @return
     */
    @RequestMapping("/index")

            return Result.error(validate);
        }
        if (homeUserAddress.getMobile() == null && homeUserAddress.getPhone() == null) {
            return Result.error(CodeMsg.HOMEUSERADDRESS_MOBILE_PHONE_ERROR);
        }
        if ("".equals(homeUserAddress.getMobile()) && "".equals(homeUserAddress.getPhone())) {
            return Result.error(CodeMsg.HOMEUSERADDRESS_MOBILE_PHONE_ERROR);
        }
        if (homeUserAddress.getIsDefault() == 0) {
            HomeUserAddress byIsDefault = homeUserAddressService.findByIsDefaultAndHomeUserTypeAndHomeUser_Id(
                    HomeUserAddress.DEFAULT,homeUserAddress.getHomeUserType(),homeUser.getId());
            if (byIsDefault != null) {
                byIsDefault.setIsDefault(1);
                if (homeUserAddressService.save(byIsDefault) == null) {
                    return Result.error(CodeMsg.HOMEUSERADDRESS_ADD_ERROR);
                }
            }
        }
        HomeUserAddress byId = homeUserAddressService.find(homeUserAddress.getId());
        //讲提交的管理员信息指定字段复制到已存在的user对象中,该方法会覆盖新字段内容
        BeanUtils.copyProperties(homeUserAddress, byId, "id", "createTime", "updateTime", "homeUser");
        if (homeUserAddressService.save(byId) == null) {
            return Result.error(CodeMsg.HOMEUSERADDRESS_ADD_ERROR);
        }
        return Result.success(true);
    }

    /**
     * 删除地址
     * @param id
     * @return
     */
    @RequestMapping("/delete")
    @ResponseBody
    public Result<Boolean> delete(@RequestParam(name = "id") Long id) {
        try {
            homeUserAddressService.delete(id);
        } catch (Exception e) {
            return Result.error(CodeMsg.HOMEUSERADDRESS_DELETE_ERROR);

     * @param model
     * @return
     */
    @RequestMapping(value = "/realName")
    public String realName(Model model) {
        HomeUser homeUser = SessionUtil.getHomeUser();
        HomeUserIdCard byHomeUserId = homeUserIdCardService.findByHomeUser_Id(homeUser.getId());
        model.addAttribute("homeUser", homeUser);
        model.addAttribute("byHomeUserId", byHomeUserId);
        model.addAttribute("index", 4);
        model.addAttribute("active", 2);
        return "home/user_manager/real_name";
    }

    /**
     * 用户进行实名认证
     * @param homeUserIdCard
     * @param code
     * @return
     */
    @RequestMapping(value = "/addRealName", method = RequestMethod.POST)
    @ResponseBody
    public Result<Boolean> addRealName(HomeUserIdCard homeUserIdCard, @RequestParam("code") String code) {
        HomeUser homeUser = SessionUtil.getHomeUser();
        HomeUserIdCard byHomeUser_id = homeUserIdCardService.findByHomeUser_Id(homeUser.getId());
        if (byHomeUser_id != null) {
            return Result.error(CodeMsg.HOMEUSERIDCARD_EXIST);
        }
        CodeMsg validate = ValidateEntityUtil.validate(homeUserIdCard);
        if (validate.getCode() != CodeMsg.SUCCESS.getCode()) {
            return Result.error(validate);
        }
        if (code == null) {
            return Result.error(CodeMsg.HOMEUSER_CODE_ERROR);
        }
        if (code.length() != 4) {
            return Result.error(CodeMsg.HOMEUSER_CODE_LENGTH_ERROR);
        }
        Object attr = SessionUtil.get(SessionConstant.HOME_USER_REAL_NAME_CODE);
        if (attr == null) {
            return Result.error(CodeMsg.CODE_NOT_EMPTY);
        }
        if (!code.equalsIgnoreCase(attr.toString())) {
            return Result.error(CodeMsg.CPACHA_ERROR);

		return "admin/user/edit";
	}
	
	/**
	 * 编辑管理员信息表单提交处理
	 * @param user
	 * @return
	 */
	@RequestMapping(value="/edit",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> edit(User user){
		//用统一验证实体方法验证是否合法
		CodeMsg validate = ValidateEntityUtil.validate(user);
		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
			return Result.error(validate);
		}
		if(user.getRole() == null || user.getRole().getId() == null){
			return Result.error(CodeMsg.ADMIN_USER_ROLE_EMPTY);
		}
		if(user.getId() == null || user.getId().longValue() <= 0){
			return Result.error(CodeMsg.ADMIN_USE_NO_EXIST);
		}
		if(userService.isExistUsername(user.getUsername(), user.getId())){
			return Result.error(CodeMsg.ADMIN_USERNAME_EXIST);
		}
		//到这说明一切符合条件，进行数据库保存
		User findById = userService.find(user.getId());
		//讲提交的管理员信息指定字段复制到已存在的user对象中,该方法会覆盖新字段内容
		BeanUtils.copyProperties(user, findById, "id","createTime","updateTime","userType");
		if(userService.save(findById) == null){
			return Result.error(CodeMsg.ADMIN_USE_EDIT_ERROR);
		}
		operaterLogService.add("编辑管理员，管理员名：" + user.getUsername());
		return Result.success(true);
	}
	
	/**
	 * 删除管理员
	 * @param id
	 * @return
	 */
	@RequestMapping(value="/delete",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> delete(@RequestParam(name="id",required=true)Long id){
		try {
			userService.delete(id);
		} catch (Exception e) {
			return Result.error(CodeMsg.ADMIN_USE_DELETE_ERROR);