Android平台无需指定版本号的Maven库构建及自动更新方案问询

Great question! Let's break this down into two clear parts to address both of your requirements: publishing an Android Maven library without tagged releases, and getting Gradle to auto-detect and update to the latest version.

Maven/Gradle relies on version identifiers to resolve dependencies, but you don't have to manually create tagged GitHub/GitLab releases or hardcode fixed versions every time. Here are two practical approaches:

Option 1: Snapshot Versions (For Development Workflows) #

Snapshot versions (e.g., 1.0.0-SNAPSHOT) are built for ongoing development. You can push updates to your Maven repository repeatedly without creating new formal version tags.

• On the library side: Configure your library's build script to use a snapshot version. For example:

  // build.gradle.kts (Android Library)
  version = "1.0.0-SNAPSHOT"
  
  publishing {
      publications {
          create<MavenPublication>("release") {
              from(components["release"])
              // Set your groupId, artifactId, and repo credentials here
          }
      }
      repositories {
          // Add your Maven repo (private or public) configuration
      }
  }
  

  You can automate this via CI/CD to push snapshots on every commit—no manual tagging required.
• On the dependency side: Declare the snapshot version, and Gradle will automatically check for updates (default: once per day, configurable):

  implementation("com.yourgroup:your-library:1.0.0-SNAPSHOT")
  

  Note: Snapshots are unstable by nature—avoid using them in production environments.

Option 2: Dynamic Stable Versions (For Production-Friendly Updates) #

If you prefer stable releases without hardcoding versions, use Gradle's dynamic version syntax:

• On the library side: Publish regular stable versions (e.g., 1.0.1, 1.0.2) via CI/CD. You can skip manual Git tags if your pipeline handles versioning automatically (like using a build counter or Git commit hash).
• On the dependency side: Use latest.release to pull the newest stable version automatically:

  implementation("com.yourgroup:your-library:latest.release")
  

  Alternatively, use a version range like [1.0, 2.0[ to restrict updates to major version 1.x and avoid breaking changes from major upgrades.

Bonus: BOM (Bill of Materials) for Clean Dependency Management #

For larger ecosystems, create a BOM library to centralize versioning. This lets dependent projects skip version numbers entirely:

1. Build the BOM:

   // build.gradle.kts (BOM Library)
   plugins {
       `java-platform`
       `maven-publish`
   }
   
   javaPlatform {
       allowDependencies()
   }
   
   dependencies {
       constraints {
           api("com.yourgroup:your-library:1.0.2")
           // Add other dependencies you want to version-control
       }
   }
   

2. Use the BOM in other projects:

   implementation(platform("com.yourgroup:your-bom:latest.release"))
   implementation("com.yourgroup:your-library") // No version needed!
   

   Update the BOM's version whenever you release a new library version, and all dependent projects will pick up the update automatically.

To automate version checks and updates, use the Gradle Versions Plugin:

Step 1: Add the Plugin #

Add this to your root project's build.gradle.kts:

plugins {
    id("com.github.ben-manes.versions") version "0.47.0"
}

Step 2: Detect Outdated Dependencies #

Run this command to generate a detailed report of available updates:

./gradlew dependencyUpdates

The report will be saved in build/dependencyUpdates/report.txt, listing outdated dependencies, their current versions, and the latest stable/alpha versions available.

Step 3: Auto-Update Dependencies #

To automatically update your build files to the latest stable versions, run:

./gradlew resolveLatestVersions

This will modify your build scripts with the newest versions. For safety, consider:

• Running this in a CI pipeline to create a pull request with updates, then reviewing changes before merging.
• Using Gradle's dependency locking to lock versions after updating, ensuring consistent, reproducible builds.

Important Notes #

• Dynamic versions (latest.release, snapshots) can introduce build instability if a new version includes breaking changes. Use them cautiously in production.
• For private Maven repositories, ensure Gradle is configured with the correct repo URL and credentials to pull updates.

内容的提问来源于stack exchange，提问作者gradlerr