Java 实战项目之教材管理系统的实现流程

一、项目简述

功能包括： 管理员可以增删改查教材、教材商、入库教材、用户(用 户包括学生和教师)可以对教材商、教材进行。excel的导入 导出操作。教师以领取入库的教材，可以退还教材。学生只能在对应的教师那里领取教材，并且可以退还教材、 查询自己已经领取的教材。并且对已领教材付款等等。

二、项目运行

环境配置： jdk1.8 + tomcat8.5 + mysql + eclispe (intellij idea,eclispe,myeclispe,sts 都支持)

项目技术： jsp +spring + springmvc + mybatis + html+ css + javascript + jquery + ajax + layui+ maven等等。

查看班级选报信息：

 
@service
public class topicsserviceimpl implements topicsservice {
 
    @autowired
    private myclassmapper classmapper;
 
    @autowired
    private studentmapper studentmapper;
 
    @autowired
    private subjectselectedmapper subjectselectedmapper;
 
    @autowired
    private subjectmapper subjectmapper;
 
    @autowired
    private httpservletrequest request;
 
    /**
     * 查看班级选报信息
     */
    @override
    public list<classinfo> classinfo(long id) {
        myclass classname = classmapper.selectbyid(id);//查到班级名字
        list<student> students = studentmapper.selectbylistall(id);//根据student表里班级id查到用户所在班级的所有人
        list<subjectselected> projectselectedlist = new arraylist<>();
        list<subject> projectlist = new arraylist<>();
        subjectselected projectselected = null;
        subject project = null;
        for (int i = 0; i < students.size(); i++) {
            list<subjectselected> tprojectselecteds = subjectselectedmapper.selectbystudentid(students.get(i).getid());
            if (tprojectselecteds != null && tprojectselecteds.size() > 0)
                projectselected = tprojectselecteds.get(0);
            if (projectselected != null) {
                projectselectedlist.add(projectselected);
            } else {
                projectselected = new subjectselected();
                projectselected.setid(0l);
                projectselected.setidproject(0l);
                projectselected.setidstudent(0l);
                projectselected.setstuselectflag(0l);
                projectselectedlist.add(projectselected);
            }
        }
        for (int i = 0; i < projectselectedlist.size(); i++) {
            if (projectselectedlist.get(i).getid() != 0) {
                projectlist.add(subjectmapper.selectbyid(projectselectedlist.get(i).getidproject()));
            } else {
                project = new subject();
                project.setprojectname("无");
                project.setteachernames("无");
                projectlist.add(project);
            }
        }
        list<classinfo> infolist = new arraylist<>();
        classinfo info = null;
        for (int i = 0; i < projectlist.size(); i++) {
            info = new classinfo();
            info.setid(students.get(i).getid());
            info.setclassname(classname.getclassname());
            info.setname(students.get(i).getname());
            info.setstunum(students.get(i).getstunum());
            info.setprojectname(projectlist.get(i).getprojectname());
            info.setteachernames(projectlist.get(i).getteachernames());
            info.setstuselectflag(projectselectedlist.get(i).getstuselectflag());
            infolist.add(info);
        }
        return infolist;
    }
 
    /**
     * 查看课题信息
     * 通过classid
     */
    @override
    public list<topicsinfo> topics(long id) {
        string specialty = classmapper.selectbyspecialty(id);
        list<subject> projectlist = subjectmapper.selectbyall("%" + specialty + "%");
        list<topicsinfo> topicsinfolist = new arraylist<>();
        topicsinfo info = null;
        for (int i = 0; i < projectlist.size(); i++) {
            info = new topicsinfo();
            info.setproject_id(projectlist.get(i).getid());
            info.setprojecttype(subjectmapper.selectbyprojecttype(projectlist.get(i).getidprojecttype().intvalue()));
            info.setprojectsource(subjectmapper.selectbyprojectsource(projectlist.get(i).getidprojectsource().intvalue()));
            info.setprojectname(projectlist.get(i).getprojectname());
            info.setselectflag(projectlist.get(i).getselectflag());
            info.setmarchspecialty(projectlist.get(i).getmarchspecialty());
            info.setteachernames(projectlist.get(i).getteachernames());
            topicsinfolist.add(info);
        }
        return topicsinfolist;
    }
 
    /**
     * 课题具体信息
     */
    @override
    public list<topicsto> topicsinfo(long project_id) {
        list<subjectselected> listed = subjectselectedmapper.selectbyprojectid(project_id);//中间表
        request.getsession().setattribute("listsize",listed.size());
 
        list<topicsto> tolist = new arraylist<>();
        topicsto to = null;
        student student = null;
        for (int i = 0; i < listed.size(); i++) {
            to = new topicsto();
            student = studentmapper.selectbyid(listed.get(i).getidstudent());
            if(student == null)
                continue;
            to.setstunum(student.getstunum());
            to.setname(student.getname());
            to.setstuselectflag(listed.get(i).getstuselectflag());
            to.setclassname(classmapper.selectbyid(student.getidclass()).getclassname());
            tolist.add(to);
        }
        return tolist;
    }
 
    /**
     * 获取该用户是否选报了课题
     */
 
    public long state(student student) {
        subjectselected project = null;
        list<subjectselected> tprojectselecteds = subjectselectedmapper.selectbystudentid(student.getid());
        if (tprojectselecteds != null && tprojectselecteds.size() > 0)
            project = tprojectselecteds.get(0);
        if (project == null) {
            return 0l;
        } else
            return project.getstuselectflag();
    }
 
 
    /**
     * 添加选题
     */
    @override
    public void insertproject(string project, long studentid) {
        long projectid = subjectmapper.selectbyprojectid(project);
        int flagid = subjectselectedmapper.insertenroll(projectid, studentid);
    }
 
    /**
     * 删除选题
     */
    @override
    public int deleteprojectselectedid(long id) {
        int flag = subjectselectedmapper.deletebystudentid(id);
        return flag;
    }
 
    /**
     * 查询课题名
     *
     */
    public string selectprojectname(long id){
        string project_name = subjectmapper.selectbyid(id).getprojectname();
        return project_name;
    }
 
 
    /**
     * 获取该题是否可选
     */
    @override
    public long flag(long project_id) {
        return subjectmapper.selectbyselectflag(project_id);
    }
}

班级信息查询业务：

@service
public class classserviceimpl implements classservice {
 
    @autowired
    myclassmapper myclassmapper;
    @autowired
    specialtyservice specialtyservice;
    @autowired
    studentservice studentservice;
 
    @override
    public list getclasses(integer offset, string getname, long specialtyid, long id_institute) {
 
        // 设置分页查询条件
        myclassexample myclassexample = new myclassexample();
        //  添加查询条件
        myclassexample = addcondition(myclassexample,offset,id_institute,getname,specialtyid);
 
        if(myclassexample==null)
            return null;
 
        //如果 offset 为 -1 则只查询 id 和 name 列
        if(offset==-1)
        {
            return myclassmapper.selectbyexampleselective(myclassexample,
                    myclass.column.id,
                    myclass.column.classname);
        }else{
            return myclassmapper.selectbyexampleselective(myclassexample);
        }
 
    }
 
    @override
    public long getclassescount(integer offset, string getname, long specialtyid, long id_institute) {
        // 设置分页查询条件
        myclassexample myclassexample = new myclassexample();
        //        添加查询条件
        myclassexample = addcondition(myclassexample,offset,id_institute,getname,specialtyid);
 
        if(myclassexample==null)
            return 0;
 
        return myclassmapper.countbyexample(myclassexample);
 
    }
 
    @override
    public long delclass(myclass myclass, long id_institute) throws myexception {
        checkspecialtyid(myclass,id_institute);
        return myclassmapper.deletebyprimarykey(myclass.getid());
    }
 
    @override
    public long putclass(myclass myclass, long id_institute) throws myexception {
        checkspecialtyid(myclass,id_institute);
        return myclassmapper.updatebyprimarykey(myclass);
    }
 
    @override
    public long postclass(myclass myclass, long id_institute) throws myexception {
        checkspecialtyid(myclass,id_institute);
        long count = getclassescount(1,myclass.getclassname(),null, id_institute);
        if(count!=0)
            throw new myexception("该班级已存在");
        return myclassmapper.insert(myclass);
    }
 
    @override
    public long delclassbyspecialty(long specialtyid) {
        return myclassmapper.deletebyexample(new myclassexample().createcriteria().andidspecialtyequalto(specialtyid).example());
    }
 
    public myclassexample addcondition(myclassexample myclassexample,integer offset , long id_institute , string keyword , long id_specialty){
 
        //代表为超管，则可以查询所有；
        if(id_institute==-1)
        {
            return myclassexample.newandcreatecriteria()
                    .when(stringutil.stringisnotnull(keyword), criteria -> criteria.andclassnameequalto(keyword)) //根据关键字查询
                    .when(id_specialty!=null,criteria -> criteria.andidspecialtyequalto(id_specialty)) //根据指定教研室查询
                    .example()
                    .when(offset!=-1 && offset != 0,criteria -> criteria.page(offset-1, 10));
        }
 
        //查询出来当前学院的所有专业
        list<specialty> specialties = specialtyservice.getspecialtys(-1,null,null,id_institute);
 
        //提取 id列 列表
        list<long> specialtiesids = specialties.stream().map(specialty::getid).collect(collectors.tolist());
 
        if(specialtiesids.size()==0||specialtiesids==null)
            return null;
 
        return myclassexample.newandcreatecriteria()
                .when(stringutil.stringisnotnull(keyword),criteria -> criteria.andclassnameequalto(keyword)) //根据关键字查询
                .when(id_specialty!=null,criteria -> criteria.andidspecialtyequalto(id_specialty)) //根据指定教研室查询
                // 查询的专业只能在当前的学院的教研室下
                .andidspecialtyin(specialtiesids)
                .example()
                .when(offset!=-1 && offset != 0,criteria -> criteria.page(offset-1, 10));// 查询第offest-1页数据（每页10条）
 
    }
 
    public void checkspecialtyid(myclass myclass ,long id_institute) throws myexception {
        //如果为超管则不需要检查有没有权力
        if(id_institute==-1)
        {
            return ;
        }
 
        long id_specialty = myclass.getidspecialty();
        list<specialty> specialtyes = specialtyservice.getspecialtys(1,null,null,id_institute);
        //如果被删除的专业是不属于本系教研室则提示没有权限
        for(specialty specialty :specialtyes)
        {
            if(specialty.getid()==id_specialty)
                return;
        }
        throw new myexception("没有权限操作");
    }
 
}

管理员业务操作：

@service
public class adminserviceimpl implements adminservice {
 
    @autowired
    adminmapper adminmapper;
 
    @autowired
    sadminmapper sadminmapper;
 
    @autowired
    generalpurposemapper mapper;
 
    @autowired
    publicservice publicservice;
 
    //session 保存时间（秒）
    private final integer save_time = 60*60*24;
 
    //超管 和 子管用一个登录
    @autowired
    studentmapper studentmapper;
 
    @autowired
    subjectselectedmapper subjectselectedmapper;
 
    @autowired
    subjectmapper subjectmapper;
    @autowired
    projectmapper projectmapper;
 
    @autowired
    classmapper classmapper;
 
 
    @autowired
    specialtymapper specialtymapper;
 
    @autowired
    institutemapper institutemapper;
 
    @autowired
    httpservletrequest request;
 
    @autowired
    httpservletresponse response;
 
    @override
    public msg login(string name, string pwd , httpsession httpsession) {
 
        sadmin sadmin = selectsadminbyname(name);
        if(sadmin!=null){
            //验证密码是否与数据库中的相同
            if(sadmin.getpwd().equals(pwd)){
                user user = new user();
                //-1表示为超管
                user.setid(-1l);
                user.setrole("sadmin");
                user.setusername(sadmin.getname());
                //生成token 存到 cookie
                cookie cookie = new cookie("token",tokenutil.createtoken(
                        user
                ));
                //该cookie无法被js读取
                cookie.sethttponly(true);
                cookie.setpath("/");
                response.addcookie(cookie);
                return msg.success();
            }
            return msg.error("密码错误");
        }else {
            admin admin = selectbyname(name);
            if(admin == null){
                return msg.error("账号不存在");
            }else {
                if(admin != null && admin.getpwd().equals(pwd)){
                    user user = new user();
                    user.setid(admin.getid());
                    user.setrole("admin");
                    user.setusername(admin.getname());
                    cookie cookie = new cookie("token",tokenutil.createtoken(
                            user
                    ));
                    cookie.setpath("/");
                    cookie.sethttponly(true);
                    response.addcookie(cookie);
                    return msg.success();//账号密码正确
                }
                return msg.error("密码错误");
            }
 
        }
 
 
    }
 
 
 
    @override
    public admin selectbyname(string name) {
        //创建一个 admin 实例 ，添加条件 为 name == name
        adminexample adminexample = new adminexample();
        adminexample.createcriteria().andnameequalto(name);
        //根据实例 来查询
        list<admin> admin = adminmapper.selectbyexample(adminexample);
        if( admin==null || admin.size()==0 ) {
            return null;
        }
        return admin.get(0);
    }
 
    @override
    public sadmin selectsadminbyname(string name) {
        sadminexample sadminexample = new sadminexample();
        sadminexample.createcriteria().andnameequalto(name);
        list<sadmin> sadmin = sadminmapper.selectbyexample(sadminexample);
        if( sadmin==null|| sadmin.size()==0 )
            return null;
        return sadmin.get(0);
    }
 
    @override
    public int updatepwdbyusername(string name, string pwd) {
        adminexample adminexample = new adminexample();
        adminexample.createcriteria().andnameequalto(name);
        admin admin = new admin();
        admin.setpwd(pwd);
        adminmapper.updatebyexampleselective(admin,adminexample);
 
        return 0;
    }
 
    @override
    public int updatesadminpwdbyusername(string name, string pwd) {
        sadminexample sadminexample = new sadminexample();
        sadminexample.createcriteria().andnameequalto(name);
        sadmin sadmin = new sadmin();
        sadmin.setpwd(pwd);
        return sadminmapper.updatebyexampleselective(sadmin, sadminexample);
    }
 
    // 班级的增加
    @override
    public int add_class(long specialty_id, string class_name) {
        list<class> classes = select_class(null, null, null, null, class_name);
        if (classes == null || classes.size() == 0) {
            class class1 = new class();
            class1.setclassname(class_name);
            class1.setidspecialty(specialty_id);
            return classmapper.insert(class1);
        }
        return 0;
    }
 
    @override
    public int addadmin(admin admin) {
        //添加的时候检测又没用户名重复的
        publicservice.checkiftheusernameisduplicated(admin.getname());
        return adminmapper.insert(admin);
    }
 
    @override
    public int deladmin(admin admin) {
        return adminmapper.deletebyprimarykey(admin.getid());
    }
 
    @override
    public int updateadmin(admin admin) {
        //不更新username
        admin.setname(null);
        return adminmapper.updatebyprimarykeyselective(admin);
    }
 
    @override
    public list selectadmins(long offset) {
 
 
 
        if(offset!=null && offset==-1){
            return adminmapper.selectbyexampleselective(
                    new adminexample(),
                    admin.column.id
            );
        }
 
        return adminmapper.selectbyexample(
                new adminexample()
        );
    }
 
 
    // 学生的增删改查
    @override
    public int add_student(string username, string stunum, long id_class, string name, string gender, string pwd){
        student ss = studentmapper.select_studentbyname(username, stunum);
        if (ss == null) {
            studentwithblobs student = new studentwithblobs();
            student.setusername(username);
            student.setstunum(stunum);
            student.setidclass(id_class);
            student.setname(name);
            student.setgender(gender);
            student.setpwd(pwd);
            return studentmapper.insert(student);
        }
        return 0;
    }
    public int delete_class(long class_id) {
        return classmapper.deletebyprimarykey(class_id);
    }
 
    @override
    public int update_class(long class_id, long specialty_id, string class_name) {
        class class1 = new class();
        class1.setid(class_id);
        class1.setidspecialty(specialty_id);
        class1.setclassname(class_name);
        return classmapper.updatebyprimarykeyselective(class1);
    }
 
    @override
    public list<project> select_project(long institute_id, long section_id, string section_name) {
        return projectmapper.select_project(institute_id, null, null);
    }
 
    @override
    public list<static_student> select_studentxt_all(long section_id, string section_name, long specialty_id, string specialty_name, long class_id, string class_name) {
        list<static_student> static_students = studentmapper.select_studentxt_all(section_id, section_name, specialty_id, specialty_name, class_id, class_name);
        if (static_students != null && static_students.size() > 0) {
            for (int i = 0; i < static_students.size(); i++) {
                list<subjectselected> projectselecteds = select_projectselected(static_students.get(i).getid(), null);
                if (projectselecteds != null && projectselecteds.size() > 0) {
                    static_students.get(i).setstuselectflag("" + projectselecteds.get(0).getstuselectflag());
                    static_students.get(i).setprojectname(projectselecteds.get(0).getproject_name());
                    static_students.get(i).setteachernames(projectselecteds.get(0).getproject_teachers());
                } else {
                    static_students.get(i).setprojectname("未选题");
                    static_students.get(i).setteachernames("");
                }
            }
        }
        return static_students;
    }
 
 
    @override
    public list<class> select_class(long institute_id, long section_id, long specialty_id, long class_id, string class_name) {
        return classmapper.select_class(institute_id, section_id, specialty_id, class_id, class_name);
    }
 
    // 专业方向的增删改查
    @override
    public int add_specialty(long section_id, string specialty_name) {
        list<specialty> specialties = select_specialty(null, null, null, specialty_name);
        if (specialties == null || specialties.size() == 0) {
            specialty specialty = new specialty();
            specialty.setidsection(section_id);
            specialty.setspecialtyname(specialty_name);
            return specialtymapper.insert(specialty);
        }
        return 0;
    }
 
    @override
    public int delete_student(long student_id) {
        return studentmapper.deletebyprimarykey(student_id);
    }
 
    @override
    public int update_student(long student_id, string username, string stunum, long id_class, string name, string gender, string pwd) {
        student student = new student();
        student.setid(student_id);
        student.setusername(username);
        student.setstunum(stunum);
        student.setidclass(id_class);
        student.setname(name);
        student.setgender(gender);
        student.setpwd(pwd);
        return studentmapper.updatebyprimarykeyselective((studentwithblobs) student);
    }
 
    @override
    public list<static_student> select_student(long institute_id, long specialty_id, long class_id, long student_id, string name) {
        list<static_student> static_students = studentmapper.select_student(institute_id, specialty_id, class_id, student_id, name);
        if (static_students != null) {
            for (int i = 0; i < static_students.size(); i++) {
                static_student static_student = static_students.get(i);
 
                list<subjectselected> projectselected = select_projectselected(static_student.getid(), null);
 
                if (projectselected != null && projectselected.size() != 0) {
                    string s = "";
                    if (projectselected.get(0).getstuselectflag() == 1) s = "选题待审核";
                    else if (projectselected.get(0).getstuselectflag() == 2) s = "选题未通过";
                    else s = "选题通过";
                    static_student.setstuselectflag(s);
                    static_student.setprojectname(projectselected.get(0).getproject_name());
                    static_student.setteachernames(projectselected.get(0).getproject_teachers());
 
 
                }
            }
            return static_students;
        }
        return null;
    }
 
 
    // 通过学生id 或者 课题id 查 课题的选择 情况
    public list<subjectselected> select_projectselected(long student_id, long project_id) {
        return subjectselectedmapper.select_projectselected(student_id, project_id);
    }
 
    public list<subject> select_projectxq(long institute_id, long section_id, string name) {
        list<subject> projects = subjectmapper.select_projectxq(institute_id, section_id, name);
        if (projects != null) {
            for (int i = 0; i < projects.size(); i++) {
                if (projects.get(i).getselectflag() == 0) projects.get(i).setprojectgb("可选");
                else if (projects.get(i).getselectflag() == 1) projects.get(i).setprojectgb("不可选");
            }
        }
        return projects;
    }
    public int delete_specialty(long specialty_id) {
        return specialtymapper.deletebyprimarykey(specialty_id);
    }
 
    @override
    public int update_specialty(long specialty_id, long section_id, string specialty_name) {
        specialty specialty = new specialty();
        specialty.setid(specialty_id);
        specialty.setidsection(section_id);
        specialty.setspecialtyname(specialty_name);
 
        return specialtymapper.updatebyprimarykeyselective(specialty);
    }
 
    @override
    public list<specialty> select_specialty(long institute_id, long section_id, long specialty_id, string specialty_name) {
        return specialtymapper.select_specialty(institute_id, section_id, specialty_id, specialty_name); // 根据学院id 或者 教研室id 查所有专业方向
    }
 
    @override
    public list<institute> select_institute(long institute_id, string institute_name) {
        instituteexample instituteexample = new instituteexample();
        instituteexample.criteria criteria = instituteexample.createcriteria();
        if (institute_id != null && institute_id != 0) criteria.andidequalto(institute_id);
        if (institute_name != null && institute_name.length() > 0) criteria.andinstitutenameequalto(institute_name);
        return institutemapper.selectbyexample(instituteexample);
    }
 
 
 
}

到此这篇关于java 实战项目之教材管理系统的实现流程的文章就介绍到这了,更多相关java 教材管理系统内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！