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

最新推荐文章于 2024-08-26 21:41:10 发布

q_1394918164

最新推荐文章于 2024-08-26 21:41:10 发布

阅读量746

点赞数 21

分类专栏：微信小程序文章标签： java 微信小程序 ssm vue mysql

本文链接：https://blog.csdn.net/qzf2538760199/article/details/139993138

版权

微信小程序专栏收录该内容

100 篇文章 0 订阅

订阅专栏

🙊作者简介：多年编程开发经验，专注java技术领域和毕业设计项目实战，系统定制、远程部署调试、代码讲解、代码修改
🍅擅长语言：springboot、ssm、vue、html、jsp、php、python、爬虫、小程序、安卓app
⬇️源码获取：文末可以获取源码+数据库+文档

⚡感兴趣的可以先收藏+关注，后续会更新更多项目资料，所有项目均配有开发文档和安装配置教程

系统介绍

现代经济快节奏发展以及不断完善升级的信息化技术，让传统数据信息的管理升级为软件存储，归纳，集中处理数据信息的管理方式。本垃圾分类小程序就是在这样的大环境下诞生，其可以帮助管理者在短时间内处理完毕庞大的数据信息，使用这种软件工具可以帮助管理人员提高事务处理效率，达到事半功倍的效果。此垃圾分类小程序使用跨平台的可开发大型商业网站的HTML技术，以及最受欢迎的RDBMS应用软件之一的MySQL数据库进行程序开发，后台采用Java语言的SSM框架，前台采用VUE框架和layui样式，垃圾分类小程序端实现页面基本用uni app框架写作。

垃圾分类小程序管理员功能有个人中心，管理员管理，意见反馈管理，视频类型管理，垃圾类型管理，新闻类型管理，论坛信息管理，环保视频管理，环保知识管理，垃圾信息管理，环保新闻管理，用户管理，知识问答试卷管理，试题管理，测试管理，轮播图管理。用户可以在微信小程序上面注册登录，查看各种环保信息和垃圾信息，还可以参加知识问答等操作。垃圾分类小程序的开发根据操作人员需要设计的界面简洁美观，在功能模块布局上跟同类型网站保持一致，程序在实现基本要求功能时，也为数据信息面临的安全问题提供了一些实用的解决方案。可以说该程序在帮助管理者高效率地处理工作事务的同时，也实现了数据信息的整体化，规范化与自动化。

系统主要技术

开发语言：Java

使用框架：SSM

系统架构：B/S

前端技术：Vue、JavaScript

数据库：Mysql 5.7/8.0

编译工具：idea或者eclipse，jdk1.8，maven

系统功能结构设计

在分析并得出使用者对程序的功能要求时，就可以进行程序设计了。如图4.2展示的就是管理员功能结构图，管理员功能有个人中心，管理员管理，濒危生物管理，地区管理，环保健康类型管理，保护法类型管理，公告类型管理，论坛管理，环保健康管理，环境保护管理，环境保护法管理，公告信息管理，轮播图管理。用户可以注册登录，修改个人信息，查看管理员发布的各种信息还可以留言，可以对濒危生物收藏，环保健康收藏，环境保护收藏等操作。

图4.2 管理员功能结构图

系统功能实现

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.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,"表中有相同数据");
        }
    }


}