Maven的使用

flying robot2024-10-18 13:54

1. Maven 简介

https://maven.apache.org/

Maven 是一个强大的项目管理和构建工具，广泛应用于 Java 项目中，旨在简化项目的依赖管理、构建、测试、部署等工作。Maven 主要通过定义 pom.xml（Project Object Model 文件）来管理项目的依赖和配置。

2. Maven 的核心概念

  • POM (Project Object Model) ：定义项目的基本信息、依赖、插件以及构建过程。位于项目根目录下的 pom.xml 文件是 Maven 项目的核心。
  • 依赖管理：Maven 自动下载、更新项目中引用的库和插件，并管理其版本。
  • 生命周期：Maven 的构建周期分为若干阶段，如编译、测试、打包、安装、部署等。
  • 仓库 ：Maven 中，依赖的库或插件来自不同的仓库，分为本地仓库、中央仓库和远程仓库（如公司内部的私服）。
    • 本地仓库：存放开发者机器上已经下载的依赖。
    • 中央仓库：Maven 官方仓库，存储广泛使用的开源库。
    • 远程仓库/私服 (Nexus、Artifactory)：用于企业内部存放私有组件或镜像中央仓库，优化下载速度。

3. Maven 私服的配置

Maven 私服（Nexus、Artifactory 等）可以用于缓存依赖，发布内部库和管理版本。配置私服可以减少从中央仓库下载依赖的时间，便于在公司内部共享私有依赖。

1. 安装私服

以 Nexus Repository Manager 为例：

  • 下载 Nexus 的发行包并安装到服务器。
  • 启动 Nexus，默认端口为 8081。
  • 通过 http://localhost:8081 访问 Nexus UI，登录默认的管理员账号 admin 进行配置。
2. 在 Maven 中配置私服

在 Maven 项目的 settings.xml 中配置私服的地址。settings.xml 文件一般位于以下位置：

  • Windows：C:\Users\{username}\.m2\settings.xml
  • Linux/macOS：~/.m2/settings.xml

修改 settings.xml 添加私服仓库配置：

xml 复制代码 
<settings>
    <mirrors>
        <!-- 配置私服作为中央仓库的镜像 -->
        <mirror>
            <id>nexus</id>
            <mirrorOf>*</mirrorOf> <!-- 所有请求都会通过私服 -->
            <url>http://localhost:8081/repository/maven-public/</url>
        </mirror>
    </mirrors>

    <servers>
        <!-- 配置私服的认证信息 -->
        <server>
            <id>nexus</id>
            <username>your-username</username>
            <password>your-password</password>
        </server>
    </servers>
</settings>
  • mirrors：配置仓库的镜像地址。
  • servers：配置私服的用户名和密码，用于发布或获取私有库。
3. 在 pom.xml 中配置私服仓库

在项目的 pom.xml 文件中配置使用私服的仓库：

xml 复制代码 
<project>
    <repositories>
        <!-- 配置私服的远程仓库 -->
        <repository>
            <id>nexus-releases</id>
            <url>http://localhost:8081/repository/maven-releases/</url>
        </repository>

        <repository>
            <id>nexus-snapshots</id>
            <url>http://localhost:8081/repository/maven-snapshots/</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
    </repositories>

    <distributionManagement>
        <!-- 配置发布时使用的仓库 -->
        <repository>
            <id>nexus-releases</id>
            <url>http://localhost:8081/repository/maven-releases/</url>
        </repository>

        <snapshotRepository>
            <id>nexus-snapshots</id>
            <url>http://localhost:8081/repository/maven-snapshots/</url>
        </snapshotRepository>
    </distributionManagement>
</project>
4. 将项目发布到私服

执行以下命令将项目发布到私服中：

bash 复制代码 
mvn clean deploy

确保项目的 pom.xml 文件中已经配置了正确的 groupId、artifactId 和 version，并且私服已经正确配置。

4. 常见问题及解决办法

  1. 私服无法访问：

    • 检查私服的 IP 地址和端口是否正确。
    • 确保防火墙规则允许访问私服。

  2. 依赖下载失败：

    • 检查 pom.xml 或 settings.xml 中的私服配置是否正确。
    • 确认私服中的依赖版本是否存在，若是内部库，确保已经成功发布。

  3. 权限问题：

    • 确保 settings.xml 中的认证信息正确。
    • 检查 Nexus 或其他私服的用户权限配置。

5. 总结

Maven 私服配置可以提高项目的依赖管理效率，减少中央仓库下载的时间，特别是在企业环境中，它可以帮助存储私有的库和共享内部组件。通过正确配置 settings.xml 和 pom.xml，可以让项目平稳地依赖于私有仓库。

微服务架构通常采用分布式部署，每个服务都独立开发、打包、部署和运行。微服务的 Maven 项目部署涉及多个服务的管理，每个服务通常是一个独立的项目，打包为 JAR、WAR 或其他形式，并通过容器化、CI/CD 管道、自动化部署工具等方式进行管理。

以下是微服务架构下 Maven 项目的典型部署流程，重点介绍如何打包和部署微服务的 JAR 包，以及常见的自动化部署方式。

微服务架构中的 Maven 项目结构

在微服务架构中，每个服务通常是一个独立的项目，并且都有各自的 pom.xml。项目可能有以下几种类型：

  1. 基础服务：提供通用功能（如用户管理、订单处理等），通常打包为 JAR。
  2. API 网关：负责请求路由和服务聚合，通常打包为 JAR。
  3. 配置中心：集中管理配置，通常打包为 JAR。
  4. 服务注册与发现：使用如 Eureka、Consul 的服务，打包为 JAR。
  5. 负载均衡：使用 Ribbon 或其他负载均衡器实现，打包为 JAR。

在 Maven 项目中，线上部署通常涉及将构建后的项目包（如 JAR、WAR、EAR 等）上传或发布到线上服务器，或将项目部署到远程仓库（如 Nexus、Artifactory）以供其他项目引用。以下是常见的 Maven 项目线上部署的流程。

1. JAR 包部署到线上服务器

如果项目打包为 JAR 并需要在服务器上运行，以下是步骤：

步骤 1：Maven 打包

首先，将项目打包为 JAR 文件：

bash 复制代码 
mvn clean package

这会在 target/ 目录下生成 JAR 包。

步骤 2：上传 JAR 包到服务器

使用工具（如 scp 或 rsync）将 JAR 包上传到线上服务器：

bash 复制代码 
scp target/your-project-name.jar user@your-server-ip:/path/to/deploy/
步骤 3：远程服务器上运行 JAR

登录到远程服务器，并使用 java -jar 命令运行 JAR 包：

bash 复制代码 
java -jar /path/to/deploy/your-project-name.jar

为了保证服务长期运行，可以通过以下方式来管理运行的 JAR 包：

  • 后台运行 ：使用 nohup 命令或 screen/tmux 来保持服务后台运行。

    bash 复制代码 
    nohup java -jar /path/to/deploy/your-project-name.jar > log.out 2>&1 &

  • 使用 systemd 管理服务 ：编写 systemd 服务文件来管理 Java 应用的启动和停止。

步骤 4：设置自动化部署

如果希望每次代码更新后自动部署，通常会使用 CI/CD 工具，如 Jenkins、GitLab CI、GitHub Actions 来自动打包并将 JAR 包部署到服务器。

2. WAR 包部署到线上服务器

如果项目是 Web 应用（WAR 包），通常需要将 WAR 包部署到 Servlet 容器（如 Tomcat）中：

步骤 1：Maven 打包 WAR

打包项目为 WAR 文件：

bash 复制代码 
mvn clean package

这会在 target/ 目录下生成 WAR 包。

步骤 2：上传 WAR 包到服务器

将 WAR 包上传到线上服务器：

bash 复制代码 
scp target/your-project-name.war user@your-server-ip:/path/to/tomcat/webapps/
步骤 3：部署到 Tomcat

将 WAR 包放入 Tomcat 的 webapps/ 目录，Tomcat 会自动解压并部署该 WAR 包。

  • WAR 包的名称会决定应用访问的上下文路径。例如，your-project-name.war 在浏览器中可以通过 http://your-server-ip:8080/your-project-name/ 访问。
步骤 4：重启 Tomcat

上传 WAR 包后，如果需要手动重启 Tomcat，可以运行以下命令：

bash 复制代码 
sudo systemctl restart tomcat

3. 通过 CI/CD 自动部署

为了简化线上部署流程，可以使用 CI/CD 工具来自动化打包、测试和部署。

常用工具：
  • Jenkins：集成构建、测试和部署，适用于企业环境。
  • GitLab CI：与 GitLab 配合使用，可自动化从代码提交到部署的全过程。
  • GitHub Actions：直接在 GitHub 仓库内创建 CI/CD 流程，支持自动化测试和部署。
GitLab CI 示例：
yaml 复制代码 
stages:
  - build
  - deploy

build_job:
  stage: build
  script:
    - mvn clean package
  artifacts:
    paths:
      - target/your-project-name.jar

deploy_job:
  stage: deploy
  script:
    - scp target/your-project-name.jar user@your-server-ip:/path/to/deploy/
    - ssh user@your-server-ip 'nohup java -jar /path/to/deploy/your-project-name.jar > log.out 2>&1 &'
Jenkins 示例：
  1. 配置一个 Jenkins Pipeline。
  2. 创建以下 Jenkinsfile，自动完成 Maven 构建并部署到远程服务器：
groovy 复制代码 
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('Deploy') {
            steps {
                sshagent(['your-ssh-credentials-id']) {
                    sh 'scp target/your-project-name.jar user@your-server-ip:/path/to/deploy/'
                    sh 'ssh user@your-server-ip nohup java -jar /path/to/deploy/your-project-name.jar > log.out 2>&1 &'
                }
            }
        }
    }
}

4. 将 Maven 项目发布到远程仓库（私服）

如果要将 Maven 项目发布到公司私有的 Maven 仓库（如 Nexus 或 Artifactory），其他项目可以通过依赖引用这个包。以下是将 Maven 项目部署到远程仓库的流程：

步骤 1：配置 distributionManagement

在项目的 pom.xml 文件中添加远程仓库的配置：

xml 复制代码 
<distributionManagement>
    <repository>
        <id>nexus-releases</id>
        <url>http://nexus.example.com/repository/maven-releases/</url>
    </repository>
    <snapshotRepository>
        <id>nexus-snapshots</id>
        <url>http://nexus.example.com/repository/maven-snapshots/</url>
    </snapshotRepository>
</distributionManagement>
步骤 2：配置认证信息

在 ~/.m2/settings.xml 中配置远程仓库的用户名和密码：

xml 复制代码 
<servers>
    <server>
        <id>nexus-releases</id>
        <username>your-username</username>
        <password>your-password</password>
    </server>
    <server>
        <id>nexus-snapshots</id>
        <username>your-username</username>
        <password>your-password</password>
    </server>
</servers>
步骤 3：发布到远程仓库

通过 Maven 部署命令将项目发布到私有仓库：

bash 复制代码 
mvn clean deploy

成功后，项目的 JAR 包会上传到指定的远程仓库，其他项目可以通过 Maven 依赖管理引入该包。

总结

Maven 项目线上部署通常包括以下几种方式：

  1. 手动将 JAR 或 WAR 上传到服务器并运行或部署。
  2. 使用 CI/CD 工具自动化打包和部署流程。
  3. 将项目发布到远程 Maven 仓库供其他项目使用。

选择合适的部署方式取决于项目的规模、团队协作的需求以及基础设施的复杂度。

线上部署

在 Maven 项目中，线上部署通常涉及将构建后的项目包（如 JAR、WAR、EAR 等）上传或发布到线上服务器，或将项目部署到远程仓库（如 Nexus、Artifactory）以供其他项目引用。以下是常见的 Maven 项目线上部署的流程。

1. JAR 包部署到线上服务器

如果项目打包为 JAR 并需要在服务器上运行，以下是步骤：

步骤 1：Maven 打包

首先，将项目打包为 JAR 文件：

bash 复制代码 
mvn clean package

这会在 target/ 目录下生成 JAR 包。

步骤 2：上传 JAR 包到服务器

使用工具（如 scp 或 rsync）将 JAR 包上传到线上服务器：

bash 复制代码 
scp target/your-project-name.jar user@your-server-ip:/path/to/deploy/
步骤 3：远程服务器上运行 JAR

登录到远程服务器，并使用 java -jar 命令运行 JAR 包：

bash 复制代码 
java -jar /path/to/deploy/your-project-name.jar

为了保证服务长期运行，可以通过以下方式来管理运行的 JAR 包：

  • 后台运行 ：使用 nohup 命令或 screen/tmux 来保持服务后台运行。

    bash 复制代码 
    nohup java -jar /path/to/deploy/your-project-name.jar > log.out 2>&1 &

  • 使用 systemd 管理服务 ：编写 systemd 服务文件来管理 Java 应用的启动和停止。

步骤 4：设置自动化部署

如果希望每次代码更新后自动部署，通常会使用 CI/CD 工具，如 Jenkins、GitLab CI、GitHub Actions 来自动打包并将 JAR 包部署到服务器。

2. WAR 包部署到线上服务器

如果项目是 Web 应用（WAR 包），通常需要将 WAR 包部署到 Servlet 容器（如 Tomcat）中：

步骤 1：Maven 打包 WAR

打包项目为 WAR 文件：

bash 复制代码 
mvn clean package

这会在 target/ 目录下生成 WAR 包。

步骤 2：上传 WAR 包到服务器

将 WAR 包上传到线上服务器：

bash 复制代码 
scp target/your-project-name.war user@your-server-ip:/path/to/tomcat/webapps/
步骤 3：部署到 Tomcat

将 WAR 包放入 Tomcat 的 webapps/ 目录，Tomcat 会自动解压并部署该 WAR 包。

  • WAR 包的名称会决定应用访问的上下文路径。例如，your-project-name.war 在浏览器中可以通过 http://your-server-ip:8080/your-project-name/ 访问。
步骤 4：重启 Tomcat

上传 WAR 包后，如果需要手动重启 Tomcat，可以运行以下命令：

bash 复制代码 
sudo systemctl restart tomcat

3. 通过 CI/CD 自动部署

为了简化线上部署流程，可以使用 CI/CD 工具来自动化打包、测试和部署。

常用工具：
  • Jenkins：集成构建、测试和部署，适用于企业环境。
  • GitLab CI：与 GitLab 配合使用，可自动化从代码提交到部署的全过程。
  • GitHub Actions：直接在 GitHub 仓库内创建 CI/CD 流程，支持自动化测试和部署。
GitLab CI 示例：
yaml 复制代码 
stages:
  - build
  - deploy

build_job:
  stage: build
  script:
    - mvn clean package
  artifacts:
    paths:
      - target/your-project-name.jar

deploy_job:
  stage: deploy
  script:
    - scp target/your-project-name.jar user@your-server-ip:/path/to/deploy/
    - ssh user@your-server-ip 'nohup java -jar /path/to/deploy/your-project-name.jar > log.out 2>&1 &'
Jenkins 示例：
  1. 配置一个 Jenkins Pipeline。
  2. 创建以下 Jenkinsfile，自动完成 Maven 构建并部署到远程服务器：
groovy 复制代码 
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('Deploy') {
            steps {
                sshagent(['your-ssh-credentials-id']) {
                    sh 'scp target/your-project-name.jar user@your-server-ip:/path/to/deploy/'
                    sh 'ssh user@your-server-ip nohup java -jar /path/to/deploy/your-project-name.jar > log.out 2>&1 &'
                }
            }
        }
    }
}

4. 将 Maven 项目发布到远程仓库（私服）

如果要将 Maven 项目发布到公司私有的 Maven 仓库（如 Nexus 或 Artifactory），其他项目可以通过依赖引用这个包。以下是将 Maven 项目部署到远程仓库的流程：

步骤 1：配置 distributionManagement

在项目的 pom.xml 文件中添加远程仓库的配置：

xml 复制代码 
<distributionManagement>
    <repository>
        <id>nexus-releases</id>
        <url>http://nexus.example.com/repository/maven-releases/</url>
    </repository>
    <snapshotRepository>
        <id>nexus-snapshots</id>
        <url>http://nexus.example.com/repository/maven-snapshots/</url>
    </snapshotRepository>
</distributionManagement>
步骤 2：配置认证信息

在 ~/.m2/settings.xml 中配置远程仓库的用户名和密码：

xml 复制代码 
<servers>
    <server>
        <id>nexus-releases</id>
        <username>your-username</username>
        <password>your-password</password>
    </server>
    <server>
        <id>nexus-snapshots</id>
        <username>your-username</username>
        <password>your-password</password>
    </server>
</servers>
步骤 3：发布到远程仓库

通过 Maven 部署命令将项目发布到私有仓库：

bash 复制代码 
mvn clean deploy

成功后，项目的 JAR 包会上传到指定的远程仓库，其他项目可以通过 Maven 依赖管理引入该包。

总结

Maven 项目线上部署通常包括以下几种方式：

  1. 手动将 JAR 或 WAR 上传到服务器并运行或部署。
  2. 使用 CI/CD 工具自动化打包和部署流程。
  3. 将项目发布到远程 Maven 仓库供其他项目使用。

选择合适的部署方式取决于项目的规模、团队协作的需求以及基础设施的复杂度。

微服务打包与部署

在 Maven 项目中，每个微服务会根据需求选择不同的打包方式。大部分情况下，微服务会打包为 JAR 并在容器化环境（如 Docker）中运行。常见的步骤包括：

1. Maven 打包为 JAR

微服务项目通常打包为 JAR（包括依赖的所有库），以独立运行。可以使用 Spring Boot、Dropwizard 等框架，简化构建自包含的可执行 JAR 包。

在 pom.xml 中，配置 Spring Boot 打包为 JAR：

xml 复制代码 
<packaging>jar</packaging>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

执行以下命令打包：

bash 复制代码 
mvn clean package

生成的 JAR 文件位于 target/ 目录，例如：target/your-service-name.jar。

2. 将 JAR 部署到服务器

将 JAR 上传到服务器并运行。通常通过 SSH 将文件上传到远程服务器，或者使用自动化工具完成上传和部署。

bash 复制代码 
scp target/your-service-name.jar user@your-server-ip:/path/to/deploy/

在服务器上运行 JAR 包：

bash 复制代码 
java -jar /path/to/deploy/your-service-name.jar
3. 容器化部署（Docker）

为了便于管理和扩展，微服务通常使用容器化工具如 Docker。使用 Docker 可以将微服务及其依赖一起打包为容器镜像，便于在云端或其他基础设施上部署。

步骤 1：创建 Dockerfile

为微服务项目创建 Dockerfile，将 JAR 文件放入容器中并指定启动命令：

Dockerfile 复制代码 
# 基础镜像
FROM openjdk:17-jdk-alpine

# 指定 JAR 文件名和路径
ARG JAR_FILE=target/your-service-name.jar

# 将 JAR 文件添加到容器中
COPY ${JAR_FILE} app.jar

# 启动命令
ENTRYPOINT ["java", "-jar", "/app.jar"]

步骤 2：构建 Docker 镜像

使用 Docker 构建微服务的镜像：

bash 复制代码 
docker build -t your-service-name .

步骤 3：运行 Docker 容器

使用生成的 Docker 镜像启动服务：

bash 复制代码 
docker run -d -p 8080:8080 your-service-name
4. CI/CD 管道部署（Jenkins、GitLab CI 等）

为了实现持续集成和持续交付（CI/CD），可以使用工具如 Jenkins、GitLab CI、GitHub Actions 来自动化微服务的构建和部署。

Jenkins Pipeline 示例：

  1. 配置 Jenkins 来构建项目，并生成 JAR 包和 Docker 镜像。
  2. 定义 Jenkins Pipeline，自动化从代码提交到部署的全过程。
groovy 复制代码 
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('Docker Build') {
            steps {
                script {
                    docker.build("your-service-name")
                }
            }
        }
        stage('Deploy') {
            steps {
                script {
                    docker.withRegistry('https://your-docker-registry.com', 'docker-credentials-id') {
                        docker.image("your-service-name").push('latest')
                    }
                }
            }
        }
    }
}

GitLab CI 示例：

在 .gitlab-ci.yml 中定义构建和部署步骤：

yaml 复制代码 
stages:
  - build
  - deploy

build:
  stage: build
  script:
    - mvn clean package
    - docker build -t your-service-name .
  artifacts:
    paths:
      - target/your-service-name.jar

deploy:
  stage: deploy
  script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker push $CI_REGISTRY/your-group/your-service-name

CI/CD 管道能够确保在每次代码更新时，自动完成测试、构建、打包并部署到线上环境中，减少人为错误并提高效率。

5. 服务注册与发现

在微服务架构中，通常需要服务注册与发现机制。服务可以自动注册到注册中心（如 Eureka、Consul），客户端通过这些注册中心发现并调用其他服务。

Spring Cloud Eureka 示例：

  1. Eureka 服务器：

    • 在微服务架构中，可以使用 Spring Cloud Netflix Eureka 作为服务注册与发现组件。
    xml 复制代码 
    <dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

  2. Eureka 客户端：

    • 各个微服务在启动时，自动注册到 Eureka 服务器，并通过该服务器发现其他微服务。
    xml 复制代码 
    <dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
6. 配置管理

对于配置管理，可以使用 Spring Cloud Config 或其他集中化配置工具。配置中心可以集中管理各个微服务的配置，并动态更新。

Spring Cloud Config 示例：

  1. Config Server：集中管理配置，并将配置保存在 Git 或文件系统中。

    xml 复制代码 
    <dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>

  2. 客户端配置：各个微服务从配置中心读取配置，而不是本地配置文件。

    xml 复制代码 
    <dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

总结

微服务的 Maven 项目部署流程大致如下：

  1. Maven 构建和打包：将微服务打包为 JAR 或 Docker 容器。
  2. 容器化：将微服务放入 Docker 容器，便于管理和部署。
  3. 自动化部署（CI/CD）：通过 Jenkins、GitLab CI 等自动化工具完成构建和部署。
  4. 服务注册与发现：使用 Eureka、Consul 等工具实现服务自动注册和发现。
  5. 配置管理：集中管理微服务配置，支持动态更新。

通过这些方式，微服务项目能够实现高效的开发、独立部署和弹性扩展。

相关推荐
何苏三月几秒前
设计模式 - 单例模式（懒汉式、饿汉式、静态内部类、枚举）
java·单例模式
Renas_TJOvO4 分钟前
排序算法汇总
java·数据结构·算法
秋恬意14 分钟前
Java 反射机制详解
java·开发语言
爱上语文22 分钟前
LeetCode每日一题
java·算法·leetcode
ღ᭄ꦿ࿐Never say never꧂30 分钟前
重生之我在Java世界------学工厂设计模式
java·设计模式·简单工厂模式·应用场景
尘浮生43 分钟前
Java项目实战II基于Spring Boot的火锅店管理系统设计与实现（开发文档+数据库+源码）
java·开发语言·数据库·spring boot·后端·微信小程序·旅游
wrx繁星点点43 分钟前
桥接模式：解耦抽象与实现的利器
android·java·开发语言·jvm·spring cloud·intellij-idea·桥接模式
羊小猪~~1 小时前
C/C++语言基础--C++模板与元编程系列二类模板、全特化、偏特化、编译模型简介、实现简单Vetctor等…………)
java·c语言·开发语言·c++·visual studio code·visual studio
l138494274511 小时前
C语言储存变量 java循环语句和循环跳转
java·c语言·开发语言·算法
HHppGo2 小时前
java_封装
java·开发语言
热门推荐
01Windows10安装PCL1.14.0及点云配准02制冷毛细管的计算方法介绍03【经验分享】Ubuntu22.04安装微信(linux官方版)04ECharts 地图实战分析：实现一个完整的地图下钻功能05前端vue3实现本地及在线文件预览（含pdf/txt/mp3/mp4/docx/xlsx/pptx）06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07红米手机使用google play08【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总09RAG 实践- Ollama+RagFlow 部署本地知识库10浏览器无法连接网络问题