【计算机毕业设计】房屋租赁系统

已于 2023-07-17 09:13:58 修改
阅读量514 收藏 8
点赞数 1
分类专栏： 计算机毕业设计实战案例 文章标签： java log4j 数据库 后端 课程设计
于 2023-06-14 09:53:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51029849/article/details/131201465
版权

Java SSM房屋租赁系统
开发语言：Java
框架：ssm
技术：JSP
JDK版本：JDK1.8
服务器：tomcat7
数据库：mysql 5.7（一定要5.7版本）
数据库工具：Navicat11
开发软件：eclipse/myeclipse/idea
Maven包：Maven3.3.9
浏览器：谷歌浏览器
Java SSM房屋租赁系统，基于SSM框架进行开发，前端页面效果通过使用JSP进行编码实现，实现了租客跟管理员这两类用户角色，实现了房屋信息管理、系统管理等功能。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

validationQuery=SELECT 1

jdbc_url=jdbc:mysql://127.0.0.1:3306/jspmv7u4f?useUnicode=true&characterEncoding=UTF-8&tinyInt1isBit=false
jdbc_username=root
jdbc_password=root

#jdbc_url=jdbc:sqlserver://127.0.0.1:1433;DatabaseName=jspmv7u4f
#jdbc_username=sa
#jdbc_password=123456



log4j.rootLogger=DEBUG,CONSOLE,A
log4j.addivity.org.apache=false
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.Threshold=DEBUG
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd HH\:mm\:ss} -%-4r [%t] %-5p  %x - %m%n
log4j.appender.CONSOLE.Target=System.out
#log4j.appender.CONSOLE.charset=utf-8
log4j.appender.CONSOLE.encoding=utf-8
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.A=org.apache.log4j.DailyRollingFileAppender
log4j.appender.A.File=${catalina.home}/logs/yo_log/PurePro_
log4j.appender.A.DatePattern=yyyy-MM-dd'.log'
log4j.appender.A.layout=org.apache.log4j.PatternLayout
log4j.appender.A.layout.ConversionPattern=[FH_sys]  %d{yyyy-MM-dd HH\:mm\:ss} %5p %c{1}\:%L \: %m%n
log4j.logger.java.sql.ResultSet=INFO
log4j.logger.org.apache=DEBUG
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.dao.DiscussfangwuxinxiDao">

	<!-- 可根据自己的需求，是否要使用 -->
    <resultMap type="com.entity.DiscussfangwuxinxiEntity" id="discussfangwuxinxiMap">
        <result property="refid" column="refid"/>
        <result property="userid" column="userid"/>
        <result property="nickname" column="nickname"/>
        <result property="content" column="content"/>
        <result property="reply" column="reply"/>
    </resultMap>

	<select id="selectListVO"
		resultType="com.entity.vo.DiscussfangwuxinxiVO" >
		SELECT * FROM discussfangwuxinxi  discussfangwuxinxi         
        <where> 1=1 ${ew.sqlSegment}</where>
	</select>
	
	<select id="selectVO"
		resultType="com.entity.vo.DiscussfangwuxinxiVO" >
		SELECT  discussfangwuxinxi.* FROM discussfangwuxinxi  discussfangwuxinxi 	
 		<where> 1=1 ${ew.sqlSegment}</where>
	</select>

    <select id="selectListView"
		resultType="com.entity.view.DiscussfangwuxinxiView" >

		SELECT  discussfangwuxinxi.* FROM discussfangwuxinxi  discussfangwuxinxi 	        
        <where> 1=1 ${ew.sqlSegment}</where>
	</select>
	
	<select id="selectView"
		resultType="com.entity.view.DiscussfangwuxinxiView" >
		SELECT * FROM discussfangwuxinxi  discussfangwuxinxi <where> 1=1 ${ew.sqlSegment}</where>
	</select>
	

</mapper>



package com.controller;


import java.util.Arrays;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.ConfigEntity;
import com.service.ConfigService;
import com.utils.MPUtil;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.ValidatorUtils;

/**
 * 登录相关
 */
@RequestMapping("config")
@RestController
public class ConfigController{
	
	@Autowired
	private ConfigService configService;

	/**
     * 列表
     */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params,ConfigEntity config){
        EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>();
    	PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params));
        return R.ok().put("data", page);
    }
    
	/**
     * 列表
     */
    @IgnoreAuth
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params,ConfigEntity config){
        EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>();
    	PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params));
        return R.ok().put("data", page);
    }

    /**
     * 信息
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") String id){
        ConfigEntity config = configService.selectById(id);
        return R.ok().put("data", config);
    }
    
    /**
     * 详情
     */
    @IgnoreAuth
    @RequestMapping("/detail/{id}")
    public R detail(@PathVariable("id") String id){
        ConfigEntity config = configService.selectById(id);
        return R.ok().put("data", config);
    }
    
    /**
     * 根据name获取信息
     */
    @RequestMapping("/info")
    public R infoByName(@RequestParam String name){
        ConfigEntity config = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile"));
        return R.ok().put("data", config);
    }
    
    /**
     * 保存
     */
    @PostMapping("/save")
    public R save(@RequestBody ConfigEntity config){
//    	ValidatorUtils.validateEntity(config);
    	configService.insert(config);
        return R.ok();
    }

    /**
     * 修改
     */
    @RequestMapping("/update")
    public R update(@RequestBody ConfigEntity config){
//        ValidatorUtils.validateEntity(config);
        configService.updateById(config);//全部更新
        return R.ok();
    }

    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids){
    	configService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }
}



package com.controller;


import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
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.bind.annotation.RestController;

import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.TokenEntity;
import com.entity.UserEntity;
import com.service.TokenService;
import com.service.UserService;
import com.utils.CommonUtil;
import com.utils.MPUtil;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.ValidatorUtils;

/**
 * 登录相关
 */
@RequestMapping("users")
@RestController
public class UserController{
	
	@Autowired
	private UserService userService;
	
	@Autowired
	private TokenService tokenService;

	/**
	 * 登录
	 */
	@IgnoreAuth
	@PostMapping(value = "/login")
	public R login(String username, String password, String captcha, HttpServletRequest request) {
		UserEntity user = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", username));
		if(user==null || !user.getPassword().equals(password)) {
			return R.error("账号或密码不正确");
		}
		String token = tokenService.generateToken(user.getId(),username, "users", user.getRole());
		return R.ok().put("token", token);
	}
	
	/**
	 * 注册
	 */
	@IgnoreAuth
	@PostMapping(value = "/register")
	public R register(@RequestBody UserEntity user){
//    	ValidatorUtils.validateEntity(user);
    	if(userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername())) !=null) {
    		return R.error("用户已存在");
    	}
        userService.insert(user);
        return R.ok();
    }

	/**
	 * 退出
	 */
	@GetMapping(value = "logout")
	public R logout(HttpServletRequest request) {
		request.getSession().invalidate();
		return R.ok("退出成功");
	}
	
	/**
     * 密码重置
     */
    @IgnoreAuth
	@RequestMapping(value = "/resetPass")
    public R resetPass(String username, HttpServletRequest request){
    	UserEntity user = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", username));
    	if(user==null) {
    		return R.error("账号不存在");
    	}
    	user.setPassword("123456");
        userService.update(user,null);
        return R.ok("密码已重置为：123456");
    }
	
	/**
     * 列表
     */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params,UserEntity user){
        EntityWrapper<UserEntity> ew = new EntityWrapper<UserEntity>();
    	PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
        return R.ok().put("data", page);
    }

	/**
     * 列表
     */
    @RequestMapping("/list")
    public R list( UserEntity user){
       	EntityWrapper<UserEntity> ew = new EntityWrapper<UserEntity>();
      	ew.allEq(MPUtil.allEQMapPre( user, "user")); 
        return R.ok().put("data", userService.selectListView(ew));
    }

    /**
     * 信息
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") String id){
        UserEntity user = userService.selectById(id);
        return R.ok().put("data", user);
    }
    
    /**
     * 获取用户的session用户信息
     */
    @RequestMapping("/session")
    public R getCurrUser(HttpServletRequest request){
    	Long id = (Long)request.getSession().getAttribute("userId");
        UserEntity user = userService.selectById(id);
        return R.ok().put("data", user);
    }

    /**
     * 保存
     */
    @PostMapping("/save")
    public R save(@RequestBody UserEntity user){
//    	ValidatorUtils.validateEntity(user);
    	if(userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername())) !=null) {
    		return R.error("用户已存在");
    	}
        userService.insert(user);
        return R.ok();
    }

    /**
     * 修改
     */
    @RequestMapping("/update")
    public R update(@RequestBody UserEntity user){
//        ValidatorUtils.validateEntity(user);
    	UserEntity u = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername()));
    	if(u!=null && u.getId()!=user.getId() && u.getUsername().equals(user.getUsername())) {
    		return R.error("用户名已存在。");
    	}
        userService.updateById(user);//全部更新
        return R.ok();
    }

    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids){
        userService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }
}


package com.controller;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;

import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth;

import com.entity.ZukeEntity;
import com.entity.view.ZukeView;

import com.service.ZukeService;
import com.service.TokenService;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.CommonUtil;
import java.io.IOException;

/**
 * 租客
 * 后端接口
 * @author 
 * @email 
 * @date 2022-03-20 17:20:42
 */
@RestController
@RequestMapping("/zuke")
public class ZukeController {
    @Autowired
    private ZukeService zukeService;



    
	@Autowired
	private TokenService tokenService;
	
	/**
	 * 登录
	 */
	@IgnoreAuth
	@RequestMapping(value = "/login")
	public R login(String username, String password, String captcha, HttpServletRequest request) {
		ZukeEntity user = zukeService.selectOne(new EntityWrapper<ZukeEntity>().eq("zhanghao", username));
		if(user==null || !user.getMima().equals(password)) {
			return R.error("账号或密码不正确");
		}
		String token = tokenService.generateToken(user.getId(), username,"zuke",  "租客" );
		return R.ok().put("token", token);
	}
	
	/**
     * 注册
     */
	@IgnoreAuth
    @RequestMapping("/register")
    public R register(@RequestBody ZukeEntity zuke){
    	//ValidatorUtils.validateEntity(zuke);
    	ZukeEntity user = zukeService.selectOne(new EntityWrapper<ZukeEntity>().eq("zhanghao", zuke.getZhanghao()));
		if(user!=null) {
			return R.error("注册用户已存在");
		}
		Long uId = new Date().getTime();
		zuke.setId(uId);
        zukeService.insert(zuke);
        return R.ok();
    }

	
	/**
	 * 退出
	 */
	@RequestMapping("/logout")
	public R logout(HttpServletRequest request) {
		request.getSession().invalidate();
		return R.ok("退出成功");
	}
	
	/**
     * 获取用户的session用户信息
     */
    @RequestMapping("/session")
    public R getCurrUser(HttpServletRequest request){
    	Long id = (Long)request.getSession().getAttribute("userId");
        ZukeEntity user = zukeService.selectById(id);
        return R.ok().put("data", user);
    }
    
    /**
     * 密码重置
     */
    @IgnoreAuth
	@RequestMapping(value = "/resetPass")
    public R resetPass(String username, HttpServletRequest request){
    	ZukeEntity user = zukeService.selectOne(new EntityWrapper<ZukeEntity>().eq("zhanghao", username));
    	if(user==null) {
    		return R.error("账号不存在");
    	}
        user.setMima("123456");
        zukeService.updateById(user);
        return R.ok("密码已重置为：123456");
    }


    /**
     * 后端列表
     */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params,ZukeEntity zuke, 
		HttpServletRequest request){

        EntityWrapper<ZukeEntity> ew = new EntityWrapper<ZukeEntity>();
    	PageUtils page = zukeService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, zuke), params), params));
		request.setAttribute("data", page);
        return R.ok().put("data", page);
    }
    
    /**
     * 前端列表
     */
	@IgnoreAuth
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params,ZukeEntity zuke, 
		HttpServletRequest request){
        EntityWrapper<ZukeEntity> ew = new EntityWrapper<ZukeEntity>();
    	PageUtils page = zukeService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, zuke), params), params));
		request.setAttribute("data", page);
        return R.ok().put("data", page);
    }

	/**
     * 列表
     */
    @RequestMapping("/lists")
    public R list( ZukeEntity zuke){
       	EntityWrapper<ZukeEntity> ew = new EntityWrapper<ZukeEntity>();
      	ew.allEq(MPUtil.allEQMapPre( zuke, "zuke")); 
        return R.ok().put("data", zukeService.selectListView(ew));
    }

	 /**
     * 查询
     */
    @RequestMapping("/query")
    public R query(ZukeEntity zuke){
        EntityWrapper< ZukeEntity> ew = new EntityWrapper< ZukeEntity>();
 		ew.allEq(MPUtil.allEQMapPre( zuke, "zuke")); 
		ZukeView zukeView =  zukeService.selectView(ew);
		return R.ok("查询租客成功").put("data", zukeView);
    }
	
    /**
     * 后端详情
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id){
        ZukeEntity zuke = zukeService.selectById(id);
        return R.ok().put("data", zuke);
    }

    /**
     * 前端详情
     */
	@IgnoreAuth
    @RequestMapping("/detail/{id}")
    public R detail(@PathVariable("id") Long id){
        ZukeEntity zuke = zukeService.selectById(id);
        return R.ok().put("data", zuke);
    }
    



    /**
     * 后端保存
     */
    @RequestMapping("/save")
    public R save(@RequestBody ZukeEntity zuke, HttpServletRequest request){
    	zuke.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
    	//ValidatorUtils.validateEntity(zuke);
    	ZukeEntity user = zukeService.selectOne(new EntityWrapper<ZukeEntity>().eq("zhanghao", zuke.getZhanghao()));
		if(user!=null) {
			return R.error("用户已存在");
		}

		zuke.setId(new Date().getTime());
        zukeService.insert(zuke);
        return R.ok();
    }
    
    /**
     * 前端保存
     */
    @RequestMapping("/add")
    public R add(@RequestBody ZukeEntity zuke, HttpServletRequest request){
    	zuke.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
    	//ValidatorUtils.validateEntity(zuke);
    	ZukeEntity user = zukeService.selectOne(new EntityWrapper<ZukeEntity>().eq("zhanghao", zuke.getZhanghao()));
		if(user!=null) {
			return R.error("用户已存在");
		}

		zuke.setId(new Date().getTime());
        zukeService.insert(zuke);
        return R.ok();
    }

    /**
     * 修改
     */
    @RequestMapping("/update")
    public R update(@RequestBody ZukeEntity zuke, HttpServletRequest request){
        //ValidatorUtils.validateEntity(zuke);
        zukeService.updateById(zuke);//全部更新
        return R.ok();
    }
    

    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids){
        zukeService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }
    
    /**
     * 提醒接口
     */
	@RequestMapping("/remind/{columnName}/{type}")
	public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, 
						 @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
		map.put("column", columnName);
		map.put("type", type);
		
		if(type.equals("2")) {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Calendar c = Calendar.getInstance();
			Date remindStartDate = null;
			Date remindEndDate = null;
			if(map.get("remindstart")!=null) {
				Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
				c.setTime(new Date()); 
				c.add(Calendar.DAY_OF_MONTH,remindStart);
				remindStartDate = c.getTime();
				map.put("remindstart", sdf.format(remindStartDate));
			}
			if(map.get("remindend")!=null) {
				Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
				c.setTime(new Date());
				c.add(Calendar.DAY_OF_MONTH,remindEnd);
				remindEndDate = c.getTime();
				map.put("remindend", sdf.format(remindEndDate));
			}
		}
		
		Wrapper<ZukeEntity> wrapper = new EntityWrapper<ZukeEntity>();
		if(map.get("remindstart")!=null) {
			wrapper.ge(columnName, map.get("remindstart"));
		}
		if(map.get("remindend")!=null) {
			wrapper.le(columnName, map.get("remindend"));
		}


		int count = zukeService.selectCount(wrapper);
		return R.ok().put("count", count);
	}
	
	





}


package com.controller;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;

import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth;

import com.entity.ChatEntity;
import com.entity.view.ChatView;

import com.service.ChatService;
import com.service.TokenService;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.CommonUtil;
import java.io.IOException;

/**
 * 在线客服
 * 后端接口
 * @author 
 * @email 
 * @date 2022-03-20 17:20:43
 */
@RestController
@RequestMapping("/chat")
public class ChatController {
    @Autowired
    private ChatService chatService;



    


    /**
     * 后端列表
     */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params,ChatEntity chat, 
		HttpServletRequest request){
    	if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
    		chat.setUserid((Long)request.getSession().getAttribute("userId"));
    	}

        EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
    	PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params));
		request.setAttribute("data", page);
        return R.ok().put("data", page);
    }
    
    /**
     * 前端列表
     */
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params,ChatEntity chat, 
		HttpServletRequest request){
    	if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
    		chat.setUserid((Long)request.getSession().getAttribute("userId"));
    	}

        EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
    	PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params));
		request.setAttribute("data", page);
        return R.ok().put("data", page);
    }

	/**
     * 列表
     */
    @RequestMapping("/lists")
    public R list( ChatEntity chat){
       	EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
      	ew.allEq(MPUtil.allEQMapPre( chat, "chat")); 
        return R.ok().put("data", chatService.selectListView(ew));
    }

	 /**
     * 查询
     */
    @RequestMapping("/query")
    public R query(ChatEntity chat){
        EntityWrapper< ChatEntity> ew = new EntityWrapper< ChatEntity>();
 		ew.allEq(MPUtil.allEQMapPre( chat, "chat")); 
		ChatView chatView =  chatService.selectView(ew);
		return R.ok("查询在线客服成功").put("data", chatView);
    }
	
    /**
     * 后端详情
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id){
        ChatEntity chat = chatService.selectById(id);
        return R.ok().put("data", chat);
    }

    /**
     * 前端详情
     */
	@IgnoreAuth
    @RequestMapping("/detail/{id}")
    public R detail(@PathVariable("id") Long id){
        ChatEntity chat = chatService.selectById(id);
        return R.ok().put("data", chat);
    }
    



    /**
     * 后端保存
     */
    @RequestMapping("/save")
    public R save(@RequestBody ChatEntity chat, HttpServletRequest request){
    	chat.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
    	//ValidatorUtils.validateEntity(chat);
    	if(StringUtils.isNotBlank(chat.getAsk())) {
			chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", request.getSession().getAttribute("userId")));
    		chat.setUserid((Long)request.getSession().getAttribute("userId"));
    		chat.setIsreply(1);
    	}
    	if(StringUtils.isNotBlank(chat.getReply())) {
    		chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", chat.getUserid()));
    		chat.setAdminid((Long)request.getSession().getAttribute("userId"));
    	}

        chatService.insert(chat);
        return R.ok();
    }
    
    /**
     * 前端保存
     */
    @RequestMapping("/add")
    public R add(@RequestBody ChatEntity chat, HttpServletRequest request){
    	chat.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
    	//ValidatorUtils.validateEntity(chat);
    	chat.setUserid((Long)request.getSession().getAttribute("userId"));
    	if(StringUtils.isNotBlank(chat.getAsk())) {
			chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", request.getSession().getAttribute("userId")));
    		chat.setUserid((Long)request.getSession().getAttribute("userId"));
    		chat.setIsreply(1);
    	}
    	if(StringUtils.isNotBlank(chat.getReply())) {
    		chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", chat.getUserid()));
    		chat.setAdminid((Long)request.getSession().getAttribute("userId"));
    	}

        chatService.insert(chat);
        return R.ok();
    }

    /**
     * 修改
     */
    @RequestMapping("/update")
    public R update(@RequestBody ChatEntity chat, HttpServletRequest request){
        //ValidatorUtils.validateEntity(chat);
        chatService.updateById(chat);//全部更新
        return R.ok();
    }
    

    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids){
        chatService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }
    
    /**
     * 提醒接口
     */
	@RequestMapping("/remind/{columnName}/{type}")
	public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, 
						 @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
		map.put("column", columnName);
		map.put("type", type);
		
		if(type.equals("2")) {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Calendar c = Calendar.getInstance();
			Date remindStartDate = null;
			Date remindEndDate = null;
			if(map.get("remindstart")!=null) {
				Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
				c.setTime(new Date()); 
				c.add(Calendar.DAY_OF_MONTH,remindStart);
				remindStartDate = c.getTime();
				map.put("remindstart", sdf.format(remindStartDate));
			}
			if(map.get("remindend")!=null) {
				Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
				c.setTime(new Date());
				c.add(Calendar.DAY_OF_MONTH,remindEnd);
				remindEndDate = c.getTime();
				map.put("remindend", sdf.format(remindEndDate));
			}
		}
		
		Wrapper<ChatEntity> wrapper = new EntityWrapper<ChatEntity>();
		if(map.get("remindstart")!=null) {
			wrapper.ge(columnName, map.get("remindstart"));
		}
		if(map.get("remindend")!=null) {
			wrapper.le(columnName, map.get("remindend"));
		}


		int count = chatService.selectCount(wrapper);
		return R.ok().put("count", count);
	}
	
	





}
JAVA编码选手
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【计算机毕业设计】028房屋租赁系统
卓怡学长的博客
04-22 1481
房屋是人类生活栖息的重要场所，随着城市中的流动人口的增多，人们对房屋租赁需求越来越高，为满足用户查询房屋、预约看房、房屋租赁的需求，特开发了本基于Spring Boot的房屋租赁系统。 本文重点阐述了房屋租赁系统的开发过程，以实际运用为开发背景，基于Spring Boot框架，运用了Java技术和MYSQL数据库进行开发，充分保证系统的安全性和稳定性。本系统界面良好，操作简单方便，通过系统概述、系统分析、系统设计、数据库设计、系统测试这几个部分，详细的说明了系统的开发过程，最后并对整个开发过程进行了总结，
基于SSM实现的房屋租赁系统【附源码】（毕设）
02-27
一、项目简介本课程演示的是一套基于SSM实现的房屋租赁系统，主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Java学习者。课程包含： 1. 项目源码、项目文档、数据库脚本、软件工具等所有资料2. 带你从零开始部署运行本套系统3. 该项目附带的源码资料可作为毕设使用4. 提供技术答疑和远程协助指导二、技术实现 后台框架：Spring、SpringMVC、MyBatisUI界面：jQuery 、JSP数据库：MySQL 三、系统功能系统分为前台用户界面和后台系统管理：1. 前台用户界面    用户注册、用户登录、用户中心、浏览房源、房源搜索    查看房源明细、发布房源、提交合同、新闻公告、留言交流2. 后台系统管理    用户管理：用户列表、用户删除、用户查询    新闻管理：新闻列表、添加新闻、修改新闻、删除新闻、查询新闻    房屋管理：房屋列表、房屋删除、分页查看    留言管理：留言列表、留言删除、留言查询、留言回复列表、回复查询    租赁合同管理：合同列表、查看合同、删除合同    管理员管理：管理员管理、新增管理员、编辑管理员、删除管理员等 四、项目截图1）前台用户界面 2）后台系统管理    更多Java毕设项目请关注【毕设系列课程】https://edu.csdn.net/lecturer/2104   点击 我的百科 ，通过百度百科更多了解我 ^_^ 
房屋租赁系统|基于JSP技术+ Mysql+Java+ B/S结构的房屋租赁系统设计与实现(可运行源码+数据库+设计文档)
最新发布
A15388691131的博客
03-20 894
房屋租赁系统为用户提供了开放的操作方便的使用系统，基本满足了用户的使用需要，以及我最初的开发目标和方向。Java语言、MySQL数据库等技术时是我开发的基础，这些技术都有各自的优点，学好这些技术，至关重要。通过这些优点设计出来的系统能够正常稳定的运行，并且可以满足人们的所有需求，在对系统的需求以及各个模块进行了详细的分析后，有针对性的进行设计，最后通过测试，系统能够正常的运行，该房屋租赁系统设计完成。
基于Springboot的房屋租赁管理系统的设计与实现
yvonneking1118的博客
06-08 1674
该房屋租赁管理系统采用Java作为主要编程语言，使用MySQL关系型数据库存储数据，采用b/s架构模式。在技术选型上，系统采用了Springboot框架搭建，具有高效、快速、便捷轻量级等特点，前端采用Html、CSS、JavaScript等开发语言，通过数据交互方式实现了用户前台和用户后台的数据通讯，保证系统可以正常稳定地运行。
JAVA 房屋出租系统（韩顺平）
热门推荐
wztmds的博客
04-04 1万+
一.需求说明 能够实现对房屋信息的添加、修改和删除（用数组实现），并能够打印房屋明细表 主要包括：主菜单，新增房源，查找房屋信息，修改房屋信息，删除房屋信息 主菜单 添加房屋信息 查找房屋信息 删除房屋信息 修改房屋信息 房屋列表 退出系统 二.出租设计（韩顺平老师总结） 在这里总结一下韩老师的设计思路，首先我们需要一个与用户交互的界面（view），其次我们需要对创建一个解决crud的（service）方法，我们可以在view界面中可...
【附源码】基于框架的房屋租赁系统的设计与实现whp019计算机毕设SSM
bishe98的博客
11-07 234
项目运行环境配置：Jdk1.8 + Tomcat7.0 + Mysql + HBuilderX（Webstorm也行）+ Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：Springboot + mybatis + Maven +mysql5.7或8.0+html+css+js等等组成，B/S模式 + Maven管理等等。环境需要1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。
【计算机毕业设计】241房屋出租出售系统
08-11
8.现在市场上的定制，都是找个成品或者模板改改发给同学，没有人从零开发一个系统，这样下来重复可能性更大不如自己找个成品去修改 9.需要部署和讲解的同学可以额外联系我 开发语言：Java语音、Vue语言 前端技术：...
计算机毕业设计之jsp房屋租赁系统.zip
09-07
今年的毕业设计，附带源程序，数据库文件和环境说明文档，可以用来做毕业设计或者课程设计 一份很好的毕业设计
【计算机毕业设计】1.房屋租赁系统
11-22
针对这一需求，本文设计并实现了一套基于SSM框架的房屋租赁出售系统，力求能简洁高效地解决用户租房、买房方面的问题。该系统使用JSP平台开发，后台框架使用ssm，利用MySql数据库技术实现数据库管理。该系统可以使...
【计算机毕业设计】242房屋租赁平台
08-11
8.现在市场上的定制，都是找个成品或者模板改改发给同学，没有人从零开发一个系统，这样下来重复可能性更大不如自己找个成品去修改 9.需要部署和讲解的同学可以额外联系我 开发语言：Java语音、Vue语言 前端技术：...
计算机毕业设计JAVA房屋租赁系统mybatis+源码+调试部署+系统+数据库+lw
05-29
项目架构：B/S架构 开发语言：Java语言 开发软件：idea eclipse 前端技术：Layui、HTML、CSS、JS、JQuery等技术 后端技术：JAVA 运行环境：Win10、JDK1.8 数 据 库：MySQL5.7/8.0 运行服务器：Tomcat7.0 CSDN太坑了...
基于java房屋租赁系统.
01-23
前台：用户的管理，房源管理，租赁管理，费用管理，个人信息。 后台：房源管理，客户管理，财务管理，合同管理，权限管理，个人信息。 说明：如不会运行安装，可联系q1357251989
java租房管理系统
04-15
hibernate+Struts2练习项目
Java租房管理系统
08-10
Java+ajax+struts1所整合的租房系统。很适于初阶段朋友学习。
java+SQL房屋租赁系统
01-03
用java编写的访问数据库的房屋租赁系统
使用java编写的房屋租赁系统
05-18
使用java编写的房屋租赁系统，供学习使用。
基于java,springboot的房屋租赁系统的设计与实现
li12412414的博客
01-07 1087
基于java,springboot的房屋租赁系统的设计与实现，Java项目，SpringBoot项目，含开发文档，源码，数据库以及ppt
基于java技术的房屋租赁系统的设计与实现
QQ80213251的博客
02-19 217
如何获取到这些信息，在计算机还不是很发达的时代，出租人或卖房人可能会通过张贴广告的形式进行宣传，这样做不仅成本告，而且费时费利，随着互联网的发展，如何充分的利用互联网的优势快速传播这些信息，成为了一个新的课题。针对以上问题，设计开发了房屋信息管理系统，本系统前台主要使用JSP作为开发语言，后台使用SqlServer作为数据库管理系统，开发环境是MyEclipse，服务器采用tomcat，开发出的一个基于Web技术的B/S结构的基于房屋信息发布，查询一体的管理系统。4.2.11房屋出售信息删除 30。
Java项目房屋租赁管理系统
weixin_66128223的博客
08-31 250
基于IDEA平台的springboot项目 jdk1.8+mysql（源码+数据库文件），基本功能实现增删改查都有，登录，注册，图片文件上传等功能（用户，管理员）喜欢的小伙伴私信我。
数据库课程设计房屋租赁系统
12-13
针对数据库课程设计房屋租赁系统，我们可以从以下几个方面进行介绍： 1.系统功能介绍 房屋租赁系统主要包括系统首页、房屋信息、系统公告、留言板、个人中心、后台管理、在线客服等内容。其中，系统首页是整个系统的入口，用户可以在首页浏览系统的各项功能；房屋信息模块提供了房屋的详细信息，用户可以根据自己的需求进行筛选和查看；系统公告模块提供了系统的最新公告信息；留言板模块提供了用户之间的交流平台；个人中心模块提供了用户的个人信息管理功能；后台管理模块提供了管理员对系统的管理功能；在线客服模块提供了用户在线咨询的功能。 2.系统实体设计 房屋租赁系统的实体设计主要包括用户、房屋、订单、管理员等实体。其中，用户实体包括用户ID、用户名、密码、性别、联系方式等属性；房屋实体包括房屋ID、房屋名称、房屋类型、房屋面积、房屋价格等属性；订单实体包括订单ID、用户ID、房屋ID、订单状态、订单时间等属性；管理员实体包括管理员ID、管理员名称、密码等属性。这些实体之间的关系可以通过ER图进行说明。 3.数据库表设计 根据实体设计，我们可以将每个实体转化为一个数据库表。例如，用户实体可以转化为一个名为“user”的数据库表，房屋实体可以转化为一个名为“house”的数据库表，订单实体可以转化为一个名为“order”的数据库表，管理员实体可以转化为一个名为“admin”的数据库表。每个数据库表包括若干个字段，例如“user”表包括“user_id”、“username”、“password”、“gender”、“contact”等字段。 4.系统功能实现 房屋租赁系统的功能实现需要使用数据库管理系统，例如MySQL、Oracle等。我们可以使用SQL语句来实现系统的各项功能，例如查询房屋信息、添加订单、修改用户信息等。同时，我们还需要使用编程语言来实现系统的前端和后端功能，例如HTML、CSS、JavaScript、Python等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

JAVA编码选手

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值