devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java项目-基于SSM实现物流信息管理系统_基于ssm框架的项目

作者：凡人多烦事01 | 2024-02-27 20:05:51

赞

踩

基于ssm框架的项目

作者主页：编程指南针

作者简介：Java领域优质创作者、CSDN博客专家 、掘金特邀作者、多年架构师设计经验、腾讯课堂常驻讲师

主要内容：Java项目、毕业设计、简历模板、学习资料、面试题库、技术互助

文末获取源码 

项目编号：BS-XX-118

一，项目简介

基于SSM框架的物流管理系统主要分为三种用户角色，分别是管理员、员工以及客户用户，其具体功能如下：

管理员：管理员登录后主要功能模块有个人信息，客户管理，反馈信息，基础信息，货物信息以及货物运输。

员工用户：员工用户登录后主要模块有个人信息，配送范围，货物信息，货物运输以及反馈信息。

客户用户：客户用户登录后主要模块有个人信息，配送范围，货物信息，货物运输以及反馈信息。

二，环境介绍

语言环境：Java:  jdk1.8

数据库：Mysql: mysql5.7

应用服务器：Tomcat:  tomcat8.5.31

开发工具：IDEA或eclipse

后台开发：SSM框架

前端开发：Bootstrap+Jquery+Echart

三，系统展示

展示一下部分系统的功能：

用户登陆

管理员主功能界面：

员工管理

客户管理

反馈信息

基础信息管理

货物信息审核

货物运输

客户角色的管理主界面

普通管理用户的管理主界面

四，核心代码展示

  1.  
  2. package com.action;
  3.  
  4. import java.util.Date;
  5. import java.util.List;
  6.  
  7. import javax.servlet.http.HttpServletRequest;
  8. import javax.servlet.http.HttpServletResponse;
  9.  
  10. import net.sf.json.JSONArray;
  11. import net.sf.json.JSONObject;
  12.  
  13. import org.springframework.beans.factory.annotation.Autowired;
  14. import org.springframework.stereotype.Controller;
  15. import org.springframework.web.bind.annotation.RequestMapping;
  16. import org.springframework.web.multipart.MultipartFile;
  17.  
  18. import com.model.*;
  19. import com.service.*;
  20. import com.util.*;
  21.  
  22. @Controller
  23. public class GgtypeAction {
  24. 	@Autowired
  25. 	private GgtypeService ggtypeService;
  26.  
  27. 	@RequestMapping("/getGgtypes")
  28. 	public void getGgtypes(HttpServletRequest request,
  29. 			HttpServletResponse response) throws Exception {
  30. 		request.setCharacterEncoding("UTF-8");
  31. 		response.setCharacterEncoding("UTF-8");
  32. 		String page = (String) request.getParameter("page");
  33. 		String rows = (String) request.getParameter("rows");
  34. 		String ggtypeName = (String) request.getParameter("ggtypeName");
  35. 		String ggtypeId = (String) request.getParameter("ggtypeId");
  36. 		PageBean pageBean = new PageBean(Integer.parseInt(page), Integer.parseInt(rows));
  37. 		Ggtype ggtype = new Ggtype();
  38. 		try {
  39. 			if (StringUtil.isNotEmpty(ggtypeName)) {
  40. 				ggtype.setGgtypeName(ggtypeName);
  41. 			}
  42. 			if (StringUtil.isNotEmpty(ggtypeId)) {
  43. 				ggtype.setGgtypeId(Integer.parseInt(ggtypeId));
  44. 			}
  45. 			JSONArray jsonArray = JSONArray.fromObject(ggtypeService.queryGgtypes(ggtype, pageBean.getStart(), pageBean.getRows()));
  46. 			JSONObject result = new JSONObject();
  47. 			int total = ggtypeService.queryGgtypes(ggtype, 0, 0).size();
  48. 			result.put("rows", jsonArray);
  49. 			result.put("total", total);
  50. 			ResponseUtil.write(response, result);
  51. 		} catch (Exception e) {
  52. 			e.printStackTrace();
  53. 		}
  54. 	}
  55.  
  56. 	@RequestMapping("/addGgtype")
  57. 	public void addGgtype(HttpServletRequest request, HttpServletResponse response)
  58. 			throws Exception {
  59. 		request.setCharacterEncoding("UTF-8");
  60. 		response.setCharacterEncoding("UTF-8");
  61. 		try {
  62. 			JSONObject result = new JSONObject();
  63.  
  64. 			String ggtypeName = (String) request.getParameter("ggtypeName");
  65. 			String ggtypeMark = (String) request.getParameter("ggtypeMark");
  66. 			String ggtypeId = (String) request.getParameter("ggtypeId");
  67. 			Ggtype ggtype = new Ggtype();
  68.  
  69. 			if (StringUtil.isNotEmpty(ggtypeId)) {
  70. 				ggtype = ggtypeService.getGgtype(Integer.parseInt(ggtypeId));
  71. 			}
  72. 			if (StringUtil.isNotEmpty(ggtypeName)) {
  73. 				ggtype.setGgtypeName(ggtypeName);
  74. 			}
  75. 			if (StringUtil.isNotEmpty(ggtypeMark)) {
  76. 				ggtype.setGgtypeMark(ggtypeMark);
  77. 			}
  78.  
  79. 			if (StringUtil.isNotEmpty(ggtypeId)) {
  80. 				ggtypeService.modifyGgtype(ggtype);
  81. 			} else {
  82. 				ggtypeService.save(ggtype);
  83. 			}
  84. 			result.put("success", "true");
  85.  
  86. 			ResponseUtil.write(response, result);
  87. 		} catch (Exception e) {
  88. 			e.printStackTrace();
  89. 		}
  90. 	}
  91.  
  92. 	@RequestMapping("/deleteGgtype")
  93. 	public void deleteGgtype(HttpServletRequest request, HttpServletResponse response)
  94. 			throws Exception {
  95. 		try {
  96. 			String delIds = (String) request.getParameter("delIds");
  97. 			System.out.println("delIds = " + delIds);
  98. 			JSONObject result = new JSONObject();
  99. 			String str[] = delIds.split(",");
  100. 			for (int i = 0; i < str.length; i++) {
  101. 				ggtypeService.deleteGgtype(Integer.parseInt(str[i]));
  102. 			}
  103. 			result.put("success", "true");
  104. 			result.put("delNums", str.length);
  105. 			ResponseUtil.write(response, result);
  106. 		} catch (Exception e) {
  107. 			e.printStackTrace();
  108. 		}
  109. 	}
  110.  
  111. 	@RequestMapping("/ggtypeComboList")
  112. 	public void ggtypeComboList(HttpServletRequest request, HttpServletResponse response)
  113. 			throws Exception {
  114.  
  115. 		try {
  116. 			JSONArray jsonArray = new JSONArray();
  117. 			JSONObject jsonObject = new JSONObject();
  118. 			jsonObject.put("id", "");
  119. 			jsonObject.put("ggtypeName", "请选择...");
  120. 			jsonArray.add(jsonObject);
  121. 			jsonArray.addAll(JSONArray.fromObject(ggtypeService.queryGgtypes(null, 0, 0)));
  122. 			ResponseUtil.write(response, jsonArray);
  123. 		} catch (Exception e) {
  124. 			e.printStackTrace();
  125. 		}
  126. 	}
  127. }
  128.  
  1.  
  2. package com.action;
  3.  
  4. import javax.servlet.http.HttpServletRequest;
  5. import javax.servlet.http.HttpServletResponse;
  6.  
  7. import net.sf.json.JSONObject;
  8.  
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.stereotype.Controller;
  11. import org.springframework.web.bind.annotation.RequestMapping;
  12.  
  13. import com.model.*;
  14. import com.service.*;
  15.  
  16. @Controller
  17. public class AdminAction {
  18. 	@Autowired
  19. 	private AdminService adminService;
  20.  
  21. 	@RequestMapping("/mimaAdmin")
  22. 	public void mimaAdmin(HttpServletRequest request, HttpServletResponse response)
  23. 			throws Exception {
  24. 		try {
  25. 			JSONObject result = new JSONObject();
  26.  
  27. 			String adminPassword = (String) request.getParameter("adminPassword");
  28. 			String adminPassword1 = (String) request.getParameter("adminPassword1");
  29. 			Admin admin = new Admin();
  30. 			admin.setAdminName("admin");
  31. 			admin.setAdminPassword(adminPassword);
  32. 			if (adminService.queryAdmins(admin, 0, 0).size()==1) {
  33. 				admin = (Admin)(adminService.queryAdmins(admin, 0, 0)).get(0);
  34. 				admin.setAdminPassword(adminPassword1);
  35. 				adminService.modifyAdmin(admin);
  36. 				request.setAttribute("error", "密码修改成功！");
  37. 				request.getRequestDispatcher("adminmima.jsp").forward(request,
  38. 						response);
  39. 			}else{
  40. 				result.put("success", "true");
  41. 				request.setAttribute("error", "原密码错误，请重新输入！");
  42. 				request.getRequestDispatcher("adminmima.jsp").forward(request,
  43. 						response);
  44. 			}
  45. 		} catch (Exception e) {
  46. 			e.printStackTrace();
  47. 		}
  48. 	}
  49. }
  50.  

  1.  
  2. package com.action;
  3.  
  4. import java.util.Date;
  5. import java.util.List;
  6.  
  7. import javax.servlet.http.HttpServletRequest;
  8. import javax.servlet.http.HttpServletResponse;
  9.  
  10. import net.sf.json.JSONArray;
  11. import net.sf.json.JSONObject;
  12.  
  13. import org.springframework.beans.factory.annotation.Autowired;
  14. import org.springframework.stereotype.Controller;
  15. import org.springframework.web.bind.annotation.RequestMapping;
  16. import org.springframework.web.multipart.MultipartFile;
  17.  
  18. import com.model.*;
  19. import com.service.*;
  20. import com.util.*;
  21.  
  22. @Controller
  23. public class RoleAction {
  24. 	@Autowired
  25. 	private RoleService roleService;
  26.  
  27. 	@RequestMapping("/getRoles")
  28. 	public void getRoles(HttpServletRequest request,
  29. 			HttpServletResponse response) throws Exception {
  30. 		request.setCharacterEncoding("UTF-8");
  31. 		response.setCharacterEncoding("UTF-8");
  32. 		String page = (String) request.getParameter("page");
  33. 		String rows = (String) request.getParameter("rows");
  34. 		String roleName = (String) request.getParameter("roleName");
  35. 		String roleId = (String) request.getParameter("roleId");
  36. 		String roleMark2 = (String) request.getParameter("roleMark2");
  37. 		PageBean pageBean = new PageBean(Integer.parseInt(page), Integer.parseInt(rows));
  38. 		Role role = new Role();
  39. 		try {
  40. 			if (StringUtil.isNotEmpty(roleName)) {
  41. 				role.setRoleName(roleName);
  42. 			}
  43. 			if (StringUtil.isNotEmpty(roleId)) {
  44. 				role.setRoleId(Integer.parseInt(roleId));
  45. 			}
  46. 			if (StringUtil.isNotEmpty(roleMark2)) {
  47. 				role.setRoleMark2(Integer.parseInt(roleMark2));
  48. 			}
  49. 			JSONArray jsonArray = JSONArray.fromObject(roleService.queryRoles(role, pageBean.getStart(), pageBean.getRows()));
  50. 			JSONObject result = new JSONObject();
  51. 			int total = roleService.queryRoles(role, 0, 0).size();
  52. 			result.put("rows", jsonArray);
  53. 			result.put("total", total);
  54. 			ResponseUtil.write(response, result);
  55. 		} catch (Exception e) {
  56. 			e.printStackTrace();
  57. 		}
  58. 	}
  59.  
  60. 	@RequestMapping("/addRole")
  61. 	public void addRole(HttpServletRequest request, HttpServletResponse response)
  62. 			throws Exception {
  63. 		request.setCharacterEncoding("UTF-8");
  64. 		response.setCharacterEncoding("UTF-8");
  65. 		try {
  66. 			JSONObject result = new JSONObject();
  67.  
  68. 			String roleName = (String) request.getParameter("roleName");
  69. 			String roleMark = (String) request.getParameter("roleMark");
  70. 			String roleMark1 = (String) request.getParameter("roleMark1");
  71. 			String roleMark2 = (String) request.getParameter("roleMark2");
  72. 			String roleId = (String) request.getParameter("roleId");
  73. 			Role role = new Role();
  74.  
  75. 			if (StringUtil.isNotEmpty(roleId)) {
  76. 				role = roleService.getRole(Integer.parseInt(roleId));
  77. 			}
  78. 			if (StringUtil.isNotEmpty(roleName)) {
  79. 				role.setRoleName(roleName);
  80. 			}
  81. 			if (StringUtil.isNotEmpty(roleMark)) {
  82. 				role.setRoleMark(roleMark);
  83. 			}
  84. 			if (StringUtil.isNotEmpty(roleMark1)) {
  85. 				role.setRoleMark1(roleMark1);
  86. 			}
  87. 			if (StringUtil.isNotEmpty(roleMark2)) {
  88. 				role.setRoleMark2(Integer.parseInt(roleMark2));
  89. 			}
  90.  
  91. 			if (StringUtil.isNotEmpty(roleId)) {
  92. 				roleService.modifyRole(role);
  93. 			} else {
  94. 				roleService.save(role);
  95. 			}
  96. 			result.put("success", "true");
  97.  
  98. 			ResponseUtil.write(response, result);
  99. 		} catch (Exception e) {
  100. 			e.printStackTrace();
  101. 		}
  102. 	}
  103.  
  104. 	@RequestMapping("/deleteRole")
  105. 	public void deleteRole(HttpServletRequest request, HttpServletResponse response)
  106. 			throws Exception {
  107. 		try {
  108. 			String delIds = (String) request.getParameter("delIds");
  109. 			System.out.println("delIds = " + delIds);
  110. 			JSONObject result = new JSONObject();
  111. 			String str[] = delIds.split(",");
  112. 			for (int i = 0; i < str.length; i++) {
  113. 				roleService.deleteRole(Integer.parseInt(str[i]));
  114. 			}
  115. 			result.put("success", "true");
  116. 			result.put("delNums", str.length);
  117. 			ResponseUtil.write(response, result);
  118. 		} catch (Exception e) {
  119. 			e.printStackTrace();
  120. 		}
  121. 	}
  122.  
  123. 	@RequestMapping("/roleComboList")
  124. 	public void roleComboList(HttpServletRequest request, HttpServletResponse response)
  125. 			throws Exception {
  126. 		request.setCharacterEncoding("UTF-8");
  127. 		response.setCharacterEncoding("UTF-8");
  128. 		String roleMark2 = (String) request.getParameter("roleMark2");
  129. 		Role role = new Role();
  130.  
  131. 		if (StringUtil.isNotEmpty(roleMark2)) {
  132. 			role.setRoleMark2(Integer.parseInt(roleMark2));
  133. 		}
  134. 		try {
  135. 			JSONArray jsonArray = new JSONArray();
  136. 			JSONObject jsonObject = new JSONObject();
  137. 			jsonObject.put("id", "");
  138. 			jsonObject.put("roleName", "请选择...");
  139. 			jsonArray.add(jsonObject);
  140. 			//jsonArray.addAll(JSONArray.fromObject(roleService.queryRoles(role, 0, 0)));
  141. 			ResponseUtil.write(response, jsonArray);
  142. 		} catch (Exception e) {
  143. 			e.printStackTrace();
  144. 		}
  145. 	}
  146. }
  147.  
  1.  
  2. package com.action;
  3.  
  4. import java.util.ArrayList;
  5. import java.util.Date;
  6. import java.util.List;
  7.  
  8. import javax.servlet.http.HttpServletRequest;
  9. import javax.servlet.http.HttpServletResponse;
  10. import javax.servlet.http.HttpSession;
  11.  
  12. import net.sf.json.JSONArray;
  13. import net.sf.json.JSONObject;
  14.  
  15. import org.springframework.beans.factory.annotation.Autowired;
  16. import org.springframework.stereotype.Controller;
  17. import org.springframework.web.bind.annotation.RequestMapping;
  18. import org.springframework.web.multipart.MultipartFile;
  19.  
  20. import com.model.*;
  21. import com.service.*;
  22. import com.util.*;
  23.  
  24. import java.io.BufferedInputStream;
  25. import java.io.BufferedOutputStream;
  26. import java.io.File;
  27. import java.io.FileInputStream;
  28. import java.io.FileOutputStream;
  29. import java.io.InputStream;
  30. import java.io.OutputStream;
  31. import java.net.URLEncoder;
  32. //导入导出
  33.  
  34. import org.apache.poi.hssf.usermodel.HSSFCell;
  35. import org.apache.poi.hssf.usermodel.HSSFCellStyle;
  36. import org.apache.poi.hssf.usermodel.HSSFRow;
  37. import org.apache.poi.hssf.usermodel.HSSFSheet;
  38. import org.apache.poi.hssf.usermodel.HSSFWorkbook;
  39. import org.apache.poi.ss.usermodel.Cell;
  40. import org.apache.poi.ss.usermodel.Row;
  41. import org.apache.poi.ss.usermodel.Sheet;
  42. import org.apache.poi.ss.usermodel.Workbook;
  43.  
  44. @Controller
  45. public class GonggaoAction {
  46. 	@Autowired
  47. 	private GonggaoService gonggaoService;
  48. 	@Autowired
  49. 	private GgtypeService ggtypeService;
  50.  
  51. 	/***上传导入开始***/
  52. 	private InputStream excelFile;
  53.  
  54. 	public InputStream getExcelFile() {
  55. 		return excelFile;
  56. 	}
  57. 	/***上传导入结束***/
  58.  
  59. 	@RequestMapping("/getGonggaos")
  60. 	public void getGonggaos(HttpServletRequest request,
  61. 			HttpServletResponse response) throws Exception {
  62. 		request.setCharacterEncoding("UTF-8");
  63. 		response.setCharacterEncoding("UTF-8");
  64. 		String page = (String) request.getParameter("page");
  65. 		String rows = (String) request.getParameter("rows");
  66. 		String gonggaoName = (String) request.getParameter("gonggaoName");
  67. 		String gonggaoId = (String) request.getParameter("gonggaoId");
  68. 		String ggtypeId = (String) request.getParameter("ggtypeId");
  69. 		String sdate = (String) request.getParameter("sdate");
  70. 		String edate = (String) request.getParameter("edate");
  71. 		PageBean pageBean = new PageBean(Integer.parseInt(page), Integer.parseInt(rows));
  72. 		Gonggao gonggao = new Gonggao();
  73. 		try {
  74. 			if (StringUtil.isNotEmpty(gonggaoName)) {
  75. 				gonggao.setGonggaoName(gonggaoName);
  76. 			}
  77. 			if (StringUtil.isNotEmpty(gonggaoId)) {
  78. 				gonggao.setGonggaoId(Integer.parseInt(gonggaoId));
  79. 			}
  80. 			if (StringUtil.isNotEmpty(ggtypeId)) {
  81. 				gonggao.setGgtypeId(Integer.parseInt(ggtypeId));
  82. 			}
  83. 			JSONArray jsonArray = JSONArray.fromObject(gonggaoService.queryGonggaos(
  84. 					gonggao, pageBean.getStart(), pageBean.getRows(), sdate, edate));
  85. 			JSONObject result = new JSONObject();
  86. 			int total = gonggaoService.queryGonggaos(gonggao, 0, 0, sdate, edate).size();
  87. 			result.put("rows", jsonArray);
  88. 			result.put("total", total);
  89. 			ResponseUtil.write(response, result);
  90. 		} catch (Exception e) {
  91. 			e.printStackTrace();
  92. 		}
  93. 	}
  94.  
  95. 	@RequestMapping("/addGonggao")
  96. 	public void addGonggao(HttpServletRequest request, HttpServletResponse response)
  97. 			throws Exception {
  98. 		JSONObject result = new JSONObject();
  99. 		request.setCharacterEncoding("UTF-8");
  100. 		response.setCharacterEncoding("UTF-8");
  101. 		String gonggaoName = (String) request.getParameter("gonggaoName");
  102. 		String gonggaoMark = (String) request.getParameter("gonggaoMark");
  103. 		String gonggaoDate = (String) request.getParameter("gonggaoDate");
  104. 		String ggtypeId = (String) request.getParameter("ggtypeId");
  105. 		String gonggaoId = (String) request.getParameter("gonggaoId");
  106. 		Gonggao gonggao = new Gonggao();
  107.  
  108. 		if (StringUtil.isNotEmpty(gonggaoId)) {
  109. 			gonggao = gonggaoService.getGonggao(Integer.parseInt(gonggaoId));
  110. 		}
  111. 		if (StringUtil.isNotEmpty(gonggaoName)) {
  112. 			gonggao.setGonggaoName(gonggaoName);
  113. 		}
  114. 		if (StringUtil.isNotEmpty(gonggaoMark)) {
  115. 			gonggao.setGonggaoMark(gonggaoMark);
  116. 		}
  117. 		if (StringUtil.isNotEmpty(gonggaoDate)) {
  118. 			gonggao.setGonggaoDate(DateUtil.formatString(gonggaoDate,
  119. 					"yyyy-MM-dd hh:mm:ss"));
  120. 		}
  121. 		if (StringUtil.isNotEmpty(ggtypeId)) {
  122. 			gonggao.setGgtypeId(Integer.parseInt(ggtypeId));
  123. 			Ggtype ggtype = new Ggtype();
  124. 			ggtype = ggtypeService.getGgtype(Integer.parseInt(ggtypeId));
  125. 			gonggao.setGgtypeName(ggtype.getGgtypeName());
  126. 		}
  127. 		try {
  128. 			if (StringUtil.isNotEmpty(gonggaoId)) {
  129. 				gonggaoService.modifyGonggao(gonggao);
  130. 				result.put("success", "true");
  131. 				ResponseUtil.write(response, result);
  132. 			} else {
  133. 				Date date = new Date();
  134. 				gonggao.setGonggaoDate(date);
  135. 				gonggaoService.save(gonggao);
  136. 				result.put("success", "true");
  137. 				ResponseUtil.write(response, result);
  138. 			}
  139. 		} catch (Exception e) {
  140. 			e.printStackTrace();
  141. 		}
  142. 	}
  143.  
  144. 	@RequestMapping("/deleteGonggao")
  145. 	public void deleteGonggao(HttpServletRequest request, HttpServletResponse response)
  146. 			throws Exception {
  147. 		JSONObject result = new JSONObject();
  148. 		String delIds = (String) request.getParameter("delIds");
  149. 		try {
  150. 			String str[] = delIds.split(",");
  151. 			for (int i = 0; i < str.length; i++) {
  152. 				gonggaoService.deleteGonggao(Integer.parseInt(str[i]));
  153. 			}
  154. 			result.put("success", "true");
  155. 			result.put("delNums", str.length);
  156. 			ResponseUtil.write(response, result);
  157. 		} catch (Exception e) {
  158. 			e.printStackTrace();
  159. 		}
  160. 	}
  161.  
  162. 	@RequestMapping("/gonggaoComboList")
  163. 	public void gonggaoComboList(HttpServletRequest request, HttpServletResponse response)
  164. 			throws Exception {
  165. 		request.setCharacterEncoding("UTF-8");
  166. 		response.setCharacterEncoding("UTF-8");
  167. 		String ggtypeId = (String) request.getParameter("ggtypeId");
  168. 		Gonggao gonggao = new Gonggao();
  169. 		if (StringUtil.isNotEmpty(ggtypeId)) {
  170. 			gonggao.setGgtypeId(Integer.parseInt(ggtypeId));
  171. 		}
  172. 		try {
  173. 			JSONArray jsonArray = new JSONArray();
  174. 			JSONObject jsonObject = new JSONObject();
  175. 			jsonObject.put("id", "");
  176. 			jsonObject.put("gonggaoName", "请选择...");
  177. 			jsonArray.add(jsonObject);
  178. 			jsonArray.addAll(JSONArray.fromObject(gonggaoService.queryGonggaos(gonggao, 0, 0, null, null)));
  179. 			ResponseUtil.write(response, jsonArray);
  180. 		} catch (Exception e) {
  181. 			e.printStackTrace();
  182. 		}
  183. 	}
  184.  
  185. 	@RequestMapping("/gonggaoTongji")
  186. 	public void gonggaoTongji(HttpServletRequest request, HttpServletResponse response)
  187. 			throws Exception {
  188. 		request.setCharacterEncoding("UTF-8");
  189. 		response.setCharacterEncoding("UTF-8");
  190. 		String sdate=request.getParameter("sdate");
  191. 		String edate=request.getParameter("edate");
  192. 		List<Integer> ggtypeIds = new ArrayList<Integer>();
  193. 		List<String> ggtypeNames = new ArrayList<String>();
  194. 		List<Integer> gonggaoZongshus = new ArrayList<Integer>();
  195. 		List<Ggtype> ggtypes = new ArrayList<Ggtype>();
  196. 		List<Gonggao> gonggaos = new ArrayList<Gonggao>();
  197. 		Gonggao gonggao = new Gonggao();
  198. 		Integer zongshu = 0;
  199. 		try {
  200. 			ggtypes = ggtypeService.queryGgtypes(null, 0,0);
  201. 			for(int i=0;i<ggtypes.size();i++){
  202. 				ggtypeIds.add(ggtypes.get(i).getGgtypeId());
  203. 				ggtypeNames.add(ggtypes.get(i).getGgtypeName());
  204. 			}
  205. 			for(int i=0;i<ggtypeIds.size();i++){
  206. 				Integer gonggaoZongshu = 0;
  207. 				gonggao.setGgtypeId(ggtypeIds.get(i));
  208. 				gonggaos = gonggaoService.queryGonggaos(gonggao, 0, 0, sdate, edate);
  209. 				for(int j=0;j<gonggaos.size();j++){
  210. 					gonggaoZongshu = gonggaoZongshu + gonggaos.size();
  211. 				}
  212. 				zongshu = zongshu + gonggaoZongshu;
  213. 				gonggaoZongshus.add(gonggaoZongshu);
  214. 			}
  215.  
  216. 			HttpSession session = request.getSession();
  217. 			session.setAttribute("ggtypeNames", ggtypeNames);
  218. 			session.setAttribute("gonggaoZongshus", gonggaoZongshus);
  219. 			session.setAttribute("zongshu", zongshu);
  220. 			response.sendRedirect("admin/gonggaotongji.jsp");
  221.  
  222. 		} catch (Exception e) {
  223. 			e.printStackTrace();
  224. 		}
  225. 	}
  226.  
  227. 	@RequestMapping("/shangchuanGonggao")
  228. 	public void shangchuanGonggao(HttpServletRequest request, HttpServletResponse response,MultipartFile uploadFile)
  229. 			throws Exception {
  230. 		try {
  231. 			String gonggaoId = (String) request.getParameter("gonggaoId");
  232. 			String directory = "/file";
  233. 			String targetDirectory = request.getSession().getServletContext().getRealPath(directory);
  234. 	        String fileName = uploadFile.getOriginalFilename();
  235. 			File dir = new File(targetDirectory,fileName);
  236. 	        if(!dir.exists()){
  237. 	            dir.mkdirs();
  238. 	        }
  239. 	        //MultipartFile自带的解析方法
  240. 	        uploadFile.transferTo(dir);
  241.  
  242. 			String shangchuandizhi = "/file" + "/" + fileName;
  243. 			String shangchuanname = fileName;
  244. 			Gonggao gonggao = gonggaoService.getGonggao(Integer.parseInt(gonggaoId));
  245. 			gonggao.setGonggaoImg(shangchuandizhi);
  246. 			gonggao.setGonggaoImgName(shangchuanname);
  247. 			gonggaoService.modifyGonggao(gonggao);
  248. 			JSONObject result = new JSONObject();
  249. 			result.put("success", "true");
  250. 			ResponseUtil.write(response, result);
  251. 		} catch (Exception e) {
  252. 			e.printStackTrace();
  253. 		}
  254. 	}
  255.  
  256. 	@RequestMapping("/xiazaiGonggao")
  257. 	public void xiazaiGonggao(HttpServletRequest request, HttpServletResponse response)
  258. 			throws Exception {
  259. 		String filename = (String) request.getParameter("filename");
  260.         //模拟文件，myfile.txt为需要下载的文件
  261.         String path = request.getSession().getServletContext().getRealPath("file")+"\\"+filename;
  262.         //获取输入流
  263.         InputStream bis = new BufferedInputStream(new FileInputStream(new File(path)));
  264.         //转码，免得文件名中文乱码
  265.         filename = URLEncoder.encode(filename,"UTF-8");
  266.         //设置文件下载头
  267.         response.addHeader("Content-Disposition", "attachment;filename=" + filename);
  268.         //1.设置文件ContentType类型，这样设置，会自动判断下载文件类型
  269.         response.setContentType("multipart/form-data");
  270.         BufferedOutputStream out = new BufferedOutputStream(response.getOutputStream());
  271.         int len = 0;
  272.         while((len = bis.read()) != -1){
  273.             out.write(len);
  274.             out.flush();
  275.         }
  276.         out.close();
  277. 	}
  278.  
  279. 	@RequestMapping("/daoruGonggao")
  280. 	public void daoruGonggao(HttpServletRequest request, HttpServletResponse response,MultipartFile uploadFile)
  281. 			throws Exception {
  282. 		try {
  283. 			String directory = "/file";
  284. 			String targetDirectory = request.getSession().getServletContext().getRealPath(directory);
  285. 	        String fileName = uploadFile.getOriginalFilename();
  286. 			File dir = new File(targetDirectory,fileName);
  287. 	        if(!dir.exists()){
  288. 	            dir.mkdirs();
  289. 	        }
  290. 	        //MultipartFile自带的解析方法
  291. 	        uploadFile.transferTo(dir);
  292. 			excelFile = new FileInputStream(dir);
  293. 			Workbook wb = new HSSFWorkbook(excelFile);
  294. 			Sheet sheet = wb.getSheetAt(0);
  295. 			int rowNum = sheet.getLastRowNum() + 1;
  296. 			for (int i = 1; i < rowNum; i++) {
  297. 				Gonggao gonggao = new Gonggao();
  298. 				Row row = sheet.getRow(i);
  299. 				int cellNum = row.getLastCellNum();
  300. 				for (int j = 0; j < cellNum; j++) {
  301. 					Cell cell = row.getCell(j);
  302. 					String cellValue = null;
  303. 					switch (cell.getCellType()) { // 判断excel单元格内容的格式，并对其进行转换，以便插入数据库
  304. 					case 0:
  305. 						cellValue = String.valueOf((int) cell
  306. 								.getNumericCellValue());
  307. 						break;
  308. 					case 1:
  309. 						cellValue = cell.getStringCellValue();
  310. 						break;
  311. 					case 2:
  312. 						cellValue = cell.getStringCellValue();
  313. 						break;
  314. 					}
  315.  
  316. 					switch (j) {// 通过列数来判断对应插如的字段
  317. 					case 1:
  318. 						gonggao.setGonggaoName(cellValue);
  319. 						break;
  320. 					case 2:
  321. 						gonggao.setGonggaoMark(cellValue);
  322. 						break;
  323. 					}
  324. 				}
  325. 				gonggaoService.save(gonggao);
  326. 			}
  327. 			JSONObject result = new JSONObject();
  328. 			result.put("success", "true");
  329. 			ResponseUtil.write(response, result);
  330. 		} catch (Exception e) {
  331. 			e.printStackTrace();
  332. 		}
  333. 	}
  334.  
  335. 	@RequestMapping("/daochuGonggao")
  336. 	public void daochuGonggao(HttpServletRequest request, HttpServletResponse response)
  337. 			throws Exception {
  338. 		String delIds = (String) request.getParameter("delIds");
  339. 		JSONObject result = new JSONObject();
  340. 		String str[] = delIds.split(",");
  341.  
  342. 		// 创建一个Excel文件
  343. 		HSSFWorkbook workbook = new HSSFWorkbook();
  344. 		// 创建一个工作表
  345. 		HSSFSheet sheet = workbook.createSheet("gonggaos记录");
  346. 		// 添加表头行
  347. 		HSSFRow hssfRow = sheet.createRow(0);
  348. 		// 设置单元格格式居中
  349. 		HSSFCellStyle cellStyle = workbook.createCellStyle();
  350. 		cellStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  351.  
  352. 		// 添加表头内容
  353. 		HSSFCell headCell = hssfRow.createCell(0);
  354. 		headCell.setCellValue("编号");
  355. 		headCell.setCellStyle(cellStyle);
  356.  
  357. 		headCell = hssfRow.createCell(1);
  358. 		headCell.setCellValue("用户名");
  359. 		headCell.setCellStyle(cellStyle);
  360.  
  361. 		headCell = hssfRow.createCell(2);
  362. 		headCell.setCellValue("密码");
  363. 		headCell.setCellStyle(cellStyle);
  364.  
  365. 		headCell = hssfRow.createCell(3);
  366. 		headCell.setCellValue("姓名");
  367. 		headCell.setCellStyle(cellStyle);
  368.  
  369. 		headCell = hssfRow.createCell(4);
  370. 		headCell.setCellValue("性别");
  371. 		headCell.setCellStyle(cellStyle);
  372.  
  373. 		headCell = hssfRow.createCell(5);
  374. 		headCell.setCellValue("年龄");
  375. 		headCell.setCellStyle(cellStyle);
  376.  
  377. 		headCell = hssfRow.createCell(6);
  378. 		headCell.setCellValue("电话");
  379. 		headCell.setCellStyle(cellStyle);
  380.  
  381. 		headCell = hssfRow.createCell(7);
  382. 		headCell.setCellValue("备注1");
  383. 		headCell.setCellStyle(cellStyle);
  384.  
  385. 		headCell = hssfRow.createCell(8);
  386. 		headCell.setCellValue("备注2");
  387. 		headCell.setCellStyle(cellStyle);
  388.  
  389. 		headCell = hssfRow.createCell(9);
  390. 		headCell.setCellValue("备注3");
  391. 		headCell.setCellStyle(cellStyle);
  392.  
  393. 		headCell = hssfRow.createCell(10);
  394. 		headCell.setCellValue("备注4");
  395. 		headCell.setCellStyle(cellStyle);
  396.  
  397. 		headCell = hssfRow.createCell(13);
  398. 		headCell.setCellValue("标志1");
  399. 		headCell.setCellStyle(cellStyle);
  400.  
  401. 		headCell = hssfRow.createCell(14);
  402. 		headCell.setCellValue("备注2");
  403. 		headCell.setCellStyle(cellStyle);
  404.  
  405. 		headCell = hssfRow.createCell(15);
  406. 		headCell.setCellValue("权限");
  407. 		headCell.setCellStyle(cellStyle);
  408.  
  409. 		headCell = hssfRow.createCell(16);
  410. 		headCell.setCellValue("部门");
  411. 		headCell.setCellStyle(cellStyle);
  412.  
  413. 		// 添加数据内容
  414. 		for (int i = 0; i < str.length; i++) {
  415. 			hssfRow = sheet.createRow((int) i + 1);
  416. 			Gonggao gonggao = gonggaoService.getGonggao(Integer.parseInt(str[i]));
  417.  
  418. 			// 创建单元格，并设置值
  419. 			HSSFCell cell = hssfRow.createCell(0);
  420. 			cell.setCellValue(gonggao.getGonggaoId());
  421. 			cell.setCellStyle(cellStyle);
  422.  
  423. 			cell = hssfRow.createCell(1);
  424. 			cell.setCellValue(gonggao.getGonggaoName());
  425. 			cell.setCellStyle(cellStyle);
  426.  
  427. 			cell = hssfRow.createCell(7);
  428. 			cell.setCellValue(gonggao.getGonggaoMark());
  429. 			cell.setCellStyle(cellStyle);
  430.  
  431. 			cell = hssfRow.createCell(16);
  432. 			cell.setCellValue(gonggao.getGgtypeName());
  433. 			cell.setCellStyle(cellStyle);
  434. 		}
  435.  
  436. 		// 保存Excel文件
  437. 		try {
  438. 			Date date = new Date();
  439. 			String strdate = DateUtil.formatDate(date, "yyyyMMddhhmmss");
  440. 			OutputStream outputStream = new FileOutputStream("D:/gonggao"
  441. 					+ strdate + ".xls");
  442. 			workbook.write(outputStream);
  443. 			outputStream.close();
  444. 			result.put("success", "true");
  445. 			ResponseUtil.write(response, result);
  446. 		} catch (Exception e) {
  447. 			e.printStackTrace();
  448. 		}
  449. 	}
  450. }
  451.

五，项目总结

   本项目主要基于物流信息的基本管理功能实现的一个信息化管理系统，客户登陆系统后可以添加货物并进行运输信息的选择和添加，普通用户进入系统可以对用户的发货信息进行审核，并根据运输情况改变运输状态，客户在货物运达后可以进行验收操作。整个业务流程十分完整。管理员主要进行基础信息的基本管理，也可以进行相关的业务操作。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/155677
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号