利用RPC技术实现一个学生信息管理系统--JAVA实现(demo版)

@小糕糕

已于 2024-06-22 15:42:39 修改

阅读量621

点赞数 21

文章标签： rpc 网络协议网络 java ide

于 2024-04-08 20:33:39 首次发布

本文链接：https://blog.csdn.net/Ga526424/article/details/137521727

版权

RPC概述

RPC（Remote Procedure Call）是一种使得程序能够在网络上的另一台计算机上执行代码的技术。以下是RPC技术的一些关键点：

1. 通信协议：RPC作为一种通信协议，允许程序调用在不同地址空间的函数或过程，通常这些地址空间位于其他主机上。这意味着可以像调用本地函数一样调用远程服务，大大简化了分布式系统中的通信问题。
2. 工作原理：当客户端需要进行远程调用时，它会将调用的参数序列化成字节流，通过网络发送到服务端。服务端接收到数据后反序列化，执行相应的方法，并把结果序列化后返回给客户端。客户端收到结果后进行反序列化，得到最终的结果。
3. 技术框架：RPC不是一个具体的规范或协议，而是一种思想，有多种不同的实现方式和技术框架。常见的RPC框架包括阿里巴巴的Dubbo、Google的gRPC、Facebook的Thrift等。这些框架提供了构建分布式系统的通信能力。
4. 应用场景：RPC在分布式系统架构中的应用场景非常广泛，可以实现不同系统间的远程通信和相互调用。例如，可以用于微服务之间的通信、跨平台的数据传输等场合。
5. 通信方式：RPC支持同步和异步通信方式。同步RPC指客户端等待服务端响应后再继续执行，而异步RPC则不等待响应，可以继续执行其他操作。
6. 远程通信协议：RPC可以使用多种通信协议，如HTTP(REST, SOAP)、TCP等，并且可以借助高性能网络框架如Mina、Netty来提高通信效率。

RPC技术为现代分布式计算环境提供了强大的远程调用能力，它通过隐藏网络细节，使得程序员能够专注于业务逻辑，而不是底层的网络通信问题。

本文实现简单的RPC功能，即客户端实现用户交互，服务器端实现学生信息存储和管理，客户端与服务器端利用RPC机制进行协作。

Java程序实现

共有方法

先要创建俩个maven项目，共有方法是客户端与服务端中都要创建的.java文件！

1.Student类

import java.io.Serializable;

public class Student implements Serializable {
    private int studentID;
    private String name;
    private String major;

    // 构造函数
    public Student(int studentID, String name, String major) {
        this.studentID = studentID;
        this.name = name;
        this.major = major;
    }

    // 获取学生ID
    public int getStudentID() {
        return studentID;
    }

    // 设置学生ID
    public void setStudentID(int studentID) {
        this.studentID = studentID;
    }

    // 获取学生姓名
    public String getName() {
        return name;
    }

    // 设置学生姓名
    public void setName(String name) {
        this.name = name;
    }

    // 获取专业信息
    public String getMajor() {
        return major;
    }

    // 设置专业信息
    public void setMajor(String major) {
        this.major = major;
    }

    @Override
    public String toString() {
        return "Student{" +
                "studentID=" + studentID +
                ", name='" + name + '\'' +
                ", major='" + major + '\'' +
                '}';
    }
}

2.StudentService接口


import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.List;

public interface StudentService extends Remote {
    boolean add(Student student) throws RemoteException;
    Student queryByID(int studentID) throws RemoteException;
    List<Student> queryByName(String name) throws RemoteException;
    boolean delete(int studentID) throws RemoteException;
    List<Student> allStudents() throws RemoteException;

}

服务端程序

程序说明

这是一个学生信息管理系统服务端程序，主要包括以下几个部分：

Student类：表示学生的基本属性，如学号、姓名、专业等。
StudentList类：表示学生信息表，用于存储和管理多个Student对象。
StudentService接口：定义了对学生信息进行操作的对外接口，如添加学生、删除学生、查询学生信息等。
StudentServiceImpl类：实现了StudentService接口，提供了具体的操作方法。
StudentServer类：服务器端程序，用于启动和管理整个系统。

要运行这个程序，只需直接编译并运行StudentServer类即可启动服务器端程序。

1.StudentServiceImpl实现接口

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.List;

public class StudentServiceImpl extends UnicastRemoteObject implements StudentService {
    private StudentList studentList;

    protected StudentServiceImpl(StudentList students) throws RemoteException {
        super();
        this.studentList = students;
    }

    @Override
    public boolean add(Student student) throws RemoteException {
        if (studentList.queryByID(student.getStudentID()) == null) {
            studentList.addStudent(student);
            return true;
        }
        return false;
    }

    @Override
    public Student queryByID(int studentID) throws RemoteException {
        return studentList.queryByID(studentID);
    }

    @Override
    public List<Student> queryByName(String name) throws RemoteException {
        return studentList.queryByName(name);
    }

    @Override
    public boolean delete(int studentID) throws RemoteException {
        return studentList.delete(studentID);
    }

    @Override
    public List<Student> allStudents() throws RemoteException {
        return studentList.allStudents();
    }
}

2.StudentList学生信息表

import java.io.Serializable;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.ArrayList;
import java.util.List;

public class StudentList extends UnicastRemoteObject implements Serializable {
    private List<Student> students;

    public StudentList () throws RemoteException {
        super();
        this.students = new ArrayList<>();
    }

    public void addStudent(Student student) {
        this.students.add(student);
    }

    public List<Student> allStudents() {
        return this.students;
    }

    public Student queryByID(int studentID) {
        for (Student student : students) {
            if (student.getStudentID() == studentID) {
                return student;
            }
        }
        return null;
    }

    public List<Student> queryByName(String name) throws RemoteException {
        List<Student> result = new ArrayList<>();
        for (Student student : students) {
            if (student.getName().equals(name)) {
                result.add(student);
            }
        }
        return result;
    }

    public boolean delete(int studentID) {
        return this.students.removeIf(student -> student.getStudentID() == studentID);
    }

}

3.StudentServer服务端主程序

import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class StudentServer {

    public static void main(String[] args) {
        try {
            String name = "StudentService";
            StudentList studentList = new StudentList();
            StudentService stub = new StudentServiceImpl(studentList);

            // 绑定RMI注册表
            Registry registry = LocateRegistry.createRegistry(1099);
            registry.bind(name, stub);

            System.out.println("服务已启动！");
        } catch (Exception e) {
            System.err.println("服务启动异常：" + e);
            e.printStackTrace();
        }
    }
}

客户端程序

程序说明

这是一个学生信息管理系统客户端程序，主要包括以下几个部分：

1. Student类：表示学生的基本属性，如学号、姓名、专业等。
2. StudentService接口：定义了对学生信息进行操作的对外接口，如添加学生、删除学生、查询学生信息等。
3. StudentClient类：客户端启动程序，用于与服务器端进行通信，实现对学生信息的增删改查等操作。

要运行这个程序，首先需要启动服务器端程序（StudentServer），然后通过客户端程序（StudentClient）与服务器端进行通信，实现对学生信息的管理和操作。

StudentClient客户端交互主程序

import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.List;
import java.util.Scanner;

public class StudentClient {

    public static void main(String[] args) throws RemoteException, NotBoundException {
        String name = "StudentService";
        String serverIP = "127.0.0.1";
        int serverPort = 1099;
        Registry registry = LocateRegistry.getRegistry(serverIP, serverPort); // 获取注册中心的引用
        StudentService proxy = (StudentService) registry.lookup(name);
        Scanner scanner = new Scanner(System.in);
        int option, studentID;
        String studentName, major;
        Student student;

        System.out.println("1.添加学生信息\n2.按学号删除学生信息\n3.按学号查询学生信息\n4.按姓名查询学生信息\n5.显示所有学生信息\n6.退出");
        while (true) {
            System.out.print("------------\n请输入选项：");
            option = scanner.nextInt();

            switch (option) {
                case 1:
                    System.out.print("输入学号、姓名、专业：");
                    studentID = scanner.nextInt();
                    studentName = scanner.next();
                    major = scanner.next();
                    student = new Student(studentID, studentName, major);
                    if (proxy.add(student)) {
                        System.out.println("添加成功");
                    } else {
                        System.out.println("学生已存在");
                    }
                    break;
                case 2:
                    System.out.print("输入学号：");
                    studentID = scanner.nextInt();
                    if (proxy.delete(studentID)) {
                        System.out.println("删除成功");
                    } else {
                        System.out.println("找不到该学生");
                    }
                    break;
                case 3:
                    System.out.print("输入学号：");
                    studentID = scanner.nextInt();
                    student = proxy.queryByID(studentID);
                    if (student != null) {
                        System.out.println("学号：" + student.getStudentID() + " 姓名：" + student.getName() + " 专业：" + student.getMajor());
                    } else {
                        System.out.println("找不到该学生");
                    }
                    break;
                case 4:
                    System.out.print("输入姓名：");
                    studentName = scanner.next();
                    List<Student> res = (List<Student>) proxy.queryByName(studentName);
                    if (res != null && !res.isEmpty()) {
                        for (Student s : res) {
                            System.out.println("学号：" + s.getStudentID() + " 姓名：" + s.getName() + " 专业：" + s.getMajor());
                        }
                    } else {
                        System.out.println("找不到该学生");
                    }
                    break;
                case 5:
                    List<Student> result = (List<Student>) proxy.allStudents();
                    if (result != null && !result.isEmpty()) {
                        for (Student s : result) {
                            System.out.println("学号：" + s.getStudentID() + " 姓名：" + s.getName() + " 专业：" + s.getMajor());
                        }
                    } else {
                        System.out.println("学生表为空");
                    }
                    break;
                case 6:
                    System.out.println("退出程序");
                    scanner.close();
                    return;
                default:
                    System.out.println("无效选项，请重新输入！");
                    break;
            }
        }
    }

}