基于java+ssm+vue的校园订餐微信小程序

q_1394918164

于 2024-08-09 12:07:14 发布

阅读量972

点赞数 27

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

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

版权

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

100 篇文章 0 订阅

订阅专栏

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

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

系统介绍

人民生活水平的提高就会造成生活节奏越来越快，很多人吃饭都采用点外卖的方式。现在点外卖的平台已有很多，大多都需要安装它们的APP才可以使用，并且没有针对校园。如果一味的使用外卖平台不仅会造成商家成本的增加，还不利于商家校园订单的配送。开发基于微信小程序的校园订餐系统可以解决这些问题，实现借助微信就可以点餐。

本基于微信小程序校园订餐系统采用Java语言和Mysql数据库进行设计，技术采用微信小程序，可以不安装App软件就实现订餐。本系统实现管理员和用户、商家三个角色的功能。用户主要在微信端操作，内容有美食信息、网站公告信息、用户可以在线充值进行美食的订餐以及管理购物车和咨询客服。商家可以发布美食和管理订单。管理员可以发布公告和审核美食以及管理订单等。本系统可以实现校园的订餐，帮助商家更好的销售餐品。

系统主要技术

开发语言：Java

使用框架：SSM

系统架构：B/S

前端技术：Vue、JavaScript

数据库：Mysql 5.7/8.0

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

系统功能结构设计

本系统的功能结构为用户界面、管理员界面和商家界面，不同角色负责的功能不同，对系统的功能设计采用系统功能结构图进行展示。本系统的功能结构图如下图4.1所示：

图4.1系统功能结构图

系统功能实现

5.1用户登录功能的界面实现

本系统中可以保证安全的功能就是用户登录功能，登录可以验证用户的身份，用户可以注册，当密码忘记后也可以通过忘记密码功能进行找回。在用户登录界面里采用上中下的方式进行设计。在上设计的是功能的名称，在中设计的是账号和密码的输入框，在下设计的是用户注册和忘记密码功能。用户登录功能的实现界面如下图5.1所示：

图5.1用户登录功能的实现界面

5.2用户注册功能的实现界面

本功能设计的目的是帮助游客在线订餐。在注册时需要设置账号和密码。用户注册功能的实现界面如下图5.2所示：

图5.2用户注册功能的实现界面

5.3首页功能的设计实现

用户登录后可进入首页，在首页里可以看到公告信息和美食信息，可以进行美食搜索和进入购物车、我的界面。首页功能的实现界面如下图5.3所示：

图5.3首页界面的实现

5.3.1用户信息管理功能的实现界面

用户可以修改自己注册时填写的资料，可以设置头像以及是否为会员。用户信息管理功能的实现界面如下图5.4所示：

图5.4用户信息管理功能的实现界面

5.3.2特色美食功能的实现界面

用户可以浏览美食信息，也可以根据美食的名称进行搜索，美食信息可以看到图片和价格，特色美食信息的实现界面如下图5.5所示：

图5.5特色美食功能的实现界面

5.3.3网站公告功能的实现界面

用户可以在前台浏览网站公告内容，也可以搜索网站公告内容。网站公告功能的实现界面如下图5.6所示：

图5.6网站公告功能的实现界面

5.3.4立即订购功能的实现界面

用户在前台选择喜欢的美食后可以立即订购，在订购时需要选择地址，立即订购功能的实现界面如下图5.7所示：

图5.7立即订购功能的实现界面

5.3.5我的功能的实现界面

在我的功能里，用户可以管理订单信息，进行在线充值以及咨询客服和管理购物车信息。我的功能实现界面如下图5.8所示：

图5.8我的功能实现界面

5.4商家权限的功能实现

商家可以管理美食信息和订单信息，可以为用户配送。商家权限的功能实现界面如下图5.9所示：

图5.9商家权限功能的实现界面

5.5管理员权限的功能实现

管理员可以管理美食类型、美食信息、订单信息、用户信息、商家信息、公告信息等。管理员权限的功能实现界面如下图5.10所示：

图5.10管理员权限的功能实现界面

论文参考

核心代码

package com.controller;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable;
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.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth;
import com.entity.OrdersEntity;
import com.service.OrdersService;

import com.entity.TesemeishiEntity;
import com.entity.view.TesemeishiView;

import com.service.TesemeishiService;
import com.service.TokenService;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.CommonUtil;
import com.service.StoreupService;
import com.entity.StoreupEntity;

/**
 * 特色美食
 * 后端接口
 * @author 
 * @email 
 * @date 
 */
@RestController
@RequestMapping("/tesemeishi")
public class TesemeishiController {
    @Autowired
    private TesemeishiService tesemeishiService;


    @Autowired
    private StoreupService storeupService;

    @Autowired
    private OrdersService ordersService;
    


    /**
     * 后端列表
     */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params,TesemeishiEntity tesemeishi, 
		HttpServletRequest request){

		String tableName = request.getSession().getAttribute("tableName").toString();
		if(tableName.equals("shangjia")) {
			tesemeishi.setShangjiamingcheng((String)request.getSession().getAttribute("username"));
		}
        EntityWrapper<TesemeishiEntity> ew = new EntityWrapper<TesemeishiEntity>();
		PageUtils page = tesemeishiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, tesemeishi), params), params));
        return R.ok().put("data", page);
    }
    
    /**
     * 前端列表
     */
	@IgnoreAuth
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params,TesemeishiEntity tesemeishi, 
		HttpServletRequest request){
        EntityWrapper<TesemeishiEntity> ew = new EntityWrapper<TesemeishiEntity>();
		PageUtils page = tesemeishiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, tesemeishi), params), params));
        return R.ok().put("data", page);
    }

	/**
     * 列表
     */
    @RequestMapping("/lists")
    public R list( TesemeishiEntity tesemeishi){
       	EntityWrapper<TesemeishiEntity> ew = new EntityWrapper<TesemeishiEntity>();
      	ew.allEq(MPUtil.allEQMapPre( tesemeishi, "tesemeishi")); 
        return R.ok().put("data", tesemeishiService.selectListView(ew));
    }

	 /**
     * 查询
     */
    @RequestMapping("/query")
    public R query(TesemeishiEntity tesemeishi){
        EntityWrapper< TesemeishiEntity> ew = new EntityWrapper< TesemeishiEntity>();
 		ew.allEq(MPUtil.allEQMapPre( tesemeishi, "tesemeishi")); 
		TesemeishiView tesemeishiView =  tesemeishiService.selectView(ew);
		return R.ok("查询特色美食成功").put("data", tesemeishiView);
    }
	
    /**
     * 后端详情
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id){
        TesemeishiEntity tesemeishi = tesemeishiService.selectById(id);
		tesemeishi.setClicknum(tesemeishi.getClicknum()+1);
		tesemeishi.setClicktime(new Date());
		tesemeishiService.updateById(tesemeishi);
        return R.ok().put("data", tesemeishi);
    }

    /**
     * 前端详情
     */
	@IgnoreAuth
    @RequestMapping("/detail/{id}")
    public R detail(@PathVariable("id") Long id){
        TesemeishiEntity tesemeishi = tesemeishiService.selectById(id);
		tesemeishi.setClicknum(tesemeishi.getClicknum()+1);
		tesemeishi.setClicktime(new Date());
		tesemeishiService.updateById(tesemeishi);
        return R.ok().put("data", tesemeishi);
    }
    


    /**
     * 赞或踩
     */
    @RequestMapping("/thumbsup/{id}")
    public R thumbsup(@PathVariable("id") String id,String type){
        TesemeishiEntity tesemeishi = tesemeishiService.selectById(id);
        if(type.equals("1")) {
        	tesemeishi.setThumbsupnum(tesemeishi.getThumbsupnum()+1);
        } else {
        	tesemeishi.setCrazilynum(tesemeishi.getCrazilynum()+1);
        }
        tesemeishiService.updateById(tesemeishi);
        return R.ok();
    }

    /**
     * 后端保存
     */
    @RequestMapping("/save")
    public R save(@RequestBody TesemeishiEntity tesemeishi, HttpServletRequest request){
    	tesemeishi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
    	//ValidatorUtils.validateEntity(tesemeishi);

        tesemeishiService.insert(tesemeishi);
        return R.ok();
    }
    
    /**
     * 前端保存
     */
    @RequestMapping("/add")
    public R add(@RequestBody TesemeishiEntity tesemeishi, HttpServletRequest request){
    	tesemeishi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
    	//ValidatorUtils.validateEntity(tesemeishi);

        tesemeishiService.insert(tesemeishi);
        return R.ok();
    }

    /**
     * 修改
     */
    @RequestMapping("/update")
    public R update(@RequestBody TesemeishiEntity tesemeishi, HttpServletRequest request){
        //ValidatorUtils.validateEntity(tesemeishi);
        tesemeishiService.updateById(tesemeishi);//全部更新
        return R.ok();
    }
    

    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids){
        tesemeishiService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }
    
    /**
     * 提醒接口
     */
	@RequestMapping("/remind/{columnName}/{type}")
	public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, 
						 @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
		map.put("column", columnName);
		map.put("type", type);
		
		if(type.equals("2")) {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Calendar c = Calendar.getInstance();
			Date remindStartDate = null;
			Date remindEndDate = null;
			if(map.get("remindstart")!=null) {
				Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
				c.setTime(new Date()); 
				c.add(Calendar.DAY_OF_MONTH,remindStart);
				remindStartDate = c.getTime();
				map.put("remindstart", sdf.format(remindStartDate));
			}
			if(map.get("remindend")!=null) {
				Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
				c.setTime(new Date());
				c.add(Calendar.DAY_OF_MONTH,remindEnd);
				remindEndDate = c.getTime();
				map.put("remindend", sdf.format(remindEndDate));
			}
		}
		
		Wrapper<TesemeishiEntity> wrapper = new EntityWrapper<TesemeishiEntity>();
		if(map.get("remindstart")!=null) {
			wrapper.ge(columnName, map.get("remindstart"));
		}
		if(map.get("remindend")!=null) {
			wrapper.le(columnName, map.get("remindend"));
		}

		String tableName = request.getSession().getAttribute("tableName").toString();
		if(tableName.equals("shangjia")) {
			wrapper.eq("shangjiamingcheng", (String)request.getSession().getAttribute("username"));
		}

		int count = tesemeishiService.selectCount(wrapper);
		return R.ok().put("count", count);
	}
	
	/**
     * 前端智能排序
     */
	@IgnoreAuth
    @RequestMapping("/autoSort")
    public R autoSort(@RequestParam Map<String, Object> params,TesemeishiEntity tesemeishi, HttpServletRequest request,String pre){
        EntityWrapper<TesemeishiEntity> ew = new EntityWrapper<TesemeishiEntity>();
        Map<String, Object> newMap = new HashMap<String, Object>();
        Map<String, Object> param = new HashMap<String, Object>();
		Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
		while (it.hasNext()) {
			Map.Entry<String, Object> entry = it.next();
			String key = entry.getKey();
			String newKey = entry.getKey();
			if (pre.endsWith(".")) {
				newMap.put(pre + newKey, entry.getValue());
			} else if (StringUtils.isEmpty(pre)) {
				newMap.put(newKey, entry.getValue());
			} else {
				newMap.put(pre + "." + newKey, entry.getValue());
			}
		}
		params.put("sort", "clicknum");
        
        params.put("order", "desc");
		PageUtils page = tesemeishiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, tesemeishi), params), params));
        return R.ok().put("data", page);
    }


	/**
     * 协同算法（按用户购买推荐）
     */
    @RequestMapping("/autoSort2")
    public R autoSort2(@RequestParam Map<String, Object> params,TesemeishiEntity tesemeishi, HttpServletRequest request){
    	String userId = request.getSession().getAttribute("userId").toString();
    	String goodtypeColumn = "meishileixing";
    	List<OrdersEntity> orders = ordersService.selectList(new EntityWrapper<OrdersEntity>().eq("userid", userId).eq("tablename", "tesemeishi").orderBy("addtime", false));
        List<String> goodtypes = new ArrayList<String>();
    	Integer limit = params.get("limit")==null?10:Integer.parseInt(params.get("limit").toString());
    	List<TesemeishiEntity> tesemeishiList = new ArrayList<TesemeishiEntity>();
	//去重
    	List<OrdersEntity> ordersDist = new ArrayList<OrdersEntity>();
    	for(OrdersEntity o1 : orders) {
    		boolean addFlag = true;
    		for(OrdersEntity o2 : ordersDist) {
    			if(o1.getGoodid()==o2.getGoodid() || o1.getGoodtype().equals(o2.getGoodtype())) {
    				addFlag = false;
    				break;
    			}
    		}
    		if(addFlag) ordersDist.add(o1);
    	}
        if(ordersDist!=null && ordersDist.size()>0) {
        	for(OrdersEntity o : ordersDist) {
        		tesemeishiList.addAll(tesemeishiService.selectList(new EntityWrapper<TesemeishiEntity>().eq(goodtypeColumn, o.getGoodtype())));
        	}
        }
    	EntityWrapper<TesemeishiEntity> ew = new EntityWrapper<TesemeishiEntity>();
	params.put("sort", "id");
	params.put("order", "desc");
	PageUtils page = tesemeishiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, tesemeishi), params), params));
        List<TesemeishiEntity> pageList = (List<TesemeishiEntity>)page.getList();
        if(tesemeishiList.size()<limit) {
        	int toAddNum = (limit-tesemeishiList.size())<=pageList.size()?(limit-tesemeishiList.size()):pageList.size();
            for(TesemeishiEntity o1 : pageList) {
                boolean addFlag = true;
                for(TesemeishiEntity o2 : tesemeishiList) {
                    if(o1.getId().intValue()==o2.getId().intValue()) {
                        addFlag = false;
                        break;
                    }
                }
                if(addFlag) {
                    tesemeishiList.add(o1);
                    if(--toAddNum==0) break;
                }
            }
        }
        page.setList(tesemeishiList);
	return R.ok().put("data", page);
    }





}