• Bot代码的执行（微服务）

    负责接收一段代码，把代码扔到我们的队列当中、每一次我们去运行一段代码
    运行结束之后、把我们的结果返回给我们的服务器

    先把依赖复制过来、我们需要动态的把用户传过来的Java代码编译然后执行
    需要加入依赖joor-java-8、用Java的代码的写法举例子
    未来自己实现的时候可以换成任意语言、在这个线程里面是有一堆的bot代码等待执行
    然后我们会有一个队列、每次我们从队列中取出一个bot代码来执行
    执行的时候用的是一个Java的包会方便的去帮我们动态编译一段Java代码
    未来可以在云端把他换成一个docker、你在云端自动启动一个docker容器
    给docker设置一个内存上限200M再去docker中动态执行一段Java代码用timeout
    去限制某一个程序的执行时间、这样又安全又可以支持其他语言
    所以这里我们用Java一个包来动态执行一段Java代码
    开一个线程用我们的joor去动态执行一段代码

     

    实现Service和Controller

    实现完service之后
    去实现我们的controller、怎么将SpringBoot和docker关联？
    SpringBoot里面可以直接执行shell命令
    注意要用127.0.0.1因为我们的config里写的是127.0.0.1

    前端加入选择框

    每一步的传递都需要加上额外的参数
    botid、前端先加上一个框
    中间加上一个复选框、需要动态的获得我们的bot列表
    这样我们的bot就传过来了、我们需要把bot的信息传回到前端

    把前面每一个通信都加上BotId

    前面通信的时候每一次通信都是没有加botid的
    userid、我们需要把前面每一个通信都加上botid 对应service层也要加上
    发的时候收的时候都需要传我们的id

    判断人或者机器+编码

    在创建完地图执行nextstep的时候
    判断一下当前的玩家是人还是代码、如果是代码的话就需要像我们的微服务发送一
    段代码、然后让她自动去算、如果是人来操作的话就要等待用户的输入
    所以这里需要判断一下如果player的botid=-1的话表示是由人来操作
    编码的时候我们随意编只要把我们的编码编成字符串就可以
    第一段传的是地图信息、中间用#号隔开

    消费者生产者模型

    微服务可以不断的去接收用户的一个输入
    当接收的代码比较多的时候、我们应该把他们所有接收到的代码放到一个队列里面
    我们每接收到一个任务、消费者是一个单独的线程
    苦力不断是完成任务，每来一个任务检测队列是否为空如果队列不空，从对头拿出
    代码执行、执行完之后再去检查

    consume里面开一个新的线程

    consume里面开一个新的线程
    如果被awit阻塞住后就会被唤醒、然后执行
    实现一下consume操作、需要在consume里面开一个新的线程
    这样我们就可以从前端动态的传一份代码过来传完之后动态的编译一遍
    编译完之后我们就可以动态的调用它编译后的结果

    代码执行，此项目只支持java代码的执行，用的是joor java 8实现

    可扩展为docker实现，设置内存上限，时间，用命令可执行所有语言代码，并具备一定安全性，因为docker与运行环境隔绝

    让BotRunning System获得到前端选择的Bot

    新建Bot执行微服务项目 

    右键backendcloud->新建->模块

    导包

    改pom

    2.         
    3.             org.springframework.boot
    4.             spring-boot-starter-web
    5.         
    6.  
    7.         
    8.             org.springframework.boot
    9.             spring-boot-starter-test
    10.             test
    11.         
    12.  
    13.         
    14.         
    15.             org.springframework.boot
    16.             spring-boot-starter-security
    17.             2.7.1
    18.         
    19.  
    20.         
    21.         
    22.             org.projectlombok
    23.             lombok
    24.             1.18.24
    25.             provided
    26.         
    27.  
    28.         
    29.         
    30.             org.jooq
    31.             joor-java-8
    32.             0.9.14
    33.         
    34.     
    35. 。

    BotRunningSystem接收前端选择的botId

    文件结构

    botrunningsystem
        config
            RestTemplateConfig.java
            SecurityConfig.java
        controller
            BotRunningController.java
        service
            impl
                BotRunningServiceImpl.java
            BotRunningService.java
        BotRunningSystemApplication.java

    将BotRunningSystem/Main.java 更名为 BotRunningSystemApplication.java

     

    1. @SpringBootApplication
    2. public class BotRunningSystemApplication {
    3.     public static void main(String[] args) {
    4.         SpringApplication.run(BotRunningSystemApplication.class, args);
    5.     }
    6. }

    接口

    1. public interface BotRunningService {
    2.  
    3.     String addBot(Integer userId, String botCode, String input);
    4. }

    接口实现

    1. @Service
    2. public class BotRunningServiceImpl implements BotRunningService {
    3.  
    4.     @Override
    5.     public String addBot(Integer userId, String botCode, String input) {
    6.         System.out.println("add bot: " + userId + " " + botCode + " " + input);
    7.         return "add bot success";
    8.     }
    9. }

    控制器

    1. @RestController
    2. public class BotRunningController {
    3.     @Autowired
    4.     private BotRunningService botRunningService;
    5.  
    6.     @PostMapping("/bot/add/")
    7.     public String addBot(@RequestParam MultiValueMap data) {
    8.         Integer userID = Integer.parseInt(Objects.requireNonNull(data.getFirst("user_id")));
    9.         String botCode = data.getFirst("bot_code");
    10.         String input = data.getFirst("input");
    11.         return botRunningService.addBot(userID, botCode, input);
    12.     }
    13. }
    14.

    权限控制(网关)

    1. @Configuration
    2. @EnableWebSecurity
    3. public class SecurityConfig extends WebSecurityConfigurerAdapter {
    4.     @Override
    5.     protected void configure(HttpSecurity http) throws Exception {
    6.         http.csrf().disable()
    7.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
    8.                 .and()
    9.                 .authorizeRequests()
    10.                 .antMatchers("/bot/add/").hasIpAddress("127.0.0.1")
    11.                 .antMatchers(HttpMethod.OPTIONS).permitAll()
    12.                 .anyRequest().authenticated();
    13.     }
    14. }

    服务间发送消息的RestTemplate

    1.  
    2. @Configuration
    3. public class RestTemplateConfig {
    4.  
    5.     @Bean
    6.     public RestTemplate getRestTemplate() {
    7.         return new RestTemplate();
    8.     }
    9. }

    端口配置

    在resources新建文件

    1. Application.properties
    2.  
    3. server.port=3002

    前端选择Bot

    匹配界面

    添加选择操作方式

    1. MatchGround.vue
    2.  
    4.  
    6.

    后端接收bot

    BackEnd接收Bot
    WebSocketServer接收到匹配请求，将bot传给匹配服务

    1. @Component
    2. // url链接：ws://127.0.0.1:3000/websocket/**
    3. @ServerEndpoint("/websocket/{token}")  // 注意不要以'/'结尾
    4. public class WebSocketServer {
    5.     ...
    6.  
    7.     private void startMatching(Integer botId) {
    8.         System.out.println("start matching!");
    9.         MultiValueMap data = new LinkedMultiValueMap<>();
    10.         data.add("user_id", this.user.getId().toString());
    11.         data.add("rating", this.user.getRating().toString());
    12.         data.add("bot_id", botId.toString());
    13.         restTemplate.postForObject(addPlayerUrl, data, String.class);
    14.     }
    15.  
    16.     ...
    17.  
    18.     @OnMessage
    19.     public void onMessage(String message, Session session) {
    20.         ...
    21.  
    22.         if("start-matching".equals(event)) {
    23.             startMatching(data.getInteger("bot_id"));
    24.         }
    25.  
    26.         ...
    27.     }
    28.  
    29.     ...
    30. }

    Matching System接收Bot

    Matching System接收到backend传的botId，将bot传给BotRunningSystem服务

    控制器

    1.  
    2. @RestController
    3. public class MatchingController {
    4.     @Autowired
    5.     private MatchingService matchingService;
    6.  
    7.     // 参数不能使用普通map，MultiValueMap和普通map的区别时，这个是一个键对应多个值
    8.     @PostMapping("/player/add/")
    9.     public String addPlayer(@RequestParam MultiValueMap data) {
    10.         ...
    11.  
    12.         Integer botId = Integer.parseInt(Objects.requireNonNull(data.getFirst("bot_id")));
    13.         return matchingService.addPlayer(userId, rating, botId);
    14.     }
    15.  
    16.     ...
    17. }

    接口

    1.  
    2. public interface MatchingService {
    3.  
    4.     String addPlayer(Integer userId, Integer rating, Integer botId);
    5.  
    6.     ...
    7. }

    接口实现

    1.  
    2. @Service
    3. public class MatchingServiceImpl implements MatchingService {
    4.     public static final MatchingPool matchingPool = new MatchingPool();
    5.  
    6.     @Override
    7.     public String addPlayer(Integer userId, Integer rating, Integer botId) {
    8.         System.out.println("Add Player: " + userId + " " + rating + " " + botId);
    9.         matchingPool.addPlayer(userId, rating, botId);
    10.         return "add player success";
    11.     }
    12.  
    13.     ...
    14. }

    匹配池

    1.  
    2. // 匹配池是多线程的
    3. @Component
    4. public class MatchingPool extends Thread {
    5.     ...
    6.  
    7.     public void addPlayer(Integer userId, Integer rating, Integer botId) {
    8.         // 在多个线程(匹配线程遍历players时，主线程调用方法时)会操作players变量，因此加锁
    9.         lock.lock();
    10.         try {
    11.             players.add(new Player(userId, rating, botId, 0));
    12.         } finally {
    13.             lock.unlock();
    14.         }
    15.     }
    16.  
    17.     ...
    18. }

    匹配池的Player

    1.  
    2. @Data
    3. @AllArgsConstructor
    4. @NoArgsConstructor
    5. public class Player {
    6.     private Integer userId;
    7.     private Integer rating;
    8.     private Integer botId;
    9.     private Integer waitingTime;
    10. }

    匹配池返回结果加上botId

    1. // 匹配池是多线程的
    2. @Component
    3. public class MatchingPool extends Thread {
    4.     ...
    5.  
    6.     private void sendResult(Player a, Player b) {   // 返回匹配结果
    7.         System.out.println("send result: " + a + " " + b);
    8.         MultiValueMap data = new LinkedMultiValueMap<>();
    9.         data.add("a_id", a.getUserId().toString());
    10.         data.add("a_bot_id", a.getBotId().toString());
    11.         data.add("b_id", b.getUserId().toString());
    12.         data.add("b_bot_id", b.getBotId().toString());
    13.         restTemplate.postForObject(startGameUrl, data, String.class);
    14.     }
    15.  
    16.     ...
    17. }

    BackEnd接收匹配成功返回的botId

    StartGameController.java

    1.  
    2. @RestController
    3. public class StartGameController {
    4.     ...
    5.  
    6.     @PostMapping("/pk/start/game/")
    7.     public String startGame(@RequestParam MultiValueMap data) {
    8.         Integer aId = Integer.parseInt(Objects.requireNonNull(data.getFirst("a_id")));
    9.         Integer aBotId = Integer.parseInt(Objects.requireNonNull(data.getFirst("a_bot_id")));
    10.         Integer bId = Integer.parseInt(Objects.requireNonNull(data.getFirst("b_id")));
    11.         Integer bBotId = Integer.parseInt(Objects.requireNonNull(data.getFirst("b_bot_id")));
    12.         return startGameService.startGame(aId, aBotId, bId, bBotId);
    13.     }
    14. }

    StartGameService.java

    1. public interface StartGameService {
    2.  
    3.     String startGame(Integer aId, Integer aBotId, Integer bId, Integer bBotId);
    4. }

    StartGameServiceImpl.java

    1. @Service
    2. public class StartGameServiceImpl implements StartGameService {
    3.  
    4.     @Override
    5.     public String startGame(Integer aId, Integer aBotId, Integer bId, Integer bBotId) {
    6.         System.out.println("start gameL: " + aId + " " + bId);
    7.         WebSocketServer.startGame(aId, aBotId, bId, bBotId);
    8.         return "start game success";
    9.     }
    10. }
    11.

    WebSocketServer.java

    1.  
    2. @Component
    3. // url链接：ws://127.0.0.1:3000/websocket/**
    4. @ServerEndpoint("/websocket/{token}")  // 注意不要以'/'结尾
    5. public class WebSocketServer {
    6.     ...
    7.  
    8.     public static BotMapper botMapper;
    9.  
    10.     ...
    11.  
    12.     @Autowired
    13.     public void setBotMapper(BotMapper botMapper) {
    14.         WebSocketServer.botMapper = botMapper;
    15.     }
    16.  
    17.     ...
    18.  
    19.     public static void startGame(Integer aId, Integer aBotId, Integer bId, Integer bBotId) {
    20.         User a = userMapper.selectById(aId), b = userMapper.selectById(bId);
    21.         Bot botA = botMapper.selectById(aBotId), botB = botMapper.selectById(bBotId);
    22.  
    23.         Game game = new Game(
    24.                 13,
    25.                 14,
    26.                 20,
    27.                 a.getId(),
    28.                 botA,
    29.                 b.getId(),
    30.                 botB);
    31.  
    32.         ...
    33.     }
    34.  
    35.     ...
    36.  
    37. }
    38.

    Player.java

    1. @Data
    2. @AllArgsConstructor
    3. @NoArgsConstructor
    4. public class Player {
    5.     private Integer id;
    6.     private Integer botId;  // -1表示亲自出马，否则表示用AI打
    7.     private String botCode;
    8.  
    9.     ...
    10. }

    WebSocketServer.java

    将RestTemplate变成public，若是代码输入则屏蔽人的输入

    1. @Component
    2. // url链接：ws://127.0.0.1:3000/websocket/**
    3. @ServerEndpoint("/websocket/{token}")  // 注意不要以'/'结尾
    4. public class WebSocketServer {
    5.     ...
    6.  
    7.     public static RestTemplate restTemplate;
    8.  
    9.     private void move(int direction) {
    10.         if(game.getPlayerA().getId().equals(user.getId())) {
    11.             if(game.getPlayerA().getBotId().equals(-1))     // 亲自出马则接收输入
    12.                 game.setNextStepA(direction);
    13.         } else if(game.getPlayerB().getId().equals(user.getId())) {
    14.             if(game.getPlayerB().getBotId().equals(-1))
    15.                 game.setNextStepB(direction);
    16.         }
    17.     }
    18.  
    19.     ...
    20. }
    21.

    Game.java

    1. public class Game extends Thread {
    2.     ...
    3.  
    4.     private static final String addBotUrl = "http://127.0.0.1:3002/bot/add/";
    5.  
    6.  
    7.     public Game(
    8.             Integer rows,
    9.             Integer cols,
    10.             Integer inner_walls_count,
    11.             Integer idA,
    12.             Bot botA,
    13.             Integer idB,
    14.             Bot botB
    15.     ) {
    16.         this.rows = rows;
    17.         this.cols = cols;
    18.         this.inner_walls_count = inner_walls_count;
    19.         this.g = new int[rows][cols];
    20.  
    21.         Integer botIdA = -1, botIdB = -1;
    22.         String botCodeA = "", botCodeB = "";
    23.  
    24.         if(botA != null) {
    25.             botIdA = botA.getId();
    26.             botCodeA = botA.getContent();
    27.         }
    28.         if(botB != null) {
    29.             botIdB= botB.getId();
    30.             botCodeB = botB.getContent();
    31.         }
    32.  
    33.         playerA = new Player(idA, botIdA, botCodeA, rows - 2, 1, new ArrayList<>());
    34.         playerB = new Player(idB, botIdB, botCodeB, 1, cols - 2, new ArrayList<>());
    35.     }
    36.  
    37.  
    38.     private String getInput(Player player) {    // 将当前局面信息编码成字符串
    39.         // 地图#my.sx#my.sy#my操作#you.sx#you.sy#you操作
    40.         Player me, you;
    41.         if(playerA.getId().equals(player.getId())) {
    42.             me = playerA;
    43.             you = playerB;
    44.         } else {
    45.             me = playerB;
    46.             you = playerA;
    47.         }
    48.  
    49.         return getMapString() + "#" +
    50.                 me.getSx() + "#" +
    51.                 me.getSy() + "#(" +
    52.                 me.getStepsString() + ")#" +    // 加()是为了预防操作序列为空
    53.                 you.getSx() + "#" +
    54.                 you.getSy() + "#(" +
    55.                 you.getStepsString() + ")";
    56.     }
    57.  
    58.     private void sendBotCode(Player player) {
    59.         if(player.getBotId().equals(-1)) return;
    60.         MultiValueMap data = new LinkedMultiValueMap<>();
    61.         data.add("user_id", player.getId().toString());
    62.         data.add("bot_code", player.getBotCode());
    63.         data.add("input", getInput(player));
    64.         WebSocketServer.restTemplate.postForObject(addBotUrl, data, String.class);
    65.     }
    66.  
    67.     // 接收玩家的下一步操作
    68.     private boolean nextStep() {
    69.         // 每秒五步操作，因此第一步操作是在200ms后判断是否接收到输入。
    70.         try {
    71.             Thread.sleep(200);
    72.         } catch (InterruptedException e) {
    73.             throw new RuntimeException(e);
    74.         }
    75.  
    76.         sendBotCode(playerA);
    77.         sendBotCode(playerB);
    78.  
    79.         ...
    80.     }
    81.  
    82.     ...
    83.  
    84. }
    85.

    BotRunning System的实现

     

    思路：

    评测器是一个经典的生产者消费者模型，此服务生产者会将任务放进一个队列中，
    消费者是单独的一个线程，当有任务就会从队头立即执行；并且关键问题是评测
    器的执行代码不能单纯的用sleep 1s去判断是否有任务，这样很影响评测体验，
    因此需要用到Condition Variable，当有任务执行，无任务等待。

    文件结构

     matchingsystem
        service
            impl
                utils
                    Bot.java
                    BotPool.java
                    Consumer.java
        utils
            Bot.java
            BotInterface.java

    Bot的实现

    1. @Data
    2. @AllArgsConstructor
    3. @NoArgsConstructor
    4. public class Bot {
    5.     Integer userId;
    6.     String botCode;
    7.     String input;
    8. }

     

    BotPoll的实现

    虽然队列没用消息队列，但是因为我们写了条件变量与锁的操作，所以等价于消息队列

    1. public class BotPool extends Thread {
    2.     // 以下的锁和条件变量加不加static都可以，因为BotPool只有一个
    3.     private final ReentrantLock lock = new ReentrantLock();
    4.     private final Condition condition = lock.newCondition();
    5.     private final Queue bots = new LinkedList<>();
    6.  
    7.     public void addBot(Integer userId, String botCode, String input) {
    8.         lock.lock();
    9.         try {
    10.             bots.add(new Bot(userId, botCode, input));
    11.             condition.signalAll();
    12.         } finally {
    13.             lock.unlock();
    14.         }
    15.     }
    16.  
    17.     private void consume(Bot bot) {
    18.  
    19.     }
    20.  
    21.     @Override
    22.     public void run() {
    23.         while(true) {
    24.             lock.lock();
    25.             if(bots.isEmpty()) {
    26.                 try {
    27.                     // 若执行了await会自动释放锁
    28.                     condition.await();
    29.                 } catch (InterruptedException e) {
    30.                     e.printStackTrace();
    31.                     lock.unlock();
    32.                     break;
    33.                 }
    34.             } else {
    35.                 Bot bot = bots.remove();
    36.                 lock.unlock();
    37.                 // 耗时操作，因此要在释放锁之后执行
    38.                 consume(bot);
    39.             }
    40.         }
    41.     }

    BotRunningServiceImpl.java

    加任务

    1. @Service
    2. public class BotRunningServiceImpl implements BotRunningService {
    3.     public static final BotPool botPool = new BotPool();
    4.  
    5.     @Override
    6.     public String addBot(Integer userId, String botCode, String input) {
    7.         System.out.println("add bot: " + userId + " " + botCode + " " + input);
    8.         botPool.addBot(userId, botCode, input);
    9.         return "add bot success";
    10.     }
    11. }
    12.

     BotPool线程的启动

    1. @SpringBootApplication
    2. public class BotRunningSystemApplication {
    3.     public static void main(String[] args) {
    4.         BotRunningServiceImpl.botPool.start();
    5.         SpringApplication.run(BotRunningSystemApplication.class, args);
    6.     }
    7. }

    BotInterface.java

    用户写Bot实现的接口

    1. BotInterface.java
    2.  
    3.  
    4. public interface BotInterface {
    5.     Integer nextMove(String input);
    6. }

    Bot.java

    1. public class Bot implements BotInterface {
    2.  
    3.     @Override
    4.     public Integer nextMove(String input) {
    5.         return 0;   // 向上走
    6.     }
    7. }

    Consumer的实现

    docker与沙箱分别有什么区别

    1. public class Consumer extends Thread {
    2.     private Bot bot;
    3.  
    4.     public void startTimeout(long timeout, Bot  bot) {
    5.         this.bot = bot;
    6.         this.start();
    7.  
    8.         // 在 程序运行结束后 或 程序在指定timeout时间后还未执行完毕 直接中断代码执行
    9.         try {
    10.             this.join(timeout);
    11.             this.interrupt();
    12.         } catch (InterruptedException e) {
    13.             e.printStackTrace();
    14.         } finally {
    15.             this.interrupt();
    16.         }
    17.     }
    18.  
    19.     private String addUid(String code, String uid) {    // 在code中的Bot类名后添加uid
    20.         int k = code.indexOf(" implements BotInterface");
    21.         return code.substring(0, k) + uid + code.substring(k);
    22.     }
    23.  
    24.     @Override
    25.     public void run() {
    26.         UUID uuid = UUID.randomUUID();
    27.         String uid = uuid.toString().substring(0, 8);
    28.         BotInterface botInterface = Reflect.compile(
    29.                 "com.kob.botrunningsystem.utils.Bot" + uid,
    30.                 addUid(bot.getBotCode(), uid)
    31.         ).create().get();
    32.  
    33.         Integer direction = botInterface.nextMove(bot.getInput());
    34.         System.out.println("move-direction: " + bot.getUserId() + " " + direction);
    35.     }
    36. }

    调用Consumer

    1. public class BotPool extends Thread {
    2.     ...
    3.  
    4.     private void consume(Bot bot) {
    5.         Consumer consumer = new Consumer();
    6.         consumer.startTimeout(2000, bot);
    7.     }
    8.  
    9.     ...
    10. }

    前端Bug的修改

    在游戏结束后，点到其他页面再点回pk页面，结果没有消失

    1. PkIndexView.vue
    2.  
    4.  
    6.

    将Bot执行结果传给前端

    BackEnd接收Bot代码的结果

    文件结构

    backend
        controller
            pk
                ReceiveBotMoveController.java
        service
            impl
                pk
                    ReceiveBotMoveServiceImpl.java
            pk
                ReceiveBotMoveService.java
     

    接口

    1. public interface ReceiveBotMoveService {
    2.  
    3.     String receiveBotMove(Integer userId, Integer direction);
    4. }

     WebSocketServer操作类

    将game改为public

    1. ...
    2.  
    3. @Component
    4. // url链接：ws://127.0.0.1:3000/websocket/**
    5. @ServerEndpoint("/websocket/{token}")  // 注意不要以'/'结尾
    6. public class WebSocketServer {
    7.     ...
    8.  
    9.     public Game game = null;
    10.  
    11.     ...
    12. }

    接口实现

    1. @Service
    2. public class ReceiveBotMoveServiceImpl implements ReceiveBotMoveService {
    3.  
    4.     @Override
    5.     public String receiveBotMove(Integer userId, Integer direction) {
    6.         System.out.println("receive bot move: " + userId + " " + direction + " ");
    7.         if(WebSocketServer.users.get(userId) != null) {
    8.             Game game = WebSocketServer.users.get(userId).game;
    9.             if(game != null) {
    10.                 if(game.getPlayerA().getId().equals(userId)) {
    11.                     game.setNextStepA(direction);
    12.                 } else if(game.getPlayerB().getId().equals(userId)) {
    13.                     game.setNextStepB(direction);
    14.                 }
    15.             }
    16.         }
    17.         return "receive bot move success";
    18.     }
    19. }
    20.

    控制器

    1. @RestController
    2. public class ReceiveBotMoveController {
    3.     @Autowired
    4.     private ReceiveBotMoveService receiveBotMoveService;
    5.  
    6.     @PostMapping("/pk/receive/bot/move/")
    7.     public String receiveBotMove(@RequestParam MultiValueMap data) {
    8.         Integer userId = Integer.parseInt(Objects.requireNonNull(data.getFirst("user_id")));
    9.         Integer direction = Integer.parseInt(Objects.requireNonNull(data.getFirst("direction")));
    10.         return receiveBotMoveService.receiveBotMove(userId, direction);
    11.     }
    12. }

    权限控制(网关)

    放行接口

    1.  
    2. @Configuration
    3. @EnableWebSecurity
    4. public class SecurityConfig extends WebSecurityConfigurerAdapter {
    5.     ...
    6.  
    7.     @Override
    8.     protected void configure(HttpSecurity http) throws Exception {
    9.         http.csrf().disable()
    10.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
    11.                 .and()
    12.                 .authorizeRequests()
    13.                 // 放行这两个接口
    14.                 .antMatchers("/user/account/token/", "/user/account/register/", "/getKaptcha").permitAll()
    15.                 .antMatchers("/pk/start/game/", "/pk/receive/bot/move/").hasIpAddress("127.0.0.1")
    16.                 .antMatchers(HttpMethod.OPTIONS).permitAll()
    17.                 .anyRequest().authenticated();
    18.  
    19.         http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    20.     }
    21.  
    22.     ...
    23. }

    BotRunningSystem返回Bot执行结果

    Consumer.java

    1. package com.kill9.botsystem.service.impl.utils;
    2.  
    3. import com.kill9.botsystem.utils.BotInterface;
    4. import org.joor.Reflect;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.stereotype.Component;
    7. import org.springframework.util.LinkedMultiValueMap;
    8. import org.springframework.util.MultiValueMap;
    9. import org.springframework.web.client.RestTemplate;
    10.  
    11. import java.util.UUID;
    12.  
    13. @Component
    14. public class Consumer extends Thread{
    15.  
    16.     private Bot bot;
    17.  
    18.     private static RestTemplate restTemplate;
    19.     private final static String receiveBotMoveUrl = "http://127.0.0.1:3000/pk/receive/bot/move";
    20.  
    21.     @Autowired
    22.     public void setRestTemplate(RestTemplate restTemplate){
    23.         Consumer.restTemplate = restTemplate;
    24.     }
    25.     public void startTimeOut(long timeout,Bot bot) {
    26.         this.bot = bot;
    27.         //开一个新的线程去执行run
    28.         this.start();
    29.  
    30.         //当前线程继续执行join ,等待时间超过timeout
    31.         try{
    32.             this.join(timeout);
    33.         }catch (InterruptedException e){
    34.             e.printStackTrace();
    35.         }finally {
    36.             this.interrupt();//中断当前线程
    37.         }
    38.     }
    39.  
    40.     private String addUid(String code,String uid){
    41.         //在code中的Bot类名 后添加Uid
    42.         int k = code.indexOf(" implements com.kill9.botsystem.utils.BotInterface");
    43.         return code.substring(0,k)+uid+code.substring(k);
    44.     }
    45.     @Override
    46.     public void run() {
    47.         //动态编译一个代码  如果类重名的话，只会编译一次 ，为了能够让类名不一样 + uuid
    48.         UUID uuid = UUID.randomUUID();
    49.         //前8位
    50.         String uid = uuid.toString().substring(0,8);
    51.         BotInterface botInterface = Reflect.compile(
    52.                 "com.kill9.botsystem.utils.Bot"+uid,
    53.                 addUid(bot.getBotCode(), uid)
    54.         ).create().get();
    55.         Integer direction = botInterface.nextMove(bot.getInput());
    56.         System.out.println("move-d:" + bot.getUserId() + " "+ direction);
    57.         MultiValueMap data = new LinkedMultiValueMap<>();
    58.         data.add("user_id",bot.getUserId().toString());
    59.         data.add("direction",direction.toString());
    60.         //结果返回给backend服务器
    61.         restTemplate.postForObject(receiveBotMoveUrl,data,String.class);
    62.     }
    63. }

     

    厉害的bot代码：

    1. public class Bot implements BotInterface {
    2.  
    3.     static class Cell {
    4.         public int x, y;
    5.         public Cell(int x, int y) {
    6.             this.x = x;
    7.             this.y = y;
    8.         }
    9.     }
    10.  
    11.     // 检查当前回合，蛇的长度是否会增加
    12.     private boolean check_tail_increasing(int step) {
    13.         if(step <= 10) return true;
    14.         return step % 3 == 1;
    15.     }
    16.  
    17.     public List getCells(int sx, int sy, String steps) {
    18.         steps = steps.substring(1, steps.length() - 1);
    19.         List res = new ArrayList<>();
    20.  
    21.         int[] dx = {-1, 0, 1, 0}, dy = {0, 1, 0, -1};
    22.         int x = sx, y = sy;
    23.         int step = 0;
    24.         res.add(new Cell(x, y));
    25.         for(int i = 0; i < steps.length(); i++) {
    26.             int d = steps.charAt(i) - '0';
    27.             x += dx[d];
    28.             y += dy[d];
    29.             res.add(new Cell(x, y));
    30.             if(!check_tail_increasing(++step)) {
    31.                 res.remove(0);
    32.             }
    33.         }
    34.         return res;
    35.     }
    36.  
    37.     @Override
    38.     public Integer nextMove(String input) {
    39.         // 地图#my.sx#my.sy#(my操作)#you.sx#you.sy#(you操作)
    40.         String[] strs = input.split("#");
    41.         int[][] g = new int[13][14];
    42.         for(int i = 0, k = 0; i < 13; i++) {
    43.             for(int j = 0; j < 14; j++, k++) {
    44.                 if(strs[0].charAt(k) == '1') {
    45.                     g[i][j] = 1;
    46.                 }
    47.             }
    48.         }
    49.  
    50.         int aSx = Integer.parseInt(strs[1]), aSy = Integer.parseInt(strs[2]);
    51.         int bSx = Integer.parseInt(strs[4]), bSy = Integer.parseInt(strs[5]);
    52.  
    53.         List aCells = getCells(aSx, aSy, strs[3]);
    54.         List bCells = getCells(bSx, bSy, strs[6]);
    55.  
    56.         for(Cell c : aCells) g[c.x][c.y] = 1;
    57.         for(Cell c : bCells) g[c.x][c.y] = 1;
    58.  
    59.         int[] dx = {-1, 0, 1, 0}, dy = {0, 1, 0, -1};
    60.         for(int i = 0; i < 4; i++) {
    61.             int x = aCells.get(aCells.size() - 1).x + dx[i];
    62.             int y = aCells.get(aCells.size() - 1).y + dy[i];
    63.             if(x >= 0 && x < 13 && y >= 0 && y < 14 && g[x][y] == 0) {
    64.                 return i;
    65.             }
    66.         }
    67.         return 0;
    68.     }
    69. }

  • 相关阅读:
    （一）. 贝叶斯滤波器
    【前端设计模式】之原型模式
    【LeetCode热题100】--73.矩阵置零
    LIN总线帧结构及各场干扰 上
    折半搜索-oier复健练习题目
    企业微信代开发应用登录操作
    Python的常用排序算法实现
    在Linux上安装RStudio工具并实现本地远程访问【内网穿透】
    拖拽（高度自定义）
    µC/OS-II---两个系统任务
  • 原文地址：https://blog.csdn.net/weixin_49884716/article/details/127970775