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

ssm固定资产管理系统源码和论文_基于ssm框架的固定资产管理系统

作者：Cpp五条 | 2024-04-19 13:46:40

赞

踩

基于ssm框架的固定资产管理系统

ssm固定资产管理系统源码和论文167


 开发工具：idea 或eclipse
 数据库mysql5.7+
 数据库链接工具：navcat,小海豚等
  技术：ssm

  • 本课题国内外状况，说明选题依据和意义
  1. 课题意义

随着当前经济社会快速发展以及互联网技术的不断突破，作为我国企业的重 要战略资产和经济命脉，资产能够使得企业在竞争情况下获得最佳的业绩和目标。 作为横跨管理科学和计算机技术两门学科的交界产业，资产管理促进了知识管理， 知识管理可以协助企业完成实现资产管理的预订目标。这些资产管理数据以企业 的宝贵无形资产的形式储存在知识库、数据库以及文件柜或管理者信息库中。企 业管理者越来越重视资产管理系统的运用和实践。企业资产数据库中存在各种IT和基础设施设备，各种设备之间缺乏明显的关 联性。目前大多数企业对于资产的管理模式仅通过管理人员的记忆式的管理。由于企业硬件设备众多，且涉及到的运维组室复杂。小组之间多种运维资料缺乏联系，无法很好地涵盖数据中心整体规划，以及当前和长效的企业硬件设备和软件的运维，会让企业对于资产的管理工作越发难以进行。在各组之间，存在信息无法有效沟通的问题。仅依据网络资产，继续向该机柜添加设备，导致系统运行安全性严重减低。

资产管理系统是运用信息系统和计算机技术，全方位、多层次地监控和管理资产，并能够实时的对管理数据进行运维和流动，以达到提高企业部门的组织机构的应变能力、创新能力，以及不断提升企业生产效率和工作技能，从而可以全面地增强企业的竞争能力。

  1. 国外研究现状

固定资产的管理面临的问题对于国内外的众多企业、高校等单位都是一样 的，所以早在上个世纪的时候，国外的专家、学者、技术研发人员就从不同的方面对固定资产管理系统进行过研究。首先从固定资产管理的理论来说，较早进行相关研究的是以美国等西方国家为典型的，这些国家提出了应用于固定资产管理的可持续发展管理理论、贯穿资产生命周期的生命周期管理理论等管理理论，为固定资产的管理模式、运行模式等形成提供了理论基础。前期由此而开发很多单机版的资产管理系统帮助国外的企业进行日常的固定资产管理工作。从固定资产发展的方向来说，国外较早提出要注重资产管理数据的安全性，保护资产数据不被篡改和恶意使用，注重资产的可靠性，保证资产的来源是正确无误的；基于这些目的就要搭建专门的管理信息系统面向复杂度不同的各类资产管理工作，并建构监管体系，制定固定资产管理的长期规划，从整体上提高效率，把风险降到最低。从固定资产管理的系统研究来说，从早期的单机版系统到目前的以网络化为主的很多跨平台的固定资产管理系统，系统的研究逐渐深入，应用的领域和行业越来越多，如国外的斯坦福大学、美国通用、花旗集团、帝国理工学院都很早使用或者研发了固定资产或者设备管理系统。此外国外还涌现了很多优秀的产品，如由IT的优秀企业IBM公司开发的MAXIM管理系统，由加拿大蒙特利尔城市IFCS公司开发的Senergy产品。前者属于一种商品化的软件开发品，能够帮助用户进行固定资产的预防性维修管理，还能够对资产进行售后维护的记录和管理，所以面向的对象大多是企业用户；系统中建立了台帐对所有类型的资产进行信息管理，以维修线索作为固定资产的过程线索，完成设备维修申请的提交、申请的审批和执行申请整个过程；同时还提供了采购流程、预算流程和供应商管理等内容，涵盖的内容较多，保证固定资产的库存率不高，实现对各类资源的优化配置。

  1. package com.controller;
  2.  
  3.  
  4. import java.text.SimpleDateFormat;
  5. import com.alibaba.fastjson.JSONObject;
  6. import java.util.*;
  7.  
  8. import com.entity.BaofeiEntity;
  9. import com.service.BaofeiService;
  10. import org.springframework.beans.BeanUtils;
  11. import javax.servlet.http.HttpServletRequest;
  12. import org.springframework.web.context.ContextLoader;
  13. import javax.servlet.ServletContext;
  14. import com.service.TokenService;
  15. import com.utils.StringUtil;
  16. import java.lang.reflect.InvocationTargetException;
  17.  
  18. import com.service.DictionaryService;
  19. import org.apache.commons.lang3.StringUtils;
  20. import com.annotation.IgnoreAuth;
  21. import org.slf4j.Logger;
  22. import org.slf4j.LoggerFactory;
  23. import org.springframework.beans.factory.annotation.Autowired;
  24. import org.springframework.stereotype.Controller;
  25. import org.springframework.web.bind.annotation.*;
  26. import com.baomidou.mybatisplus.mapper.EntityWrapper;
  27. import com.baomidou.mybatisplus.mapper.Wrapper;
  28.  
  29. import com.entity.ZichanEntity;
  30.  
  31. import com.service.ZichanService;
  32. import com.entity.view.ZichanView;
  33. import com.utils.PageUtils;
  34. import com.utils.R;
  35.  
  36. /**
  37.  * 资产
  38.  * 后端接口
  39.  * @author
  40.  * @email
  41.  * @date 2021-04-06
  42. */
  43. @RestController
  44. @Controller
  45. @RequestMapping("/zichan")
  46. public class ZichanController {
  47.     private static final Logger logger = LoggerFactory.getLogger(ZichanController.class);
  48.  
  49.     @Autowired
  50.     private ZichanService zichanService;
  51.  
  52.     @Autowired
  53.     private BaofeiService baofeiService;
  54.  
  55.  
  56.     @Autowired
  57.     private TokenService tokenService;
  58.     @Autowired
  59.     private DictionaryService dictionaryService;
  60.  
  61.  
  62.     //级联表service
  63.  
  64.  
  65.     /**
  66.     * 后端列表
  67.     */
  68.     @RequestMapping("/page")
  69.     public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
  70.         logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
  71.         String role = String.valueOf(request.getSession().getAttribute("role"));
  72.         if(StringUtil.isNotEmpty(role) && "用户".equals(role)){
  73.             params.put("yonghuId",request.getSession().getAttribute("userId"));
  74.         }
  75.         params.put("orderBy","id");
  76.         PageUtils page = zichanService.queryPage(params);
  77.  
  78.         //字典表数据转换
  79.         List<ZichanView> list =(List<ZichanView>)page.getList();
  80.         for(ZichanView c:list){
  81.             //修改对应字典表字段
  82.             dictionaryService.dictionaryConvert(c);
  83.         }
  84.         return R.ok().put("data", page);
  85.     }
  86.  
  87.     /**
  88.     * 后端详情
  89.     */
  90.     @RequestMapping("/info/{id}")
  91.     public R info(@PathVariable("id") Long id){
  92.         logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
  93.         ZichanEntity zichan = zichanService.selectById(id);
  94.         if(zichan !=null){
  95.             //entity转view
  96.             ZichanView view = new ZichanView();
  97.             BeanUtils.copyProperties( zichan , view );//把实体数据重构到view中
  98.  
  99.             //修改对应字典表字段
  100.             dictionaryService.dictionaryConvert(view);
  101.             return R.ok().put("data", view);
  102.         }else {
  103.             return R.error(511,"查不到数据");
  104.         }
  105.  
  106.     }
  107.  
  108.     /**
  109.     * 后端保存
  110.     */
  111.     @RequestMapping("/save")
  112.     public R save(@RequestBody ZichanEntity zichan, HttpServletRequest request){
  113.         logger.debug("save方法:,,Controller:{},,zichan:{}",this.getClass().getName(),zichan.toString());
  114.         Wrapper<ZichanEntity> queryWrapper = new EntityWrapper<ZichanEntity>()
  115.             .eq("zichan_name", zichan.getZichanName())
  116.             .eq("zichan_types", zichan.getZichanTypes())
  117.             .eq("bumen_types", zichan.getBumenTypes())
  118.             .eq("zichan_guige", zichan.getZichanGuige())
  119.             .eq("zichan_changjia", zichan.getZichanChangjia())
  120.             .eq("zichan_baoyang", zichan.getZichanBaoyang())
  121.             ;
  122.         logger.info("sql语句:"+queryWrapper.getSqlSegment());
  123.         ZichanEntity zichanEntity = zichanService.selectOne(queryWrapper);
  124.         if(zichanEntity==null){
  125.             zichan.setCreateTime(new Date());
  126.         //  String role = String.valueOf(request.getSession().getAttribute("role"));
  127.         //  if("".equals(role)){
  128.         //      zichan.set
  129.         //  }
  130.             zichanService.insert(zichan);
  131.             return R.ok();
  132.         }else {
  133.             return R.error(511,"表中有相同数据");
  134.         }
  135.     }
  136.  
  137.     /**
  138.     * 后端修改
  139.     */
  140.     @RequestMapping("/update")
  141.     public R update(@RequestBody ZichanEntity zichan, HttpServletRequest request){
  142.         logger.debug("update方法:,,Controller:{},,zichan:{}",this.getClass().getName(),zichan.toString());
  143.         //根据字段查询是否有相同数据
  144.         Wrapper<ZichanEntity> queryWrapper = new EntityWrapper<ZichanEntity>()
  145.             .notIn("id",zichan.getId())
  146.             .andNew()
  147.             .eq("zichan_name", zichan.getZichanName())
  148.             .eq("zichan_types", zichan.getZichanTypes())
  149.             .eq("bumen_types", zichan.getBumenTypes())
  150.             .eq("zichan_guige", zichan.getZichanGuige())
  151.             .eq("zichan_changjia", zichan.getZichanChangjia())
  152.             .eq("zichan_baoyang", zichan.getZichanBaoyang())
  153.             ;
  154.         logger.info("sql语句:"+queryWrapper.getSqlSegment());
  155.         ZichanEntity zichanEntity = zichanService.selectOne(queryWrapper);
  156.         if(zichanEntity==null){
  157.             //  String role = String.valueOf(request.getSession().getAttribute("role"));
  158.             //  if("".equals(role)){
  159.             //      zichan.set
  160.             //  }
  161.             zichanService.updateById(zichan);//根据id更新
  162.             return R.ok();
  163.         }else {
  164.             return R.error(511,"表中有相同数据");
  165.         }
  166.     }
  167.  
  168.  
  169.     /**
  170.     * 删除
  171.     */
  172.     @RequestMapping("/delete")
  173.     public R delete(Integer ids){
  174.         ZichanEntity zichan = zichanService.selectById(ids);
  175.         if(zichan == null){
  176.             return R.error();
  177.         }
  178.         BaofeiEntity baofei = new BaofeiEntity();
  179.         baofei.setCreateTime(new Date());
  180.         baofei.setInsertTime(new Date());
  181.         baofei.setZichanName(zichan.getZichanName());
  182.         boolean insert = baofeiService.insert(baofei);
  183.         if(insert){
  184.             boolean b = zichanService.deleteBatchIds(Arrays.asList(ids));
  185.             if(b){
  186.                 return R.ok();
  187.             }
  188.         }
  189.         return R.error();
  190.     }
  191.  
  192.  
  193.  
  194. }
  195.  
  1. package com.controller;
  2.  
  3.  
  4. import java.text.SimpleDateFormat;
  5. import com.alibaba.fastjson.JSONObject;
  6. import java.util.*;
  7. import org.springframework.beans.BeanUtils;
  8. import javax.servlet.http.HttpServletRequest;
  9. import org.springframework.web.context.ContextLoader;
  10. import javax.servlet.ServletContext;
  11. import com.service.TokenService;
  12. import com.utils.StringUtil;
  13. import java.lang.reflect.InvocationTargetException;
  14.  
  15. import com.service.DictionaryService;
  16. import org.apache.commons.lang3.StringUtils;
  17. import com.annotation.IgnoreAuth;
  18. import org.slf4j.Logger;
  19. import org.slf4j.LoggerFactory;
  20. import org.springframework.beans.factory.annotation.Autowired;
  21. import org.springframework.stereotype.Controller;
  22. import org.springframework.web.bind.annotation.*;
  23. import com.baomidou.mybatisplus.mapper.EntityWrapper;
  24. import com.baomidou.mybatisplus.mapper.Wrapper;
  25.  
  26. import com.entity.BaofeiEntity;
  27.  
  28. import com.service.BaofeiService;
  29. import com.entity.view.BaofeiView;
  30. import com.utils.PageUtils;
  31. import com.utils.R;
  32.  
  33. /**
  34.  * 资产报废
  35.  * 后端接口
  36.  * @author
  37.  * @email
  38.  * @date 2021-04-06
  39. */
  40. @RestController
  41. @Controller
  42. @RequestMapping("/baofei")
  43. public class BaofeiController {
  44.     private static final Logger logger = LoggerFactory.getLogger(BaofeiController.class);
  45.  
  46.     @Autowired
  47.     private BaofeiService baofeiService;
  48.  
  49.  
  50.     @Autowired
  51.     private TokenService tokenService;
  52.     @Autowired
  53.     private DictionaryService dictionaryService;
  54.  
  55.  
  56.     //级联表service
  57.  
  58.  
  59.     /**
  60.     * 后端列表
  61.     */
  62.     @RequestMapping("/page")
  63.     public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
  64.         logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
  65.         String role = String.valueOf(request.getSession().getAttribute("role"));
  66.         if(StringUtil.isNotEmpty(role) && "用户".equals(role)){
  67.             params.put("yonghuId",request.getSession().getAttribute("userId"));
  68.         }
  69.         params.put("orderBy","id");
  70.         PageUtils page = baofeiService.queryPage(params);
  71.  
  72.         //字典表数据转换
  73.         List<BaofeiView> list =(List<BaofeiView>)page.getList();
  74.         for(BaofeiView c:list){
  75.             //修改对应字典表字段
  76.             dictionaryService.dictionaryConvert(c);
  77.         }
  78.         return R.ok().put("data", page);
  79.     }
  80.  
  81.     /**
  82.     * 后端详情
  83.     */
  84.     @RequestMapping("/info/{id}")
  85.     public R info(@PathVariable("id") Long id){
  86.         logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
  87.         BaofeiEntity baofei = baofeiService.selectById(id);
  88.         if(baofei !=null){
  89.             //entity转view
  90.             BaofeiView view = new BaofeiView();
  91.             BeanUtils.copyProperties( baofei , view );//把实体数据重构到view中
  92.  
  93.             //修改对应字典表字段
  94.             dictionaryService.dictionaryConvert(view);
  95.             return R.ok().put("data", view);
  96.         }else {
  97.             return R.error(511,"查不到数据");
  98.         }
  99.  
  100.     }
  101.  
  102.     /**
  103.     * 后端保存
  104.     */
  105.     @RequestMapping("/save")
  106.     public R save(@RequestBody BaofeiEntity baofei, HttpServletRequest request){
  107.         logger.debug("save方法:,,Controller:{},,baofei:{}",this.getClass().getName(),baofei.toString());
  108.         Wrapper<BaofeiEntity> queryWrapper = new EntityWrapper<BaofeiEntity>()
  109.             .eq("zichan_name", baofei.getZichanName())
  110.             ;
  111.         logger.info("sql语句:"+queryWrapper.getSqlSegment());
  112.         BaofeiEntity baofeiEntity = baofeiService.selectOne(queryWrapper);
  113.         if(baofeiEntity==null){
  114.             baofei.setInsertTime(new Date());
  115.             baofei.setCreateTime(new Date());
  116.         //  String role = String.valueOf(request.getSession().getAttribute("role"));
  117.         //  if("".equals(role)){
  118.         //      baofei.set
  119.         //  }
  120.             baofeiService.insert(baofei);
  121.             return R.ok();
  122.         }else {
  123.             return R.error(511,"表中有相同数据");
  124.         }
  125.     }
  126.  
  127.     /**
  128.     * 后端修改
  129.     */
  130.     @RequestMapping("/update")
  131.     public R update(@RequestBody BaofeiEntity baofei, HttpServletRequest request){
  132.         logger.debug("update方法:,,Controller:{},,baofei:{}",this.getClass().getName(),baofei.toString());
  133.         //根据字段查询是否有相同数据
  134.         Wrapper<BaofeiEntity> queryWrapper = new EntityWrapper<BaofeiEntity>()
  135.             .notIn("id",baofei.getId())
  136.             .andNew()
  137.             .eq("zichan_name", baofei.getZichanName())
  138.             ;
  139.         logger.info("sql语句:"+queryWrapper.getSqlSegment());
  140.         BaofeiEntity baofeiEntity = baofeiService.selectOne(queryWrapper);
  141.         if(baofeiEntity==null){
  142.             //  String role = String.valueOf(request.getSession().getAttribute("role"));
  143.             //  if("".equals(role)){
  144.             //      baofei.set
  145.             //  }
  146.             baofeiService.updateById(baofei);//根据id更新
  147.             return R.ok();
  148.         }else {
  149.             return R.error(511,"表中有相同数据");
  150.         }
  151.     }
  152.  
  153.  
  154.     /**
  155.     * 删除
  156.     */
  157.     @RequestMapping("/delete")
  158.     public R delete(@RequestBody Integer[] ids){
  159.         logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
  160.         baofeiService.deleteBatchIds(Arrays.asList(ids));
  161.         return R.ok();
  162.     }
  163.  
  164.  
  165.  
  166. }
  167.

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

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

  

闽ICP备14008679号