计算机毕业设计选题推荐-高校学生求职就业招聘平台-Java/Python项目实战

IT研究室

于 2024-08-19 11:18:05 发布

阅读量760

点赞数 11

分类专栏： Java项目 Python项目文章标签：课程设计 java python 毕业设计源码 spring boot django

本文链接：https://blog.csdn.net/2301_79456892/article/details/141320376

版权

Java项目同时被 2 个专栏收录

136 篇文章 6 订阅

订阅专栏

Python项目

76 篇文章 9 订阅

订阅专栏

✨作者主页：IT研究室✨
个人简介：曾从事计算机专业培训教学，擅长Java、Python、微信小程序、Golang、安卓Android等项目实战。接项目定制开发、代码讲解、答辩教学、文档编写、降重等。
☑文末获取源码☑
精彩专栏推荐⬇⬇⬇
Java项目
Python项目
安卓项目
微信小程序项目

一、前言

当前，随着信息技术的快速发展，特别是云计算、大数据、人工智能等技术的应用，智慧教育已成为教育行业的重要发展方向。在高等教育领域，高校毕业生的就业问题一直是社会关注的焦点。据统计，2022年中国高校毕业生数量达到1076万，创历史新高。面对严峻的就业形势和疫情的双重挑战，如何利用信息技术提高高校毕业生的就业服务质量和效率，成为亟待解决的问题。

尽管目前已有一些就业服务平台，但仍存在一些问题。例如，信息更新不够及时，导致毕业生无法获取最新的就业信息；平台功能单一，缺乏个性化的就业指导和职业规划服务；此外，平台的用户体验不佳，操作复杂，不够人性化。这些问题限制了就业服务平台在提升就业服务质量和效率方面的潜力。

本课题旨在设计并实现一个功能全面、操作简便、用户友好的高校学生求职就业招聘平台。系统将提供用户管理、招聘信息管理、简历投递、面试通知、面试结果查看等功能，以满足不同用户角色的需求，优化招聘流程，提高求职成功率。

本课题的研究具有重要的理论意义和实际意义。从理论角度来看，它为高等教育领域提供了新的研究思路，即如何利用信息技术提升就业服务的质量和效率。从实际角度来看，该平台的应用将有助于提高高校毕业生的就业率，优化企业的招聘流程，提升学校的就业指导服务水平，促进高校、企业和学生之间的有效沟通和合作。同时，系统的推广应用还将推动教育信息化进程，促进教育现代化的发展。

在高校学生求职就业招聘平台中，管理员负责用户账户的创建与维护、公告信息的发布与管理、论坛内容的监管、岗位类型的分类与管理、招聘信息的审核与更新、投递简历的查看与处理、面试通知的发送与面试结果的审核；企业用户可以发布和管理自己的招聘信息、查看投递的简历、发送面试通知、提交面试结果；学生用户能够浏览招聘信息、参与论坛交流、查看和更新公告信息、投递简历、接收面试通知、查看面试结果。系统通过这些功能模块的整合，旨在提供一个全面、互动的求职就业服务平台，满足不同用户角色的需求，优化招聘流程，提高求职成功率。

二、开发环境

开发语言：Java/Python
数据库：MySQL
系统架构：B/S
后端：SpringBoot/SSM/Django/Flask
前端：Vue

三、系统界面展示

高校学生求职就业招聘平台界面展示：
企业-招聘信息管理：

学生-查看招聘信息：

学生-投递简历：

企业-查阅简历：

企业-面试通知：

企业-提交面试结果：

四、代码参考

项目实战代码参考：

@RestController
@Controller
@RequestMapping("/zhaopin")
public class ZhaopinController {
    private static final Logger logger = LoggerFactory.getLogger(ZhaopinController.class);

    private static final String TABLE_NAME = "zhaopin";

    @Autowired
    private ZhaopinService zhaopinService;


    @Autowired
    private TokenService tokenService;

    @Autowired
    private DictionaryService dictionaryService;//字典表
    @Autowired
    private ForumService forumService;//论坛
    @Autowired
    private GongsiService gongsiService;//企业
    @Autowired
    private JianliService jianliService;//简历
    @Autowired
    private NewsService newsService;//公告信息
    @Autowired
    private TongzhiService tongzhiService;//企业通知
    @Autowired
    private ToudiService toudiService;//简历投递
    @Autowired
    private YonghuService yonghuService;//用户
    @Autowired
    private ZhaopinCollectionService zhaopinCollectionService;//职位收藏
    @Autowired
    private ZhaopinLiuyanService zhaopinLiuyanService;//职位留言
    @Autowired
    private UsersService usersService;//管理员


    /**
    * 后端列表
    */
    @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(false)
            return R.error(511,"永不会进入");
        else if("用户".equals(role))
            params.put("yonghuId",request.getSession().getAttribute("userId"));
        else if("企业".equals(role))
            params.put("gongsiId",request.getSession().getAttribute("userId"));
        CommonUtil.checkMap(params);
        PageUtils page = zhaopinService.queryPage(params);

        //字典表数据转换
        List<ZhaopinView> list =(List<ZhaopinView>)page.getList();
        for(ZhaopinView 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);
        ZhaopinEntity zhaopin = zhaopinService.selectById(id);
        if(zhaopin !=null){
            //entity转view
            ZhaopinView view = new ZhaopinView();
            BeanUtils.copyProperties( zhaopin , view );//把实体数据重构到view中
            //级联表 企业
            //级联表
            GongsiEntity gongsi = gongsiService.selectById(zhaopin.getGongsiId());
            if(gongsi != null){
            BeanUtils.copyProperties( gongsi , view ,new String[]{ "id", "createTime", "insertTime", "updateTime", "gongsiId"});//把级联的数据添加到view中,并排除id和创建时间字段,当前表的级联注册表
            view.setGongsiId(gongsi.getId());
            }
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(view, request);
            return R.ok().put("data", view);
        }else {
            return R.error(511,"查不到数据");
        }

    }

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

        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(false)
            return R.error(511,"永远不会进入");
        else if("企业".equals(role))
            zhaopin.setGongsiId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));

        Wrapper<ZhaopinEntity> queryWrapper = new EntityWrapper<ZhaopinEntity>()
            .eq("gongsi_id", zhaopin.getGongsiId())
            .eq("zhaopin_name", zhaopin.getZhaopinName())
            .eq("zhaopin_daiyu", zhaopin.getZhaopinDaiyu())
            .eq("zhaopin_address", zhaopin.getZhaopinAddress())
            .eq("lianxiren_name", zhaopin.getLianxirenName())
            .eq("zhaopin_phone", zhaopin.getZhaopinPhone())
            .eq("zan_number", zhaopin.getZanNumber())
            .eq("cai_number", zhaopin.getCaiNumber())
            .eq("zhaopin_types", zhaopin.getZhaopinTypes())
            .eq("leixing_types", zhaopin.getLeixingTypes())
            .eq("zhaopin_renshu_number", zhaopin.getZhaopinRenshuNumber())
            .eq("shangxia_types", zhaopin.getShangxiaTypes())
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ZhaopinEntity zhaopinEntity = zhaopinService.selectOne(queryWrapper);
        if(zhaopinEntity==null){
            zhaopin.setShangxiaTypes(1);
            zhaopin.setCreateTime(new Date());
            zhaopinService.insert(zhaopin);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 后端修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody ZhaopinEntity zhaopin, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
        logger.debug("update方法:,,Controller:{},,zhaopin:{}",this.getClass().getName(),zhaopin.toString());
        ZhaopinEntity oldZhaopinEntity = zhaopinService.selectById(zhaopin.getId());//查询原先数据

        String role = String.valueOf(request.getSession().getAttribute("role"));
//        if(false)
//            return R.error(511,"永远不会进入");
//        else if("企业".equals(role))
//            zhaopin.setGongsiId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
        if("".equals(zhaopin.getZhaopinPhoto()) || "null".equals(zhaopin.getZhaopinPhoto())){
                zhaopin.setZhaopinPhoto(null);
        }

            zhaopinService.updateById(zhaopin);//根据id更新
            return R.ok();
    }



    /**
    * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
        List<ZhaopinEntity> oldZhaopinList =zhaopinService.selectBatchIds(Arrays.asList(ids));//要删除的数据
        zhaopinService.deleteBatchIds(Arrays.asList(ids));

        return R.ok();
    }


    /**
     * 批量上传
     */
    @RequestMapping("/batchInsert")
    public R save( String fileName, HttpServletRequest request){
        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
        Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            List<ZhaopinEntity> zhaopinList = 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){
                            //循环
                            ZhaopinEntity zhaopinEntity = new ZhaopinEntity();
//                            zhaopinEntity.setGongsiId(Integer.valueOf(data.get(0)));   //企业 要改的
//                            zhaopinEntity.setZhaopinName(data.get(0));                    //招聘信息名称 要改的
//                            zhaopinEntity.setZhaopinPhoto("");//详情和图片
//                            zhaopinEntity.setZhaopinDaiyu(data.get(0));                    //薪资待遇 要改的
//                            zhaopinEntity.setZhaopinAddress(data.get(0));                    //上班地点 要改的
//                            zhaopinEntity.setLianxirenName(data.get(0));                    //联系人 要改的
//                            zhaopinEntity.setZhaopinPhone(data.get(0));                    //招聘电话 要改的
//                            zhaopinEntity.setZanNumber(Integer.valueOf(data.get(0)));   //赞 要改的
//                            zhaopinEntity.setCaiNumber(Integer.valueOf(data.get(0)));   //踩 要改的
//                            zhaopinEntity.setZhaopinTypes(Integer.valueOf(data.get(0)));   //招聘岗位 要改的
//                            zhaopinEntity.setLeixingTypes(Integer.valueOf(data.get(0)));   //招聘类型 要改的
//                            zhaopinEntity.setZhaopinRenshuNumber(Integer.valueOf(data.get(0)));   //招聘人数 要改的
//                            zhaopinEntity.setShangxiaTypes(Integer.valueOf(data.get(0)));   //是否上架 要改的
//                            zhaopinEntity.setZhaopinContent("");//详情和图片
//                            zhaopinEntity.setCreateTime(date);//时间
                            zhaopinList.add(zhaopinEntity);


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

                        //查询是否重复
                         //招聘电话
                        List<ZhaopinEntity> zhaopinEntities_zhaopinPhone = zhaopinService.selectList(new EntityWrapper<ZhaopinEntity>().in("zhaopin_phone", seachFields.get("zhaopinPhone")));
                        if(zhaopinEntities_zhaopinPhone.size() >0 ){
                            ArrayList<String> repeatFields = new ArrayList<>();
                            for(ZhaopinEntity s:zhaopinEntities_zhaopinPhone){
                                repeatFields.add(s.getZhaopinPhone());
                            }
                            return R.error(511,"数据库的该表中的 [招聘电话] 字段已经存在 存在数据为:"+repeatFields.toString());
                        }
                        zhaopinService.insertBatch(zhaopinList);
                        return R.ok();
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            return R.error(511,"批量插入数据异常，请联系管理员");
        }
    }



    /**
    * 个性推荐
    */
    @IgnoreAuth
    @RequestMapping("/gexingtuijian")
    public R gexingtuijian(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("gexingtuijian方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
        CommonUtil.checkMap(params);
        List<ZhaopinView> returnZhaopinViewList = new ArrayList<>();

        //查看收藏
        Map<String, Object> params1 = new HashMap<>(params);params1.put("sort","id");params1.put("yonghuId",request.getSession().getAttribute("userId"));
        PageUtils pageUtils = zhaopinCollectionService.queryPage(params1);
        List<ZhaopinCollectionView> collectionViewsList =(List<ZhaopinCollectionView>)pageUtils.getList();
        Map<Integer,Integer> typeMap=new HashMap<>();//购买的类型list
        for(ZhaopinCollectionView collectionView:collectionViewsList){
            Integer zhaopinTypes = collectionView.getZhaopinTypes();
            if(typeMap.containsKey(zhaopinTypes)){
                typeMap.put(zhaopinTypes,typeMap.get(zhaopinTypes)+1);
            }else{
                typeMap.put(zhaopinTypes,1);
            }
        }
        List<Integer> typeList = new ArrayList<>();//排序后的有序的类型 按最多到最少
        typeMap.entrySet().stream().sorted((o1, o2) -> o2.getValue() - o1.getValue()).forEach(e -> typeList.add(e.getKey()));//排序
        Integer limit = Integer.valueOf(String.valueOf(params.get("limit")));
        for(Integer type:typeList){
            Map<String, Object> params2 = new HashMap<>(params);params2.put("zhaopinTypes",type);
            PageUtils pageUtils1 = zhaopinService.queryPage(params2);
            List<ZhaopinView> zhaopinViewList =(List<ZhaopinView>)pageUtils1.getList();
            returnZhaopinViewList.addAll(zhaopinViewList);
            if(returnZhaopinViewList.size()>= limit) break;//返回的推荐数量大于要的数量 跳出循环
        }
        //正常查询出来商品,用于补全推荐缺少的数据
        PageUtils page = zhaopinService.queryPage(params);
        if(returnZhaopinViewList.size()<limit){//返回数量还是小于要求数量
            int toAddNum = limit - returnZhaopinViewList.size();//要添加的数量
            List<ZhaopinView> zhaopinViewList =(List<ZhaopinView>)page.getList();
            for(ZhaopinView zhaopinView:zhaopinViewList){
                Boolean addFlag = true;
                for(ZhaopinView returnZhaopinView:returnZhaopinViewList){
                    if(returnZhaopinView.getId().intValue() ==zhaopinView.getId().intValue()) addFlag=false;//返回的数据中已存在此商品
                }
                if(addFlag){
                    toAddNum=toAddNum-1;
                    returnZhaopinViewList.add(zhaopinView);
                    if(toAddNum==0) break;//够数量了
                }
            }
        }else {
            returnZhaopinViewList = returnZhaopinViewList.subList(0, limit);
        }

        for(ZhaopinView c:returnZhaopinViewList)
            dictionaryService.dictionaryConvert(c, request);
        page.setList(returnZhaopinViewList);
        return R.ok().put("data", page);
    }

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

        CommonUtil.checkMap(params);
        PageUtils page = zhaopinService.queryPage(params);

        //字典表数据转换
        List<ZhaopinView> list =(List<ZhaopinView>)page.getList();
        for(ZhaopinView 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);
        ZhaopinEntity zhaopin = zhaopinService.selectById(id);
            if(zhaopin !=null){


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

                //级联表
                    GongsiEntity gongsi = gongsiService.selectById(zhaopin.getGongsiId());
                if(gongsi != null){
                    BeanUtils.copyProperties( gongsi , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
                    view.setGongsiId(gongsi.getId());
                }
                //修改对应字典表字段
                dictionaryService.dictionaryConvert(view, request);
                return R.ok().put("data", view);
            }else {
                return R.error(511,"查不到数据");
            }
    }


    /**
    * 前端保存
    */
    @RequestMapping("/add")
    public R add(@RequestBody ZhaopinEntity zhaopin, HttpServletRequest request){
        logger.debug("add方法:,,Controller:{},,zhaopin:{}",this.getClass().getName(),zhaopin.toString());
        Wrapper<ZhaopinEntity> queryWrapper = new EntityWrapper<ZhaopinEntity>()
            .eq("gongsi_id", zhaopin.getGongsiId())
            .eq("zhaopin_name", zhaopin.getZhaopinName())
            .eq("zhaopin_daiyu", zhaopin.getZhaopinDaiyu())
            .eq("zhaopin_address", zhaopin.getZhaopinAddress())
            .eq("lianxiren_name", zhaopin.getLianxirenName())
            .eq("zhaopin_phone", zhaopin.getZhaopinPhone())
            .eq("zan_number", zhaopin.getZanNumber())
            .eq("cai_number", zhaopin.getCaiNumber())
            .eq("zhaopin_types", zhaopin.getZhaopinTypes())
            .eq("leixing_types", zhaopin.getLeixingTypes())
            .eq("zhaopin_renshu_number", zhaopin.getZhaopinRenshuNumber())
            .eq("shangxia_types", zhaopin.getShangxiaTypes())
//            .notIn("zhaopin_types", new Integer[]{102})
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ZhaopinEntity zhaopinEntity = zhaopinService.selectOne(queryWrapper);
        if(zhaopinEntity==null){
                zhaopin.setZanNumber(1);
                zhaopin.setCaiNumber(1);
            zhaopin.setCreateTime(new Date());
        zhaopinService.insert(zhaopin);

            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

}

@RestController
@Controller
@RequestMapping("/toudi")
public class ToudiController {
    private static final Logger logger = LoggerFactory.getLogger(ToudiController.class);

    private static final String TABLE_NAME = "toudi";

    @Autowired
    private ToudiService toudiService;


    @Autowired
    private TokenService tokenService;

    @Autowired
    private DictionaryService dictionaryService;//字典表
    @Autowired
    private ForumService forumService;//论坛
    @Autowired
    private GongsiService gongsiService;//企业
    @Autowired
    private JianliService jianliService;//简历
    @Autowired
    private NewsService newsService;//公告信息
    @Autowired
    private TongzhiService tongzhiService;//企业通知
    @Autowired
    private YonghuService yonghuService;//用户
    @Autowired
    private ZhaopinService zhaopinService;//职位招聘
    @Autowired
    private ZhaopinCollectionService zhaopinCollectionService;//职位收藏
    @Autowired
    private ZhaopinLiuyanService zhaopinLiuyanService;//职位留言
    @Autowired
    private UsersService usersService;//管理员


    /**
    * 后端列表
    */
    @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(false)
            return R.error(511,"永不会进入");
        else if("用户".equals(role))
            params.put("yonghuId",request.getSession().getAttribute("userId"));
        else if("企业".equals(role))
            params.put("gongsiId",request.getSession().getAttribute("userId"));
        CommonUtil.checkMap(params);
        PageUtils page = toudiService.queryPage(params);

        //字典表数据转换
        List<ToudiView> list =(List<ToudiView>)page.getList();
        for(ToudiView 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);
        ToudiEntity toudi = toudiService.selectById(id);
        if(toudi !=null){
            //entity转view
            ToudiView view = new ToudiView();
            BeanUtils.copyProperties( toudi , view );//把实体数据重构到view中
            //级联表 简历
            //级联表
            JianliEntity jianli = jianliService.selectById(toudi.getJianliId());
            if(jianli != null){
            BeanUtils.copyProperties( jianli , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段,当前表的级联注册表
            view.setJianliId(jianli.getId());
            }
            //级联表 职位招聘
            //级联表
            ZhaopinEntity zhaopin = zhaopinService.selectById(toudi.getZhaopinId());
            if(zhaopin != null){
            BeanUtils.copyProperties( zhaopin , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段,当前表的级联注册表
            view.setZhaopinId(zhaopin.getId());
            }
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(view, request);
            return R.ok().put("data", view);
        }else {
            return R.error(511,"查不到数据");
        }

    }

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

        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(false)
            return R.error(511,"永远不会进入");

        Wrapper<JianliEntity> jianliEntityWrapper = new EntityWrapper<JianliEntity>()
                .eq("yonghu_id", request.getSession().getAttribute("userId"));
        List<JianliEntity> jianliEntities = jianliService.selectList(jianliEntityWrapper);

        toudi.setJianliId(jianliEntities.get(0).getId());
        Wrapper<ToudiEntity> queryWrapper = new EntityWrapper<ToudiEntity>()
            .eq("jianli_id", toudi.getJianliId())
            .eq("zhaopin_id", toudi.getZhaopinId())
            .in("toudi_yesno_types", new Integer[]{1,2})
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ToudiEntity toudiEntity = toudiService.selectOne(queryWrapper);
        if(toudiEntity==null){
            toudi.setToudiYesnoTypes(1);
            toudi.setInsertTime(new Date());
            toudi.setCreateTime(new Date());
            toudiService.insert(toudi);
            return R.ok();
        }else {
            if(toudiEntity.getToudiYesnoTypes()==1)
                return R.error(511,"有相同的待审核的数据");
            else if(toudiEntity.getToudiYesnoTypes()==2)
                return R.error(511,"有相同的审核通过的数据");
            else
                return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 后端修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody ToudiEntity toudi, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
        logger.debug("update方法:,,Controller:{},,toudi:{}",this.getClass().getName(),toudi.toString());
        ToudiEntity oldToudiEntity = toudiService.selectById(toudi.getId());//查询原先数据

        String role = String.valueOf(request.getSession().getAttribute("role"));
//        if(false)
//            return R.error(511,"永远不会进入");

            toudiService.updateById(toudi);//根据id更新
            return R.ok();
    }


    /**
    * 审核
    */
    @RequestMapping("/shenhe")
    public R shenhe(@RequestBody ToudiEntity toudiEntity, HttpServletRequest request){
        logger.debug("shenhe方法:,,Controller:{},,toudiEntity:{}",this.getClass().getName(),toudiEntity.toString());

        ToudiEntity oldToudi = toudiService.selectById(toudiEntity.getId());//查询原先数据

//        if(toudiEntity.getToudiYesnoTypes() == 2){//通过
//            toudiEntity.setToudiTypes();
//        }else if(toudiEntity.getToudiYesnoTypes() == 3){//拒绝
//            toudiEntity.setToudiTypes();
//        }
        toudiService.updateById(toudiEntity);//审核

        return R.ok();
    }

    /**
    * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
        List<ToudiEntity> oldToudiList =toudiService.selectBatchIds(Arrays.asList(ids));//要删除的数据
        toudiService.deleteBatchIds(Arrays.asList(ids));

        return R.ok();
    }


    /**
     * 批量上传
     */
    @RequestMapping("/batchInsert")
    public R save( String fileName, HttpServletRequest request){
        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
        Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            List<ToudiEntity> toudiList = 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){
                            //循环
                            ToudiEntity toudiEntity = new ToudiEntity();
//                            toudiEntity.setJianliId(Integer.valueOf(data.get(0)));   //简历 要改的
//                            toudiEntity.setZhaopinId(Integer.valueOf(data.get(0)));   //招聘 要改的
//                            toudiEntity.setToudiYesnoTypes(Integer.valueOf(data.get(0)));   //投递状态 要改的
//                            toudiEntity.setToudiYesnoText(data.get(0));                    //投递回复 要改的
//                            toudiEntity.setInsertTime(date);//时间
//                            toudiEntity.setCreateTime(date);//时间
                            toudiList.add(toudiEntity);


                            //把要查询是否重复的字段放入map中
                        }

                        //查询是否重复
                        toudiService.insertBatch(toudiList);
                        return R.ok();
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            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));

        CommonUtil.checkMap(params);
        PageUtils page = toudiService.queryPage(params);

        //字典表数据转换
        List<ToudiView> list =(List<ToudiView>)page.getList();
        for(ToudiView 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);
        ToudiEntity toudi = toudiService.selectById(id);
            if(toudi !=null){


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

                //级联表
                    JianliEntity jianli = jianliService.selectById(toudi.getJianliId());
                if(jianli != null){
                    BeanUtils.copyProperties( jianli , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
                    view.setJianliId(jianli.getId());
                }
                //级联表
                    ZhaopinEntity zhaopin = zhaopinService.selectById(toudi.getZhaopinId());
                if(zhaopin != null){
                    BeanUtils.copyProperties( zhaopin , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
                    view.setZhaopinId(zhaopin.getId());
                }
                //修改对应字典表字段
                dictionaryService.dictionaryConvert(view, request);
                return R.ok().put("data", view);
            }else {
                return R.error(511,"查不到数据");
            }
    }


    /**
    * 前端保存
    */
    @RequestMapping("/add")
    public R add(@RequestBody ToudiEntity toudi, HttpServletRequest request){
        logger.debug("add方法:,,Controller:{},,toudi:{}",this.getClass().getName(),toudi.toString());
        Wrapper<ToudiEntity> queryWrapper = new EntityWrapper<ToudiEntity>()
            .eq("jianli_id", toudi.getJianliId())
            .eq("zhaopin_id", toudi.getZhaopinId())
            .in("toudi_yesno_types", new Integer[]{1,2})
            .eq("toudi_yesno_text", toudi.getToudiYesnoText())
//            .notIn("toudi_types", new Integer[]{102})
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ToudiEntity toudiEntity = toudiService.selectOne(queryWrapper);
        if(toudiEntity==null){
            toudi.setToudiYesnoTypes(1);
            toudi.setInsertTime(new Date());
            toudi.setCreateTime(new Date());
        toudiService.insert(toudi);

            return R.ok();
        }else {
            if(toudiEntity.getToudiYesnoTypes()==1)
                return R.error(511,"有相同的待审核的数据");
            else if(toudiEntity.getToudiYesnoTypes()==2)
                return R.error(511,"有相同的审核通过的数据");
            else
                return R.error(511,"表中有相同数据");
        }
    }

}

五、论文参考

计算机毕业设计选题推荐-高校学生求职就业招聘平台论文参考：

六、系统视频

高校学生求职就业招聘平台项目视频：

计算机毕业设计选题推荐-高校学生求职就业招聘平台-项目实战

结语

计算机毕业设计选题推荐-高校学生求职就业招聘平台-Java/Python项目实战
大家可以帮忙点赞、收藏、关注、评论啦～
源码获取：⬇⬇⬇

精彩专栏推荐⬇⬇⬇
Java项目
Python项目
安卓项目
微信小程序项目

IT研究室

关注

11
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
0
评论
计算机毕业设计选题推荐-高校学生求职就业招聘平台-Java/Python项目实战

当前，随着信息技术的快速发展，特别是云计算、大数据、人工智能等技术的应用，智慧教育已成为教育行业的重要发展方向。在高等教育领域，高校毕业生的就业问题一直是社会关注的焦点。据统计，2022年中国高校毕业生数量达到1076万，创历史新高。面对严峻的就业形势和疫情的双重挑战，如何利用信息技术提高高校毕业生的就业服务质量和效率，成为亟待解决的问题。
复制链接

扫一扫