基于javaweb+mysql的springboot调查问卷管理系统(java+springboot+vue+elementui+maven+mysql)

基于javaweb+mysql的springboot调查问卷管理系统(java+springboot+vue+elementui+maven+mysql)

私信源码获取及调试交流

运行环境

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

开发工具

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

前端：WebStorm/VSCode/HBuilderX等均可

适用

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

功能说明

基于javaweb的SpringBoot调查问卷管理系统(java+springboot+vue+elementui+maven+mysql)

项目介绍

• 本项目的在线问卷调查调查系统是基于SpringBoot开发的，采用了前后端分离模式来开发。

• 前端开发使用了Vue、Element UI，后端的开发则是使用了SpringBoot、MyBatis技术。

项目配置

• 下载项目压缩包，在IDEA或者Eclipse软件中打开，并修改application.yml文件中数据库的用户和密码 > * 在本地的MySQL数据库中导入项目的sql文件 > * 在编译器中运行该项目:此为SpringBoot框架，启动主类Main方法

• 在浏览器中输入localhost:8181后按回车键进入系统

                else {
                    flag=false;
                    break;
                }
                //保险一点，删除对应选项的回答数据
                responseService.delResponseByOid(oid);
            }
        }
        //修改或添加问题和选项信息
        JSONArray ques = queList.getJSONArray("question");//获取问题列表
        //遍历问题数组
        for (int i = 0; i < ques.size(); i++) {
            JSONObject que = ques.getJSONObject(i);
            int qtype = que.getInteger("qtype");//获取该问题的题目类型
            String qtitle = que.getString("qtitle");//获取该问题内容
            //判断该问题是否为新添加
            if (que.getInteger("qid")==null){
                //添加问题操作
                if (qtype==1||qtype==2){
                    //问题为选择题,先添加问题信息，并获取问题编号
                    Question quesChos = new Question();
                    quesChos.setQtype(qtype);
                    quesChos.setQtitle(qtitle);
                    quesChos.setSid(sid);
                    int qid = questionService.addQueChos(quesChos);//添加选择题
                    if (qid>0){
                        //问题添加成功，获取对应的选项列表
                        JSONArray ops = que.getJSONArray("options");
                        for (int j = 0; j < ops.size(); j++) {
                            JSONObject op = ops.getJSONObject(j);
                            String option = op.getString("option");//获取选项值
                            //添加问题选项
                            int res = optionService.addOption(option,qid);
                            if (res>0)
                                flag = true;//选项添加成功
                            else{
                                flag=false;
                                break;
                            }
                        }
                    }
                    if (!flag) break;
                }else if (qtype==3){

                }else {
                    // 该手机号已被绑定，修改失败
                    json.put("msg","fail");
                }
            }
        }else{
            //出现错误，修改失败
            json.put("msg","error");
        }
        return json;
    }

    @CrossOrigin
    @PostMapping(value = "api/setSex")
    @ResponseBody // 修改性别
    public JSONObject setSex(@RequestBody User user){
        JSONObject json = new JSONObject();
        int id = user.getId(); //获取用户的id
        int sex = user.getSex();
        if (sex>-1 && sex<2){//检测sex的值是否有效
            int before = userService.getBeforeSex(id);//获取原本的sex值
            if (before == sex ){
                json.put("msg","same");//sex没有改变，修改失败
            }else{
                //sex变化了，可以修改
                int res = userService.setSex(id,sex);
                if (res > 0){
                    json.put("msg","success");//修改成功
                    json.put("sex",String.valueOf(sex));
                }else
                    json.put("msg","error");//出现错误，修改失败
            }
        }else{
            json.put("msg","fail");//sex值为无效，修改失败
        }
        return json;
    }

    @CrossOrigin
    @PostMapping(value = "api/setBirthdate")
    @ResponseBody // 修改出生日期
    public JSONObject setBirthdate(@RequestBody User user){
        JSONObject json = new JSONObject();
        int id = user.getId(); //获取用户的id
        String date = user.getBirthdate();
        if (!"".equals(date) && date != null){//检测birthdate的值是否有效
            String before = userService.getBeforeDate(id);//获取原本的sex值
            if (date.equals(before)){
                json.put("msg","same");//sex没有改变，修改失败

    //删除问卷
    @CrossOrigin
    @PostMapping(value = "api/delSurvey")
    @ResponseBody
    public JSONObject delSurvey(@RequestBody JSONObject data){
        JSONObject json = new JSONObject();
        //设置flag记录操作过程
        boolean flag = false;
        //获取问卷编号
        int sid = data.getInteger("sid");
        //先获取该问卷的问题列表
        List<Question> questionList = questionService.getQuestionListBySid(sid);
        //遍历问题列表
        if (questionList.size()>0){
            for (Question que:questionList) {
                //获取问题编号、题目类型
                int qid = que.getQid();
                int qtype = que.getQtype();
                //选择题
                if (qtype!=3){
                    //先删除对应题目的所有选项信息
                    int countOps = optionService.delOptionsByQid(qid);
                    if (countOps>0){
                        flag = true;
                    }else {
                        break;
                    }
                }
                //再删除该条问题信息
                questionService.delQuestionByQid(qid);
                //保险一点，删掉该条问题的回答数据
                responseService.delResponseByQid(qid);
            }
        }else {
            flag = true;
        }

        //最后删除该条问题并删除该问题的统计数据
        int countSurvey = surveyService.delSurveyBySid(sid);
        if (countSurvey>0 && flag){
            json.put("msg","success");
        }else{
            json.put("msg","fail");

    @CrossOrigin
    @PostMapping(value = "api/getName")
    @ResponseBody // 获取当前用户的用户名
    public JSONObject getName(@RequestBody User user){
        JSONObject json = new JSONObject();
        int id = user.getId();
        String username = userService.getNameById(id);
        if (username != null && !"".equals(username))
            json.put("username",username);
        else
            json.put("username","error");
        return json;
    }

    @CrossOrigin
    @PostMapping(value = "api/userInfo")
    @ResponseBody //获取当前用户信息
    public JSONObject getUserInfo(@RequestBody User curUser){
        JSONObject json = new JSONObject();
        int id = curUser.getId();
        //根据id获取当前用户信息
        User user = userService.findUserById(id);
        //将结果json化
        JSONObject userInfo = (JSONObject) JSON.toJSON(user);
        json.put("user",userInfo);
        return json;
    }

    @CrossOrigin
    @PostMapping(value = "api/resetPass")
    @ResponseBody // 重置账号密码
    public JSONObject resetPassword(@RequestBody User user){
        JSONObject json = new JSONObject();
        //获取账号的用户名
        String username = user.getUsername();
        //获取账号的手机号
        String telephone = user.getTelephone();
        //获取账号的新密码
        String newPass = user.getPassword();
        //调用业务逻辑层接口，检查系统中是否存在与用户名对应的账号
        User res = userService.findUserByName(username);
        //1.存在该账号

    @CrossOrigin
    @PostMapping(value = "api/setStitle")
    @ResponseBody
    public JSONObject editStitle(@RequestBody JSONObject data){
        JSONObject json = new JSONObject();
        //获取问卷编号
        int sid = data.getInteger("sid");
        //获取要修改的问卷标题
        String stitle = data.getString("stitle");
        if (stitle!=null && !"".equals(stitle) && sid>0){
            //根据问卷编号修改问卷标题
            int count = surveyService.setStitle(sid, stitle);
            if (count>0){
                //修改成功，返回信息
                json.put("msg","success");
                json.put("stitle",stitle);
            }else {
                //修改失败，返回信息
                json.put("msg","fail");
            }
        }else {
            //数据有误，返回错误信息
            json.put("msg","err");
        }
        return json;
    }

    //切换问卷状态
    @CrossOrigin
    @PostMapping(value = "api/setPublish")
    @ResponseBody
    public JSONObject editPublish(@RequestBody JSONObject data){
        JSONObject json = new JSONObject();
        //获取当前操作的问卷编号
        int sid = data.getInteger("sid");
        //获取当前问卷的状态
        int publish = data.getInteger("publish");
        //判断当前问卷状态
        if (publish==1){
            // 若当前问卷状态为已发布，则切换成未发布

    @ResponseBody
    public JSONObject editSurvey(@RequestBody JSONObject data){
        JSONObject json = new JSONObject();
        //设置flag记录操作过程
        boolean flag = false;
        //获取该问卷的编号
        int sid = data.getInteger("sid");
        JSONObject queList = data.getJSONObject("quesList");
        //先做删除操作，再做修改操作
        JSONArray delQues = queList.getJSONArray("delQues");//获取要删除的问题编号数组
        JSONArray delOps = queList.getJSONArray("delOps");//获取要删除的选项编号数组
        //删除问题操作
        if (delQues.size()>0){
            //遍历数组
            for (int i = 0; i < delQues.size(); i++) {
                JSONObject que = delQues.getJSONObject(i);
                //获取问题编号、题目类型
                int qid = que.getInteger("qid");
                int qtype = que.getInteger("qtype");
                //若题目为选择题
                if (qtype==1||qtype==2){
                    //先删除对应题目的所有选项信息
                    int countOps = optionService.delOptionsByQid(qid);
                    if (countOps>0){
                        flag = true;
                    }else {
                        flag = false;
                        break;
                    }
                }else if(qtype==3){
                    //再删除该条问题信息
                    int countQue = questionService.delQuestionByQid(qid);
                    System.out.println("删除问题:"+qtype);
                    //保险一点，删掉该条问题的回答数据
                    responseService.delResponseByQid(qid);
                    if (countQue>0){
                        flag = true;
                    }else {
                        flag = false;
                        break;
                    }
                }
                questionService.delQuestionByQid(qid);

        //获取关键字
        String keyword = data.getString("keyword");
        if (keyword!=null && !"".equals(keyword) && uid>0){
            //根据关键字搜索问卷
            List<Survey> surveyList = surveyService.getMySurveysByKey(uid,'%'+keyword+'%');
            JSONArray surveys = JSONArray.parseArray(JSON.toJSONString(surveyList));
            //返回搜索结果
            json.put("surveyData",surveys);
        }
        return json;
    }

    //加载个人问卷信息
    @CrossOrigin
    @PostMapping(value = "api/mySurveys")
    @ResponseBody
    public JSONObject getSurveyByUid(@RequestBody User curUser){
        JSONObject json = new JSONObject();
        //获取输入的用户名
        int uid = curUser.getId();
        List<Survey> res = surveyService.getSurveysByUid(uid);
        JSONArray surveyList = JSONArray.parseArray(JSON.toJSONString(res));
        json.put("mysurveylist",surveyList);
        return json;
    }

    //获取问卷内容
    @CrossOrigin
    @PostMapping(value = "api/surveyPage")
    @ResponseBody
    public JSONObject getSurveyPage(@RequestBody Survey survey){
        JSONObject json = new JSONObject();
        //获取问卷编号
        int sid = survey.getSid();
        if (sid>0){
            //获取问卷标题
            String stitle = surveyService.getStitleBySid(sid);
            //获取问卷状态
            int publish = surveyService.getPublishBySid(sid);
            //标题信息json化
            json.put("stitle",stitle);
            json.put("publish",publish);

        //根据id获取当前用户信息
        User user = userService.findUserById(id);
        //将结果json化
        JSONObject userInfo = (JSONObject) JSON.toJSON(user);
        json.put("user",userInfo);
        return json;
    }

    @CrossOrigin
    @PostMapping(value = "api/resetPass")
    @ResponseBody // 重置账号密码
    public JSONObject resetPassword(@RequestBody User user){
        JSONObject json = new JSONObject();
        //获取账号的用户名
        String username = user.getUsername();
        //获取账号的手机号
        String telephone = user.getTelephone();
        //获取账号的新密码
        String newPass = user.getPassword();
        //调用业务逻辑层接口，检查系统中是否存在与用户名对应的账号
        User res = userService.findUserByName(username);
        //1.存在该账号
        if (res!=null){
            if (res.getTelephone().equals(telephone)){
                //1.1 手机号与该账号的手机号对应，可以重置密码
                int count = userService.resetPass(res.getId(),newPass);
                if (count > 0){
                    //1.1.1 密码重置成功，返回操作结果
                    json.put("msg","success");
                }else{
                    //1.1.2 出现错误，重置失败，返回操作结果
                    json.put("msg","fail");
                }
            }else{
                //1.2 手机号不匹配，返回错误信息
                json.put("msg","phone-err");
            }
        }else{
            //2.用户名输入错误，不存在该账号,返回错误信息
            json.put("msg","name-err");

                    json.put("msg","fail");
                }
            }
        }else{
            //出现错误，修改失败
            json.put("msg","error");
        }
        return json;
    }

    @CrossOrigin
    @PostMapping(value = "api/setSex")
    @ResponseBody // 修改性别
    public JSONObject setSex(@RequestBody User user){
        JSONObject json = new JSONObject();
        int id = user.getId(); //获取用户的id
        int sex = user.getSex();
        if (sex>-1 && sex<2){//检测sex的值是否有效
            int before = userService.getBeforeSex(id);//获取原本的sex值
            if (before == sex ){
                json.put("msg","same");//sex没有改变，修改失败
            }else{
                //sex变化了，可以修改
                int res = userService.setSex(id,sex);
                if (res > 0){
                    json.put("msg","success");//修改成功
                    json.put("sex",String.valueOf(sex));
                }else
                    json.put("msg","error");//出现错误，修改失败
            }
        }else{
            json.put("msg","fail");//sex值为无效，修改失败
        }
        return json;
    }

    @CrossOrigin
    @PostMapping(value = "api/setBirthdate")
    @ResponseBody // 修改出生日期
    public JSONObject setBirthdate(@RequestBody User user){
        JSONObject json = new JSONObject();
        int id = user.getId(); //获取用户的id
        String date = user.getBirthdate();
        if (!"".equals(date) && date != null){//检测birthdate的值是否有效
            String before = userService.getBeforeDate(id);//获取原本的sex值
            if (date.equals(before)){
                json.put("msg","same");//sex没有改变，修改失败
            }else{
                //可以修改
                int res = userService.setDate(id,date);
                if (res > 0){

            int qtype = res.getInteger("qtype");
            //判断回答的题目类型
            if (qtype==1){
                //单选题,回答内容为选项编号
                Response queData = new Response();//回答数据
                //获取回答的选项编号
                int oid = res.getInteger("answer");
                queData.setSid(sid);//设置回答的问卷编号
                queData.setQid(qid);//设置回答的问题编号
                queData.setOid(oid);//设置回答的选项编号
                //根据回答的选项编号，获取回答内容
                String answer = optionService.getOptionByOid(oid);
                queData.setResponse(answer);//设置回答的内容
                //提交该条回答数据
                int count = responseService.submitData(queData);
                if (count > 0)
                    flag=true;//提交成功
                else {
                    flag=false;//提交失败
                    break;//跳出遍历
                }
            }else if (qtype==2){
                //多选题,回答内容是选项编号的数组,
                JSONArray answers = res.getJSONArray("answer");
                //遍历回答内容
                for (int j = 0; j < answers.size(); j++) {
                    int oid = answers.getInteger(j);
                    System.out.println(oid);
                    Response queData = new Response();//回答数据
                    queData.setSid(sid);//设置回答的问卷编号
                    queData.setQid(qid);//设置回答的问题编号
                    queData.setOid(oid);//设置回答的选项编号
                    //根据回答的选项编号，获取回答内容
                    String answer = optionService.getOptionByOid(oid);
                    queData.setResponse(answer);//设置回答的内容
                    //提交该条回答数据
                    int count = responseService.submitData(queData);
                    if (count > 0)
                        flag=true;//提交成功
                    else {
                        flag=false;//提交失败
                        break;//跳出遍历
                    }
                }

            json.put("msg","success");
        else
            json.put("msg","fail");

        return json;
    }

    //获取问卷的回答数据
    @CrossOrigin
    @PostMapping(value = "api/getResponse")
    @ResponseBody
    public JSONObject getResponseListBySid(@RequestBody JSONObject data){
        JSONObject json = new JSONObject();
        //获取问卷编号
        int sid = data.getInteger("sid");
        String stitle = surveyService.getStitleBySid(sid);
        json.put("stitle",stitle);
        int num = countService.getNum(sid);
        json.put("num",num);
            //获取该问卷的问题编号和题目类型列表
            List<JSONObject> ques = questionService.getQuesInfo(sid);
            JSONArray responses = new JSONArray();//记录该问卷所有回答
            //遍历列表
            for (JSONObject que:ques) {
                JSONObject queData = new JSONObject();
                String qtitle = que.getString("qtitle");//获取问题内容
                int qid = que.getInteger("qid");//获取问题编号
                int qtype = que.getInteger("qtype");//获取问题类型
                //选择题
                if (qtype==1||qtype==2){
                    //获取选项信息列表
                    List<JSONObject> ops = optionService.getOpsInfo(qid);
                    JSONArray legend = new JSONArray();
                    JSONArray series = new JSONArray();
                    for (JSONObject op:ops) {
                        //配置legend
                        int oid = op.getInteger("oid");
                        String option = op.getString("option");
                        legend.add(option);
                        //获取回答数据
                        int value = responseService.getCountByOid(oid);
                        //单选题
                        if (qtype==1){
                            JSONObject seriesData = new JSONObject();
                            seriesData.put("value",value);
                            seriesData.put("name",option);
                            series.add(seriesData);

        String newPass = user.getString("newPass");
        //调用业务逻辑层接口，检查当前用户输入的旧密码是否正确
        User res = userService.findUserById(id);
        if (res!=null){
            if (res.getPassword().equals(oldPass)){
                //旧密码正确，可以修改账号密码
                int count = userService.resetPass(res.getId(),newPass);
                if (count > 0){
                    //密码修改成功，返回操作结果
                    json.put("msg","success");
                }else{
                    //出现错误，修改失败，返回错误信息
                    json.put("msg","fail");
                }
            }else{
                //旧密码错误，返回错误信息
                json.put("msg","oldPass-err");
            }
        }else{
            //当前用户不存在，返回错误信息
            json.put("msg","user-err");
        }
        return json;
    }

    @CrossOrigin
    @PostMapping(value = "api/setName")
    @ResponseBody // 修改用户名（保持username的唯一性）
    public JSONObject setUsername(@RequestBody User user){
        JSONObject json = new JSONObject();
        int id = user.getId();//获取用户的id
        String username = user.getUsername();
        if (!"".equals(username) && username != null){
            String before = userService.getNameById(id);//获取原本的username值
            if (before.equals(username)){
                json.put("msg","same");// 用户名没有变化
            }else{
                User temp = userService.findUserByName(username);//检测用户名是否被占用
                if (temp==null){
                    //查找为空，用户名可以修改
                    int res = userService.setUsername(id,username);//修改当前账号的用户名
                    if (res > 0){
                        json.put("msg","success");//修改成功
                        json.put("username",username);
                    }else{
                        json.put("msg","error");//出现错误，修改失败
                    }
                }else{
                    //用户名已存在，修改失败
                    json.put("msg","fail");
                }

        }

        //删除选项操作
        if (delOps.size()>0){
            //遍历数组
            for (int i = 0; i < delOps.size(); i++) {
                int oid = delOps.getInteger(i);//获取选项编号
                //删除对应的选项信息
                int count = optionService.delOptionByOid(oid);
                if (count>0) flag=true;
                else {
                    flag=false;
                    break;
                }
                //保险一点，删除对应选项的回答数据
                responseService.delResponseByOid(oid);
            }
        }
        //修改或添加问题和选项信息
        JSONArray ques = queList.getJSONArray("question");//获取问题列表
        //遍历问题数组
        for (int i = 0; i < ques.size(); i++) {
            JSONObject que = ques.getJSONObject(i);
            int qtype = que.getInteger("qtype");//获取该问题的题目类型
            String qtitle = que.getString("qtitle");//获取该问题内容
            //判断该问题是否为新添加
            if (que.getInteger("qid")==null){
                //添加问题操作
                if (qtype==1||qtype==2){
                    //问题为选择题,先添加问题信息，并获取问题编号
                    Question quesChos = new Question();
                    quesChos.setQtype(qtype);
                    quesChos.setQtitle(qtitle);
                    quesChos.setSid(sid);
                    int qid = questionService.addQueChos(quesChos);//添加选择题
                    if (qid>0){
                        //问题添加成功，获取对应的选项列表
                        JSONArray ops = que.getJSONArray("options");
                        for (int j = 0; j < ops.size(); j++) {
                            JSONObject op = ops.getJSONObject(j);
                            String option = op.getString("option");//获取选项值
                            //添加问题选项
                            int res = optionService.addOption(option,qid);
                            if (res>0)
                                flag = true;//选项添加成功
                            else{
                                flag=false;
                                break;
                            }
                        }

@Controller
public class UserCtrl {
    @Resource
    private UserService userService;

    @PostMapping(value = "/allUser")
    @ResponseBody //获取所有用户
    public JSONObject selectAllUsers(){
        JSONObject json = new JSONObject();
        //获取所有用户信息
        List<User> users = userService.selectAllUsers();
        //把结果json化
        JSONObject userList = (JSONObject) JSON.toJSON(users);
        json.put("userlist",userList);
        return json;
    }

    @CrossOrigin
    @PostMapping(value = "api/login")
    @ResponseBody //用户登录
    public JSONObject login(@RequestBody User loginUser){
        JSONObject res = new JSONObject();
        //获取输入的用户名
        String username = loginUser.getUsername();
        username = HtmlUtils.htmlEscape(username);
        //获取输入的密码
        String password = loginUser.getPassword();
        password = HtmlUtils.htmlEscape(password);

                                flag=true;
                            }else {
                                flag=false;
                                break;
                            }
                        }
                    }
                }
                if (flag){
                    //更新问题信息
                    int countQue = questionService.updateQuestion(qtitle,qid);
                    if (countQue>0){
                        flag=true;
                    }else {
                        flag=false;
                        break;
                    }
                }
            }
        }
        //更新该问卷的最后修改时间
        surveyService.updateLastTime(sid);

        if (flag)
            json.put("msg","success");
        else
            json.put("msg","fail");

        return json;
    }
}

@Controller
public class ResponseCtrl {
    @Resource
    private ResponseService responseService;
    @Resource
    private OptionService optionService;

            }else{
                //操作失败，返回信息
                json.put("msg","fail");
            }
        }else {
            //问卷编号有误，返回错误信息
            json.put("msg","err");
        }
        return json;
    }

    //修改问卷标题
    @CrossOrigin
    @PostMapping(value = "api/setStitle")
    @ResponseBody
    public JSONObject editStitle(@RequestBody JSONObject data){
        JSONObject json = new JSONObject();
        //获取问卷编号
        int sid = data.getInteger("sid");
        //获取要修改的问卷标题
        String stitle = data.getString("stitle");
        if (stitle!=null && !"".equals(stitle) && sid>0){
            //根据问卷编号修改问卷标题
            int count = surveyService.setStitle(sid, stitle);
            if (count>0){
                //修改成功，返回信息
                json.put("msg","success");
                json.put("stitle",stitle);
            }else {
                //修改失败，返回信息
                json.put("msg","fail");
            }
        }else {
            //数据有误，返回错误信息
            json.put("msg","err");
        }
        return json;
    }

    //切换问卷状态
    @CrossOrigin
    @PostMapping(value = "api/setPublish")
    @ResponseBody
    public JSONObject editPublish(@RequestBody JSONObject data){
        JSONObject json = new JSONObject();
        //获取当前操作的问卷编号
        int sid = data.getInteger("sid");

            int count = surveyService.setPublish(1,sid);
            if (count>0)
                json.put("msg","success");//操作成功
            else
                json.put("msg","fail");//操作失败
        }else {
            // 数据信息出现错误，返回错误信息
            json.put("msg","err");
        }
        return json;
    }

    //删除问卷
    @CrossOrigin
    @PostMapping(value = "api/delSurvey")
    @ResponseBody
    public JSONObject delSurvey(@RequestBody JSONObject data){
        JSONObject json = new JSONObject();
        //设置flag记录操作过程
        boolean flag = false;
        //获取问卷编号
        int sid = data.getInteger("sid");
        //先获取该问卷的问题列表
        List<Question> questionList = questionService.getQuestionListBySid(sid);
        //遍历问题列表
        if (questionList.size()>0){
            for (Question que:questionList) {
                //获取问题编号、题目类型
                int qid = que.getQid();
                int qtype = que.getQtype();
                //选择题
                if (qtype!=3){
                    //先删除对应题目的所有选项信息
                    int countOps = optionService.delOptionsByQid(qid);
                    if (countOps>0){
                        flag = true;
                    }else {
                        break;
                    }
                }
                //再删除该条问题信息
                questionService.delQuestionByQid(qid);
                //保险一点，删掉该条问题的回答数据
                responseService.delResponseByQid(qid);
            }
        }else {
            flag = true;
        }

        //最后删除该条问题并删除该问题的统计数据
        int countSurvey = surveyService.delSurveyBySid(sid);
        if (countSurvey>0 && flag){
            json.put("msg","success");

    @ResponseBody // 修改出生日期
    public JSONObject setBirthdate(@RequestBody User user){
        JSONObject json = new JSONObject();
        int id = user.getId(); //获取用户的id
        String date = user.getBirthdate();
        if (!"".equals(date) && date != null){//检测birthdate的值是否有效
            String before = userService.getBeforeDate(id);//获取原本的sex值
            if (date.equals(before)){
                json.put("msg","same");//sex没有改变，修改失败
            }else{
                //可以修改
                int res = userService.setDate(id,date);
                if (res > 0){
                    json.put("msg","success");//修改成功
                    json.put("birthdate",date);
                }else {
                    json.put("msg","error");//出现错误，修改失败
                }
            }
        }else{
            //出现错误，修改失败
            json.put("msg","fail");
        }
        return json;
    }

}

@Controller
public class QuestionCtrl {
    @Resource
    private QuestionService questionService;
    @Resource