计算机毕业设计选题推荐-短文写作竞赛微信小程序/安卓APP-项目实战

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

一、前言

在当今信息化社会，科技和教育的发展日新月异，对人才的培养提出了更高的要求。短文写作能力作为学生的基本素养之一，越来越受到重视。为了提高学生的短文写作水平，各类短文写作竞赛应运而生。然而，如何进行竞赛管理，公平公正地评选作品，成为了一个亟待解决的问题。这正是本课题研究的背景。

当前，短文写作竞赛的管理和评选大多依赖于线下模式，如纸质提交、人工评审等。这种方式存在一些难以避免的问题：一是效率低下，线下操作流程繁琐，费时费力；二是难以保证公平公正，人为因素容易影响评选结果。因此，开发一款基于微信小程序/安卓APP的短文写作竞赛管理系统，具有十分重要的现实意义和必要性。

本课题旨在开发一款基于微信小程序/安卓APP的短文写作竞赛管理系统，主要有以下功能：
竞赛报名：学生可以通过微信小程序/安卓APP在线报名参加竞赛；
提交竞赛成果：学生在规定时间内在线提交自己的短文作品，作品将自动保存并提交至服务器；
评分：评委可以通过微信小程序/安卓APP在线对提交的作品进行评分。

通过本课题的研究，将实现短文写作竞赛的管理和评选过程的公平公正，提高竞赛效果和参与度，同时为其他类似竞赛活动的管理和评选提供参考和借鉴。

二、开发环境

• 开发语言：Java
• 数据库：MySQL
• 后端：SpringBoot
• 前端：微信小程序/android+uniapp+Vue

三、系统界面展示

• 短文写作竞赛微信小程序/安卓APP界面展示：
  
  
  
  
  
  
  

四、部分代码设计

• 短文写作竞赛微信小程序/安卓APP项目实战-代码参考：

@RestController
@RequestMapping("/admin")
public class AdminController {
    @Autowired
    private AdminService adminService;

    @Autowired
    private College_CompService college_compService;

    @Autowired
    private CompService compService;

    @Autowired
    private ProjectService projectService;

    @GetMapping("/getUserAdminById")
    public Admin getUserAdminById(@RequestParam int id){
        Admin admin = adminService.getAdminById(id);
        return admin;
    }

    /**
     * 保存或者更新管理员账户
     * @param admin
     * @return
     */
    @PostMapping("/updateAdmin")
    public UserInfo updateAdmin(Admin admin){
        System.out.println(admin.getId());
        return adminService.updateAdmin(admin);
    }

    /**
     * 创建学院账号
     * @param college
     * @return
     */
    @PostMapping("/createCollege")
    public UserInfo createCollege(College college){
        return adminService.createCollege(college);
    }

    /**
     * 得到未处理的比赛申请集合
     * @return
     */
    @PostMapping("/getUndoApplyCompList")
    public List<College_Comp> getUndoApplyCompList(){
        return college_compService.getUndoApplyComp();
    }

    /**
     * 得到已处理的比赛申请集合
     * @return
     */
    @PostMapping("/getDoneApplyCompList")
    public List<College_Comp> getDoneApplyCompList(){
        return college_compService.getDoneApplyComp();
    }

    /**
     * 同意比赛申请
     * @param collegeCompId
     * @return
     */
    @GetMapping("applyComp/{collegeCompId}")
    public CompResult applyComp(@PathVariable Integer collegeCompId){
        return compService.applyComp(collegeCompId);
    }

    /**
     * 拒绝比赛申请
     * @param collegeCompId
     * @return
     */
    @GetMapping("refuseComp/{collegeCompId}")
    public CompResult refuseComp(@PathVariable Integer collegeCompId){
        return compService.refuseComp(collegeCompId);
    }

    /**
     * 得到所有的竞赛项目
     * @return
     */
    @GetMapping("/getAllProjects")
    public List<Project> getAllProjects(){
        List<Project> result=new ArrayList<>();
        List<Project> allProjects = projectService.getAllProjects();
        for (Project allProject : allProjects) {
            if (allProject.getApplyState()==1){
                result.add(allProject);
            }
        }
        return result;
    }

    /**
     * 得到未处理的添加竞赛的申请列表
     * @return
     */
    @GetMapping("/getUndoAddCompList")
    public List<College_Comp> getUndoAddCompList(){
        return college_compService.getUndoAddCompList();
    }

    @GetMapping("/getDoneAddCompList")
    public List<College_Comp> getDoneAddCompList(){
        return college_compService.getDoneAddCompList();
    }

    @GetMapping("/checkComp/{compId}")
    public List<Comp> checkComp(@PathVariable Integer compId){
        List<Comp> compList=new ArrayList<>();
        compList.add(compService.findCompById(compId));
        return compList;
    }

    @GetMapping("/applyAddCommp/{comp_collegeId}")
    public CompResult applyAddCommp(@PathVariable Integer comp_collegeId){
        CompResult compResult=new CompResult();
        College_Comp collegeComp = college_compService.getCollegeComp(comp_collegeId);
        Comp comp = compService.findCompById(collegeComp.getComp().getId());
        comp.setVisiable(true);
        comp.setPublishTime(new Date());
        compService.save(comp);
        collegeComp.setUpdateApplyDate(new Date());
        collegeComp.setApplyOrJoin(5);
        College_Comp save = college_compService.save(collegeComp);
        if(save!=null){
            compResult.setCode(200);
            compResult.setMessage("操作成功！");
        }else {
            compResult.setCode(400);
            compResult.setMessage("操作失败！");
        }
        return compResult;
    }

    @GetMapping("/refuseAddComp/{comp_collegeId}")
    public CompResult refuseAddComp(@PathVariable Integer comp_collegeId){
        CompResult compResult=new CompResult();
        College_Comp collegeComp = college_compService.getCollegeComp(comp_collegeId);
        collegeComp.setApplyOrJoin(6);
        College_Comp save = college_compService.save(collegeComp);
        if(save!=null){
            compResult.setCode(200);
            compResult.setMessage("操作成功！");
        }else {
            compResult.setCode(400);
            compResult.setMessage("操作失败！");
        }
        return compResult;
    }
}

@RestController
@RequestMapping("/student")
public class StudentController {

    @Autowired
    private StudentService studentService;

    @Autowired
    private Student_ProjectService student_projectService;

    @Autowired
    private ProjectService projectService;

    @Autowired
    private UploadFileUtils uploadFileUtils;

    @Autowired
    private WorkFileService workFileService;

    @Autowired
    private WorkService workService;

    private static String OS = System.getProperty("os.name").toLowerCase();

    @Value("${file-upload.image.winUrl}")
    private String winUrl;

    @Value("${file-upload.image.linuxUrl}")
    private String linuxUrl;

    /**
     * 根据老师id得到院内的比赛项目
     */
    @GetMapping("/getProjectByCollegeWithStudent/{studentId}")
    public List<Project> getProjectByCollegeWithStudent(@PathVariable Integer studentId){

        List<Project> projectByCollegeWithStudent = projectService.getProjectByCollegeWithStudent(studentId);
        projectByCollegeWithStudent.sort(Comparator.naturalOrder());
        return projectByCollegeWithStudent;
    }


    /**
     * 学生申请加入项目
     * @param projectId
     * @param studentId
     * @return
     */
    @GetMapping("/applyJoinProject/{projectId}/{studentId}")
    public ProResult applyJoinProject(@PathVariable Integer projectId,@PathVariable Integer studentId){
        return studentService.applyJoinProject(studentId,projectId);
    }

    /**
     * 学生重新申请加入项目
     * @param student_projectd
     * @return
     */
    @GetMapping("/reApplyJoinProject/{student_projectd}")
    public ProResult reApplyJoinProject(@PathVariable Integer student_projectd){
        Integer studentId=student_projectService.getStudentProjectById(student_projectd).getStudent().getId();
        Integer projectId=student_projectService.getStudentProjectById(student_projectd).getProject().getId();
        return studentService.applyJoinProject(studentId,projectId);
    }

    /**
     * 根据学生的id返回学生的未处理的请求
     * @param studentId
     * @return
     */
    @GetMapping("/getUndoApplyProjectList/{studentId}")
    public List<Student_Project> getUndoApplyProjectList(@PathVariable Integer studentId){
        List<Student_Project> undoApplyProjectList = student_projectService.getUndoApplyProjectList(studentId);
        undoApplyProjectList.sort(Comparator.naturalOrder());
        return undoApplyProjectList;
    }

    /**
     * 根据学生的id返回学生的处理过的请求
     * @param studentId
     * @return
     */
    @GetMapping("/getDoneApplyProjectList/{studentId}")
    public List<Student_Project> getDoneApplyProjectList(@PathVariable Integer studentId){
        List<Student_Project> doneApplyProjectList = student_projectService.getDoneApplyProjectList(studentId);
        doneApplyProjectList.sort(Comparator.naturalOrder());
        return doneApplyProjectList;
    }

    /**
     * 得到学生信息
     * @param studentId
     * @return
     */
    @GetMapping("/getStudentInfoById/{studentId}")
    public Student getStudentInfoById(@PathVariable Integer studentId){
        return studentService.getStudentById(studentId);
    }

    /**
     * 更新学生信息
     * @param student
     * @return
     */
    @PostMapping("/updateStudent")
    public UserInfo updateStudent(Student student){
        Integer studentId=student.getId();
        return studentService.updateStudent(student);
    }

    @GetMapping("/exitProject/{studentId}/{projectId}")
    public ProResult exitProject(@PathVariable Integer studentId, @PathVariable Integer projectId){
        return studentService.exitProject(studentId,projectId);
    }

    @PostMapping("/workUpload")
    public ProResult workUpload(@RequestParam(value = "uploadFile") MultipartFile[] uploadFile, Work work,Integer projectId){
        ProResult proResult=new ProResult();
        if(uploadFile==null){
            proResult.setCode(400);
            proResult.setMessage("请添加作品附件！");
            return proResult;
        }
        Project project = projectService.getProjectById(projectId);
        if(project.getWork()!=null){
            work.setId(project.getWork().getId());
        }else {
            work.setApplyDate(new Date());
        }
        String infoPath="/"+project.getCreateByTeacher().getCollege().getNickname()+"/"+project.getComp().getCompName()+"/"+project.getProjectName()+"/";
        List<WorkFile> workFiles = uploadFileUtils.uploadFile(uploadFile, infoPath);
        try {
            work.setIfMark(false);
            work.setProject(project);
            work = workService.save(work);
            for (WorkFile workFile : workFiles) {
                WorkFile workFileById = workFileService.findWorkFileById(workFile.getId());
                workFileById.setWork(work);
                workFileService.save(workFile);
            }
            proResult.setCode(200);
            proResult.setMessage("提交成功！");
        }catch (Exception e){
            proResult.setCode(400);
            proResult.setMessage("提交失败！");
        }
        return proResult;
    }

    @PostMapping("/editWork")
    public ProResult editWork(@RequestParam(value = "workFile") MultipartFile workFile,Integer workFileId) throws FileNotFoundException {
        ProResult proResult=new ProResult();
        String rootBean;
        if(OS.startsWith("win")){
            rootBean=winUrl;
        }else {
            rootBean=linuxUrl;
        }
        WorkFile workFileById = workFileService.findWorkFileById(workFileId);
        Project project = workFileById.getWork().getProject();
        String fileUrl = workFileById.getFileUrl();
        File fileDelete=new File(rootBean+fileUrl);
        fileDelete.delete();
        try {
            String infoPath = "/" + project.getCreateByTeacher().getCollege().getNickname() + "/" + project.getComp().getCompName() + "/" + project.getProjectName() + "/";
            String workPath = uploadFileUtils.uploadWorkFile(workFile, infoPath);
            workFileById.setFileName(workFile.getOriginalFilename());
            workFileById.setFileUrl(workPath);
            workFileService.save(workFileById);
            proResult.setCode(200);
            proResult.setMessage("修改成功！");
            return proResult;
        }catch (Exception e){
            proResult.setCode(400);
            proResult.setMessage("修改失败！");
            return proResult;
        }
    }

    @GetMapping("/deleteWorkFile/{workFileId}")
    public ProResult deleteWorkFile(@PathVariable Integer workFileId){
        ProResult proResult=new ProResult();
        String rootBean;
        if(OS.startsWith("win")){
            rootBean=winUrl;
        }else {
            rootBean=linuxUrl;
        }
        WorkFile workFileById = workFileService.findWorkFileById(workFileId);
        Work work = workFileById.getWork();
        String fileUrl = workFileById.getFileUrl();
        File file=new File(rootBean+fileUrl);
        try {
            file.delete();
            workFileService.delete(workFileId);
            proResult.setCode(200);
            proResult.setMessage("删除成功！");
            return proResult;
        }catch (Exception e){
            proResult.setCode(400);
            proResult.setMessage("删除失败！");
            return proResult;
        }



    }

    /**
     * 没有提交做作品的
     * @param studentId
     * @return
     */
    @GetMapping("/getUnHandOutWorks/{studentId}")
    public List<Project> getUnHandOutWorks(@PathVariable Integer studentId){
        List<Project> projectList=new ArrayList<>();
        List<Project> projectByCollegeWithStudent = projectService.getStudentProjects(studentId);
        for (Project project : projectByCollegeWithStudent) {
            Integer compState = project.getComp().getCompState();
            if(compState<3&&project.getWork()==null){
                projectList.add(project);
            }
        }
        return projectList;
    }

    /**
     * 提交过作品的
     * @param studentId
     * @return
     */
    @GetMapping("/getHandOutWorks/{studentId}")
    public List<Work> getHandOutWorks(@PathVariable Integer studentId){
        List<Work> workList=new ArrayList<>();
        List<Project> projectByCollegeWithStudent = projectService.getStudentProjects(studentId);
        for (Project project : projectByCollegeWithStudent) {
            Integer compState = project.getComp().getCompState();
            if(project.getWork()!=null){
                if(project.getWork().getIfMark()==false)
                    workList.add(project.getWork());
            }
        }
        return workList;
    }

    /**
     * 提交过作品的
     * @param studentId
     * @return
     */
    @GetMapping("/getWorksMark/{studentId}")
    public List<Work> getWorksMark(@PathVariable Integer studentId){
        List<Work> workList=new ArrayList<>();
        List<Project> projectByCollegeWithStudent = projectService.getStudentProjects(studentId);
        for (Project project : projectByCollegeWithStudent) {
            Integer compState = project.getComp().getCompState();
            if(project.getWork()!=null){
                if(project.getWork().getIfMark()==true)
                    workList.add(project.getWork());
            }
        }
        return workList;
    }
}

@RestController
@RequestMapping("/notice")
public class NoticeController {
    @Autowired
    private NoticeService noticeService;

    /**
     * 查询所有的公告信息
     * @return
     */
    @GetMapping("/findAllNotice")
    public List<Notice> findAllNotice(){
        List<Notice> allNotice = noticeService.findAllNotice();
        allNotice.sort(Comparator.naturalOrder());
        return allNotice;
    }

    /**
     * 发布新的公告
     * @param notice
     * @return
     */
    @PostMapping("/addNotice")
    public String addNotice(Notice notice){
        System.out.println(notice.getTime());
        return noticeService.addNotice(notice);
    }

    /**
     * 更新新的公告
     * @param notice
     * @return
     */
    @PostMapping("/updateNotice")
    public String updateNotice(Notice notice){
        return noticeService.addNotice(notice);
    }

    /**
     * 根据id删除公告
     * @param id
     * @return
     */
    @GetMapping("/deleteNoticeById")
    public String deleteNoticeById(int id){
        return noticeService.deleteNoticeById(id);
    }

    /**
     * 查询所有公告，并以类型分类，都以级别从高到底排列。
     * @return
     */
    @GetMapping("/selectAllByTypeOrderBYLevelDesc")
    public Map<String,List<Notice>> selectAllByTypeOrderBYLevelDesc(){
        return noticeService.findNoticeByTypeOrderByLevelDesc();
    }
}

五、论文参考

• 计算机毕业设计选题推荐-短文写作竞赛微信小程序/安卓APP-论文参考：
  

六、系统视频

短文写作竞赛微信小程序/安卓APP-项目视频：

计算机毕业设计选题推荐-短文写作竞赛微信小程序/安卓APP

结语

计算机毕业设计选题推荐-短文写作竞赛微信小程序/安卓APP-项目实战
大家可以帮忙点赞、收藏、关注、评论啦～
源码获取：私信我

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