Holen Sie sich am Ende den Quellcode
. Entwicklungssprache: Java
Java-Entwicklungstool: JDK1.8
Back-End-Framework: SSM
Front-End: entwickelt mit JSP-Technologie
Datenbank: MySQL5.7 kombiniert mit Navicat-Verwaltungstools
Server: Tomcat8.5
Entwicklungssoftware: IDEA/Eclipse
Ob es sich um ein Maven-Projekt handelt: Ja
Inhaltsverzeichnis
3. Screenshots des Systemprojekts
3.1 Implementierung der Benutzerfunktion
3.2 Implementierung der Administratorfunktion
Edit 3.3 Implementierung der Schiedsrichterfunktion
1. Projekteinführung
In der heutigen Gesellschaft wird Sport immer beliebter und immer mehr Menschen nehmen an Sportspielen teil. Die derzeitige Verwaltung von Informationen zu Sportveranstaltungen befindet sich jedoch noch im Zeitalter der manuellen Aufzeichnung, was den aktuellen Anforderungen bei weitem nicht gerecht wird Benutzer. Daher wird ein Informationsmanagementsystem für Sportveranstaltungen eingerichtet. ist sehr wichtig geworden.
Dieser Artikel konzentriert sich auf den Entwicklungsprozess des Informationsmanagementsystems für Schulsportveranstaltungen. Er basiert auf der praktischen Anwendung als Entwicklungshintergrund, basiert auf der B/S- Struktur und verwendet JSP- Technologie und MYSQL als Systemdatenbank für die Entwicklung, um dies vollständig sicherzustellen Sicherheit und Stabilität des Systems. Dieses System verfügt über eine gute Schnittstelle und ist einfach und bequem zu bedienen. Durch die Systemübersicht, Systemanalyse, Systemdesign, Datenbankdesign und Systemtests wird der Systementwicklungsprozess ausführlich erläutert. Abschließend wird der gesamte Entwicklungsprozess zusammengefasst und realisiert. Eine wichtige Funktion des Informationsmanagements von Schulsportveranstaltungen.
Dieses System wurde getestet und als stabil, einfach und schnell zu bedienen befunden. Es handelt sich um ein Schulsport-Informationsmanagementsystem mit umfassenden Funktionen, guter Praktikabilität, hoher Sicherheit, guter Skalierbarkeit und Wartbarkeit.
2. Gestaltungsprinzipien
Bevor Sie mit der Entwicklung eines Projekts beginnen, müssen Sie zunächst die Praktikabilität und den wissenschaftlichen Charakter des Projekts berücksichtigen und prüfen, ob das Projekt den Benutzern wirklich zugute kommen und die Rolle des Projekts maximieren kann. Daher sollte das Projekt vor der Entwicklung nach folgenden Grundsätzen beurteilt werden:
(1) Das Prinzip der Machbarkeit. Das Projekt muss die wirtschaftliche Machbarkeit und technische Machbarkeit sicherstellen, einschließlich der Frage, ob das Projekt browserseitig, serverseitig usw. wirtschaftlich und technisch realisierbar ist.
(2) Das Prinzip der Anpassungsfähigkeit. Das Projekt muss Wartbarkeit und Skalierbarkeit gewährleisten, was bei jedem nicht kurzfristigen Projekt berücksichtigt werden muss. Unabhängig davon, ob es sich um Wartung oder Erweiterung handelt, muss es auf der Anpassung an die normalen Bedürfnisse der Benutzer basieren.
(3) Grundsätze der Sicherheit und Vertraulichkeit. Die Sicherheit und Vertraulichkeit der Benutzerinformationen muss vollständig gewährleistet sein und Benutzerinformationen dürfen nicht aufgrund von Nachlässigkeit bei der Entwicklung preisgegeben werden.
(4) Prinzipien der Systemtechnik. Um die Integrität des Projekts sicherzustellen, müssen die Projektuntersuchungs-, Projektanalyse-, Projektentwurfs- und Projektentwicklungsprozesse Schritt für Schritt den Methoden und Schritten der Projektentwicklung folgen.
(5) Die Grundsätze der einheitlichen Planung, der schrittweisen Umsetzung und der schrittweisen Verbesserung. Während des Projektentwicklungsprozesses müssen wir dem Plan folgen und ihn phasenweise umsetzen. Insbesondere müssen wir darauf achten, während des Projektentwicklungsprozesses vom Punkt bis zur Oberfläche methodisch vorzugehen und uns Schritt für Schritt zu verbessern. Seien Sie nicht gierig Fortschritt, sondern entwickeln Sie das Projekt zyklisch und schrittweise weiter.
3. Screenshots des Systemprojekts
3.1 Implementierung der Benutzerfunktion
Benutzer können Systeminformationen anzeigen, indem sie das System betreten
Benutzer, die kein Konto haben, können sich über die Registrierungsoberfläche registrieren.
Nutzer müssen sich im System anmelden, wenn sie sich für den Wettbewerb anmelden möchten.
Benutzer können die detaillierten Informationen zum Wettbewerb auf der Wettbewerbsdetailseite einsehen. Nach der Anmeldung können sie Registrierungsvorgänge durchführen. Die Wettbewerbsdetailoberfläche wird angezeigt.
Nach der Anmeldung kann der Benutzer einen Wettbewerb zur Registrierung auswählen und die Wettbewerbsregistrierungsoberfläche wird angezeigt.
Nach der Anmeldung können Benutzer Nachrichten-Feedback-Vorgänge ausführen und die Nachrichten-Feedback-Schnittstelle wird angezeigt.
Benutzer können persönliche Informationen ändern, und die Benutzeroberfläche für persönliche Informationen wird angezeigt. 
Benutzer können die Benutzeroberfläche für Wettbewerbsergebnisse aufrufen, um Informationen zu persönlichen Wettbewerbsergebnissen anzuzeigen, und die Benutzeroberfläche für Wettbewerbsergebnisse wird angezeigt.
3.2 Implementierung der Administratorfunktion
Wenn der Administrator den Systemhintergrund betreten möchte, um Verwaltungsvorgänge auf dem System durchzuführen, muss er sich beim System anmelden. Die Administrator-Anmeldeschnittstelle wird angezeigt.
Der Administrator kann alle Schiedsrichterinformationen anzeigen, ändern und löschen sowie Schiedsrichterinformationen hinzufügen und die Schiedsrichterschnittstelle anzeigen.
Administratoren können Benutzerinformationen hinzufügen, ändern und löschen und die Benutzerverwaltungsoberfläche wird angezeigt
Administratoren können Wettbewerbsveranstaltungsinformationen hinzufügen, löschen, ändern und überprüfen, und die Schnittstelle zur Verwaltung von Wettbewerbsveranstaltungen wird angezeigt.
Administratoren können Spielinformationen hinzufügen, löschen, ändern und überprüfen, und die Schnittstelle zur Verwaltung von Spielinformationen wird angezeigt
3.3 Umsetzung der Schiedsrichterfunktion
Schiedsrichter können alle Informationen zur Veranstaltungsregistrierung einsehen und diese überprüfen und löschen. Die Schnittstelle zur Verwaltung der Veranstaltungsregistrierung wird angezeigt
Schiedsrichter können Spielstandsinformationen hinzufügen, ändern und löschen, und die Benutzeroberfläche zur Spielstandsverwaltung wird angezeigt
4. Kerncode
4.1 Login-bezogen
package com.controller;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.TokenEntity;
import com.entity.UserEntity;
import com.service.TokenService;
import com.service.UserService;
import com.utils.CommonUtil;
import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.ValidatorUtils;
/**
* 登录相关
*/
@RequestMapping("users")
@RestController
public class UserController{
@Autowired
private UserService userService;
@Autowired
private TokenService tokenService;
/**
* 登录
*/
@IgnoreAuth
@PostMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) {
UserEntity user = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", username));
if(user==null || !user.getPassword().equals(password)) {
return R.error("账号或密码不正确");
}
String token = tokenService.generateToken(user.getId(),username, "users", user.getRole());
return R.ok().put("token", token);
}
/**
* 注册
*/
@IgnoreAuth
@PostMapping(value = "/register")
public R register(@RequestBody UserEntity user){
// ValidatorUtils.validateEntity(user);
if(userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername())) !=null) {
return R.error("用户已存在");
}
userService.insert(user);
return R.ok();
}
/**
* 退出
*/
@GetMapping(value = "logout")
public R logout(HttpServletRequest request) {
request.getSession().invalidate();
return R.ok("退出成功");
}
/**
* 密码重置
*/
@IgnoreAuth
@RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request){
UserEntity user = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", username));
if(user==null) {
return R.error("账号不存在");
}
user.setPassword("123456");
userService.update(user,null);
return R.ok("密码已重置为：123456");
}
/**
* 列表
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params,UserEntity user){
EntityWrapper<UserEntity> ew = new EntityWrapper<UserEntity>();
PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
return R.ok().put("data", page);
}
/**
* 列表
*/
@RequestMapping("/list")
public R list( UserEntity user){
EntityWrapper<UserEntity> ew = new EntityWrapper<UserEntity>();
ew.allEq(MPUtil.allEQMapPre( user, "user"));
return R.ok().put("data", userService.selectListView(ew));
}
/**
* 信息
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") String id){
UserEntity user = userService.selectById(id);
return R.ok().put("data", user);
}
/**
* 获取用户的session用户信息
*/
@RequestMapping("/session")
public R getCurrUser(HttpServletRequest request){
Long id = (Long)request.getSession().getAttribute("userId");
UserEntity user = userService.selectById(id);
return R.ok().put("data", user);
}
/**
* 保存
*/
@PostMapping("/save")
public R save(@RequestBody UserEntity user){
// ValidatorUtils.validateEntity(user);
if(userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername())) !=null) {
return R.error("用户已存在");
}
userService.insert(user);
return R.ok();
}
/**
* 修改
*/
@RequestMapping("/update")
public R update(@RequestBody UserEntity user){
// ValidatorUtils.validateEntity(user);
userService.updateById(user);//全部更新
return R.ok();
}
/**
* 删除
*/
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids){
userService.deleteBatchIds(Arrays.asList(ids));
return R.ok();
}
}
4.2 Datei-Upload
package com.controller;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.UUID;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.util.ResourceUtils;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.ConfigEntity;
import com.entity.EIException;
import com.service.ConfigService;
import com.utils.R;
/**
* 上传文件映射表
*/
@RestController
@RequestMapping("file")
@SuppressWarnings({"unchecked","rawtypes"})
public class FileController{
@Autowired
private ConfigService configService;
/**
* 上传文件
*/
@RequestMapping("/upload")
public R upload(@RequestParam("file") MultipartFile file,String type) throws Exception {
if (file.isEmpty()) {
throw new EIException("上传文件不能为空");
}
String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".")+1);
File path = new File(ResourceUtils.getURL("classpath:static").getPath());
if(!path.exists()) {
path = new File("");
}
File upload = new File(path.getAbsolutePath(),"/upload/");
if(!upload.exists()) {
upload.mkdirs();
}
String fileName = new Date().getTime()+"."+fileExt;
File dest = new File(upload.getAbsolutePath()+"/"+fileName);
file.transferTo(dest);
FileUtils.copyFile(dest, new File("C:\\Users\\Desktop\\jiadian\\springbootl7own\\src\\main\\resources\\static\\upload"+"/"+fileName));
if(StringUtils.isNotBlank(type) && type.equals("1")) {
ConfigEntity configEntity = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile"));
if(configEntity==null) {
configEntity = new ConfigEntity();
configEntity.setName("faceFile");
configEntity.setValue(fileName);
} else {
configEntity.setValue(fileName);
}
configService.insertOrUpdate(configEntity);
}
return R.ok().put("file", fileName);
}
/**
* 下载文件
*/
@IgnoreAuth
@RequestMapping("/download")
public ResponseEntity<byte[]> download(@RequestParam String fileName) {
try {
File path = new File(ResourceUtils.getURL("classpath:static").getPath());
if(!path.exists()) {
path = new File("");
}
File upload = new File(path.getAbsolutePath(),"/upload/");
if(!upload.exists()) {
upload.mkdirs();
}
File file = new File(upload.getAbsolutePath()+"/"+fileName);
if(file.exists()){
/*if(!fileService.canRead(file, SessionManager.getSessionUser())){
getResponse().sendError(403);
}*/
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
headers.setContentDispositionFormData("attachment", fileName);
return new ResponseEntity<byte[]>(FileUtils.readFileToByteArray(file),headers, HttpStatus.CREATED);
}
} catch (IOException e) {
e.printStackTrace();
}
return new ResponseEntity<byte[]>(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
4.3 Verpackung
package com.utils;
import java.util.HashMap;
import java.util.Map;
/**
* 返回数据
*/
public class R extends HashMap<String, Object> {
private static final long serialVersionUID = 1L;
public R() {
put("code", 0);
}
public static R error() {
return error(500, "未知异常，请联系管理员");
}
public static R error(String msg) {
return error(500, msg);
}
public static R error(int code, String msg) {
R r = new R();
r.put("code", code);
r.put("msg", msg);
return r;
}
public static R ok(String msg) {
R r = new R();
r.put("msg", msg);
return r;
}
public static R ok(Map<String, Object> map) {
R r = new R();
r.putAll(map);
return r;
}
public static R ok() {
return new R();
}
public R put(String key, Object value) {
super.put(key, value);
return this;
}
}
5. Systemtests
1. Testdefinition
Systemtests sind ein unverzichtbarer Bestandteil der Systementwicklung, daher ist die Bedeutung des Testens unbeschreiblich. Testen Sie nach der Entwicklung des Systems, ob es normal und stabil laufen kann. Wenn während des Testprozesses ein Fehler auftritt, müssen wir den Fehler beheben und das System verbessern. Auf diese Weise ist der Entwicklungsprozess sehr korrekt und stabil und die einzige Möglichkeit, das System zu entwickeln. Ohne Systemtests wird die Systementwicklung funktionieren defekt. . Der Zweck des Testens besteht darin, sicherzustellen, dass die entwickelten Systemprodukte nicht perfektioniert werden oder so viele Fehler wie möglich behoben werden, bevor sie für den offiziellen Gebrauch bestätigt werden, um sicherzustellen, dass das entwickelte System von ausgezeichneter Qualität ist, und um mögliche FEHLER und einige Unvollkommenheiten zu beseitigen im System. Das Design hat keinen Einfluss auf den Arbeitsinhalt des Benutzers. Daher sind Systemtests ein unverzichtbarer Bestandteil des Systementwicklungsprozesses. Systementwicklung und -tests müssen einen weiteren Punkt kontrollieren. Dieser Punkt besteht darin, die Fehler und Fehler im System in einem bestimmten Bereich zu halten, damit Benutzer, die das System verwenden, nicht beeinträchtigt werden, die Glaubwürdigkeit des Benutzers verbessert wird und es normal und stabil läuft. .
2. Leistungstest
Die Entwicklung jedes Projekts erfordert Hunderte, Tausende oder sogar mehr Tests, um die Qualität des Projekts sicherzustellen. Sein grundlegender Zweck besteht darin, die Benutzererfahrung zu verbessern. Nur Projekte mit hoher Benutzererfahrung werden beliebt sein. Und wenn ein Projekt veröffentlicht wird, ohne dass es strengen Tests unterzogen wurde, werden Benutzer beim Erleben des Projekts unweigerlich auf Fehler der einen oder anderen Art stoßen, was zu einer schlechten Benutzererfahrung führt. Wenn die Benutzererfahrung schlecht ist, wird die Anzahl der Personen, die das Projekt nutzen, zwangsläufig abnehmen. Daher müssen wir einen Teufelskreis wie diesen vermeiden.
Systemfunktionstests werden auch Black-Box-Tests genannt. Systemfunktionstests berücksichtigen hauptsächlich die Funktion eines Systems. Das heißt, es wird geprüft, ob die Funktion eines Systems fehlt und ob es normal genutzt werden kann. Zufällige Tests führen zu einem langen Testprozess und für effektive Tests sind Echtzeitdaten erforderlich, um Verzögerungen bei der Systemeinführung zu reduzieren.
3. Prüfprinzip
Systemtests sollen es Testern ermöglichen, mögliche Probleme und Lücken im System zu finden, bevor es offiziell gestartet wird. Um rechtzeitig Verbesserungen am System vorzunehmen, bevor erneut Probleme auftreten. Systemtester müssen testen, indem sie die Nutzungsumgebung des Benutzers simulieren. Dies soll es dem System ermöglichen, den Betriebsstatus des Systems unter tatsächlicher Benutzernutzung anzuzeigen, um zu überprüfen, ob die gesamte Software den Anforderungen des Benutzers entspricht und ob die Grundfunktionen realisiert werden können. Das Testen der Simulationsumgebung ist nur ein Aspekt. Systemtester müssen den Hintergrundcode des Systems testen und einen umfassenden Test der Rationalität der Systemschnittstelle durchführen. Die theoretische Grundlage des Softwaretests ist das Prinzip des Systemtests. Um den tatsächlichen Anwendungswert von Software zu erkennen, muss sich der Softwaretest strikt an die Methoden und Prinzipien des Systemtests halten.
Beim Testen ist es wichtig, dass die Testfälle den Spezifikationen entsprechen. Ob die Testfälle standardisiert sind, ist für die Testergebnisse des Systems sehr wichtig. Dies erfordert, dass Softwaretester über bestimmte berufliche Fähigkeiten verfügen und nicht blind testen können. Andernfalls weichen die Testergebnisse von den erwarteten Ergebnissen ab, was zu Fehlern bei der Beurteilung der Tester führt und sich somit auf die Nutzung des gesamten Systems auswirkt in irreversiblen Ergebnissen. Erscheinen.
4. Testanalyse
Während des gesamten Testprozesses waren die Funktionen jedes Moduls des Informationsmanagementsystems für Sportveranstaltungen der Schule relativ erfolgreich, es wurden jedoch auch einige Probleme festgestellt. Beispielsweise kann sich die Anmeldeseite nicht beim System anmelden, da die Passwörter der Datenbank in der Konfigurationsdateien sind inkonsistent usw. Änderungen wurden umgehend nach der Entdeckung vorgenommen. Derzeit gibt es noch viele Verbesserungsmöglichkeiten im System, die in der zukünftigen Nutzung und Wartung kontinuierlich verbessert werden.