对英雄联盟比赛预测（三）- 数据获取Java实现

最新推荐文章于 2022-02-09 16:36:47 发布
最新推荐文章于 2022-02-09 16:36:47 发布
阅读量1.3k 收藏 2
点赞数 1
分类专栏： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/majixiang1996/article/details/112757374
版权

系列文章目录

对英雄联盟比赛预测（一）- 特征分析
对英雄联盟比赛预测（二）- 数据获取api分析
对英雄联盟比赛预测（三）- 数据获取Java实现

文章目录

声明

本文所提到的爬虫方法仅供学习研究使用，不得用于商业用途

前言

前面几篇文章，主要讲述lol比赛的影响因素和riotgames 提供对外的api，本文主要讲述如何利用前面两篇文章的内容，去真正实现一个自动化的爬虫。

一、基本框架

本文以SpringBoot为主框架，引用apache httpclient，apache commons-io和google guava为辅，另外解析json由alibaba fastjson实现，idea插件引入lombok。

二、基本配置

1. maven依赖配置

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.4</version>
        </dependency>

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.13</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>30.1-jre</version>
        </dependency>
        
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>

2. properties配置

# the apikey applied by riotgames: https://developer.riotgames.com/
spider.riotgames.apikey=RGAPI-74967532-db62-4129-a292-a3f0d5713f88

spider.riotgames.lol.base-url=https://developer.riotgames.com
# these urls below are start with br1, because the data regions are br1, but there are some other region like kr, na1 etc.
spider.riotgames.lol.summoner.byname.url=https://br1.api.riotgames.com/tft/summoner/v1/summoners/by-name/%s

# the urls below is to get lol match details
spider.riotgames.lol.matchlist.byaccount.url=https://br1.api.riotgames.com/lol/match/v4/matchlists/by-account/%s?beginIndex=%d
spider.riotgames.lol.match.detail.url=https://br1.api.riotgames.com/lol/match/v4/matches/%s
spider.riotgames.lol.match.timelines.url=https://br1.api.riotgames.com/lol/match/v4/timelines/by-match/%s

三、模块详解

本项目中共分为

  • client
    改造httpClient，实现一些自定义的属性
  • config
    riotgames的一些配置
  • entity
    取/存数据的基本实体类
  • pipeline
    定义了两个中间件，实现类似消息队列的功能
  • scheduler
    定时任务
  • service
    爬虫的主要逻辑

六个部分实现

本次最终获得数据并未入数据库，而是以json文件的格式，保存在本地

1. client

client模块共包含两个类

  • RiotGamesClient

/**
 * @date 2021/1/16 20:34
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Component
public class RiotGamesClient {
    private static RateLimiter rateLimiterMin = RateLimiter.create(100, 2, TimeUnit.MINUTES);
    private static RateLimiter rateLimiterSec = RateLimiter.create(20, 1, TimeUnit.SECONDS);
    private static HttpClient httpClient;

    private static final String UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36";
    private static final String AP = "*/*";
    private static final String AL = "zh-CN,zh;q=0.9";

    @Autowired
    private RiotGamesConfig riotGamesConfig;


    private HttpClient getClient() {
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectionRequestTimeout(5000)
                .setConnectTimeout(5000).build();

        List<Header> headerList = new ArrayList<>(5);
        headerList.add(new BasicHeader(HttpHeaders.USER_AGENT, UA));
        headerList.add(new BasicHeader(HttpHeaders.ACCEPT, AP));
        headerList.add(new BasicHeader(HttpHeaders.ACCEPT_LANGUAGE, AL));
        headerList.add(new BasicHeader("Origin", riotGamesConfig.getLolBaseUrl()));
        headerList.add(new BasicHeader("X-Riot-Token", riotGamesConfig.getApiKey()));

        httpClient = HttpClientBuilder.create().
                setDefaultRequestConfig(requestConfig)
                .setDefaultHeaders(headerList)
                .setRetryHandler(retryHandler())
                .build();
        return this.httpClient;
    }

    public HttpResponse execute(HttpUriRequest httpRequest) throws IOException {
        rateLimiterMin.acquire(1);
        rateLimiterSec.acquire(1);
        return this.getClient().execute(httpRequest);
    }

    private static HttpRequestRetryHandler retryHandler(){
        return (exception, executionCount, context) -> {

            System.out.println("riotGames api retry request: " + executionCount);
            if (executionCount >= 5) {
                // Do not retry if over max retry count
                return false;
            }
            if (exception instanceof InterruptedIOException) {
                // Timeout
                return false;
            }
            if (exception instanceof UnknownHostException) {
                // Unknown host
                return false;
            }
            if (exception instanceof SSLException) {
                // SSL handshake exception
                return false;
            }

            if(exception instanceof SocketTimeoutException) {
                return true;
            }
            HttpClientContext clientContext = HttpClientContext.adapt(context);
            HttpRequest request = clientContext.getRequest();
            boolean idempotent = !(request instanceof HttpEntityEnclosingRequest);
            if (idempotent) {
                // Retry if the request is considered idempotent
                return true;
            }
            return false;
        };
    }


}
  • RiotGamesRetryHandler

/**
 * @date 2021/1/17 17:48
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
public class RiotGamesRetryHandler implements HttpRequestRetryHandler {
    @Override
    public boolean retryRequest(IOException e, int i, HttpContext httpContext) {
        return false;
    }
}

在RiotGamesClient中定义了两个RateLimiter，是因为拳头的api限制了api访问速度：每秒最多20个，每两分钟最多100个，所以，我们必须在发送http请求时对一定时间内的请求数量做限制，我们这里采用的是guava的RateLimiter。

插一句：google的guava是一个非常强大的jdk补充库，值得一学。

2. config

config这个模块只有一个配置类，为其他模块提供配置参数。

/**
 * @date 2021/1/17 1:30
 * @auth jixiang.ma@transwarp.io
 * @copyright copyright © 2021 www.jixiang.ma all right reserved.
 **/
@Configuration
@Getter
public class RiotGamesConfig {
    @Value("${spider.riotgames.apikey}")
    private String apiKey;
    
    @Value("${spider.riotgames.lol.base-url}")
    private String lolBaseUrl;
    
    @Value("${spider.riotgames.lol.summoner.byname.url}")
    private String lolSummonerUrl;
    
    @Value("${spider.riotgames.lol.matchlist.byaccount.url}")
    private String lolMatchListByAccountUrl;
    
    @Value("${spider.riotgames.lol.match.detail.url}")
    private String lolMatchDetailUrl;
    
    @Value("${spider.riotgames.lol.match.timelines.url}")
    private String lolMatchTimeLinesUrl;
}

3. entity

这个模块是整个爬虫中的基础，一切数据都依靠entity中的实体类交互。

  • Ban
/**
 * @date 2021/1/17 13:38
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Getter
@Setter
public class Ban {
    private Integer championId;
    private Integer pickTurn;
}
  • Frame
/**
 * @date 2021/1/17 14:59
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Getter
@Setter
@ToString
public class Frame {
    private List<ParticipantFrame> participantFrames;
    private Long timestamp;
    private List<Event> events;
}
  • Match

/**
 * @date 2021/1/17 13:11
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Getter
@Setter
public class Match {
    private String platformId;
    private Long gameId;
    private Integer champion;
    private Integer queue;
    private Integer season;
    private Long timestamp;
    private String role;
    private String lane;
}
  • MatchDetail
/**
 * @date 2021/1/17 13:26
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Getter
@Setter
@ToString
public class MatchDetail {
    private Long gameId;
    private String platformId;
    private Long gameCreation;
    private Long gameDuration;
    private Integer queueId;
    private Integer mapId;
    private Integer seasonId;
    private String gameVersion;
    private String gameMode;
    private String gameType;
    private List<Team> teams;
    private List<Participants> participants;
    private List<ParticipantIdentities> participantIdentities;
    private List<Ban> bans;
}
  • MatchList

/**
 * @date 2021/1/17 14:48
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Data
public class MatchList {
    private List<Match> matches;
    private Integer startIndex;
    private Integer endIndex;
    private Integer totalGames;
}
  • ParticipantFrame
/**
 * @date 2021/1/17 14:27
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Setter
@Getter
@ToString
public class ParticipantFrame {
    private Integer participantId;
    private Integer currentGold;
    private Integer totalGold;
    private Integer level;
    private Integer xp;
    private Integer minionsKilled;
    private Integer jungleMinionsKilled;
    private Integer dominionScore;
    private Integer teamScore;
}
  • ParticipantIdentities
/**
 * @date 2021/1/17 13:31
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Getter
@Setter
@ToString
public class ParticipantIdentities {
    private Integer participantId;
    private Player player;
}
  • Participants
/**
 * @date 2021/1/17 13:30
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Getter
@Setter
public class Participants {
    private Integer participantId;
    private Integer teamId;
    private Integer championId;
    private Integer spell1Id;
    private Integer spell2Id;
}
  • Player
/**
 * @date 2021/1/17 15:56
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Getter
@Setter
@ToString
public class Player {
    private String platformId;
    private String accountId;
    private String summonerName;
    private String summonerId;
    private String currentAccountId;
    private String currentPlatformId;
    private String matchHistoryUri;
}
  • Stats
/**
 * @date 2021/1/17 13:42
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Getter
@Setter
public class Stats {
    private Integer participantId;
    private Boolean win;
    private Integer item0;
    private Integer item1;
    private Integer item2;
    private Integer item3;
    private Integer item4;
    private Integer item5;
    private Integer item6;
    private Integer kills;
    private Integer deaths;
    private Integer assists;
    private Integer largestKillingSpree;
    private Integer largestMultiKill;
    private Integer killingSprees;
    private Integer longestTimeSpentLiving;
    private Integer doubleKills;
    private Integer tripleKills;
    private Integer quadraKills;
    private Integer pentaKills;
    private Integer unrealKills;
    private Integer totalDamageDealt;
    private Integer magicDamageDealt;
    private Integer physicalDamageDealt;
    private Integer trueDamageDealt;
    // 最大伤害
    private Integer largestCriticalStrike;
    private Integer totalDamageDealtToChampions;
    private Integer magicDamageDealtToChampions;
    private Integer physicalDamageDealtToChampions;
    private Integer trueDamageDealtToChampions;
    private Integer totalHeal;
    private Integer totalUnitsHealed;
    private Integer damageSelfMitigated;
    private Integer damageDealtToObjectives;
    private Integer damageDealtToTurrets;
    private Integer visionScore;
    private Integer timeCCingOthers;
    private Integer totalDamageTaken;
    private Integer magicalDamageTaken;
    private Integer physicalDamageTaken;
    private Integer trueDamageTaken;
    private Integer goldEarned;
    private Integer goldSpent;
    private Integer turretKills;
    private Integer inhibitorKills;
    private Integer totalMinionsKilled;
    private Integer neutralMinionsKilled;
    private Integer neutralMinionsKilledTeamJungle;
    private Integer neutralMinionsKilledEnemyJungle;
    private Integer totalTimeCrowdControlDealt;
    private Integer champLevel;
    private Integer visionWardsBoughtInGame;
    private Integer sightWardsBoughtInGame;
    private Integer wardsPlaced;
    private Integer wardsKilled;
    private Boolean firstBloodKill;
    private Boolean firstBloodAssist;
    private Boolean firstTowerKill;
    private Boolean firstTowerAssist;
    private Boolean firstInhibitorKill;
    private Boolean firstInhibitorAssist;
}
  • Summoner
/**
 * @date 2021/1/16 20:22
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Getter
@Setter
@ToString
public class Summoner {
    private String id;
    private String accountId;
    private String puuid;
    private String name;
    private Integer profileIconId;
    private Long revisionDate;
    private Integer summonerLevel;
}
  • Team

/**
 * @date 2021/1/17 13:30
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Getter
@Setter
public class Team {
    private Integer teamId;
    private Win win;
    private Boolean firstBlood;
    private Boolean firstTower;
    private Boolean firstInhibitor;
    private Boolean firstBaron;
    private Boolean firstDragon;
    private Boolean firstRiftHerald;
    private Integer towerKills;
    private Integer inhibitorKills;
    private Integer baronKills;
    private Integer dragonKills;
    private Integer vilemawKills;
    private Integer riftHeraldKills;
    private Integer dominionVictoryScore;
}
  • TimeLine

/**
 * @date 2021/1/17 14:39
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Getter
@Setter
@ToString
public class TimeLine {
    List<ParticipantFrame> frames;
    private Long frameInterval;
}
  • Win
/**
 * @date 2021/1/17 13:33
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
public enum Win {
    Fail, Win
}

4. pipeline

本模块实现了两个类似消息队列，所有的summoner accountId和gameId都从本模块中获取，同时为了避免又重复的accountId和gameId，用布隆过滤器做了个校验，这样可以保证所有没进入list的都进入list，已存在list中的大概率不会再进入list中。

/**
 * @date 2021/1/17 16:02
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Component
public class RiotGamesPipeLine {
    private List<String> summoners = new ArrayList<>(16);
    private List<String> gameIds = new ArrayList<>(16);
    private BloomFilter<String> summonerBloomFilter =
            BloomFilter.create(Funnels.stringFunnel(Charset.forName("UTF-8")), 10000000, 0.00001);
    private BloomFilter<String> gameIdBloomFilter =
            BloomFilter.create(Funnels.stringFunnel(Charset.forName("UTF-8")), 10000000, 0.00001);

    public void addSummoner(String accountId) {
        if(!summonerBloomFilter.mightContain(accountId)) {
            summonerBloomFilter.put(accountId);
            summoners.add(accountId);
        }
    }

    public String getSummoner() {
        Iterator<String> sIterator = summoners.listIterator();
        if(sIterator.hasNext()) {
            String acccountId = sIterator.next();
            if(acccountId != null) {
                summoners.remove(acccountId);
            }
            return acccountId;
        }
        return null;
    }

    public void addGameId(String gameId) {
        if(!gameIdBloomFilter.mightContain(gameId)) {
            gameIdBloomFilter.put(gameId);
            gameIds.add(gameId);
        }
    }

    public String getGameId() {
        Iterator<String> sIterator = gameIds.listIterator();
        if(sIterator.hasNext()) {
            String gameId = sIterator.next();;
            gameIds.remove(gameId);
            return gameId;
        }
        return null;
    }
}

5. scheduler

本模块主要处理调度任务，cron表达式表示每分钟都会调度一次，但是如果上次的任务还没执行结束，那么本次任务就不会被执行。

其中定时任务使用的是springboot自带的，所以要在启动类上加上注解@EnableScheduling


/**
 * @date 2021/1/16 20:13
 * @auth jixiang.ma
 * @copyright copyright © 2020 jixiang.ma all right reserved.
 **/
@Slf4j
@Component
public class WebCrawlerJob {
    @Autowired
    private LolService lolService;

    @Autowired
    private RiotGamesPipeLine pipeLine;

    private static Lock lock = new ReentrantLock();

    @Scheduled(cron = "0 0/1 * * * ?")
    public void crawlerJob() {
        if (lock.tryLock()) {
            try {
                doExecute();
            } finally {
                lock.unlock();
            }
        } else {
            log.warn("the previous job has not finished, so this job is canceled");
        }
    }

    private void doExecute() {
        lolService.getSummonerDetails("abc");
        String summonerAccountId = pipeLine.getSummoner();

        while (summonerAccountId != null) {
            // it is the first to get the match list, we need to use the total games to get the all gameId.
            MatchList matchList = lolService.getMatchList(summonerAccountId, 0);
            for (int i = matchList.getEndIndex(); i < matchList.getTotalGames(); i += 100) {
                lolService.getMatchList(summonerAccountId, i);
            }
            String gameId = pipeLine.getGameId();
            while (gameId != null) {
                lolService.getMatchDetail(gameId);
                lolService.getGameTimeLine(gameId);
                gameId = pipeLine.getGameId();
                System.out.println("gameId = \t" + gameId);
            }
            summonerAccountId = pipeLine.getSummoner();
        }
    }
}

6. service

本模块是整体核心，业务逻辑皆于此。各个方法的作用见名知意，就不详解了。


/**
 * @date 2021/1/16 20:21
 * @auth jixiang.ma
 * @copyright copyright © 2021 jixiang.ma all right reserved.
 **/
@Slf4j
@Service
@AllArgsConstructor(onConstructor_ = {@Autowired})
public class LolService {

    private RiotGamesClient riotGamesClient;
    private RiotGamesConfig riotGamesConfig;
    private RiotGamesPipeLine riotGamesPipeLine;

    public Summoner getSummonerDetails(String summonerName) {
        HttpGet httpGet = new HttpGet(String.format(riotGamesConfig.getLolSummonerUrl(), summonerName));
        Summoner summoner = null;
        try {
            HttpResponse response = riotGamesClient.execute(httpGet);
            String result = EntityUtils.toString(response.getEntity(), Charset.forName("UTF-8"));
            summoner = JSONObject.parseObject(result, Summoner.class);
        } catch (IOException e) {
            log.error("when get summoner details, it has error taken place!", e);
        }
        if(summoner != null) {
            riotGamesPipeLine.addSummoner(summoner.getAccountId());
        }
        return summoner;
    }

    public MatchList getMatchList(String puuid, Integer beginIndex) {
        HttpGet httpGet = new HttpGet(String.format(riotGamesConfig.getLolMatchListByAccountUrl(), puuid, beginIndex));
        MatchList matches = null;
        try {
            HttpResponse response = riotGamesClient.execute(httpGet);
            String result = EntityUtils.toString(response.getEntity(), Charset.forName("UTF-8"));
            matches = JSONObject.parseObject(result).toJavaObject(MatchList.class);
        } catch (IOException e) {
            log.error("when get match list, it has error taken place, puuid is {}", puuid, e);
        }
        matches.getMatches().forEach(match -> riotGamesPipeLine.addGameId(String.valueOf(match.getGameId())));
        return matches;
    }

    public MatchDetail getMatchDetail(String matchId) {
        HttpGet httpGet = new HttpGet(String.format(riotGamesConfig.getLolMatchDetailUrl(), matchId));
        MatchDetail matchDetail = null;
        String result = null;
        try {
            HttpResponse response = riotGamesClient.execute(httpGet);
            result = EntityUtils.toString(response.getEntity(), Charset.forName("UTF-8"));
            matchDetail = JSONObject.parseObject(result, MatchDetail.class);
        } catch (IOException e) {
            log.error("when get match detail, something error has taken place, matchId is {}", matchId, e);
        }
        matchDetail.getParticipantIdentities().forEach(participant -> participant.getPlayer().getAccountId());
        saveJsonFile(result, "E:\\riotgames\\data\\"+ matchId+"_detail.json");
        return matchDetail;
    }

    public TimeLine getGameTimeLine(String matchId) {
        HttpGet httpGet = new HttpGet(String.format(riotGamesConfig.getLolMatchTimeLinesUrl(), matchId));
        TimeLine timeLine = null;
        String result = null;
        try {
            HttpResponse response = riotGamesClient.execute(httpGet);
            result = EntityUtils.toString(response.getEntity(), Charset.forName("UTF-8"));
            timeLine = JSONObject.parseObject(result, TimeLine.class);
        } catch (IOException e) {
            log.error("when get match details, something error taken place, matchId is {}", matchId, e);
        }
        saveJsonFile(result, "E:\\riotgames\\data\\"+ matchId+"_timeline.json");
        return timeLine;
    }

    private void saveJsonFile(String data, String path) {
        if(data != null ) {
            File file = new File(path);
            if(!file.exists()) {
                try {
                    if(file.createNewFile()) {
                        FileUtils.write(file, data, false);
                    }
                } catch (IOException e) {
                    log.error("write match info to file failed.", e);
                }
            }
        }
    }

}

以下是最后运行的效果，每个game都会有两个json文件。
在这里插入图片描述

总结

本文主要讲述了一个完整的拳头数据获取的自动化爬虫，其中使用了RateLimiter做限流，用BloomFilter做防重复数据，另外还有四个获取数据的方法。

遗留问题

重启会造成资源浪费

当程序重启时，又会从abc开始抓数据，造成性能的浪费，本文为了使得此项目尽量轻量化，故而设定程序一直跑下去。

当然，有两个方法可以避免：

  • 手动修改这个name
    当进程每次重启后都修改这个值
    在这里插入图片描述
  • 把召唤师的数据落数据库
    每次启动定时任务时，都从数据库里读最新的，且没有被抓过数据的召唤师名字或者accountId。

速度慢

因为拳头限定每两分钟最多有100条请求，每天大约可以获取三万六千条游戏数据（game详情和timeline各一次）。
所以可以采用分布式爬虫或者多apikey的方式来解决问题。

apikey有效期

注意：拳头给的apikey只有24小时有效期，所以我建议把这个apikey存到数据库里，每23小时更新一次

数据不全

此数据接口只有某一个地区的数据，最后大概率会把这个地区的所有数据都拿到，但是换个地区，比如LCK，NA的数据就拿不到了，如果要拿到其他赛区的数据，就需要改配置文件，其他赛区的url，除了subdomain不同外，其他都一致。
在这里插入图片描述

解决办法：增加一个枚举类，列出所有地区id，在service里生成http request url时，去生成不同地区的url

上述所有缺陷和解决方案，会在下个版本修正，敬请期待。

码字不易，转载请注明出处。笔者水平有限，难免会有一定的错误，希望大家能不吝指出，请大家多多点赞，评论，谢谢！
爱技术的小马哥
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
某腾LOL开发负责人教你如何用Java实现一把 LOL 案例，学会模板设计模式！
weixin_55932015的博客
03-31 619
前言 假如开一把lol，必须要做哪些事呢？可以简化位这三个步骤。选择英雄，开始游戏，投降。这三个步骤必须按照顺序执行。映射到代码中可以想到socket信息传输，建立连接，传输数据，关闭连接。 [这就是模板模式了大概的样子，在模板模式中，一个抽象类公开定义了执行它的方法的方式模板，它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。] [比如玩一把lol,选择什么英雄都可以，开始游戏后，每个人也有自己的发育路线，最后是15分钟投降，还是20分钟投降，每一局也都不一定（赢了暂时不算）不管谁来玩，
如何设计JAVA的接口？以lol的英雄为例
wjhauannn的博客
10-24 221
在设计LOL的时候，进攻类英雄有两种，一种是进行物理系攻击，一种是进行魔法系攻击 这时候，就可以使用接口来实现这个效果。 接口就像是一种约定，我们约定某些英雄是物理系英雄，那么他们就一定能够进行物理攻击。 首先设计ad接口，后续ad英雄实现ad接口之后，则必须赴约重写ad接口中的方法。 public interface ad { //物理伤害 public void physicAttack(); } 同理，设计ap接口。 public interface ap { public
java英雄联盟战斗力题目,Java 查询英雄联盟玩家战绩
weixin_39618173的博客
03-12 592
先来张效果图 首先新建两个实体类//玩家的信息public class Player {private String id;// 用户名private String tier;//大段位private String rank;// 小段位private String league_points;// 胜点private String rank_games;// 排位场数private String...
期末作业——基于机器学习算法的LOL比赛预测（求高分，拜托拜托）
AmbiRF的博客
07-10 8691
前言：2018年5月2日，各大高校男生宿舍不约而同的爆发出尖叫和呼喊声。难道是“单身少年们”集体受到刺激，而引发的集体抗议吗？在这一切的背后究竟隐藏着怎样的秘密？其实真相是：一、题目背景  近年来，随着科技的不断进步和人们传统思想的不断改变，电子竞技正在飞速发展。刚刚，亚奥理事会公布了亚运电子体育表演赛的六个项目：《英雄联盟》、《实况足球》、《炉石传说》、《星际争霸2》、《Arena of Val...
英雄联盟系统java,JAVA Swing课程设计之LOL英雄联盟英雄查询系统
weixin_39808726的博客
03-13 255
package dao;import java.awt.EventQueue;import javax.swing.JFrame;import java.awt.GridBagLayout;import java.awt.HeadlessException;import java.awt.Image;import java.awt.Point;import java.awt.Toolkit;imp...
英雄预测分析-数据英雄预测分析-数据
12-30
英雄预测分析——数据英雄预测分析——数据英雄预测分析——数据
获取英雄联盟的皮肤名字 -易语言
06-14
标题“获取英雄联盟的皮肤名字 - 易语言”所涉及的知识点主要集中在使用易语言编程来获取《英雄联盟》游戏中的皮肤名称。易语言是一种中国本土开发的、以中文编程为特色的编程语言，旨在降低编程的门槛，让更多人...
英雄联盟 2020 数据集
11-10
《英雄联盟2020数据分析探索》 英雄联盟，作为全球最受欢迎的多人...通过对这些数据的详尽分析，我们可以更深入地了解比赛的运作规律，为玩家、教练和分析师提供有价值的参考，推动英雄联盟电竞的理论研究和实践应用。
英雄联盟LPL比赛数据可视化系统.rar
最新发布
08-22
在英雄联盟LPL比赛数据可视化系统中，CSS将起到至关重要的作用，它能实现界面的美化，如设置字体、颜色、布局、响应式设计等。通过CSS，开发者可以创建吸引人的视觉效果，使用户在查看比赛数据时有更好的体验。例如...
爬虫之爬取英雄联盟战绩详细数据
12-22
在本文中，我们将探讨如何使用Python爬虫技术来获取英雄联盟（League of Legends，简称LOL）的游戏战绩详细数据。这个过程涉及到的主要知识点包括：使用cookie进行身份验证、通过JavaScript获取URL参数、处理网络...
英雄联盟
02-26
下一个Tailwind打字稿示例 与create-next-app ： npx create-next-app -e https://github.com/wwsalmon/next-tailwind-typescript-example 与默认的create-next-app ，此示例： 预先配置了Typescript和TailwindCSS 具有默认的index.js ， Home.module.css ， pages/api/和public/剥离 预先配置了_document.tsx 将.env添加到.gitignore
最新价值1.5W金刚竞技/电竞比分源码/LOL赛事预测比赛采集/后台设置玩法+完美运行+架设教程
05-21
【七月独家修复版】最新价值1.5W金刚竞技/电竞比分源码/LOL赛事预测比赛采集/后台设置玩法+完美运行+架设教程 金刚竞技/电竞比分源码/LOL赛事预测/电竞游戏比分竞猜源码/免买分/修复比赛采集/后台设置玩法网传价值1.5W的电竞比分源码 大概看了一下全网各大论坛分享的，99.99%搭建都搭建不起来，最常见的问题就是后台登录后报错。
league_of_legends:英雄联盟（LoL）API的实现
04-29
英雄联盟 该gem实现了League of Legends API（目前处于公开Beta版）。 随着API的发展，它将继续更新。 未经Riot Games，Inc.或其任何关联公司以任何方式认可，认证或以其他方式批准此产品。 安装 将此行添加到您的应用程序的Gemfile中： gem 'league_of_legends' 然后执行： $ bundle 或将其自己安装为： $ gem install league_of_legends 用法 该gem仍在开发中，功能有限。 # create a new instance of the API lol_api = ::LeagueOfLegends::Api.new <api> # get all available request types lol_api.available_requests # execute a
英雄联盟所有英雄数据
01-06
版本：8.24.1 更新日期：2018-12-11 共计142个英雄 英雄数据结构如下： `id` varchar(15) NOT NULL COMMENT '英雄名称', `key` int(4) NOT NULL COMMENT '英雄标志id', `name` varchar(10) NOT NULL COMMENT '英雄名称', `title` varchar(10) NOT NULL COMMENT '英雄名字', `tag1` varchar(8) NOT NULL COMMENT '英雄类型', `tag2` varchar(8) DEFAULT NULL COMMENT '英雄第二类型', `attack` int(1) NOT NULL COMMENT '物理攻击', `defense` int(1) NOT NULL COMMENT '防御能力', `magic` int(1) NOT NULL COMMENT '法术攻击', `difficulty` int(1) NOT NULL COMMENT '上手难度', `lore` text COMMENT '背景故事', `blurb` text COMMENT '背景故事展开', `allytips` text COMMENT '当你使用该英雄时', `enemytips` text COMMENT '当敌人使用该英雄时'
加密解密，UUID，密钥生成
11-17
加密解密，UUID，密钥生成
对英雄联盟比赛预测（一）- 特征分析
majixiang1996的博客
01-02 2267
说起来自己也是个LOL老玩家了，S4玩到S10，唉技术还是一如既往的菜。 前段时间一直在忙其他事情，最近终于稍微有点时间了，突发奇想，想做一个比赛预测的模型，这个预测模型必须能跟随比赛进程实时同步，即在比赛进程前，进行中都可以做预测。 我们先来分析下影响比赛有哪些因素 我们知道影响比赛进程的因素有很多，首先我们排除一些非比赛性因素： 网络延迟超大/电脑太卡 恶意送人头/消极比赛 被老婆抓走 地震/海啸/泥石流等 那么接下来就是一些非常重要的决定性因素： 下面说的内在/外在因素是针对某场比赛的 外在因
lol java_JAVA初学者第一课：用开发LOL的思路来掌握JAVA的面向对象思想
weixin_42292348的博客
02-17 392
面向对象系列教材 (一)- Java中的类和对象很多想要学习JAVA的同学在第一次看到面向对象这个词汇时，都是一脸懵逼，甚至跟着视频学完了java基础，也还是感觉很抽象。但这的确是JAVA最核心的思想，理解这一点后，再学习以后反射、注解等中高级内容也会更的心应手。本文适合人群：未接触过JAVA，想了解JAVA的人群刚开始接触JAVA，不理解什么是面向对象思想的初学者本章节会引入面向对象的基本概念，...
Java策略模式：一个关于英雄联盟的例子
qqliaaaa的博客
06-02 536
片段 - 万物皆片段（可能是最好用的代码分享平台） 策略模式 将类中未来可能会变化的需求抽取为接口，而在这个类中持有那个接口的引用，编程时使用接口，而不是那个接口的实现。 直接看一个例子： 英雄联盟1.0版本只有一个英雄。如下 Skil.java //技能公共接口，需要添加新的技能的时候，就添加他的实现类 public interface Skill { //放技能 ...
必看~与众不同、通俗易懂的lol版Java学习路线图
Java_Coding1的博客
02-09 556
前言 动力节点2022最新的LOL版Java学习路线图整理完了！！！这篇文章是把每个阶段做了一个汇总，强烈建议大家收藏起来，是时候学习真正的Java技术了！ 一、Java学前准备工作 2022全新Java学习路线图动力节点（一）Java学前准备工作_Java_Coding1的博客-CSDN博客动力节点2022最新的LOL版Java学习路线图来了！！！准备做一个系列文章，强烈建议大家收藏起来，是时候学习真正的Java技术了！楔子这天，符文之地被Java编程全面同化，EZ为了适应新世界，开启了全新的冒险.
英雄联盟排位比赛数据不同算法预测分析
05-23
英雄联盟排位比赛数据可以通过多种算法进行预测分析，以下是几种常用的算法： 1. 逻辑回归（Logistic Regression） 逻辑回归是一种二分类算法，可以根据比赛数据预测胜负。通过对历史数据的分析，可以得到一组影响...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值