java wms物流管理 基于javaweb的物流管理系统

基于javaweb的物流快递管理系统(java+ssm+html+js+jsp+mysql)

运行环境

Java≥8、MySQL≥5.7、Tomcat≥8

开发工具

eclipse/idea/myeclipse/sts等均可配置运行

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb+mysql的物流快递管理系统(java+SSM+HTML+JS+jsp+mysql)

项目介绍

仓库管理员角色包含以下功能： 仓库管理员操作,入库操作,员工查看,揽收快件,新建员工等功能。

快递员角色包含以下功能： 员工操作,员工登录,操作成功等功能。

用户角色包含以下功能： 发快递成功,发送快递,查看快递等功能。

管理员角色包含以下功能： 管理员查看全局快递信息等功能。

环境需要

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版本；

技术栈

1. 后端：Spring+SpringMVC+Mybatis 2. 前端：HTML+CSS+JavaScript+jsp

使用说明

1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件； 2. 使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven;若为maven项目，导入成功后请执行maven clean;maven install命令，然后运行； 3. 将项目中application.yml配置文件中的数据库配置改为自己的配置; 4. 运行项目，输入localhost:8080/ 登录

订单管理控制层：

@Controller
@RequestMapping(“/order”)
public class OrderController {
@Autowired
private OrderViewService orderViewService;
@Autowired
private OrderService orderService;
@Autowired
private UserService userService;
@Autowired
private CustomerService customerService;
@Autowired
private BasicDataService basicDataService;
@Autowired
private OrderDetailService orderDetailService;
//工具方法
public PageInfo getOrdersUtil(String keyWord, Integer pageNum, Integer pageSize) {
//开始分页，这里启动并设置页码，和每页结果数量后，后续结果会自动为分页后结果
PageHelper.startPage(pageNum, pageSize);
OrderViewExample orderViewExample = new OrderViewExample();
OrderViewExample.Criteria criteria = orderViewExample.createCriteria();
/**
• StringUtils.isNotBlank 可以判断 “”/" "/null 为 false
*/
if (StringUtils.isNotBlank(keyWord)) {
//客户名条件
criteria.andCustomerNameLike(“%” + keyWord + “%”);
//判断当前登录用户是否为业务员，业务员只能查看自己的订单
Subject subject = SecurityUtils.getSubject();
User user = (User) subject.getPrincipal();
if (user.getRoleId() == ConstantDataField.SALESMAN_ROLE_ID) {
//客户的业务员用户名等于登录用户的用户名
criteria.andUsernameEqualTo(user.getUsername());
List orders = orderViewService.selectByExample(orderViewExample);
//获得分页对象
PageInfo pageInfo = new PageInfo<>(orders);
return pageInfo;
@RequestMapping(“/list”)
@RequiresPermissions(“order:list”)
public String list() {
return “order/list”;
@ResponseBody
@RequestMapping(“/getOrders”)
@RequiresPermissions(“order:list”)
public PageInfo getOrders(String keyWord,
@RequestParam(defaultValue = “1”) Integer pageNum,
@RequestParam(defaultValue = “10”) Integer pageSize) {
return getOrdersUtil(keyWord, pageNum, pageSize);
@ResponseBody
@RequestMapping(“/delete”)
@RequiresPermissions(“order:delete”)
public Map<String, String> delete(Long[] orderIds) {
HashMap<String, String> map = new HashMap<>();
//单个删除
if (orderIds.length == 1) {
int res = orderService.deleteByPrimaryKey(orderIds[0]);
if (res == 1) {
map.put(“status”, “true”);
map.put(“info”, “删除成功！”);
return map;
map.put(“status”, “false”);
map.put(“info”, “删除失败！订单已经不存在”);
return map;
//批量删除
int success = 0;
int total = orderIds.length;
for(Long orderId : orderIds) {
success += orderService.deleteByPrimaryKey(orderId);
map.put(“status”, “true”);
map.put(“info”, “成功删除选中 " + total + " 个订单中的 " + success + " 个订单”);
return map;
@RequestMapping(“/add”)
@RequiresPermissions(“order:insert”)
public String add(Model m) {
this.getOrderGeneralData(m);
return “order/add”;
/*
用 @RequestBody 注解，将前台传入的 JSON 字符串解析成对象
*/
@RequestMapping(“/insert”)
@RequiresPermissions(“order:insert”)
@ResponseBody
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED, timeout = 5)
public Boolean insert(@RequestBody Order order) {
//插入 order，在此之后，order 获得了 orderId
int res = orderService.insert(order);
//获取订单详情集合
List orderDetails = order.getorderDetails();
orderDetails.forEach(orderDetail -> {
orderDetail.setOrderId(order.getOrderId());
orderDetailService.insert(orderDetail);
});
if (res == 1) {
return true;
return false;
@RequestMapping(“/edit”)
@RequiresPermissions(“order:update”)
public String edit(Long orderId, Model m) {
//获取常规数据
getOrderGeneralData(m);
//添加选中的订单
Order selectedOrder = orderService.selectByPrimaryKey(orderId);
m.addAttribute(“selectedOrder”, selectedOrder);
//添加订单详情
OrderDetailExample orderDetailExample = new OrderDetailExample();
orderDetailExample.createCriteria().andOrderIdEqualTo(orderId);
List orderDetails = orderDetailService.selectByExample(orderDetailExample);
m.addAttribute(“orderDetails”, orderDetails);
return “order/edit”;
@RequiresPermissions(“order:update”)
@RequestMapping(“/update”)
@ResponseBody
public Boolean update(@RequestBody Order order) {
OrderDetailExample orderDetailExample = new OrderDetailExample();
orderDetailExample.createCriteria().andOrderIdEqualTo(order.getOrderId());
List dbOrderDetails = orderDetailService.selectByExample(orderDetailExample); //数据库中的orderDetails
List formOrderDetails = order.getorderDetails(); //表单数据中的orderDetails
//循环比较数据库数据和表单新数据，删除数据库中在修改中删除的数据
dbOrderDetails.forEach(dbOrderDetail -> {
if (!formOrderDetails.contains(dbOrderDetail)) {
orderDetailService.deleteByPrimaryKey(dbOrderDetail.getOrderDetailId());
});
//循环比较表单新数据和数据库数据，若存在则修改，不存在则新增
formOrderDetails.forEach(formOrderDetail -> {
if (dbOrderDetails.contains(formOrderDetail)) {
orderDetailService.updateByPrimaryKeySelective(formOrderDetail);
} else {
formOrderDetail.setOrderId(order.getOrderId());
orderDetailService.insert(formOrderDetail);
});
//修改Order
int res = orderService.updateByPrimaryKey(order);
if (res == 1){
return true;
return false;
//抽取的工具方法
private void getOrderGeneralData(Model m){
User user = (User)SecurityUtils.getSubject().getPrincipal(); //获取当前用户
Long userRoleId = user.getRoleId(); //当前用户角色ID
Long userId = user.getUserId(); //当前用户ID
//查找业务员
UserExample userExample = new UserExample();
List users = new ArrayList<>();
//如果当前用户是业务员只能用自己用户添加
if (userRoleId == ConstantDataField.SALESMAN_ROLE_ID) {
users.add(userService.selectByPrimaryKey(userId));
} else {
userExample.createCriteria().andRoleIdEqualTo(ConstantDataField.SALESMAN_ROLE_ID);
users = userService.selectByExample(userExample);
m.addAttribute(“users”, users);
//查找客户
CustomerExample customerExample = new CustomerExample();
List customers;
//如果当前用户是业务员只能获得自己的客户
if (userRoleId == ConstantDataField.SALESMAN_ROLE_ID) {
customerExample.createCriteria().andUserIdEqualTo(userId);
customers = customerService.selectByExample(customerExample);
} else {
customers = customerService.selectByExample(customerExample);
m.addAttribute(“customers”, customers);
//查找地区
BasicDataExample areaExample = new BasicDataExample();
areaExample.createCriteria().andParentIdEqualTo(ConstantDataField.AREA_BASICDATA_ID);
List areas = basicDataService.selectByExample(areaExample);
m.addAttribute(“areas”, areas);
//查找付款方式
BasicDataExample paymentExample = new BasicDataExample();
paymentExample.createCriteria().andParentIdEqualTo(ConstantDataField.PAYMENT_BASICDATA_ID);
List payments = basicDataService.selectByExample(paymentExample);
m.addAttribute(“payments”, payments);
//查找运送方式
BasicDataExample transportExample = new BasicDataExample();
transportExample.createCriteria().andParentIdEqualTo(ConstantDataField.TRANSPORT_BASICDATA_ID);
List transports = basicDataService.selectByExample(transportExample);
m.addAttribute(“transports”, transports);
//查找取件方式
BasicDataExample pickupExample = new BasicDataExample();
pickupExample.createCriteria().andParentIdEqualTo(ConstantDataField.PICKUP_BASICDATA_ID);
List pickups = basicDataService.selectByExample(pickupExample);
m.addAttribute(“pickups”, pickups);
//查找单位
BasicDataExample unitExample = new BasicDataExample();
unitExample.createCriteria().andParentIdEqualTo(ConstantDataField.UNIT_BASICDATA_ID);
List units = basicDataService.selectByExample(unitExample);
m.addAttribute(“units”, units);
用户管理控制层：
@Controller
@RequestMapping(“/customer”)
public class CustomerController {
@Autowired
private CustomerViewService customerViewService;
@Autowired
private CustomerService customerService;
@Autowired
private BasicDataService basicDataService;
@Autowired
private UserService userService;
@RequestMapping(“/list”)
@RequiresPermissions(“customer:list”)
public String list() {
return “customer/list”;
@ResponseBody
@RequestMapping(“/getCustomers”)
@RequiresPermissions(“customer:list”)
public PageInfo getCustomers(String keyWord,
@RequestParam(defaultValue = “1”) Integer pageNum,
@RequestParam(defaultValue = “10”) Integer pageSize) {
//开始分页，这里启动并设置页码，和每页结果数量后，后续结果会自动为分页后结果
PageHelper.startPage(pageNum, pageSize);
CustomerViewExample customerViewExample = new CustomerViewExample();
CustomerViewExample.Criteria criteria = customerViewExample.createCriteria();
/**
• StringUtils.isNotBlank 可以判断 “”/" "/null 为 false
*/
if (StringUtils.isNotBlank(keyWord)) {
//权限名条件
criteria.andCustomerNameLike(“%” + keyWord + “%”);
//判断当前登录用户是否为业务员，业务员只能查看自己的客户
Subject subject = SecurityUtils.getSubject();
User user = (User) subject.getPrincipal();
if (user.getRoleId() == ConstantDataField.SALESMAN_ROLE_ID) {
//客户的业务员id等于登录用户的id
criteria.andUserIdEqualTo(user.getUserId());
List customers = customerViewService.selectByExample(customerViewExample);
//获得分页对象
PageInfo pageInfo = new PageInfo<>(customers);
return pageInfo;
@ResponseBody
@RequestMapping(“/delete”)
@RequiresPermissions(“customer:delete”)
public Map<String, String> delete(Long[] customerIds) {
HashMap<String, String> map = new HashMap<>();
if (customerIds.length == 1) {
int res = customerService.deleteByPrimaryKey(customerIds[0]);
if (res == 1) {
map.put(“status”, “true”);
map.put(“info”, “删除成功！”);
return map;
map.put(“status”, “false”);
map.put(“info”, “删除失败！客户已经不存在”);
return map;
//批量删除
int success = 0;
int total = customerIds.length;
for(Long customerId : customerIds) {
success += customerService.deleteByPrimaryKey(customerId);
map.put(“status”, “true”);
map.put(“info”, “成功删除选中 " + total + " 个客户中的 " + success + " 个客户”);
return map;
@RequestMapping(“/add”)
@RequiresPermissions(“customer:insert”)
public String add(Model m) {
//查出地区列表
BasicDataExample basicDataExample = new BasicDataExample();
basicDataExample.createCriteria().andParentIdEqualTo(ConstantDataField.AREA_BASICDATA_ID);
List basicDatas= basicDataService.selectByExample(basicDataExample);
m.addAttribute(“areas”,basicDatas);
//获取当前登录用户
Subject subject = SecurityUtils.getSubject();
User user = (User) subject.getPrincipal();
//如果是业务员进行操作，只能选择自己作为业务员
List users = new ArrayList<>();
if (user.getRoleId() == ConstantDataField.SALESMAN_ROLE_ID) {
users.add(user);
} else {
UserExample userExample = new UserExample();
userExample.createCriteria().andRoleIdEqualTo(ConstantDataField.SALESMAN_ROLE_ID);
users = userService.selectByExample(userExample);
m.addAttribute(“users”, users);
return “customer/add”;
@ResponseBody
@RequestMapping(“/insert”)
@RequiresPermissions(“customer:insert”)
public Boolean insert(Customer customer){
int res = customerService.insert(customer);
if (res == 1) {
return true;
return false;
@RequestMapping(“/edit”)
@RequiresPermissions(“customer:update”)
public String edit(Model m, Long customerId) {
//查出地区列表
BasicDataExample basicDataExample = new BasicDataExample();
basicDataExample.createCriteria().andParentIdEqualTo(ConstantDataField.AREA_BASICDATA_ID);
List basicDatas= basicDataService.selectByExample(basicDataExample);
m.addAttribute(“areas”,basicDatas);
//查出业务员
UserExample userExample = new UserExample();
userExample.createCriteria().andRoleIdEqualTo(ConstantDataField.SALESMAN_ROLE_ID);
List users = userService.selectByExample(userExample);
m.addAttribute(“users”, users);
//查出当前客户
Customer customer = customerService.selectByPrimaryKey(customerId);
m.addAttribute(“customer”, customer);
return “customer/edit”;
@ResponseBody
@RequestMapping(“/update”)
@RequiresPermissions(“customer:update”)
public Boolean update(Customer customer) {
int res = customerService.updateByPrimaryKeySelective(customer);
if (res == 1) {
return true;
return false;
业务管理控制层：
@RequestMapping(“/transaction”)
@Controller
public class TransactionController {
@Autowired
private OrderController orderController;
@Autowired
private OrderViewService orderViewService;
@Autowired
private OrderService orderService;
@Autowired
private BasicDataService basicDataService;
@Autowired
private OrderDetailService orderDetailService;
@Autowired
private UserService userService;
@Autowired
private TransactionService transactionService;
@Autowired
private TransactionDetailService transactionDetailService;
@Autowired
private InfoService infoService;
@Autowired
private ExportService exportService;
@Autowired
private ExportDetailService exportDetailService;
@RequestMapping(“/list”)
@RequiresPermissions(“transaction:deal”)
public String list() {
return “transaction/list”;
@RequestMapping(“/getOrders”)
@RequiresPermissions(“transaction:deal”)
@ResponseBody
public PageInfo getOrders(String keyWord,
@RequestParam(defaultValue = “1”) Integer pageNum,
@RequestParam(defaultValue = “10”) Integer pageSize) {
return orderController.getOrdersUtil(keyWord, pageNum, pageSize);
@RequestMapping(“/deal”)
public String deal(Model m, Long orderId) {
Order order = orderService.selectByPrimaryKey(orderId);
OrderViewExample orderViewExample = new OrderViewExample();
orderViewExample.createCriteria().andOrderIdEqualTo(orderId);
OrderView orderView = orderViewService.selectByExample(orderViewExample).get(0);
String area = basicDataService.selectByPrimaryKey(order.getIntervalId()).getBaseName();
String payment = basicDataService.selectByPrimaryKey(order.getPaymentMethodId()).getBaseName();
String shippingMethod = basicDataService.selectByPrimaryKey(order.getFreightMethodId()).getBaseName();
String pickUpMethod = basicDataService.selectByPrimaryKey(order.getTakeMethodId()).getBaseName();
BasicDataExample basicDataExample = new BasicDataExample();
basicDataExample.createCriteria().andParentIdEqualTo(ConstantDataField.STORAGE_BASICDATA_ID);
List storages = basicDataService.selectByExample(basicDataExample);
OrderDetailExample orderDetailExample = new OrderDetailExample();
orderDetailExample.createCriteria().andOrderIdEqualTo(orderId);
List orderDetails = orderDetailService.selectByExample(orderDetailExample);
BasicDataExample basicDataExample1 = new BasicDataExample();
basicDataExample.createCriteria().andParentIdEqualTo(ConstantDataField.UNIT_BASICDATA_ID);
List units = basicDataService.selectByExample(basicDataExample1);
UserExample userExample = new UserExample();
userExample.createCriteria().andRoleIdEqualTo(ConstantDataField.STORAGE_ROLE_ID);
List users = userService.selectByExample(userExample);
TransactionExample transactionExample = new TransactionExample();
transactionExample.createCriteria().andOrderIdEqualTo(orderId);
List transactions = transactionService.selectByExample(transactionExample);
List transactionDetails = new ArrayList<>();
orderDetails.forEach(orderDetail -> {
TransactionDetailExample transactionDetailExample = new TransactionDetailExample();
transactionDetailExample.createCriteria().andOrderDetailIdEqualTo(orderDetail.getOrderDetailId());
List details = transactionDetailService.selectByExample(transactionDetailExample);
if (details.size() == 0){
transactionDetails.add(null);
} else {
transactionDetails.add(details.get(0));
});
Subject subject = SecurityUtils.getSubject();
Boolean allowedQuote = subject.isPermitted(“transaction:quote”);
Boolean allowedStorage = subject.isPermitted(“transaction:storage”);
m.addAttribute(“order”, order);
m.addAttribute(“orderView”, orderView);
m.addAttribute(“area”, area);
m.addAttribute(“payment”, payment);
m.addAttribute(“shippingMethod”, shippingMethod);
m.addAttribute(“pickUpMethod”, pickUpMethod);
m.addAttribute(“storages”, storages);
m.addAttribute(“orderDetails”, orderDetails);
m.addAttribute(“units”, units);
m.addAttribute(“users”, users);
if (transactions.size() > 0) {
m.addAttribute(“transaction”, transactions.get(0));
} else {
m.addAttribute(“transaction”, null);
m.addAttribute(“transactionDetails”,transactionDetails);
m.addAttribute(“allowedQuote”, allowedQuote);
m.addAttribute(“allowedStorage”, allowedStorage);
return “transaction/deal”;
@RequestMapping(“/update”)
@RequiresPermissions(“transaction:deal”)
@ResponseBody
public Boolean update(@RequestBody Transaction transaction){
//判断是否存在
TransactionExample transactionExample = new TransactionExample();
transactionExample.createCriteria().andOrderIdEqualTo(transaction.getOrderId());
int res;
if (transactionService.selectByExample(transactionExample).size() == 0 ) {
res = transactionService.insert(transaction);
} else {
res = transactionService.updateByPrimaryKeySelective(transaction);
List transactionDetails = transaction.getTransactionDetails();
transactionDetails.forEach(transactionDetail -> {
if (transactionDetail.getTransactionDetailId() == null){
transactionDetailService.insert(transactionDetail);
} else {
transactionDetailService.updateByPrimaryKeySelective(transactionDetail);
});
//修改为入库
Order order = orderService.selectByPrimaryKey(transaction.getOrderId());
order.setOrderStatus(1);
orderService.updateByPrimaryKeySelective(order);
if (res == 1) {
return true;
return false;
@RequestMapping(“/export”)
@RequiresPermissions(“transaction:export”)
public String export(Model m, Long orderId) {
//判定是否入库了，若否，返回错误页面
Order order = orderService.selectByPrimaryKey(orderId);
if (order.getOrderStatus() == 0) {
m.addAttribute(“errorMsg”,“该订单还未报价入库！”);
return “transaction/error”;
Info info = null;
try {
info = resolveInfo(orderId);
} catch (Exception e) {
m.addAttribute(“errorMsg”, “出现异常，请检查是否完成报价入库！”);
return “transaction/error”;
Info dbInfo = infoService.selectByPrimaryKey(orderId);
if (dbInfo == null) {
infoService.insert(info);
} else {
infoService.updateByPrimaryKeySelective(info);
ExportExample exportExample = new ExportExample();
exportExample.createCriteria().andOrderIdEqualTo(orderId);
Export export = exportService.selectByExample(exportExample).get(0);
m.addAttribute(“export”, export);
ExportDetailExample exportDetailExample = new ExportDetailExample();
exportDetailExample.createCriteria().andOrderIdEqualTo(orderId);
List exportDetails = exportDetailService.selectByExample(exportDetailExample);
m.addAttribute(“exportDetails”, exportDetails);
TransactionExample transactionExample = new TransactionExample();
transactionExample.createCriteria().andOrderIdEqualTo(orderId);
Transaction transaction = transactionService.selectByExample(transactionExample).get(0);
m.addAttribute(“transaction”, transaction);
m.addAttribute(“info”, info);
return “transaction/export”;
@RequiresPermissions(“transaction:export”)
@RequestMapping(“/print”)
public void print(HttpServletResponse response, Long orderId){
//查找处需要的信息
Info info = infoService.selectByPrimaryKey(orderId);
ExportExample exportExample = new ExportExample();
exportExample.createCriteria().andOrderIdEqualTo(orderId);
Export export = exportService.selectByExample(exportExample).get(0);
ExportDetailExample exportDetailExample = new ExportDetailExample();
exportDetailExample.createCriteria().andOrderIdEqualTo(orderId);
List exportDetails = exportDetailService.selectByExample(exportDetailExample);
TransactionExample transactionExample = new TransactionExample();
transactionExample.createCriteria().andOrderIdEqualTo(orderId);
Transaction transaction = transactionService.selectByExample(transactionExample).get(0);
//excel 制作
HSSFWorkbook book = new HSSFWorkbook();
HSSFSheet sheet = book.createSheet();
HSSFRow row_0 = sheet.createRow(0);
sheet.addMergedRegion(new CellRangeAddress(0,0,1,3));
sheet.addMergedRegion(new CellRangeAddress(0,0,5,7));
sheet.addMergedRegion(new CellRangeAddress(0,0,9,11));
row_0.createCell(0).setCellValue(“订单编号”);
row_0.createCell(1).setCellValue(export.getOrderId());
row_0.createCell(4).setCellValue(“业务员”);
row_0.createCell(5).setCellValue(export.getStaff());
row_0.createCell(8).setCellValue(“客户”);
row_0.createCell(9).setCellValue(export.getCustomerName());
HSSFRow row_1 = sheet.createRow(1);
sheet.addMergedRegion(new CellRangeAddress(1,1,1,3));
sheet.addMergedRegion(new CellRangeAddress(1,1,5,7));
sheet.addMergedRegion(new CellRangeAddress(1,1,9,11));
row_1.createCell(0).setCellValue(“到达国家”);
row_1.createCell(1).setCellValue(export.getArea());
row_1.createCell(4).setCellValue(“收货地址”);
row_1.createCell(5).setCellValue(export.getShippingAddress());
row_1.createCell(8).setCellValue(“收件人”);
row_1.createCell(9).setCellValue(export.getShippingName());
HSSFRow row_2 = sheet.createRow(2);
sheet.addMergedRegion(new CellRangeAddress(2,2,1,3));
sheet.addMergedRegion(new CellRangeAddress(2,2,5,7));
sheet.addMergedRegion(new CellRangeAddress(2,2,9,11));
row_2.createCell(0).setCellValue(“联系电话”);
row_2.createCell(1).setCellValue(export.getShippingPhone());
row_2.createCell(4).setCellValue(“付款方式”);
row_2.createCell(5).setCellValue(export.getPayment());
row_2.createCell(8).setCellValue(“货运方式”);
row_2.createCell(9).setCellValue(export.getShippingMethod());
HSSFRow row_3 = sheet.createRow(3);
sheet.addMergedRegion(new CellRangeAddress(3,3,1,3));
sheet.addMergedRegion(new CellRangeAddress(3,3,5,7));
sheet.addMergedRegion(new CellRangeAddress(3,3,9,11));
row_3.createCell(0).setCellValue(“取件方式”);
row_3.createCell(1).setCellValue(export.getPickupMehtod());
row_3.createCell(4).setCellValue(“入库人”);
row_3.createCell(5).setCellValue(export.getStorageStaff());
row_3.createCell(8).setCellValue(“入库选择”);
row_3.createCell(9).setCellValue(export.getStorage());
HSSFRow row_4 = sheet.createRow(4);
sheet.addMergedRegion(new CellRangeAddress(4,4,0,11));
row_4.createCell(0).setCellValue(“费用明细”);
HSSFRow row_5 = sheet.createRow(5);
sheet.addMergedRegion(new CellRangeAddress(5,5,1,3));
sheet.addMergedRegion(new CellRangeAddress(5,5,5,7));
sheet.addMergedRegion(new CellRangeAddress(5,5,9,11));
row_5.createCell(0).setCellValue(“体积收费”);
row_5.createCell(1).setCellValue(export.getVolumeFee());
row_5.createCell(4).setCellValue(“总体积”);
row_5.createCell(5).setCellValue(export.getTotalVolume());
row_5.createCell(8).setCellValue(“体积费率”);
row_5.createCell(9).setCellValue(transaction.getVolumeRate());
HSSFRow row_6 = sheet.createRow(6);
sheet.addMergedRegion(new CellRangeAddress(6,6,1,3));
sheet.addMergedRegion(new CellRangeAddress(6,6,5,7));
sheet.addMergedRegion(new CellRangeAddress(6,6,9,11));
row_6.createCell(0).setCellValue(“重量收费”);
row_6.createCell(1).setCellValue(export.getWeightFee());
row_6.createCell(4).setCellValue(“总重量”);
row_6.createCell(5).setCellValue(export.getTotalWeight());
row_6.createCell(8).setCellValue(“重量费率”);
row_6.createCell(9).setCellValue(transaction.getWeightRate());
HSSFRow row_7 = sheet.createRow(7);
sheet.addMergedRegion(new CellRangeAddress(7,7,1,3));
sheet.addMergedRegion(new CellRangeAddress(7,7,5,7));
sheet.addMergedRegion(new CellRangeAddress(7,7,9,11));
row_7.createCell(0).setCellValue(“过关税费”);
row_7.createCell(1).setCellValue(export.getTaxFee());
row_7.createCell(4).setCellValue(“总价值”);
row_7.createCell(5).setCellValue(export.getTotalValue());
row_7.createCell(8).setCellValue(“税率”);
row_7.createCell(9).setCellValue(info.getTaxRate());
HSSFRow row_8 = sheet.createRow(8);
sheet.addMergedRegion(new CellRangeAddress(8,8,1,11));
row_8.createCell(0).setCellValue(“取件费用”);
row_8.createCell(1).setCellValue(export.getPickUpFee());
HSSFRow row_9 = sheet.createRow(9);
sheet.addMergedRegion(new CellRangeAddress(9,9,1,11));
row_9.createCell(0).setCellValue(“总费用”);
row_9.createCell(1).setCellValue(export.getTotalFee());
HSSFRow row_10 = sheet.createRow(10);
sheet.addMergedRegion(new CellRangeAddress(10,10,0,11));
row_10.createCell(0).setCellValue(“货物清单”);
HSSFRow row_11 = sheet.createRow(11);
sheet.addMergedRegion(new CellRangeAddress(11,11,0,1));
sheet.addMergedRegion(new CellRangeAddress(11,11,7,8));
sheet.addMergedRegion(new CellRangeAddress(11,11,9,10));
row_11.createCell(0).setCellValue(“货物名称”);
row_11.createCell(2).setCellValue(“数量”);
row_11.createCell(3).setCellValue(“单位”);
row_11.createCell(4).setCellValue(“长”);
row_11.createCell(5).setCellValue(“宽”);
row_11.createCell(6).setCellValue(“高”);
row_11.createCell(7).setCellValue(“核算体积”);
row_11.createCell(9).setCellValue(“核算重量”);
row_11.createCell(11).setCellValue(“总价值”);
for(int i = 0; i < exportDetails.size(); i++) {
HSSFRow row = sheet.createRow(i + 12);
sheet.addMergedRegion(new CellRangeAddress(i+12,i+12,0,1));
sheet.addMergedRegion(new CellRangeAddress(i+12,i+12,7,8));
sheet.addMergedRegion(new CellRangeAddress(i+12,i+12,9,10));
row.createCell(0).setCellValue(exportDetails.get(i).getGoodsName());
row.createCell(2).setCellValue(exportDetails.get(i).getGoodsNumber());
row.createCell(3).setCellValue(exportDetails.get(i).getGoodsUnit());
row.createCell(4).setCellValue(exportDetails.get(i).getLength());
row.createCell(5).setCellValue(exportDetails.get(i).getWidth());
row.createCell(6).setCellValue(exportDetails.get(i).getHeight());
row.createCell(7).setCellValue(exportDetails.get(i).getVolume());
row.createCell(9).setCellValue(exportDetails.get(i).getWeight());
row.createCell(11).setCellValue(exportDetails.get(i).getGoodsTotal());
try {
response.addHeader(“Content-Disposition”,
“attachment;filename=” + new String(“财务审核表.xls”.getBytes(), “ISO-8859-1”));
book.write(response.getOutputStream());
} catch (Exception e) {
e.printStackTrace();
//添加info 方法
private Info resolveInfo(Long orderId) {
Info info = new Info();
info.setOrderId(orderId);
Double totalVolume = 0.0;
Double totalWeight = 0.0;
Double totalValue =0.0;
Double taxRate = 0.0;
Double weightFee = 0.0;
Double volumeFee = 0.0;
Double taxFee = 0.0;
Double totalFee = 0.0;
//获取订单
Order order = orderService.selectByPrimaryKey(orderId);
//获得税率
if (order.getFreightMethodId() == ConstantDataField.SEA_BASICDATA_ID){
if (order.getIntervalId() == ConstantDataField.SINGAPORE_BASICDATA_ID || order.getIntervalId() == ConstantDataField.AUSTRALIA_BASICDATA_ID) {
taxRate = 0.07;
//获取业务
TransactionExample transactionExample = new TransactionExample();
transactionExample.createCriteria().andOrderIdEqualTo(orderId);
Transaction transaction = transactionService.selectByExample(transactionExample).get(0);
//获取订单详情
OrderDetailExample orderDetailExample = new OrderDetailExample();
orderDetailExample.createCriteria().andOrderIdEqualTo(orderId);
List orderDetails = orderDetailService.selectByExample(orderDetailExample);
//获取业务详情，同时计算出总重量、总体积、总价值
for (OrderDetail orderDetail : orderDetails) {
TransactionDetailExample transactionDetailExample = new TransactionDetailExample();
transactionDetailExample.createCriteria().andOrderDetailIdEqualTo(orderDetail.getOrderDetailId());
List transactionDetails = transactionDetailService.selectByExample(transactionDetailExample);
//计算
totalValue += orderDetail.getGoodsTotal();
for (TransactionDetail transactionDetail : transactionDetails) {
totalVolume += transactionDetail.getVolume();
totalWeight += transactionDetail.getWeight();
//重量价格
if (totalWeight / totalVolume < 200) {
weightFee = totalVolume * 200 * transaction.getWeightRate();
} else {
weightFee = totalWeight * transaction.getWeightRate();
//体积价格
volumeFee = totalVolume * transaction.getVolumeRate();
taxFee = totalValue * taxRate;
totalFee = weightFee + taxFee + volumeFee + transaction.getPickUpFee();
info.setTaxFee(taxFee);
info.setTaxRate(taxRate);
info.setTotalFee(totalFee);
info.setTotalValue(totalValue);
info.setTotalWeight(totalWeight);
info.setTotalVolume(totalVolume);
info.setVolumeFee(volumeFee);
info.setWeightFee(weightFee);
return info;

---