基于javaweb+mysql的springboot房屋租赁系统(java+springboot+maven+ssm+jsp+jquery+mysql)-CSDN博客

本文链接：https://blog.csdn.net/2301_81060432/article/details/138425918

基于javaweb+mysql的springboot房屋租赁系统(java+springboot+maven+ssm+jsp+jquery+mysql)

私信源码获取及调试交流

运行环境

Java≥8、MySQL≥5.7

开发工具

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

适用

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

功能说明

基于javaweb的SpringBoot房屋租赁系统(java+springboot+maven+ssm+jsp+jquery+mysql)

项目介绍

基于springboot房屋出租系统有前台和后台

登陆角色：用户+房东+管理员

前台功能模块：登陆+注册+整租+合租+租房+新闻资讯+用户反馈+搜索+忘记密码+联系房东等

后台功能模块：用户端：订单管理+个人信息+我的家+我的收藏+密码修改+我的反馈管理员端：房子管理+订单管理+新闻资讯管理+反馈管理+用户管理+个人信息+我的收藏+密码修改房东端：房子管理+订单管理+个人信息+我的收藏+密码修改+我的反馈

环境需要

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

技术栈

后端：SpringBoot(Spring+SpringMVC+Mybatis)

前端: JSP、css、JavaScript、JQuery、Ajax

使用说明

项目运行： 1. 使用Navicat或者其它工具，在mysql中创建对应sql文件名称的数据库，并导入项目的sql文件； 2. 使用IDEA/Eclipse/MyEclipse导入项目，导入成功后请执行maven clean;maven install命令，然后运行； 3. 将项目中application.yml配置文件中的数据库配置改为自己的配置; 4. 运行项目，控制台提示运行成功后再去运行前端项目； 5. 管理员用户名密码：admin/admin 普通用户名密码：user/123456

文档介绍（课题背景与意义、系统实现功能、课题研究现状、系统相关技术、java技术、B/S架构、Mysql介绍、Mysql环境配置、Springboot框架、系统需求分析、系统功能、可行性研究、经济可行性、技术可行性、运行可行性、事件可行性、系统业务过程分析、系统业务过程分析、系统用例图、系统设计、数据库设计、系统整体设计、系统设计思想、系统流程图、系统详情设计、系统功能模块、系统功能模块、管理员功能模块）：

房屋租赁系统-首页展示：

最新整租咨询展示：

租房列表展示：

旅游景点展示页面：

后台管理展示页：

后台订单管理展示页：

        //该订单的房东信息
        order.setOwnerUser(userService.get(order.getOwnerUserId()));
        model.addAttribute("order", order);
        return "front/agreement";
    }

    /*
     * 签订合同
     * */
    @RequestMapping("/order/agreement/submit")
    @ResponseBody
    public JsonResult agreementSubmit(@RequestParam(value = "orderId") Long orderId, Model model) {
        if (getLoginUser() == null) {
            return JsonResult.error("用户未登录");
        }
        //订单不存在
        Order order = orderService.get(orderId);
        if (order == null) {
            return JsonResult.error("订单不存在");
        }

        House house = houseService.get(order.getHouseId());
        if (house == null) {
            return JsonResult.error("房屋信息不存在");
        }

        //登录用户不是该订单的租客、房东或管理员，就无权限查看。
        if (!Objects.equals(getLoginUserId(), order.getCustomerUserId()) && !Objects.equals(getLoginUserId(), order.getOwnerUserId()) && !loginUserIsAdmin()) {
            return JsonResult.error("没有权限");
        }

        if (Objects.equals(house.getStatus(), HouseStatusEnum.HAS_RENT.getValue())) {
            return JsonResult.error("房屋已被租出或未释放");
        }

        Order checkOrder = orderService.getCurrentEffectiveOrder(order.getHouseId());
        if (checkOrder != null) {
            return JsonResult.error("房屋已被租出或未释放");
        }

        User ownerUser = userService.get(house.getUserId());

            orderService.update(order);
            house.setStatus(HouseStatusEnum.HAS_RENT.getValue());
            house.setLastOrderStartTime(order.getStartDate());
            house.setLastOrderEndTime(order.getEndDate());
            houseService.update(house);
            return JsonResult.success("模拟支付成功，联系房东入住吧。");
        } else if (payMethod.equals("2")) {
            /*用于测试环境下的模拟订单支付成功环境*/
            order.setStatus(OrderStatusEnum.NORMAL.getValue());
            orderService.update(order);
            house.setStatus(HouseStatusEnum.HAS_RENT.getValue());
            house.setLastOrderStartTime(order.getStartDate());
            house.setLastOrderEndTime(order.getEndDate());
            houseService.update(house);
            return JsonResult.success("模拟支付成功，联系房东入住吧。");
        } else if (payMethod.equals("8888")) {
            /*用于测试环境下的模拟订单支付成功环境*/
            order.setStatus(OrderStatusEnum.NORMAL.getValue());
            orderService.update(order);
            house.setStatus(HouseStatusEnum.HAS_RENT.getValue());
            house.setLastOrderStartTime(order.getStartDate());
            house.setLastOrderEndTime(order.getEndDate());
            houseService.update(house);
            return JsonResult.success("模拟支付成功，联系房东入住吧。");
        } else {
            return JsonResult.error("未知支付功能参数，请勿修改支付参数！您的IP已被记录。");
        }

    }

    /*
     * 联系房东
     * */
    @RequestMapping("/house/contact")
    @ResponseBody
    public JsonResult contact(@RequestParam("houseId") Long houseId, @RequestParam("name") String name,
                              @RequestParam("phone") String phone, @RequestParam("email") String email,
                              @RequestParam("content") String content) {
        if (getLoginUser() == null) {
            return JsonResult.error("用户未登录");
        }
        House house = houseService.get(houseId);

public class GiftcardController extends BaseController {
    @Autowired
    private UserService userService;

    @Autowired
    private GiftcardService giftcardService;

    /*
     * 充值兑换余额到账户
     * */
    @RequestMapping("/redeem")
    @ResponseBody
    public JsonResult redeem(@RequestParam("series") String series) {
        if(series.equals("")){
            return JsonResult.error("请填写礼品卡代码或PIN！");
        }
        User user = userService.get(getLoginUserId());
        if (user == null) {
            return JsonResult.error("您还未登录！");
        }
        //判断序列号 是否存在、有效
        Double redeem_value = giftcardService.checkValidGiftcard(series, GiftcardStatusEnum.NORMAL.getValue());
        if (Objects.equals(redeem_value, null) || Objects.equals(redeem_value, "")) {
            return JsonResult.error("兑换码不存在或已被使用或已到期");
        }
        Date date = new Date();
        //进行兑换，将礼品卡设置为 status = -1已使用并且，将使用者设置为当前用户
        giftcardService.redeemGiftcard(series, GiftcardStatusEnum.USED.getValue(), date, user.getUserName());
        Double currentBalance = giftcardService.currentBalance(user.getUserName());
        String afterBalance = String.format("%.2f", redeem_value + currentBalance);
        giftcardService.addToUserBalance(afterBalance, user.getUserName());
        return JsonResult.success("兑换成功！礼品卡为您兑换了" + redeem_value + "元");
    }
}

//所有controller控制器的基类
@Controller

@Controller
public class BaseController {
    @Autowired
    protected HttpServletRequest request;

    /*
     * 获取当前登录用户
     * */
    public User getLoginUser() {
        User user = (User) request.getSession().getAttribute(Constant.SESSION_USER_KEY);
        return user;
    }

    /*
     * 获取当前用户ID
     * */
    public Long getLoginUserId() {
        User user = getLoginUser();
        if (user == null) {
            return null;
        }
        return user.getId();
    }

    /*
     * 判断当前用户是管理员
     * */
    public Boolean loginUserIsAdmin() {
        User user = getLoginUser();
        if (user == null) {
            return false;
        }
        return UserRoleEnum.ADMIN.getValue().equalsIgnoreCase(user.getRole());
    }

    /*
     * 判断当前用户是租客
     * */
    public Boolean loginUserIsCustomer() {
        User user = getLoginUser();

        if (user1 != null) {
            return JsonResult.error("用户已存在，请重新输入");
        }

        user.setIdCard("");
        user.setUserAvatar("/assets/img/default-avatar.jpg");
        user.setUserDesc("还未填写...");
        user.setSex("保密");
        user.setHobby("暂未填写");
        user.setJob("暂未填写");
        user.setCreateTime(new Date());
        user.setBalance(100000.00);
        try {
            userService.insert(user);
        } catch (Exception e) {
            e.printStackTrace();
            return JsonResult.error("注册失败，请重试！");
        }
        session.setAttribute(Constant.SESSION_USER_KEY, user);
        return JsonResult.success("注册成功！请继续完善个人资料...");
    }
}

/*
 * 我的收藏查询和取消收藏功能 控制器
 * */
@Controller("backMarkController")
public class MarkController extends BaseController {
    @Autowired
    private HouseService houseService;


    /*
     * 获取当前用户ID
     * */
    public Long getLoginUserId() {
        User user = getLoginUser();
        if (user == null) {
            return null;
        }
        return user.getId();
    }

    /*
     * 判断当前用户是管理员
     * */
    public Boolean loginUserIsAdmin() {
        User user = getLoginUser();
        if (user == null) {
            return false;
        }
        return UserRoleEnum.ADMIN.getValue().equalsIgnoreCase(user.getRole());
    }

    /*
     * 判断当前用户是租客
     * */
    public Boolean loginUserIsCustomer() {
        User user = getLoginUser();
        if (user == null) {
            return false;
        }
        return UserRoleEnum.CUSTOMER.getValue().equalsIgnoreCase(user.getRole());
    }

    /*
     * 判断当前用户是房东
     * */
    public Boolean loginUserIsOwner() {
        User user = getLoginUser();

        }
        //登录用户不是该订单所属租客、管理员、该订单所属房东，不能取消订单。
        if (!loginUserIsAdmin() && !Objects.equals(getLoginUserId(), order.getCustomerUserId()) && !Objects.equals(getLoginUserId(), order.getOwnerUserId())) {
            return JsonResult.error("没有权限");
        }
        order.setStatus(OrderStatusEnum.END_APPLY.getValue());
        orderService.update(order);

        return JsonResult.success("申请退租成功，请联系房东审核");
    }

    /*
     * 退租申请：通过
     * */
    @RequestMapping(value = "/endPass", method = RequestMethod.POST)
    @ResponseBody
    public JsonResult endOrderPass(@RequestParam("orderId") Long orderId) throws ParseException {
        //校验订单是否存在
        Order order = orderService.get(orderId);
        if (order == null) {
            return JsonResult.error("订单不存在");
        }
        //登录用户不是该订单所属租客、管理员、该订单所属房东，不能取消订单。
        if (!loginUserIsAdmin() && !Objects.equals(getLoginUserId(), order.getOwnerUserId())) {
            return JsonResult.error("没有权限");
        }
        order.setStatus(OrderStatusEnum.FINISH.getValue());
        Date date = new Date();
        int dayNum = DateUtil.daysBetween(order.getStartDate(), date);
        order.setDayNum(dayNum);
        order.setTotalAmount(order.getMonthRent() / 30 * dayNum);
        order.setEndDate(date);
        orderService.update(order);

        //将房屋的状态变更一下，未租出状态
        House house = houseService.get(order.getHouseId());
        if (house != null && Objects.equals(house.getStatus(), HouseStatusEnum.HAS_RENT.getValue())) {
            house.setStatus(HouseStatusEnum.NOT_RENT.getValue());
            house.setLastOrderEndTime(date);
            houseService.update(house);
        }

        //若租客提前退租，将退还剩余天数的金额
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        Date endDayFormat = df.parse(df.format(order.getEndDate()));
        Date StartDayFormat = df.parse(df.format(order.getStartDate()));
        Integer livedDay = differentDaysByMillisecond(endDayFormat, StartDayFormat);
        System.out.println(livedDay);
        if (livedDay == 0) {

                return JsonResult.error("上架失败，没有选择的房屋。");
            }
            //如果无管理员权限上架别人的房屋，跳转到403页面
            if (!loginUserIsAdmin() && Objects.equals(house.getUserId(), getLoginUserId())) {
                return JsonResult.error("上架失败，无法上架他人房屋信息。");
            }
            if (Objects.equals(house.getStatus(), HouseStatusEnum.HAS_RENT.getValue())) {
                return JsonResult.error("房屋正在租住中，不能进行上架操作。");
            }
            house.setStatus(HouseStatusEnum.NOT_RENT.getValue());
            houseService.update(house);
        } catch (Exception e) {
            return JsonResult.error("上架房屋失败，请重试。");
        }

        return JsonResult.success("上架成功！");
    }

    /*
     * 房屋审核通过
     * */
    @RequestMapping("/checkPass")
    @ResponseBody
    public JsonResult checkPassHouse(@RequestParam("id") Long id) {
        try {
            House house = houseService.get(id);
            if (house == null) {
                return JsonResult.error("审核失败，您未选中需要审核的房屋");
            }
            //仅限管理员有权限审核
            if (!loginUserIsAdmin()) {
                return JsonResult.error("您无权限审核房屋信息");
            }
            if (!Objects.equals(house.getStatus(), HouseStatusEnum.NOT_CHECK.getValue())) {
                return JsonResult.error("房屋状态不为待审核状态，无法审核。");
            }
            house.setStatus(HouseStatusEnum.NOT_RENT.getValue());
            houseService.update(house);
        } catch (Exception e) {
            return JsonResult.error("审核房屋信息失败，请重试。");
        }

        return JsonResult.success("审核成功！");
    }

    /*
     * 房屋审核拒绝
     * */
    @RequestMapping("/checkReject")
    @ResponseBody
    public JsonResult checkRejectHouse(@RequestParam("id") Long id) {
        try {

     * */
    @RequestMapping("/admin/user/enable")
    @ResponseBody
    public JsonResult enable(@RequestParam("id") Long id) {
        try {
            User user = userService.get(id);
            if (user == null) {
                return JsonResult.error("用户不存在");
            }
            user.setStatus(UserStatusEnum.ENABLE.getValue());
            userService.update(user);
        } catch (Exception e) {
            return JsonResult.error("启用用户失败");
        }

        return JsonResult.success("启用用户成功");
    }

    /*
     * 进入修改密码页面
     * */
    @RequestMapping("/admin/password")
    public String password(Model model) {
        model.addAttribute("tab", "password");
        return "admin/password";
    }

    /*
     * 更新密码
     * */
    @RequestMapping("/admin/password/submit")
    @ResponseBody
    public JsonResult passwordSubmit(@RequestParam("oldPassword") String oldPassword,
                                     @RequestParam("newPassword") String newPassword,
                                     @RequestParam("confirmPassword") String confirmPassword, HttpSession session) {
        if (!Objects.equals(newPassword, confirmPassword)) {
            return JsonResult.error("输入的两次密码不一致");
        }
        User user = userService.get(getLoginUserId());
        if (user == null || !Objects.equals(user.getUserPass(), oldPassword)) {

    }

    /*
     * 申请退租
     * */
    @RequestMapping(value = "/end", method = RequestMethod.POST)
    @ResponseBody
    public JsonResult endOrder(@RequestParam("orderId") Long orderId) {
        //校验订单是否存在
        Order order = orderService.get(orderId);
        if (order == null) {
            return JsonResult.error("订单不存在");
        }
        //登录用户不是该订单所属租客、管理员、该订单所属房东，不能取消订单。
        if (!loginUserIsAdmin() && !Objects.equals(getLoginUserId(), order.getCustomerUserId()) && !Objects.equals(getLoginUserId(), order.getOwnerUserId())) {
            return JsonResult.error("没有权限");
        }
        order.setStatus(OrderStatusEnum.END_APPLY.getValue());
        orderService.update(order);

        return JsonResult.success("申请退租成功，请联系房东审核");
    }

    /*
     * 退租申请：通过
     * */
    @RequestMapping(value = "/endPass", method = RequestMethod.POST)
    @ResponseBody
    public JsonResult endOrderPass(@RequestParam("orderId") Long orderId) throws ParseException {
        //校验订单是否存在
        Order order = orderService.get(orderId);
        if (order == null) {
            return JsonResult.error("订单不存在");
        }
        //登录用户不是该订单所属租客、管理员、该订单所属房东，不能取消订单。
        if (!loginUserIsAdmin() && !Objects.equals(getLoginUserId(), order.getOwnerUserId())) {
            return JsonResult.error("没有权限");
        }
        order.setStatus(OrderStatusEnum.FINISH.getValue());
        Date date = new Date();
        int dayNum = DateUtil.daysBetween(order.getStartDate(), date);
        order.setDayNum(dayNum);
        order.setTotalAmount(order.getMonthRent() / 30 * dayNum);
        order.setEndDate(date);
        orderService.update(order);

        //将房屋的状态变更一下，未租出状态
        House house = houseService.get(order.getHouseId());
        if (house != null && Objects.equals(house.getStatus(), HouseStatusEnum.HAS_RENT.getValue())) {
            house.setStatus(HouseStatusEnum.NOT_RENT.getValue());
            house.setLastOrderEndTime(date);
            houseService.update(house);

        }

        Order checkOrder = orderService.getCurrentEffectiveOrder(houseId);
        if (checkOrder != null) {
            return JsonResult.error("房屋已被租出或未释放");
        }

        User ownerUser = userService.get(house.getUserId());
        if (ownerUser == null) {
            return JsonResult.error("房东用户不存在");
        }

        //退租日期
        SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy");
        Date endDate;
        try {
            endDate = sdf.parse(endDateStr);
        } catch (ParseException e) {
            e.printStackTrace();
            return JsonResult.error("退租日期格式不合法");
        }
        Date startDate = new Date();

        //计算总共天数
        Integer dayNum = DateUtil.daysBetween(startDate, endDate);
        if (dayNum < Constant.MIN_RENT_DAYS) {
            return JsonResult.error("最少租住" + Constant.MIN_RENT_DAYS + "天");
        }

        //创建订单
        Order order = new Order();
        order.setCreateTime(new Date());
        order.setCustomerUserId(getLoginUserId());
        order.setOwnerUserId(house.getUserId());
        order.setHouseId(houseId);
        order.setStatus(OrderStatusEnum.NOT_AGREEMENT.getValue());
        order.setMonthRent(house.getMonthRent());
        order.setDayNum(dayNum);
        order.setTotalAmount(house.getMonthRent() / 30 * dayNum);
        order.setStartDate(startDate);
        order.setEndDate(endDate);
        orderService.insert(order);

        return JsonResult.success("订单创建成功，请签订合同。", order.getId());
    }

    /*
     * 查看合同信息
     * */
    @RequestMapping("/order/agreement/view")
    public String agreementView(@RequestParam(value = "orderId") Long orderId, Model model) {
        if (getLoginUser() == null) {
            return "redirect:/";
        }

    @Autowired
    private FeedbackService feedbackService;

    @RequestMapping("/admin/feedback")
    public String feedback(@RequestParam(value = "page", defaultValue = "1") Long pageNumber, @RequestParam(value = "size", defaultValue = "6") Long pageSize, Model model) {
        Page page = PageUtil.initMpPage(pageNumber, pageSize);
        Feedback condition = new Feedback();
        //如果不是管理员，只查询自己的反馈
        if (!loginUserIsAdmin()) {
            condition.setUserId(getLoginUserId());
        }
        Page<Feedback> feedbackPage = feedbackService.findAll(page, condition);
        model.addAttribute("pageInfo", feedbackPage);
        model.addAttribute("pagePrefix", "/news?");
        model.addAttribute("tab", "feedback-list");
        model.addAttribute("isAdmin", loginUserIsAdmin());
        return "admin/feedback-list";
    }

    @RequestMapping(value = "/admin/feedback/reply/submit", method = RequestMethod.POST)
    @ResponseBody
    public JsonResult replySubmit(Feedback feedback) {
        feedbackService.update(feedback);
        return JsonResult.success("保存成功！");
    }

    /*
     * 删除反馈
     * */
    @RequestMapping("/admin/feedback/delete")
    @ResponseBody
    public JsonResult deleteFeedback(@RequestParam("id") Long id) {
        try {
            Feedback feedback = feedbackService.get(id);
            if (feedback == null) {
                return JsonResult.error("删除失败，未找到反馈ID。");
            }
            if (!loginUserIsAdmin() && !Objects.equals(feedback.getUserId(), getLoginUserId())) {
                return JsonResult.error("无权限操作！");
            }
            feedbackService.delete(id);
        } catch (Exception e) {
            return JsonResult.error("删除反馈信息失败，请重试。");
        }

        return JsonResult.success("删除成功！");
    }

}

     * 获取Ueditor的配置文件
     *
     * @return
     */
    @GetMapping("/config")
    public String getConfig() {
        return "{\n" +
                "        \"imageActionName\": \"uploadimage\",\n" +
                "            \"imageFieldName\": \"file\",\n" +
                "            \"imageMaxSize\": 2048000,\n" +
                "            \"imageAllowFiles\": [\".png\", \".jpg\", \".jpeg\", \".gif\", \".bmp\"],\n" +
                "        \"imageCompressEnable\": true,\n" +
                "            \"imageCompressBorder\": 1600,\n" +
                "            \"imageInsertAlign\": \"none\",\n" +
                "            \"imageUrlPrefix\": \"\",\n" +
                "            \"imagePathFormat\": \"/ueditor/jsp/upload/image/{yyyy}{mm}{dd}/{time}{rand:6}\",\n" +
                "\n" +
                "        /* 上传文件配置 */\n" +
                "        \"fileActionName\": \"uploadfile\",\n" +
                "            \"fileFieldName\": \"file\",\n" +
                "            \"filePathFormat\": \"/ueditor/jsp/upload/file/{yyyy}{mm}{dd}/{time}{rand:6}\",\n" +
                "            \"fileUrlPrefix\": \"\",\n" +
                "            \"fileMaxSize\": 51200000,\n" +
                "            \"fileAllowFiles\": [\n" +
                "        \".png\", \".jpg\", \".jpeg\", \".gif\", \".bmp\",\n" +
                "                \".flv\", \".swf\", \".mkv\", \".avi\", \".rm\", \".rmvb\", \".mpeg\", \".mpg\",\n" +
                "                \".ogg\", \".ogv\", \".mov\", \".wmv\", \".mp4\", \".webm\", \".mp3\", \".wav\", \".mid\",\n" +
                "                \".rar\", \".zip\", \".tar\", \".gz\", \".7z\", \".bz2\", \".cab\", \".iso\",\n" +
                "                \".doc\", \".docx\", \".xls\", \".xlsx\", \".ppt\", \".pptx\", \".pdf\", \".txt\", \".md\", \".xml\"]\n" +
                "    }";
    }

    /**
     * Ueditor上传文件
     * 这里以上传图片为例，图片上传后，imgPath将存储图片的保存路径，返回到编辑器中做展示
     *
     * @param file
     * @return
     */
    @PostMapping("/upload")
    public String upload(@RequestParam("file") MultipartFile file) {
        String result = "";
        if (!file.isEmpty()) {
            String originalFileName = file.getOriginalFilename();

            // 这里写你的文件上传逻辑
            // String imgPath = fileUtil.uploadImg(file);

            String imgPath = null;
            try {


    @RequestMapping(value = "/admin/feedback/reply/submit", method = RequestMethod.POST)
    @ResponseBody
    public JsonResult replySubmit(Feedback feedback) {
        feedbackService.update(feedback);
        return JsonResult.success("保存成功！");
    }

    /*
     * 删除反馈
     * */
    @RequestMapping("/admin/feedback/delete")
    @ResponseBody
    public JsonResult deleteFeedback(@RequestParam("id") Long id) {
        try {
            Feedback feedback = feedbackService.get(id);
            if (feedback == null) {
                return JsonResult.error("删除失败，未找到反馈ID。");
            }
            if (!loginUserIsAdmin() && !Objects.equals(feedback.getUserId(), getLoginUserId())) {
                return JsonResult.error("无权限操作！");
            }
            feedbackService.delete(id);
        } catch (Exception e) {
            return JsonResult.error("删除反馈信息失败，请重试。");
        }

        return JsonResult.success("删除成功！");
    }

}

        return new Color(r, g, b);
    }

    /**
     * 生成随机图片
     */
    public void getRandcode(HttpServletRequest request, HttpServletResponse response) {
        HttpSession session = request.getSession();
        // BufferedImage类是具有缓冲区的Image类,Image类是用于描述图像信息的类
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_BGR);
        Graphics g = image.getGraphics();// 产生Image对象的Graphics对象,改对象可以在图像上进行各种绘制操作
        g.fillRect(0, 0, width, height);//图片大小
        g.setFont(new Font("Times New Roman", Font.ROMAN_BASELINE, 18));//字体大小
        g.setColor(getRandColor(110, 133));//字体颜色
        // 绘制干扰线
        for (int i = 0; i <= lineSize; i++) {
            drowLine(g);
        }
        // 绘制随机字符
        String randomString = "";
        for (int i = 1; i <= stringNum; i++) {
            randomString = drowString(g, randomString, i);
        }
        //将生成的随机字符串保存到session中
        session.removeAttribute(RANDOMCODEKEY);
        session.setAttribute(RANDOMCODEKEY, randomString);
        g.dispose();
        try {
            // 将内存中的图片通过流动形式输出到客户端
            ImageIO.write(image, "JPEG", response.getOutputStream());
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 绘制字符串
     */
    private String drowString(Graphics g, String randomString, int i) {
        g.setFont(getFont());


/*
 * 用户反馈前端控制器
 * */
@Controller("frontFeedbackController")
public class FeedbackController extends BaseController {
    @Autowired
    private FeedbackService feedbackService;

    @RequestMapping("/feedback")
    public String feedbackSubmit() {
        return "front/feedback";
    }

    /*
     * 反馈信息提交
     * */

    @RequestMapping(value = "/feedback/submit", method = RequestMethod.POST)
    @ResponseBody
    public JsonResult submit(@RequestParam("contactName") String contactName,
                             @RequestParam("contactEmail") String contactEmail,
                             @RequestParam("title") String title,
                             @RequestParam("content") String content) {
        //判断用户是否已登录
        User loginUser = getLoginUser();
        if (loginUser == null) {
            return JsonResult.error("请先登录");
        }
        if (contactName.equals("") || contactEmail.equals("") || title.equals("") || content.equals("")) {
            return JsonResult.error("请完善内容后再提交");
        }
        Feedback feedback = new Feedback();
        feedback.setContactEmail(contactEmail);
        feedback.setContactName(contactName);
        feedback.setStatus(FeedbackStatusEnum.NOT_HANDLE.getValue());
        feedback.setTitle(title);
        feedback.setUserId(getLoginUserId());
        feedback.setContent(content);
        feedback.setCreateTime(new Date());
        feedbackService.insert(feedback);
        return JsonResult.success("反馈提交成功，请耐心等待处理");
    }
}


/*
 * 前端订单控制器
 * */
@Controller("frontOrderController")
public class OrderController extends BaseController {
    @Autowired
    private OrderService orderService;

    @Autowired
    private HouseService houseService;

    @Autowired
    private UserService userService;

    /*
     * 创建订单
     * */
    @RequestMapping("/order/create")
    @ResponseBody
    public JsonResult createOrder(@RequestParam("houseId") Long houseId, @RequestParam("endDate") String endDateStr) {
        if (getLoginUser() == null) {
            return JsonResult.error("用户未登录");
        }

        House house = houseService.get(houseId);
        if (house == null) {
            return JsonResult.error("房屋信息不存在");
        }

        if (Objects.equals(house.getStatus(), HouseStatusEnum.HAS_RENT.getValue())) {
            return JsonResult.error("房屋已被租出或未释放");
        }

请添加图片描述