Class management system based on Spring Boot
Summary
The rapid development of scientific and technological progress has caused great changes in people's daily life, and the rapid development of electronic information technology has made the application level of electronic information technology in various fields popularized and applied. The arrival of the information age has become an irresistible fashion trend, and the history of human development is entering a new era. In actual application, the working rules and development steps of the application software are used to build a class management system using Java technology.
This design mainly realizes the class management system integrating the advantages of humanization, high efficiency, and convenience, and completes functions such as user management, course information, course classification, student selection, course tasks, completion records, online examinations, examination records, and examination results. module. The system communicates with the server through the browser to realize data interaction and change. The system improves work efficiency and reduces errors and omissions in data storage through scientific management methods and convenient services. The class management system uses the Java language and is developed using the springboot technology based on the MVVM model. In terms of data, it mainly uses Microsoft's MySQL relational database as the data storage medium, and cooperates with the front-end HTML+CSS technology to complete the system development.
Keywords: class management; Java language; relational database; data storage
Class management system based on spring boot
Abstract
The rapid development of scientific and technological progress has caused great changes in people's daily life. The rapid development of electronic information technology has popularized and applied the application level of electronic information technology in various fields. The advent of the information age has become an irresistible fashion trend, and the history of human development is entering a new era. In practical application, according to the working rules and development steps of the application software, Java technology is used to build the class management system.
This design mainly realizes the class management system with the advantages of humanization, high efficiency and convenience, and completes the functional modules such as user management, course information, course classification, student course selection, course task, completion record, online examination, examination record, examination score and so on. The system communicates with the server through the browser to realize the interaction and change of data. Through scientific management and convenient service, the system improves work efficiency and reduces errors and omissions in data storage. The class management system uses Java language and springboot technology based on MVVM mode for development. In terms of data, Microsoft's MySQL relational database is mainly used as the data storage medium, and the system development is completed with the foreground HTML + CSS technology.
Key words: Class management; Java language; Relational database; data storage
Table of contents
1.2 Purpose and Significance of the Research 1
1.3 Organizational structure of this paper 2
Chapter 2 Introduction to Related Technologies 3
2.6 Main functions of Vue.js 4
3.1.1 Technical Feasibility Analysis 6
3.1.2 Economic feasibility analysis 6
3.1.3 Operation Feasibility Analysis 6
3.2 Analysis of functional requirements 6
3.3 Analysis of non-functional requirements 9
4.1 System Architecture Design 11
4.2 System function structure 11
4.3 Functional module design 12
Chapter 5 System Implementation 2 1
5.1 Implementation of login module 2 1
5.2 Implementation of User Subsystem Module 22
5.2.1 User home page module 22
5.2.3 Course information module 24
5.2.4 Student Course Selection Module 25
5.3 Implementation of the Administrator Subsystem Module 26
5.3.1 Student Management Module 26
5.3.2 Online Exam Management Module 2 9
5.3.3 Exam Results Management Module 3 2
Chapter 7 Summary and Outlook 3 6
Thanks 3 9
The class management system is an innovation of computer application technology that uses computers to manage class information. Before computers were popularized, class management was carried out by teachers and class cadres. Now most schools have adopted information management. The way is to use the computer as a practical computer class information management program to help the class teacher to manage the class more effectively. The class information management system is a typical information management system (MIS), and its development mainly includes the establishment and maintenance of the background database and the development of the front-end application program. For the former, it is required to establish a library with strong data consistency and integrity and good data security. For the latter, the application program is required to be fully functional and easy to use.
-
- Purpose and Significance of the Research
With the further implementation of the college enrollment expansion plan, the scale of the university is getting bigger and bigger, there are more and more classes, and the affairs management is becoming more and more complicated. This requires a class management system, and we can get some relevant information about the class at any time, such as: class Inquiry and analysis of members' individual conditions (examination results, course selection, etc.), query and analysis of class collective conditions (overall score analysis). In addition, the system has an administrator, who manages the overall situation of the class in a unified manner, and can authorize the students in the class (that is, ordinary users), withdraw permissions, and add, delete, and modify related information.
Finally, we also need to consider the comprehensive management and maintenance of the database, mainly including the backup of the database, the recovery of the database, data security and the operation of viewing the database log. The class management system is a software system developed to facilitate class committees to manage student performance. This software brings the management of academic performance into a kind of computerized era. In order to facilitate students to query their own information, improve work efficiency, update students' latest information in a timely and effective manner, and provide reliable data archives. The homework required by the teacher consolidates and improves the students' knowledge of software engineering.
Our life should be in the era of informationization, it should be the era of electronicization. Students create a management system document, which can facilitate students to understand more about the management system that should be developed and applied in modern society, and better exercise We become good managers ourselves.
After each semester is completed, students no longer have to worry about checking their semester grades. They only need to enter their own class management system and log in with their student ID to easily check their final grades and understand their daily learning status. Improve and regulate yourself better. The background of the topic of class management system in this paper is the trend of education informatization and the construction of education informatization system in colleges and universities in my country. Insufficient manual management. Compared with the traditional management mode, online management has infiltrated more technical links, and it also puts forward higher technical requirements for the ways and methods to realize security. Realizing online management through Internet/Intranet is a concrete realization of modern educational technology and has very important practical significance.
At present, the technology for web application system development is developing rapidly, and new technologies are constantly emerging. How to design a class management system, what technology to use to realize the class management system, and improve the processing ability of the system have become a problem worth pondering. On the server side, the technologies currently being widely used include CGI, ASP, PHP, JSP, Java Servlet, etc.; while on the client side, they include VBScript, JavaScript, Java Applet, etc. These technologies provide a solid foundation for the development of Web application systems. Generally speaking, these technologies have their own advantages in terms of development efficiency, operating speed, distributed transaction processing, and scalability, which requires developers to choose flexibly according to specific requirements during the development process. In general, an actual web application system is jointly developed by multiple developers using different technologies according to their respective tasks. However, in the development process of many actual projects at present, due to the lack of a standardized programming development model and the lack of sufficient communication between developers of various parts, there is a situation of mutual influence and mutual restriction, resulting in system development, integration and maintenance. rising costs. Therefore, it is particularly important to introduce a standard, reasonable and effective development model for the development of Web application systems. The MVC (Model View Controller) mode, with its advantages of separating the model from the display and controlling the process by the controller, meets the basic requirements of the current web application system development, and has gradually become the mainstream mode for developing web application systems.
In response to the above problems, "component-based software development", which integrates software reuse, distributed object computing, and enterprise-level application development, has emerged as the times require. This technology uses software frameworks as assembly blueprints and reusable software components In order to assemble modules, it supports the reuse of assembled software, which greatly improves the software production efficiency and software quality. Research on this technology at home and abroad is deepening. Large software companies (such as Sun, Microsoft) and software organizations (OMG) have launched platform specifications that support distributed computing. At the same time, people are increasingly aware of the important role of the reusable design idea of design patterns in the software design process. Various distributed computing platforms not only use a lot of design patterns, but also give rise to many design patterns for building application systems based on specific platforms.
In the early stage of Web application development, due to the relative lack of optional development technologies, people build corresponding Web application models more from the perspective of methodology and software engineering. In the subsequent development, the abstraction and reuse mechanism in Web applications were further proposed. All of these have made great contributions to Web application research, providing an abstract conceptual model for Web application development. However, with the development of network technology and the continuous emergence of new technologies, there is a need for an effective design and development model guidance The development of Web applications can also meet the needs of enterprise applications with changing business requirements, so that the enterprise Web application system has good scalability, scalability and security.
-
- Organization of this article
The first chapter is the introduction, the beginning of this article, some textual descriptions of the research background and research significance of this topic.
The second chapter studies the development techniques and development tools adopted by the class management system.
The third chapter is the system analysis part, including the description of the overall requirements of the system, the analysis of system requirements from a functional point of view, and the non-functional analysis of whether the system can be realized.
The fourth chapter is the system design part, an important part of this article, which provides the detailed design of the system architecture and the design description of some main functional modules.
The fifth chapter is the specific realization of the system, introducing the specific realization of each module of the system.
The sixth chapter tests and runs the system on the basis of the previous chapters.
Finally, the system is seriously summarized, so as to have a new prospect for the future.
The JAVA language is currently the most widely used language development program in the software market. It can be used on a variety of platforms, has strong compatibility, adapts to most operating systems on the market, does not appear garbled characters, has better scalability and maintainability, and has the ability to analyze and solve problems. Process-oriented programming allows us to write more robust code.
Compared with other languages, JAVA is relatively simple, more convenient to compile, and has high security and reliability. According to incomplete statistics, there are more than 20 million people in the world using it. JAVA can be used both inlaid and independently. JAVA can be roughly divided into two parts, one part is the compilation that JAVA is responsible for, and the other is the operation that JAVA is responsible for. JAVA is very similar to C++ language, but JAVA is compiled in an object-oriented way when programming, so that the compiled software can be used on a stand-alone computer or on the Internet, and it is more convenient to check for errors. The distributed and architecture-neutral characteristics of JAVA also make its storage faster and programming simpler. Object-oriented includes four characteristics, one is encapsulation, which means that certain functions and attributes can be realized when defining a class. The second is abstraction, which is a kind of class. It can encapsulate a class with common attributes in an abstraction, which is convenient for simple compilation. The third is inheritance, as the name implies, it has the characteristics of the former. Another feature is polymorphism, which can be used in multiple ways, which shows that it has good scalability.
-
- MVVM pattern
MVVM is shorthand for Model-View-ViewModel. It's essentially an improved version of MVC. MVVM is to abstract the state and behavior of the View in it, and let us separate the view UI from the business logic. Of course, ViewModel has already done these things for us. It can take out the data of Model and help deal with the business logic involved in View because of the need to display content. Microsoft's WPF brings new technical experience, such as Silverlight, audio , video , 3D , animation ..., which leads to more detailed and customizable software UI layer. At the same time, at the technical level, WPF also brings new features such as Binding, Dependency Property, Routed Events, Command, DataTemplate, and ControlTemplate. The origin of the MVVM (Model-View-ViewModel) framework is a new type of architectural framework developed and evolved from the application of the MVP (Model-View-Presenter) pattern combined with WPF . It is based on the original MVP framework and incorporates the new features of WPF to cope with the increasingly complex needs of customers.
-
- MySQL database
The advancement of science and technology has brought many conveniences to daily life: classroom projectors use virtual imaging technology, digital cameras use photoelectric detection technology, for example, the records of goods entering and leaving warehouses in supermarkets require an information warehouse. This information warehouse is the database, and this class management system also needs the support of this technology [7].
The reason for using the MySQL software is that it can be accessed by multiple users, and there are Archives, etc. in it. It will classify the data first, and then store them in tables separately. Such special operations will improve the speed of the data management system itself, allowing the database to be used flexibly. The code of MySQL is public, and allows others to compile and upgrade it twice. This feature can reduce the cost of users, and form a good website system after matching with suitable software. Although it has disadvantages, in all aspects, it is the mainstream application of users [8].
B/S (Browser/Server) is a more convenient architecture than its predecessor architecture. It uses the Web server to complete the data transfer and exchange. You only need to download the browser as the client, then the work will achieve the effect of "slimming", and there is no need to consider the problem of non-stop installation of software [9].
The Spring framework is an open source application framework on the Java platform that provides a container with inversion of control features. Although the Spring framework itself has no restrictions on the programming model, its frequent use in Java applications made it so popular that it was later used as a supplement or even a substitute for the EJB (EnterpriseJavaBeans) model. The Spring framework provides a series of solutions for development, such as using the core features of inversion of control, and implementing inversion of control through dependency injection to realize the containerization of the management object life cycle, using aspect-oriented programming for declarative transaction management, and integrating A variety of persistence technologies manage data access, provide a large number of excellent web frameworks to facilitate development, and so on. The Spring framework has the feature of inversion of control (IOC). IOC is designed to facilitate project maintenance and testing. It provides a method for unified configuration and management of Java objects through the Java reflection mechanism. The Spring framework uses the container to manage the life cycle of objects. The container can configure objects by scanning XML files or specific Java annotations on classes. Developers can obtain objects through dependency lookup or dependency injection. Aspect Oriented Programming(AOP) framework, the Spring AOP framework is based on the proxy mode, and can be configured at runtime; the AOP framework is mainly modularized for the cross concerns between modules. The AOP framework of the Spring framework only provides basic AOP features. Although it cannot be compared with the AspectJ framework, it can also meet the basic needs through integration with AspectJ. Functions such as transaction management and remote access under the Spring framework can be realized by using Spring AOP technology. Spring's transaction management framework brings an abstraction mechanism to the Java platform that enables local and global transactions, as well as nested transactions, to work with savepoints and in almost any environment on the Java platform. Spring integrates multiple transaction templates. The system can configure transactions through transaction templates, XML or Java annotations, and the transaction framework integrates functions such as messaging and caching. Spring's data access framework addresses common difficulties developers encounter when using databases in their applications. It not only provides support for all popular data access frameworks such as Java: JDBC, iBATS/MyBATIs, Hibernate, Java Data Objects (JDO), ApacheOJB and Apache Cayne, but also can be used with Spring's transaction management to provide data access Flexible abstraction. The Spring framework initially did not intend to build its own Web MVC framework . During the development process, its developers believed that the separation between the presentation layer and the request processing layer of the existing Struts Web framework and between the request processing layer and the model was not enough, so they created Spring MVC.
2.6 Main functions of Vue.js
Vue.js is a progressive framework for building user interfaces. Unlike other heavyweight frameworks, Vue is designed with bottom-up incremental development. Vue's core library only focuses on the view layer, and is very easy to learn and integrate with other libraries or existing projects. On the other hand, Vue is fully capable of driving complex single-page applications developed with single-file components and libraries supported by the Vue ecosystem.
The goal of Vue.js is to enable responsive data binding and composed view components with the simplest API possible .
Vue.js itself is not a catch-all framework - it only focuses on the view layer. So it's very easy to learn, very easy to integrate with other libraries or existing projects. On the other hand, Vue.js can also power complex single-page applications when used with related tooling and supporting libraries.
This design is based on the B/S mode, and the Java technology is used to implement the MySQL database. The overall feasibility is divided into the following three aspects.
The so-called technical feasibility refers to whether the functions planned in the early stage can be satisfied within a limited time. Whether there will be problems that cannot be solved in the development and design. Whether the completed project can be well applied, if there are shortcomings, whether there is great difficulty in later maintenance. After evaluating the system, it was determined that existing technology could achieve the goals. Using Java technology to realize dynamic pages, embedding low-dependency design patterns, flexible databases, and stable servers, the operating efficiency of the entire system is greatly improved. It can be seen that achieving the goal at the technical level is not a nonsense.
Most of the tools used in the project are currently popular open source and free, so in the early stage of development, the funds used for the project will be greatly reduced, and the development of the software will not be affected by the funds during the project start-up period, so It is still economically feasible. Try to use the least cost to meet the needs of users. Save funds for labor costs and equipment costs. It will go further and further on the road of paperless and high efficiency.
The operation of this system to realize the function is very simple. The common configuration of ordinary computers can run this software, and as long as you have a rough understanding of the basic common sense of computer use, you can use this software smoothly. The computer has the ability to connect to the Internet and can access the system normally. It does not require the operator to have any superb ability. It only needs to understand the business process and operate correctly according to professional knowledge. Therefore, the class management system is feasible to operate.
Before system development and design, you should make a preliminary idea of the functions, know what sections the management system has, what functions each section has, whether the overall design meets the needs of users, and then conduct a detailed analysis and summary of the developed system functions , so as to design a complete system and implement it. Communication analysis of users and developers to achieve the best understanding and make the system function to the best.
The student use case diagram is shown below.
Uploading... Reupload Cancel
Figure 3-1 Student use case diagram
The administrator use case diagram is shown below.
Uploading... Reupload Cancel
Figure 3-2 Administrator use case diagram
The teacher use case diagram is shown below.
Uploading... Reupload Cancel
Figure 3-3 Teacher use case diagram
Class management system After analyzing the requirements, the whole system is mainly divided into two parts: administrators, students, and teachers. The branch functions of each module are different. Describe the function as follows:
Student Module:
Account login authentication.
Manage profile information, modify modifiable information items.
Course information, and at the same time view the history of published course information records.
Inquiry about student course selection, and at the same time view the history of published course selection records.
Teacher Module:
Account login authentication.
Manage profile information, modify modifiable information items.
Record test scores, and check the records of historical scores at the same time.
Inquiry about personal courses, and view the course records assigned to you.
Review of student course selection and review of student course selection.
Admin module:
Maintain students, review student accounts, freeze student login permissions, or delete student accounts.
Publish course information, and can destroy a course, update course data, fuzzy search course data, etc.
Manage online exam data.
Maintain student course selection information data.
View the course task data released by the teacher, and the administrator has the right to maintain it.
There are many non-functional requirements of the system, such as performance requirements, maximum number of users that can be carried, stability, and usability requirements. The analysis of this system takes into account the requirement of ease of use, because the system is used by people, so it is necessary to fully consider the user experience from the user's point of view, so that the system is easy to understand, easy to use and easy to operate.
The first-level data flow chart includes modules such as login, user function, and retrieval maintenance. The data used in the login module stores user account documents, and the storage required by the user function module is the data file of each user function module. The retrieval maintenance uses the above Data documents are retrieved by keywords.
The layer-by-layer data flow diagram of the system is shown in the figure below.
Uploading... Reupload Cancel
Figure 3-2 System data flow diagram (one layer)
The second-tier data flow is the refinement of filling in login information and user functions in the first-tier data flow diagram. That is: fill in the login information and refine it into filling information and background review, and user functions are refined into operations such as notification query, student course selection, course information, online examination, test results, and teachers.
The layer 2 data flow diagram of the system is shown in the figure below.
Uploading... Reupload Cancel
Figure 3-4 System data flow diagram (second floor)
At present, the main data access method of the B/S system is: the user can enter the system through the browser page, and the system can automatically process the request sent by the user to the server. The processing request is carried out in the background of the system. Perform corresponding operations on the page, and you can see the processing results delivered by the server. The class management system is mainly divided into view-model-control three-tier architecture design. In the view layer, it mainly operates the data fed back and displayed from the server to the client. In the model layer, it mainly deals with related business logic, data integration, etc., and the final control layer is between the view and the model. It is to adjust the relationship between the two layers and finally implement the data transmission.
The system architecture diagram is shown in the figure below.
Uploading... Reupload Cancel
Figure 4-1 System architecture diagram
The purpose of system design is to analyze all the functional structures included in the system, and make preparations for developers to design, develop and implement the system. After the preliminary demand investigation, analysis and sorting, the determined overall demand mainly includes multiple modules, namely: user management, course information, course classification, student selection, course tasks, completion records, online examinations, examination records, examination results . The overall role of the system is divided into three parts, one is the teacher, the other is the student, and the last is the administrator. The authority distribution is also obvious. In addition to browsing information, students also have the authority to query and manage their own account information, notification inquiries, course information, student selection, course tasks, completion records, online exams, and exam records; the administrator is the highest authority. permission holder.
The functional structure diagram of the system is shown in the figure below.
Uploading...Re-upload to cancel Figure 4-2 System function structure diagram
User Management Module
This module is designed for all users to log in. For example, students can only perform their own common function operations (such as personal information modification) after logging in. Administrators and super administrators have different permissions after logging in, and administrators cannot exceed permissions. The super administrator can manage the data of the entire system, mainly the user's login authority and the user's operation authority in the system after login.
Publish Course Information Module
There is a publishing relationship between teachers and courses, and the relationship is one-to-many. According to the course industry number, the course data is transferred to the publishing data, the operator is the teacher, and then the publishing list is generated. The teacher can view the personal historical publishing list and destroy the data.
Course Maintenance Module
The teacher enters the course data, clicks the course entry button, fills in the course data to be entered in turn, clicks the submit button, submits the data to the database, and then refreshes the course data page, and there are delete and edit buttons on the right of each data to complete the corresponding deletion and update functions.
Course Information Information Module
There is an arrangement relationship between teachers and students, and the relationship is one-to-many. According to the assignment number, the assignment data is transferred to the release data. The operator is the teacher, and then generates a release list. The teacher can view the personal historical release list and destroy the data.
Exam Results Module
There is a grade relationship between students and course selection, and the relationship is one-to-many. According to the course selection number, the course selection data is transferred to the grade data. The operator is the student, and then a grade list is generated. The student can view the personal historical grade list and destroy the data.
For a system to be developed, ER diagrams allow others to understand the transactions of the system and the relationships between them faster and easier. According to the conclusions drawn in the system analysis stage, it is determined that there are multiple entities in the class management system, which are students, administrators, teachers, student selection, course information, course tasks, completion records, examination records, and online examinations.
The overall ER diagram of the system is shown in the figure below.
Uploading... Reupload Cancel
Figure 4-4 System overall ER diagram
Admin ( admin id , username, password, permissions)
Student ( student id , student name, student gender, student number)
Student selection ( student selection id , course number, course name, course type, teacher, student information, student name, student number, teacher review, teacher reply)
Online exam ( online exam id , title name, course name, instructor, exam document, exam notes)
Teacher ( teacher id , teacher name, teacher gender, teacher job number, teacher title, user id)
Exam records ( examination record id , title name, course name, lecturer, student information, student name, answer document, test score)
Course tasks ( course task id , title name, course name, instructor, release time, task content, task requirements)
Course information ( course information id , course number, course name, course type, course picture, teacher, course introduction, remark information)
Completion record ( completion record id , title name, course name, teacher, student information, student name, student number, completion content)
The logical structure of the database is to describe the ER diagram in the database with specific fields. Use fields and data type descriptions to materialize object characteristics, and finally form a database table structure with certain logical relationships. Part of the data structure table required by the class management system is shown in the table below.
teacher_user table:
| type |
length |
not null |
primary key |
note |
|
| teacher_user_id |
int |
11 |
yes |
yes |
Teacher User ID |
| teacher_name |
varchar |
64 |
no |
no |
teacher name |
| teacher_gender |
varchar |
64 |
no |
no |
teacher sex |
| teacher_job_number |
varchar |
64 |
yes |
no |
Teacher ID |
| teacher_title |
varchar |
64 |
no |
no |
Teacher title |
| examine_state |
varchar |
16 |
yes |
no |
Approval Status |
| recommend |
int |
11 |
yes |
no |
Intelligent Recommendation |
| user_id |
int |
11 |
yes |
no |
User ID |
| create_time |
datetime |
0 |
yes |
no |
creation time |
| update_time |
timestamp |
0 |
yes |
no |
update time |
| online_examination table: |
|||||
| name |
type |
length |
not null |
primary key |
note |
| online_examination_id |
int |
11 |
yes |
yes |
Online Exam ID |
| title_name |
varchar |
64 |
no |
no |
title name |
| course_name |
varchar |
64 |
no |
no |
Course Title |
| instructor |
int |
11 |
no |
no |
teacher |
| examination_documents |
varchar |
255 |
no |
no |
Exam Documentation |
| exam_notes |
text |
0 |
no |
no |
Exam Remarks |
| recommend |
int |
11 |
yes |
no |
Intelligent Recommendation |
| create_time |
datetime |
0 |
yes |
no |
creation time |
| update_time |
timestamp |
0 |
yes |
no |
update time |
| examination_record table: |
|||||
| name |
type |
length |
not null |
primary key |
note |
| examination_record_id |
int |
11 |
yes |
yes |
Exam Record ID |
| title_name |
varchar |
64 |
no |
no |
title name |
| course_name |
varchar |
64 |
no |
no |
Course Title |
| instructor |
int |
11 |
no |
no |
teacher |
| student_information |
int |
11 |
no |
no |
student information |
| student_name |
varchar |
64 |
no |
no |
student name |
| student_number |
varchar |
64 |
no |
no |
student number |
| answer_document |
varchar |
255 |
no |
no |
Answer document |
| examination_results |
varchar |
64 |
no |
no |
test scores |
| recommend |
int |
11 |
yes |
no |
Intelligent Recommendation |
| create_time |
datetime |
0 |
yes |
no |
creation time |
| update_time |
timestamp |
0 |
yes |
no |
update time |
| course_task table: |
|||||
| name |
type |
length |
not null |
primary key |
note |
| course_task_id |
int |
11 |
yes |
yes |
Course Task ID |
| title_name |
varchar |
64 |
no |
no |
title name |
| course_name |
varchar |
64 |
no |
no |
Course Title |
| instructor |
int |
11 |
no |
no |
teacher |
| release_time |
date |
0 |
no |
no |
release time |
| task_content |
text |
0 |
no |
no |
task content |
| task_requirements |
text |
0 |
no |
no |
mission requirements |
| recommend |
int |
11 |
yes |
no |
Intelligent Recommendation |
| create_time |
datetime |
0 |
yes |
no |
creation time |
| update_time |
timestamp |
0 |
yes |
no |
update time |
| course_information table: |
|||||
| name |
type |
length |
not null |
primary key |
note |
| course_information_id |
int |
11 |
yes |
yes |
Course Information ID |
| course_number |
varchar |
64 |
yes |
no |
Course No |
| course_name |
varchar |
64 |
no |
no |
Course Title |
| course_type |
varchar |
64 |
no |
no |
Course type |
| course_pictures |
varchar |
255 |
no |
no |
course picture |
| instructor |
int |
11 |
no |
no |
teacher |
| course_introduction |
text |
0 |
no |
no |
Course Introduction |
| remark_information |
text |
0 |
no |
no |
Remarks |
| recommend |
int |
11 |
yes |
no |
Intelligent Recommendation |
| create_time |
datetime |
0 |
yes |
no |
creation time |
| update_time |
timestamp |
0 |
yes |
no |
update time |
| completion_record table: |
|||||
| name |
type |
length |
not null |
primary key |
note |
| completion_record_id |
int |
11 |
yes |
yes |
Completion Record ID |
| title_name |
varchar |
64 |
no |
no |
title name |
| course_name |
varchar |
64 |
no |
no |
Course Title |
| instructor |
int |
11 |
no |
no |
teacher |
| student_information |
int |
11 |
no |
no |
student information |
| student_name |
varchar |
64 |
no |
no |
student name |
| student_number |
varchar |
64 |
no |
no |
student number |
| complete_content |
text |
0 |
no |
no |
complete content |
| recommend |
int |
11 |
yes |
no |
Intelligent Recommendation |
| create_time |
datetime |
0 |
yes |
no |
creation time |
| update_time |
timestamp |
0 |
yes |
no |
update time |
| student_user table: |
|||||
| name |
type |
length |
not null |
primary key |
note |
| student_user_id |
int |
11 |
yes |
yes |
Student User ID |
| student_name |
varchar |
64 |
no |
no |
student name |
| student_gender |
varchar |
64 |
no |
no |
student gender |
| student_number |
varchar |
64 |
yes |
no |
student number |
| examine_state |
varchar |
16 |
yes |
no |
Approval Status |
| recommend |
int |
11 |
yes |
no |
Intelligent Recommendation |
| user_id |
int |
11 |
yes |
no |
User ID |
| create_time |
datetime |
0 |
yes |
no |
creation time |
| update_time |
timestamp |
0 |
yes |
no |
update time |
The login window of the system is the user's entrance, and the user can enter and visit only after the login is successful. By submitting the form at login, the background process judges whether it is a legitimate user, jumps to the page, and enters the system.
Login legality judgment process: After the user enters the account number and password, the system first determines the legality of the input data, then sends a login request on the login.Java page, and calls the dopost method of the mainctrl class under src to verify.
The IPO for the user login module looks like this:
Enter: username and password.
deal with:
1) Detect whether the account number and password entered by the user are correct and exist in the database.
2）从数据库中提取记录，并储存在本地的session中（timeout默认=30min）。
3）根据用户名，将其显示在系统首页上。
输出：是否成功的信息。
登录流程图如下所示。
正在上传…重新上传取消
图5-1登录流程图
系统登录界面如下所示。
正在上传…重新上传取消
图5-2系统登录界面
登录系统主要代码如下。
/**
* 登录
* @param data
* @param httpServletRequest
* @return
*/
@PostMapping("login")
public Map<String, Object> login(@RequestBody Map<String, String> data, HttpServletRequest httpServletRequest) {
log.info("[执行登录接口]");
String username = data.get("username");
String email = data.get("email");
String phone = data.get("phone");
String password = data.get("password");
List resultList = null;
Map<String, String> map = new HashMap<>();
if(username != null && "".equals(username) == false){
map.put("username", username);
resultList = service.select(map, new HashMap<>()).getResultList();
}
else if(email != null && "".equals(email) == false){
map.put("email", email);
resultList = service.select(map, new HashMap<>()).getResultList();
}
else if(phone != null && "".equals(phone) == false){
map.put("phone", phone);
resultList = service.select(map, new HashMap<>()).getResultList();
}else{
return error(30000, "账号或密码不能为空");
}
if (resultList == null || password == null) {
return error(30000, "账号或密码不能为空");
}
//判断是否有这个用户
if (resultList.size()<=0){
return error(30000,"用户不存在");
}
User byUsername = (User) resultList.get(0);
Map<String, String> groupMap = new HashMap<>();
groupMap.put("name",byUsername.getUserGroup());
List groupList = userGroupService.select(groupMap, new HashMap<>()).getResultList();
if (groupList.size()<1){
return error(30000,"用户组不存在");
}
UserGroup userGroup = (UserGroup) groupList.get(0);
//查询用户审核状态
if (!StringUtils.isEmpty(userGroup.getSourceTable())){
String sql = "select examine_state from "+ userGroup.getSourceTable() +" WHERE user_id = " + byUsername.getUserId();
String res = String.valueOf(service.runCountSql(sql).getSingleResult());
if (res==null){
return error(30000,"用户不存在");
}
if (!res.equals("已通过")){
return error(30000,"该用户审核未通过");
}
}
//查询用户状态
if (byUsername.getState()!=1){
return error(30000,"用户非可用状态，不能登录");
}
String md5password = service.encryption(password);
if (byUsername.getPassword().equals(md5password)) {
// 存储Token到数据库
AccessToken accessToken = new AccessToken();
accessToken.setToken(UUID.randomUUID().toString().replaceAll("-", ""));
accessToken.setUser_id(byUsername.getUserId());
tokenService.save(accessToken);
// 返回用户信息
JSONObject user = JSONObject.parseObject(JSONObject.toJSONString(byUsername));
user.put("token", accessToken.getToken());
JSONObject ret = new JSONObject();
ret.put("obj",user);
return success(ret);
} else {
return error(30000, "账号或密码不正确");
}
}
系统呈现出一种简洁大方的首页：界面简约、鳞次栉比，用户能轻车熟路的使用。出于对系统使用群体广泛的顾虑，应有良好性能的后台。
如下图所示为系统的首页界面。
正在上传…重新上传取消
图5-3系统首页界面
学生在填写数据的时候必须与注册页面上的验证相匹配否则会注册失败，注册页面的表单验证是通过验证的，用户名的长度必须在6到18之间，邮箱必须带有@符号，密码和密码确认必须相同，你输入的密码，系统会根据你输入密码的强度给出指定的值，电话号码和身份证号码必须要求输入格式与生活相符合，当你前台验证通过的时候你点击注册，表单会将你输入的值通过name值传递给后台并保存到数据库中。
学生注册流程图如下图所示。
正在上传…重新上传取消
图5-1学生注册流程图
正在上传…重新上传取消
图5-4学生注册界面图
学生注册关键代码如下所示。
/**
* 注册
* @param user
* @return
*/
@PostMapping("register")
public Map<String, Object> signUp(@RequestBody User user) {
// 查询用户
Map<String, String> query = new HashMap<>();
query.put("username",user.getUsername());
List list = service.select(query, new HashMap<>()).getResultList();
if (list.size()>0){
return error(30000, "用户已存在");
}
user.setUserId(null);
user.setPassword(service.encryption(user.getPassword()));
service.save(user);
return success(1);
}
/**
* 用户ID：[0,8388607]用户获取其他与用户相关的数据
*/
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "user_id")
private Integer userId;
/**
* 账户状态：[0,10](1可用|2异常|3已冻结|4已注销)
*/
@Basic
@Column(name = "state")
private Integer state;
/**
* 所在用户组：[0,32767]决定用户身份和权限
*/
@Basic
@Column(name = "user_group")
private String userGroup;
/**
* 上次登录时间：
*/
@Basic
@Column(name = "login_time")
private Timestamp loginTime;
/**
* 手机号码：[0,11]用户的手机号码，用于找回密码时或登录时
*/
@Basic
@Column(name = "phone")
private String phone;
/**
* 手机认证：[0,1](0未认证|1审核中|2已认证)
*/
@Basic
@Column(name = "phone_state")
private Integer phoneState;
/**
* 用户名：[0,16]用户登录时所用的账户名称
*/
@Basic
@Column(name = "username")
private String username;
/**
* 昵称：[0,16]
*/
@Basic
@Column(name = "nickname")
private String nickname;
/**
* 密码：[0,32]用户登录所需的密码，由6-16位数字或英文组成
*/
@Basic
@Column(name = "password")
private String password;
/**
* 邮箱：[0,64]用户的邮箱，用于找回密码时或登录时
*/
@Basic
@Column(name = "email")
private String email;
/**
* 邮箱认证：[0,1](0未认证|1审核中|2已认证)
*/
@Basic
@Column(name = "email_state")
private Integer emailState;
/**
* 头像地址：[0,255]
*/
@Basic
@Column(name = "avatar")
private String avatar;
/**
* 创建时间：
*/
@Basic
@Column(name = "create_time")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Timestamp createTime;
@Basic
@Transient
private String code;
}
-
-
- 课程信息模块
-
课程信息过程中，首先使用getmap(id,"xinxi")，通过课程ID得到课程数据，将课程数据赋值给考试成绩，调用CommDAO的insert方法将安排数据插入安排表中，最后查看个人历史发布课程信息记录，可以销毁历史安排数据。
课程信息流程图如下所示。
正在上传…重新上传取消
图5-6课程信息流程图
课程信息界面如图所示。
正在上传…重新上传取消
图5-7课程信息界面
-
-
- 学生选课模块
-
学生选课过程中，首先通过课程ID得到课程数据，将课程数据赋值给学生选课，调用mysql_query($sql)方法将选课数据插入选课表中，最后查看个人历史学生选课记录，可以销毁历史学生选课数据。
学生选课流程图如下所示。
正在上传…重新上传取消
图5-1学生选课流程图
学生选课界面如图所示。
正在上传…重新上传取消
图5-8学生选课界面
学生在yhzhgl查看学生信息，先使用sql语句查询出所有学生表的数据，然后调用PageManager.getPages(url,4,sql, request )，返回一个ArrayList的对象，在for循环里，使用jsp得到每个ArrayList对象的数据，在jsp页面中解析ArrayList对象，得到其各个键值对的值。
学生管理界面如下图所示。
正在上传…重新上传取消
图5-9学生管理界面
学生管理关键代码如下所示。
@RequestMapping(value = {"/count_group", "/count"})
public Map<String, Object> count(HttpServletRequest request) {
Query count = service.count(service.readQuery(request), service.readConfig(request));
return success(count.getResultList());
}
-
-
- 在线考试管理模块
-
添加考试信息时，输入必填字段后，表现层的ZuoyeController接受传过来的在线考试信息参数，再调用ZuoyeController类的addZuoye方法，经过ZuoyeService业务层到ZuoyeMapper持久层的处理，完成对整个添加考试信息的操作。addZuoye方法也和用户管理中的addUser方法类似，同时做添加和修改工作。
修改在线考试信息时，选择需要修改的考试进行修改，调用ZuoyeController控制器的editZuoye方法，拿到该考试原本的信息并显示到页面，管理员再对需要修改的考试信息字段进行修改，完成后调用addZuoye方法，调用业务层的updateByKey方法，更新数据库的在线考试表的数据。
在线考试管理流程图如下所示。
正在上传…重新上传取消
图5-10在线考试管理流程图
在线考试添加界面如下图所示。
正在上传…重新上传取消
图5-11在线考试添加界面
在线考试管理关键代码如下所示。
@PostMapping("/add")
@Transactional
public Map<String, Object> add(HttpServletRequest request) throws IOException {
service.insert(service.readBody(request.getReader()));
return success(1);
}
@Transactional
public Map<String, Object> addMap(Map<String,Object> map){
service.insert(map);
return success(1);
}
public Map<String,Object> readBody(BufferedReader reader){
BufferedReader br = null;
StringBuilder sb = new StringBuilder("");
try{
br = reader;
String str;
while ((str = br.readLine()) != null){
sb.append(str);
}
br.close();
String json = sb.toString();
return JSONObject.parseObject(json, Map.class);
}catch (IOException e){
e.printStackTrace();
}finally{
if (null != br){
try{
br.close();
}catch (IOException e){
e.printStackTrace();
}
}
}
return null;
}
public void insert(Map<String,Object> body){
StringBuffer sql = new StringBuffer("INSERT INTO ");
sql.append("`").append(table).append("`").append(" (");
for (Map.Entry<String,Object> entry:body.entrySet()){
sql.append("`"+humpToLine(entry.getKey())+"`").append(",");
}
sql.deleteCharAt(sql.length()-1);
sql.append(") VALUES (");
for (Map.Entry<String,Object> entry:body.entrySet()){
Object value = entry.getValue();
if (value instanceof String){
sql.append("'").append(entry.getValue()).append("'").append(",");
}else {
sql.append(entry.getValue()).append(",");
}
}
sql.deleteCharAt(sql.length() - 1);
sql.append(")");
log.info("[{}] - 插入操作：{}",table,sql);
Query query = runCountSql(sql.toString());
query.executeUpdate();
}
-
-
- 考试成绩管理模块
-
考试成绩过程中，首先通过考试ID得到成绩数据，将选课数据赋值给考试成绩，调用mysql_query($sql)方法将成绩数据插入成绩表中，最后查看个人历史考试成绩记录，可以销毁历史成绩数据。
考试成绩录入流程图如下所示。
正在上传…重新上传取消
图5-12考试成绩录入流程图
考试成绩管理界面如图所示。
正在上传…重新上传取消
图5-13考试成绩信息界面
考试成绩管理关键代码如下所示。
@PostMapping("/set")
@Transactional
public Map<String, Object> set(HttpServletRequest request) throws IOException {
service.update(service.readQuery(request), service.readConfig(request), service.readBody(request.getReader()));
return success(1);
}
public Map<String,String> readConfig(HttpServletRequest request){
Map<String,String> map = new HashMap<>();
map.put(FindConfig.PAGE,request.getParameter(FindConfig.PAGE));
map.put(FindConfig.SIZE,request.getParameter(FindConfig.SIZE));
map.put(FindConfig.LIKE,request.getParameter(FindConfig.LIKE));
map.put(FindConfig.ORDER_BY,request.getParameter(FindConfig.ORDER_BY));
map.put(FindConfig.FIELD,request.getParameter(FindConfig.FIELD));
map.put(FindConfig.GROUP_BY,request.getParameter(FindConfig.GROUP_BY));
map.put(FindConfig.MAX_,request.getParameter(FindConfig.MAX_));
map.put(FindConfig.MIN_,request.getParameter(FindConfig.MIN_));
return map;
}
public Map<String,String> readQuery(HttpServletRequest request){
String queryString = request.getQueryString();
if (queryString != null && !"".equals(queryString)) {
String[] querys = queryString.split("&");
Map<String, String> map = new HashMap<>();
for (String query : querys) {
String[] q = query.split("=");
map.put(q[0], q[1]);
}
map.remove(FindConfig.PAGE);
map.remove(FindConfig.SIZE);
map.remove(FindConfig.LIKE);
map.remove(FindConfig.ORDER_BY);
map.remove(FindConfig.FIELD);
map.remove(FindConfig.GROUP_BY);
map.remove(FindConfig.MAX_);
map.remove(FindConfig.MIN_);
return map;
}else {
return new HashMap<>();
}
}
@Transactional
public void update(Map<String,String> query,Map<String,String> config,Map<String,Object> body){
StringBuffer sql = new StringBuffer("UPDATE ").append("`").append(table).append("`").append(" SET ");
for (Map.Entry<String,Object> entry:body.entrySet()){
Object value = entry.getValue();
if (value instanceof String){
sql.append("`"+humpToLine(entry.getKey())+"`").append("=").append("'").append(value).append("'").append(",");
}else {
sql.append("`"+humpToLine(entry.getKey())+"`").append("=").append(value).append(",");
}
}
sql.deleteCharAt(sql.length()-1);
sql.append(toWhereSql(query,"0".equals(config.get(FindConfig.LIKE))));
log.info("[{}] - 更新操作：{}",table,sql);
Query query1 = runCountSql(sql.toString());
query1.executeUpdate();
}
public String toWhereSql(Map<String,String> query, Boolean like) {
if (query.size() > 0) {
try {
StringBuilder sql = new StringBuilder(" WHERE ");
for (Map.Entry<String, String> entry : query.entrySet()) {
if (entry.getKey().contains(FindConfig.MIN_)) {
String min = humpToLine(entry.getKey()).replace("_min", "");
sql.append("`"+min+"`").append(" >= '").append(URLDecoder.decode(entry.getValue(), "UTF-8")).append("' and ");
continue;
}
if (entry.getKey().contains(FindConfig.MAX_)) {
String max = humpToLine(entry.getKey()).replace("_max", "");
sql.append("`"+max+"`").append(" <= '").append(URLDecoder.decode(entry.getValue(), "UTF-8")).append("' and ");
continue;
}
if (like == true) {
sql.append("`"+humpToLine(entry.getKey())+"`").append(" LIKE '%").append(URLDecoder.decode(entry.getValue(), "UTF-8")).append("%'").append(" and ");
} else {
sql.append("`"+humpToLine(entry.getKey())+"`").append(" = '").append(URLDecoder.decode(entry.getValue(), "UTF-8")).append("'").append(" and ");
}
}
sql.delete(sql.length() - 4, sql.length());
sql.append(" ");
return sql.toString();
} catch (UnsupportedEncodingException e) {
log.info("拼接sql 失败：{}", e.getMessage());
}
}
return "";
}
在对该系统进行完详细设计和编码之后，就要对班级管理系统的程序进行测试，检测程序是否运行无误，反复进行测试和修改，使之最后成为完整的软件，满足用户的需求，实现预期的功能。
在软件的测试过程中，通常测试人员需要针对不同的功能模块设计多种测试用例。通过测试用例能够及时发现代码业务逻辑上是否与真实的业务逻辑相对应，及时发现代码上或逻辑上的缺陷，以此来来完善系统，提高软件产品的质量，使软件具有良好的用户体验。
登录测试用例表如下所示。
表6-1登录测试用例
| 测试性能 |
用户或操作员登录系统 |
||
| 用例目的 |
测试用户或操作员登录系统时功能是否正常 |
||
| 前提条件 |
进入用户登录页面或操作员登录页面 |
||
| 输入条件 |
预期输出 |
实际情况 |
|
| 各项信息不予填写，直接点击登陆按钮 |
不允许登录，提示填写账号相关信息 |
一致 |
|
| 填写错误的登录名或密码后点击登录系统 |
提示用户名或密码错误，要求重新填写进行登录 |
一致 |
|
| 填写与验证码信息不一致的信息 |
系统显示出提示信息，表明验证码错误，要求重新填写 |
一致 |
|
考试成绩测试用例表如下所示。
表6-2考试成绩测试用例
| 测试性能 |
用户进行考试成绩的操作 |
||
| 用例目的 |
测试用户进行考试成绩操作时，该功能是否正常 |
||
| 前提条件 |
用户进入作业详情页，该作业能够被批复 |
||
| 输入条件 |
预期输出 |
实际情况 |
|
| 对着某作业点击“发布”按钮 |
界面跳转至批复界面 |
一致 |
|
| 在批复界面，输入必填项，点击“提交”按钮 |
提示“发布成功”，并返回上一级界面 |
一致 |
|
| 在作业界面，填写发布表单的时候未输入完整，点击“提交”按钮 |
提示“发布失败” |
一致 |
|
课程信息管理测试用例表如下所示。
表6-3课程信息管理测试用例
| 测试性能 |
课程信息相关信息管理功能 |
||
| 用例目的 |
测试系统操作者对作业相关信息进行管理的功能是否正常 |
||
| 前提条件 |
登录系统进入相关管理页面 |
||
| 输入条件 |
预期输出 |
实际情况 |
|
| 进入课程信息管理界面，点击“录入”按钮，填写所有必填项，点击提交 |
提示“录入成功”，并返回查询界面 |
一致 |
|
| 进入课程信息管理界面，点击“录入”按钮，未填写一个或者多个必填项，点击提交 |
提示“录入失败”，请填写必填项 |
一致 |
|
| 进入课程信息管理界面，选择要修改的一条数据，点击该条数据后面的“修改”按钮 |
节目跳转至修改界面 |
一致 |
|
| 在修改界面，修改可修改项后，点击“提交”按钮 |
提示“修改成功”，并返回查询界面 |
一致 |
|
| 进入课程信息管理界面，点击某条数据后面的删除按钮 |
提示“是否要删除该数据”，如果用户点击“确定”按钮，则成功删除该条数据，并提示“删除成功”，之后返回查询界面 |
一致 |
|
经过对此系统的测试，得出该系统足以满足用户日常需求，在功能项目和操作等方面也能满足操作员对于其他用户的管理。但是，还有很多功能有待添加，这个系统仅能满足大部分的需求，还需要对此系统的功能更进一步的完善，这样使用起来才能更加的完美。
通过班级管理系统的开发，本人巩固了之前学过的知识，如今将平时所学到的知识融合在设计中，在设计过程中，做了很多的准备，首先，在数据库系统的设计过程中，尤其是在数据库的工作原理、工作特点，对其深刻的讨论，与此同时，对于小型站点来说，最好服务器的选择，其次，利用所学的知识点分析所做的系统，并在此基础上设计。
目前本系统已经上线，正在试运行阶段，用户反馈良好，基本完成用户所需，试运行过程中没有出现阻断性问题，有一些不足和小问题也及时予以修正，系统上线后，为了保证数据的安全性，对系统进行了备份操作，系统备份是每两个月备份一次，数据库备份为每周备份一次，系统部署在租赁的云平台服务器中。
本次系统上线成功后，得到了用户的高度认可，但是在功能上和性能上还需做进一步的研究处理，使其有更高的性能和更好的用户体验。
系统在以后的升级过程中，需要解决一系列用户所提出的问题，例如打印过程中如何避免浏览器的兼容性问题，大量用户访问时，如何保持较高的响应速度，在系统今后的升级过程中将着重解决这些安全性问题。
参考文献
[1]宋荣,窦长保.信息技术环境下班级管理的有效策略[J].西部素质教育,2022,8(06):128-130.DOI:10.16681/j.cnki.wcqe.202206040.
[2]李小红.高校辅导员班级管理与班风建设标准化对策分析[J].中国标准化,2022(06):175-177.
[3]曹军科.基于学生为主体的高中班级管理策略探究[J].品位·经典,2022(05):78-80.
[4]王曼维,杨荻,李岩,及松洁.基于SpringBoot框架的智慧医疗问诊系统设计与实现[J].中国医学装备,2022,19(03):133-136.
[5]胡中一.高校班级管理低质量探赜[J].湖北开放职业学院学报,2022,35(05):59-60+69.
[6]贺仕伟. 一种班级噪声管理系统和设备[P]. 四川省：CN215219745U,2021-12-17.
[7]马聪,华亮,羌予践.一种基于SpringBoot架构下的水质监测系统设计[J].电子器件,2021,44(05):1109-1114.
[8]黄冠,罗涛,侯宏伟. 互联网班级管理方法、系统、计算机设备和存储介质[P]. 广东省：CN113506195A,2021-10-15.
[9]Fuyuan Cheng. Talent Recruitment Management System for Small and Micro Enterprises Based on Springboot Framework[J]. Advances in Educational Technology and Psychology,2021,5(2).
[10]Jian Chen,Chen Jian,Pan Hailan. Design of Man Hour Management Information System on SpringBoot Framework[J]. Journal of Physics: Conference Series,2020,1646(1).
[11] Deng Zhilong. Design and Implementation of Class Management System in Higher Vocational Colleges Based on Spring MVC Architecture [J]. Educational Observation, 2020, 9(18): 79-80. DOI: 10.16070/j.cnki.cn45-1388/ g4s.2020.18.031.
[12] Zhang Haiyan, Tang Wenxin, Liang Yongzhen. Design of Class Information Management System Based on LabVIEW [J]. Software, 2019, 40(12): 81-84.
[13] Xu Yuanhui. Research and Analysis of High School Class Management System [D]. Yunnan University, 2018.
[14] Zhang Honghao, Kang Ruihua. Design and Implementation of Class Management System Based on Mobile Internet [J]. Software Guide, 2017,16(05):91-93.
[15] Shen Caiwen. Research on Class Management System Based on B/S Structure [C]//. Exploring Science Academic Seminar in May 2016., 2016:330-331.
thank you
With the completion of the design, the college career is coming to an end. The time in college is the time I cherish the most. I have learned a lot and grown a lot during the time in college. Every memory during this time is engraved in my mind. Thanks to the students who studied and grew up together, and the teachers who taught me during the growth process, I am very grateful for your company.
First of all, I would like to thank my instructor. The completion of the design is inseparable from a series of guidance from the teacher. During the completion of the graduation project, the teacher gave many pertinent suggestions. It is precisely because of the teacher's meticulous work attitude that my design can be successfully completed.
Finally, I would like to thank every teacher who taught me during my college career. You have taught me a wealth of knowledge and taught me how to deal with and solve problems when I encounter them. Thank you for your help and support.
Get the source code of the project for free, please pay attention to like + private message