AI 助理
备案控制台
开发者社区 云计算 文章 正文

Banner——第三阶段考核——大学生选课管理系统 上

2023-02-14 84
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Banner——第三阶段考核——大学生选课管理系统 上

初学者未完善 后期完善

顺序：entity–>dao—>servce–>controller

util包可以先写先测试，测试类看自身情况

entity包

User 类

package entity;
/**
 * @Author: hyy
 * @Date: 2020/12/18 13:11
 */
public class User {
    private Integer id;
    private String userName;
    private String passWord;
    private String question;
    private String answer;
    private Integer level;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassWord() {
        return passWord;
    }
    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
    public String getQuestion() {
        return question;
    }
    public void setQuestion(String question) {
        this.question = question;
    }
    public String getAnswer() {
        return answer;
    }
    public void setAnswer(String answer) {
        this.answer = answer;
    }
    public Integer getLevel() {
        return level;
    }
    public void setLevel(Integer level) {
        this.level = level;
    }
    /**
     *  空参构造器
     */
    public User() {
    }
    /**
     *  用来用户注册
     * @param id
     */
    public User(Integer id) {
        this.id = id;
    }
    /**
     *  初始化除账号外的参数
     * @param userName
     * @param passWord
     * @param question
     * @param answer
     * @param level
     */
    public User(String userName, String passWord, String question, String answer, Integer level) {
        this.userName = userName;
        this.passWord = passWord;
        this.question = question;
        this.answer = answer;
        this.level = level;
    }
    /**
     *  初始化全部参数的构造器
     * @param id
     * @param userName
     * @param passWord
     * @param question
     * @param answer
     * @param level
     */
    public User(Integer id, String userName, String passWord, String question, String answer, Integer level) {
        this.id = id;
        this.userName = userName;
        this.passWord = passWord;
        this.question = question;
        this.answer = answer;
        this.level = level;
    }
    @Override
    public String toString() {
        return "{" +
                "ID：" + id +
                ", 昵称：" + userName +
                ", 密码：" + passWord +
                ", 密保问题：" + question +
                ", 密保答案：" + answer +
                ", 用户权限：" + level +
                "}\n";
    }
}

Course 类

课程类

package entity;
/**
 * @Author: hyy
 * @Date: 2020/12/18 21:11
 */
public class Course {
    /**
     *  学生id
     */
    private Integer id;
    /**
     *   课程名称
     */
    private String courseName;
    /**
     * 课程编号
     */
    private String courseId;
    /**
     * 上课教师
     */
    private String courseTeacher;
    /**
     * 课程可选总人数
     */
    private Integer number;
    /**
     *  空参构造器
     */
    public Course() {
    }
    /**
     *  初始化除id外所有参数的构造器
     * @param courseName
     * @param courseId
     * @param courseTeacher
     * @param number
     */
    public Course(String courseName, String courseId, String courseTeacher, Integer number) {
        this.courseName = courseName;
        this.courseId = courseId;
        this.courseTeacher = courseTeacher;
        this.number = number;
    }
    /**
     *  初始化所有参数的构造器
     * @param id
     * @param courseName
     * @param courseId
     * @param courseTeacher
     * @param number
     */
    public Course(Integer id, String courseName, String courseId, String courseTeacher, Integer number) {
        this.id = id;
        this.courseName = courseName;
        this.courseId = courseId;
        this.courseTeacher = courseTeacher;
        this.number = number;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getCourseName() {
        return courseName;
    }
    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }
    public String getCourseId() {
        return courseId;
    }
    public void setCourseId(String courseId) {
        this.courseId = courseId;
    }
    public String getCourseTeacher() {
        return courseTeacher;
    }
    public void setCourseTeacher(String courseTeacher) {
        this.courseTeacher = courseTeacher;
    }
    public Integer getNumber() {
        return number;
    }
    public void setNumber(Integer number) {
        this.number = number;
    }
    @Override
    public String toString() {
        return "{" +
                "ID=" + id +
                ", 课程名称：：" + courseName +
                ", 课程编号：" + courseId +
                ", 任教老师：" + courseTeacher +
                ", 课程总可选人数：" + number +
                "}\n";
    }
}

Dao包

UserDao.java

接口

package dao;
import entity.User;
import java.util.List;
/**
 * @Author: hyy
 * @Date: 2020/12/18 13:34
 */
public interface UserDao {
    /**
     *  添加用户
     * @param user
     * @return
     */
    boolean insertUser(User user);
    /**
     *  根据id 删除用户
     * @param id
     * @return
     */
    boolean deleteUserById(Integer id);
    /**
     *  根据id 更改用户
     * @param id
     * @param user
     * @return
     */
    boolean updateUserById(Integer id,User user);
    /**
     *  根据id 查询用户
     * @param id
     * @return
     */
    User selectUserById(Integer id);
    /**
     *  根据用户名 查询用户
     * @param userName
     * @return
     */
    User selectUserByUserName(String userName);
    /**
     *  查询所有用户
      * @return
     */
    List<User> selectAllUser();
}

UserDaoImpl.java

实现类

package dao.impl;
import dao.UserDao;
import entity.User;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
/**
 * @Author: hyy
 * @Date: 2020/12/18 13:35
 */
public class UserDaoImpl implements UserDao {
    /**
     *  添加用户
     * @param user
     * @return boolean
     */
    @Override
    public boolean insertUser(User user) {
        try{
            BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter("UniversityCourseSelectionSystem\\User.txt",true));
            bufferedWriter.write(user.getId()+","+user.getUserName()+","+user.getPassWord()+","+user.getQuestion()+","+user.getAnswer()+","+user.getLevel());
            bufferedWriter.newLine();
            bufferedWriter.close();
            return true;
        }catch (IOException e){
            System.out.println("io异常，添加失败！");
            return false;
        }
    }
    /**
     *  根据id 删除用户
     * @param id
     * @return boolean
     */
    @Override
    public boolean deleteUserById(Integer id) {
        try {
            BufferedReader bufferedReader=new BufferedReader(new FileReader("UniversityCourseSelectionSystem\\User.txt"));
            List<User> userList=new ArrayList<>();
            String string ;
            while ((string=bufferedReader.readLine())!=null){
                String[]dates= string.split(",");
                User user=new User(Integer.parseInt(dates[0]),dates[1],dates[2],dates[3],dates[4],Integer.parseInt(dates[5]));
                userList.add(user);
            }
            for (int i = 0; i < userList.size(); i++) {
                User user=userList.get(i);
                if ( (user.getId()).equals(id) ){
                    userList.remove(i);
                }
            }
            BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter("UniversityCourseSelectionSystem\\User.txt"));
            for (int i = 0; i < userList.size(); i++) {
                User user=userList.get(i);
                String returnString =String.format("%s,%s,%s,%s,%s,%s",user.getId(),user.getUserName(),user.getPassWord(),user.getQuestion(),user.getAnswer(),user.getLevel());
                bufferedWriter.write(returnString);
                bufferedWriter.newLine();
            }
            bufferedReader.close();
            bufferedWriter.close();
            return true;
        }catch (IOException e){
            System.out.println("IO异常，删除失败！");
            return false;
        }
    }
    /**
     *  根据id 更改用户
     * @param id
     * @param user
     * @return boolean
     */
    @Override
    public boolean updateUserById(Integer id,User user) {
        try{
            BufferedReader bufferedReader=new BufferedReader(new FileReader("UniversityCourseSelectionSystem\\User.txt"));
            List<User> userList=new ArrayList<>();
            String string;
            while ((string=bufferedReader.readLine())!=null){
                String[] dates=string.split(",");
                User user1=new User(Integer.parseInt(dates[0]),dates[1],dates[2],dates[3],dates[4],Integer.parseInt(dates[5]));
                userList.add(user1);
            }
            for (int i = 0; i < userList.size(); i++) {
                User user1= userList.get(i);
                if (user1.getId().equals(id)){
                    userList.set(i,user);
                }
            }
            BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter("UniversityCourseSelectionSystem\\User.txt"));
            for (int i = 0; i < userList.size(); i++) {
                User user1=userList.get(i);
                String returnString=String.format("%s,%s,%s,%s,%s,%s",user1.getId(),user1.getUserName(),user1.getPassWord(),user1.getQuestion(),user1.getAnswer(),user1.getLevel());
                bufferedWriter.write(returnString);
                bufferedWriter.newLine();
            }
            bufferedReader.close();
            bufferedWriter.close();
            return true;
        }catch (IOException e){
            System.out.println("io异常，更改用户信息失败！");
            return false;
        }
    }
    /**
     *  根据id 查询用户
     * @param id
     * @return User
     */
    @Override
    public User selectUserById(Integer id) {
        try {
            BufferedReader bufferedReader=new BufferedReader(new FileReader("UniversityCourseSelectionSystem\\User.txt"));
            List<User> userList=new ArrayList<>();
            String string;
            while ((string=bufferedReader.readLine())!=null){
                String [] dates=string.split(",");
                User user=new User(Integer.parseInt(dates[0]),dates[1],dates[2],dates[3],dates[4],Integer.parseInt(dates[5]));
                userList.add(user);
            }
            for (int i = 0; i < userList.size(); i++) {
                User user=userList.get(i);
                if (user.getId().equals(id)){
                    return user;
                }
            }
            bufferedReader.close();
        }catch (IOException e){
            System.out.println("IO异常，查询失败！");
            return null;
        }
        return null;
    }
    /**
     *  根据userName 查询用户
     * @param userName
     * @return User
     */
    @Override
    public User selectUserByUserName(String userName) {
        try{
            BufferedReader bufferedReader=new BufferedReader(new FileReader("UniversityCourseSelectionSystem\\User.txt"));
            List<User> userList=new ArrayList<>();
            String string;
            while ((string=bufferedReader.readLine())!=null){
                String[] dates=string.split(",");
                User user=new User(Integer.parseInt(dates[0]),dates[1],dates[2],dates[3],dates[4],Integer.parseInt(dates[5]));
                userList.add(user);
            }
            for (int i = 0; i < userList.size(); i++) {
                User user=userList.get(i);
                if (user.getUserName().equals(userName)){
                    return user;
                }
            }
            bufferedReader.close();
        }catch (IOException e) {
            System.out.println("io异常，查询用户信息失败！");
        }
            return null;
    }
    /**
     *  查询所有用户
     * @return List<User>
     */
    @Override
    public List<User> selectAllUser() {
        try {
            BufferedReader bufferedReader=new BufferedReader(new FileReader("UniversityCourseSelectionSystem\\User.txt"));
            List<User> userList=new ArrayList<>();
            String string;
            while ((string=bufferedReader.readLine())!=null){
                String[]dates=string.split(",");
                User user=new User(Integer.parseInt(dates[0]),dates[1],dates[2],dates[3],dates[4],Integer.parseInt(dates[5]));
                userList.add(user);
            }
            bufferedReader.close();
            return userList;
        }catch (IOException e){
            System.out.println("io异常，查询用户信息失败！");
        }
        return null;
    }
}

CourseDao.java

接口

package dao;
import entity.Course;
import java.util.List;
/**
 * @Author: hyy
 * @Date: 2020/12/18 21:22
 */
public interface CourseDao {
    /**
     *  增加课程
     * @param course
     * @return
     */
    boolean insertCourse(Course course);
    /**
     *  根据id和课程编号 删除对应id里的课程
     * @param id
     * @param courseId
     * @return
     */
    boolean deleteCourseByCourseId(Integer id,String courseId);
    /**
     *  根据id和课程编号 更改对应id里的课程
     * @param id
     * @param courseId
     * @param course
     * @return
     */
    boolean updateCourseById(Integer id,String courseId,Course course);
    /**
     *  根据id 查询该id所选的课程
     * @param id
     * @return
     */
    List<Course> selectCourseById(Integer id);
    /**
     *  查询所有id 所选的课程
     * @return
     */
    List<Course> selectAllCourse();
}

CourseDaoImpl.java

实现类

package dao.impl;
import dao.CourseDao;
import entity.Course;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
/**
 * @Author: hyy
 * @Date: 2020/12/18 21:27
 */
public class CourseDaoImpl implements CourseDao {
//    CourseDaoImpl courseDao=new CourseDaoImpl(); 这样调回栈溢出异常
    /**
     *  添加课程
     * @param course
     * @return boolean
     */
    @Override
    public boolean insertCourse(Course course) {
        try {
            BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter("UniversityCourseSelectionSystem\\Course.txt",true));
            bufferedWriter.write(course.getId()+","+course.getCourseName()+","+course.getCourseId()+","+course.getCourseTeacher()+","+course.getNumber());
            bufferedWriter.newLine();
            bufferedWriter.close();
            return true;
        }catch (IOException e){
            System.out.println("IO异常，添加失败！");
            return false;
        }
    }
    /**
     *  根据用户id和课程编号 删除用户课程里的该课程
     * @param id
     * @param courseId
     * @return boolean
     */
    @Override
    public boolean deleteCourseByCourseId(Integer id,String courseId) {
        try {
//            List<Course> courseList1=courseDao.selectCourseById(id);
            BufferedReader bufferedReader=new BufferedReader(new FileReader("UniversityCourseSelectionSystem\\Course.txt"));
            List<Course> courseList=new ArrayList<>();
            String string;
            while ((string=bufferedReader.readLine())!=null){
                String[] dates=string.split(",");
                Course course=new Course(Integer.parseInt(dates[0]),dates[1],dates[2],dates[3],Integer.parseInt(dates[4]));
                courseList.add(course);
            }
            for (int i = 0; i < courseList.size(); i++) {
                Course course=courseList.get(i);
                if (course.getId().equals(id)){
                    if (course.getCourseId().equals(courseId)){
                        courseList.remove(i);
                    }else {
                        System.out.println("该用户里不存在该课程,删除失败！");
                    }
                }else{
                    System.out.println("查无此id 删除失败！");
                }
            }
            BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter("UniversityCourseSelectionSystem\\Course.txt"));
            for (int i = 0; i < courseList.size(); i++) {
                Course course=courseList.get(i);
                String returnString=String.format("%s,%s,%s,%s,%s,",course.getId(),course.getCourseName(),course.getCourseId(),course.getCourseTeacher(),course.getNumber());
                bufferedWriter.write(returnString);
                bufferedWriter.newLine();
            }
//           byfferedReader.close();
            bufferedWriter.close();
            return true;
        }catch (IOException e){
            System.out.println("IO异常，删除失败！");
            return false;
        }
    }
    /**
     *  根据id和课程编号 将id对应用户里的该课程更改成course
     * @param id
     * @param courseId
     * @param course
     * @return boolean
     */
    @Override
    public boolean updateCourseById(Integer id,String courseId, Course course) {
       try {
//           List<Course> courseList=courseDao.selectCourseById(id);
           BufferedReader bufferedReader=new BufferedReader(new FileReader("UniversityCourseSelectionSystem\\Course.txt"));
           List<Course> courseList=new ArrayList<>();
           String string;
           while ((string=bufferedReader.readLine())!=null){
               String[] dates=string.split(",");
               Course course1=new Course(Integer.parseInt(dates[0]),dates[1],dates[2],dates[3],Integer.parseInt(dates[4]));
               courseList.add(course1);
           }
           for (int i = 0; i < courseList.size(); i++) {
               Course course1=courseList.get(i);
               if (course1.getId().equals(id)){
                   if (course1.getCourseId().equals(courseId)){
                       courseList.set(i,course);
                   }
               }
           }
           BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter("UniversityCourseSelectionSystem\\Course.txt"));
           for (int i = 0; i < courseList.size(); i++) {
               Course course1=courseList.get(i);
               String returnString=String.format("%s,%s,%s,%s,%s,",course1.getId(),course1.getCourseName(),course1.getCourseId(),course1.getCourseTeacher(),course1.getNumber());
               bufferedWriter.write(returnString);
               bufferedWriter.newLine();
           }
//           bufferedReader.close();
           bufferedWriter.close();
           return true;
       }catch (IOException e){
           System.out.println("IO异常，更改失败！");
           return false;
       }
    }
    /**
     *  根据id 查询id对应用户所选的课程
     * @param id
     * @return List<Course>
     */
    @Override
    public List<Course> selectCourseById(Integer id) {
        try {
            BufferedReader bufferedReader = new BufferedReader(new FileReader("UniversityCourseSelectionSystem\\Course.txt"));
            List<Course> courseList = new ArrayList<>();
            List<Course> courseList1=new ArrayList<>();
            String string;
            while ((string = bufferedReader.readLine()) != null) {
                String[] dates = string.split(",");
                Course course1 = new Course(Integer.parseInt(dates[0]), dates[1], dates[2], dates[3], Integer.parseInt(dates[4]));
                courseList.add(course1);
            }
            for (int i = 0; i < courseList.size(); i++) {
                Course course1 = courseList.get(i);
                if (course1.getId().equals(id)) {
                    courseList1.add(course1);
                }
            }
            bufferedReader.close();
            return courseList1;
        }catch (IOException e){
            System.out.println("IO异常，查询失败！");
            return null;
        }
    }
    /**
     *  查询所有用户选的课程
     * @return List<Course>
     */
    @Override
    public List<Course> selectAllCourse() {
        try {
            BufferedReader bufferedReader = new BufferedReader(new FileReader("UniversityCourseSelectionSystem\\Course.txt"));
            List<Course> courseList = new ArrayList<>();
            String string;
            while ((string = bufferedReader.readLine()) != null) {
                String[] dates = string.split(",");
                Course course = new Course(Integer.parseInt(dates[0]), dates[1], dates[2], dates[3], Integer.parseInt(dates[4]));
                courseList.add(course);
            }
            bufferedReader.close();
            return courseList;
        }catch (IOException e){
            System.out.println("IO异常，查询失败！");
            return null;
        }
    }
}

Service包

UserService.java

接口

package setvice;
import entity.User;
import java.util.List;
/**
 * @Author: hyy
 * @Date: 2020/12/18 14:23
 */
public interface UserService {
    /**
     *  根据id和密码登录普通用户
     * @param id
     * @param passWord
     * @return boolean
     */
    boolean ordinaryUserLogin(Integer id,String passWord);
    /**
     *  根据id和密码登录管理员
     * @param id
     * @param passWord
     * @return boolean
     */
    boolean administratorLogin(Integer id,String passWord);
    /**
     *  注册用户
     *  学生和教师的注册分离在UserView里
     * @param user
     * @return boolean
     */
    boolean registerUser(User user);
    /**
     *  添加用户
     * @param user
     * @return boolean
     */
    boolean insertUser(User user);
    /**
     *  根据id删除用户
     * @param id
     * @return boolean
     */
    boolean deleteUserById(Integer id);
    /**
     *  根据id 更改用户信息
     * @param id
     * @param user
     * @return boolean
     */
    boolean updateUserById(Integer id,User user);
    /**
     *  根据id查询用户
     * @param id
     * @return User
     */
    User selectUserById(Integer id);
    /**
     *  根据用户名查询用户
     * @param userName
     * @return User
     */
    User selectUserByUserName(String userName);
    /**、
     *  查询所有用户
     * @return List<User>
     */
    List<User> selectAllUser();
}

UserServiceImpl.java

实现类

package setvice.impl;
import dao.UserDao;
import dao.impl.UserDaoImpl;
import entity.User;
import setvice.UserService;
import java.util.List;
/**
 * @Author: hyy
 * @Date: 2020/12/18 14:23
 */
public class UserServiceImpl implements UserService {
    UserDao UserDao=new UserDaoImpl();
    /**
     *  普通用户登录（老师和学生）
     * @param id
     * @param passWord
     * @return boolean
     */
    @Override
    public boolean ordinaryUserLogin(Integer id, String passWord) {
        User user=UserDao.selectUserById(id);
        if (user!=null&&(user.getLevel()==1||user.getLevel()==2)&&user.getId().equals(id)&&user.getPassWord().equals(passWord)){
            System.out.println("登录成功！");
            return true;
        }
        else {
            System.out.println("登录失败，id不存在或密码输入错误！");
            return false;
        }
    }
    /**
     *  管理员登录
     * @param id
     * @param passWord
     * @return boolean
     */
    @Override
    public boolean administratorLogin(Integer id, String passWord) {
        User user=UserDao.selectUserById(id);
        if (user!=null&&user.getLevel()==3&&user.getId().equals(id)&&user.getPassWord().equals(passWord)){
            System.out.println("登录成功！");
            return true;
        }
        else {
            System.out.println("登录失败，id不存在或密码输入错误！");
            return false;
        }
    }
    /**
     *   注册用户
     * @param user
     * @return boolean
     */
    @Override
    public boolean registerUser(User user) {
        User user1=UserDao.selectUserById(user.getId());
        if (user1==null){
            UserDao.insertUser(user);
            System.out.println("恭喜注册成功！");
            return true;
        } else{
            System.out.println("用户已存在,注册失败！");
            return false;
        }
    }
    /**
     *  添加用户
     * @param user
     * @return
     */
    @Override
    public boolean insertUser(User user) {
            User user1=UserDao.selectUserById(user.getId());
            if (user1==null){
                UserDao.insertUser(user);
                System.out.println("添加成功！");
                return true;
            }else {
                System.out.println("用户已存在，添加失败！");
                return false;
            }
    }
    /**
     *  根据id 删除用户
     * @param id
     * @return
     */
    @Override
    public boolean deleteUserById(Integer id) {
        User user=UserDao.selectUserById(id);
        if (user!=null){
            UserDao.deleteUserById(id);
            System.out.println("删除成功！");
            return true;
        }else {
            System.out.println("用户不存在，删除失败！");
            return false;
        }
    }
    /**
     *  根据id 更改用户
     * @param id
     * @param user
     * @return
     */
    @Override
    public boolean updateUserById(Integer id,User user) {
        User user1=UserDao.selectUserById(id);
        if (user1!=null){
            UserDao.updateUserById(id,user);
            System.out.println("更改成功！");
            return true;
        }else {
            System.out.println("用户不存在，更改失败！");
            return false;
        }
    }
    /**
     *  根据id 查询用户
     * @param id
     * @return
     */
    @Override
    public User selectUserById(Integer id) {
        User user=UserDao.selectUserById(id);
        if (user!=null){
            return user;
        }else {
            System.out.println("用户不存在");
            return null;
        }
    }
    /**
     *  根据用户名查询用户
     * @param userName
     * @return
     */
    @Override
    public User selectUserByUserName(String userName) {
        User user=UserDao.selectUserByUserName(userName);
        if (user!=null){
            return user;
        }else {
            System.out.println("用户不存在，查询失败！");
            return null;
        }
    }
    /**
     *  查询所有用户
     * @return
     */
    @Override
    public List<User> selectAllUser() {
        List<User> userList=UserDao.selectAllUser();
        if (userList!=null){
            return userList;
        }else{
            System.out.println("无用户！");
            return null;
        }
    }
}

CourseService.java

接口

package setvice;
import entity.Course;
import java.util.List;
/**
 * @Author: hyy
 * @Date: 2020/12/18 22:06
 */
public interface CourseService {
    /**
     *  添加课程 即 选课
     * @param course
     * @return boolean
     */
    boolean insertCourseService(Course course);
    /**
     *  根据id和课程编号 删除id对应用户里的该课程
     * @param id
     * @param courseId
     * @return boolean
     */
    boolean deleteCourseByCourseIdService(Integer id,String courseId);
    /**
     * 根据id和课程编号 更改id对应用户里的该课程
     * @param id
     * @param courseId
     * @param course
     * @return boolean
     */
    boolean updateCourseByIdService(Integer id,String courseId,Course course);
    /**
     *  根据id 查询id对应用户所选全部课程
     * @param id
     * @return List<Course>
     */
    List<Course> selectCourseByIdService(Integer id);
    /**
     *  查询所有用户对应的课程
     * @return List<Course>
     */
    List<Course> selectAllCourseService();
}

CourseServiceImpl.java

实现类

package setvice.impl;
import dao.CourseDao;
import dao.impl.CourseDaoImpl;
import entity.Course;
import entity.User;
import setvice.CourseService;
import java.util.List;
/**
 * @Author: hyy
 * @Date: 2020/12/18 22:24
 */
public class CourseServiceImpl implements CourseService {
    CourseDao courseDao=new CourseDaoImpl();
    /**
     *  添加课程 即 选课
     * @param course
     * @return boolean
     */
    @Override
    public boolean insertCourseService(Course course) {
            courseDao.insertCourse(course);
            System.out.println("添加成功！");
            return true;
    }
    /**
     *  根据id和课程编号 删除id对应用户里的该课程
     * @param id
     * @param courseId
     * @return boolean
     */
    @Override
    public boolean deleteCourseByCourseIdService(Integer id,String courseId) {
        List<Course> courseList=courseDao.selectCourseById(id);
        if (courseList!=null){
            courseDao.deleteCourseByCourseId(id,courseId);
            System.out.println("删除成功！");
            return true;
        }else {
            System.out.println("课程不存在，删除失败！");
            return false;
        }
    }
    /**
     * 根据id和课程编号 更改id对应用户里的该课程
     * @param id
     * @param courseId
     * @param course
     * @return boolean
     */
    @Override
    public boolean updateCourseByIdService(Integer id,String courseId, Course course) {
        List<Course> courseList=courseDao.selectCourseById(id);
//        System.out.println(courseList);
        if (courseList!=null){
            for (int i = 0; i < courseList.size(); i++) {
                Course course1=courseList.get(i);
//                System.out.println(course1);
                if (course1.getCourseId().equals(courseId)){
                    courseDao.updateCourseById(id,courseId,course);
                    System.out.println("更改成功！");
                }
            }
            return true;
//            courseDao.updateCourseById(id,courseId,course);
//            System.out.println("更改成功！");
//            return true;
        }else {
            System.out.println("课程不存在，更改失败！");
            return false;
        }
//        return false;
    }
    /**
     *  根据id 查询id对应用户所选全部课程
     * @param id
     * @return List<Course>
     */
    @Override
    public List<Course> selectCourseByIdService(Integer id) {
        List<Course> courseList=courseDao.selectCourseById(id);
        if (courseList!=null){
            return courseList;
        }else {
            System.out.println("课程不存在");
            return null;
        }
    }
    /**
     *  查询所有用户对应的课程
     * @return  List<Course>
     */
    @Override
    public List<Course> selectAllCourseService() {
        List<Course> courseList=courseDao.selectAllCourse();
        if (courseList!=null){
            return courseList;
        }else{
            System.out.println("无用户！");
            return null;
        }
    }
}

Contoller包

UserController.java

package controller;
import entity.User;
import setvice.UserService;
import setvice.impl.UserServiceImpl;
import java.util.List;
/**
 * @Author: hyy
 * @Date: 2020/12/18 15:23
 */
public class UserController {
    UserService userService=new UserServiceImpl();
    /**
     *  普通用户登录
     * @param id
     * @param passWord
     * @return boolean
     */
    public boolean ordinaryUserLogin(Integer id, String passWord){
        return userService.ordinaryUserLogin(id,passWord);
    }
    /**
     *  管理员登陆
     * @param id
     * @param passWord
     * @return boolean
     */
    public boolean administratorLogin(Integer id, String passWord){
        return userService.administratorLogin(id,passWord);
    }
    /**
     *  注册用户
     * @param user
     * @return boolean
     */
    public boolean registerUser(User user){
        return userService.registerUser(user);
    }
    /**
     *  添加用户
     * @param user
     * @return boolean
     */
    public boolean insertUser(User user){
        return userService.insertUser(user);
    }
    /**
     *  根据id
     * @param id
     * @return boolean
     */
    public boolean deleteUserById(Integer id){
        return userService.deleteUserById(id);
    }
    /**
     *  根据id 更改用户
     * @param id
     * @param user
     * @return boolean
     */
    public boolean updateUserById(Integer id,User user){
        return userService.updateUserById(id,user);
    }
    /**
     *  根据id 查询用户
     * @param id
     * @return User
     */
    public User selectUserById(Integer id){
        return userService.selectUserById(id);
    }
    /**
     *  根据用户名查询用户
     * @param userName
     * @return User
     */
    public User selectUserByUserName(String userName){
        return userService.selectUserByUserName(userName);
    }
    /**
     *  查询所有用户
     * @return List<User>
     */
    public List<User> selectAllUser(){
        return userService.selectAllUser();
    }
}

CourseController.java

package controller;
import entity.Course;
import setvice.CourseService;
import setvice.impl.CourseServiceImpl;
import java.util.List;
/**
 * @Author: hyy
 * @Date: 2020/12/18 22:32
 */
public class CourseController {
    CourseService courseService=new CourseServiceImpl();
    /**
     *  添加课程 即 选课
     * @param course
     * @return boolean
     */
    public boolean insertCourseController(Course course){
        return  courseService.insertCourseService(course);
    }
    /**
     *  根据id和课程编号 删除id对应用户里的该课程
     * @param id
     * @param courseId
     * @return boolean
     */
    public boolean deleteCourseByCourseIdController(Integer id,String courseId){
        return courseService.deleteCourseByCourseIdService(id,courseId);
    }
    /**
     * 根据id和课程编号 更改id对应用户里的该课程
     * @param id
     * @param courseId
     * @param course
     * @return boolean
     */
    public boolean updateCourseByIdService(Integer id,String courseId,Course course){
        return courseService.updateCourseByIdService(id,courseId,course);
    }
    /**
     *  根据id 查询id对应用户所选全部课程
     * @param id
     * @return List<Course>
     */
    public List<Course> selectCourseByIdController(Integer id){
        return  courseService.selectCourseByIdService(id);
    }
    /**
     *  查询所有用户对应的课程
     * @return List<Course>
     */
    public List<Course> selectAllCourseService(){
        return courseService.selectAllCourseService();
    }
}


小象裤衩
目录
相关文章
码上来科技
|
Java 关系型数据库 MySQL
【实训项目】基于JavaWeb的图书销售购物系统
【实训项目】基于JavaWeb的图书销售购物系统
码上来科技
219 0
Meteor.792
|
关系型数据库 MySQL 数据库
MySQL数据库期末项目 图书馆管理系统（上）
MySQL数据库期末项目 图书馆管理系统
Meteor.792
414 0
然然学长
|
9月前
|
JavaScript 小程序 Java
基于SSM大学生宿舍管理系统的设计与实现
基于SSM大学生宿舍管理系统的设计与实现
然然学长
105 1
Meteor.792
|
存储 Java 关系型数据库
JavaWeb期末项目 图书馆管理系统
JavaWeb期末项目 图书馆管理系统
Meteor.792
226 1
冷辞
|
9月前
|
Java
图书馆管理系统
图书馆管理系统
冷辞
236 2
Meteor.792
|
存储 关系型数据库 MySQL
MySQL数据库期末项目 图书馆管理系统（下）
MySQL数据库期末项目 图书馆管理系统（下）
Meteor.792
143 0
godspeedlucip-44601
|
9月前
|
存储 数据可视化 数据安全/隐私保护
C++实现简易图书馆管理系统
C++实现简易图书馆管理系统
godspeedlucip-44601
182 1
dearQiHao
|
9月前
11驾校科目一考试系统——发布项目
发布项目   当我们编写完项目之后就需要发布项目 。就需要发布项目了。一般发布项目的话我们会把所有需要的文件都放在一个文件夹里面，这样的话就更方便。有时候文件过多的话，有可能会有很多的子文件夹，我们先把功能工作目录设置一下，因为当前的工作目录是debug或者release，导致咱们在读取数据文件的时候需要相对路径的话还需要上一级目录去寻找。如下图所示。
dearQiHao
54 1
dearQiHao
|
9月前
07——驾校科目一考试系统——布局题库
如果需要题库的资料（exam.txt）可以留下邮箱，博主会发给大家的。 总代码
dearQiHao
148 1
dearQiHao
|
9月前
|
设计模式 编译器 C语言
02——驾校科目一考试系统——新建项目
创建QT 双击打开QT编译器
dearQiHao
97 0

热门文章

最新文章

  • 1
    Oracle使用expdp/impdp实现全库导入导出的整体流程
  • 2
    Python实现阿里云域名DDNS支持ipv4和ipv6
  • 3
    Tensorflow车牌识别完整项目（含完整源代码及训练集）
  • 4
    linux误删除了文件
  • 5
    系统架构技能之设计模式-组合模式
  • 6
    php判断上传文件是不是图片，如果是，返回图片格式
  • 7
    用户手册概要
  • 8
    Android -- 与WEB交互在同一个会话Session中通信
  • 9
    青岛城市圈：青岛 OSCER 技术交流会(1月12日)
  • 10
    springMVC对异常处理的支持
  • 1
    一维信号的小波变换与重构算法matlab仿真
    15
  • 2
    基于ADRC自抗扰算法的UAV飞行姿态控制系统simulink建模与仿真
    14
  • 3
    《深度剖析：边缘计算与AI融合下，生成对抗网络部署的变革与展望》
    11
  • 4
    《深度剖析：生成对抗网络如何实现图像风格的细腻逼真迁移》
    13
  • 5
    《深度剖析：生成对抗网络如何攻克文本生成的逻辑与语义难题》
    19
  • 6
    《深度剖析：生成对抗网络中生成器与判别器的高效协作之道》
    13
  • 7
    《深度揭秘：生成对抗网络如何重塑遥感图像分析精度》
    10
  • 8
    低代码：真能“0代码”开发应用吗？
    18
  • 9
    算法系列之回溯算法
    17
  • 10
    基于阿里云Serverless Kubernetes（ASK）的无服务器架构设计与实践
    20

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    通义万相：视觉生成大模型再进化