Abschlussprojekt｜Campus-Dating-Plattform basierend auf SpringBoot+Vue

Autoren-Homepage:Programming Compass

Über den Autor: Hochwertiger Entwickler im Java-Bereich, CSDN-Blog-Experte, CSDN-Content-Partner, Nuggets-Gastautor, Alibaba Cloud-Blog-Experte, 51CTO-Gastautor, langjährige Erfahrung im Architektendesign, Dozent im Tencent-Klassenzimmer

Hauptinhalte: Java-Projekte, Python-Projekte, Front-End-Projekte, künstliche Intelligenz und Big Data, Lebenslaufvorlagen, Lernmaterialien, Fragendatenbank für Vorstellungsgespräche, technische gegenseitige Unterstützung

Sammeln, liken und nicht verloren gehen. Es ist gut, dem Autor zu folgen.

Den Quellcode finden Sie am Ende des Artikels

Artikelnummer:

1. Einführung in die Umwelt

Gebietsschema: Java: jdk1.8

Datenbank: MySQL: mysql5.7

Anwendungsserver: Tomcat: tomcat8.5.31

Entwicklungstools: IDEA oder Eclipse

2. Projekteinführung

Mit der Beliebtheit sozialer Medien und der Vielfalt des Campuslebens sind Campus-Dating-Plattformen zu einem wichtigen Bestandteil des Universitätslebens geworden. Ziel dieses Projekts ist es, Studenten auf dem Campus eine sichere, bequeme und hochgradig interaktive Dating-Plattform zu bieten, die ihnen dabei hilft, neue Freunde zu finden, ihre sozialen Kreise zu erweitern und durch die Abstimmung gemeinsamer Interessen und Hobbys eine tiefere Kommunikation und Interaktion zu fördern.

Projekt-Technologie-Stack:

Frontend: Vue.js, Element UI, HTML5, CSS3, JavaScript usw.

Backend: SpringBoot, MySQL, MyBatis, Spring Security usw.

Hauptfunktionen der Rezeption:

Startseite: Zeigt Karussellbilder, dynamische Rankings, aktuelle Nachrichten, Campusinformationen und andere Inhalte an, um die Aufmerksamkeit der Benutzer zu erregen.
Globale dynamische Suche: Ermöglicht Benutzern die Suche nach Beschreibung, Thema oder Titel, sodass Benutzer schnell interessante Inhalte finden können.
Chatroom: Bietet eine Online-Chat-Funktion, die es Benutzern ermöglicht, in Echtzeit mit anderen Benutzern zu kommunizieren und zu interagieren.
Points Mall: Sammeln Sie Punkte durch Aktionen wie Likes und bieten Sie die Funktion, Punkte gegen Waren einzulösen, wodurch die Motivation der Benutzer erhöht wird, aktiv an Plattformaktivitäten teilzunehmen.
Punkteverbrauchsbestellungen: Zeigen Sie die Punkteverbrauchsaufzeichnungen und Bestellinformationen des Benutzers an, damit Benutzer ihren Verbrauchsstatus besser verstehen können.
Nachrichtenbenachrichtigungen: Senden Sie Systembenachrichtigungen und persönliche Nachrichten an Benutzer, um sie umgehend über Aktualisierungen und wichtige Informationen zu informieren.
Persönliches Center: Benutzer können ihre eigenen Updates, Lieferadressen und Sammlungen verwalten, persönliche Informationen anzeigen und Passwörter ändern usw.

Hauptfunktionen des Hintergrunds:

Systemverwaltung: einschließlich Rollenverwaltung, Benutzerverwaltung, Berechtigungsverwaltung, Dateiverwaltung und Protokollverwaltung usw., um die Sicherheit und Kontrollierbarkeit des Systems sicherzustellen.
Homepage-Verwaltung: Verwalten Sie den Inhalt der Homepage, einschließlich der Bearbeitung und Veröffentlichung von Karussells, dynamischen Rankings, neuesten Entwicklungen, Campusinformationen usw.
Campus-Informationsmanagement: Ermöglicht Administratoren die Veröffentlichung und Verwaltung von Campus-Informationen, einschließlich Titel, Inhalt, Veröffentlichungszeitpunkt usw.
Themenverwaltung: Verwalten Sie Themen auf der Plattform, einschließlich Erstellen, Bearbeiten, Löschen von Themen sowie Kategorisieren und Sortieren von Themen.
Dynamische Verwaltung: Verwalten Sie die von Benutzern geposteten Dynamiken, einschließlich Vorgängen wie Überprüfen, Löschen und Anheften.
Sammlungsverwaltung: Verwalten Sie den Sammlungsinhalt des Benutzers, einschließlich Such- und Löschfunktionen.
Kommentarverwaltung: Überprüfen und löschen Sie Benutzerkommentare, um die Reihenfolge der Kommentare auf der Plattform sicherzustellen.
Benachrichtigungsverwaltung: Senden Sie Systembenachrichtigungen und persönliche Nachrichten an Benutzer zum Bearbeiten, Senden und Löschen von Vorgängen.
Points-Mall-Management: Verwalten Sie Produktinformationen, einschließlich Vorgängen wie Hinzufügen, Bearbeiten, Entfernen von Produkten aus Regalen und Bestandsverwaltung.
Datenstatistiken: Analysieren und sammeln Sie Statistiken zu Benutzeraktivitäts- und Interaktionsdaten durch grafische Anzeige von Stichdiagrammen, Balkendiagrammen und Kreisdiagrammen.
Persönliche Informationen und Passwortänderung: Administratoren können die persönlichen Informationen der Benutzer anzeigen und ändern, Passwörter zurücksetzen usw.

3. Systemanzeige

3.1 Anmeldung und Registrierung

3.2 Datenanzeige

3.3 Ankündigung dynamisch wie Management

3.4 Verwaltung von Sammlungsnachrichten und Kommentaren

3,5 Punkte Mall Management

3.6 Systemverwaltung

3.7 Benutzer-Frontend-Homepage

3.8 Chat-Fenster

3.9 Points Mall und Points Orders

3.10 Updates anzeigen

4. Kerncode-Anzeige

4.1 Chat-Kerncode


/**
 * @author websocket服务
 */
@ServerEndpoint(value = "/imserver/{uid}")
@Component
public class WebSocketServer {
    private static final Logger log = LoggerFactory.getLogger(WebSocketServer.class);
    /**
     * 记录当前在线连接数
     */
public static final Map<String, Session> sessionMap = new ConcurrentHashMap<>();

    @Resource
    IUserService userService;
    @Resource
    IImService imService;


    private static IUserService staticUserService;
    private static IImService staticImService;

    // 程序初始化的时候触发这个方法  赋值
    @PostConstruct
public void setStaticUser() {
        staticUserService = userService;
        staticImService = imService;
    }

    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
public void onOpen(Session session, @PathParam("uid") String uid) {
        sessionMap.put(uid, session);
        log.info("有新用户加入，uid={}, 当前在线人数为：{}", uid, sessionMap.size());
        Dict dict = Dict.create().set("nums", sessionMap.size());
        sendAllMessage(JSONUtil.toJsonStr(dict));  // 后台发送消息给所有的客户端
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
public void onClose(Session session, @PathParam("uid") String uid) {
        sessionMap.remove(uid);
        log.info("有一连接关闭，uid={}的用户session, 当前在线人数为：{}", uid, sessionMap.size());
        Dict dict = Dict.create().set("nums", sessionMap.size());
        sendAllMessage(JSONUtil.toJsonStr(dict));  // 后台发送消息给所有的客户端
    }

    /**
     * 收到客户端消息后调用的方法
     * 后台收到客户端发送过来的消息
     * onMessage 是一个消息的中转站
     * 接受 浏览器端 socket.send 发送过来的 json数据
     * @param message 客户端发送过来的消息
     */
    @OnMessage
public void onMessage(String message, Session fromSession, @PathParam("uid") String uid) throws JsonProcessingException {
        log.info("服务端收到用户uid={}的消息:{}", uid, message);
        // 处理msg
        // 存储数据库
        // 添加创建时间
        if (staticUserService == null) {
            return;
        }
        User user = staticUserService.getOne(new QueryWrapper<User>().eq("uid", uid));
        if (user == null) {
            log.error("获取用户信息失败，uid={}", uid);
            return;
        }

        Im im = Im.builder().uid(uid).username(user.getName()).avatar(user.getAvatar()).sign("")
                .createTime(LocalDateTime.now()).text(message).build();
        // 存储数据到数据库
        staticImService.save(im);
        String jsonStr = new ObjectMapper().writeValueAsString(im);  // 处理后的消息体
        this.sendAllMessage(jsonStr);
        log.info("发送消息：{}", jsonStr);
    }

    @OnError
public void onError(Session session, Throwable error) {
        log.error("发生错误");
        error.printStackTrace();
    }

    /**
     * 服务端发送消息给除了自己的其他客户端
     */
    private void sendMessage(Session fromSession, String message) {
        sessionMap.values().forEach(session -> {
            if (fromSession != session) {
                log.info("服务端给客户端[{}]发送消息{}", session.getId(), message);
                try {
                    session.getBasicRemote().sendText(message);
                } catch (IOException e) {
                    log.error("服务端发送消息给客户端异常", e);
                }
            }
        });
    }

    /**
     * 服务端发送消息给所有客户端
     */
    private void sendAllMessage(String message) {
        try {
            for (Session session : sessionMap.values()) {
                log.info("服务端给客户端[{}]发送消息{}", session.getId(), message);
                session.getBasicRemote().sendText(message);
            }
        } catch (Exception e) {
            log.error("服务端发送消息给客户端失败", e);
        }
    }
}

4.2 Kerncode des Anmeldeprotokolls

@Component
@Aspect
@Slf4j
public class LogAspect {

    @Resource
    private ILogService logService;

    @Around("@annotation(autoLog)")
public Object autoLog(ProceedingJoinPoint joinPoint, AutoLog autoLog) throws Throwable {
        long beginTime = SystemClock.now();
        //执行方法
        Object result = joinPoint.proceed();
        //执行时长(毫秒)
        long time = SystemClock.now() - beginTime;
        // 操作
        String name = autoLog.value();
        HttpServletRequest request = getRequest();
        // 请求的url
        String url = request.getRequestURL().toString();
        if (url.contains("/file/download")) {
            return result;
        }
        // 请求参数
        String params = "";
        Object[] args = joinPoint.getArgs();
        if (args.length > 0) {
            Object arg0 = args[0];
            if (arg0 instanceof MultipartFile) {
                params = "文件流";
            } else if (arg0 instanceof String || arg0 instanceof Long || arg0 instanceof Integer) {
                params = arg0.toString();
            } else {
                params = JSONUtil.toJsonStr(args[0]);
            }
        }
        // 返回数据
        String returnValue = JSONUtil.toJsonStr(result);
        if (returnValue.length() > 1000) {
            returnValue = "数据过大，返回状态码：" + JSONUtil.parseObj(returnValue).getStr("code");
        }
        // ip 和地址
        Dict ipAndCity = IpUtils.getIPAndCity();
        String ip = ipAndCity.getStr("ip");
        String city = ipAndCity.getStr("city");
        // 操作人
        String username = "";
        User user = SessionUtils.getUser();
        if (user != null) {
            username = user.getUsername();
        }
        // 保存到数据库
        Log log = Log.builder().name(name).params(params).output(returnValue).url(url).ip(ip)
                .address(city).duration((int) time).username(username).build();
        logService.save(log);
        return result;
    }

    private HttpServletRequest getRequest() {
        return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
    }


}