基于java+ssm+vue的垃圾分类微信小程序

标签：5.1 vue java 微信 lajixinxi request import return 页面

项目介绍

现代经济快节奏发展以及不断完善升级的信息化技术，让传统数据信息的管理升级为软件存储，归纳，集中处理数据信息的管理方式。本垃圾分类小程序就是在这样的大环境下诞生，其可以帮助管理者在短时间内处理完毕庞大的数据信息，使用这种软件工具可以帮助管理人员提高事务处理效率，达到事半功倍的效果。

此垃圾分类小程序使用跨平台的可开发大型商业网站的HTML技术，以及最受欢迎的RDBMS应用软件之一的MySQL数据库进行程序开发，后台采用Java语言的SSM框架，前台采用VUE框架和layui样式，垃圾分类小程序端实现页面基本用uni app框架写作。垃圾分类小程序管理员功能有个人中心，管理员管理，意见反馈管理，视频类型管理，垃圾类型管理，新闻类型管理，论坛信息管理，环保视频管理，环保知识管理，垃圾信息管理，环保新闻管理，用户管理，知识问答试卷管理，试题管理，测试管理，轮播图管理。用户可以在微信小程序上面注册登录，查看各种环保信息和垃圾信息，还可以参加知识问答等操作。

垃圾分类小程序的开发根据操作人员需要设计的界面简洁美观，在功能模块布局上跟同类型网站保持一致，程序在实现基本要求功能时，也为数据信息面临的安全问题提供了一些实用的解决方案。可以说该程序在帮助管理者高效率地处理工作事务的同时，也实现了数据信息的整体化，规范化与自动化。
在这里插入图片描述

开发环境

编程语言：Java
数据库：Mysql
系统架构：B/S
后端框架：SSM
编译工具：idea或者eclipse，微信开发者工具，jdk1.8，maven
支持定做：java/php/python/android/小程序vue/爬虫/c#/asp.net

系统实现

5.1 管理员功能介绍
5.1.1 管理员管理
如图5.1显示的就是管理员管理页面，管理员可以对管理员信息进行添加，修改，删除，查询操作。
在这里插入图片描述

图5.1 管理员管理页面

5.1.2 视频类型管理
如图5.2显示的就是视频类型管理页面，管理员可以对视频类型信息进行添加，修改，删除，查询操作。
在这里插入图片描述

图5.2 视频类型管理页面

5.1.3 论坛管理
如图5.3显示的就是论坛管理页面，管理员可以对论坛信息进行添加，修改，删除，查询操作。
在这里插入图片描述

图5.3 论坛管理页面

5.1.4 新闻类型管理
如图5.4显示的就是新闻类型管理页面，管理员可以对新闻类型信息进行添加，修改，删除，查询操作。
在这里插入图片描述

图5.4 新闻类型管理页面

5.1.5 环保视频管理
如图5.5显示的就是环保视频页面，管理员可以对环保视频信息进行添加，修改，删除，查询操作。
在这里插入图片描述

图5.5 环保视频管理页面

5.1.6 环保知识管理
如图5.6显示的就是环保知识管理页面，管理员可以对环保知识信息进行添加，修改，删除，查询操作。
在这里插入图片描述

图5.6 环保知识管理页面

5.1.7 环保新闻管理
如图5.7显示的就是环保新闻管理页面，管理员可以对环保新闻进行添加，修改，删除，查询操作。
在这里插入图片描述

图5.7 环保新闻管理页面

5.1.8 用户信息管理
如图5.8显示的就是用户信息页面，管理员可以对用户信息进行添加，修改，删除，查询操作。
在这里插入图片描述

图5.8 用户信息管理页面

5.2 用户功能介绍
5.2.1 首页
如图5.9显示的就是首页页面，用户注册登录后可以看到首页，下面是导航，中间是内容。
在这里插入图片描述

图5.9 首页页面

5.2.2 环保视频
如图5.9显示的就是环保视频页面，用户可以在环保视频界面查看环保视频信息。
在这里插入图片描述

图5.10 环保视频页面

5.2.3 垃圾信息
如图5.9显示的就是垃圾信息页面，用户点击垃圾信息可以查看垃圾信息。
在这里插入图片描述

图5.11 垃圾信息页面

5.2.4 我的
如图5.9显示的就是我的页面，用户登录后可以点击我的可以看到关于我的所有功能。
在这里插入图片描述

图5.12 我的页面

核心代码

package com.controller;

import java.io.File;
import java.math.BigDecimal;
import java.net.URL;
import java.text.SimpleDateFormat;
import com.alibaba.fastjson.JSONObject;
import java.util.*;
import org.springframework.beans.BeanUtils;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.context.ContextLoader;
import javax.servlet.ServletContext;
import com.service.TokenService;
import com.utils.*;
import java.lang.reflect.InvocationTargetException;

import com.service.DictionaryService;
import org.apache.commons.lang3.StringUtils;
import com.annotation.IgnoreAuth;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.entity.*;
import com.entity.view.*;
import com.service.*;
import com.utils.PageUtils;
import com.utils.R;
import com.alibaba.fastjson.*;

/**
 * 垃圾信息
 * 后端接口
 * @author
 * @email
*/
@RestController
@Controller
@RequestMapping("/lajixinxi")
public class LajixinxiController {
    private static final Logger logger = LoggerFactory.getLogger(LajixinxiController.class);

    @Autowired
    private LajixinxiService lajixinxiService;


    @Autowired
    private TokenService tokenService;
    @Autowired
    private DictionaryService dictionaryService;

    //级联表service

    @Autowired
    private YonghuService yonghuService;


    /**
    * 后端列表
    */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(false)
            return R.error(511,"永不会进入");
        else if("用户".equals(role))
            params.put("yonghuId",request.getSession().getAttribute("userId"));
        if(params.get("orderBy")==null || params.get("orderBy")==""){
            params.put("orderBy","id");
        }
        PageUtils page = lajixinxiService.queryPage(params);

        //字典表数据转换
        List<LajixinxiView> list =(List<LajixinxiView>)page.getList();
        for(LajixinxiView c:list){
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(c, request);
        }
        return R.ok().put("data", page);
    }

    /**
    * 后端详情
    */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id, HttpServletRequest request){
        logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        LajixinxiEntity lajixinxi = lajixinxiService.selectById(id);
        if(lajixinxi !=null){
            //entity转view
            LajixinxiView view = new LajixinxiView();
            BeanUtils.copyProperties( lajixinxi , view );//把实体数据重构到view中

            //修改对应字典表字段
            dictionaryService.dictionaryConvert(view, request);
            return R.ok().put("data", view);
        }else {
            return R.error(511,"查不到数据");
        }

    }

    /**
    * 后端保存
    */
    @RequestMapping("/save")
    public R save(@RequestBody LajixinxiEntity lajixinxi, HttpServletRequest request){
        logger.debug("save方法:,,Controller:{},,lajixinxi:{}",this.getClass().getName(),lajixinxi.toString());

        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(false)
            return R.error(511,"永远不会进入");

        Wrapper<LajixinxiEntity> queryWrapper = new EntityWrapper<LajixinxiEntity>()
            .eq("lajixinxi_name", lajixinxi.getLajixinxiName())
            .eq("lajixinxi_types", lajixinxi.getLajixinxiTypes())
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        LajixinxiEntity lajixinxiEntity = lajixinxiService.selectOne(queryWrapper);
        if(lajixinxiEntity==null){
            lajixinxi.setInsertTime(new Date());
            lajixinxi.setCreateTime(new Date());
            lajixinxiService.insert(lajixinxi);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 后端修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody LajixinxiEntity lajixinxi, HttpServletRequest request){
        logger.debug("update方法:,,Controller:{},,lajixinxi:{}",this.getClass().getName(),lajixinxi.toString());

        String role = String.valueOf(request.getSession().getAttribute("role"));
//        if(false)
//            return R.error(511,"永远不会进入");
        //根据字段查询是否有相同数据
        Wrapper<LajixinxiEntity> queryWrapper = new EntityWrapper<LajixinxiEntity>()
            .notIn("id",lajixinxi.getId())
            .andNew()
            .eq("lajixinxi_name", lajixinxi.getLajixinxiName())
            .eq("lajixinxi_types", lajixinxi.getLajixinxiTypes())
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        LajixinxiEntity lajixinxiEntity = lajixinxiService.selectOne(queryWrapper);
        if("".equals(lajixinxi.getLajixinxiPhoto()) || "null".equals(lajixinxi.getLajixinxiPhoto())){
                lajixinxi.setLajixinxiPhoto(null);
        }
        if(lajixinxiEntity==null){
            lajixinxiService.updateById(lajixinxi);//根据id更新
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }



    /**
    * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids){
        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
        lajixinxiService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }


    /**
     * 批量上传
     */
    @RequestMapping("/batchInsert")
    public R save( String fileName, HttpServletRequest request){
        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
        Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            List<LajixinxiEntity> lajixinxiList = new ArrayList<>();//上传的东西
            Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
            Date date = new Date();
            int lastIndexOf = fileName.lastIndexOf(".");
            if(lastIndexOf == -1){
                return R.error(511,"该文件没有后缀");
            }else{
                String suffix = fileName.substring(lastIndexOf);
                if(!".xls".equals(suffix)){
                    return R.error(511,"只支持后缀为xls的excel文件");
                }else{
                    URL resource = this.getClass().getClassLoader().getResource("../../upload/" + fileName);//获取文件路径
                    File file = new File(resource.getFile());
                    if(!file.exists()){
                        return R.error(511,"找不到上传文件，请联系管理员");
                    }else{
                        List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
                        dataList.remove(0);//删除第一行，因为第一行是提示
                        for(List<String> data:dataList){
                            //循环
                            LajixinxiEntity lajixinxiEntity = new LajixinxiEntity();
//                            lajixinxiEntity.setLajixinxiName(data.get(0));                    //垃圾名称 要改的
//                            lajixinxiEntity.setLajixinxiPhoto("");//详情和图片
//                            lajixinxiEntity.setLajixinxiTypes(Integer.valueOf(data.get(0)));   //垃圾类型 要改的
//                            lajixinxiEntity.setLajixinxiContent("");//详情和图片
//                            lajixinxiEntity.setInsertTime(date);//时间
//                            lajixinxiEntity.setCreateTime(date);//时间
                            lajixinxiList.add(lajixinxiEntity);


                            //把要查询是否重复的字段放入map中
                        }

                        //查询是否重复
                        lajixinxiService.insertBatch(lajixinxiList);
                        return R.ok();
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            return R.error(511,"批量插入数据异常，请联系管理员");
        }
    }





    /**
    * 前端列表
    */
    @IgnoreAuth
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));

        // 没有指定排序字段就默认id倒序
        if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
            params.put("orderBy","id");
        }
        PageUtils page = lajixinxiService.queryPage(params);

        //字典表数据转换
        List<LajixinxiView> list =(List<LajixinxiView>)page.getList();
        for(LajixinxiView c:list)
            dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
        return R.ok().put("data", page);
    }

    /**
    * 前端详情
    */
    @RequestMapping("/detail/{id}")
    public R detail(@PathVariable("id") Long id, HttpServletRequest request){
        logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        LajixinxiEntity lajixinxi = lajixinxiService.selectById(id);
            if(lajixinxi !=null){


                //entity转view
                LajixinxiView view = new LajixinxiView();
                BeanUtils.copyProperties( lajixinxi , view );//把实体数据重构到view中

                //修改对应字典表字段
                dictionaryService.dictionaryConvert(view, request);
                return R.ok().put("data", view);
            }else {
                return R.error(511,"查不到数据");
            }
    }


    /**
    * 前端保存
    */
    @RequestMapping("/add")
    public R add(@RequestBody LajixinxiEntity lajixinxi, HttpServletRequest request){
        logger.debug("add方法:,,Controller:{},,lajixinxi:{}",this.getClass().getName(),lajixinxi.toString());
        Wrapper<LajixinxiEntity> queryWrapper = new EntityWrapper<LajixinxiEntity>()
            .eq("lajixinxi_name", lajixinxi.getLajixinxiName())
            .eq("lajixinxi_types", lajixinxi.getLajixinxiTypes())
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        LajixinxiEntity lajixinxiEntity = lajixinxiService.selectOne(queryWrapper);
        if(lajixinxiEntity==null){
            lajixinxi.setInsertTime(new Date());
            lajixinxi.setCreateTime(new Date());
        lajixinxiService.insert(lajixinxi);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }


}

论文参考

在这里插入图片描述
目录
目录 III
1 绪论 1
1.1 研究背景 1
1.2 目的和意义 1
1.3 论文结构安排 2
2 相关技术 3
2.1 uni app技术介绍 3
2.2 B/S结构介绍 3
2.3 MySQL数据库介绍 4
2.4 Java语言介绍 5
2.5 VUE框架介绍 5
2.6 Tomcat 服务器介绍 6
2.7 layui介绍 7
2.8 SSM框架介绍 7
3 系统分析 9
3.1 系统可行性分析 9
3.1.1 技术可行性分析 9
3.1.2 经济可行性分析 9
3.1.3 运行可行性分析 9
3.2 系统性能分析 10
3.2.1 易用性指标 10
3.2.2 可扩展性指标 10
3.2.3 健壮性指标 10
3.2.4 安全性指标 11
3.3 系统流程分析 11
3.3.1 操作流程分析 11
3.3.2 登录流程分析 12
3.3.3 信息添加流程分析 13
3.3.4 信息删除流程分析 14
4 系统设计 15
4.1 系统设计的原则 15
4.2 系统概要设计 16
4.3 系统功能结构设计 16
4.4 数据库设计 17
4.4.1 数据库E-R图设计 17
4.4.2 数据库表结构设计 19
5 系统实现 24
5.1 管理员功能介绍 24
5.1.1 管理员管理 24
5.1.2 视频类型管理 24
5.1.3 论坛管理 25
5.1.4 新闻类型管理 25
5.1.5 环保视频管理 26
5.1.6 环保知识管理 26
5.1.7 环保新闻管理 27
5.1.8 用户信息管理 27
5.2 用户功能介绍 28
5.2.1 首页 28
5.2.2 环保视频 29
5.2.3 垃圾信息 30
5.2.4 我的 31
6 系统测试 33
6.1 系统测试的特点 33
6.2 系统测试方法 33
6.3 系统功能测试 34
6.3.1 登录功能测试 34
6.3.2 修改密码功能测试 35
6.4 测试结果分析 36
结论 37
致谢 38
参考文献 39

标签：5.1,vue,java,微信,lajixinxi,request,import,return,页面
From： https://blog.csdn.net/qq_3306428634/article/details/141903038