【java毕业设计源码】基于SSM框架的在线智能题库管理系统设计与实现_java题库系统源码git

作者：小小林熬夜学编程 | 2024-04-27 07:19:05

踩

java题库系统源码git

该项目含有源码、文档、PPT、配套开发软件、软件安装教程、项目发布教程等学习内容。

关键词：计算机毕业设计，源码网站，源码下载，java毕业设计源码，开题报告，毕业设计定制，小程序毕业设计源码，本科毕业设计

一、项目介绍：

背景：
随着互联网的普及和信息化的发展，教育行业也在不断变革和创新。在线教育成为了一种新的教学模式，它能够突破时间和空间的限制，为学生提供更加灵活和便捷的学习方式。而在线题库管理系统作为在线教育的重要组成部分，能够为教师和学生提供高质量的题库资源，帮助他们更好地进行学习和教学。

目的：
本课题旨在设计和实现一个基于SSM框架的在线智能题库管理系统，通过该系统，教师可以方便地创建、编辑和管理题库资源，学生可以根据自己的需求进行题目的筛选和练习，从而提高学习效率和学习成绩。

意义：
1. 提高教学效率：教师可以通过系统快速地创建和编辑题库资源，为学生提供更加丰富和多样化的学习资源，从而提高教学效率。
2. 个性化学习：学生可以根据自己的学习需求进行题目的筛选和练习，实现个性化学习，提高学习效果。
3. 数据分析和评估：系统可以对学生的学习情况进行数据分析和评估，为教师提供学生学习情况的反馈，帮助教师更好地进行教学。
4. 技术推广：通过该系统的设计和实现，可以推广SSM框架在教育领域的应用，为其他教育机构提供参考和借鉴。

二、文档学习资料：

三、模块截图：

四、开发技术与运行环境：

技术栈：

1. 前端技术：

Vue.js：用于构建用户界面的渐进式JavaScript框架。

Element UI：Vue的UI组件库，用于快速构建界面。

Axios：基于Promise的HTTP客户端，用于与后端进行通信。

2. 后端技术：

Spring：用于构建业务逻辑层的Java框架。

Spring MVC：用于构建Web层的Spring框架。

MyBatis：一个支持定制化SQL、存储过程以及高级映射的持久层框架。

3. 数据库技术：

MySQL：常用的关系型数据库管理系统。

4. 构建工具：

Maven：项目管理和构建自动化工具。

运行环境：

1. 开发环境：

IDE：如IDEA或eclipse，用于编码和调试。

本地数据库：如MySQL，用于数据存储和查询。

本地服务器：如Tomcat7.0，用于部署和运行Web应用。

五、代码展示：


/**
 * 考场
 * 后端接口
 * @author
 * @email
*/
@RestController
@Controller
@RequestMapping("/kaochang")
public class KaochangController {
    private static final Logger logger = LoggerFactory.getLogger(KaochangController.class);
 
    private static final String TABLE_NAME = "kaochang";
 
    @Autowired
    private KaochangService kaochangService;
 
 
    @Autowired
    private TokenService tokenService;
    @Autowired
    private DictionaryService dictionaryService;
 
    //级联表非注册的service
    //注册表service
    @Autowired
    private YonghuService yonghuService;
 
 
    /**
    * 后端列表
    */
    @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"));
        CommonUtil.checkMap(params);
        PageUtils page = kaochangService.queryPage(params);
 
        //字典表数据转换
        List<KaochangView> list =(List<KaochangView>)page.getList();
        for(KaochangView 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);
        KaochangEntity kaochang = kaochangService.selectById(id);
        if(kaochang !=null){
            //entity转view
            KaochangView view = new KaochangView();
            BeanUtils.copyProperties( kaochang , view );//把实体数据重构到view中
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(view, request);
            return R.ok().put("data", view);
        }else {
            return R.error(511,"查不到数据");
        }
 
    }
 
    /**
    * 后端保存
    */
    @RequestMapping("/save")
    public R save(@RequestBody KaochangEntity kaochang, HttpServletRequest request){
        logger.debug("save方法:,,Controller:{},,kaochang:{}",this.getClass().getName(),kaochang.toString());
 
        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(false)
            return R.error(511,"永远不会进入");
 
        Wrapper<KaochangEntity> queryWrapper = new EntityWrapper<KaochangEntity>()
            .eq("kaochang_name", kaochang.getKaochangName())
            .eq("kaochang_address", kaochang.getKaochangAddress())
            ;
 
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        KaochangEntity kaochangEntity = kaochangService.selectOne(queryWrapper);
        if(kaochangEntity==null){
            kaochang.setInsertTime(new Date());
            kaochang.setCreateTime(new Date());
            kaochangService.insert(kaochang);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }
 
    /**
    * 后端修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody KaochangEntity kaochang, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
        logger.debug("update方法:,,Controller:{},,kaochang:{}",this.getClass().getName(),kaochang.toString());
        KaochangEntity oldKaochangEntity = kaochangService.selectById(kaochang.getId());//查询原先数据
 
        String role = String.valueOf(request.getSession().getAttribute("role"));
//        if(false)
//            return R.error(511,"永远不会进入");
        //根据字段查询是否有相同数据
        Wrapper<KaochangEntity> queryWrapper = new EntityWrapper<KaochangEntity>()
            .notIn("id",kaochang.getId())
            .andNew()
            .eq("kaochang_name", kaochang.getKaochangName())
            .eq("kaochang_address", kaochang.getKaochangAddress())
            ;
 
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        KaochangEntity kaochangEntity = kaochangService.selectOne(queryWrapper);
        if(kaochangEntity==null){
            kaochangService.updateById(kaochang);//根据id更新
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }
 
 
 
    /**
    * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
        List<KaochangEntity> oldKaochangList =kaochangService.selectBatchIds(Arrays.asList(ids));//要删除的数据
        kaochangService.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<KaochangEntity> kaochangList = 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("../../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){
                            //循环
                            KaochangEntity kaochangEntity = new KaochangEntity();
//                            kaochangEntity.setKaochangUuidNumber(data.get(0));                    //考场编号 要改的
//                            kaochangEntity.setKaochangName(data.get(0));                    //考场名称 要改的
//                            kaochangEntity.setKaochangAddress(data.get(0));                    //考场位置 要改的
//                            kaochangEntity.setKaochangContent("");//详情和图片
//                            kaochangEntity.setInsertTime(date);//时间
//                            kaochangEntity.setCreateTime(date);//时间
                            kaochangList.add(kaochangEntity);
 
 
                            //把要查询是否重复的字段放入map中
                                //考场编号
                                if(seachFields.containsKey("kaochangUuidNumber")){
                                    List<String> kaochangUuidNumber = seachFields.get("kaochangUuidNumber");
                                    kaochangUuidNumber.add(data.get(0));//要改的
                                }else{
                                    List<String> kaochangUuidNumber = new ArrayList<>();
                                    kaochangUuidNumber.add(data.get(0));//要改的
                                    seachFields.put("kaochangUuidNumber",kaochangUuidNumber);
                                }
                        }
 
                        //查询是否重复
                         //考场编号
                        List<KaochangEntity> kaochangEntities_kaochangUuidNumber = kaochangService.selectList(new EntityWrapper<KaochangEntity>().in("kaochang_uuid_number", seachFields.get("kaochangUuidNumber")));
                        if(kaochangEntities_kaochangUuidNumber.size() >0 ){
                            ArrayList<String> repeatFields = new ArrayList<>();
                            for(KaochangEntity s:kaochangEntities_kaochangUuidNumber){
                                repeatFields.add(s.getKaochangUuidNumber());
                            }
                            return R.error(511,"数据库的该表中的 [考场编号] 字段已经存在 存在数据为:"+repeatFields.toString());
                        }
                        kaochangService.insertBatch(kaochangList);
                        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 = kaochangService.queryPage(params);
 
        //字典表数据转换
        List<KaochangView> list =(List<KaochangView>)page.getList();
        for(KaochangView 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);
        KaochangEntity kaochang = kaochangService.selectById(id);
            if(kaochang !=null){
 
 
                //entity转view
                KaochangView view = new KaochangView();
                BeanUtils.copyProperties( kaochang , view );//把实体数据重构到view中
 
                //修改对应字典表字段
                dictionaryService.dictionaryConvert(view, request);
                return R.ok().put("data", view);
            }else {
                return R.error(511,"查不到数据");
            }
    }
 
 
    /**
    * 前端保存
    */
    @RequestMapping("/add")
    public R add(@RequestBody KaochangEntity kaochang, HttpServletRequest request){
        logger.debug("add方法:,,Controller:{},,kaochang:{}",this.getClass().getName(),kaochang.toString());
        Wrapper<KaochangEntity> queryWrapper = new EntityWrapper<KaochangEntity>()
            .eq("kaochang_uuid_number", kaochang.getKaochangUuidNumber())
            .eq("kaochang_name", kaochang.getKaochangName())
            .eq("kaochang_address", kaochang.getKaochangAddress())
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        KaochangEntity kaochangEntity = kaochangService.selectOne(queryWrapper);
        if(kaochangEntity==null){
            kaochang.setInsertTime(new Date());
            kaochang.setCreateTime(new Date());
        kaochangService.insert(kaochang);
 
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }
 
}

六、数据库表截图：

七、配套学习资料

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/495462