• Java项目:物资发放管理系统(java+Springboot+HTML+layui+Mysql)

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

    项目介绍

    本项目有物资管理员与普通员工两种角色；

    普通员工具有以下功能：申领物资；撤销申请；查看待领任务。
    （1）申领物资：提交物资领取申请。
    （2）撤销申请：对于物资管理员还未审核的申请，可以撤销；已审核的申请则不能撤销。
    （3）查看待领任务：查看已通过审核的申请和物资管理员发起的领取任务。

    物资管理员拥有以下功能：物资信息管理；物资入库；物资发放；查看物资库存；审批申请。
    （1）物资信息管理：添加物资类别；添加、修改、删除物资信息；按名称或类别或编号查询物资信息。
    （2）物资入库：增加物资的库存量；可以按入库时间来查看入库信息。
    （3）物资发放：向指定人发放一定数量的物资，并在其领取后进行登记。
    （4）查看物资库存：查看所有物资的库存量。
    （5）审批申请：查看和审批物资领取申请，同意则员工可以领取物资，不同意则驳回该申请，不允许领取物资。

    环境需要

    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 8.0/5.7版本；
    6.是否Maven项目：是；

    技术栈

    springboot+mysql+layui+CSS+JavaScript

    使用说明

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

     

     

     

     

     

     

     

    登录管理控制层：

    1. @Controller
    2. @RequestMapping("/")
    3. public class IndexController {
    4.     @Resource
    5.     private IndexService indexService;
    6.  
    7.     @Resource
    8.     private MenuService menuService;
    9.  
    10.     @RequestMapping(value = "/")
    11.     public String index() {
    12.         return "/login";
    13.     }
    14.  
    15.     @RequestMapping(value = "/login.html")
    16.     public String toLogin() {
    17.         return "/login";
    18.     }
    19.  
    20.     @RequestMapping(value = "/home.html")
    21.     public String home() {
    22.         return "/home";
    23.     }
    24.  
    25.     @RequestMapping(value = "/welcome.html")
    26.     public String welcome() {
    27.         return "/welcome";
    28.     }
    29.  
    30.     /**
    31.      * 登录
    32.      *
    33.      * @param request
    34.      * @param session
    35.      * @return
    36.      */
    37.     @ResponseBody
    38.     @RequestMapping(value = "/login.action")
    39.     public String login(@RequestBody Map<String, String> request, HttpSession session) {
    40.         Map<String, Object> map = new HashMap<>();
    41.         String uid = request.get("uid");
    42.         String password = request.get("password");
    43.         System.out.println("uid:" + uid + "--pwd:" + password);
    44.         User user = indexService.findUser(uid, password);
    45.         if (user != null) {
    46.             session.setAttribute("uid", uid);
    47.             session.setAttribute("uname", user.getUname());
    48.             session.setAttribute("utype", user.getUtype());
    49.             map.put("msg","登录成功");
    50.             map.put("success", true);
    51.         } else {
    52.             map.put("success", false);
    53.             map.put("msg", "账号或密码错误！");
    54.         }
    55.         return JSON.toJSONString(map);
    56.     }
    57.  
    58.     /**
    59.      * 加载菜单列表
    60.      *
    61.      * @param session
    62.      * @return
    63.      */
    64.     @ResponseBody
    65.     @RequestMapping(value = "/api/loadMenuList")
    66.     public String loadMenuList(HttpSession session) {
    67.         Integer utype = (Integer) session.getAttribute("utype");
    68.         String initJson = menuService.loadMenuList(utype);
    69.         return initJson;
    70.     }
    71.  
    72.     /**
    73.      * 退出登录
    74.      *
    75.      * @param session
    76.      * @return 返回到登录界面
    77.      */
    78.     @RequestMapping(value = "/logout.action")
    79.     public String logout(HttpSession session) {
    80.         // 清空session中的属性
    81.         session.removeAttribute("uid");
    82.         session.removeAttribute("uname");
    83.         session.removeAttribute("utype");
    84.         //让session无效
    85.         session.invalidate();
    86.         return "redirect:/login.html";
    87.     }
    88. }

    物资管理控制层：

    1. @Controller
    2. @RequestMapping("/mh")
    3. public class MHController {
    4.     @Resource
    5.     private KindService kindService;
    6.  
    7.     @Resource
    8.     private MaterialService materialService;
    9.  
    10.     @Resource
    11.     private PutinService putinService;
    12.  
    13.     @Resource
    14.     private StoreService storeService;
    15.  
    16.     @Resource
    17.     private RequisitionService requisitionService;
    18.  
    19.     @Resource
    20.     private IndexService indexService;
    21.  
    22.     @RequestMapping(value = "/info.html")
    23.     public String materialInfo() {
    24.         return "/mh/material-info.html";
    25.     }
    26.  
    27.     /**
    28.      * 获取全部种类
    29.      *
    30.      * @return
    31.      */
    32.     @ResponseBody
    33.     @RequestMapping(value = "/info/getOptions.action")
    34.     public String getSelectOptions() {
    35.         Map<String, Object> map = new HashMap<>();
    36.         List<Kind> list = kindService.findAllKind();
    37.         if (list != null) {
    38.             map.put("success", true);
    39.             map.put("data", list);
    40.         } else {
    41.             map.put("success", false);
    42.             Kind kind = new Kind("005", "其它");
    43.             map.put("data", kind);
    44.         }
    45.         System.out.println(map);
    46.         return JSON.toJSONString(map);
    47.     }
    48.  
    49.     /**
    50.      * 上传物资图片
    51.      *
    52.      * @param file
    53.      * @param request
    54.      * @return
    55.      */
    56.     @ResponseBody
    57.     @RequestMapping(value = "/info/uploadImage")
    58.     public String uploadImage(MultipartFile file, HttpServletRequest request) {
    59.         HashMap<String, Object> map = new HashMap<>();
    60.         HashMap<String, Object> data = new HashMap<>();
    61.         try {
    62.             if (file != null) {
    63.                 String originalFilename = file.getOriginalFilename();
    64.                 Date date = new Date();
    65.                 String fileName = date.getTime() + "-" + originalFilename;
    66.                 // 类路径
    67.                 String classPath = "F:/IDEA/workspace/MMS/mms/target/classes/static";
    68.                 // 父路径
    69.                 String src = "/upload/";
    70.                 File directory = new File(classPath, src);
    71.                 if (!directory.exists()) {
    72.                     directory.mkdir();
    73.                 }
    74.                 // 文件名
    75.                 String imagePath = directory.getPath() + "\\" + fileName;
    76.                 file.transferTo(new File(imagePath));
    77.                 data.put("src", src + fileName);
    78.                 map.put("code", 0);
    79.                 map.put("msg", "上传成功！");
    80.                 map.put("data", data);
    81.                 return JSON.toJSONString(map);
    82.             } else {
    83.                 map.put("code", -1);
    84.                 map.put("msg", "请选择图片！");
    85.                 return JSON.toJSONString(map);
    86.             }
    87.         } catch (Exception e) {
    88.             e.printStackTrace();
    89.             map.put("code", -1);
    90.             map.put("msg", "上传失败，请稍后重试！");
    91.             return JSON.toJSONString(map);
    92.         }
    93.     }
    94.  
    95.     /**
    96.      * 添加物资信息
    97.      *
    98.      * @param mi
    99.      * @return
    100.      */
    101.     @ResponseBody
    102.     @RequestMapping(value = "/info/add")
    103.     public String addMaterialInfo(Material mi) {
    104.         HashMap<String, Object> map = new HashMap<>();
    105.         System.out.println(mi);
    106.         boolean result = materialService.addMaterialInfo(mi);
    107.         if (result) {
    108.             map.put("success", true);
    109.             map.put("msg", "添加成功！");
    110.         } else {
    111.             map.put("success", false);
    112.             map.put("msg", "添加失败,请稍后再试！");
    113.         }
    114.         return JSON.toJSONString(map);
    115.     }
    116.  
    117.     /**
    118.      * 查看物资信息列表
    119.      *
    120.      * @param mv
    121.      * @return
    122.      */
    123.     @ResponseBody
    124.     @RequestMapping(value = "/info/list")
    125.     public DataGridViewResult materialInfoList(MaterialVo mv) {
    126.         // 设置分页信息
    127.         PageHelper.startPage(mv.getPage(), mv.getLimit());
    128.         // 查询
    129.         List<Material> list = materialService.findMaterialInfoListByPage(mv);
    130.         // 创建分页对象
    131.         PageInfo<Material> pageInfo = new PageInfo<Material>(list);
    132.         // 按接口要求返回数据
    133.         DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
    134.         return data;
    135.     }
    136.  
    137.     /**
    138.      * 修改物资信息
    139.      *
    140.      * @param mi
    141.      * @return
    142.      */
    143.     @ResponseBody
    144.     @RequestMapping(value = "/info/update")
    145.     public String updateMaterialInfo(Material mi) {
    146.         HashMap<String, Object> map = new HashMap<>();
    147.         boolean result = materialService.updateMaterialInfo(mi);
    148.         if (result) {
    149.             map.put("success", true);
    150.             map.put("msg", "更改成功！");
    151.         } else {
    152.             map.put("success", false);
    153.             map.put("msg", "更改失败！");
    154.         }
    155.         return JSON.toJSONString(map);
    156.     }
    157.  
    158.  
    159.     /**
    160.      * 删除物资信息
    161.      *
    162.      * @param request
    163.      * @return
    164.      */
    165.     @ResponseBody
    166.     @RequestMapping(value = "/info/delete")
    167.     public String deleteMaterialInfo(HttpServletRequest request) {
    168.         HashMap<String, Object> map = new HashMap<>();
    169.         String params = request.getParameter("params");
    170.         try {
    171.             if (!params.equals("") && params != "") {
    172.                 // 获取mid数组
    173.                 JSONArray jsonArray = JSONArray.parseArray(params);
    174.                 List<String> list = new ArrayList<>();
    175.                 for (int i = 0; i < jsonArray.size(); i++) {
    176.                     JSONObject obj = jsonArray.getJSONObject(i);
    177.                     String mid = (String) obj.get("mid");
    178.                     System.out.println(mid);
    179.                     list.add(mid);
    180.                 }
    181.                 boolean result = materialService.deleteMaterialInfo(list);
    182.                 if (result) {
    183.                     map.put("success", true);
    184.                     map.put("msg", "删除成功！");
    185.                 } else {
    186.                     map.put("success", false);
    187.                     map.put("msg", "删除失败！");
    188.                 }
    189.             }
    190.         } catch (Exception e) {
    191.             e.printStackTrace();
    192.             map.put("success", false);
    193.             map.put("msg", "删除失败！");
    194.         }
    195.         return JSON.toJSONString(map);
    196.     }
    197.  
    198.  
    199.     /**
    200.      * 添加物资类别
    201.      *
    202.      * @param kd
    203.      * @return
    204.      */
    205.     @ResponseBody
    206.     @RequestMapping(value = "/kind/add")
    207.     public String addKind(Kind kd) {
    208.         HashMap<String, Object> map = new HashMap<>();
    209.         System.out.println(kd);
    210.         boolean result = kindService.addKind(kd);
    211.         if (result) {
    212.             map.put("success", true);
    213.             map.put("msg", "添加成功！");
    214.         } else {
    215.             map.put("success", false);
    216.             map.put("msg", "添加失败,请稍后再试！");
    217.         }
    218.         return JSON.toJSONString(map);
    219.     }
    220.  
    221.  
    222.     @RequestMapping(value = "/putin.html")
    223.     public String putinRecords(){
    224.         return "/mh/putin.html";
    225.     }
    226.  
    227.  
    228.     /**
    229.      * 获取全部的物资名称
    230.      *
    231.      * @return
    232.      */
    233.     @ResponseBody
    234.     @RequestMapping(value = "/putin/getMname.action")
    235.     public String getMnameOptions() {
    236.         Map<String, Object> map = new HashMap<>();
    237.         List<Material> list = materialService.findAllMname();
    238.         if (list != null) {
    239.             map.put("success", true);
    240.             map.put("data", list);
    241.         } else {
    242.             map.put("success", false);
    243.         }
    244.         return JSON.toJSONString(map);
    245.     }
    246.  
    247.     /**
    248.      * 物资入库
    249.      * @param pi
    250.      * @return
    251.      */
    252.     @ResponseBody
    253.     @RequestMapping(value = "/putin/add")
    254.     public String addPutinInfo(Putin pi,HttpServletRequest request) {
    255.         HashMap<String, Object> map = new HashMap<>();
    256.         // 获取经办人信息
    257.         String uname = (String)request.getSession().getAttribute("uname");
    258.         pi.setPagent(uname);
    259.  
    260.         // 获取当前日期
    261.         Date date = new Date();
    262.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    263.         pi.setPdate(sdf.format(date));
    264.  
    265.         // 生成时间戳，保证主键的唯一性
    266.         String pno = String.valueOf(date.getTime());
    267.         pi.setPno(pno);
    268.  
    269.         System.out.println(pi);
    270.         boolean result = putinService.addPutin(pi);
    271.         if (result) {
    272.             map.put("success", true);
    273.             map.put("msg", "入库成功！");
    274.         } else {
    275.             map.put("success", false);
    276.             map.put("msg", "入库失败,请稍后再试！");
    277.         }
    278.         return JSON.toJSONString(map);
    279.     }
    280.  
    281.     /**
    282.      * 查询物资入库信息
    283.      * @param pv
    284.      * @return
    285.      */
    286.     @RequestMapping(value = "/putin/list")
    287.     @ResponseBody
    288.     public DataGridViewResult findPutinList(PutinVo pv){
    289.         // 设置分页信息
    290.         PageHelper.startPage(pv.getPage(), pv.getLimit());
    291.         // 查询
    292.         List<Putin> list = putinService.findPutinList(pv);
    293.         // 创建分页对象
    294.         PageInfo<Putin> pageInfo = new PageInfo<Putin>(list);
    295.         // 按接口要求返回数据
    296.         DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
    297.         return data;
    298.     }
    299.  
    300.     @RequestMapping(value = "/store.html")
    301.     public String storeInfo(){
    302.         return "/mh/store.html";
    303.     }
    304.  
    305.     /**
    306.      * 查询物资的库存信息
    307.      * @param sv
    308.      * @return
    309.      */
    310.     @RequestMapping(value = "/store/list")
    311.     @ResponseBody
    312.     public DataGridViewResult findStoreList(StoreVo sv){
    313.         // 设置分页信息
    314.         PageHelper.startPage(sv.getPage(), sv.getLimit());
    315.         // 查询
    316.         List<Store> list = storeService.findStoreList(sv);
    317.         // 创建分页对象
    318.         PageInfo<Store> pageInfo = new PageInfo<Store>(list);
    319.         // 按接口要求返回数据
    320.         DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
    321.         return data;
    322.     }
    323.  
    324.     @RequestMapping(value = "/approve.html")
    325.     public String approve(){
    326.         return "/mh/approve.html";
    327.     }
    328.  
    329.  
    330.     /**
    331.      * 查询待审核的领用申请
    332.      * @param rv
    333.      * @return
    334.      */
    335.     @RequestMapping(value = "/approve/list")
    336.     @ResponseBody
    337.     public DataGridViewResult approveList(RequisitionVo rv){
    338.         rv.setRstatus("申请中");
    339.         // 设置分页信息
    340.         PageHelper.startPage(rv.getPage(), rv.getLimit());
    341.         // 查询
    342.         List<Requisition> list = requisitionService.findApproveList(rv);
    343.         // 创建分页对象
    344.         PageInfo<Requisition> pageInfo = new PageInfo<>(list);
    345.         // 按接口要求返回数据
    346.         DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
    347.         return data;
    348.     }
    349.  
    350.     /**
    351.      * 审批申请
    352.      * @param rt
    353.      * @param request
    354.      * @return
    355.      */
    356.     @ResponseBody
    357.     @RequestMapping(value = "/approve/approve.action")
    358.     public String doApprove(Requisition rt,HttpServletRequest request){
    359.         // 审核人
    360.         String uname = (String)request.getSession().getAttribute("uname");
    361.         rt.setRverifier(uname);
    362.  
    363.         System.out.println(rt);
    364.         HashMap<String, Object> map = new HashMap<>();
    365.         boolean result = requisitionService.updateRstatus(rt);
    366.         if (result) {
    367.             map.put("success", true);
    368.             map.put("msg", "审核成功！");
    369.         } else {
    370.             map.put("success", false);
    371.             map.put("msg", "审核失败,请稍后再试！");
    372.         }
    373.         return JSON.toJSONString(map);
    374.     }
    375.  
    376.     /**
    377.      * 物资发放页面
    378.      * @return
    379.      */
    380.     @RequestMapping(value = "/distribute.html")
    381.     public String distribute(){
    382.         return "/mh/distribute.html";
    383.     }
    384.  
    385.     /**
    386.      * 查询所有的领用记录
    387.      * @param rv
    388.      * @return
    389.      */
    390.     @RequestMapping(value = "/distribute/list")
    391.     @ResponseBody
    392.     public DataGridViewResult distributeList(RequisitionVo rv){
    393.         // 设置分页信息
    394.         PageHelper.startPage(rv.getPage(), rv.getLimit());
    395.         // 查询
    396.         List<Requisition> list = requisitionService.findAll(rv);
    397.         // 创建分页对象
    398.         PageInfo<Requisition> pageInfo = new PageInfo<>(list);
    399.         // 按接口要求返回数据
    400.         DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
    401.         return data;
    402.     }
    403.  
    404.     /**
    405.      * 领用登记
    406.      * @param rt
    407.      * @param request
    408.      * @return
    409.      */
    410.     @ResponseBody
    411.     @RequestMapping(value = "/distribute/received.action")
    412.     public String received(Requisition rt,HttpServletRequest request){
    413.         // 发放人
    414.         String uname = (String)request.getSession().getAttribute("uname");
    415.         rt.setRagent(uname);
    416.  
    417.         // 领用日期
    418.         Date date = new Date();
    419.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    420.         rt.setRtaketime(sdf.format(date));
    421.  
    422.         HashMap<String, Object> map = new HashMap<>();
    423.         boolean result = requisitionService.received(rt);
    424.         if (result) {
    425.             map.put("success", true);
    426.             map.put("msg", "登记成功！");
    427.         } else {
    428.             map.put("success", false);
    429.             map.put("msg", "登记失败,库存不足或系统错误,请稍后重试！");
    430.         }
    431.         return JSON.toJSONString(map);
    432.     }
    433.  
    434.     /**
    435.      * 获取普通员工
    436.      * @return
    437.      */
    438.     @RequestMapping(value = "/distribute/getUname.action")
    439.     @ResponseBody
    440.     public String getUname(){
    441.         Map<String, Object> map = new HashMap<>();
    442.         Integer utype = 0;
    443.         List<User> list = indexService.getUname(utype);
    444.         if (list != null) {
    445.             map.put("success", true);
    446.             map.put("data", list);
    447.         } else {
    448.             map.put("success", false);
    449.         }
    450.         return JSON.toJSONString(map);
    451.     }
    452.  
    453.     /**
    454.      * 发布领取任务
    455.      * @param rt
    456.      * @param request
    457.      * @return
    458.      */
    459.     @ResponseBody
    460.     @RequestMapping(value = "/distribute/give")
    461.     public String give(Requisition rt,HttpServletRequest request){
    462.         // 审核人
    463.         String uname = (String)request.getSession().getAttribute("uname");
    464.         rt.setRverifier(uname);
    465.  
    466.         // 任务发布日期（即申请日期）
    467.         Date date = new Date();
    468.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    469.         rt.setRapplytime(sdf.format(date));
    470.  
    471.         // 申请类型
    472.         rt.setRtype("直接发放");
    473.  
    474.         // 时间戳，作为主键
    475.         String rid = String.valueOf(date.getTime());
    476.         rt.setRid(rid);
    477.  
    478.         // 申请进度
    479.         rt.setRstatus("待领取");
    480.  
    481.         System.out.println(rt);
    482.  
    483.         HashMap<String, Object> map = new HashMap<>();
    484.         boolean result = requisitionService.give(rt);
    485.         if (result) {
    486.             map.put("success", true);
    487.             map.put("msg", "发布任务成功！");
    488.         } else {
    489.             map.put("success", false);
    490.             map.put("msg", "发布任务失败,请稍后重试！");
    491.         }
    492.         return JSON.toJSONString(map);
    493.     }
    494. }

    申领信息管理控制层： 

    1. @Controller
    2. @RequestMapping("/staff")
    3. public class StaffController {
    4.  
    5.     @Resource
    6.     private RequisitionService requisitionService;
    7.  
    8.     @RequestMapping(value = "/apply.html")
    9.     public String apply() {
    10.         return "/staff/apply.html";
    11.     }
    12.  
    13.     /**
    14.      * 查看申领信息，只能查看自己的
    15.      * @param rv
    16.      * @param request
    17.      * @return
    18.      */
    19.     @ResponseBody
    20.     @RequestMapping(value = "/apply/list")
    21.     public DataGridViewResult applyList(RequisitionVo rv,HttpServletRequest request) {
    22.         String uname = (String)request.getSession().getAttribute("uname");
    23.         rv.setRtaker(uname);
    24.         // 设置分页信息
    25.         PageHelper.startPage(rv.getPage(), rv.getLimit());
    26.         // 查询
    27.         List<Requisition> list = requisitionService.findRequisitionList(rv);
    28.         // 创建分页对象
    29.         PageInfo<Requisition> pageInfo = new PageInfo<>(list);
    30.         // 按接口要求返回数据
    31.         DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
    32.         return data;
    33.     }
    34.  
    35.     /**
    36.      * 提交申请
    37.      *
    38.      * @param rt
    39.      * @return
    40.      */
    41.     @ResponseBody
    42.     @RequestMapping(value = "/apply/add")
    43.     public String addPutinInfo(Requisition rt, HttpServletRequest request) {
    44.         HashMap<String, Object> map = new HashMap<>();
    45.         // 获取领用人
    46.         String uname = (String) request.getSession().getAttribute("uname");
    47.         rt.setRtaker(uname);
    48.  
    49.         // 生成时间戳，保证主键的唯一性
    50.         Date date = new Date();
    51.         String rid = String.valueOf(date.getTime());
    52.         rt.setRid(rid);
    53.  
    54.         rt.setRstatus("申请中");
    55.         rt.setRtype("申请发放");
    56.  
    57.         System.out.println(rt);
    58.         boolean result = requisitionService.add(rt);
    59.         if (result) {
    60.             map.put("success", true);
    61.             map.put("msg", "提交申请成功！");
    62.         } else {
    63.             map.put("success", false);
    64.             map.put("msg", "提交申请失败,请稍后再试！");
    65.         }
    66.         return JSON.toJSONString(map);
    67.     }
    68.  
    69.     /**
    70.      * 撤销申请
    71.      * @param rid
    72.      * @return
    73.      */
    74.     @ResponseBody
    75.     @RequestMapping(value = "/apply/revoke")
    76.     public String revoke(@RequestParam("rid") String rid) {
    77.         HashMap<String, Object> map = new HashMap<>();
    78.         boolean result = requisitionService.revoke(rid);
    79.         if (result) {
    80.             map.put("success", true);
    81.             map.put("msg", "撤销成功！");
    82.         } else {
    83.             map.put("success", false);
    84.             map.put("msg", "撤销失败，请稍后重试！");
    85.         }
    86.         return JSON.toJSONString(map);
    87.     }
    88.  
    89.     @RequestMapping(value = "/todo.html")
    90.     public String todo(){
    91.         return "/staff/todo.html";
    92.     }
    93.  
    94.     /**
    95.      * 待领取列表
    96.      * @param rv
    97.      * @return
    98.      */
    99.     @ResponseBody
    100.     @RequestMapping(value = "/todo/list")
    101.     public DataGridViewResult todoList(RequisitionVo rv,HttpServletRequest request){
    102.         String uname = (String)request.getSession().getAttribute("uname");
    103.         rv.setRtaker(uname);
    104.         rv.setRstatus("待领取");
    105.         // 设置分页信息
    106.         PageHelper.startPage(rv.getPage(), rv.getLimit());
    107.         // 查询
    108.         List<Requisition> list = requisitionService.findRequisitionList(rv);
    109.         // 创建分页对象
    110.         PageInfo<Requisition> pageInfo = new PageInfo<Requisition>(list);
    111.         // 按接口要求返回数据
    112.         DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
    113.         return data;
    114.     }
    115. }

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

  • 相关阅读:
    Qt多弹窗实现包括QDialog、QWidget、QMainWindow
    【SpringCloud】SpringCloud简介
    基于遗传算法的红绿灯间隔时间优化（代码完整，数据齐全）
    Rust错误处理机制：优雅地管理错误
    1.工具-VSCode有哪些常用快捷键
    Python实现喷泉粒子系统（Win11）
    java-php-python-基于Web的社区商超系统的设计与实现计算机毕业设计
    MySQl有哪些索引（种类）？索引特点？为什么要使用索引？
    史上超全！Docker命令全集，值得收藏！
    针对多分类问题，使用深度学习--Keras进行微调提升性能
  • 原文地址：https://blog.csdn.net/m0_66863468/article/details/125612014