使用jsoup获取maven仓库所有版本信息

iBit程序猿 2021年11月14日 2,653次浏览

最新项目需要获取maven仓库中开源的组件版本信息，原以为使用wget命令，就可以从 Maven Repo 轻松获取。可惜，理想很丰满，现实很有骨感。既然wget获取不到，那就自己简单实现个爬虫获取吧。

分析过程

打开页面

打开仓库页面：https://repo.maven.apache.org/maven2/

页面上都是以目录和文件的方式展示的。

查看页面源码

可以轻易的发现目录和文件的内容都是在id为“contents”下的a标签中。

版本信息查看（在maven-metadata.xml）

不断深入某个目录，可以轻易的发现组件的版本信息都在maven-metadata.xml中进行描述。eg:

https://repo.maven.apache.org/maven2/tech/ibit/sql-builder/maven-metadata.xml 的内容

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <metadata>
  3.     <groupId>tech.ibit</groupId>
  4.     <artifactId>sql-builder</artifactId>
  5.     <versioning>
  6.         <latest>2.0</latest>
  7.         <release>2.0</release>
  8.         <versions>
  9.             <version>1.0</version>
  10.             <version>1.1</version>
  11.             <version>2.0</version>
  12.         </versions>
  13.         <lastUpdated>20201130115230</lastUpdated>
  14.     </versioning>
  15. </metadata>

maven-metadata.xml中包含groupId，artifactId和version信息。

综合上述过程，获取maven所有版本信息，可以做以下操作

  • 遍历 maven repo 所有目录信息，并获取 maven-metadata.xml 文件
  • 解析 maven-metadata.xml，获取 groupId，artifactId和version。

示例代码:

爬取所有的 maven-metadata.xml文件和目录

  1. package tech.ibit.crawler;

  3. import org.apache.commons.lang.StringUtils;
  4. import org.jsoup.Jsoup;
  5. import org.jsoup.nodes.Document;
  6. import org.jsoup.nodes.Element;
  7. import org.jsoup.select.Elements;

  9. import java.io.File;
  10. import java.io.FileWriter;
  11. import java.io.IOException;
  12. import java.util.Scanner;

  14. /**
  15.  * Maven爬虫
  16.  *
  17.  * @author IBIT程序猿
  18.  */
  19. public class MavenCrawler {

  21.     /**
  22.      * 爬取跟目录
  23.      */
  24.     private static final String ROOT = "https://repo.maven.apache.org/";

  26.     /**
  27.      * maven-metadata.xml文件名
  28.      */
  29.     private static final String MAVEN_METADATA_XML_FILENAME = "maven-metadata.xml";

  31.     public static void main(String[] args) {

  33.         // 参数说明
  34.         // args[0]: 爬取目录
  35.         // args[1]: sleep毫秒数
  36.         // args[2]: 开始层级（可选）
  37.         // args[3]: 开始行（可选）

  39.         String dirPath = args[0];

  41.         File dir = new File(dirPath);
  42.         if (!dir.exists() || !dir.isDirectory()) {
  43.             System.err.println("爬取目录不存在，dir: " + dirPath);
  44.             System.exit(1);
  45.         }

  47.         int sleepMillis = Integer.parseInt(args[1]);

  49.         int level = 0;
  50.         if (args.length > 2) {
  51.             level = Integer.parseInt(args[2]);
  52.         }

  54.         String beginLine = null;
  55.         if (args.length > 3) {
  56.             beginLine = args[3];
  57.         }


  60.         File urlFile;
  61.         boolean begin = null == beginLine;

  63.         while ((urlFile = getLevelFile(dir, level)).exists()) {
  64.             level++;
  65.             boolean fileEmpty = true;
  66.             File subFile = getLevelFile(dir, level);
  67.             try (Scanner scanner = new Scanner(urlFile);
  68.                  FileWriter writer = new FileWriter(subFile)) {
  69.                 while (scanner.hasNext()) {
  70.                     String line = scanner.nextLine();
  71.                     if (StringUtils.isNotBlank(line)) {
  72.                         fileEmpty = false;
  73.                         if (!begin && line.equals(beginLine)) {
  74.                             begin = true;
  75.                         }
  76.                         if (begin) {
  77.                             String url = ROOT + line;
  78.                             findSubUrl(url, sleepMillis, writer);
  79.                         }
  80.                     }
  81.                 }

  83.             } catch (IOException e) {
  84.                 e.printStackTrace();
  85.             }
  86.             if (fileEmpty) {
  87.                 urlFile.deleteOnExit();
  88.                 subFile.deleteOnExit();
  89.                 break;
  90.             }
  91.         }

  93.     }

  95.     /**
  96.      * 获取文件
  97.      *
  98.      * @param dir   目录
  99.      * @param level 等级
  100.      * @return 文件
  101.      */
  102.     private static File getLevelFile(File dir, int level) {
  103.         return new File(dir.getAbsolutePath() + File.separator + "level_" + level + ".txt");
  104.     }


  107.     /**
  108.      * 查询子url
  109.      *
  110.      * @param url         当前url
  111.      * @param sleepMillis 睡眠毫秒数
  112.      * @param writer      writer
  113.      */
  114.     private static void findSubUrl(String url, int sleepMillis, FileWriter writer) {
  115.         try {
  116.             if (url.endsWith(MAVEN_METADATA_XML_FILENAME)) {
  117.                 return;
  118.             }
  119.             Thread.sleep(sleepMillis);
  120.             Document doc = Jsoup.connect(url).get();
  121.             Elements links = doc.select("#contents a");
  122.             for (Element link : links) {
  123.                 String absUrl = link.absUrl("href");
  124.                 // 非子目录
  125.                 if (!absUrl.contains(url) || url.equals(absUrl)) {
  126.                     continue;
  127.                 }
  128.                 String relativePath = absUrl.substring(url.length());
  129.                 if (MAVEN_METADATA_XML_FILENAME.equals(relativePath) || !relativePath.contains(".")) {
  130.                     String path = absUrl.substring(ROOT.length());
  131.                     writer.write(path + "\n");
  132.                     writer.flush();
  133.                     System.out.println(path);
  134.                 }
  135.             }
  136.         } catch (IOException | InterruptedException e) {
  137.             e.printStackTrace();
  138.         }

  140.     }

  142. }

说明：

  1. 需要在保存的文件夹中新建level_0.txt文件，并将初始url https://repo.maven.apache.org/maven2/ 放置于文件中。执行过程中，会按照遍历目录的深度，生成level_1.txt, level_2.txt等。。
  2. 当前示例代码使用单线程，并设置睡眠时间（避免ip被封），如果需要改为多线程，自行设计。

解析 maven-metadata.xml 示例代码

  1. package tech.ibit.crawler;


  4. import org.apache.commons.collections4.CollectionUtils;
  5. import org.apache.commons.io.IOUtils;
  6. import org.apache.commons.lang.StringUtils;
  7. import org.w3c.dom.Document;
  8. import org.w3c.dom.Node;
  9. import org.w3c.dom.NodeList;

  11. import javax.xml.parsers.DocumentBuilder;
  12. import javax.xml.parsers.DocumentBuilderFactory;
  13. import java.io.ByteArrayInputStream;
  14. import java.io.File;
  15. import java.io.FileWriter;
  16. import java.io.IOException;
  17. import java.net.URL;
  18. import java.nio.charset.StandardCharsets;
  19. import java.util.LinkedHashSet;
  20. import java.util.Scanner;
  21. import java.util.Set;

  23. /**
  24.  * Maven meta
  25.  *
  26.  * @author IBIT程序猿
  27.  */
  28. public class MavenMetaDataParser {

  30.     /**
  31.      * 爬取跟目录
  32.      */
  33.     private static final String ROOT = "https://repo.maven.apache.org/";

  35.     /**
  36.      * maven-metadata.xml文件名
  37.      */
  38.     private static final String MAVEN_METADATA_XML_FILENAME = "maven-metadata.xml";


  41.     public static void main(String[] args) {

  43.         // 参数说明
  44.         // args[0]: 爬取目录
  45.         // args[1]: sleep毫秒数
  46.         // args[2]: 开始层级
  47.         // args[3]: 结束层级
  48.         // args[4]: 开始行（可选）
  49.         if (args.length < 4) {
  50.             System.err.println("参数：爬取目录 sleep毫秒数 开始层级 结束层级 开始行（可选）");
  51.             System.exit(1);
  52.         }

  54.         String dirPath = args[0];

  56.         File dir = new File(dirPath);
  57.         if (!dir.exists() || !dir.isDirectory()) {
  58.             System.err.println("爬取目录不存在，dir: " + dirPath);
  59.             System.exit(1);
  60.         }


  63.         int sleepMillis = Integer.parseInt(args[1]);
  64.         int beginLevel = Integer.parseInt(args[2]);
  65.         int endLevel = Integer.parseInt(args[3]);


  68.         String beginLine = null;

  70.         if (args.length > 4) {
  71.             beginLine = args[4];
  72.         }

  74.         boolean begin = null == beginLine;
  75.         for (int i = beginLevel; i <= endLevel; i++) {
  76.             File urlFile = getLevelFile(dir, i);
  77.             if (!urlFile.exists()) {
  78.                 break;
  79.             }

  81.             try (Scanner scanner = new Scanner(urlFile);
  82.                  FileWriter writer = new FileWriter(getVersionLevelFile(dir, i))) {
  83.                 while (scanner.hasNext()) {
  84.                     String line = scanner.nextLine();
  85.                     if (StringUtils.isNotBlank(line)) {
  86.                         if (!begin && line.equals(beginLine)) {
  87.                             begin = true;
  88.                         }
  89.                         if (begin && line.endsWith(MAVEN_METADATA_XML_FILENAME)) {
  90.                             String url = ROOT + line;
  91.                             appendVersions(url, sleepMillis, writer);
  92.                         }
  93.                     }
  94.                 }
  95.             } catch (IOException e) {
  96.                 e.printStackTrace();
  97.             }

  99.         }

  101.     }

  103.     /**
  104.      * 生成版本
  105.      *
  106.      * @param url         url
  107.      * @param sleepMillis 睡眠毫秒数
  108.      * @param writer      writer
  109.      */
  110.     private static void appendVersions(String url, int sleepMillis, FileWriter writer) {
  111.         try {
  112.             Thread.sleep(sleepMillis);
  113.             String xmlContent = IOUtils.toString(new URL(url), StandardCharsets.UTF_8);
  114.             DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  115.             DocumentBuilder builder = factory.newDocumentBuilder();
  116.             try (ByteArrayInputStream in = new ByteArrayInputStream(xmlContent.getBytes(StandardCharsets.UTF_8))) {
  117.                 Document doc = builder.parse(in);

  119.                 String groupId = getSingleValue(doc, "groupId");
  120.                 if (StringUtils.isBlank(groupId)) {
  121.                     return;
  122.                 }

  124.                 String artifactId = getSingleValue(doc, "artifactId");
  125.                 if (StringUtils.isBlank(artifactId)) {
  126.                     return;
  127.                 }

  129.                 Set<String> versions = getMultiValues(doc, "version");
  130.                 if (CollectionUtils.isEmpty(versions)) {
  131.                     return;
  132.                 }

  134.                 String versionLine = groupId + ":" + artifactId + ":" + StringUtils.join(versions, ",");
  135.                 writer.write(versionLine + "\n");
  136.                 writer.flush();
  137.                 System.out.println(versionLine);
  138.             }


  141.         } catch (Exception e) {
  142.             e.printStackTrace();
  143.         }

  145.     }

  147.     /**
  148.      * 获取文件
  149.      *
  150.      * @param dir   目录
  151.      * @param level 等级
  152.      * @return 文件
  153.      */
  154.     private static File getLevelFile(File dir, int level) {
  155.         return new File(dir.getAbsolutePath() + File.separator + "level_" + level + ".txt");
  156.     }

  158.     /**
  159.      * 获取文件
  160.      *
  161.      * @param dir   目录
  162.      * @param level 等级
  163.      * @return 文件
  164.      */
  165.     private static File getVersionLevelFile(File dir, int level) {
  166.         return new File(dir.getAbsolutePath() + File.separator + "version_level_" + level + ".txt");
  167.     }

  169.     /**
  170.      * 获取单个值
  171.      *
  172.      * @param document 文档
  173.      * @param tagName  标签名称
  174.      * @return 单个值
  175.      */
  176.     private static String getSingleValue(Document document, String tagName) {
  177.         NodeList nodeList = document.getElementsByTagName(tagName);
  178.         if (nodeList.getLength() == 0) {
  179.             return null;
  180.         }
  181.         return getNodeValue(nodeList.item(0));
  182.     }


  185.     /**
  186.      * 获取多个值
  187.      *
  188.      * @param document 文档
  189.      * @param tagName  标签名称
  190.      * @return 值集合
  191.      */
  192.     private static Set<String> getMultiValues(Document document, String tagName) {
  193.         Set<String> values = new LinkedHashSet<>();
  194.         NodeList nodeList = document.getElementsByTagName(tagName);
  195.         for (int i = 0; i < nodeList.getLength(); i++) {
  196.             String value = getNodeValue(nodeList.item(i));
  197.             if (null != value) {
  198.                 values.add(value);
  199.             }
  200.         }
  201.         return values;
  202.     }

  204.     /**
  205.      * 获取节点值
  206.      *
  207.      * @param node 节点
  208.      * @return 节点值
  209.      */
  210.     private static String getNodeValue(Node node) {
  211.         if (null == node) {
  212.             return null;
  213.         }
  214.         return node.getFirstChild().getNodeValue();
  215.     }
  216. }

说明

  1. 该示例代码就是读取爬虫生成的level_x.txt文件中的maven-metadata.xml文件，并解析出对应的groupId, artifactId, version
  2. 当前示例代码使用单线程，并设置睡眠时间（避免ip被封），如果需要改为多线程，自行设计。

其他说明，pom.xml引入依赖说明

  1.     <dependencies>
  2.         <dependency>
  3.             <groupId>org.jsoup</groupId>
  4.             <artifactId>jsoup</artifactId>
  5.             <version>1.14.3</version>
  6.         </dependency>


  9.         <dependency>
  10.             <groupId>commons-lang</groupId>
  11.             <artifactId>commons-lang</artifactId>
  12.             <version>2.6</version>
  13.         </dependency>

  15.         <dependency>
  16.             <groupId>org.apache.commons</groupId>
  17.             <artifactId>commons-collections4</artifactId>
  18.             <version>4.4</version>
  19.         </dependency>

  21.         <dependency>
  22.             <groupId>commons-io</groupId>
  23.             <artifactId>commons-io</artifactId>
  24.             <version>2.11.0</version>
  25.         </dependency>
  26.     </dependencies>
上一篇： docker-compose.yaml文件详解