项目实战——匹配系统（下）

最新推荐文章于 2024-01-16 17:04:56 发布

yan扬

最新推荐文章于 2024-01-16 17:04:56 发布

阅读量1.2k

点赞数

分类专栏： springboot项目文章标签： java 前端开发语言

本文链接：https://blog.csdn.net/qq_59539549/article/details/128028037

版权

springboot项目专栏收录该内容

15 篇文章 5 订阅

订阅专栏

上节课知识梳理：

用户浏览器打开之后、两个client表示两个浏览器
Client向云端server发送请求、有http的servercontroller
还有ws的server、前端client会向websocket发请求
发完请求之后、本来应该用微服务实现匹配系统
向matchingsystem发送请求、表示我们加入了一个玩家
matchingsystem匹配完之后向server返回一个结果
当两名玩家匹配完之后、他们就会开一个线程
就会开始在云端执行一次游戏、Game第一步先去创建一个地图
创建完地图之后我们会把地图返回给前端、在前端画出来
通过ws返回、下一步读入两个玩家的操作
也可以用bot来执行、不一定非从前端读进来
如果没有得到某个玩家的输入可以直接结束返回结果
如果两名玩家的下一步操作都获取到的话我们就judge一下
判断一下操作是不是合法、如果不合法的话就结束了
如果合法的话无限循环到下一步

一、整体梳理

微服务
未来bot的执行也是一个微服务、微服务：其实就是这边会有一个独立的程序可以认为
又起了一个新的webserver，又起了一个新的springboot，两个springboot
当我们获取到两名玩家的匹配信息之后、它会向我们的matchingserver后端发送一个http请求
当我们接收到这个请求之后类似与game它也会开一个单独的线程来做一个匹配
Matching、这个Matching的过程类似的游戏的过程、每隔一秒钟去扫描当前已有的所有玩家
然后判断一下这些玩家能不能相互之间匹配出来、如果可以匹配的话就把结果返回
返回的结果也是通过http、这个就称为一个微服务！我们微服务用的是springcloud
对比Django课微服务实现方式、我们用的是通过http进行操作两边都是webserver
thrift用的是普通的socket来通信、其他的地方没有任何区别

每个服务是一个独立的程序，每个服务之间可以相互通信。此项目中，BackEnd 和 MatchSystem都是一个微服务！
当BackEnd接收到玩家开始匹配的请求，BackEnd会想MatchSystem发送http请求，通知MatchSystem开始匹配，
MatchSystem会单独开一个线程开始匹配，匹配逻辑为：每秒都会扫描匹配池中的所有玩家，判断玩家能否相互匹配，若能，则发送http请求给BackEnd。此项目使用的微服务技术是Spring Cloud。Spring Cloud技术涉及的很多不只是服务间的相关通信，还包括网关、负载均衡等优化配置，由于项目并发量没那么大，因此未使用这些技术。

二、创建SpringCloud目录

首先我们先创建一个SpringCloud的目录
整个项目的结果会做一个变化
需要创建一个新的父项目用来装两个并列的子项目
加入springweb依赖,这个微服务其实就是两个单独的服务
它可以接收信息也可以发送信息，spring里面我们是用http操作的
也就是创建了两个后端服务器都是通过url来通信的、thrift是通过socket来通信的
会稍微快一些、创建完之后我们需要先配置一下
由于父级项目是没有逻辑的我们可以把src目录删掉、删完之后我们修改一下pom
另外加上springcloud的依赖

Spring Cloud和Thrift的区别：
Spring Cloud：每个服务都是一个Server，每个Server相互通信使用的是http协议。
Thrift：用Thrift生成的微服务，BackEnd与服务之间的通信为Socket协议，比http快一些。

backendcloud/pom.xml：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.kob</groupId>
    <artifactId>backendcloud</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>backendcloud</name>
    <description>backendcloud</description>
    <!-- 修改处1 -->
    <packaging>pom</packaging>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- 修改处2 -->
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-dependencies -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2021.0.3</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <!-- 修改处3 -->
                <version>2.7.2</version>
            </plugin>
        </plugins>
    </build>

</project>

三、创建子项目

两个模块，我们需要匹配一些依赖
matchingsystem本质上也是一个springboot、我们需要将springboot的一些依赖加进去
迁移一下Springweb、然后我们点开我们的src然后我们来实现一下我们的匹配系统
匹配系统中我们需要实现几个接口呢、我们需要实现两个接口
第一个是添加一个玩家addplayer、第二个是removeplayer
有两个springboot每一个springboot都需要占用一个独立的端口
我们需要先把matchingsystem这个服务器配置一下端口、接下里java里创建两个接口

配置端口
在matchingsystem -> src -> main -> resources右键新建文件，文件名为：application.properties：

server.port=3001

四、实现接口

接下来在java里创建两个接口
创建接口的话我们就需要创建一个controller
定义两个接口、然后我们实现这两个接口、然后我们创建一个controller、注入接口
因为涉及到对玩家的修改、所以用post请求
MultiValueMap、是每一个关键字对应一个列表value、在这里需要加上一个权限控制

matchingsystem/service/MatchingService.java：

package com.kob.matchingsystem.service;

public interface MatchingService {

    String addPlayer(Integer userId, Integer rating);

    String removePlayer(Integer userId);
}

matchingsystem/service/impl/MatchingServiceImpl.java：

package com.kob.matchingsystem.service.impl;

import com.kob.matchingsystem.service.MatchingService;
import org.springframework.stereotype.Service;

@Service
public class MatchingServiceImpl implements MatchingService {

    @Override
    public String addPlayer(Integer userId, Integer rating) {
        System.out.println("Add Player: " + userId + " " + rating);
        return "add player success";
    }

    @Override
    public String removePlayer(Integer userId) {
        System.out.println("Remove Player: " + userId);
        return "Remove player success";
    }
}

matchingsystem/controller/MatchingController.java：

package com.kob.matchingsystem.controller;

import com.kob.matchingsystem.service.MatchingService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.Objects;

@RestController
public class MatchingController {
    @Autowired
    private MatchingService matchingService;

    // 参数不能使用普通map，MultiValueMap和普通map的区别时，这个是一个键对应多个值
    @PostMapping("/player/add/")
    public String addPlayer(@RequestParam MultiValueMap<String, String> data) {
        Integer userId = Integer.parseInt(Objects.requireNonNull(data.getFirst("user_id")));
        Integer rating = Integer.parseInt(Objects.requireNonNull(data.getFirst("rating")));
        return matchingService.addPlayer(userId, rating);
    }

    @PostMapping("/player/remove/")
    public String removePlayer(@RequestParam MultiValueMap<String, String> data) {
        Integer userId = Integer.parseInt(Objects.requireNonNull(data.getFirst("user_id")));
        return matchingService.removePlayer(userId);
    }
}

五、config网关配置

加上依赖
需要对链接加一个权限设置，只能被我们的后端服务器访问
可以通过ip地址来判断、只允许本地来访问，
写完之后写一下SpringBoot的入口
一个软件中可以使用多个springboot项目
add报405我们应该是post类型但是我们写的是get类型所以访问不了报405
remove是403是因为我们将add放行了，并没有将我们的remove链接放行
所以我们的权限是起到作用了

matchingsystem/config/SecurityConfig.java：

package com.kob.matchingsystem.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                // 放行这两个接口
                .antMatchers("/player/add/", "/player/remove/").hasIpAddress("127.0.0.1")
                .antMatchers(HttpMethod.OPTIONS).permitAll()
                .anyRequest().authenticated();
    }
}

matchingsystem/MatchSystemApplication.java：

package com.kob.matchingsystem;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MatchSystemApplication {
    public static void main(String[] args) {
        SpringApplication.run(MatchSystemApplication.class, args);
    }
}

六、放行API

这样我们的matchingserver的两个api就写完了
写完之后我们还需要对接一下我们前面的服务、我们还需要创建一个新的子项目
把我们前面的后端逻辑装起来

七、封装后端逻辑

我们还需要创建一个新的子项目
把我们前面的后端逻辑装起来，删掉src
把上节课的src复制过来、pom的话也把之前的pom复制过来即可

封装StartGame逻辑：

backend/consumer/WebSocketServer.java：

package com.kob.backend.consumer;

// 1.删除以下两个包
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArraySet;

@Component
// url链接：ws://127.0.0.1:3000/websocket/**
@ServerEndpoint("/websocket/{token}")  // 注意不要以'/'结尾
public class WebSocketServer {
    ...

    // 2.删除matchingPool变量

    ...

    @OnClose
    public void onClose() {
        // 关闭链接
        System.out.println("disconnected!");
        if(this.user != null) {
            users.remove(this.user.getId());
            // 3. 删除取消匹配逻辑
        }
    }

    // 4.抽取匹配成功后的逻辑为一个函数
    public static void startGame(Integer aId, Integer bId) {
        User a = userMapper.selectById(aId), b = userMapper.selectById(bId);
        Game game = new Game(13, 14, 20, a.getId(), b.getId());
        game.createMap();
        // 一局游戏一个线程，会执行game类的run方法
        game.start();

        users.get(a.getId()).game = game;
        users.get(b .getId()).game = game;

        JSONObject respGame = new JSONObject();
        // 玩家的id以及横纵信息
        respGame.put("a_id", game.getPlayerA().getId());
        respGame.put("a_sx", game.getPlayerA().getSx());
        respGame.put("a_sy", game.getPlayerA().getSy());
        respGame.put("b_id", game.getPlayerB().getId());
        respGame.put("b_sx", game.getPlayerB().getSx());
        respGame.put("b_sy", game.getPlayerB().getSy());
        respGame.put("map", game.getG());

        // 发送给A的信息
        JSONObject respA = new JSONObject();
        respA.put("event", "start-matching");
        respA.put("opponent_username", b.getUsername());
        respA.put("opponent_photo", b.getPhoto());
        respA.put("game", respGame);
        // 通过userId取出a的连接，给A发送respA
        users.get(a.getId()).sendMessage(respA.toJSONString());

        // 发送给B的信息
        JSONObject respB = new JSONObject();
        respB.put("event", "start-matching");
        respB.put("opponent_username", a.getUsername());
        respB.put("opponent_photo", a.getPhoto());
        respB.put("game", respGame);
        // 通过userId取出b的连接，给B发送respB
        users.get(b.getId()).sendMessage(respB.toJSONString());
    }

    // 5.删除原先匹配逻辑，把匹配的逻辑交给另一个服务，服务成功后再调用startGame函数开始游戏逻辑
    private void startMatching() {
        System.out.println("start matching!");
    }

    // 6.删除取消匹配逻辑
    private void stopMatching() {
        System.out.println("stop matching");
    }

    ...
}

八、对接匹配系统

我们需要让我们前面的链接对接到我们的匹配系统
需要打通这一步、我们之前实现了一个傻瓜式的匹配
只要有两个人就会匹配到一起、首先为了方便我们可以把匹配的逻辑封装成函数
把mathingpool所有的相关操作放到我们的匹配系统中、开始的时候我们应该在我们的
matchingserver发送我们的请求、表示我们传一个玩家过去
向后端发请求SpringBoot也有一个工具、如果我们需要在当前的component用到service的话
就把它先加个注解bean、想取得谁加一个bean注解然后获取就可以了
当我们需要用到某个东西的时候、就定一个它的configuration
加一个注解bean、返回它的实例然后就可以了
定义完之后、未来我们用它的时候就可以加一个Autowired就可以自动注入进来
加了Autowired的话
他就会去看一下他就会去看一下这个service这个接口是不是有唯一的加了注解bean的函数和它对应
如果有的话就调用一下这个函数把它的返回赋过来
RestTemplate：是一个工具可以来两个进程间进行通信
我们这里需要向后端发送一个请求

九、修改数据库

天梯积分应该放到user还是bot上?
其实都行习惯把天梯分放到个人身上、把rating从bot拿到user里面
在pojo里改一下配置\还有service层里改一下

backend/pojo/User.java：

package com.kob.backend.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    @TableId(type = IdType.AUTO)
    private Integer id;
    private String username;
    private String password;
    private String photo;
    private Integer rating;
}

backend/pojo/Bot.java：：


package com.kob.backend.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Bot {
    @TableId(type = IdType.AUTO)
    private Integer id;
    private Integer userId;
    private String title;
    private String description;
    private String content;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone="Asia/Shanghai")
    private Date createtime;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone="Asia/Shanghai")
    private Date modifytime;
}

backend/service/impl/user/account/RegisterServiceImpl.java：

package com.kob.backend.service.impl.user.account;

...

@Service
public class RegisterServiceImpl implements RegisterService {
    ...

    @Override
    public Map<String, String> register(String username, String password, String confirmedPassword) {
        ...

        // 修改处：增加rating为1500的分数
        User user = new User(null, username, encodedPassword, photo, 1500);

        ...
    }
}

backend/service/impl/user/bot/AddServiceImpl.java：

package com.kob.backend.service.impl.user.bot;

...

@Service
public class AddServiceImpl implements AddService {
    @Autowired
    private BotMapper botMapper;

    @Override
    public Map<String, String> add(Map<String, String> data) {
        ...

        Bot bot = new Bot(null, user.getId(), title, description, content, now, now);

        ...
    }
}

十、实现匹配之后的逻辑

当前已经实现浏览器端向云端发送了一个请求
我们在websocket当中接收到这个请求之后，它会把我们的请求再发送给我们的匹配系统
我们刚才看到的输出是在匹配系统中看到的输出、一个添加一个取消两个操作
下一步就是要实现我们匹配之后的逻辑了、收到请求之后的逻辑
接收到一个请求之后会将当前匹配的所有用户放到一个池子
然后我们开一个额外的新线程、是每隔一秒去扫描一遍数组
将能够匹配的人匹配到一起、匹配的时候、匹配两名分值比较相近的玩家
随着时间的推移、两名玩家允许的分差可以越来越大可能一开始a和b分值比较大
这两个人是不能匹配到一块的，但是随着时间推移我们发现没有其他玩家可以跟这两名玩家匹配
我们就可以逐步放大两名玩家的一个匹配范围、直到两名玩家都可以匹配到一块为止
具体就是、每位玩家有一个分值rating
第0秒的时候这个玩家只能匹配分差在十以内的玩家、第二秒的时候就可以匹配分差在20以内的玩家

创建一个类来存储玩家
匹配池是多线程类要继承自Thread
MatchingPool里面要把所有用户存起来

加上BackEnd发送给matchingsystem服务的添加玩家和删除玩家的请求：

backend/consumer/WebSocketServer.java：


package com.kob.backend.consumer;

...

import org.springframework.web.client.RestTemplate;
import org.springframework.util.MultiValueMap;
import org.springframework.util.LinkedMultiValueMap;

@Component
// url链接：ws://127.0.0.1:3000/websocket/**
@ServerEndpoint("/websocket/{token}")  // 注意不要以'/'结尾
public class WebSocketServer {
    private static RestTemplate restTemplate;
    private final static String addPlayerUrl = "http://127.0.0.1:3001/player/add/";
    private final static String removePlayerUrl = "http://127.0.0.1:3001/player/remove/";

    ...

    @Autowired
    public void setRestTemplate(RestTemplate restTemplate) {
        WebSocketServer.restTemplate = restTemplate;
    }

    private void startMatching() {
        System.out.println("start matching!");
        MultiValueMap<String, String> data = new LinkedMultiValueMap<>();
        data.add("user_id", this.user.getId().toString());
        data.add("rating", this.user.getRating().toString());
        restTemplate.postForObject(addPlayerUrl, data, String.class);
    }

    private void stopMatching() {
        System.out.println("stop matching");
        MultiValueMap<String, String> data = new LinkedMultiValueMap<>();
        data.add("user_id", this.user.getId().toString());
        restTemplate.postForObject(removePlayerUrl, data, String.class);
    }

    ...
}

十一、线程锁

这里不需要用线程安全的列表
因为这里会手动加锁、不管线程安全不安全
我们会把它变成安全、异步就是不是按照顺序执行的
会切换线程、顺序是乱的、我们需要两个线程范围我们的player
一个是匹配线程一个是我们传入参数的线程
这是我们添加一名玩家以及删除一名玩家

十二、匹配函数

我们需要写几个匹配函数
如何去匹配玩家呢？
我们可以开一个bool数组用来判断当前还剩下哪些人、从前往后去枚举每一个玩家
对于这个玩家我们需要去看一下哪个玩家和他匹配、如果有人可以和他匹配
我们就不匹配了、越老的玩家越具有优先选择权
分差能被ab接受\我们只需要判断我们的分差能不能被a和b等待时间的最小值*10就可以了

Player.java：

package com.kob.matchingsystem.service.impl.utils;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Player {
    private Integer userId;
    private Integer rating;
    private Integer waitingTime;
}

matchingsystem/service/impl/MatchingServiceImpl.java：

package com.kob.matchingsystem.service.impl;

...

import com.kob.matchingsystem.service.impl.utils.MatchingPool;

@Service
public class MatchingServiceImpl implements MatchingService {
    public static final MatchingPool matchingPool = new MatchingPool();

    @Override
    public String addPlayer(Integer userId, Integer rating) {
        System.out.println("Add Player: " + userId + " " + rating);
        matchingPool.addPlayer(userId, rating);
        return "add player success";
    }

    @Override
    public String removePlayer(Integer userId) {
        System.out.println("Remove Player: " + userId);
        matchingPool.removePlayer(userId);
        return "Remove player success";
    }
}

我们需要是调用sendresult函数的话
已经在匹配池匹配好了、server里需要能接收这个消息
写一个方法能够接收这个信息、写完之后对接口放行
就可以在sendresult中调用、用到RestTemplate

yan扬

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
项目实战——匹配系统（下）

上节课知识梳理：用户浏览器打开之后、两个client表示两个浏览器Client向云端server发送请求、有http的servercontroller还有ws的server、前端client会向websocket发请求发完请求之后、本来应该用微服务实现匹配系统向matchingsystem发送请求、表示我们加入了一个玩家matchingsystem匹配完之后向server返回一个结果当两名玩家匹配完之后、他们就会开一个线程。
复制链接

扫一扫

专栏目录