基于java+ssm+jsp的生鲜配送系统

项目介绍

互联网发展至今，无论是其理论还是技术都已经成熟，而且它广泛参与在社会中的方方面面。它让信息都可以通过网络传播，搭配信息管理工具可以很好地为人们提供服务。针对生鲜配送信息管理混乱，出错率高，信息安全性差，劳动强度大，费时费力等问题，采用生鲜配送系统可以有效管理，使信息管理能够更加科学和规范。

生鲜配送系统在idea环境中，使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理员管理商品，商品评价，积分记录，用户购物订单。用户收藏商品，评价商品，购买商品，支付购买订单，管理收货地址。

总之，生鲜配送系统集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。

4.2 功能结构设计
在前面分析的管理员功能的基础上，进行接下来的设计工作，最终展示设计的管理员结构图（见下图）。管理员管理商品，商品评价，积分记录，用户购物订单。

在前面分析的用户功能的基础上，进行接下来的设计工作，最终展示设计的用户结构图（见下图）。用户收藏商品，评价商品，购买商品，支付购买订单，管理收货地址。

开发环境

编程语言：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 商品信息管理页面

管理员可以查询商品的信息列表，实现代码如下所示：
/**

• 后端列表
  */
  @RequestMapping(“/page”)
  public R page(@RequestParam Map<String, Object> params,ShangpinxinxiEntity shangpinxinxi,
  HttpServletRequest request){

  EntityWrapper ew = new EntityWrapper();
  PageUtils page = shangpinxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinxinxi), params), params));
  return R.ok().put(“data”, page);
  }
  前端页面向后台控制器发送了一个查询商品信息的ajax的GET请求,请求的名为/shangpinxinxi/page，并传输过来要查询的条件，封装到后台中定义的params中，params中的key就是字段名，value就是条件，之后调用shangpinxinxiService类中的queryPage方法，查询出来数据返回给前端。
  5.1.2 用户管理
  管理员进入指定功能操作区之后可以管理用户信息。其页面见下图。管理员查看用户账户余额，可以修改用户的联系电话，电子邮箱等信息，在本页面也能删除指定的用户资料。
  

图5.2 用户管理页面

新增用户：
/**
* 后端保存
*/
@RequestMapping(“/save”)
public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
yonghu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(yonghu);
YonghuEntity user = yonghuService.selectOne(new EntityWrapper().eq(“yonghuzhanghao”, yonghu.getYonghuzhanghao()));
if(user!=null) {
return R.error(“用户已存在”);
}

	yonghu.setId(new Date().getTime());
    yonghuService.insert(yonghu);
    return R.ok();
}

前端页面向后台控制器发送了一个新增用户的POST请求,请求的名为/yonghu/save，把用户信息封装在后台定义的yonghu对象中，由于id是唯一的，不允许重复，所以取当前时间的毫秒数加上随机出来的整数作为id，保证唯一性，通过mybatis的selectOne方法，查询账户是否存在，存在就返回错误信息，用户已存在，不存在就调用mybatis-plus的insert方法，把用户数据新增到数据库中。

5.1.3 新闻资讯
管理员进入指定功能操作区之后可以管理新闻资讯信息。其页面见下图。管理员负责新闻资讯的发布，在本页面可以对新闻资讯的内容或图片等信息进行修改，或者是删除指定的新闻资讯。
在这里插入图片描述

图5.3 新闻资讯页面

修改新闻资讯：
/**
* 修改
*/
@RequestMapping(“/update”)
public R update(@RequestBody NewsEntity news, HttpServletRequest request){
//ValidatorUtils.validateEntity(news);
newsService.updateById(news);//全部更新
return R.ok();
}
前端页面向后台控制器发送了一个修改新闻的POST请求,请求的名为/new/update，把新闻资讯信息封装在后台定义的news对象中，通过mybatis的update
ById方法通过id把新闻资讯数据更改，更新完成后返回更新完成给前端，进行页面展示和跳转。

5.1.4 积分记录
管理员进入指定功能操作区之后管理积分记录。其页面见下图。管理员查询积分记录，查看用户的积分记录明细，包括添加的积分与使用的积分信息。

图5.4 积分记录页面

管理员可以查询积分记录的信息列表，实现代码如下所示：
/**
* 后端列表
*/
@RequestMapping(“/page”)
public R page(@RequestParam Map<String, Object> params,JifenjiluEntity jifenjilu, HttpServletRequest request){
if(!request.getSession().getAttribute(“role”).toString().equals(“管理员”)) {
params.put(“yonghuId”,request.getSession().getAttribute(“userId”));
}
PageUtils page= jifenjiluService.queryPage1(params);
return R.ok().put(“data”, page);
}
前端页面向后台控制器发送了一个查询积分记录信息的ajax的GET请求,请求的名为/jifenjilu/page，并传输过来要查询的条件，封装到后台中定义的params中，params中的key就是字段名，value就是条件，里面有条数，第几页，排序字段，用户姓名，联系电话等查询条件，之后调用jifenjiluService类中的queryPage方法，查询出来数据返回给前端进行展示。
5.1.5 商品评价管理
管理员进入指定功能操作区之后可以管理商品评价信息，其页面见下图。管理员根据评论的内容查询用户对商品的评价，在本页面，管理员可以删除指定的商品评价信息。

图5.5 商品评价管理页面

商品评价回复功能：
/**
* 修改
*/
@RequestMapping(“/update”)
public R update(@RequestBody DiscussshangpinxinxiEntity discussshangpinxinxi, HttpServletRequest request){
//ValidatorUtils.validateEntity(discussshangpinxinxi);
discussshangpinxinxiService.updateById(discussshangpinxinxi);//全部更新
return R.ok();
}
前端页面向后台控制器发送了一个商品评价的POST请求,请求的名为/discussshangpinxinxi/update，把回复信息封装在后台定义的discussshangpinxinxi对象中，通过mybatis的updateById方法通过id把回复信息修改进数据库中，更新完成后返回更新完成给前端，进行页面展示和跳转。

5.1.6 已支付订单
管理员进入指定功能操作区之后可以管理已支付订单。其页面见下图。管理员查看订单的收货地址信息，然后针对各个订单进行发货。

图5.6 已支付订单页面

查询已支付订单的信息列表，实现代码如下所示：
/**
* 后端列表
*/
@RequestMapping(“/page”)
public R page(@RequestParam Map<String, Object> params,OrdersEntity orders, HttpServletRequest request){
if(!request.getSession().getAttribute(“role”).toString().equals(“管理员”)) {
orders.setUserid((Long)request.getSession().getAttribute(“userId”));
}
PageUtils page=null;
if(“已完成”.equals(orders.getStatus())){
params.put(“status”,orders.getStatus());
// params.put(“userid”,orders.getStatus());
page= ordersService.queryPage1(params);
}else{
EntityWrapper ew = new EntityWrapper();
page = ordersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, orders), params), params));
request.setAttribute(“data”, page);
}
return R.ok().put(“data”, page);
}
前端页面向后台控制器发送了一个查询已支付订单信息的ajax的GET请求,请求的名为/orders/page，并传输过来要查询的条件，封装到后台中定义的params中，params中的key就是字段名，value就是条件，里面有条数，第几页，排序字段等查询条件，如果是管理员，就查询全部的，如果是用户的话，就把用户的id塞入查询条件中，只能查询自己的，如果是已完成订单的话，要级联查询售后表，所以单独提出来查询ordersService的queryPage1方法，如果不是已完成订单的话，调用ordersService类中的queryPage方法，查询出来数据返回给前端进行展示。

5.2 用户功能实现
5.2.1 商品信息
用户进入指定功能操作区之后可以查看商品信息。其页面见下图。用户在当前页面除了查看商品详情之外，也能收藏商品，对商品进行评价，或把商品添加进入购物车，也能选择直接购买商品。

图5.7 商品信息页面

商品查询：
/**
* 前端详情
*/
@IgnoreAuth
@RequestMapping(“/detail/{id}”)
public R detail(@PathVariable(“id”) String id){
ShangpinxinxiEntity shangpinxinxi = shangpinxinxiService.selectById(id);
shangpinxinxi.setClicknum(shangpinxinxi.getClicknum()+1);
shangpinxinxi.setClicktime(new Date());
shangpinxinxiService.updateById(shangpinxinxi);
return R.ok().put(“data”, shangpinxinxi);
}
前端页面向后台控制器发送了一个查询商品的get请求,请求的名为/shangpinxinxi/detail/{id}，把商品的id传入后台的id对象中，然后通过mybatis-plus的selectById方法，通过id把数据查询出来，设置点击次数加1，最近点击时间设置为当前时间，更新点击次数和最近点击时间两个字段的数据更新数据库中，然后把商品信息返回给前台，进行展示。
5.2.2 购物车
用户进入指定功能操作区之后可以管理购物车信息。其页面见下图。购物车专门用来保存用户打算购买的商品的信息，用户在本页面除了修改商品购买数量，删除购买商品之外，也能选择购买购物车保存的商品。

图5.8 购物车页面

用户可以查询到当前用户的购物车中的商品信息，实现代码如下所示：
/**
* 前端列表
*/
@RequestMapping(“/list”)
public R list(@RequestParam Map<String, Object> params,CartEntity cart, HttpServletRequest request){
EntityWrapper ew = new EntityWrapper();
PageUtils page = cartService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, cart), params), params));
request.setAttribute(“data”, page);
return R.ok().put(“data”, page);
}
前端页面向后台控制器发送了一个查询购物车中商品的ajax的GET请求,请求的名为/cart/list，并传输过来要查询的条件，封装到后台中定义的params中，params中的key就是字段名，value就是条件，里面有条数，第几页，排序字段，当前用户的id等查询条件，之后调用cartService类中的queryPage方法，查询出当前用户的购物车的所有商品，然后返回给前台，进行页面展示。

5.2.3 在线下单
用户进入指定功能操作区之后可以对需要购买的商品提交订单。其页面见下图。用户检查购买的商品信息，对收货地址进行选择，然后点击支付按钮即可支付订单。

图5.9 在线下单页面

用户可以查询到当前用户的购物车中的商品信息，实现代码如下所示：
payClick() {
console.log(‘payClick’)
var index = layui.jquery(‘input[name=address]:checked’).val();
console.log(index);
if (!index) {
layui.layer.msg(‘请选择收货地址’, {
time: 2000,
icon: 5
});
return
}

// 生成订单
for (let item of this.dataList) {

	// 获取商品详情信息
	layui.http.request(`${item.tablename}/info/${item.goodid}`, 'get', {}, (res) => {
		// 订单编号
		debugger
		var orderId = genTradeNo();
		let data = res.data;
		// 减少库存
		data.shuliang = data.shuliang - item.buynumber;
		// 更新库存信息
		layui.http.requestJson(`${item.tablename}/update`, 'post', data, (res) => {
			// 添加订单信息
			let order = {
				orderid: orderId,
				tablename: item.tablename,
				userid: this.user.id,
				goodid: item.goodid,
				goodname: item.goodname,
				picture: item.picture,
				buynumber: item.buynumber,
				discountprice: item.discountprice,
				price: item.price,
				total: item.price * item.buynumber,
				discounttotal: item.discountprice * item.buynumber,
				type: 1,
				address: this.addressList[index].address,
				status: '未支付'
			}
			layui.http.requestJson(`orders/add`, 'post', order, (res) => {
				// 减少余额，更新订单状态
				// 判断余额是否充足
				if (this.user.money < this.totalPrice) {
					layui.layer.msg('余额不足，请先充值', {
						time: 2000,
						icon: 5
					});
					return
				}
				// 如果该商品存在积分
				var date = new Date();
				var dateformat = date.getFullYear() + '-' + (date.getMonth() + 1) + '-' + date.getDate() + ' ' + date.getHours() + ':' + date.getMinutes() + ':' + date.getSeconds();
				var s =Number(this.shiyongJifen);
				if(s !=0){// 使用积分不为0
					let jifenjilu = {
						yonghuId: this.user.id,
						shangpinxinxiId:item.goodid,
						jifenjiluTypes:"使用",
						buynumber:this.shiyongJifen,
						insertTime:dateformat
					}
					layui.http.requestJson(`jifenjilu/add`, 'post', jifenjilu, (res) => {});
				}
				var a = Number(this.user.jifen)-s;
				if (data.jifen) {
					debugger
					// this.user.jifen = Number(this.user.jifen) + Number(data.jifen * item.buynumber);
					//用户积分-这次使用的积分+这次订单的积分
					a+=Number(data.jifen * item.buynumber);
					let jifenjilu = {
						yonghuId: this.user.id,
						shangpinxinxiId:item.goodid,
						jifenjiluTypes:"添加",
						buynumber:Number(data.jifen * item.buynumber),
						insertTime:dateformat
					}
					layui.http.requestJson(`jifenjilu/add`, 'post', jifenjilu, (res) => {});
				}
				this.user.jifen=a;
				this.user.money = this.user.money - this.totalPrice;
				// 更新用户余额
				layui.http.requestJson(`${localStorage.getItem("userTable")}/update`, 'post', this.user, (res) => {
					order.status = '已支付'
					layui.http.request(`orders/list`, 'get', {
						orderid: orderId,
						page: 1,
						limit: 1,
					}, (res) => {
						order.id = res.data.list[0].id;
						layui.http.requestJson(`orders/update`, 'post', order, (res) => {
							// 删除购物车数据(如果是购物车下单)
							if (item.id) {
								layui.http.requestJson(`cart/delete`, 'post', [item.id], (res) => {});
							}
							layui.layer.msg('购买成功', {
								time: 2000,
								icon: 6
							}, function() {
								window.location.href='../order/list.jsp'
							});
						});
					});
				});
			})
		})
	});
}

},
点击支付按钮，会调用payClick方法，进行支付操作，先获取收货地址是否被选择，选择了进入下一步，没选择就提示，请选择收货地址，然后获取当前所有商品的信息，把库存减去，添加订单信息，减少余额（如果余额够，就减去余额，如果余额不够就把该订单设置为未支付），如果有积分，就把当前商品的积分加给用户，把订单给新增到数据库中，把余额给更改到数据库中，执行完成后把购物车中的信息给清空。

5.2.4 已支付订单
用户进入指定功能操作区之后可以查看已支付订单。其页面见下图。用户在已支付订单模块查看订单明细，核对订单的收货地址以及购买的商品信息，用户在本页面可以点击退款按钮进行订单退款。

图5.10 已支付订单页面

查询已支付订单的信息列表，实现代码如下所示：
/**
* 后端列表
*/
@RequestMapping(“/page”)
public R page(@RequestParam Map<String, Object> params,OrdersEntity orders, HttpServletRequest request){
if(!request.getSession().getAttribute(“role”).toString().equals(“管理员”)) {
orders.setUserid((Long)request.getSession().getAttribute(“userId”));
}
PageUtils page=null;
if(“已完成”.equals(orders.getStatus())){
params.put(“status”,orders.getStatus());
// params.put(“userid”,orders.getStatus());
page= ordersService.queryPage1(params);
}else{
EntityWrapper ew = new EntityWrapper();
page = ordersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, orders), params), params));
request.setAttribute(“data”, page);
}
return R.ok().put(“data”, page);
}
前端页面向后台控制器发送了一个查询已支付订单信息的ajax的GET请求,请求的名为/orders/page，并传输过来要查询的条件，封装到后台中定义的params中，params中的key就是字段名，value就是条件，里面有条数，第几页，排序字段等查询条件，如果是管理员，就查询全部的，如果是用户的话，就把用户的id塞入查询条件中，只能查询自己的，如果是已完成订单的话，要级联查询售后表，所以单独提出来查询ordersService的queryPage1方法，如果不是已完成订单的话，调用ordersService类中的queryPage方法，查询出来数据返回给前端进行展示。

5.2.5 我的地址
用户进入指定功能操作区之后可以管理收货地址。其页面见下图。用户在当前页面新增收货地址，对已存在的收货地址进行信息更改，也能删除不需要的收货地址信息。

图5.11 我的地址页面

查询我的地址列表，实现代码如下所示：
/**
* 后端列表
*/
@RequestMapping(“/page”)
public R page(@RequestParam Map<String, Object> params,AddressEntity address, HttpServletRequest request){
if(!request.getSession().getAttribute(“role”).toString().equals(“管理员”)) {
address.setUserid((Long)request.getSession().getAttribute(“userId”));
}

    EntityWrapper<AddressEntity> ew = new EntityWrapper<AddressEntity>();
	PageUtils page = addressService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, address), params), params));
	request.setAttribute("data", page);
    return R.ok().put("data", page);
}

前端页面向后台控制器发送了一个查询我的地址列表信息的ajax的GET请求,请求的名为/address/page，并传输过来要查询的条件，封装到后台中定义的params中，params中的key就是字段名，value就是条件，里面有条数，第几页，排序字段，当前用户的id等查询条件，通过addressService的queryPage方法，从service中把数据查询出来，然后返回给前端，进行展示。
5.2.6 新闻资讯
用户进入指定功能操作区之后可以查看新闻资讯信息。其页面见下图。用户查看新闻资讯的标题和图片，对感兴趣的新闻资讯进行其内容的详细查看。

图5.12 新闻资讯页面
查询新闻咨询列表，实现代码如下所示：
/**
* 前端列表
*/
@IgnoreAuth
@RequestMapping(“/list”)
public R list(@RequestParam Map<String, Object> params,NewsEntity news, HttpServletRequest request){
EntityWrapper ew = new EntityWrapper();
PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params));
request.setAttribute(“data”, page);
return R.ok().put(“data”, page);
}
前端页面向后台控制器发送了一个查询新闻咨询信息的ajax的GET请求,请求的名为/news/page，并传输过来要查询的条件，封装到后台中定义的params中，params中的key就是字段名，value就是条件，里面有条数，第几页，排序字段等查询条件，通过newsService的queryPage方法，从service中把数据查询出来，然后返回给前端，进行展示。

核心代码

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 com.entity.ShouhouEntity;
import com.service.ShouhouService;
import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
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.entity.view.OrdersView;

import com.service.OrdersService;
import com.service.TokenService;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.MPUtil;
import com.utils.CommonUtil;


/**
 * 订单
 * 后端接口
 * @author 
 * @email 
 * @date
 */
@RestController
@RequestMapping("/orders")
public class OrdersController {
    @Autowired
    private OrdersService ordersService;

    @Autowired
    private ShouhouService shouhouService;
    


    /**
     * 后端列表
     */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params,OrdersEntity orders, HttpServletRequest request){
    	if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
    		orders.setUserid((Long)request.getSession().getAttribute("userId"));
    	}
        PageUtils page=null;
        if("已完成".equals(orders.getStatus())){
            params.put("status",orders.getStatus());
//            params.put("userid",orders.getStatus());
            page= ordersService.queryPage1(params);
        }else{
            EntityWrapper<OrdersEntity> ew = new EntityWrapper<OrdersEntity>();
            page = ordersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, orders), params), params));
            request.setAttribute("data", page);
        }
        return R.ok().put("data", page);
    }
    
    /**
     * 前端列表
     */
    @RequestMapping("st")
    public R list(@RequestParam Map<String, Object> params,OrdersEntity orders, HttpServletRequest request){
        PageUtils page=null;
        if("已完成".equals(orders.getStatus())){
            params.put("status",orders.getStatus());
            page= ordersService.queryPage1(params);
        }else{
            EntityWrapper<OrdersEntity> ew = new EntityWrapper<OrdersEntity>();
            page = ordersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, orders), params), params));
            request.setAttribute("data", page);
        }
        return R.ok().put("data", page);
    }

	/**
     * 列表
     */
    @RequestMapping("sts")
    public R list( OrdersEntity orders){
       	EntityWrapper<OrdersEntity> ew = new EntityWrapper<OrdersEntity>();
      	ew.allEq(MPUtil.allEQMapPre( orders, "orders")); 
        return R.ok().put("data", ordersService.selectListView(ew));
    }

	 /**
     * 查询
     */
    @RequestMapping("/query")
    public R query(OrdersEntity orders){
        EntityWrapper< OrdersEntity> ew = new EntityWrapper< OrdersEntity>();
 		ew.allEq(MPUtil.allEQMapPre( orders, "orders")); 
		OrdersView ordersView =  ordersService.selectView(ew);
		return R.ok("查询订单成功").put("data", ordersView);
    }
	
    /**
     * 后端详情
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") String id){
        OrdersEntity orders = ordersService.selectById(id);
        if(orders!= null && "已完成".equals(orders.getStatus())){
            EntityWrapper<ShouhouEntity> wrapper = new EntityWrapper<>();
            wrapper.eq("orderid",orders.getOrderid());
            ShouhouEntity s = shouhouService.selectOne(wrapper);
            BeanUtils.copyProperties(orders, s,new String[]{"id","addtime"});
        }
        return R.ok().put("data", orders);
    }

    /**
     * 前端详情
     */
    @RequestMapping("/detail/{id}")
    public R detail(@PathVariable("id") String id){
        OrdersEntity orders = ordersService.selectById(id);
        if(orders!= null && "已完成".equals(orders.getStatus())){
            EntityWrapper<ShouhouEntity> wrapper = new EntityWrapper<>();
            wrapper.eq("orderid",orders.getOrderid());
            ShouhouEntity s = shouhouService.selectOne(wrapper);
            BeanUtils.copyProperties(orders, s,new String[]{"id","addtime"});
        }
        return R.ok().put("data", orders);
    }
    



    /**
     * 后端保存
     */
    @RequestMapping("ve")
    public R save(@RequestBody OrdersEntity orders, HttpServletRequest request){
    	orders.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
    	//ValidatorUtils.validateEntity(orders);
    	orders.setUserid((Long)request.getSession().getAttribute("userId"));

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

        ordersService.insert(orders);
        return R.ok();
    }

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

    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids){
        ordersService.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<OrdersEntity> wrapper = new EntityWrapper<OrdersEntity>();
		if(map.get("remindstart")!=null) {
			wrapper.ge(columnName, map.get("remindstart"));
		}
		if(map.get("remindend")!=null) {
			wrapper.le(columnName, map.get("remindend"));
		}
		if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
    		wrapper.eq("userid", (Long)request.getSession().getAttribute("userId"));
    	}


		int count = ordersService.selectCount(wrapper);
		return R.ok().put("count", count);
	}


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

//        PageUtils page=null;
//        if("已完成".equals(orders.getStatus())){
//            params.put("status",orders.getStatus());
//            page= ordersService.queryPage1(params);
//        }else{
//            EntityWrapper<OrdersEntity> ew = new EntityWrapper<OrdersEntity>();
//            page = ordersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, orders), params), params));
//            request.setAttribute("data", page);
//        }
        List<Map<String, Object>> result = ordersService.graph();
        return R.ok().put("data", result);
    }




}

论文参考

目 录
第1章 绪论 1
1.1 课题背景 1
1.2 课题意义 1
1.3 研究内容 2
第2章 开发环境与技术 3
2.1 MYSQL数据库 3
2.2 Java语言 3
2.3 JSP技术 4
2.4 SSM框架 4
2.5 B/S架构 5
2.6 Tomcat 介绍 5
第3章 系统分析 7
3.1 可行性分析 7
3.1.1 技术可行性 7
3.1.2 经济可行性 7
3.1.3 操作可行性 7
3.2 系统流程 8
3.2.1 操作流程 8
3.2.2 登录流程 8
3.2.3 删除信息流程 9
3.2.4 添加信息流程 10
3.3 性能需求 10
3.4 功能需求 11
第4章 系统设计 14
4.1 设计原则 14
4.2 功能结构设计 15
4.3 数据库设计 16
4.3.1 数据库概念设计 16
4.3.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.2 用户功能实现 27
5.2.1 商品信息 27
5.2.2 购物车 28
5.2.3 在线下单 29
5.2.4 已支付订单 30
5.2.5 我的地址 30
5.2.6 新闻资讯 31
第6章 系统测试 32
6.1 测试的任务  32
6.2 测试的目标  32
6.3 测试方案  33
6.4 功能测试 34
6.4.1 登录功能测试 35
6.4.2 修改密码功能测试 35
6.5 测试结果 36
结 论 37
致 谢 38
参考文献 39