基于javaweb+mysql的springboot兼职平台系统(java+springboot+ssm+html+maven+ajax+mysql)

基于javaweb+mysql的springboot兼职平台系统(java+springboot+ssm+html+maven+ajax+mysql)

运行环境

Java≥8、MySQL≥5.7

开发工具

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

适用

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

功能说明

管理员：后台管理

雇主：发布兼职任务、指派兼职人

兼职者：竞标接单

基于javaweb+mysql的SpringBoot兼职平台系统(java+springboot+ssm+html+maven+ajax+mysql)

一、项目运行 环境配置：

Jdk1.8 + Tomcat8.5 + mysql + Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）

项目技术：

HTML +Springboot+ SpringMVC + MyBatis + ThymeLeaf + JavaScript + JQuery + Ajax + maven等等.

/**
 * 文件上传控制器
 *
 * @Classname UploadController
 * @see com.yuu.recruit.controller
 */
@Controller
public class UploadController {

    private static final String ENDPOINT = "oss-cn-beijing.aliyuncs.com";
    private static final String ACCESS_KEY_ID = "LTAI4Fzn8nSjZm7R1dA4G6kp";
    private static final String ACCESS_KEY_SECRET = "5LfEnU4JlGHqViyhgZkzwYcyythV0F";
    private static final String BUCKET_NAME = "ce11211";

    /**
     * 图片上传
     *
     * @param dropzFile
     * @param request
     * @return

    /**
     * 确定完成任务
     *
     * @param taskId
     * @return
     */
    @GetMapping("task/success")
    public String successTask(Long taskId) {
        taskService.successTask(taskId);
        return "redirect:/employer/myTasks";
    }

    /**
     * 跳转到个人信息设置页面
     *
     * @return
     */
    @GetMapping("settings/base")
    public String settings(HttpSession session, Model model) {
        // 获取 session 中的雇员信息
        Employer employer = (Employer) session.getAttribute("employer");
        model.addAttribute("employer", employer);
        return "employer/settings_base";
    }

    /**
     * 保存个人基本信息
     *
     * @param employer
     * @return
     */
    @PostMapping("settings/base/save")
    public String saveBase(Employer employer, HttpSession session) {
        // 更新个人信息到数据库
        Employer currEmployer = employerService.save(employer);

        // 更新 session 中的个人信息
        session.setAttribute("employer", currEmployer);
        return "redirect:/employer/settings/base";
    }

    /**
     * 跳转到修改密码页
     *
     * @return
     */
    @GetMapping("settings/password")
    public String updatePass() {
        return "employer/settings_pass";
    }

    /**

    @Resource
    private TaskService taskService;

    @Resource
    private TaskCategoryService taskCategoryService;

    @Resource
    private BidService bidService;

    @Resource
    private EmployerService employerService;

    /**
     * 雇主退出登录
     *
     * @param session
     * @return
     */
    @GetMapping("logout")
    public String logout(HttpSession session) {
        session.removeAttribute("employer");
        return "redirect:/index";
    }

    /**
     * 跳转到个人中心
     */
    @GetMapping("dashboard")
    public String dashboard(HttpSession session, Model model) {

        // 获取雇主登录情况
        Employer employer = (Employer) session.getAttribute("employer");

        // 查询总发布任务数量
        List<TaskVo> tasks = taskService.getByEmployerId(employer.getId());
        Integer taskCount = tasks != null ? tasks.size() : 0;

        // 查询任务总投标人数
        Integer bidCount = taskService.getBidCount(employer.getId());

        // 任务提交完成
        List<TaskVo> taskVos = taskService.getRecentlySubmit(employer.getId());

        // 放置域对象中
        model.addAttribute("taskCount", taskCount);
        model.addAttribute("bidCount", bidCount);
        model.addAttribute("tasks", taskVos);

        return "employer/dashboard";

    public String index(Model model) {

        // 查询所有任务分类, 为什么要用 Vo 对象，因为首页展示的热门分类中需要显示，该分类的任务数量，所以需要创建一个 Vo 对象，来包含分类任务数量信息
        List<TaskCategoryVo> taskCategoryVos = taskCategoryService.getAll();

        // 查询任务发布总数
        Integer taskCount = taskService.getAllCount();

        // 查询自由职业者(雇员）总数
        Integer employeeCount = employeeService.getAllCount();

        // 雇主数量
        Integer employerCount = employerService.getAllCount();

        // 查询热门分类,分类状态为 1 则为人们分类
        List<TaskCategoryVo> popularCategories = taskCategoryService.getPopular();

        // 查询近期任务（查询 5 条）,根据创建时间来查询
        List<TaskVo> recentTaskVos =  taskService.getRecently();

        // 添加到 Model 域对象中，供页面展示
        model.addAttribute("taskCategories", taskCategoryVos);
        model.addAttribute("taskCount", taskCount);
        model.addAttribute("employeeCount", employeeCount);
        model.addAttribute("employerCount", employerCount);
        model.addAttribute("popularCategories", popularCategories);
        model.addAttribute("recentTasks", recentTaskVos);

        return "index";
    }

    /**
     * 跳转到注册页面
     *
     * @return
     */
    @GetMapping("register")
    public String register() {
        return "register";
    }

    /**
     * 用户注册，包括雇员和雇主，通过传过来的 accountType 判断
     *
     * @return
     */
    @PostMapping("register")
    public String register(Integer accountType, String username, String password, RedirectAttributes redirectAttributes) {
        // 如果传过来的 accountType 为 0 则为雇员注册

        List<TaskVo> recentTaskVos =  taskService.getRecently();

        // 添加到 Model 域对象中，供页面展示
        model.addAttribute("taskCategories", taskCategoryVos);
        model.addAttribute("taskCount", taskCount);
        model.addAttribute("employeeCount", employeeCount);
        model.addAttribute("employerCount", employerCount);
        model.addAttribute("popularCategories", popularCategories);
        model.addAttribute("recentTasks", recentTaskVos);

        return "index";
    }

    /**
     * 跳转到注册页面
     *
     * @return
     */
    @GetMapping("register")
    public String register() {
        return "register";
    }

    /**
     * 用户注册，包括雇员和雇主，通过传过来的 accountType 判断
     *
     * @return
     */
    @PostMapping("register")
    public String register(Integer accountType, String username, String password, RedirectAttributes redirectAttributes) {
        // 如果传过来的 accountType 为 0 则为雇员注册
        if (accountType == 0) {
            // 先判断用户名是否注册过
            Employee employee = employeeService.getByUsername(username);
            // 如果 employee 不为 null,说明该用户名已经被注册过了，不能注册
            if (employee != null) {
                // 设置到重定向的域对象中，供页面提示
                redirectAttributes.addFlashAttribute("msg", "用户名已被注册");
                // 重定向到注册页
                return "redirect:/register";
            }

            // 用户名不存在，注册
            employeeService.register(username, password);

            // 注册成功，重定向到登录页

    public String bookmarks(HttpSession session, Model model) {
        // 获取雇员登录信息
        Employee employee = (Employee) session.getAttribute("employee");

        // 获取收藏的任务集合
        List<EmployeeBookmarkedVo> bookMarks = employeeBookmarkedService.getByEmployeeId(employee.getId());

        // 放置到域对象中，方便页面展示
        model.addAttribute("bookMarks", bookMarks);

        return "employee/bookmarks";
    }

    /**
     * 删除收藏任务
     *
     * @param taskId 任务 ID
     * @return
     */
    @PostMapping("bookmarks/remove")
    @ResponseBody
    public String bookmarks(Long taskId, HttpSession session) {
        // 获取雇员登录信息
        Employee employee = (Employee) session.getAttribute("employee");

        // 删除收藏信息
        employeeBookmarkedService.remove(employee.getId(), taskId);

        return "删除收藏信息";
    }

    /**
     * 查询已完成任务
     *
     * @param session
     * @return
     */
    @GetMapping("/task/completed")
    public String completedTask(HttpSession session, Model model) {
        // 获取雇员登录信息
        Employee employee = (Employee) session.getAttribute("employee");

        // 查询出已完成的订单
        List<TaskVo> taskVos = taskService.getCompletedByEmployeeId(employee.getId());

        // 放置到域对象中
        model.addAttribute("tasks", taskVos);
        return "employee/completed_task";
    }

        // 查询所有任务
        List<TaskCategoryVo> categorys = taskCategoryService.getAll();

        TaskVo taskVo = taskService.getById(taskId);

        model.addAttribute("task", taskVo);
        model.addAttribute("taskCategories", categorys);
        return "employer/update_task";
    }

    /**
     * 添加技能
     *
     * @param skillName 技能名称
     * @return
     */
    @PostMapping("skill/add")
    @ResponseBody
    public String addSkill(String skillName, Long taskId, HttpSession session) {
        if (!"".equals(skillName)) {
            employerService.addSkill(taskId, skillName);
        }
        return "添加技能";
    }

    /**
     * 删除技能
     *
     * @param skillId
     * @return
     */
    @PostMapping("skill/delete")
    @ResponseBody
    public String deleteSkill(Long skillId) {
        employerService.deleteSkill(skillId);
        return "删除技能";
    }

    /**
     * 更新任务
     *
     * @param task 任务
     * @return
     */
    @PostMapping("task/update")
    public String updateTask(Task task, String upload, RedirectAttributes redirectAttributes) {
        // 修改任务

     * @return
     */
    @PostMapping("task/update")
    public String updateTask(Task task, String upload, RedirectAttributes redirectAttributes) {
        // 修改任务
        if (!"".equals(upload)) {
            task.setFilename(upload);
        }
        taskService.updateTask(task);
        // 提示消息
        redirectAttributes.addFlashAttribute("msg", "发布任务成功，等待管理员审核！");
        return "redirect:/employer/myTasks";
    }

    /**
     * 删除任务
     *
     * @param taskId 任务 ID
     * @return
     */
    @GetMapping("task/delete")
    public String deleteTask(Long taskId) {
        taskService.deleteById(taskId);
        return "redirect:/employer/myTasks";
    }

    /**
     * 跳转到任务竞标者管理页面
     *
     * @return
     */
    @GetMapping("taskBidders")
    public String manageBidders(Long taskId, Model model) {

        // 查询任务信息
        TaskVo taskVo = taskService.getById(taskId);

        // 放置域对象中
        model.addAttribute("task", taskVo);

        return "employer/manage_bidders";
    }

    /**
     * 中标：接受投标

    }

    /**
     * 删除竞标信息
     *
     * @param bid
     * @return
     */
    @GetMapping("bid/delete")
    public String deleteBid(Long bid) {
        bidService.deleteById(bid);
        return "redirect:/employee/mybids";
    }

    /**
     * 跳转到个人信息设置页面
     *
     * @return
     */
    @GetMapping("settings/base")
    public String settings(HttpSession session, Model model) {

        // 获取 session 中的雇员信息
        Employee employee = (Employee) session.getAttribute("employee");

        // 获取视图展示对象，主要是为了展示技能信息，因为 Employee 中只有 技能 ID 没有技能名称
        EmployeeVo employeeVo = employeeService.getById(employee.getId());

        model.addAttribute("employee", employeeVo);
        return "employee/settings_base";
    }

    /**
     * 保存个人基本信息
     *
     * @param employee
     * @return
     */
    @PostMapping("settings/base/save")
    public String saveBase(Employee employee, HttpSession session) {
        // 更新个人信息到数据库
        Employee currEmployee = employeeService.save(employee);

        // 更新 session 中的个人信息
        session.setAttribute("employee", currEmployee);
        return "redirect:/employee/settings/base";
    }

    /**
     * 跳转到修改密码页
     *
     * @return
     */

@Controller
@RequestMapping("employer")
public class EmployerController {

    @Resource
    private TaskService taskService;

    @Resource
    private TaskCategoryService taskCategoryService;

    @Resource
    private BidService bidService;

    @Resource
    private EmployerService employerService;

    /**
     * 雇主退出登录
     *
     * @param session
     * @return
     */
    @GetMapping("logout")
    public String logout(HttpSession session) {
        session.removeAttribute("employer");
        return "redirect:/index";
    }

    /**
     * 跳转到个人中心
     */
    @GetMapping("dashboard")
    public String dashboard(HttpSession session, Model model) {

        // 获取雇主登录情况
        Employer employer = (Employer) session.getAttribute("employer");

        // 查询总发布任务数量
        List<TaskVo> tasks = taskService.getByEmployerId(employer.getId());
        Integer taskCount = tasks != null ? tasks.size() : 0;

        // 查询任务总投标人数
        Integer bidCount = taskService.getBidCount(employer.getId());

        // 任务提交完成
        List<TaskVo> taskVos = taskService.getRecentlySubmit(employer.getId());

        // 放置域对象中

     */
    @GetMapping("acceptBid")
    public String acceptBid(Long taskId, Long employeeId) {
        bidService.acceptBid(taskId, employeeId);
        return "redirect:/employer/myTasks";
    }

    /**
     * 确定完成任务
     *
     * @param taskId
     * @return
     */
    @GetMapping("task/success")
    public String successTask(Long taskId) {
        taskService.successTask(taskId);
        return "redirect:/employer/myTasks";
    }

    /**
     * 跳转到个人信息设置页面
     *
     * @return
     */
    @GetMapping("settings/base")
    public String settings(HttpSession session, Model model) {
        // 获取 session 中的雇员信息
        Employer employer = (Employer) session.getAttribute("employer");
        model.addAttribute("employer", employer);
        return "employer/settings_base";
    }

    /**
     * 保存个人基本信息
     *
     * @param employer
     * @return
     */
    @PostMapping("settings/base/save")
    public String saveBase(Employer employer, HttpSession session) {
        // 更新个人信息到数据库

 * @Classname AdminController
 * @see com.yuu.recruit.controller
 */
@Controller
@RequestMapping("admin")
public class AdminController {

    /**
     * Spring 容器自动注入 AdminService
     */
    @Resource
    private AdminService adminService;

    @Resource
    private EmployerService employerService;

    @Resource
    private EmployeeService employeeService;

    @Resource
    private TaskService taskService;

    /**
     * 跳转到登录页面
     *
     * @return
     */
    @GetMapping("login")
    public String login() {
        return "admin/login";
    }

    /**
     * 管理员登录
     *
     * @param admin 管理员，在参数上使用实体类接收，可以自动接受 username,password 属性
     * @return
     */
    @PostMapping("login")
    public String login(Admin admin, RedirectAttributes redirectAttributes, HttpSession session) {
        // 调用 AdminService 处理登录的业务逻辑，返回一个 Admin 对象，如果为空登录失败，如果不为空登录成功
        Admin currAdmin = adminService.login(admin);

        // 如果为空，登录失败，返回一个消息给登录页面提示, RedirectAttributes 是重定向用于把消息存放在域对象中，供页面获取
        if (currAdmin == null) {
            // 将消息放入重定向的与对象中
            redirectAttributes.addFlashAttribute("msg", "用户名或密码错误");
            // 重定向到登录页
            return "redirect:/admin/login";
        }

/**
 * 雇员控制器
 *
 * @Classname EmployeeController
 * @see com.yuu.recruit.controller
 */
@Controller
@RequestMapping("employee")
public class EmployeeController {

    @Resource
    private EmployeeService employeeService;

    @Resource
    private TaskService taskService;

    @Resource
    private HomeBowerService homeBowerService;

    @Resource
    private EmployeeBookmarkedService employeeBookmarkedService;

    @Resource
    private BidService bidService;

        return "admin/employee";
    }
}

/**
 * 管理员雇主管理控制器
 *
 * @Classname AdminEmployerController
 * @see com.yuu.recruit.controller
 */
@Controller
@RequestMapping("admin/employer")
public class AdminEmployerController {

    @Resource
    private EmployerService employerService;

    /**
     * 跳转到雇主列表页
     *
     * @return
     */
    @GetMapping("")
    public String taskCategory(Model model) {
        // 查询所有雇主
        List<Employer> employers = employerService.getAll();

        // 设置到域对象中，提供给页面展示
        model.addAttribute("employers", employers);
        return "admin/employer";
    }
}

    @ResponseBody
    public Map<String, Object> uploadFile(MultipartFile upload, HttpServletRequest request, HttpServletResponse response) {

        Map<String, Object> result = new HashMap<>();
        String fileName = upload.getOriginalFilename();
        String suffix = fileName.substring(fileName.lastIndexOf(".") + 1);
        String newName = UUID.randomUUID() + "." + suffix;
        OSS client = new OSSClientBuilder().build(ENDPOINT, ACCESS_KEY_ID, ACCESS_KEY_SECRET);
        try {
            client.putObject(new PutObjectRequest(BUCKET_NAME, newName, new ByteArrayInputStream(upload.getBytes())));
            // 上传文件路径 = http://BUCKET_NAME.ENDPOINT/自定义路径/fileName
            String filePath = "http://" + BUCKET_NAME + "." + ENDPOINT + "/" + newName;
            result.put("filePath", filePath);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            client.shutdown();
        }
        return result;
    }

}

/**
 * 任务控制器
 *
 * @Classname TaskController
 * @see com.yuu.recruit.controller
 */
@Controller

        model.addAttribute("categoryId", categoryId);
        model.addAttribute("key", key);
        model.addAttribute("bookMarkedIds", bookMarkedIds);

        return "task_list";
    }

    /**
     * 跳转到任务详情页
     *
     * @param taskId 任务 ID
     * @return
     */
    @GetMapping("page")
    public String page(@RequestParam(required = true) Long taskId, Model model) {
        // 根据任务 ID 查询出任务详情
        TaskVo taskVo = taskService.getById(taskId);
        // 放入域对象中，提供给页面查询
        model.addAttribute("task", taskVo);
        return "task_page";
    }

}

/**
 * 管理员管理任务分类控制器
 *
 * @Classname AdminTaskCategoryController
 * @see com.yuu.recruit.controller
 */
@Controller
@RequestMapping("admin/task/category")
public class AdminTaskCategoryController {

    @Resource
    private TaskCategoryService taskCategoryService;

    private EmployeeBookmarkedService employeeBookmarkedService;

    /**
     * 跳转到分类列表页
     *
     * @param categoryId 分类列表页
     * @param key 查询条件
     * @param page
     * @return
     */
    @GetMapping("list")
    public String list(@RequestParam(defaultValue = "0") Long categoryId,
                       @RequestParam(defaultValue = "") String key,
                       @RequestParam(defaultValue = "1") int page,
                       HttpSession session,
                       Model model) {
        // 如果雇员登录了，查询出雇员收藏信息
        Employee employee = (Employee) session.getAttribute("employee");
        List<Long> bookMarkedIds = new ArrayList<>();
        if (employee != null) {
            // 查询雇员收藏信息
            Long employeeId = employee.getId();
            // 查询雇员收藏任务ID集合
            bookMarkedIds = employeeBookmarkedService.getIdsByEmployeeId(employeeId);
        }

        // 查询出所有分类信息，因为选择分类的时候，需要分类信息
        List<TaskCategoryVo> taskCategories = taskCategoryService.getAll();

        // 调用 TaskService 进行分页查询，得到分页结果
        PageResult<TaskVo> tasksPage = taskService.page(categoryId, key, page);

        // 将查询结果放置到域对象中，供页面查询
        model.addAttribute("taskCategories", taskCategories);
        model.addAttribute("tasksPage", tasksPage);
        // 将查询条件页放置到域对象中，方便页面读取
        model.addAttribute("categoryId", categoryId);
        model.addAttribute("key", key);
        model.addAttribute("bookMarkedIds", bookMarkedIds);

        return "task_list";
    }

    /**
     * 跳转到任务详情页
     *
     * @param taskId 任务 ID