基于java+springboot+vue的码头船只货柜管理系统

最新推荐文章于 2024-07-29 14:22:26 发布

qq_3306428634

最新推荐文章于 2024-07-29 14:22:26 发布

阅读量141

点赞数

分类专栏： JAVA项目文章标签： java spring boot vue mysql

本文链接：https://blog.csdn.net/qq_3306428634/article/details/132092547

版权

JAVA项目专栏收录该内容

994 篇文章 52 订阅

订阅专栏

项目介绍

针对于码头船只货柜信息管理方面的不规范，容错率低，管理人员处理数据费工费时，采用新开发的码头船只货柜管理系统可以从根源上规范整个数据处理流程。

码头船只货柜管理系统能够实现货柜管理，路线管理，新闻管理，船只管理，用户管理等功能。该系统采用了Mysql数据库，Java语言，Spring Boot框架等技术进行编程实现。

码头船只货柜管理系统可以提高码头船只货柜信息管理问题的解决效率，优化码头船只货柜信息处理流程，提交信息处理效率。

4.1 功能结构设计
图4.1即为设计的系统功能结构，系统分为管理员和用户两个操作权限，管理员权限操作的功能包括管理用户，管理船只，管理路线，管理货柜，管理新闻等。用户权限操作的功能包括查看船只，查看新闻，查看路线以及货柜信息等。
在这里插入图片描述

开发环境

编程语言：Java
数据库：Mysql
系统架构：B/S
后端框架：SpringBoot
编译工具：idea或者eclipse，jdk1.8，maven
支持定做：java/php/python/android/小程序vue/爬虫/c#/asp.net

系统实现

5.1 管理员功能实现
5.1.1 船只信息管理
图5.1 即为编码实现的船只信息管理界面，管理员在该界面中新增船只信息，船只信息包括船只材质，船只型号等信息，管理员可以对船只信息进行查询，更改等操作。
在这里插入图片描述

图5.1 船只信息管理界面

5.1.2 货柜信息管理
图5.2 即为编码实现的货柜信息管理界面，管理员在该界面中对货柜信息进行新增，货柜信息包括货柜类型，货柜型号等信息，在本界面，管理员可以更改货柜信息，查询货柜信息等。
在这里插入图片描述

图5.2 货柜信息管理界面

5.1.3 路线信息管理
图5.3 即为编码实现的路线信息管理界面，管理员在该界面中具备对路线信息新增，查询，编辑，删除等操作权限。
在这里插入图片描述

图5.3 路线信息管理界面

5.1.4 新闻管理
图5.4 即为编码实现的新闻管理界面，管理员在该界面中具备发布新闻，编辑新闻，查询新闻等权限。
在这里插入图片描述

图5.4 新闻管理界面

5.1.5 用户管理
图5.5 即为编码实现的用户管理界面，管理员在该界面中为用户的账号重置密码，更改用户资料，查询用户等。
在这里插入图片描述

图5.5 用户管理界面

5.2 用户功能实现
5.2.1 船只信息
图5.6 即为编码实现的船只信息界面，用户在该界面中查询船只，查看船只信息。
在这里插入图片描述

图5.6 船只信息界面

5.2.2 新闻信息
图5.7 即为编码实现的新闻信息界面，用户在该界面中查询并查看新闻信息。
在这里插入图片描述

图5.7 新闻信息界面

5.2.3 更改个人信息
图5.8 即为编码实现的更改个人信息界面，用户在该界面中对个人信息进行查看，对登记错误的个人信息进行更改，也包括更改个人照片，更改手机号等信息。
在这里插入图片描述

图5.8 更改个人信息界面

核心代码

package com.controller;

import java.io.File;
import java.math.BigDecimal;
import java.net.URL;
import java.text.SimpleDateFormat;
import com.alibaba.fastjson.JSONObject;
import java.util.*;
import org.springframework.beans.BeanUtils;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.context.ContextLoader;
import javax.servlet.ServletContext;
import com.service.TokenService;
import com.utils.*;
import java.lang.reflect.InvocationTargetException;

import com.service.DictionaryService;
import org.apache.commons.lang3.StringUtils;
import com.annotation.IgnoreAuth;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.entity.*;
import com.entity.view.*;
import com.service.*;
import com.utils.PageUtils;
import com.utils.R;
import com.alibaba.fastjson.*;

/**
 * 船只信息
 * 后端接口
 * @author
 * @email
*/
@RestController
@Controller
@RequestMapping("/chuanzhi")
public class ChuanzhiController {
    private static final Logger logger = LoggerFactory.getLogger(ChuanzhiController.class);

    @Autowired
    private ChuanzhiService chuanzhiService;


    @Autowired
    private TokenService tokenService;
    @Autowired
    private DictionaryService dictionaryService;

    //级联表service

    @Autowired
    private YonghuService yonghuService;


    /**
    * 后端列表
    */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(StringUtil.isEmpty(role))
            return R.error(511,"权限为空");
        else if("用户".equals(role))
            params.put("yonghuId",request.getSession().getAttribute("userId"));
        params.put("chuanzhiDeleteStart",1);params.put("chuanzhiDeleteEnd",1);
        if(params.get("orderBy")==null || params.get("orderBy")==""){
            params.put("orderBy","id");
        }
        PageUtils page = chuanzhiService.queryPage(params);

        //字典表数据转换
        List<ChuanzhiView> list =(List<ChuanzhiView>)page.getList();
        for(ChuanzhiView c:list){
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(c, request);
        }
        return R.ok().put("data", page);
    }

    /**
    * 后端详情
    */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id, HttpServletRequest request){
        logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        ChuanzhiEntity chuanzhi = chuanzhiService.selectById(id);
        if(chuanzhi !=null){
            //entity转view
            ChuanzhiView view = new ChuanzhiView();
            BeanUtils.copyProperties( chuanzhi , view );//把实体数据重构到view中

            //修改对应字典表字段
            dictionaryService.dictionaryConvert(view, request);
            return R.ok().put("data", view);
        }else {
            return R.error(511,"查不到数据");
        }

    }

    /**
    * 后端保存
    */
    @RequestMapping("/save")
    public R save(@RequestBody ChuanzhiEntity chuanzhi, HttpServletRequest request){
        logger.debug("save方法:,,Controller:{},,chuanzhi:{}",this.getClass().getName(),chuanzhi.toString());

        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(StringUtil.isEmpty(role))
            return R.error(511,"权限为空");

        Wrapper<ChuanzhiEntity> queryWrapper = new EntityWrapper<ChuanzhiEntity>()
            .eq("chuanzhi_uuid_number", chuanzhi.getChuanzhiUuidNumber())
            .eq("chuanzhi_name", chuanzhi.getChuanzhiName())
            .eq("chuanzhi_types", chuanzhi.getChuanzhiTypes())
            .eq("chuanzhi_xinghao", chuanzhi.getChuanzhiXinghao())
            .eq("chuanzhi_caizhi", chuanzhi.getChuanzhiCaizhi())
            .eq("chuanzhi_delete", chuanzhi.getChuanzhiDelete())
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ChuanzhiEntity chuanzhiEntity = chuanzhiService.selectOne(queryWrapper);
        if(chuanzhiEntity==null){
            chuanzhi.setChuanzhiDelete(1);
            chuanzhi.setCreateTime(new Date());
            chuanzhiService.insert(chuanzhi);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 后端修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody ChuanzhiEntity chuanzhi, HttpServletRequest request){
        logger.debug("update方法:,,Controller:{},,chuanzhi:{}",this.getClass().getName(),chuanzhi.toString());

        String role = String.valueOf(request.getSession().getAttribute("role"));
//        if(StringUtil.isEmpty(role))
//            return R.error(511,"权限为空");
        //根据字段查询是否有相同数据
        Wrapper<ChuanzhiEntity> queryWrapper = new EntityWrapper<ChuanzhiEntity>()
            .notIn("id",chuanzhi.getId())
            .andNew()
            .eq("chuanzhi_uuid_number", chuanzhi.getChuanzhiUuidNumber())
            .eq("chuanzhi_name", chuanzhi.getChuanzhiName())
            .eq("chuanzhi_types", chuanzhi.getChuanzhiTypes())
            .eq("chuanzhi_xinghao", chuanzhi.getChuanzhiXinghao())
            .eq("chuanzhi_caizhi", chuanzhi.getChuanzhiCaizhi())
            .eq("chuanzhi_delete", chuanzhi.getChuanzhiDelete())
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ChuanzhiEntity chuanzhiEntity = chuanzhiService.selectOne(queryWrapper);
        if("".equals(chuanzhi.getChuanzhiPhoto()) || "null".equals(chuanzhi.getChuanzhiPhoto())){
                chuanzhi.setChuanzhiPhoto(null);
        }
        if(chuanzhiEntity==null){
            //  String role = String.valueOf(request.getSession().getAttribute("role"));
            //  if("".equals(role)){
            //      chuanzhi.set
            //  }
            chuanzhiService.updateById(chuanzhi);//根据id更新
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids){
        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
        ArrayList<ChuanzhiEntity> list = new ArrayList<>();
        for(Integer id:ids){
            ChuanzhiEntity chuanzhiEntity = new ChuanzhiEntity();
            chuanzhiEntity.setId(id);
            chuanzhiEntity.setChuanzhiDelete(2);
            list.add(chuanzhiEntity);
        }
        if(list != null && list.size() >0){
            chuanzhiService.updateBatchById(list);
        }
        return R.ok();
    }


    /**
     * 批量上传
     */
    @RequestMapping("/batchInsert")
    public R save( String fileName){
        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
        try {
            List<ChuanzhiEntity> chuanzhiList = new ArrayList<>();//上传的东西
            Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
            Date date = new Date();
            int lastIndexOf = fileName.lastIndexOf(".");
            if(lastIndexOf == -1){
                return R.error(511,"该文件没有后缀");
            }else{
                String suffix = fileName.substring(lastIndexOf);
                if(!".xls".equals(suffix)){
                    return R.error(511,"只支持后缀为xls的excel文件");
                }else{
                    URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
                    File file = new File(resource.getFile());
                    if(!file.exists()){
                        return R.error(511,"找不到上传文件，请联系管理员");
                    }else{
                        List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
                        dataList.remove(0);//删除第一行，因为第一行是提示
                        for(List<String> data:dataList){
                            //循环
                            ChuanzhiEntity chuanzhiEntity = new ChuanzhiEntity();
//                            chuanzhiEntity.setChuanzhiUuidNumber(data.get(0));                    //船只编号 要改的
//                            chuanzhiEntity.setChuanzhiName(data.get(0));                    //船只名称 要改的
//                            chuanzhiEntity.setChuanzhiTypes(Integer.valueOf(data.get(0)));   //船只类型 要改的
//                            chuanzhiEntity.setChuanzhiPhoto("");//照片
//                            chuanzhiEntity.setChuanzhiXinghao(data.get(0));                    //船只型号 要改的
//                            chuanzhiEntity.setChuanzhiCaizhi(data.get(0));                    //船只材质 要改的
//                            chuanzhiEntity.setChuanzhiContent("");//照片
//                            chuanzhiEntity.setChuanzhiDelete(1);//逻辑删除字段
//                            chuanzhiEntity.setCreateTime(date);//时间
                            chuanzhiList.add(chuanzhiEntity);


                            //把要查询是否重复的字段放入map中
                                //船只编号
                                if(seachFields.containsKey("chuanzhiUuidNumber")){
                                    List<String> chuanzhiUuidNumber = seachFields.get("chuanzhiUuidNumber");
                                    chuanzhiUuidNumber.add(data.get(0));//要改的
                                }else{
                                    List<String> chuanzhiUuidNumber = new ArrayList<>();
                                    chuanzhiUuidNumber.add(data.get(0));//要改的
                                    seachFields.put("chuanzhiUuidNumber",chuanzhiUuidNumber);
                                }
                        }

                        //查询是否重复
                         //船只编号
                        List<ChuanzhiEntity> chuanzhiEntities_chuanzhiUuidNumber = chuanzhiService.selectList(new EntityWrapper<ChuanzhiEntity>().in("chuanzhi_uuid_number", seachFields.get("chuanzhiUuidNumber")).eq("chuanzhi_delete", 1));
                        if(chuanzhiEntities_chuanzhiUuidNumber.size() >0 ){
                            ArrayList<String> repeatFields = new ArrayList<>();
                            for(ChuanzhiEntity s:chuanzhiEntities_chuanzhiUuidNumber){
                                repeatFields.add(s.getChuanzhiUuidNumber());
                            }
                            return R.error(511,"数据库的该表中的 [船只编号] 字段已经存在 存在数据为:"+repeatFields.toString());
                        }
                        chuanzhiService.insertBatch(chuanzhiList);
                        return R.ok();
                    }
                }
            }
        }catch (Exception e){
            return R.error(511,"批量插入数据异常，请联系管理员");
        }
    }





    /**
    * 前端列表
    */
    @IgnoreAuth
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));

        // 没有指定排序字段就默认id倒序
        if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
            params.put("orderBy","id");
        }
        PageUtils page = chuanzhiService.queryPage(params);

        //字典表数据转换
        List<ChuanzhiView> list =(List<ChuanzhiView>)page.getList();
        for(ChuanzhiView c:list)
            dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
        return R.ok().put("data", page);
    }

    /**
    * 前端详情
    */
    @RequestMapping("/detail/{id}")
    public R detail(@PathVariable("id") Long id, HttpServletRequest request){
        logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        ChuanzhiEntity chuanzhi = chuanzhiService.selectById(id);
            if(chuanzhi !=null){


                //entity转view
                ChuanzhiView view = new ChuanzhiView();
                BeanUtils.copyProperties( chuanzhi , view );//把实体数据重构到view中

                //修改对应字典表字段
                dictionaryService.dictionaryConvert(view, request);
                return R.ok().put("data", view);
            }else {
                return R.error(511,"查不到数据");
            }
    }


    /**
    * 前端保存
    */
    @RequestMapping("/add")
    public R add(@RequestBody ChuanzhiEntity chuanzhi, HttpServletRequest request){
        logger.debug("add方法:,,Controller:{},,chuanzhi:{}",this.getClass().getName(),chuanzhi.toString());
        Wrapper<ChuanzhiEntity> queryWrapper = new EntityWrapper<ChuanzhiEntity>()
            .eq("chuanzhi_uuid_number", chuanzhi.getChuanzhiUuidNumber())
            .eq("chuanzhi_name", chuanzhi.getChuanzhiName())
            .eq("chuanzhi_types", chuanzhi.getChuanzhiTypes())
            .eq("chuanzhi_xinghao", chuanzhi.getChuanzhiXinghao())
            .eq("chuanzhi_caizhi", chuanzhi.getChuanzhiCaizhi())
            .eq("chuanzhi_delete", chuanzhi.getChuanzhiDelete())
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ChuanzhiEntity chuanzhiEntity = chuanzhiService.selectOne(queryWrapper);
        if(chuanzhiEntity==null){
            chuanzhi.setChuanzhiDelete(1);
            chuanzhi.setCreateTime(new Date());
        //  String role = String.valueOf(request.getSession().getAttribute("role"));
        //  if("".equals(role)){
        //      chuanzhi.set
        //  }
        chuanzhiService.insert(chuanzhi);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }


}

论文参考

在这里插入图片描述

第1章绪论 1
1.1 课题背景 1
1.2 课题意义 1
1.3 研究内容 2
第2章开发环境与技术 3
2.1 JAVA语言 3
2.2 MYSQL数据库 3
2.3 IDEA开发工具 4
2.4 SPRING BOOT框架 4
第3章系统分析 5
3.1 可行性分析 5
3.1.1 技术可行性 5
3.1.2 经济可行性 5
3.1.3 操作可行性 5
3.2 系统流程 5
3.2.1 操作流程 6
3.2.2 登录流程 6
3.2.3 删除信息流程 7
3.2.4 添加信息流程 7
3.3 性能需求 8
3.4 功能需求 9
第4章系统设计 11
4.1 功能结构设计 11
4.2 数据库设计 12
4.2.1 数据库概念设计 12
4.2.2 数据库物理设计 15
第5章系统实现 18
5.1 管理员功能实现 18
5.1.1 船只信息管理 18
5.1.2 货柜信息管理 18
5.1.3 路线信息管理 19
5.1.4 新闻管理 19
5.1.5 用户管理 20
5.2 用户功能实现 20
5.2.1 船只信息 20
5.2.2 新闻信息 21
5.2.3 更改个人信息 21
第6章系统测试 23
6.1 功能测试 23
6.1.1 登录功能测试 23
6.1.2 修改密码功能测试 24
6.2 系统测试结果 25
结论 26
参考文献 28
致谢 29

qq_3306428634

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
基于java+springboot+vue的码头船只货柜管理系统

针对于码头船只货柜信息管理方面的不规范，容错率低，管理人员处理数据费工费时，采用新开发的码头船只货柜管理系统可以从根源上规范整个数据处理流程。码头船只货柜管理系统能够实现货柜管理，路线管理，新闻管理，船只管理，用户管理等功能。该系统采用了Mysql数据库，Java语言，Spring Boot框架等技术进行编程实现。码头船只货柜管理系统可以提高码头船只货柜信息管理问题的解决效率，优化码头船只货柜信息处理流程，提交信息处理效率。4.1 功能结构设计。
复制链接

扫一扫