Java源码社

基于javaweb的SSM+Maven垃圾分类管理系统(java+vue+ssm+js+layui+mysql)

更新于

运行环境

Java≥8、MySQL≥5.7、Tomcat≥8、Node.js≥14

开发工具

后端：eclipse/idea/myeclipse/sts等均可配置运行
前端：WebStorm/VSCode/HBuilderX等均可

❗没学过node.js的不要搞前后端分离项目

适用

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

功能说明

242323411807

252323411807

262323411807

272323411807

282323411807

292323411807

基于javaweb的SSM+Maven垃圾分类管理系统(java+vue+ssm+js+layui+mysql)

项目介绍

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

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

1
2
3
4
5
6
7
8
管理员
admin   123456

片区管理员
guanli  123456

用户(注册)
user1   123456

（一）用户

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

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

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

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

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

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

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

（二）片区管理员

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

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

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

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

（三）总管理员

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

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

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

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

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

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

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

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
//
    public void importDb(MultipartFile file) throws IOException {
        if (file.isEmpty()) {
            return;
        }
        List<Map<String,String>> body = new ArrayList<>();
        String fileName = file.getOriginalFilename();
        if (fileName == null){
            return;
        }
        String suffix = fileName.substring(fileName.lastIndexOf(".")+1);
        InputStream ins = file.getInputStream();
        Workbook wb = null;
        if(suffix.equals("xlsx")){
            wb = new XSSFWorkbook(ins);
        }else{
            wb = new HSSFWorkbook(ins);
        }
        Sheet sheet = wb.getSheetAt(0);
        if(null != sheet){
            for(int line = 0; line <= sheet.getLastRowNum();line++){
                Row row = sheet.getRow(line);
                if(null == row){
                    continue;
                }
                Iterator<Cell> cellIterator = row.cellIterator();
                StringBuffer sql = new StringBuffer("INSERT INTO ").append(table).append(" VALUES (null,");
                while (cellIterator.hasNext()){
                    sql.append(cellIterator.next().getStringCellValue()).append(",");
                }
                sql.deleteCharAt(sql.length());
                sql.append(")");
//                runCountSql(sql.toString());
            }
        }
    }

//    public HSSFWorkbook exportDb(Map<String,String> query, Map<String,String> config){
//        List<Map<String,String>> resultList = baseMapper.selectBaseList(select(query, config));
//        HSSFWorkbook workbook = new HSSFWorkbook();
//        HSSFSheet sheet = workbook.createSheet(table);
//        HSSFCellStyle headerStyle = workbook.createCellStyle();
//        headerStyle.setFillForegroundColor(IndexedColors.YELLOW.index);
//        headerStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
//        for (int i = 0; i < resultList.size(); i++) {
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
        map.put("list",list);
        map.put("count",baseMapper.selectBaseCount(count(query,config)));
        return map;
    }

    public Map<String,Object> selectToList(Map<String,String> query,Map<String,String> config){
        Map<String,Object> map = new HashMap<>();
        List<Map<String,Object>> resultList = baseMapper.selectBaseList(selectGroupCount(query, config));
        List list = new ArrayList();
        for (Map<String,Object> resultMap:resultList) {
            List subList = new ArrayList();
            for(String key:resultMap.keySet()){//keySet获取map集合key的集合  然后在遍历key即可
                subList.add(resultMap.get(key));
            }
            list.add(subList);
        }
        map.put("list",list);
        return map;
    }

    public Integer selectSqlToInteger(String sql){
        Integer value = baseMapper.selectBaseCount(sql);
        return value;
    }

    public Map<String,Object> selectBarGroup(Map<String,String> query,Map<String,String> config){
        Map<String,Object> map = new HashMap<>();
        List<Map<String,Object>> resultList = baseMapper.selectBaseList(barGroup(query, config));
        List list = new ArrayList();
        for (Map<String,Object> resultMap:resultList) {
            List subList = new ArrayList();
            for(String key:resultMap.keySet()){//keySet获取map集合key的集合  然后在遍历key即可
                subList.add(resultMap.get(key));
            }
            list.add(subList);
        }
        map.put("list",list);
        return map;
    }

//    public void barGroup(Map<String,String> query,Map<String,String> config,QueryWrapper wrapper){
//        if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
//            wrapper.select(config.get(FindConfig.GROUP_BY));
//            if (config.get(FindConfig.FIELD) != null && !"".equals(config.get(FindConfig.FIELD))){
//                String[] fieldList = config.get(FindConfig.FIELD).split(",");
//                for (int i=0;i<fieldList.length;i++)
//                    wrapper.select("SUM("+fieldList[i]+")");
//            }
//            toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),wrapper);
//            wrapper.groupBy(config.get(FindConfig.GROUP_BY));
//        }else {
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
    @RequestMapping(value = {"/count_group", "/count"})
    public Map<String, Object> count(HttpServletRequest request) {
        Integer value= service.selectSqlToInteger(service.groupCount(service.readQuery(request), service.readConfig(request)));
        return success(value);
    }

    @RequestMapping(value = {"/sum_group", "/sum"})
    public Map<String, Object> sum(HttpServletRequest request) {
        Integer value = service.selectSqlToInteger(service.sum(service.readQuery(request), service.readConfig(request)));
        return success(value);
    }

    @RequestMapping(value = {"/avg_group", "/avg"})
    public Map<String, Object> avg(HttpServletRequest request) {
        Integer value = service.selectSqlToInteger(service.avg(service.readQuery(request), service.readConfig(request)));
        return success(value);
    }

//    @RequestMapping(value = {"/count_group", "/count"})
//    public Map<String, Object> count(HttpServletRequest request) {
//        Query count = service.count(service.readQuery(request), service.readConfig(request));
//        return success(count.getResultList());
//    }
//
//    @RequestMapping(value = {"/sum_group", "/sum"})
//    public Map<String, Object> sum(HttpServletRequest request) {
//        Query count = service.sum(service.readQuery(request), service.readConfig(request));
//        return success(count.getResultList());
//    }
//
//    @RequestMapping(value = {"/avg_group", "/avg"})
//	public Map<String, Object> avg(HttpServletRequest request) {
//        Query count = service.avg(service.readQuery(request), service.readConfig(request));
//        return success(count.getResultList());
//    }


    @PostMapping("/upload")
    public Map<String, Object> upload(@RequestParam(value = "file",required=false) MultipartFile file,HttpServletRequest request) {
        log.info("进入方法");
        if (file.isEmpty()) {
            return error(30000, "没有选择文件");
        }
        try {
            //判断有没路径，没有则创建
            String filePath = request.getSession().getServletContext().getRealPath("\\") +"upload\\";
//            String filePath = System.getProperty("user.dir") + "\\target\\classes\\static\\upload\\";
            File targetDir = new File(filePath);
            if (!targetDir.exists() && !targetDir.isDirectory()) {
                if (targetDir.mkdirs()) {
                    log.info("创建目录成功");
                } else {
                    log.error("创建目录失败");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

/**
 *积分扣减：(IntegralDeduction)表控制层
 *
 */
@RestController
@RequestMapping("/integral_deduction")
public class IntegralDeductionController extends BaseController<IntegralDeduction,IntegralDeductionService> {

    /**
     *积分扣减对象
     */
    @Autowired
    public IntegralDeductionController(IntegralDeductionService service) {
        setService(service);
    }

    @PostMapping("/add")
    @Transactional
    public Map<String, Object> add(HttpServletRequest request) throws IOException {
        Map<String,Object> paramMap = service.readBody(request.getReader());
        this.addMap(paramMap);
        String sql = "SELECT MAX(integral_deduction_id) AS max FROM "+"integral_deduction";
        Integer max = service.selectBaseCount(sql);
        sql = ("SELECT count(*) count FROM `user_points` INNER JOIN `integral_deduction` ON user_points.user=integral_deduction.user WHERE user_points.integral &#60; integral_deduction.deduction_points AND integral_deduction.integral_deduction_id="+max).replaceAll("&#60;","<");
        Integer count = service.selectBaseCount(sql);
        if(count>0){
            sql = "delete from "+"integral_deduction"+" WHERE "+"integral_deduction_id"+" ="+max;
            service.deleteBaseSql(sql);
            return error(30000,"积分不足!");
        }
        sql = "UPDATE `user_points` INNER JOIN `integral_deduction` ON user_points.user=integral_deduction.user SET user_points.integral = user_points.integral - integral_deduction.deduction_points WHERE integral_deduction.integral_deduction_id="+max;
        service.updateBaseSql(sql);
        return success(1);
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
    }

    @RequestMapping(value = {"/sum_group", "/sum"})
    public Map<String, Object> sum(HttpServletRequest request) {
        Integer value = service.selectSqlToInteger(service.sum(service.readQuery(request), service.readConfig(request)));
        return success(value);
    }

    @RequestMapping(value = {"/avg_group", "/avg"})
    public Map<String, Object> avg(HttpServletRequest request) {
        Integer value = service.selectSqlToInteger(service.avg(service.readQuery(request), service.readConfig(request)));
        return success(value);
    }

//    @RequestMapping(value = {"/count_group", "/count"})
//    public Map<String, Object> count(HttpServletRequest request) {
//        Query count = service.count(service.readQuery(request), service.readConfig(request));
//        return success(count.getResultList());
//    }
//
//    @RequestMapping(value = {"/sum_group", "/sum"})
//    public Map<String, Object> sum(HttpServletRequest request) {
//        Query count = service.sum(service.readQuery(request), service.readConfig(request));
//        return success(count.getResultList());
//    }
//
//    @RequestMapping(value = {"/avg_group", "/avg"})
//	public Map<String, Object> avg(HttpServletRequest request) {
//        Query count = service.avg(service.readQuery(request), service.readConfig(request));
//        return success(count.getResultList());
//    }


    @PostMapping("/upload")
    public Map<String, Object> upload(@RequestParam(value = "file",required=false) MultipartFile file,HttpServletRequest request) {
        log.info("进入方法");
        if (file.isEmpty()) {
            return error(30000, "没有选择文件");
        }
        try {
            //判断有没路径，没有则创建
            String filePath = request.getSession().getServletContext().getRealPath("\\") +"upload\\";
//            String filePath = System.getProperty("user.dir") + "\\target\\classes\\static\\upload\\";
            File targetDir = new File(filePath);
            if (!targetDir.exists() && !targetDir.isDirectory()) {
                if (targetDir.mkdirs()) {
                    log.info("创建目录成功");
                } else {
                    log.error("创建目录失败");
                }
            }
//            String path = ResourceUtils.getURL("classpath:").getPath() + "static/upload/";
//            String filePath = path.replace('/', '\\').substring(1, path.length());

项目链接：
https://javayms.github.io?id=040023061907201ap
https://javayms.pages.dev?id=040023061907201ap