基于javaweb+mysql的springboot高校毕业生就业服务平台求职招聘系统(java+springboot+vue+mysql+redis)

基于javaweb+mysql的springboot高校毕业生就业服务平台求职招聘系统(java+springboot+vue+mysql+redis)

私信源码获取及调试交流

运行环境

Java≥8、MySQL≥5.7、Node.js≥10

开发工具

后端：eclipse/idea/myeclipse/sts等均可配置运行

前端：WebStorm/VSCode/HBuilderX等均可

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb+mysql的SpringBoot高校毕业生就业服务平台求职招聘系统(java+springboot+vue+mysql+redis)

管理员

admin 123456

学生

zhangsan 123456

lisi 123456

wangwu 123456

企业

alibaba 123456

tencent 123456

xiaomi 123456

前后端分离-毕业生就业服务平台

该项目是基于SpringBoot+Redis+Vue.js实现，采用采用JWT实现前后端分离验证，项目主要分为前台网站和后台管理系统。

技术架构

• 后端框架：SpringBoot 2.3

• 数据库：MySQL 5.7

• 缓存数据库：Redis

• 前后端验证技术：JWT、token

• 前端框架：Vuejs、ElementUI

后端token服务报错Connection refused

启动redis 服务就好

        return flag;
    }
}

@RestController
@RequestMapping("/project")
public class ProjectController {

    @Autowired
    private ProjectService projectService;
    @Autowired
    private ResumeService resumeService;
    @Autowired
    private UserDataService userDataService;

    @PostMapping("/create")
    public Result create(@RequestBody Project project) {
        int flag = projectService.create(project);
        if (flag > 0) {
            return Result.success();
        } else {
            return Result.error();
        }
    }

    @PostMapping("/delete")
    public Result delete(String ids) {
        int flag = projectService.delete(ids);
        if (flag > 0) {
            return Result.success();
        } else {

            return Result.error();
        }
    }

    @PostMapping("/update")
    public Result update(@RequestBody Student student) {
        int flag = studentService.update(student);
        if (flag > 0) {
            return Result.success();
        } else {
            return Result.error();
        }
    }

    @PostMapping("/detail")
    public Result detail(Integer id) {
        return Result.success(studentService.detail(id));
    }

    @PostMapping("/query")
    public Map<String, Object> query(@RequestBody Student student) {
        PageInfo<Student> pageInfo = studentService.query(student);
        return Result.success(pageInfo);
    }

    @PostMapping("info")
    @RequiresRoles(type = Role.STUDENT)
    public Result info(){
        String token = UserThreadLocal.get();
        UserData userData = (UserData) redisUtil.get(token);
        return  Result.success(studentService.detail(userData.getId()));
    }
}

        list.forEach(channel -> {
            if (channel.getParentId() == 0) {
                Map<String, Object> map = new HashMap<>();
                map.put("id", channel.getId());
                map.put("label", channel.getName());
                if (isChildren(channel.getId(), list)) {
                    map.put("children", children(channel.getId(), list));
                }
                mapList.add(map);
            }
        });
        return Result.success(mapList);
    }

    //如何支持多级：递归
    public List<Map<String, Object>> children(int id, List<Channel> list) {
        List<Map<String, Object>> children = new ArrayList<>();
        for (Channel channel : list) {
            if (channel.getParentId() == id) {
                Map<String, Object> map = new HashMap();
                map.put("id", channel.getId());
                map.put("label", channel.getName());
                if (isChildren(channel.getId(), list)) {//出口
                    map.put("children", children(channel.getId(), list));
                }
                children.add(map);
            }
        }
        return children;
    }

    public boolean isChildren(int id, List<Channel> list) {
        boolean flag = false;
        for (Channel channel : list) {
            if (channel.getParentId() == id) {
                flag = true;
            }
        }
        return flag;
    }
}

public class ArticleController {

    @Autowired
    private ArticleService articleService;
    @Autowired
    private RedisUtil redisUtil;

    @PostMapping("/create")
    public Result create(@RequestBody Article article) {
        //获取登录用户的信息
        String token = UserThreadLocal.get();
        UserData userData = (UserData) redisUtil.get(token);
        //设置一些属性
        article.setCreateDate(new Date());
        article.setUpdateDate(new Date());
        article.setCreateUser(userData.getId());
        int flag = articleService.create(article);
        if (flag > 0) {
            return Result.success();
        } else {
            return Result.error();
        }
    }

    @PostMapping("/delete")
    public Result delete(String ids) {
        int flag = articleService.delete(ids);
        if (flag > 0) {
            return Result.success();
        } else {
            return Result.error();
        }
    }

    @PostMapping("/update")
    public Result update(@RequestBody Article article) {
        //获取登录用户的信息
        String token = UserThreadLocal.get();
        UserData userData = (UserData) redisUtil.get(token);
        //设置一些属性
        article.setUpdateDate(new Date());
        article.setCreateUser(userData.getId());
        int flag = articleService.update(article);
        if (flag > 0) {
            return Result.success();
        } else {
            return Result.error();
        }
    }

    @PostMapping("/detail")
    public Result detail(Integer id) {
        return Result.success(articleService.detail(id));

        UserData user = userDataService.getUser();
        Resume resumeParam = resumeService.detail(user.getId());
        if(resumeParam == null) {
            return Result.success(new PageInfo<>());
        }
        train.setResumeId(resumeParam.getId());
        PageInfo<Train> pageInfo = trainService.query(train);
        pageInfo.getList().forEach(item -> {
            Resume resume = resumeService.detail(item.getResumeId());
            item.setResume(resume);
        });
        return Result.success(pageInfo);
    }

}

@RestController
@RequestMapping("/resume")
public class ResumeController {

    @Autowired
    private ResumeService resumeService;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private UserDataService userDataService;

    @PostMapping("/create")
    public Result create(@RequestBody Resume resume) {

            return Result.error();
        }
    }

    @PostMapping("/detail")
    public Result detail(Integer id) {
        return Result.success(favorService.detail(id));
    }

    @PostMapping("/query")
    public Map<String, Object> query(@RequestBody Favor favor) {
        PageInfo<Favor> pageInfo = favorService.query(favor);
        pageInfo.getList().forEach(item -> {
            item.setCompany(companyService.detail(item.getCompanyId()));
            item.setStudent(studentService.detail(item.getStudentId()));
            item.setPost(postService.detail(item.getPostId()));
        });
        return Result.success(pageInfo);
    }

}

@RestController
@RequestMapping("/article")
public class ArticleController {

    @Autowired
    private ArticleService articleService;

                map.put("parentId", profession.getParentId());
                //构建children
                map.put("children", children(profession.getId(), list));
                mapList.add(map);
            }
        });
        return Result.success(mapList);
    }

    public List<Map<String,Object>> children(int id, List<Profession> list) {
        List<Map<String,Object>> children = new ArrayList<>();
        for (Profession profession : list) {
            if(profession.getParentId() == id) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", profession.getId());
                map.put("label", profession.getName());
                map.put("parentId", profession.getParentId());
                children.add(map);
            }
        }
        return children;
    }
}

@RestController
public class LoginController {

    @Autowired
    private UserService userService;
    @Autowired
    private CompanyService companyService;

        Integer companyId = map.get("companyId");
        //2、判断是否重复申请职位
        Send sendParam = new Send();
        sendParam.setStudentId(userData.getId());
        sendParam.setPostId(postId);
        sendParam.setCompanyId(companyId);
        PageInfo<Send> sendPageInfo = sendService.query(sendParam);
        if (sendPageInfo.getList() != null && sendPageInfo.getList().size() > 0) {
            return Result.error("请勿重复申请职位");
        }
        //构建send对象
        Send send = new Send();
        send.setPostId(postId);
        send.setCompanyId(companyId);
        send.setSendDate(new Date());
        send.setStatus(0);
        send.setStudentId(userData.getId());
        //3、查询学生简历，判断简历是否开放
        Resume param = new Resume();
        param.setStudentId(userData.getId());
        param.setStatus(1);
        PageInfo<Resume> pageInfo = resumeService.query(param);
        if (pageInfo.getList() != null && pageInfo.getList().size() > 0) {
            Resume resume = pageInfo.getList().get(0);
            send.setResumeId(resume.getId());
        } else {
            Result.error("请先完善简历");
        }
        //4、进行保存操作
        int row = sendService.create(send);
        if (row > 0) {
            return Result.success("操作成功");
        } else {
            return Result.error("操作失败");
        }
    }

    @PostMapping("/delete")
    public Result delete(String ids) {
        int flag = sendService.delete(ids);
        if (flag > 0) {
            return Result.success();

@RestController
@RequestMapping("/intention")
public class IntentionController {

    @Autowired
    private IntentionService intentionService;
    @Autowired
    private ResumeService resumeService;
    @Autowired
    private UserDataService userDataService;

    @PostMapping("/create")
    public Result create(@RequestBody Intention intention) {
        int flag = intentionService.create(intention);
        if (flag > 0) {
            return Result.success();
        } else {
            return Result.error();
        }
    }

    @PostMapping("/delete")
    public Result delete(String ids) {
        int flag = intentionService.delete(ids);
        if (flag > 0) {
            return Result.success();
        } else {
            return Result.error();
        }
    }

    @PostMapping("/update")
    public Result update(@RequestBody Intention intention) {
        int flag = intentionService.update(intention);
        if (flag > 0) {
            return Result.success();
        } else {
            return Result.error();
        }
    }

    @PostMapping("/detail")
    public Result detail(Integer id) {
        return Result.success(intentionService.detail(id));
    }

    @PostMapping("/query")
    public Map<String, Object> query(@RequestBody Intention intention) {

    @PostMapping("/login")
    public Result login(@RequestBody Map<String,String> map) {
        String account = map.get("account");
        String password = map.get("password");
        String type = map.get("type");

        boolean flag = false;
        UserData userData = new UserData();

        if(Role.ADMIN.getCode().equals(Integer.parseInt(type))) {
            //管理员登录
            User user = userService.login(account, password);
            if(user != null) {
                flag = true;
                userData.setId(user.getId());
                userData.setAccount(user.getUserName());
                userData.setName(user.getName());
                userData.setType(Role.ADMIN.getCode());
            }
        }
        if(Role.COMPANY.getCode().equals(Integer.parseInt(type))) {
            //企业登录
            Company company = companyService.login(account, password);
            if(company != null) {
                flag = true;
                userData.setId(company.getId());
                userData.setAccount(company.getAccount());
                userData.setName(company.getName());
                userData.setType(Role.COMPANY.getCode());
            }
        }
        if(Role.STUDENT.getCode().equals(Integer.parseInt(type))) {
            //学生登录
            Student student = studentService.login(account, password);
            if(student != null) {
                flag = true;
                userData.setId(student.getId());
                userData.setAccount(student.getAccount());
                userData.setName(student.getName());
                userData.setType(Role.STUDENT.getCode());
            }
        }

        if(flag) {
            //登录成功

    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private UserDataService userDataService;

    @PostMapping("/create")
    public Result create(@RequestBody Post post) {
        //获取登录用户的信息
        String token = UserThreadLocal.get();
        UserData userData = (UserData) redisUtil.get(token);
        //设置企业id
        post.setCompanyId(userData.getId());
        int flag = postService.create(post);
        if (flag > 0) {
            return Result.success();
        } else {
            return Result.error();
        }
    }

    @PostMapping("/delete")
    public Result delete(String ids) {
        int flag = postService.delete(ids);
        if (flag > 0) {
            return Result.success();
        } else {
            return Result.error();
        }
    }

    @PostMapping("/update")
    public Result update(@RequestBody Post post) {
        int flag = postService.update(post);
        if (flag > 0) {
            return Result.success();
        } else {
            return Result.error();
        }
    }

    @PostMapping("/detail")
    public Result detail(Integer id) {
        return Result.success(postService.detail(id));
    }

    @PostMapping("/query")

    }

    @PostMapping("/detail")
    public Result detail(Integer id) {
        return Result.success(favorService.detail(id));
    }

    @PostMapping("/query")
    public Map<String, Object> query(@RequestBody Favor favor) {
        PageInfo<Favor> pageInfo = favorService.query(favor);
        pageInfo.getList().forEach(item -> {
            item.setCompany(companyService.detail(item.getCompanyId()));
            item.setStudent(studentService.detail(item.getStudentId()));
            item.setPost(postService.detail(item.getPostId()));
        });
        return Result.success(pageInfo);
    }

}

@RestController
@RequestMapping("/article")
public class ArticleController {

    @Autowired
    private ArticleService articleService;
    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private FavorService favorService;
    @Autowired
    private UserDataService userDataService;
    @Autowired
    private StudentService studentService;
    @Autowired
    private CompanyService companyService;
    @Autowired
    private PostService postService;

    @PostMapping("/create")
    public Result create(@RequestBody Map<String,Integer> map) {
        UserData userData = userDataService.getUser();
        //1、判断用户是否登录
        if(userData == null || userData.getType() != 2) {
            Result.success("非法登录不能操作");
        }
        Integer postId = map.get("postId");
        Integer companyId = map.get("companyId");
        //2、判断是否重复收藏
        Favor favorParam = new Favor();
        favorParam.setStudentId(userData.getId());
        favorParam.setPostId(postId);
        favorParam.setCompanyId(companyId);
        PageInfo<Favor> favorPageInfo = favorService.query(favorParam);
        if(favorPageInfo.getList() != null && favorPageInfo.getList().size() > 0) {
            return Result.error("请勿重复收藏职位");
        }
        //构建send对象
        Favor favor = new Favor();
        favor.setPostId(postId);
        favor.setCompanyId(companyId);
        favor.setFavorDate(new Date());
        favor.setStudentId(userData.getId());
        //3、进行保存操作
        int row = favorService.create(favor);
        if(row > 0) {
            return Result.success();
        } else {
            return Result.error("操作失败");
        }
    }

    @PostMapping("/delete")
    public Result delete(String ids) {
        int flag = favorService.delete(ids);
        if (flag > 0) {
            return Result.success();
        } else {

@RestController
@RequestMapping("/company")
public class CompanyController {

    @Autowired
    private CompanyService companyService;
    @Autowired
    private RedisUtil redisUtil;

    @PostMapping("/create")
    public Result create(@RequestBody Company company) {
        int flag = companyService.create(company);
        if (flag > 0) {
            return Result.success();
        } else {
            return Result.error();
        }
    }

    @PostMapping("/delete")
    public Result delete(String ids) {
        int flag = companyService.delete(ids);
        if (flag > 0) {
            return Result.success();
        } else {
            return Result.error();
        }
    }

    @PostMapping("/update")
    public Result update(@RequestBody Company company) {
        int flag = companyService.update(company);
        if (flag > 0) {
            return Result.success();
        } else {
            return Result.error();
        }
    }

    @PostMapping("/detail")
    public Result detail(Integer id) {
        return Result.success(companyService.detail(id));
    }

    @PostMapping("/query")

        }
        if(Role.STUDENT.getCode().equals(Integer.parseInt(type))) {
            //学生登录
            Student student = studentService.login(account, password);
            if(student != null) {
                flag = true;
                userData.setId(student.getId());
                userData.setAccount(student.getAccount());
                userData.setName(student.getName());
                userData.setType(Role.STUDENT.getCode());
            }
        }

        if(flag) {
            //登录成功
            //1、生成token
            String token = UUID.randomUUID().toString();
            //2、存入redis
            userData.setToken(token);
            redisUtil.set(token, userData, RedisUtil.EXPR);
            //3、响应数据
            return Result.success(userData);
        } else {
            return Result.error("用户名或密码错误");
        }
    }
}

@RestController
@RequestMapping("/favor")
public class FavorController {

    @Autowired

    @PostMapping("/detail")
    public Result detail(Integer id) {
        return Result.success(companyService.detail(id));
    }

    @PostMapping("/query")
    public Map<String, Object> query(@RequestBody Company company) {
        PageInfo<Company> pageInfo = companyService.query(company);
        return Result.success(pageInfo);
    }

    @PostMapping("/info")
    @RequiresRoles(type = Role.COMPANY)
    public Result info() {
        //获取登录用户的信息
        String token = UserThreadLocal.get();
        UserData userData = (UserData) redisUtil.get(token);
        return Result.success(companyService.detail(userData.getId()));
    }

}

@RestController
@RequestMapping("/train")
public class TrainController {

                mapList.add(map);
            }
        });
        return Result.success(mapList);
    }

    public List<Map<String,Object>> children(int id, List<Profession> list) {
        List<Map<String,Object>> children = new ArrayList<>();
        for (Profession profession : list) {
            if(profession.getParentId() == id) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", profession.getId());
                map.put("label", profession.getName());
                map.put("parentId", profession.getParentId());
                children.add(map);
            }
        }
        return children;
    }
}

@RestController
public class LoginController {

    @Autowired
    private UserService userService;
    @Autowired
    private CompanyService companyService;
    @Autowired
    private StudentService studentService;

        if(Role.STUDENT.getCode().equals(Integer.parseInt(type))) {
            //学生登录
            Student student = studentService.login(account, password);
            if(student != null) {
                flag = true;
                userData.setId(student.getId());
                userData.setAccount(student.getAccount());
                userData.setName(student.getName());
                userData.setType(Role.STUDENT.getCode());
            }
        }

        if(flag) {
            //登录成功
            //1、生成token
            String token = UUID.randomUUID().toString();
            //2、存入redis
            userData.setToken(token);
            redisUtil.set(token, userData, RedisUtil.EXPR);
            //3、响应数据
            return Result.success(userData);
        } else {
            return Result.error("用户名或密码错误");
        }
    }
}

@RestController
@RequestMapping("/favor")
public class FavorController {