～技术宅真可怕～ » 讨论
友评排行榜Java爬虫

import org.jsoup.Jsoup;

import org.jsoup.nodes.Document;

import org.jsoup.nodes.Element;

import org.jsoup.select.Elements;

import java.io.FileWriter;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;



public class OutputFriendRatings {

    public static void main(String[] args) {

        // 我的用户ID

        String myUserId = "650688";



        // 获取我的所有好友ID

        List<String> friendIds = getFriendIds(myUserId);



        // 遍历所有好友，查询其条目打分情况

        for (String friendId : friendIds) {

            System.out.println("正在查询好友ID：" + friendId);

            Map<String, String> ratings = getUserRatings(friendId);

            System.out.println("好友ID：" + friendId + "，条目打分情况：");

            for (Map.Entry<String, String> entry : ratings.entrySet()) {

                System.out.println(entry.getKey() + ", " + entry.getValue());

            }

            // 存储至本地文件

            saveToFile(friendId, ratings);

            // 休眠5秒钟

            try {

                Thread.sleep(5000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }



    // 获取我的所有好友ID

    private static List<String> getFriendIds(String userId) {

        List<String> friendIds = new ArrayList<>();

        String url = "https://bgm.tv/user/" + userId + "/friends";

        try {

            Document doc = Jsoup.connect(url).get();

            Elements users = doc.select("ul.usersMedium li.user a[href^=/user/]");

            for (Element user : users) {

                String href = user.attr("href");

                String friendId = href.substring(href.lastIndexOf("/") + 1);

                friendIds.add(friendId);

            }

        } catch (IOException e) {

            e.printStackTrace();

        }

        return friendIds;

    }



    // 获取用户的条目打分情况

    private static Map<String, String> getUserRatings(String userId) {

        Map<String, String> ratings = new HashMap<>();

        String baseUrl = "https://bgm.tv/anime/list/";

        int page = 1;

        while (true) {

            String url = baseUrl + userId + "/collect?orderby=rate&page=" + page;

            try {

                Document doc = Jsoup.connect(url).get();

                Elements items = doc.select("li.item");

                if (items.isEmpty()) {

                    break;

                }

                for (Element item : items) {

                    Element link = item.selectFirst("a[href^=/subject/]");

                    Element titleElement = item.selectFirst("a.l");

                    Element subTitleElement = item.selectFirst("small.grey");

                    Element ratingElement = item.selectFirst("span.starstop-s > span.starlight");

                    if (ratingElement != null) {

                        String href = link.attr("href");

                        String entryId = href.substring(href.lastIndexOf("/") + 1);

                        String title = (titleElement != null) ? titleElement.text() : "";

                        String subTitle = (subTitleElement != null) ? subTitleElement.text() : "";

                        int rating = extractRating(ratingElement);

                        ratings.put(entryId, title + " " + subTitle + " 评分：" + rating);

                    }

                }

                page++;

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

        return ratings;

    }



    // 提取评分

    private static int extractRating(Element ratingElement) {

        String classAttribute = ratingElement.attr("class");

        String ratingText = classAttribute.substring(classAttribute.lastIndexOf("stars") + 5);

        return Integer.parseInt(ratingText);

    }



    // 将用户的条目打分情况存储至本地文件

    private static void saveToFile(String userId, Map<String, String> ratings) {

        String fileName = "C:\\Users\\Admin\\Desktop\\friends_rating\\" + userId + ".txt";

        try (FileWriter writer = new FileWriter(fileName)) {

            for (Map.Entry<String, String> entry : ratings.entrySet()) {

                writer.write(entry.getKey() + ", " + entry.getValue() + "\n");

            }

        } catch (IOException e) {

            e.printStackTrace();

        }

        System.out.println("用户ID：" + userId + " 的条目打分情况已存储至本地文件：" + fileName);

    }

}

import java.io.*;

import java.util.HashMap;

import java.util.Map;

import java.util.Scanner;

import java.util.TreeMap;



public class ReadFilesOutputRankingList {

    public static void main(String[] args) {

        // 获取用户输入的评分人数阈值

        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入评分人数阈值：");

        int threshold = scanner.nextInt();



        // 读取所有用户评分文件

        Map<String, WebCrawler.RatingInfo> ratingsMap = readRatingsFiles("C:\\Users\\Admin\\Desktop\\friends_rating");



        // 过滤评分人数低于阈值的条目

        filterByThreshold(ratingsMap, threshold);



        // 统计每个条目的平均评分和评分人数

        Map<String, Double> averageRatings = calculateAverageRatings(ratingsMap);



        // 对所有条目按照平均评分进行排序

        TreeMap<String, Double> sortedRatings = sortByAverageRating(averageRatings);



        // 输出排行榜到 txt 文件中

        outputRankingToFile(sortedRatings, ratingsMap, "C:\\Users\\Admin\\Desktop\\ranking.txt");



        // 询问用户是否删除所有用户打分文件

        System.out.print("是否删除所有用户打分文件？（Y/N）：");

        String response = scanner.next();

        if (response.equalsIgnoreCase("Y")) {

            deleteAllRatingFiles("C:\\Users\\Admin\\Desktop\\friends_rating");

        }

    }



    // 读取所有用户评分文件

    private static Map<String, WebCrawler.RatingInfo> readRatingsFiles(String directoryPath) {

        Map<String, WebCrawler.RatingInfo> ratingsMap = new HashMap<>();

        File directory = new File(directoryPath);

        File[] files = directory.listFiles();

        if (files != null) {

            for (File file : files) {

                if (file.isFile()) {

                    String userId = file.getName().replace(".txt", "");

                    try (BufferedReader br = new BufferedReader(new FileReader(file))) {

                        String line;

                        while ((line = br.readLine()) != null) {

                            String[] parts = line.split(", ", 2);

                            String entryId = parts[0];

                            String ratingInfo = parts[1];

                            ratingsMap.putIfAbsent(entryId, new WebCrawler.RatingInfo());

                            ratingsMap.get(entryId).addRating(userId, ratingInfo);

                        }

                    } catch (IOException e) {

                        e.printStackTrace();

                    }

                }

            }

        }

        return ratingsMap;

    }



    // 过滤评分人数低于阈值的条目

    private static void filterByThreshold(Map<String, WebCrawler.RatingInfo> ratingsMap, int threshold) {

        ratingsMap.entrySet().removeIf(entry -> entry.getValue().getTotalUsers() < threshold);

    }



    // 统计每个条目的平均评分和评分人数

    private static Map<String, Double> calculateAverageRatings(Map<String, WebCrawler.RatingInfo> ratingsMap) {

        Map<String, Double> averageRatings = new HashMap<>();

        for (Map.Entry<String, WebCrawler.RatingInfo> entry : ratingsMap.entrySet()) {

            double totalRating = entry.getValue().getTotalRating();

            int totalUsers = entry.getValue().getTotalUsers();

            double averageRating = (totalUsers > 0) ? totalRating / totalUsers : 0;

            // 保留四位小数

            averageRatings.put(entry.getKey(), Math.round(averageRating * 10000.0) / 10000.0);

        }

        return averageRatings;

    }



    // 对所有条目按照平均评分进行排序

    private static TreeMap<String, Double> sortByAverageRating(Map<String, Double> averageRatings) {

        TreeMap<String, Double> sortedRatings = new TreeMap<>((o1, o2) -> {

            double result = averageRatings.get(o2) - averageRatings.get(o1);

            return (result != 0) ? (int) Math.signum(result) : o1.compareTo(o2);

        });

        sortedRatings.putAll(averageRatings);

        return sortedRatings;

    }



    // 输出排行榜到 txt 文件中

    private static void outputRankingToFile(TreeMap<String, Double> sortedRatings, Map<String, WebCrawler.RatingInfo> ratingsMap, String filePath) {

        try (FileWriter writer = new FileWriter(filePath)) {

            for (Map.Entry<String, Double> entry : sortedRatings.entrySet()) {

                String entryId = entry.getKey();

                double averageRating = entry.getValue();

                WebCrawler.RatingInfo ratingInfo = ratingsMap.get(entryId);

                String titleAndSubtitle = ratingInfo.getTitleAndSubtitle();

                int totalUsers = ratingInfo.getTotalUsers();

                writer.write("https://bgm.tv/subject/" + entryId + "   " + titleAndSubtitle + ", 平均分数: " + averageRating + ", 评分人数: " + totalUsers + "\n");

            }

        } catch (IOException e) {

            e.printStackTrace();

        }

        System.out.println("排行榜已输出至文件：" + filePath);

    }



    // 删除所有用户打分文件

    private static void deleteAllRatingFiles(String directoryPath) {

        File directory = new File(directoryPath);

        File[] files = directory.listFiles();

        if (files != null) {

            for (File file : files) {

                if (file.isFile()) {

                    file.delete();

                }

            }

        }

        System.out.println("所有用户打分文件已删除");

    }



    // 内部类用于保存条目的评分信息

    static class RatingInfo {

        private double totalRating;

        private int totalUsers;

        private String titleAndSubtitle;



        public RatingInfo() {

            totalRating = 0;

            totalUsers = 0;

        }



        public void addRating(String userId, String ratingInfo) {

            totalRating += extractRating(ratingInfo);

            totalUsers++;

            if (titleAndSubtitle == null) {

                titleAndSubtitle = extractTitleAndSubtitle(ratingInfo);

            }

        }



        public double getTotalRating() {

            return totalRating;

        }



        public int getTotalUsers() {

            return totalUsers;

        }



        public String getTitleAndSubtitle() {

            return (titleAndSubtitle != null) ? titleAndSubtitle : "";

        }



        private double extractRating(String ratingInfo) {

            String ratingText = ratingInfo.substring(ratingInfo.lastIndexOf("：") + 1);

            return Double.parseDouble(ratingText);

        }



        private String extractTitleAndSubtitle(String ratingInfo) {

            return ratingInfo.substring(0, ratingInfo.lastIndexOf("评分：") - 1);

        }

    }



}

import org.jsoup.Jsoup;

import org.jsoup.nodes.Document;

import org.jsoup.nodes.Element;

import org.jsoup.select.Elements;

import org.springframework.boot.configurationprocessor.json.JSONArray;

import org.springframework.boot.configurationprocessor.json.JSONException;

import org.springframework.boot.configurationprocessor.json.JSONObject;



import java.io.*;

import java.net.HttpURLConnection;

import java.net.URL;

import java.util.*;



public class Main {

    

    

    //获取友评排行榜并保存本地文件（包括自己）（包括在看、看过、搁置、抛弃）

    public static void main(String[] args) {



        Scanner scanner1 = new Scanner(System.in);

        Scanner scanner2 = new Scanner(System.in);

        Scanner scanner3 = new Scanner(System.in);

        Scanner scanner4 = new Scanner(System.in);



        // 用户ID

        System.out.println("请输入要查询友评榜的用户ID: ");

        String userId = scanner1.nextLine();



        // 请求URL

        String baseUrl = "https://api.bgm.tv/v0/users/";



        // 用户代理

        String userAgent = "650688/my-private-project";



        System.out.println("请输入您的Access Token: ");

        System.out.println("(请在该网址获取: https://next.bgm.tv/demo/access-token)");

        // 请求头部信息

        //String token = "";

        String token = scanner2.nextLine();



        // 用户输入低于多少人评分的动画条目从最终排行榜中删除

        System.out.print("请输入低于多少人评分的动画条目将被删除：");

        int threshold = scanner3.nextInt();



        System.out.println();



        // 获取用户好友ID列表

        List<String> friendIds = getFriendIds(userId);



        // 创建Map存储动画信息及好友评分

        Map<Integer, Animation> animationMap = new HashMap<>();



        // 遍历好友ID，获取每个好友对动画的评分情况

        int no = 1;

        for (String friendId : friendIds) {

            System.out.println("正在查询第" + no + "位用户，ID: " + friendId + " 对动画的评分...");

            no++;



            // 遍历type为2、3、4、5的情况

            for (int type = 2; type <= 5; type++) {

                // 分页参数

                int offset = 0;

                boolean hasNextPage = true;



                // 发起请求直到没有下一页为止

                while (hasNextPage) {

                    try {

                        // 构建完整的请求URL

                        String fullUrl = baseUrl + friendId + "/collections?subject_type=2&limit=50&type=" + type + "&offset=" + offset;

                        URL url = new URL(fullUrl);

                        HttpURLConnection conn = (HttpURLConnection) url.openConnection();



                        // 设置请求方法和请求头部信息

                        conn.setRequestMethod("GET");

                        conn.setRequestProperty("User-Agent", userAgent);

                        conn.setRequestProperty("Authorization", "Bearer " + token);



                        // 获取响应码

                        int responseCode = conn.getResponseCode();

                        if (responseCode == HttpURLConnection.HTTP_OK) {

                            // 读取响应内容

                            BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));

                            StringBuilder response = new StringBuilder();

                            String inputLine;

                            while ((inputLine = in.readLine()) != null) {

                                response.append(inputLine);

                            }

                            in.close();



                            // 解析JSON响应

                            JSONObject jsonResponse = new JSONObject(response.toString());

                            JSONArray data = jsonResponse.getJSONArray("data");



                            // 遍历动画信息

                            for (int i = 0; i < data.length(); i++) {

                                JSONObject item = data.getJSONObject(i);

                                int score = item.optInt("rate", 0);



                                // 如果分数不为0，则处理该动画信息

                                if (score != 0) {

                                    int subjectId = item.getInt("subject_id");



                                    // 如果该动画信息已存在，则更新好友评分

                                    if (animationMap.containsKey(subjectId)) {

                                        Animation animation = animationMap.get(subjectId);

                                        animation.addFriendRating(friendId, score);

                                    } else {

                                        String subjectName = item.getJSONObject("subject").getString("name");

                                        String subjectNameCN = item.getJSONObject("subject").optString("name_cn", "");



                                        // 创建Animation对象并添加到Map

                                        Animation animation = new Animation(subjectId, subjectName, subjectNameCN);

                                        animation.addFriendRating(friendId, score);

                                        animationMap.put(subjectId, animation);

                                    }

                                }

                            }



                            // 更新分页参数

                            offset += jsonResponse.getInt("limit");

                            if (offset >= jsonResponse.getInt("total")) {

                                hasNextPage = false;

                            }

                        } else {

                            // 打印错误信息

                            System.out.println("Error: " + responseCode);

                        }



                        // 关闭连接

                        conn.disconnect();

                    } catch (IOException | JSONException e) {

                        e.printStackTrace();

                    }

                }

            }

        }



        // 统计平均分数并排序

        List<Animation> sortedAnimations = calculateAndSortAverage(animationMap);



//        // 控制台输出排行榜

//        System.out.println("动画排行榜：");

//        for (int i = 0; i < sortedAnimations.size(); i++) {

//            Animation animation = sortedAnimations.get(i);

//            System.out.println("排名：" + (i + 1));

//            System.out.println("动画ID：" + animation.getSubjectId());

//            System.out.println("动画原名：" + animation.getSubjectName());

//            System.out.println("动画中文名：" + animation.getSubjectNameCN());

//            System.out.println("参与评分的好友人数：" + animation.getFriendRatings().size());

//            System.out.println("平均分数：" + animation.getAverageScore());

//            System.out.println();

//        }





//        // 用户输入低于多少人评分的动画条目从排行榜中删除

//        Scanner scanner = new Scanner(System.in);

//        System.out.print("请输入低于多少人评分的动画条目将被删除：");

//        int threshold = scanner.nextInt();



        // 删除低于阈值的动画条目

        sortedAnimations.removeIf(animation -> animation.getFriendRatings().size() < threshold);



        // 保存排行榜到本地文件

        saveRankingToFile(sortedAnimations, "C:\\Users\\Admin\\Desktop\\ranking.txt");

        System.out.println("友评榜已保存到 C:\\Users\\Admin\\Desktop\\ranking.txt ");

    }



    // 获取用户好友ID列表

    private static List<String> getFriendIds(String userId) {

        List<String> friendIds = new ArrayList<>();

        //把自己加入好友列表中,因为自己也参与友评榜计算

        friendIds.add(userId);

        // 目标网址

        String url = "https://bgm.tv/user/" + userId + "/friends";

        try {

            // 使用Jsoup库获取网页内容

            Document doc = Jsoup.connect(url).get();

            // 选择所有类似于<ul class="usersMedium">下的<li class="user">元素

            Elements users = doc.select("ul.usersMedium li.user a[href^=/user/]");



            // 遍历所有用户元素

            for (Element user : users) {

                // 获取用户链接中的 href 属性值

                String href = user.attr("href");

                // 从链接中提取用户ID部分

                String friendId = href.substring(href.lastIndexOf("/") + 1);

                // 添加好友ID到列表

                friendIds.add(friendId);

            }

        } catch (IOException e) {

            e.printStackTrace();

        }

        return friendIds;

    }



    // 计算平均分数并排序

    private static List<Animation> calculateAndSortAverage(Map<Integer, Animation> animationMap) {

        List<Animation> animations = new ArrayList<>(animationMap.values());

        // 计算每个动画的平均分数

        for (Animation animation : animations) {

            animation.calculateAverageScore();

        }

        // 根据平均分数排序

        animations.sort((a1, a2) -> Double.compare(a2.getAverageScore(), a1.getAverageScore()));

        return animations;

    }



    // 保存排行榜到本地文件

    private static void saveRankingToFile(List<Animation> animations, String filePath) {

        try (PrintWriter writer = new PrintWriter(filePath)) {

            for (Animation animation : animations) {

                writer.print("https://bgm.tv/subject/" + animation.getSubjectId() + "   ");

                writer.print("排名：" + (animations.indexOf(animation) + 1) + "   ");

                writer.print("" + animation.getSubjectName() + "   ");

                writer.print("" + animation.getSubjectNameCN() + "   ");

                writer.print("评分人数：" + animation.getFriendRatings().size() + "   ");



                //平均分保留四位小数

                double averageScore = animation.getAverageScore();

                String formatted = String.format("%.4f", averageScore);

                writer.println("平均分数：" + formatted);



                //writer.println("平均分数：" + animation.getAverageScore() + "");





                //writer.println();

            }

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        }

    }

}



// 定义动画类

class Animation {

    private int subjectId;

    private String subjectName;

    private String subjectNameCN;

    private Map<String, Integer> friendRatings;

    private double averageScore;



    public Animation(int subjectId, String subjectName, String subjectNameCN) {

        this.subjectId = subjectId;

        this.subjectName = subjectName;

        this.subjectNameCN = subjectNameCN;

        this.friendRatings = new HashMap<>();

    }



    public int getSubjectId() {

        return subjectId;

    }



    public String getSubjectName() {

        return subjectName;

    }



    public String getSubjectNameCN() {

        return subjectNameCN;

    }



    public Map<String, Integer> getFriendRatings() {

        return friendRatings;

    }



    public double getAverageScore() {

        return averageScore;

    }



    public void addFriendRating(String friendId, int score) {

        friendRatings.put(friendId, score);

    }



    public void calculateAverageScore() {

        if (friendRatings.isEmpty()) {

            averageScore = 0.0;

        } else {

            int sum = friendRatings.values().stream().mapToInt(Integer::intValue).sum();

            averageScore = (double) sum / friendRatings.size();

        }

    }

}