Java项目：272SSM的垃圾分类管理系统

最新推荐文章于 2024-03-19 12:30:56 发布

源码空间站2022

最新推荐文章于 2024-03-19 12:30:56 发布

阅读量82

点赞数

文章标签： java python 大数据

本文链接：https://blog.csdn.net/m0_74967853/article/details/133389070

版权

作者主页：源码空间站2022

简介：Java领域优质创作者、Java项目、学习资料、技术互助

文末获取源码

项目介绍

基于SSM的垃圾分类管理系统

角色：用户、片区管理员、总管理员

（一）用户

用户登录注册功能：页面验证账号和密码是否合法，然后进行服务端的用户是否存在验证，通过就登陆成功，否则提示用户注册。

公告栏功能：用户可以他通过公告栏看到网站的通知和信息。

环保资讯功能：用户可以通过环保资讯了解各类环保信息。

积分商品功能：向用户提供各类积分商品，激励用户进行垃圾分类和预约回收。

垃圾信息查询功能：可以查询垃圾种类，帮助用户进行垃圾分类。当用户不知道垃圾类别是可以通过查询输入垃圾名称知道垃圾的类别和详细信息。

站点信息查询功能：可以看到各个站点的信息和状态，并且当用户有大的可回收的物品是，可以预约相应的站点上门回收。

我的账户：可以对个人的用户信息进行修改。

（二）片区管理员

用户积分：片区管理员对用户积分进行查询，并且通过用户的预约回收处理，可以对其用户积分进行增加或者减少。

预约回收信息处理功能：片区管理员可以查询用户的预约回收，并且对预约流程和状态进行处理，预约回收这个业务结束，可以对用户积分进行修改。

站点信息管理功能：片区管理员对站点信息进行查询并且编辑站点信息内容和状态。

垃圾清运功能：片区管理员可以查询站点垃圾站状态，若状态为满则安排清运，编辑清运状态。

（三）总管理员

网站管理功能：有两个功能，分别为轮播图和公告栏，这个模块可以对网站轮播图片进行修改，并且也可以对公告信息进行编辑和发布。

用户信息管理功能；可以对注册用户，片区管理员信息进行查询，删除编辑和添加。

内容信息管理功能：可以对环保资讯和资讯分类信息进行添加，删除，修改和查询。

更多内容管理功能：包含垃圾分类，积分商品，用户积分，预约回收，垃圾管理，站点管理，垃圾清运功能。

垃圾分类信息管理功能：可以对垃圾类别信息进行查询，添加，删除和修改。

积分商品信息管理功能：可以对积分商品信息进行查询，添加，删除和修改。

用户积分信息管理功能：可以对用户积分信息进行查询，添加，删除和修改。

预约回收信息管理功能：处理注册用户的回收信息。

垃圾信息管理功能：可以对垃圾信息进行查询，添加，删除和修改。

站点信息管理功能：可以对垃圾站点信息进行查询，添加，删除和修改。

垃圾清运信息管理功能：在垃圾站点满状态的情况下，对站点信息进行处理。

由于本程序规模不大，可供课程设计，毕业设计学习演示之用

更多项目源码，请到“源码空间站”，地址：http://www.shuyue.fun/

环境需要

1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。
2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA;
3.tomcat环境：Tomcat 7版本; 注意该项目仅支持Tomcat 7;
4.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS；
5.是否Maven项目: 是；查看源码目录中是否包含pom.xml；若包含，则为maven项目，否则为非maven项目
6.数据库：MySql 5.7/8.0等版本均可；
7.Node：版本为12

技术栈

后端：SSM(Spring+SpringMVC+Mybatis)
前端：ElementUI+Vue

使用说明

后端代码运行：
1. 使用Navicat或者其它工具，在mysql中创建对应sql文件名称的数据库，并导入项目的sql文件；
2. 使用IDEA/Eclipse/MyEclipse导入项目，修改配置，运行项目；
3. 将项目中jdbc.properties配置文件中的数据库配置改为自己的配置，然后运行；

前端代码运行：
1、命令行切换到该路径安装项目的路径，client_admin或者client_home
执行npm install
或者用cnpm install
2、执行npm run serve启动项目
3.在浏览器中输入指定的前端路径
管理员： admin **asd123**
片区管理员：guanli 123456
用户： zs123456 123456

运行截图

论文截图

前台界面

后台界面

相关代码

UserController

package com.project.demo.controller;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.project.demo.dao.AccessTokenMapper;
import com.project.demo.entity.AccessToken;
import com.project.demo.entity.User;
import com.project.demo.entity.UserGroup;
import com.project.demo.service.AccessTokenService;
import com.project.demo.service.UserGroupService;
import com.project.demo.service.UserService;
import com.project.demo.controller.base.BaseController;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

/**
 * 用户账户：用于保存用户登录信息(User)表控制层
 *
 */
@Slf4j
@RestController
@RequestMapping("user")
public class UserController extends BaseController<User, UserService> {
    /**
     * 服务对象
     */
    @Autowired
    public UserController(UserService service) {
        setService(service);
    }

    /**
     * Token服务
     */
    @Autowired
    private AccessTokenService tokenService;

    @Autowired
    private UserGroupService userGroupService;

    @Autowired
    private AccessTokenMapper accessTokenMapper;

    /**
     * 注册
     * @return
     */
    @PostMapping("register")
    public Map<String, Object> signUp(HttpServletRequest request) throws IOException {
        // 查询用户
        Map<String, String> query = new HashMap<>();
        Map<String,Object> map = service.readBody(request.getReader());
        query.put("username",String.valueOf(map.get("username")));
        List list = service.selectBaseList(service.select(query, new HashMap<>()));
        if (list.size()>0){
            return error(30000, "用户已存在");
        }
        map.put("password",service.encryption(String.valueOf(map.get("password"))));
        service.insert(map);
        return success(1);
    }

    /**
     * 找回密码
     * @param form
     * @return
     */
    @PostMapping("forget_password")
    public Map<String, Object> forgetPassword(@RequestBody User form, HttpServletRequest request) {
        JSONObject ret = new JSONObject();
        String username = form.getUsername();
        String code = form.getCode();
        String password = form.getPassword();
        // 判断条件
        if(code == null || code.length() == 0){
            return error(30000, "验证码不能为空");
        }
        if(username == null || username.length() == 0){
            return error(30000, "用户名不能为空");
        }
        if(password == null || password.length() == 0){
            return error(30000, "密码不能为空");
        }

        // 查询用户
        Map<String, String> query = new HashMap<>();
        query.put("username",username);
        List list = service.selectBaseList(service.select(query, service.readConfig(request)));
        if (list.size() > 0) {
            User o = (User) list.get(0);
            JSONObject query2 = new JSONObject();
            JSONObject form2 = new JSONObject();
            // 修改用户密码
            query2.put("user_id",o.getUserId());
            form2.put("password",service.encryption(password));
            service.update(query, service.readConfig(request), form2);
            return success(1);
        }
        return error(70000,"用户不存在");
    }

    /**
     * 登录
     * @param data
     * @param httpServletRequest
     * @return
     */
    @PostMapping("login")
    public Map<String, Object> login(@RequestBody Map<String, String> data, HttpServletRequest httpServletRequest) {
        log.info("[执行登录接口]");

        String username = data.get("username");
        String email = data.get("email");
        String phone = data.get("phone");
        String password = data.get("password");

        List resultList = null;
        QueryWrapper wrapper = new QueryWrapper<User>();
        Map<String, String> map = new HashMap<>();
        if(username != null && "".equals(username) == false){
            map.put("username", username);
            resultList = service.selectBaseList(service.select(map, new HashMap<>()));
        }
        else if(email != null && "".equals(email) == false){
            map.put("email", email);
            resultList = service.selectBaseList(service.select(map, new HashMap<>()));
        }
        else if(phone != null && "".equals(phone) == false){
            map.put("phone", phone);
            resultList = service.selectBaseList(service.select(map, new HashMap<>()));
        }else{
            return error(30000, "账号或密码不能为空");
        }
        if (resultList == null || password == null) {
            return error(30000, "账号或密码不能为空");
        }
        //判断是否有这个用户
        if (resultList.size()<=0){
            return error(30000,"用户不存在");
        }

        User byUsername = (User) resultList.get(0);


        Map<String, String> groupMap = new HashMap<>();
        groupMap.put("name",byUsername.getUserGroup());
        List groupList = userGroupService.selectBaseList(userGroupService.select(groupMap, new HashMap<>()));
        if (groupList.size()<1){
            return error(30000,"用户组不存在");
        }

        UserGroup userGroup = (UserGroup) groupList.get(0);

        //查询用户审核状态
        if (!StringUtils.isEmpty(userGroup.getSourceTable())){
            String res = service.selectExamineState(userGroup.getSourceTable(),byUsername.getUserId());
            if (res==null){
                return error(30000,"用户不存在");
            }
            if (!res.equals("已通过")){
                return error(30000,"该用户审核未通过");
            }
        }

        //查询用户状态
        if (byUsername.getState()!=1){
            return error(30000,"用户非可用状态，不能登录");
        }

        String md5password = service.encryption(password);
        if (byUsername.getPassword().equals(md5password)) {
            // 存储Token到数据库
            AccessToken accessToken = new AccessToken();
            accessToken.setToken(UUID.randomUUID().toString().replaceAll("-", ""));
            accessToken.setUser_id(byUsername.getUserId());
            tokenService.save(accessToken);

            // 返回用户信息
            JSONObject user = JSONObject.parseObject(JSONObject.toJSONString(byUsername));
            user.put("token", accessToken.getToken());
            JSONObject ret = new JSONObject();
            ret.put("obj",user);
            return success(ret);
        } else {
            return error(30000, "账号或密码不正确");
        }
    }

    /**
     * 修改密码
     * @param data
     * @param request
     * @return
     */
    @PostMapping("change_password")
    public Map<String, Object> change_password(@RequestBody Map<String, String> data, HttpServletRequest request){
        // 根据Token获取UserId
        String token = request.getHeader("x-auth-token");
        Integer userId = tokenGetUserId(token);
        // 根据UserId和旧密码获取用户
        Map<String, String> query = new HashMap<>();
        String o_password = data.get("o_password");
        query.put("user_id" ,String.valueOf(userId));
        query.put("password" ,service.encryption(o_password));
        int count = service.selectBaseCount(service.count(query, service.readConfig(request)));
        if(count > 0){
            // 修改密码
            Map<String,Object> form = new HashMap<>();
            form.put("password",service.encryption(data.get("password")));
            service.update(query,service.readConfig(request),form);
            return success(1);
        }
        return error(10000,"密码修改失败！");
    }

    /**
     * 登录态
     * @param request
     * @return
     */
    @GetMapping("state")
    public Map<String, Object> state(HttpServletRequest request) {
        JSONObject ret = new JSONObject();
        // 获取状态
        String token = request.getHeader("x-auth-token");

        // 根据登录态获取用户ID
        Integer userId = tokenGetUserId(token);

        log.info("[返回userId] {}",userId);
        if(userId == null || userId == 0){
            return error(10000,"用户未登录!");
        }

        // 根据用户ID获取用户
        Map<String,String> query = new HashMap<>();
        query.put("user_id" ,String.valueOf(userId));

        // 根据用户ID获取
        List resultList = service.selectBaseList(service.select(query,service.readConfig(request)));
        if (resultList.size() > 0) {
            JSONObject user = JSONObject.parseObject(JSONObject.toJSONString(resultList.get(0)));
            user.put("token",token);
            ret.put("obj",user);
            return success(ret);
        } else {
            return error(10000,"用户未登录!");
        }
    }

    /**
     * 登录态
     * @param request
     * @return
     */
    @GetMapping("quit")
    public Map<String, Object> quit(HttpServletRequest request) {
        String token = request.getHeader("x-auth-token");
        Map<String, String> query = new HashMap<>(16);
        query.put("token", token);
        try{
            tokenService.delete(query,service.readConfig(request));
        }catch (Exception e){
            e.printStackTrace();
        }
        return success("退出登录成功！");
    }

    /**
     * 获取登录用户ID
     * @param token
     * @return
     */
    public Integer tokenGetUserId(String token) {
        log.info("[获取的token] {}",token);
        // 根据登录态获取用户ID
        if(token == null || "".equals(token)){
            return 0;
        }
        QueryWrapper wrapper = new QueryWrapper<AccessToken>();
        wrapper.eq("token",token);
        AccessToken byToken = accessTokenMapper.selectOne(wrapper);
        if(byToken == null){
            return 0;
        }
        return byToken.getUser_id();
    }

    /**
     * 重写add
     * @return
     */
    @PostMapping("/add")
    @Transactional
    public Map<String, Object> add(HttpServletRequest request) throws IOException {
        Map<String,Object> map = service.readBody(request.getReader());
        map.put("password",service.encryption(String.valueOf(map.get("password"))));
        service.insert(map);
        return success(1);
    }

}

如果也想学习本系统，下面领取。关注并回复：272ssm