• java项目-基于SSM实现物流信息管理系统

    作者主页：编程指南针

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

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

    文末获取源码 

    一，项目简介

    基于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.

    五，项目总结

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

  • 相关阅读:
    volatile与Java内存模型
    windows域控制器损坏修复过程
    WebRTC源码分析 nack详解
    你不知道并且没听说过的js原生网页共享接口
    【华为认证超全科普帖】
    OCR:C++ PaddleOCR C++ PaddleOCR vs2019 （CPU版）保姆教程
    【招聘岗位】基础设施软件开发人员
    【10.30】【VP】Codeforces Round #735 (Div. 2)
    是否可以嗅探 HTTPS URL？
    YOLOV1详解——Pytorch版
  • 原文地址：https://blog.csdn.net/whirlwind526/article/details/125395918