学生信息管理系统

在一次技术讨论会上，两位软件工程师正在交流关于“学工管理系统”在“工程学院”中的应用。他们的对话围绕系统的功能模块展开，涉及前端、后端、数据库以及安全性等多个方面。

张伟（前端工程师）：李明，最近我们学院要重新设计学工管理系统，你觉得我们应该从哪些功能模块开始？

李明（后端工程师）：我觉得首先应该明确几个核心功能模块。比如学生信息管理、成绩录入、课程安排、通知公告这些，都是日常教学和管理中不可或缺的部分。

张伟：没错，那我们可以先从学生信息管理模块入手。这个模块需要包括学生的个人信息、班级、专业等数据。你有什么想法吗？

李明：我建议使用RESTful API来设计这个模块。前端可以通过GET请求获取学生列表，POST请求添加新学生，PUT更新信息，DELETE删除记录。

张伟：听起来不错。那我可以用Vue.js来构建前端界面，配合Axios发送HTTP请求。不过，我们需要考虑权限控制，防止未授权用户访问或修改数据。

李明：对，权限控制是关键。我们可以使用JWT（JSON Web Token）来验证用户身份。当用户登录后，服务器会返回一个token，后续请求都需要携带这个token。

张伟：明白了。那我们先写一个简单的登录接口吧。前端可以提供用户名和密码输入框，后端接收并验证，如果正确则生成token返回。

李明：好的，下面是一个简单的登录接口示例，用Python Flask框架实现：

from flask import Flask, request, jsonify
import jwt
import datetime

app = Flask(__name__)

SECRET_KEY = 'your_secret_key'

@app.route('/login', methods=['POST'])
def login():
    data = request.get_json()
    username = data.get('username')
    password = data.get('password')

    # 这里假设有一个简单的验证逻辑
    if username == 'admin' and password == '123456':
        payload = {
            'user': username,
            'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1)
        }
        token = jwt.encode(payload, SECRET_KEY, algorithm='HS256')
        return jsonify({'token': token})
    else:
        return jsonify({'error': 'Invalid credentials'}), 401

if __name__ == '__main__':
    app.run(debug=True)

    

张伟：这段代码很清晰，使用了JWT进行身份验证。接下来我们可以为学生信息管理模块编写API。

李明：学生信息管理模块需要支持CRUD操作。我们可以创建一个Student模型，包含id、name、gender、major、class等字段。

张伟：那我们可以用SQLAlchemy来定义模型，然后通过Flask-Restful来构建REST API。

李明：是的，以下是一个学生信息管理模块的示例代码：

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_restful import Api, Resource
import jwt
import datetime

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///students.db'
db = SQLAlchemy(app)
api = Api(app)

SECRET_KEY = 'your_secret_key'

class Student(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100))
    gender = db.Column(db.String(10))
    major = db.Column(db.String(100))
    class_name = db.Column(db.String(50))

class StudentResource(Resource):
    def get(self, student_id=None):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        if student_id:
            student = Student.query.get(student_id)
            if not student:
                return {'error': 'Student not found'}, 404
            return {
                'id': student.id,
                'name': student.name,
                'gender': student.gender,
                'major': student.major,
                'class': student.class_name
            }
        else:
            students = Student.query.all()
            return [{
                'id': s.id,
                'name': s.name,
                'gender': s.gender,
                'major': s.major,
                'class': s.class_name
            } for s in students]

    def post(self):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        data = request.get_json()
        new_student = Student(
            name=data['name'],
            gender=data['gender'],
            major=data['major'],
            class_name=data['class']
        )
        db.session.add(new_student)
        db.session.commit()
        return {'message': 'Student added successfully'}, 201

    def put(self, student_id):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        student = Student.query.get(student_id)
        if not student:
            return {'error': 'Student not found'}, 404

        data = request.get_json()
        student.name = data.get('name', student.name)
        student.gender = data.get('gender', student.gender)
        student.major = data.get('major', student.major)
        student.class_name = data.get('class', student.class_name)

        db.session.commit()
        return {'message': 'Student updated successfully'}, 200

    def delete(self, student_id):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        student = Student.query.get(student_id)
        if not student:
            return {'error': 'Student not found'}, 404

        db.session.delete(student)
        db.session.commit()
        return {'message': 'Student deleted successfully'}, 200

api.add_resource(StudentResource, '/students', '/students/')

if __name__ == '__main__':
    db.create_all()
    app.run(debug=True)

    

张伟：这段代码实现了学生信息管理模块的基本功能，包括增删改查，并且加入了JWT认证机制，确保只有合法用户才能操作数据。

李明：接下来我们可以考虑成绩录入模块。这个模块需要支持教师上传学生成绩，并且允许学生查看自己的成绩。

张伟：那我们可以设计一个Grade模型，包含学生ID、课程名称、成绩等字段。

李明：是的，以下是成绩录入模块的代码示例：

class Grade(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    student_id = db.Column(db.Integer, db.ForeignKey('student.id'))
    course = db.Column(db.String(100))
    score = db.Column(db.Float)

class GradeResource(Resource):
    def get(self, grade_id=None):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        if grade_id:
            grade = Grade.query.get(grade_id)
            if not grade:
                return {'error': 'Grade not found'}, 404
            return {
                'id': grade.id,
                'student_id': grade.student_id,
                'course': grade.course,
                'score': grade.score
            }
        else:
            grades = Grade.query.all()
            return [{
                'id': g.id,
                'student_id': g.student_id,
                'course': g.course,
                'score': g.score
            } for g in grades]

    def post(self):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        data = request.get_json()
        new_grade = Grade(
            student_id=data['student_id'],
            course=data['course'],
            score=data['score']
        )
        db.session.add(new_grade)
        db.session.commit()
        return {'message': 'Grade added successfully'}, 201

    def put(self, grade_id):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        grade = Grade.query.get(grade_id)
        if not grade:
            return {'error': 'Grade not found'}, 404

        data = request.get_json()
        grade.student_id = data.get('student_id', grade.student_id)
        grade.course = data.get('course', grade.course)
        grade.score = data.get('score', grade.score)

        db.session.commit()
        return {'message': 'Grade updated successfully'}, 200

    def delete(self, grade_id):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        grade = Grade.query.get(grade_id)
        if not grade:
            return {'error': 'Grade not found'}, 404

        db.session.delete(grade)
        db.session.commit()
        return {'message': 'Grade deleted successfully'}, 200

api.add_resource(GradeResource, '/grades', '/grades/')

    

张伟：这段代码实现了成绩录入模块的功能，包括添加、查询、更新和删除成绩记录，同时也进行了权限验证。

李明：接下来我们可以考虑课程安排模块。这个模块需要支持教师发布课程信息，学生选择课程，并显示课程表。

张伟：我们可以设计一个Course模型，包含课程名称、时间、地点、教师等字段。

李明：是的，以下是课程安排模块的代码示例：

class Course(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100))
    time = db.Column(db.String(50))
    location = db.Column(db.String(100))
    teacher = db.Column(db.String(100))

class CourseResource(Resource):
    def get(self, course_id=None):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        if course_id:
            course = Course.query.get(course_id)
            if not course:
                return {'error': 'Course not found'}, 404
            return {
                'id': course.id,
                'name': course.name,
                'time': course.time,
                'location': course.location,
                'teacher': course.teacher
            }
        else:
            courses = Course.query.all()
            return [{
                'id': c.id,
                'name': c.name,
                'time': c.time,
                'location': c.location,
                'teacher': c.teacher
            } for c in courses]

    def post(self):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        data = request.get_json()
        new_course = Course(
            name=data['name'],
            time=data['time'],
            location=data['location'],
            teacher=data['teacher']
        )
        db.session.add(new_course)
        db.session.commit()
        return {'message': 'Course added successfully'}, 201

    def put(self, course_id):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        course = Course.query.get(course_id)
        if not course:
            return {'error': 'Course not found'}, 404

        data = request.get_json()
        course.name = data.get('name', course.name)
        course.time = data.get('time', course.time)
        course.location = data.get('location', course.location)
        course.teacher = data.get('teacher', course.teacher)

        db.session.commit()
        return {'message': 'Course updated successfully'}, 200

    def delete(self, course_id):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        course = Course.query.get(course_id)
        if not course:
            return {'error': 'Course not found'}, 404

        db.session.delete(course)
        db.session.commit()
        return {'message': 'Course deleted successfully'}, 200

api.add_resource(CourseResource, '/courses', '/courses/')

    

张伟：这段代码实现了课程安排模块的功能，包括课程信息的增删改查，同时也加入了权限控制。

李明：最后，我们还需要一个通知公告模块，让管理员可以发布通知，学生可以查看。

张伟：我们可以设计一个Notice模型，包含标题、内容、发布时间等字段。

李明：是的，以下是通知公告模块的代码示例：

class Notice(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100))
    content = db.Column(db.Text)
    date = db.Column(db.DateTime, default=datetime.datetime.utcnow)

class NoticeResource(Resource):
    def get(self, notice_id=None):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        if notice_id:
            notice = Notice.query.get(notice_id)
            if not notice:
                return {'error': 'Notice not found'}, 404
            return {
                'id': notice.id,
                'title': notice.title,
                'content': notice.content,
                'date': notice.date.strftime('%Y-%m-%d %H:%M:%S')
            }
        else:
            notices = Notice.query.order_by(Notice.date.desc()).all()
            return [{
                'id': n.id,
                'title': n.title,
                'content': n.content,
                'date': n.date.strftime('%Y-%m-%d %H:%M:%S')
            } for n in notices]

    def post(self):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        data = request.get_json()
        new_notice = Notice(
            title=data['title'],
            content=data['content']
        )
        db.session.add(new_notice)
        db.session.commit()
        return {'message': 'Notice added successfully'}, 201

    def put(self, notice_id):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        notice = Notice.query.get(notice_id)
        if not notice:
            return {'error': 'Notice not found'}, 404

        data = request.get_json()
        notice.title = data.get('title', notice.title)
        notice.content = data.get('content', notice.content)

        db.session.commit()
        return {'message': 'Notice updated successfully'}, 200

    def delete(self, notice_id):
        token = request.headers.get('Authorization')
        if not token:
            return {'error': 'Missing token'}, 401

        try:
            payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            user = payload['user']
        except:
            return {'error': 'Invalid token'}, 401

        notice = Notice.query.get(notice_id)
        if not notice:
            return {'error': 'Notice not found'}, 404

        db.session.delete(notice)
        db.session.commit()
        return {'message': 'Notice deleted successfully'}, 200

api.add_resource(NoticeResource, '/notices', '/notices/')

    

张伟：这段代码实现了通知公告模块的功能，包括发布公告、查看通知等操作。

李明：至此，我们已经完成了学工管理系统的核心功能模块：学生信息管理、成绩录入、课程安排、通知公告。接下来，我们可以将这些模块整合成一个完整的系统，并部署到服务器上。

张伟：是的，我们可以使用Docker容器化部署，提高系统的可扩展性和维护性。同时，还可以加入日志记录、异常处理等机制，增强系统的健壮性。

李明：没错，整个系统的架构设计也需要合理规划，比如前后端分离、微服务架构等，以适应未来可能的业务扩展。

张伟：感谢你的帮助，李明！这次讨论让我对学工管理系统的功能模块有了更深入的理解。

李明：我也受益匪浅，希望我们的系统能真正帮助工程学院提升管理效率。