基于Spring Boot的房地产销售管理系统

最新推荐文章于 2024-09-26 15:45:00 发布

我真的在拉扯QAQ

最新推荐文章于 2024-09-26 15:45:00 发布

阅读量953

点赞数 19

本文链接：https://blog.csdn.net/Steve792/article/details/135190014

版权

本文介绍了基于JAVA、SpringBoot和Vue技术构建的房地产销售管理系统，包括管理员、客户和销售经理角色，功能涵盖房产查询、预约、评价、购置等，强调了登录验证、权限管理和跨域实现的详细实现过程。

摘要由CSDN通过智能技术生成

系统描述

社会和科技的不断进步带来更便利的生活，计算机技术也越来越平民化。二十一世纪是数据时代，各种信息经过统计分析都可以得到想要的结果，所以也可以更好的为人们工作、生活服务。房屋是生活条件的一部分，所以需求量非常大。把计算机技术和房地产销售相结合可以更符合现代、用户的要求，实现更为方便的销售房屋的方式。

本基于JAVA的房地产销售管理系统采用JAVA语言和Vue技术，框架采用Springboot，搭配Mysql数据库，运行在Idea里。本基于JAVA的房地产销售管理系统提供管理员、客户、销售经理三种角色的服务。总的功能包括房产的查询、预约、评价、购买和论坛管理等。本系统可以帮助管理员、销售经理更新房产信息和管理预约、购买信息，帮助客户实现在线的预约方式，并可以实现购买。本系统采用成熟技术开发可以完成房地产销售管理的相关工作。

技术描述

文章末尾获取源码

开发语言：Java

技术框架：SpringBoot

前端语言：Vue\HTML

持久层框架：Mybatis

服务器：Tomcat7\8\9\10

数据库：MySQL5.7以上

项目管理工具：Maven

项目开发工具：IDEA\Eclipse

系统展示

用户登录功能的详细实现

用户登录界面起到验证身份的作用，本界面采用风景图片背景进行设计。在用户登录界面里设置了程序的名称和用户、密码、客户注册的文本框。在文本框下是登录按钮。用户在信息输入完成后可以使用登录按钮进行相对应的操作，还加入了登录安全的简单文字提醒。

管理员权限的功能实现

客户信息管理功能的详细实现

管理员负责客户信息的录入和管理，客户的地址、联系方式等都可以由管理员在此功能里看到。

房产管理功能的详细实现

管理员可以对房产的信息进行管理、审核。本功能可以实现房产的定时更新和审核管理。

预约看房功能的详细实现

本功能包括查询已有的所有预约看房信息和删除预约看房信息。

论坛管理功能的详细实现

管理员可以查询论坛和审核管理客户发布的帖子。

购置房产管理功能的详细实现

管理员可以管理客户的购置房产信息，也可以查询和删除购置房产内容。

个人中心管理功能的详细实现

管理员可以对个人的资料进行修改和管理，管理员还可以在本功能里修改密码。

客户打分管理功能的实现界面

管理员可以查询客户的打分详情，并进行查询等操作。

基础数据管理功能的实现界面

管理员可以管理房产户型和公告类型。

轮播图管理功能的实现界面

可以设置轮播图。

客户权限的功能详细实现

个人中心管理功能的详细界面实现

当客户登录进系统后可以修改自己的资料，可以使自己信息的保持正确性。

房产查询功能的详细实现

用户可以根据房产名称搜索相对应的房产

预约看房功能的详细实现

在本功能里客户可以查看自己预约的所有房产信息。

论坛管理功能的详细实现

客户可以发布帖子和查看帖子的回复信息。

购置房产管理功能的详细实现

客户可以在线购置房产，也可以查询自己的详细购置内容。

客户打分功能的详细实现

完成销售后，客户可以进行打分。

售经理权限功能的实现

　　销售经理的功能和管理员的类似，功能包括房产信息管理、预约看房管理、论坛管理、公告管理、购置房产管理、客户打分管理。

代码实现：

跨域实现

package com.interceptor;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
import com.alibaba.fastjson.JSONObject;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import com.annotation.IgnoreAuth;
import com.entity.EIException;
import com.entity.TokenEntity;
import com.service.TokenService;
import com.utils.R;

/**
 * 权限(Token)验证
 */
@Component
public class AuthorizationInterceptor implements HandlerInterceptor {

    public static final String LOGIN_TOKEN_KEY = "Token";

    @Autowired
    private TokenService tokenService;
    
	@Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        //支持跨域请求
        response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Credentials", "true");
        response.setHeader("Access-Control-Allow-Headers", "x-requested-with,request-source,Token, Origin,imgType, Content-Type, cache-control,postman-token,Cookie, Accept,authorization");
        response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin"));

        IgnoreAuth annotation;
        if (handler instanceof HandlerMethod) {
            annotation = ((HandlerMethod) handler).getMethodAnnotation(IgnoreAuth.class);
        } else {
            return true;
        }

        //从header中获取token
        String token = request.getHeader(LOGIN_TOKEN_KEY);
        
        /**
         * 不需要验证权限的方法直接放过
         */
        if(annotation!=null) {
        	return true;
        }
        
        TokenEntity tokenEntity = null;
        if(StringUtils.isNotBlank(token)) {
        	tokenEntity = tokenService.getTokenEntity(token);
        }
        
        if(tokenEntity != null) {
        	request.getSession().setAttribute("userId", tokenEntity.getUserid());
        	request.getSession().setAttribute("role", tokenEntity.getRole());
        	request.getSession().setAttribute("tableName", tokenEntity.getTablename());
        	request.getSession().setAttribute("username", tokenEntity.getUsername());
        	return true;
        }
        
		PrintWriter writer = null;
		response.setCharacterEncoding("UTF-8");
		response.setContentType("application/json; charset=utf-8");
		try {
		    writer = response.getWriter();
		    writer.print(JSONObject.toJSONString(R.error(401, "请先登录")));
		} finally {
		    if(writer != null){
		        writer.close();
		    }
		}
//				throw new EIException("请先登录", 401);
		return false;
    }
}

登录实现


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.MD5Util;
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();
    }
}