devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java项目:校园物流快递管理系统(java+maven+JSP+SpringBoot+layui+mysql)_java校园流项目

作者：我家小花儿 | 2024-02-27 19:59:53

赞

踩

java校园流项目

源码获取：博客首页 "资源" 里下载！

一、项目运行

环境配置：

Jdk1.8 + Tomcat8.5 + mysql + Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）

项目技术：

JSP +SpringBoot + MyBatis + html+ css + JavaScript + JQuery + Ajax + layui+ maven等等。


 

 

 

 

 

 

客户管理控制层：

  1. @Controller
  2. @RequestMapping("/customer")
  3. public class CustomerController {
  4.     @Autowired
  5.     private CustomerViewService customerViewService;
  6.     @Autowired
  7.     private CustomerService customerService;
  8.     @Autowired
  9.     private BasicDataService basicDataService;
  10.     @Autowired
  11.     private UserService userService;
  12.  
  13.     @RequestMapping("/list")
  14.     @RequiresPermissions("customer:list")
  15.     public String list() {
  16.         return "customer/list";
  17.     }
  18.  
  19.     @ResponseBody
  20.     @RequestMapping("/getCustomers")
  21.     @RequiresPermissions("customer:list")
  22.     public PageInfo<CustomerView> getCustomers(String keyWord,
  23.                                                  @RequestParam(defaultValue = "1") Integer pageNum,
  24.                                                  @RequestParam(defaultValue = "10") Integer pageSize) {
  25.         //开始分页，这里启动并设置页码，和每页结果数量后，后续结果会自动为分页后结果
  26.         PageHelper.startPage(pageNum, pageSize);
  27.  
  28.         CustomerViewExample customerViewExample = new CustomerViewExample();
  29.         CustomerViewExample.Criteria criteria = customerViewExample.createCriteria();
  30.         /**
  31.          * StringUtils.isNotBlank 可以判断 ""/" "/null 为 false
  32.          */
  33.         if (StringUtils.isNotBlank(keyWord)) {
  34.             //权限名条件
  35.             criteria.andCustomerNameLike("%" + keyWord + "%");
  36.         }
  37.  
  38.         //判断当前登录用户是否为业务员，业务员只能查看自己的客户
  39.         Subject subject = SecurityUtils.getSubject();
  40.         User user = (User) subject.getPrincipal();
  41.         if (user.getRoleId() == ConstantDataField.SALESMAN_ROLE_ID) {
  42.             //客户的业务员id等于登录用户的id
  43.             criteria.andUserIdEqualTo(user.getUserId());
  44.         }
  45.  
  46.         List<CustomerView> customers = customerViewService.selectByExample(customerViewExample);
  47.         //获得分页对象
  48.         PageInfo<CustomerView> pageInfo = new PageInfo<>(customers);
  49.  
  50.         return pageInfo;
  51.     }
  52.  
  53.     @ResponseBody
  54.     @RequestMapping("/delete")
  55.     @RequiresPermissions("customer:delete")
  56.     public Map<String, String> delete(Long[] customerIds) {
  57.         HashMap<String, String> map = new HashMap<>();
  58.         if (customerIds.length == 1) {
  59.             int res = customerService.deleteByPrimaryKey(customerIds[0]);
  60.             if (res == 1) {
  61.                 map.put("status", "true");
  62.                 map.put("info", "删除成功！");
  63.                 return map;
  64.             }
  65.             map.put("status", "false");
  66.             map.put("info", "删除失败！客户已经不存在");
  67.             return map;
  68.         }
  69.         //批量删除
  70.         int success = 0;
  71.         int total = customerIds.length;
  72.         for(Long customerId : customerIds) {
  73.             success += customerService.deleteByPrimaryKey(customerId);
  74.         }
  75.         map.put("status", "true");
  76.         map.put("info", "成功删除选中 " + total + " 个客户中的 " + success + " 个客户");
  77.         return map;
  78.     }
  79.  
  80.  
  81.     @RequestMapping("/add")
  82.     @RequiresPermissions("customer:insert")
  83.     public String add(Model m) {
  84.         //查出地区列表
  85.         BasicDataExample basicDataExample = new BasicDataExample();
  86.         basicDataExample.createCriteria().andParentIdEqualTo(ConstantDataField.AREA_BASICDATA_ID);
  87.         List<BasicData> basicDatas= basicDataService.selectByExample(basicDataExample);
  88.         m.addAttribute("areas",basicDatas);
  89.  
  90.         //获取当前登录用户
  91.         Subject subject = SecurityUtils.getSubject();
  92.         User user = (User) subject.getPrincipal();
  93.  
  94.         //如果是业务员进行操作，只能选择自己作为业务员
  95.         List<User> users = new ArrayList<>();
  96.         if (user.getRoleId() == ConstantDataField.SALESMAN_ROLE_ID) {
  97.             users.add(user);
  98.         } else {
  99.             UserExample userExample = new UserExample();
  100.             userExample.createCriteria().andRoleIdEqualTo(ConstantDataField.SALESMAN_ROLE_ID);
  101.             users = userService.selectByExample(userExample);
  102.         }
  103.         m.addAttribute("users", users);
  104.  
  105.         return "customer/add";
  106.     }
  107.  
  108.     @ResponseBody
  109.     @RequestMapping("/insert")
  110.     @RequiresPermissions("customer:insert")
  111.     public Boolean insert(Customer customer){
  112.         int res = customerService.insert(customer);
  113.         if (res == 1) {
  114.             return true;
  115.         }
  116.         return false;
  117.     }
  118.  
  119.     @RequestMapping("/edit")
  120.     @RequiresPermissions("customer:update")
  121.     public String edit(Model m, Long customerId) {
  122.         //查出地区列表
  123.         BasicDataExample basicDataExample = new BasicDataExample();
  124.         basicDataExample.createCriteria().andParentIdEqualTo(ConstantDataField.AREA_BASICDATA_ID);
  125.         List<BasicData> basicDatas= basicDataService.selectByExample(basicDataExample);
  126.         m.addAttribute("areas",basicDatas);
  127.  
  128.         //查出业务员
  129.         UserExample userExample = new UserExample();
  130.         userExample.createCriteria().andRoleIdEqualTo(ConstantDataField.SALESMAN_ROLE_ID);
  131.         List<User> users = userService.selectByExample(userExample);
  132.         m.addAttribute("users", users);
  133.  
  134.         //查出当前客户
  135.         Customer customer = customerService.selectByPrimaryKey(customerId);
  136.         m.addAttribute("customer", customer);
  137.         return "customer/edit";
  138.     }
  139.  
  140.     @ResponseBody
  141.     @RequestMapping("/update")
  142.     @RequiresPermissions("customer:update")
  143.     public Boolean update(Customer customer) {
  144.         int res = customerService.updateByPrimaryKeySelective(customer);
  145.         if (res == 1) {
  146.             return true;
  147.         }
  148.         return false;
  149.     }
  150. }

后台管理控制层：

  1. @Controller
  2. @RequestMapping("/admin")
  3. public class AdminController {
  4.     @Autowired
  5.     private UserService userService;
  6.     @Autowired
  7.     private RoleService roleService;
  8.  
  9.     @RequestMapping("/list")
  10.     @RequiresPermissions("admin:list")
  11.     public String adminList() {
  12.         return "admin/list";
  13.     }
  14.  
  15.     /**
  16.      * 该方法返回 admin 集合的 JSON 字符串，使用 PageHelper 工具进行分页
  17.      * @param keyWord 搜索关键字
  18.      * @param pageNum 页数，默认为 1
  19.      * @param pageSize 每个页面用户容量，默认为 10/页
  20.      * @return
  21.      */
  22.     @ResponseBody
  23.     @RequestMapping("/getAdmins")
  24.     @RequiresPermissions("admin:list")
  25.     public PageInfo<User> getAdmins(String keyWord,
  26.                                 @RequestParam(defaultValue = "1") Integer pageNum,
  27.                                 @RequestParam(defaultValue = "10") Integer pageSize) {
  28.         //开始分页，这里启动并设置页码，和每页结果数量后，后续结果会自动为分页后结果
  29.         PageHelper.startPage(pageNum, pageSize);
  30.  
  31.         UserExample userExample = new UserExample();
  32.  
  33.         /**
  34.          * StringUtils.isNotBlank 可以判断 ""/" "/null 为 false
  35.          */
  36.         if (StringUtils.isNotBlank(keyWord)) {
  37.             //用户名条件
  38.             UserExample.Criteria criteriaUserName = userExample.createCriteria();
  39.             criteriaUserName.andUsernameLike("%" + keyWord + "%");
  40.  
  41.             //真实名字条件
  42.             UserExample.Criteria criteriaRealName = userExample.createCriteria();
  43.             criteriaRealName.andRealnameLike("%" + keyWord + "%");
  44.  
  45.             //将两个条件用 or 组合
  46.             userExample.or(criteriaRealName);
  47.         }
  48.  
  49.         List<User> users = userService.selectByExample(userExample);
  50.         //获得分页对象
  51.         PageInfo<User> pageInfo = new PageInfo<>(users);
  52.  
  53.         return pageInfo;
  54.     }
  55.  
  56.     @ResponseBody
  57.     @RequestMapping("/delete")
  58.     @RequiresPermissions("admin:delete")
  59.     public Map<String, String> delete(Long[] userIds) {
  60.         HashMap<String, String> map = new HashMap<>();
  61.         if (userIds.length == 1) {
  62.             int res = userService.deleteByPrimaryKey(userIds[0]);
  63.             if (res == 1) {
  64.                 map.put("status", "true");
  65.                 map.put("info", "删除成功！");
  66.                 return map;
  67.             }
  68.             map.put("status", "false");
  69.             map.put("info", "删除失败！用户已经不存在");
  70.             return map;
  71.         }
  72.         //批量删除
  73.         int success = 0;
  74.         int total = userIds.length;
  75.         for(Long userId : userIds) {
  76.             success += userService.deleteByPrimaryKey(userId);
  77.         }
  78.         map.put("status", "true");
  79.         map.put("info", "成功删除选中 " + total + " 个用户中的 " + success + " 个用户");
  80.         return map;
  81.     }
  82.  
  83.     @RequiresPermissions("admin:insert")
  84.     @RequestMapping("/add")
  85.     public String addAdmin(Model m) {
  86.         RoleExample roleExample = new RoleExample();
  87.         List<Role> roles = roleService.selectByExample(roleExample);
  88.         m.addAttribute("roles", roles);
  89.         return "admin/add";
  90.     }
  91.  
  92.     @ResponseBody
  93.     @RequestMapping("/checkUsername")
  94.     @RequiresPermissions("admin:list")
  95.     public Boolean checkUsername(String username) {
  96.         UserExample userExample = new UserExample();
  97.         UserExample.Criteria criteria = userExample.createCriteria();
  98.         criteria.andUsernameEqualTo(username);
  99.         System.out.println(userService.selectByExample(userExample));
  100.         if (userService.selectByExample(userExample).size() != 0) {
  101.             return false;
  102.         }
  103.         return true;
  104.     }
  105.  
  106.     @ResponseBody
  107.     @RequestMapping("/insert")
  108.     @RequiresPermissions("admin:insert")
  109.     public Boolean insert(User user){
  110.         String salt = UUID.randomUUID().toString().substring(0, 4);
  111.         String hashedPassword = new SimpleHash("md5", user.getPassword(), salt,3).toString();
  112.         user.setSalt(salt);
  113.         user.setPassword(hashedPassword);
  114.         user.setCreateDate(new Date());
  115.         int res = userService.insert(user);
  116.         if (res == 1) {
  117.             return true;
  118.         }
  119.         return false;
  120.     }
  121.  
  122.     @RequestMapping("/edit")
  123.     @RequiresPermissions("admin:update")
  124.     public String edit(Model m, Long userId) {
  125.         m.addAttribute("user", userService.selectByPrimaryKey(userId));
  126.         m.addAttribute("roles", roleService.selectByExample(new RoleExample()));
  127.         return "admin/edit";
  128.     }
  129.  
  130.     @ResponseBody
  131.     @RequestMapping("/update")
  132.     @RequiresPermissions("admin:update")
  133.     public Boolean update(User user) {
  134.         if (StringUtils.isBlank(user.getPassword())) {
  135.             user.setPassword(null);
  136.         } else {
  137.             String salt = UUID.randomUUID().toString().substring(0, 4);
  138.             String hashedPassword = new SimpleHash("md5", user.getPassword(), salt, 3).toString();
  139.             user.setPassword(hashedPassword);
  140.             user.setSalt(salt);
  141.         }
  142.         int res = userService.updateByPrimaryKeySelective(user);
  143.         if (res == 1) {
  144.             return true;
  145.         }
  146.         return false;
  147.     }
  148. }
  149.

订单管理控制层：

  1. @Controller
  2. @RequestMapping("/order")
  3. public class OrderController {
  4.  
  5.     @Autowired
  6.     private OrderViewService orderViewService;
  7.  
  8.     @Autowired
  9.     private OrderService orderService;
  10.  
  11.     @Autowired
  12.     private UserService userService;
  13.  
  14.     @Autowired
  15.     private CustomerService customerService;
  16.  
  17.     @Autowired
  18.     private BasicDataService basicDataService;
  19.  
  20.     @Autowired
  21.     private OrderDetailService orderDetailService;
  22.  
  23.     //工具方法
  24.     public PageInfo<OrderView> getOrdersUtil(String keyWord, Integer pageNum, Integer pageSize) {
  25.         //开始分页，这里启动并设置页码，和每页结果数量后，后续结果会自动为分页后结果
  26.         PageHelper.startPage(pageNum, pageSize);
  27.  
  28.         OrderViewExample orderViewExample = new OrderViewExample();
  29.         OrderViewExample.Criteria criteria = orderViewExample.createCriteria();
  30.         /**
  31.          * StringUtils.isNotBlank 可以判断 ""/" "/null 为 false
  32.          */
  33.         if (StringUtils.isNotBlank(keyWord)) {
  34.             //客户名条件
  35.             criteria.andCustomerNameLike("%" + keyWord + "%");
  36.         }
  37.  
  38.         //判断当前登录用户是否为业务员，业务员只能查看自己的订单
  39.         Subject subject = SecurityUtils.getSubject();
  40.         User user = (User) subject.getPrincipal();
  41.         if (user.getRoleId() == ConstantDataField.SALESMAN_ROLE_ID) {
  42.             //客户的业务员用户名等于登录用户的用户名
  43.             criteria.andUsernameEqualTo(user.getUsername());
  44.         }
  45.  
  46.         List<OrderView> orders = orderViewService.selectByExample(orderViewExample);
  47.         //获得分页对象
  48.         PageInfo<OrderView> pageInfo = new PageInfo<>(orders);
  49.  
  50.         return pageInfo;
  51.     }
  52.  
  53.     @RequestMapping("/list")
  54.     @RequiresPermissions("order:list")
  55.     public String list() {
  56.         return "order/list";
  57.     }
  58.  
  59.     @ResponseBody
  60.     @RequestMapping("/getOrders")
  61.     @RequiresPermissions("order:list")
  62.     public PageInfo<OrderView> getOrders(String keyWord,
  63.                                         @RequestParam(defaultValue = "1") Integer pageNum,
  64.                                         @RequestParam(defaultValue = "10") Integer pageSize) {
  65.         return getOrdersUtil(keyWord, pageNum, pageSize);
  66.     }
  67.  
  68.     @ResponseBody
  69.     @RequestMapping("/delete")
  70.     @RequiresPermissions("order:delete")
  71.     public Map<String, String> delete(Long[] orderIds) {
  72.         HashMap<String, String> map = new HashMap<>();
  73.         //单个删除
  74.         if (orderIds.length == 1) {
  75.             int res = orderService.deleteByPrimaryKey(orderIds[0]);
  76.             if (res == 1) {
  77.                 map.put("status", "true");
  78.                 map.put("info", "删除成功！");
  79.                 return map;
  80.             }
  81.             map.put("status", "false");
  82.             map.put("info", "删除失败！订单已经不存在");
  83.             return map;
  84.         }
  85.         //批量删除
  86.         int success = 0;
  87.         int total = orderIds.length;
  88.         for(Long orderId : orderIds) {
  89.             success += orderService.deleteByPrimaryKey(orderId);
  90.         }
  91.         map.put("status", "true");
  92.         map.put("info", "成功删除选中 " + total + " 个订单中的 " + success + " 个订单");
  93.         return map;
  94.     }
  95.  
  96.     @RequestMapping("/add")
  97.     @RequiresPermissions("order:insert")
  98.     public String add(Model m) {
  99.         this.getOrderGeneralData(m);
  100.         return "order/add";
  101.     }
  102.  
  103.  
  104.     /*
  105.     用 @RequestBody 注解，将前台传入的 JSON 字符串解析成对象
  106.      */
  107.     @RequestMapping("/insert")
  108.     @RequiresPermissions("order:insert")
  109.     @ResponseBody
  110.     @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED, timeout = 5)
  111.     public Boolean insert(@RequestBody Order order) {
  112.         //插入 order，在此之后，order 获得了 orderId
  113.         int res = orderService.insert(order);
  114.         //获取订单详情集合
  115.         List<OrderDetail> orderDetails = order.getorderDetails();
  116.         orderDetails.forEach(orderDetail -> {
  117.             orderDetail.setOrderId(order.getOrderId());
  118.             orderDetailService.insert(orderDetail);
  119.         });
  120.         if (res == 1) {
  121.             return true;
  122.         }
  123.         return false;
  124.     }
  125.  
  126.     @RequestMapping("/edit")
  127.     @RequiresPermissions("order:update")
  128.     public String edit(Long orderId, Model m) {
  129.         //获取常规数据
  130.         getOrderGeneralData(m);
  131.  
  132.         //添加选中的订单
  133.         Order selectedOrder = orderService.selectByPrimaryKey(orderId);
  134.         m.addAttribute("selectedOrder", selectedOrder);
  135.  
  136.         //添加订单详情
  137.         OrderDetailExample orderDetailExample = new OrderDetailExample();
  138.         orderDetailExample.createCriteria().andOrderIdEqualTo(orderId);
  139.         List<OrderDetail> orderDetails = orderDetailService.selectByExample(orderDetailExample);
  140.         m.addAttribute("orderDetails", orderDetails);
  141.  
  142.         return "order/edit";
  143.     }
  144.  
  145.     @RequiresPermissions("order:update")
  146.     @RequestMapping("/update")
  147.     @ResponseBody
  148.     public Boolean update(@RequestBody Order order) {
  149.         OrderDetailExample orderDetailExample = new OrderDetailExample();
  150.         orderDetailExample.createCriteria().andOrderIdEqualTo(order.getOrderId());
  151.         List<OrderDetail> dbOrderDetails = orderDetailService.selectByExample(orderDetailExample); //数据库中的orderDetails
  152.         List<OrderDetail> formOrderDetails = order.getorderDetails(); //表单数据中的orderDetails
  153.  
  154.         //循环比较数据库数据和表单新数据，删除数据库中在修改中删除的数据
  155.         dbOrderDetails.forEach(dbOrderDetail -> {
  156.             if (!formOrderDetails.contains(dbOrderDetail)) {
  157.                 orderDetailService.deleteByPrimaryKey(dbOrderDetail.getOrderDetailId());
  158.             }
  159.         });
  160.  
  161.         //循环比较表单新数据和数据库数据，若存在则修改，不存在则新增
  162.         formOrderDetails.forEach(formOrderDetail -> {
  163.             if (dbOrderDetails.contains(formOrderDetail)) {
  164.                 orderDetailService.updateByPrimaryKeySelective(formOrderDetail);
  165.             } else {
  166.                 formOrderDetail.setOrderId(order.getOrderId());
  167.                 orderDetailService.insert(formOrderDetail);
  168.             }
  169.         });
  170.  
  171.         //修改Order
  172.         int res = orderService.updateByPrimaryKey(order);
  173.         if (res == 1){
  174.             return true;
  175.         }
  176.         return false;
  177.     }
  178.  
  179.     //抽取的工具方法
  180.     private void getOrderGeneralData(Model m){
  181.         User user = (User)SecurityUtils.getSubject().getPrincipal(); //获取当前用户
  182.         Long userRoleId = user.getRoleId(); //当前用户角色ID
  183.         Long userId = user.getUserId(); //当前用户ID
  184.  
  185.         //查找业务员
  186.         UserExample userExample = new UserExample();
  187.         List<User> users = new ArrayList<>();
  188.         //如果当前用户是业务员只能用自己用户添加
  189.         if (userRoleId == ConstantDataField.SALESMAN_ROLE_ID) {
  190.             users.add(userService.selectByPrimaryKey(userId));
  191.         } else {
  192.             userExample.createCriteria().andRoleIdEqualTo(ConstantDataField.SALESMAN_ROLE_ID);
  193.             users = userService.selectByExample(userExample);
  194.         }
  195.         m.addAttribute("users", users);
  196.  
  197.         //查找客户
  198.         CustomerExample customerExample = new CustomerExample();
  199.         List<Customer> customers;
  200.         //如果当前用户是业务员只能获得自己的客户
  201.         if (userRoleId == ConstantDataField.SALESMAN_ROLE_ID) {
  202.             customerExample.createCriteria().andUserIdEqualTo(userId);
  203.             customers = customerService.selectByExample(customerExample);
  204.         } else {
  205.             customers = customerService.selectByExample(customerExample);
  206.         }
  207.         m.addAttribute("customers", customers);
  208.  
  209.         //查找地区
  210.         BasicDataExample areaExample = new BasicDataExample();
  211.         areaExample.createCriteria().andParentIdEqualTo(ConstantDataField.AREA_BASICDATA_ID);
  212.         List<BasicData> areas = basicDataService.selectByExample(areaExample);
  213.         m.addAttribute("areas", areas);
  214.  
  215.         //查找付款方式
  216.         BasicDataExample paymentExample = new BasicDataExample();
  217.         paymentExample.createCriteria().andParentIdEqualTo(ConstantDataField.PAYMENT_BASICDATA_ID);
  218.         List<BasicData> payments = basicDataService.selectByExample(paymentExample);
  219.         m.addAttribute("payments", payments);
  220.  
  221.         //查找运送方式
  222.         BasicDataExample transportExample = new BasicDataExample();
  223.         transportExample.createCriteria().andParentIdEqualTo(ConstantDataField.TRANSPORT_BASICDATA_ID);
  224.         List<BasicData> transports = basicDataService.selectByExample(transportExample);
  225.         m.addAttribute("transports", transports);
  226.  
  227.         //查找取件方式
  228.         BasicDataExample pickupExample = new BasicDataExample();
  229.         pickupExample.createCriteria().andParentIdEqualTo(ConstantDataField.PICKUP_BASICDATA_ID);
  230.         List<BasicData> pickups = basicDataService.selectByExample(pickupExample);
  231.         m.addAttribute("pickups", pickups);
  232.  
  233.         //查找单位
  234.         BasicDataExample unitExample = new BasicDataExample();
  235.         unitExample.createCriteria().andParentIdEqualTo(ConstantDataField.UNIT_BASICDATA_ID);
  236.         List<BasicData> units = basicDataService.selectByExample(unitExample);
  237.         m.addAttribute("units", units);
  238.     }
  239. }

 

源码获取：博客首页 "资源" 里下载！ 

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

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

  

闽ICP备14008679号