基于javaweb+mysql的springboot房屋租赁管理系统(java+springboot+vue+maven+mysql)

基于javaweb+mysql的springboot房屋租赁管理系统(java+springboot+vue+maven+mysql)

私信源码获取及调试交流

运行环境

Java≥8、MySQL≥5.7、Node.js≥10

开发工具

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

前端：WebStorm/VSCode/HBuilderX等均可

适用

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

功能说明

基于javaweb+mysql的SpringBoot房屋租赁管理系统(java+springboot+vue+maven+mysql)

用户类型：管理员、房主、用户

一、项目运行 环境配置：

Jdk1.8 + Mysql + HBuilderX（Webstorm也行）+ Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）。

项目技术：

Spring + SpringBoot+ mybatis + Maven + Vue 等等组成，B/S模式 + Maven管理等等。

        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

        // 获取当前用户最新的匹配规则 和 当前规则匹配成功的房源
        MateRuleAndRecordVo marVo = mateRuleService.getRuleAndHouseImfor(uId);

        if (marVo == null) {
            return Result.success("noMateRule");
        }
        return Result.success(marVo);
    }

    @PostMapping("/addMateRule")
    @ApiOperation("新建规则征集房源")
    public Result<?> addMateRule(@RequestBody MateRuleVo mateRuleVo) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

        if (mateRuleVo.getProvinceValue() != null) {
            // 将前端选择的户型多选 合并为一个字符串使用#进行间隔
            mateRuleVo.transitionToStringHouseType();

            // 新增匹配规则
            int addResult = mateRuleService.addMateRule(mateRuleVo, uId);
            // 启动匹配
            int startResult = mateRuleService.startMateRule(mateRuleVo.getMrId(), uId);
            if (addResult != 1) {
                return Result.error("-1", "创建失败");
            } else if (startResult != 1) {
                return Result.error("-1", "启动失败");
            }

            return Result.success("");
        }

        return Result.error("-1", "必须输入规则");
    }

    @PostMapping("/updateMateRule")
    @ApiOperation("修改规则征集房源")
    public Result<?> updateMateRule(@RequestBody MateRuleVo mateRuleVo) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

@RestController
@RequestMapping("/admin")
@Api(tags = "管理员对系统管理的相关操作")
public class AdminOperationController {
    @Autowired
    MateRuleAction mateRuleAction;
    @Autowired
    AdminService adminService;
    @Autowired
    UserService userService;
    @Autowired
    HouseService houseService;

    @GetMapping("/getMerchantApply")
    @ApiOperation("获取商家申请未处理的记录")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getMerchantApply(@RequestParam(defaultValue = "1") Integer pageNum,
                                      @RequestParam(defaultValue = "10") Integer pageSize,
                                      HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        Page<LeaserApply> page = adminService.getMerchantApply(new Page<LeaserApply>(pageNum, pageSize), uId);

        return Result.success(page);
    }

    @PostMapping("/updateLeaserApply")
    @ApiOperation("更新房主申请的记录状态")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "leaserApplyId", value = "申请记录的id"),
            @ApiImplicitParam(name = "operation", value = "操作(success、fail)"),})
    public Result<?> updateLeaserApply(@RequestParam("leaserApplyId") Long leaserApplyId,
                                      @RequestParam("operation") String operation,
                                      HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        Long lapUId = adminService.updateLeaserApplyState(leaserApplyId, operation);

        // 如果更新成功&&并且通过审核，进入更改用户的角色
        if (lapUId != null && operation.equals("success")){
            // 更新用户的角色
            int updateUS = userService.updateUserRole(lapUId);
            if (updateUS == 1){
                return Result.success();
            }
            return Result.error("-1", "角色修改失败");
        }
        else if (lapUId != null && operation.equals("fail")){
            return Result.success();
        }

                                      @RequestParam("comeFromUId") Long comeFromUId,
                                      @RequestParam("punishType") String punishType) {
        // 更新投诉记录的状态
        int update = adminService.complaintSuccess(type, id);
        if (update == 1) {
            return Result.success();
        }
        return Result.error("-1", "操作失败");
    }

    @GetMapping("/manualStartMatchHouse")
    @ApiOperation("人工启动匹配房源程序接口")
    public Result<?> manualStartMatchHouse() {
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        System.out.println("执行一次"+ sdf.format(new Date()));

        // 判断当前是否在运行，如果不是就启动
        boolean runState = MateRuleAction.runState;
        if (!runState) {
            mateRuleAction.initData();
            try {
                mateRuleAction.start();
            } catch (InterruptedException e) {
                e.printStackTrace();
                return Result.error("-1", "启动失败，程序出错");
            }
            return Result.success();
        }
        return Result.error("-1", "当前已正在运行，无序手动start");
    }
}

            return Result.error("-1", "账户已锁定");
        } catch (ExcessiveAttemptsException eae) {
            return Result.error("-1", "用户名或密码错误次数过多");
        } catch (AuthenticationException ae) {
            return Result.error("-1", "用户名或密码不正确");
        }
        if (subject.isAuthenticated()) {
            // 将用户名和角色返回给前端
            User user = userService.getAccountByName(username);
            UserNameAndRoleVo result = new UserNameAndRoleVo();
            result.setRole(user.getuRole());
            result.setUsername(user.getuNickname());

            return Result.success(result);
        } else {
            token.clear();
            return Result.error("-1", "登录失败");
        }
    }

    /**
     * 注册接口
     * */
    @PostMapping("/register")
    @ApiOperation("注册接口")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "username", value = "账号"),
            @ApiImplicitParam(name = "password", value = "密码")})
    public Result<?> register(@RequestParam("username") String username, @RequestParam("password") String password) {

        // 查询用户名是否被占用
        User user = userService.getAccountByName(username);
        if (user == null) {
            // 注册账号
            // 使用MD5+Salt（盐--用户名）+2次散列
            String newPassword = new SimpleHash("MD5", password, username, 2).toHex();
            newPassword=password;
            int state = userService.addAccount(username, newPassword);
            if (state == 1) {
                return Result.success();
            }
            else {
                return Result.error("-1", "注册失败，未知错误");
            }
        }

    @PostMapping("/updateUserState")
    @ApiOperation("更新用户状态")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "uId", value = "用户id"),
            @ApiImplicitParam(name = "operation", value = "操作(banSay、frozen、close、removeBanSay、removeFrozen)")})
    public Result<?> updateUserState(@RequestParam("uId") Long uId,
                                     @RequestParam("operation") String operation){
        int num = userService.updateUserState(uId, operation);
        if (num == 1){
            return Result.success();
        }
        return Result.error("-1", "操作失败");
    }
    /* ================end================ */

    @GetMapping("/getComplaintUser")
    @ApiOperation("获取未处理的投诉用户信息")
    @ApiImplicitParams({@ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
                        @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getComplaintUser(@RequestParam(defaultValue = "1") Integer pageNum,
                                      @RequestParam(defaultValue = "10") Integer pageSize){
        Page<ComplaintUser> result =
                adminService.getUntreatedComplaintUser(new Page<ComplaintUser>(pageNum, pageSize));
        return Result.success(result);
    }

    @GetMapping("/getComplaintHouse")
    @ApiOperation("获取未处理的投诉房源信息")
    @ApiImplicitParams({@ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
                        @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getComplaintHouse(@RequestParam(defaultValue = "1") Integer pageNum,
                                      @RequestParam(defaultValue = "10") Integer pageSize){
        Page<ComplaintHouse> result =
                adminService.getUntreatedComplaintHouse(new Page<ComplaintHouse>(pageNum, pageSize));
        return Result.success(result);
    }

    @PostMapping("/notPassComplaint")
    @ApiOperation("投诉信息--审核不通过（投诉房源、用户）")
    @ApiImplicitParams({@ApiImplicitParam(name = "comeFromUId", value = "该投诉的发起者用户id"),
                        @ApiImplicitParam(name = "type", value = "类型（house、user）"),
                        @ApiImplicitParam(name = "id", value = "投诉记录的id"),
                        @ApiImplicitParam(name = "noPassReason", value = "不通过的理由"),})
    public Result<?> getComplaintUser(@RequestParam("type") String type,
                                      @RequestParam("id") Long id,
                                      @RequestParam("comeFromUId") Long comeFromUId,
                                      @RequestParam(name = "noPassReason") String noPassReason){
        int update = adminService.updateComplaintState(type, id);
        if (update == 1){

@RestController
@RequestMapping("/user")
@Api(tags = "用户对房源的相关操作")
public class UserOperationHouseController {
    @Autowired
    HouseService houseService;
    @Autowired
    MateRuleService mateRuleService;
    @Autowired
    RentHouseService rentHouseService;
    @Autowired
    PayAndBillService payAndBillService;

    @GetMapping("/collectHouse")
    @ApiOperation("收藏/取消收藏房源")
    @ApiImplicitParam(name = "hId", value = "房源id")
    public Result<?> collectHouse(Long hId, HttpServletRequest request) {
        // 获得当前操作的用户id
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

        String state = houseService.collectHouse(hId, uId);
        if (state.equals("fail")) {
            return Result.error("-1", "收藏失败");
        }
        return Result.success(state);
    }

    @GetMapping("/appointHouse")
    @ApiOperation("预约看房")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "hId", value = "房源id"),
            @ApiImplicitParam(name = "dateTime", value = "预约的时间"),})
    public Result<?> appointHouse(@RequestParam("hId") Long hId,
                                  @RequestParam("dateTime") String dateTime,
                                  HttpServletRequest request) {
        System.out.println(dateTime + "预约时间");
        // 从token中获取出用户id
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

            String regEx = "[^0-9]";
            Pattern pattern = Pattern.compile(regEx);
            Matcher matcher;
            // 将价格的非数字字符去除
            matcher = pattern.matcher(search);
            price = matcher.replaceAll("").trim();
        }
        else if (type.equals("address")){
            address = search;
        }
        else if (type.equals("roomNum")){
            roomNum = search;
        }

        Page<HistoryBill> resultPage = payAndBillService.getHistoryBillByUId("user", new Page<HistoryBill>(pageNum, pageSize), uId, price, address, roomNum);
        return Result.success(resultPage);
    }

    @GetMapping("/getUnpaidBill")
    @ApiOperation("获取当前账号未支付的账单")
    public Result<?> getUnpaidBill(HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        // 根据用户id获取未支付的账单和对应的合同信息
        List<HistoryBill> historyBillList =  payAndBillService.getUnPaidBillByUId(uId);

        return Result.success(historyBillList);
    }

    @PostMapping("/payMoney")
    @ApiOperation("支付租金")
    @ApiImplicitParam(name = "hbId", value = "账单id")
    public Result<?> getCurrentRentHouse(@RequestParam("hbId") Long hbId,
                                         HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

        // 根据账单id更新账单支付状态
        int result = payAndBillService.updateBillState(hbId);
        if (result == 1) {
            return Result.success();
        }

        return Result.error("-1", "支付失败");
    }
}

    @GetMapping("/getComplaintUser")
    @ApiOperation("获取未处理的投诉用户信息")
    @ApiImplicitParams({@ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
                        @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getComplaintUser(@RequestParam(defaultValue = "1") Integer pageNum,
                                      @RequestParam(defaultValue = "10") Integer pageSize){
        Page<ComplaintUser> result =
                adminService.getUntreatedComplaintUser(new Page<ComplaintUser>(pageNum, pageSize));
        return Result.success(result);
    }

    @GetMapping("/getComplaintHouse")
    @ApiOperation("获取未处理的投诉房源信息")
    @ApiImplicitParams({@ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
                        @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getComplaintHouse(@RequestParam(defaultValue = "1") Integer pageNum,
                                      @RequestParam(defaultValue = "10") Integer pageSize){
        Page<ComplaintHouse> result =
                adminService.getUntreatedComplaintHouse(new Page<ComplaintHouse>(pageNum, pageSize));
        return Result.success(result);
    }

    @PostMapping("/notPassComplaint")
    @ApiOperation("投诉信息--审核不通过（投诉房源、用户）")
    @ApiImplicitParams({@ApiImplicitParam(name = "comeFromUId", value = "该投诉的发起者用户id"),
                        @ApiImplicitParam(name = "type", value = "类型（house、user）"),
                        @ApiImplicitParam(name = "id", value = "投诉记录的id"),
                        @ApiImplicitParam(name = "noPassReason", value = "不通过的理由"),})
    public Result<?> getComplaintUser(@RequestParam("type") String type,
                                      @RequestParam("id") Long id,
                                      @RequestParam("comeFromUId") Long comeFromUId,
                                      @RequestParam(name = "noPassReason") String noPassReason){
        int update = adminService.updateComplaintState(type, id);
        if (update == 1){
            return Result.success();
        }
        return Result.error("-1", "操作失败");
    }

    @PostMapping("/passComplaint")
    @ApiOperation("投诉信息--审核通过（投诉房源、用户）")

@RestController
@RequestMapping("/user")
@Api(tags = "用户对房源的相关操作")
public class UserOperationHouseController {
    @Autowired
    HouseService houseService;
    @Autowired
    MateRuleService mateRuleService;
    @Autowired
    RentHouseService rentHouseService;
    @Autowired
    PayAndBillService payAndBillService;

    @GetMapping("/collectHouse")
    @ApiOperation("收藏/取消收藏房源")
    @ApiImplicitParam(name = "hId", value = "房源id")
    public Result<?> collectHouse(Long hId, HttpServletRequest request) {
        // 获得当前操作的用户id

@RequestMapping("/merchant")
@Api(tags = "商家对房源的相关操作")
public class MerchantOperationHouseController {
    @Autowired
    HouseService houseService;
    @Autowired
    PayAndBillService payAndBillService;

    @PostMapping("/addHouse")
    @ApiOperation("新增房源")
    public Result<?> addHouse(HouseCreateVo houseCreateVo,
                              HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String dateNowStr = sdf.format(new Date());

        houseCreateVo.transitionFloorStrToNum();
        houseCreateVo.sethUidForeign(uId);
        houseCreateVo.sethCheckinTime(dateNowStr);
        String result = houseService.addHouse(houseCreateVo, uId);
        if (result.equals("保存失败")){
            return Result.error("-1", result);
        }

        return Result.success(result);
    }

    /*
    * ============== 修改房源信息 start =======================
    * */
    @PostMapping("/removeOneHouseImage")
    @ApiOperation("移除一张房源的图片")
    @ApiImplicitParam(name = "imageId", value = "需要删除的这张房源图片id")
    public Result<?> removeOneHouseImage(@RequestParam("imageId") Long imageId){
        String result = houseService.removeOneHouseImage(imageId);
        if (result.equals("删除成功")){
            return Result.success();
        }

        return Result.error("-1", result);
    }

    @PostMapping("/updateHouse")
    @ApiOperation( tags = "更新房源", value = "更新房源+新增的图片+配套设备")
    public Result<?> updateHouse(HouseCreateVo houseCreateVo,
                              HttpServletRequest request){

    }

    @PostMapping("/confirmAppoint")
    //方法参数说明，name参数名；value参数说明，备注；dataType参数类型；required 是否必传；defaultValue 默认值
    @ApiOperation("确认预约")
    @ApiImplicitParam(name = "apId", value = "预约记录的id")
    public Result<?> confirmAppoint(@RequestParam("apId") Long apId, HttpServletRequest request) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        boolean state = houseService.confirmAppoint(apId, uId);
        if (state){
            return Result.success();
        }

        return Result.error("-1", "确认失败");
    }

    @PostMapping("/cancelAppoint")
    @ApiOperation("取消预约")
    @ApiImplicitParam(name = "apId", value = "预约记录的id")
    public Result<?> cancelAppoint(Long apId, HttpServletRequest request) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        // 取消预约记录
        int result = houseService.cancelAppoint(apId, uId, "merchant");
        // 删除预设未签订的合约
        int result2 = houseService.deleteContract(apId);
        if (result < 1) {
            return Result.error("-1", "取消失败");
        }
        if (result2 < 1) {
            System.out.println("预设的合同删除失败（取消预约联动删除预设合同）");
        }

        return Result.success("取消成功");
    }

    @GetMapping("/getUnconfirmedContract")
    @ApiOperation("获取未确认的租房合同")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getUnconfirmedContract(@RequestParam(defaultValue = "1") Integer pageNum,
                                      @RequestParam(defaultValue = "10") Integer pageSize,
                                      HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        Page<RentHouseContract> page = houseService.getUnconfirmedContract(new Page<RentHouseContract>(pageNum, pageSize), uId);

        return Result.success(page);

                                            HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        Page<RentHouseContract> page = houseService.getConfirmRentHouseContact(new Page<RentHouseContract>(pageNum, pageSize), uId);
        // 查询该合同当月的账单状态
        payAndBillService.setCurrentBillState(page.getRecords());

        return Result.success(page);
    }

    @PostMapping("/inputBill")
    @ApiOperation("录入账单")
    public Result<?> inputBill(InputBillVo inputBillVo, HttpServletRequest request) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        int insert = payAndBillService.inputBill(inputBillVo, uId);
        if (insert == 1){
            return Result.success();
        }

        return Result.error("-1", "录入失败");
    }

    @PostMapping("/terminateContract")
    @ApiOperation("终止合同")
    @ApiImplicitParam(name = "rhcId", value = "合同的id")
    public Result<?> terminateContract(@RequestParam("rhcId") Long rhcId, HttpServletRequest request) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        int insert = houseService.terminateContract(rhcId, uId);
        if (insert == 1){
            return Result.success();
        }

        return Result.error("-1", "终止失败");
    }

    @GetMapping("/getHistoryBill")
    @ApiOperation("获取我的历史账单(商家)")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "search", value = "搜索的关键字"),
            @ApiImplicitParam(name = "type", value = "根据哪种类型搜索（价格，房间号，地址）"),
            @ApiImplicitParam(name = "pageNum", value = "当前页数"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getHistoryBill(@RequestParam(value = "search", defaultValue = "") String search,
                                    @RequestParam(value = "type", defaultValue = "") String type,

    @PostMapping("/updateMateRule")
    @ApiOperation("修改规则征集房源")
    public Result<?> updateMateRule(@RequestBody MateRuleVo mateRuleVo) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

        if (mateRuleVo.getMrId() != null) {
            // 将前端选择的户型多选 合并为一个字符串使用#进行间隔
            mateRuleVo.transitionToStringHouseType();
            // 修改匹配规则
            int updateResult = mateRuleService.updateMateRule(mateRuleVo, uId);

            if (updateResult == 1) {
                return Result.success("");
            } else {
                return Result.error("-1", "更新失败");
            }
        }

        return Result.error("-1", "必须输入规则");
    }

    @GetMapping("/deleteMateRule")
    @ApiOperation("终止规则征集房源")
    public Result<?> deleteMateRule(@RequestParam("mrId") Long mrId,
                                    HttpServletRequest request) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

        if (mrId != null) {
            // 删除匹配规则
            int deleteResult = mateRuleService.deleteMateRule(mrId, uId);

            if (deleteResult == 1) {
                return Result.success("");
            } else {
                return Result.error("-1", "删除失败--当前规则不属于该用户");
            }
        }

        return Result.error("-1", "删除失败--没有传入id");
    }

    @GetMapping("/getCurrentRentHouse")
    @ApiOperation("获取当前当前用户租的房源")
    public Result<?> getCurrentRentHouse(HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        // 获取当前用户正在租的房源
        List<RentHouseContract> rentHouseContractList = rentHouseService.getCurrentRentHouse(uId);

        return Result.success(rentHouseContractList);
    }

            return Result.success();
        }

        return Result.error("-1", "确认失败");
    }

    @GetMapping("/getConfirmRentHouseContact")
    @ApiOperation("获取已租的合同信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getConfirmRentHouseContact(@RequestParam(defaultValue = "1") Integer pageNum,
                                            @RequestParam(defaultValue = "10") Integer pageSize,
                                            HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        Page<RentHouseContract> page = houseService.getConfirmRentHouseContact(new Page<RentHouseContract>(pageNum, pageSize), uId);
        // 查询该合同当月的账单状态
        payAndBillService.setCurrentBillState(page.getRecords());

        return Result.success(page);
    }

    @PostMapping("/inputBill")
    @ApiOperation("录入账单")
    public Result<?> inputBill(InputBillVo inputBillVo, HttpServletRequest request) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        int insert = payAndBillService.inputBill(inputBillVo, uId);
        if (insert == 1){
            return Result.success();
        }

        return Result.error("-1", "录入失败");
    }

    @PostMapping("/terminateContract")
    @ApiOperation("终止合同")
    @ApiImplicitParam(name = "rhcId", value = "合同的id")
    public Result<?> terminateContract(@RequestParam("rhcId") Long rhcId, HttpServletRequest request) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        int insert = houseService.terminateContract(rhcId, uId);
        if (insert == 1){

    @Autowired
    UserService userService;
    @Autowired
    ComplaintService complaintService;

    @PostMapping("/merchantApply")
    @ApiOperation("商家申请 --上传多个材料、图片")
    public Result<?> merchantApply(@RequestParam("files") MultipartFile[] files){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        // 保存图片+添加记录到申请表
        boolean state = userService.merchantApply(files, uId);
        if (state){
            return Result.success();
        }
        return Result.error("-1", "上传失败");
    }

    @PostMapping("/complaint")
    @ApiOperation("投诉房源或用户")
    @ApiImplicitParam(name = "complaintVo", value = "投诉信息的封装")
    public Result<?> complaint(ComplaintVo complaintVo,
                               HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        boolean state = false;

        if (complaintVo.getType().equals("house"))
            // 投诉房源
            state = complaintService.complaintHouse(complaintVo, uId);
        else
            // 投诉用户
            state = complaintService.complaintUser(complaintVo, uId);

        if (state)
            return Result.success();

        return Result.error("-1", "未知错误");
    }
}

/*
* 自定义Shiro的登录过滤器
* 问题1：前后端分离，跨域访问
* 解决：未如果未登录，shiro默认重定向出错
*       改为返回JSON，在shiro配置类的过滤工厂中添加配置
* 问题2：重写了登录过滤器，如果使用rememberMe就要在isAccessAllowed中把记住登录的这种也考虑为登录（user级别的）
* */
public class ShiroLoginFilter extends FormAuthenticationFilter {

    /**
     * 这个方法决定了是否能让用户登录
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        Subject subject = getSubject(request, response);

        //如果 isAuthenticated 为 false 证明不是登录过的，同时 isRememberd 为true 证明是没登陆直接通过记住我功能进来的
        if(!subject.isAuthenticated() && subject.isRemembered()){

            //获取session看看是不是空的
            Session session = subject.getSession(true);

            //随便拿session的一个属性来看session当前是否是空的，我用userId，你们的项目可以自行发挥
            /*if(session.getAttribute("userId") == null){

@RestController
@RequestMapping("/screening")
//说明接口文件
@Api(tags = "筛选房源", value = "用于系统主页index页面的筛选房源")
public class ScreeningController {
    @Autowired
    HouseService houseService;

    /*
    * 获取主页的初始化房源简要信息
    * */
    @PostMapping("/getBasicHouseImfor")
    //方法参数说明，name参数名；value参数说明，备注；dataType参数类型；required 是否必传；defaultValue 默认值
    @ApiOperation("获取房源简要信息")
    @ApiImplicitParams({@ApiImplicitParam(name = "houseBasicVo", value = "筛选房源的条件"),})
    public Result<?> getBasicHouseImfor(@RequestBody HouseBasicVo houseBasicVo){
        // 将选定的价格区间分割（按~符号）, 转为对象PriceScope存储
        if (houseBasicVo != null){
            houseBasicVo.transitionPriceScopeObjectList();
        }else {
            houseBasicVo = new HouseBasicVo();
        }

        Page<HouseBasicResultVo> page = houseService.getHouseList(new Page<>(houseBasicVo.getPageNum(), houseBasicVo.getPageSize()), houseBasicVo.getSearch(), houseBasicVo);
        return Result.success(page);
    }

    /*
     * 获取房源详细信息(查看房源详细信息)
     * */
    @GetMapping("/getHouseImfor")
    //方法参数说明，name参数名；value参数说明，备注；dataType参数类型；required 是否必传；defaultValue 默认值
    @ApiOperation("获取房源详细信息")
    @ApiImplicitParam(name = "hId", value = "房源id")
    public Result<?> getHouseImfor(Long hId){
        // 获取房源详细信息
        House house = houseService.getHouseDetailByHId(hId);

        return Result.success(house);
    }
}

public class ScreeningController {
    @Autowired
    HouseService houseService;

    /*
    * 获取主页的初始化房源简要信息
    * */
    @PostMapping("/getBasicHouseImfor")
    //方法参数说明，name参数名；value参数说明，备注；dataType参数类型；required 是否必传；defaultValue 默认值
    @ApiOperation("获取房源简要信息")
    @ApiImplicitParams({@ApiImplicitParam(name = "houseBasicVo", value = "筛选房源的条件"),})
    public Result<?> getBasicHouseImfor(@RequestBody HouseBasicVo houseBasicVo){
        // 将选定的价格区间分割（按~符号）, 转为对象PriceScope存储
        if (houseBasicVo != null){
            houseBasicVo.transitionPriceScopeObjectList();
        }else {
            houseBasicVo = new HouseBasicVo();
        }

        Page<HouseBasicResultVo> page = houseService.getHouseList(new Page<>(houseBasicVo.getPageNum(), houseBasicVo.getPageSize()), houseBasicVo.getSearch(), houseBasicVo);
        return Result.success(page);
    }

    /*
     * 获取房源详细信息(查看房源详细信息)
     * */
    @GetMapping("/getHouseImfor")
    //方法参数说明，name参数名；value参数说明，备注；dataType参数类型；required 是否必传；defaultValue 默认值
    @ApiOperation("获取房源详细信息")
    @ApiImplicitParam(name = "hId", value = "房源id")
    public Result<?> getHouseImfor(Long hId){
        // 获取房源详细信息
        House house = houseService.getHouseDetailByHId(hId);

        return Result.success(house);
    }
}