学生管理系统基础功能实现

学生管理系统

功能模块分析

客户端功能分析

登录模块

	验证用户名和密码

	完成自动登录效果

数据展示模块

	JSON格式数据解析展示

数据转发模块

	数据发送到服务器

	数据转发到展示模块展示

服务器端功能分析

数据处理模块

	验证用户登录

	完成基本的增删改查操作

	锁操作

数据存储模块

	JSON格式存储和读取去

	数据定时更新

数据传输模块

	发送JSON格式数据到客户端

	接受客户端发送的数据

文件保存路径，这里采用JSON格式数据的存储

package code.studentManage.anno;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author Anonymous
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface FilePathAnnotation {
    /**
     * 保存文件路径对应地址
     *
     * @return String保存文件路径地址
     */
    String filePath();
}

服务器端增删改查，排序和过滤模块，其中封装了获取指定ID下标方法

package code.studentManage.dao;

import code.studentManage.Student;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.function.Predicate;

/**
 * 使用ArrayList存储对应的Student信息，完成CRUD操作
 *
 * @author Anonymous
 */
public class StudentDao {
    /**
     * ArrayList集合保存所有学生的信息
     */
    private ArrayList<Student> allStudents = null;

    /**
     * 保存StudentDao创建的空间首地址
     */
    private static StudentDao studentDao = null;

    /**
     * 私有化构造方法
     */
    private StudentDao() {
        allStudents = new ArrayList<>();
    }

    /**
     * 获取当前StudentDao类对象的静态方法，并加锁
     *
     * @return StudentDao类对象
     */
    public synchronized static StudentDao getInstance() {
        if (null == studentDao) {
            //单例模式引用
            studentDao = new StudentDao();
        }

        return studentDao;
    }

    /**
     * 添加Student类对象到ArrayList中
     *
     * @param student Student类对象
     * @return 成功返回true，否则返回false
     */
    public boolean add(Student student) {
        return allStudents.add(student);
    }

    /**
     * 根据ID删除对应的Student类对象
     *
     * @param id 指定的ID
     * @return 删除成功返回Student类对象，失败返回null
     */
    public Student remove(Integer id) {
        int index = getIndexById(id);

        Student stu = null;

        if (index > -1) {
            stu = allStudents.remove(index);
        }

        return stu;
    }

    /**
     * 根据ID获取对应的Student类对象
     *
     * @param id 指定ID号
     * @return 返回对应Student类对象，如果没有找到，返回null
     */
    public Student getStudentById(Integer id) {
        int index = getIndexById(id);
        Student stu = null;

        if (index > -1) {
            stu = allStudents.get(index);
        }

        return stu;
    }

    /**
     * 修改指定ID的Student类对象
     *
     * @param id      指定的ID号
     * @param student 客户端修改数据之后发送的Student类对象
     */
    public void modifyStudent(Integer id, Student student) {
        int index = getIndexById(id);

        allStudents.set(index, student);
    }

    /**
     * 排序Student数据，返回值是排序完成的Student
     * 数组，并客户端展示
     *
     * @param comparator Comparator函数式接口
     * @return 排序完成的Student数组
     */
    public Student[] sortUsingCompara(Comparator<Student> comparator) {
        Student[] students = new Student[allStudents.size()];

        // 从ArrayList中取出所有的Student对象，保存到Students数组中
        for (int i = 0; i < students.length; i++) {
            students[i] = allStudents.get(i);
        }

        // 调用sort方法排序Student数组，使用Comparator函数式接口
        Arrays.sort(students, comparator);
        return students;
    }

    /**
     * 过滤方法，使用test方法约束过滤条件
     *
     * @param predicate Predicate函数式接口作为过滤条件
     * @return 如果过滤后有结果，返回List集合，
     *         如果没有返回null
     */
    public List<Student> filter(Predicate<Student> predicate) {
        ArrayList<Student> list = new ArrayList<>();

        // 遍历整个ArrayList，过滤条件
        for (Student student : allStudents) {
            // 使用Predicate函数式接口中的test方法，做过滤条件
            if (predicate.test(student)) {
                list.add(student);
            }
        }

        return list.size() > 0 ? list : null;
    }

    /**
     * 获取指定ID对应的下标位置
     *
     * @param id 指定ID号
     * @return 对应当前ID Student类对象所处的下标位置，没有找到返回-1
     */
    private int getIndexById(Integer id) {
        int index = -1;

        for (int i = 0; i < allStudents.size(); i++) {
            if (id.equals(allStudents.get(i).getId())) {
                index = i;
                break;
            }
        }

        return index;
    }

    /**
     * 返回StudentDao中保存的ArrayList对象
     *
     * @return 保存所有Student数据的ArrayList对象
     */
    public ArrayList<Student> getAllStudents() {
        return allStudents;
    }
}

Student实体类，要符合JavaBean规范

package code.studentManage.entity;

/**
 * Student实体类，要求符合JavaBean规范
 *
 * @author Anonymous
 */
public class Student {
    private Integer id;
    private String name;
    private Boolean gender;
    private Integer age;
    private Integer mathScore;
    private Integer chnScore;
    private Integer engScore;
    private Integer totalScore;
    private Integer rank;

    public Student() {
    }

    public Student(Integer id, String name, Boolean gender, Integer age, Integer mathScore, Integer chnScore, Integer engScore, Integer totalScore, Integer rank) {
        this.id = id;
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.mathScore = mathScore;
        this.chnScore = chnScore;
        this.engScore = engScore;
        this.totalScore = totalScore;
        this.rank = rank;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Boolean getGender() {
        return gender;
    }

    public void setGender(Boolean gender) {
        this.gender = gender;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getMathScore() {
        return mathScore;
    }

    public void setMathScore(Integer mathScore) {
        this.mathScore = mathScore;
    }

    public Integer getChnScore() {
        return chnScore;
    }

    public void setChnScore(Integer chnScore) {
        this.chnScore = chnScore;
    }

    public Integer getEngScore() {
        return engScore;
    }

    public void setEngScore(Integer engScore) {
        this.engScore = engScore;
    }

    public Integer getTotalScore() {
        return totalScore;
    }

    public void setTotalScore(Integer totalScore) {
        this.totalScore = totalScore;
    }

    public Integer getRank() {
        return rank;
    }

    public void setRank(Integer rank) {
        this.rank = rank;
    }

    @Override
    public String toString() {
        return "Student{" + "id=" + id + ", name='" + name + '\'' + ", gender=" + gender + ", age=" + age + ", mathScore=" + mathScore + ", chnScore=" + chnScore + ", engScore=" + engScore + ", totalScore=" + totalScore + ", rank=" + rank + '}';
    }
}

测试类

package code.studentManage.systemTest;


import code.studentManage.dao.StudentDao;
import code.studentManage.entity.Student;
import code.studentManage.util.JsonUtil;
import org.junit.Test;

/**
 * @author Anonymous
 */
public class SystemTest {
    @Test
    public void test1() {
        StudentDao dao = StudentDao.getInstance();

        dao.add(new Student(1, "骚磊", false , 16, 100, 100, 100, 300, 1));
        dao.add(new Student(2, "嘉楠", false , 23, 100, 98, 87, 55, 2));

        JsonUtil.saveDataToJsonFile(dao);
    }

    @Test
    public void test2() {
        //获取事件
        StudentDao dao = StudentDao.getInstance();

        JsonUtil.readDataFromJsonFile(dao);

        for (Student student : dao.getAllStudents()) {
            System.out.println(student);
        }
    }
}

代码中存在多出资源关闭操作，为了减少复用度，我们把资源关闭操作写成一个独立的工具类。

package code.studentManage.util;

import java.io.Closeable;
import java.io.IOException;

/**
 * 资源关闭工具类
 *
 * @author Anonymous
 */
public class CloseUtil {

    /**
     * close方法
     *
     * @param res 不定长参数
     */
    public static void closeAll(Closeable... res) {
        for (Closeable re : res) {
            try {
                if (re != null) {
                    re.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

我们用到JSON格式数据的存储方式和读取方式，自然少不了数据类型之间的转换，我们用到的数据类型有List集合，Student类型和JSON类型字符串，我们需要解析JSON文件中的字符串转换成Sutdent类型数据，从ArrayList保存数据到Json文件中，Student类对象转换成Json格式字符串，List集合转换成一个Json格式字符串。

package code.studentManage.util;

import com.alibaba.fastjson.JSON;
import code.studentManage.anno.FilePathAnnotation;

import code.studentManage.dao.StudentDao;
import code.studentManage.entity.Student;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

/**
 * JSON数据格式解析和数据转换操作工具类
 *
 * @author Anonymous
 */
@FilePathAnnotation(filePath = "./data/student.json")
public class JsonUtil {

    /**
     * 保存数据文件的地址
     */
    private static String filePath = null;

    /*
     * 初始化整个程序
     */
    static  {
        // 获取在类名上的注解
        FilePathAnnotation annotation = JsonUtil.class.getAnnotation(FilePathAnnotation.class);

        // 从注解中获取文件保存地址
        filePath = annotation.filePath();
    }

    /**
     * 从ArrayList保存数据到Json文件中
     *
     * @param dao StudentDao类对象
     */
    public static void saveDataToJsonFile(StudentDao dao) {

        ArrayList<Student> allStudents = dao.getAllStudents();
        // ArrayList ==> Json格式字符串
        String jsonString = JSON.toJSONString(allStudents);
        //初始化
        BufferedWriter bw = null;

        try {
            //字符输出缓冲流，设置文件写入的路径
            bw = new BufferedWriter(new FileWriter(filePath));

            bw.write(jsonString);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            CloseUtil.closeAll(bw);
        }
    }

    /**
     * 从Json文件中解析并读取Json格式数据，转换成Student类型，保存到StudentDao
     * 的ArrayList中
     *
     * @param dao StudentDao类对象
     */
    public static void readDataFromJsonFile(StudentDao dao) {
        //初始化
        BufferedReader br = null;

        try {
            //读取路径为filePath
            br = new BufferedReader(new FileReader(filePath));

            // 16KB字符缓冲数组
            char[] buf = new char[1024 * 8];
            int length = -1;

            // StringBuilder字符串缓冲拼接Json格式字符串
            StringBuilder stb = new StringBuilder();

            while ((length = br.read(buf)) != -1) {
                // StringBuilder拼接char类型数组缓冲，同时限制开始和结束
                stb.append(buf, 0, length);
            }

            //获取Json格式字符串
            String jsonString = stb.toString();
            //fastJson解析Json格式字符串，转换成Student类型
            List<Student> list = JSON.parseArray(jsonString, Student.class);

            //从Json文件中读取的List保存到StudentDao的ArrayList中
            dao.getAllStudents().addAll(list);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            CloseUtil.closeAll(br);
        }
    }

    /**
     * Json字符串转换成对应Student类对象
     *
     * @param jsonString Json格式字符串
     * @return Student类对象
     */
    public static Student jsonToStudent(String jsonString) {
        //返回类型为Student
        return JSON.parseObject(jsonString, Student.class);
    }

    /**
     * Student类对象转换成Json格式字符串
     *
     * @param student Student类对象数据
     * @return 符合Json格式的String类型字符串
     */
    public static String studentToJson(Student student) {
        return JSON.toJSONString(student);
    }

    /**
     * Json格式字符串转换成List集合
     *
     * @param jsonString Json格式字符串
     * @return 保存Student类型List集合
     */
    public static List<Student> jsonToStudentList(String jsonString) {
        return JSON.parseArray(jsonString, Student.class);
    }

    /**
     * List集合转换成一个Json格式字符串
     *
     * @param list 保存Student类型的List集合
     * @return Json格式字符串
     */
    public static String studentListToJson(List<Student> list) {
        return JSON.toJSONString(list);
    }
}