• Java项目：SSM农产品朔源管理系统

    作者主页：夜未央5788

     简介：Java领域优质创作者、Java项目、学习资料、技术互助

    文末获取源码

    项目介绍

    本项目分为前后台，分为普通用户、管理员、企业用户三种角色；
    普通用户无需登录，可在前台直接进行溯源查询，管理员、企业用户可登录后台进行管理；

    超级管理员角色包含以下功能：

    登录,管理企业,设置管理员,增加管理员,删除管理员等功能。

    用户角色包含以下功能：
    用户首页,用户进行溯源查询,溯源结果等功能。

    企业角色包含以下功能：

    注册,登录,企业登录后主页,增删改查农产品列表,新增农产品,二维码列表查看,溯源列表,查看近期溯源人数,修改企业信息,查看溯源二维码等功能。

    环境需要

    1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。
    2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA;
    3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可
    4.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS； 

    5.数据库：MySql 5.7版本；

    6.是否Maven项目：是；

    技术栈

    1. 后端：Spring+SpringMVC+Mybatis

    2. 前端：JSP+CSS+JavaScript+LayUI+jQuery

    使用说明

    1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件；
    2. 使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven;
    若为maven项目，导入成功后请执行maven clean;maven install命令，然后运行；
    3. 将项目中database.properties配置文件中的数据库配置改为自己的配置;
    4. 运行项目，输入http://localhost:8080/ncpsy 登录 
    注：Tomcat中配置路径必须为/ncpsy 否则会有异常
    管理员账号/密码：admin/admin

    企业账号/密码：user/123456

    运行截图

    普通用户界面

     

    管理员用户界面

     

     

     

     

    企业用户界面

     

     

     

     

     

     

    代码相关

    农产品管理控制器

    1. @Controller
    2. @RequestMapping("/handle")
    3. public class NcpController {
    4.  
    5. 	protected Logger logger = LoggerFactory.getLogger(this.getClass());
    6. 	
    7. 	@Autowired
    8. 	private INcpService ncpService;
    9. 	
    10. 	@Autowired
    11. 	private IEwmService ewmService;
    12. 	
    13. 	/**
    14. 	 * 新增农产品(生成二维码数据，插入二维码表)
    15. 	 * @param ncp
    16. 	 * @return
    17. 	 */
    18. 	@RequestMapping("/product/add")
    19. 	@ResponseBody
    20. 	public boolean productAdd(@RequestBody Ncp ncp, HttpServletRequest request) {
    21. 		logger.info("/handle/product/add===> ncp={}", ncp);
    22. 		QueryWrapper queryWrapper = new QueryWrapper<>();
    23. 		
    24. 		//设置农产品id
    25. 		queryWrapper.eq("qyid", ncp.getQyid());
    26. 		int num = ncpService.count(queryWrapper) + 1;
    27. 		String ncpid = "ncp";
    28. 		while(ncp.getNcpid() == null) {
    29. 			if(num /10 == 0) {
    30. 				ncpid = ncpid.concat("00" + num);
    31. 			} else if(num / 10 >= 1 && num / 10 < 10) {
    32. 				ncpid = ncpid.concat("0" + num);
    33. 			} else {
    34. 				ncpid = ncpid.concat("" + num);
    35. 			}
    36. 			ncpid = ncpid.concat("-" + ncp.getQyid());
    37. 			//查询数据库是否存在相同的ncpid，存在则num+1，继续循环
    38. 			QueryWrapper ncpidQueryWrapper = new QueryWrapper<>();
    39. 			ncpidQueryWrapper.eq("ncpid", ncpid);
    40. 			int isExist = ncpService.count(ncpidQueryWrapper);
    41. 			if(isExist > 0) {
    42. 				num += 1;
    43. 				ncpid = "ncp";
    44. 				continue;
    45. 			} else {
    46. 				break;
    47. 			}
    48. 		}
    49. 		ncp.setNcpid(ncpid);
    50. 		
    51. 		//生成二维码id
    52. 		QueryWrapper ewmQueryWrapper = new QueryWrapper<>();
    53. 		ewmQueryWrapper.likeLeft("ewmid", ncp.getQyid());
    54. 		//int num2 = ewmService.count(ewmQueryWrapper) + 1;
    55. 		int num2 = num;
    56. 		String ewmid = "ewm";
    57. 		while(ncp.getEwmid() == null) {
    58. 			if(num2 /10 == 0) {
    59. 				ewmid = ewmid.concat("00" + num2);
    60. 			} else if(num2 / 10 >= 1 && num2 / 10 < 10) {
    61. 				ewmid = ewmid.concat("0" + num2);
    62. 			} else {
    63. 				ewmid = ewmid.concat("" + num2);
    64. 			}
    65. 			ewmid = ewmid.concat("-" + ncpid);
    66. 			//查询数据库是否存在相同的ewmid，存在则num+1，继续循环
    67. 			QueryWrapper ewmidQueryWrapper = new QueryWrapper<>();
    68. 			ewmidQueryWrapper.eq("ewmid", ewmid);
    69. 			int isExist = ewmService.count(ewmidQueryWrapper);
    70. 			if(isExist > 0) {
    71. 				num2 += 1;
    72. 				ewmid = "ewm";
    73. 				continue;
    74. 			} else {
    75. 				break;
    76. 			}
    77. 		}
    78. 		
    79. 		//获取服务器地址、端口、项目名
    80. 		HttpServletRequest httpRequest=(HttpServletRequest)request;
    81. 		String baseUrl = "http://" + request.getServerName() + ":" + request.getServerPort() + httpRequest.getContextPath();
    82.  
    83. 		//插入二维码表
    84. 		String ewmsj = baseUrl + "/info/product-info?ncpid=" + ncpid;
    85. 		Ewm ewm = new Ewm();
    86. 		ewm.setEwmid(ewmid);
    87. 		ewm.setEwmsj(ewmsj);
    88. 		boolean flag = ewmService.save(ewm);
    89. 		
    90. 		//如果二维码表插入成功，则插入ncp表
    91. 		//在插入农产品表的时候可能会出错导致插入失败，这样上面插入的二维码表字段就作废了，所以在这里catch紅酒表的错误，并把上面二维码表字段删除
    92. 		try {
    93. 			if(flag) {
    94. 				ncp.setEwmid(ewmid);
    95. 				boolean flag2 = ncpService.save(ncp);
    96. 				return flag2;
    97. 			} else {
    98. 				return flag;
    99. 			}
    100. 		} catch (Exception e) {
    101. 			ewmQueryWrapper.eq("ewmid", ewm.getEwmid());
    102. 			ewmService.remove(ewmQueryWrapper);
    103. 			e.printStackTrace();
    104. 			return false;
    105. 		}
    106. 	}
    107. 	
    108. 	/**
    109. 	 * 农产品列表
    110. 	 * @param ncp
    111. 	 * @param page
    112. 	 * @param limit
    113. 	 * @return
    114. 	 * @throws Exception
    115. 	 */
    116. 	@RequestMapping("/product/list")
    117. 	@ResponseBody
    118. 	public Map productList(Ncp ncp, @RequestParam int page, @RequestParam int limit) throws Exception {
    119. 		logger.info("/handle/product/list===> ncp={}", ncp);
    120. 		logger.info("page = {}", page);
    121. 		logger.info("limit = {}", limit);
    122. 		QueryWrapper ncpQueryWrapper = new QueryWrapper<>();
    123. 		//遍历ncp对象的属性
    124. 		Field field[] = ncp.getClass().getDeclaredFields();
    125. 		for(int i = 0; i < field.length; i++) {
    126. 			//获取属性名
    127. 			String name = field[i].getName();
    128. 			//将属性的首字符大写，方便构造get，set方法
    129. 			String getterName = name.substring(0,1).toUpperCase()+name.substring(1);
    130. 			//获取属性的类型
    131. 			String type = field[i].getGenericType().toString();
    132. 			//根据类型做操作
    133. 			if (type.equals("class java.lang.String")) {
    134. 				//获得getter方法
    135. 				Method m = ncp.getClass().getMethod("get" + getterName);
    136. 				//调用getter方法
    137. 				String value = (String) m.invoke(ncp);
    138. 				//如果非空，则加入查询条件
    139. 				if (value != null) {
    140. 					ncpQueryWrapper.eq(name, value);
    141. 				}
    142. 			}
    143. 		}
    144. 		List ncpList = ncpService.list(ncpQueryWrapper);
    145. 		logger.info("=========={}", ncpList);
    146. 		//查询到的总量，返回数据要用
    147. 		int count = ncpList.size();
    148. 		//list截取分页的索引
    149. 		int fromIndex = (page-1)*limit;
    150. 		int toIndex = page * limit;
    151. 		//截取分页数据
    152. 		if(page*limit > count) {
    153. 			toIndex = count;
    154. 		}
    155. 		ncpList = ncpList.subList(fromIndex, toIndex);
    156. 		
    157. 		Map response = new HashMap();
    158. 		response.put("code", 0);
    159. 		response.put("msg", "");
    160. 		response.put("count", count);
    161. 		response.put("data", ncpList);
    162. 		
    163. 		return response;
    164. 	}
    165. 	
    166. 	/**
    167. 	 * 获取农产品表一个数据
    168. 	 * @param ncp
    169. 	 * @return
    170. 	 */
    171. 	@RequestMapping("/product/getone")
    172. 	@ResponseBody
    173. 	public Ncp productGetone(@RequestBody Ncp ncp) {
    174. 		logger.info("/handle/product/getone===> ncp={}", ncp);
    175. 		QueryWrapper ncpQueryWrapper = new QueryWrapper<>();
    176. 		ncpQueryWrapper.eq("ncpid", ncp.getNcpid());
    177. 		ncp = ncpService.getOne(ncpQueryWrapper);
    178. 		return ncp;
    179. 	}
    180. 	
    181. 	@RequestMapping("/product/modify")
    182. 	@ResponseBody
    183. 	public boolean productModify(@RequestBody Ncp ncp) {
    184. 		logger.info("/handle/product/modify===> ncp={}", ncp);
    185. 		QueryWrapper ncpQueryWrapper = new QueryWrapper<>();
    186. 		ncpQueryWrapper.eq("ncpid", ncp.getNcpid());
    187. 		Ncp ncpEntity = ncpService.getOne(ncpQueryWrapper);
    188. 		ncp.setQyid(ncpEntity.getQyid());
    189. 		ncp.setEwmid(ncpEntity.getEwmid());
    190. 		UpdateWrapper ncpUpdateWrapper = new UpdateWrapper<>();
    191. 		ncpUpdateWrapper.eq("ncpid", ncp.getNcpid());
    192. 		boolean flag = ncpService.update(ncp, ncpUpdateWrapper);
    193. 		return flag;
    194. 	}
    195. 	
    196. 	/**
    197. 	 * 删除农产品
    198. 	 * @param ncp
    199. 	 * @return
    200. 	 */
    201. 	@RequestMapping("/product/delete")
    202. 	@ResponseBody
    203. 	public boolean productDelete(@RequestBody Ncp ncp) {
    204. 		logger.info("/handle/product/list===> ncp={}", ncp);
    205. 		QueryWrapper queryWrapper = new QueryWrapper<>();
    206. 		queryWrapper.eq("ncpid", ncp.getNcpid());
    207. 		ncp = ncpService.getOne(queryWrapper);
    208. 		boolean flag = ncpService.remove(queryWrapper);
    209. 		if(flag) {
    210. 			QueryWrapper ewmQueryWrapper = new QueryWrapper<>();
    211. 			ewmQueryWrapper.eq("ewmid", ncp.getEwmid());
    212. 			boolean flag2 = ewmService.remove(ewmQueryWrapper);
    213. 			return flag2;
    214. 		} else {
    215. 			return flag;
    216. 		}
    217. 	}
    218. }

     溯源管理控制器

    1. @Controller
    2. @RequestMapping("/handle")
    3. public class SylyController {
    4. 	
    5. 	protected Logger logger = LoggerFactory.getLogger(this.getClass());
    6. 	
    7. 	@Autowired
    8. 	private ISylyService sylyService;
    9. 	
    10. 	@Autowired
    11. 	private SylyMapper sylyMapper;
    12. 	
    13. 	private static Tool tool = new Tool();
    14. 	
    15. 	/**
    16. 	 * 溯源来源计数
    17. 	 * @param syly
    18. 	 * @param request
    19. 	 * @return
    20. 	 */
    21. 	@RequestMapping("/source/count")
    22. 	@ResponseBody
    23. 	public boolean sourceCount(@RequestBody Syly syly, HttpServletRequest request) {
    24. 		logger.info("/handle/source/count===> syly={}", syly);
    25. 		
    26. 		//查询syly总数,即溯源总数
    27. 		QueryWrapper countQueryWrapper = new QueryWrapper<>();
    28. 		countQueryWrapper.eq("syqyid", syly.getSyqyid());
    29. 		int count = sylyService.count(countQueryWrapper) + 1;
    30. 		//获取当前日期，设置溯源时间
    31. 		Date now = new Date();
    32. 		syly.setSysj(now);
    33. 		//设置溯源id
    34. 		SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");
    35. 		String newNo = df.format(now);
    36. 		String syid = "syly-" + newNo + "-" + count;
    37. 		syly.setSyid(syid);
    38. 		//设置溯源ip
    39. 		String syip = request.getRemoteAddr();
    40. 		syly.setSyip(syip);
    41. 		
    42. 		boolean flag = sylyService.save(syly);
    43. 		return flag;
    44. 	}
    45. 	
    46. 	/**
    47. 	 * 溯源列表
    48. 	 * @param syly
    49. 	 * @param page
    50. 	 * @param limit
    51. 	 * @return
    52. 	 * @throws Exception
    53. 	 */
    54. 	@RequestMapping("/source/list")
    55. 	@ResponseBody
    56. 	public Map sourceList(Syly syly, @RequestParam int page, @RequestParam int limit) throws Exception {
    57. 		logger.info("/handle/source/list===> syly={}", syly);
    58. 		logger.info("page = {}", page);
    59. 		logger.info("limit = {}", limit);
    60. 		QueryWrapper sylyQueryWrapper = new QueryWrapper<>();
    61. 		//遍历syly对象的属性
    62. 		Field field[] = syly.getClass().getDeclaredFields();
    63. 		for(int i = 0; i < field.length; i++) {
    64. 			//获取属性名
    65. 			String name = field[i].getName();
    66. 			//将属性的首字符大写，方便构造get，set方法
    67. 			String getterName = name.substring(0,1).toUpperCase()+name.substring(1);
    68. 			//获取属性的类型
    69. 			String type = field[i].getGenericType().toString();
    70. 			//根据类型做操作
    71. 			if (type.equals("class java.lang.String")) {
    72. 				//获得getter方法
    73. 				Method m = syly.getClass().getMethod("get" + getterName);
    74. 				//调用getter方法
    75. 				String value = (String) m.invoke(syly);
    76. 				//如果非空，则加入查询条件
    77. 				if (value != null) {
    78. 					sylyQueryWrapper.eq(name, value);
    79. 				}
    80. 			}
    81. 		}
    82. 		
    83. 		List sylyList = sylyService.list(sylyQueryWrapper);
    84. 		logger.info("=========={}", sylyList);
    85. 		//查询到的总量，返回数据要用
    86. 		int count = sylyList.size();
    87. 		//list截取分页的索引
    88. 		int fromIndex = (page-1)*limit;
    89. 		int toIndex = page * limit;
    90. 		//截取分页数据
    91. 		if(page*limit > count) {
    92. 			toIndex = count;
    93. 		}
    94. 		sylyList = sylyList.subList(fromIndex, toIndex);
    95. 		
    96. 		Map response = new HashMap();
    97. 		response.put("code", 0);
    98. 		response.put("msg", "");
    99. 		response.put("count", count);
    100. 		response.put("data", sylyList);
    101. 		
    102. 		return response;
    103. 	}
    104. 	
    105. 	/**
    106. 	 * 获取7天溯源数据
    107. 	 * @param syly
    108. 	 * @return
    109. 	 */
    110. 	@RequestMapping("/source/line")
    111. 	@ResponseBody
    112. 	public Map sourceChart(@RequestBody Syly syly) {
    113. 		logger.info("/handle/source/line===> syly={}", syly);
    114. 		//groud by 溯源时间查询list
    115. 		QueryWrapper sylyQueryWrapper = new QueryWrapper<>();
    116. 		//map对象用来储存返回数据
    117. 		Map map = new HashMap();
    118. 		//新建sysjList和counts，用于保存时间和访问数
    119. 		List sysjList = new ArrayList<>();
    120. 		List countList = new ArrayList<>();
    121. 		for(int i = 6; i >= 0; i--) {
    122. 			//获取i天前日期对象
    123. 			Date date = tool.getDateBefore(new Date(), i);
    124. 			//溯源时间转字符串
    125. 			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
    126. 			String sysjString = df.format(date);
    127. 			//查询i天前溯源数量
    128. 			QueryWrapper countQueryWrapper = new QueryWrapper<>();
    129. 			countQueryWrapper.eq("sysj", sysjString).eq("syqyid", syly.getSyqyid());
    130. 			int count = sylyService.count(countQueryWrapper);
    131. 			//将结果插入list
    132. 			countList.add(count);
    133. 			sysjList.add(sysjString);
    134. 		}
    135. 		map.put("sysjList", sysjList);
    136. 		map.put("counts",countList);
    137. 		return map;
    138. 	}
    139. 	
    140. 	/**
    141. 	 * 获取溯源农产品分布数据
    142. 	 * @param syly
    143. 	 * @return
    144. 	 */
    145. 	@RequestMapping("/source/pie")
    146. 	@ResponseBody
    147. 	public Map sourcePie(@RequestBody Syly syly) {
    148. 		logger.info("/handle/source/pie===> syly={}", syly);
    149. 		//获取溯源总数
    150. 		QueryWrapper sylyQueryWrapper = new QueryWrapper<>();
    151. 		sylyQueryWrapper.eq("syqyid", syly.getSyqyid());
    152. 		int count = sylyService.count(sylyQueryWrapper);
    153. 		int alreadyGet = 0;
    154. 		//获取最大溯源量的4个ncp
    155. 		List dataList = sylyMapper.selectSylyCountNcpGroupByNcpid(syly.getSyqyid());
    156. 		//新建两个列表对象储存返回数据
    157. 		List ncpmcList = new ArrayList<>();
    158. 		List countList = new ArrayList<>();
    159. 		//插入查询到的数据到list
    160. 		for(SylyCountNcpGroupByNcpid item : dataList) {
    161. 			ncpmcList.add(item.getNcpmc());
    162. 			countList.add(item.getCount());
    163. 			alreadyGet += item.getCount();
    164. 		}
    165. 		ncpmcList.add("其他");
    166. 		countList.add(count-alreadyGet);
    167. 		Map map = new HashMap();
    168. 		map.put("ncpmcList", ncpmcList);
    169. 		map.put("countList", countList);
    170. 		return map;
    171. 	}
    172. 	
    173. 	/**
    174. 	 * 获取总溯源数
    175. 	 * @param syly
    176. 	 * @return
    177. 	 */
    178. 	@RequestMapping("/source/total")
    179. 	@ResponseBody
    180. 	public List sourceTotal(@RequestBody Syly syly) {
    181. 		logger.info("/handle/source/total===> syly={}", syly);
    182. 		//获取溯源总数
    183. 		QueryWrapper sylyQueryWrapper = new QueryWrapper<>();
    184. 		sylyQueryWrapper.eq("syqyid", syly.getSyqyid());
    185. 		int count = sylyService.count(sylyQueryWrapper);
    186. 		List list = new ArrayList<>();
    187. 		list.add(count+"");
    188. 		return list;
    189. 	}
    190. 	
    191. 	/**
    192. 	 * 获取当日溯源数和同比增长比例
    193. 	 * @param syly
    194. 	 * @return
    195. 	 */
    196. 	@RequestMapping("/source/today")
    197. 	@ResponseBody
    198. 	public List sourceToday(@RequestBody Syly syly) {
    199. 		logger.info("/handle/source/today===> syly={}", syly);
    200. 		//获取今天日期
    201. 		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
    202. 		String todayString = df.format(new Date());
    203. 		//获取昨天日期
    204. 		SimpleDateFormat df2 = new SimpleDateFormat("yyyy-MM-dd");
    205. 		String yesterdayString = df.format(new Date(new Date().getTime()-86400000L));
    206. 		//查询今天总数
    207. 		QueryWrapper todayQueryWrapper = new QueryWrapper<>();
    208. 		todayQueryWrapper.eq("syqyid", syly.getSyqyid()).eq("sysj", todayString);
    209. 		int todayCount = sylyService.count(todayQueryWrapper);
    210. 		//查询昨天总数
    211. 		QueryWrapper yesterdayQueryWrapper = new QueryWrapper<>();
    212. 		yesterdayQueryWrapper.eq("syqyid", syly.getSyqyid()).eq("sysj", yesterdayString);
    213. 		int yesterdayCount = sylyService.count(yesterdayQueryWrapper);
    214. 		//算出同比增长比例
    215. 		float rise = ((float)todayCount - (float)yesterdayCount) / (float)yesterdayCount * 100;
    216. 		
    217. 		List list = new ArrayList<>();
    218. 		list.add(todayCount+"");
    219. 		list.add(rise+"%");
    220. 		return list;
    221. 	}
    222. 	
    223. 	/**
    224. 	 * 获取7天溯源人数和同比增长比例
    225. 	 * @param syly
    226. 	 * @return
    227. 	 */
    228. 	@RequestMapping("/source/week")
    229. 	@ResponseBody
    230. 	public List sourceWeek(@RequestBody Syly syly) {
    231. 		logger.info("/handle/source/week===> syly={}", syly);
    232. 		//获取今天和七天前的日期
    233. 		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
    234. 		String dateString = df.format(new Date());
    235. 		String weekBeforeString = df.format(tool.getDateBefore(new Date(), 6));
    236. 		//查询介于两个日期之间的总数
    237. 		QueryWrapper countQueryWrapper = new QueryWrapper<>();
    238. 		countQueryWrapper.between("sysj", weekBeforeString, dateString).eq("syqyid", syly.getSyqyid());
    239. 		int count = sylyService.count(countQueryWrapper);
    240. 		
    241. 		//获取上一期的两个日期
    242. 		String lastDateString = df.format(tool.getDateBefore(new Date(), 7));
    243. 		String lastWeekBeforeString = df.format(tool.getDateBefore(new Date(), 13));
    244. 		//同样查询两个日期之间的总数
    245. 		QueryWrapper lastCountQueryWrapper = new QueryWrapper<>();
    246. 		lastCountQueryWrapper.between("sysj", lastWeekBeforeString, lastDateString).eq("syqyid", syly.getSyqyid());
    247. 		int lastCount = sylyService.count(lastCountQueryWrapper);
    248. 		
    249. 		//通过两期数据算出同比增长比例
    250. 		float rise = ((float)count - (float)lastCount) / (float)lastCount * 100;
    251. 		
    252. 		//返回数据
    253. 		List list = new ArrayList<>();
    254. 		list.add(count+"");
    255. 		list.add(rise+"%");
    256. 		return list;
    257. 	}
    258. 	
    259. 	@RequestMapping("/source/month")
    260. 	@ResponseBody
    261. 	public List sourceMonth(@RequestBody Syly syly) {
    262. 		logger.info("/handle/source/month===> syly={}", syly);
    263. 		//获取今天和30天前的日期
    264. 		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
    265. 		String dateString = df.format(new Date());
    266. 		String monthBeforeString = df.format(tool.getDateBefore(new Date(), 29));
    267. 		//查询介于两个日期之间的总数
    268. 		QueryWrapper countQueryWrapper = new QueryWrapper<>();
    269. 		countQueryWrapper.between("sysj", monthBeforeString, dateString).eq("syqyid", syly.getSyqyid());
    270. 		int count = sylyService.count(countQueryWrapper);
    271. 		
    272. 		//获取上一期的两个日期
    273. 		String lastDateString = df.format(tool.getDateBefore(new Date(), 30));
    274. 		String lastMonthBeforeString = df.format(tool.getDateBefore(new Date(), 59));
    275. 		//同样查询两个日期之间的总数
    276. 		QueryWrapper lastCountQueryWrapper = new QueryWrapper<>();
    277. 		lastCountQueryWrapper.between("sysj", lastMonthBeforeString, lastDateString).eq("syqyid", syly.getSyqyid());
    278. 		int lastCount = sylyService.count(lastCountQueryWrapper);
    279. 		
    280. 		//通过两期数据算出同比增长比例
    281. 		float rise = ((float)count - (float)lastCount) / (float)lastCount * 100;
    282. 		
    283. 		//返回数据
    284. 		List list = new ArrayList<>();
    285. 		list.add(count+"");
    286. 		list.add(rise+"%");
    287. 		return list;
    288. 	}
    289.  
    290. }

    如果也想学习本系统，下面领取。关注并回复：110ssm  

  • 相关阅读:
    2023CCPC重庆经验小结
    【JVM】JVM的垃圾回收机制与垃圾回收器的选择
    Spark之UDF失效
    10道高频Vuex面试题快问快答
    10月最新外贸进出口情况，外贸整体向好
    x86: perf_events内核初始化
    解决Windows 10更新安装失败的问题
    asp毕业设计——基于asp+sqlserver的工艺品销售系统设计与实现（毕业论文+程序源码）——工艺品销售系统
    2023-9-8 求组合数(二)
    How to install mongodb 7.0 to Ubuntu 22.04
  • 原文地址：https://blog.csdn.net/hanyunlong1989/article/details/126613539