Передача переменных из Gradle в Java: подходы и практические методы

# Версии и конфигурации
versionMajor=1
versionMinor=2
versionPatch=3
apiBaseUrl=https://api.example.com
enableDebugMode=true

# Параметры безопасности
apiKey=YOUR_API_KEY_HERE

// Получение доступа к переменным из gradle.properties
def versionMajor = project.findProperty('versionMajor') ?: 0
def versionMinor = project.findProperty('versionMinor') ?: 0
def versionPatch = project.findProperty('versionPatch') ?: 0
def apiBaseUrl = project.findProperty('apiBaseUrl') ?: "https://default-api.example.com"
def enableDebugMode = Boolean.parseBoolean(project.findProperty('enableDebugMode') ?: "false")
def apiKey = project.findProperty('apiKey') ?: ""

task generateConstants {
doLast {
def constantsDir = new File("${projectDir}/src/main/java/com/example/config")
constantsDir.mkdirs()

def constantsFile = new File(constantsDir, "AppConstants.java")
constantsFile.text = """package com.example.config;

public class AppConstants {
public static final String VERSION = "${versionMajor}.${versionMinor}.${versionPatch}";
public static final String API_BASE_URL = "${apiBaseUrl}";
public static final boolean DEBUG_MODE = ${enableDebugMode};
public static final String API_KEY = "${apiKey}";
}
"""
}
}

// Привязываем генерацию констант к процессу сборки
compileJava.dependsOn(generateConstants)

import com.example.config.AppConstants;

public class ApiClient {
public void initialize() {
System.out.println("Initializing API client version: " + AppConstants.VERSION);
System.out.println("Using API URL: " + AppConstants.API_BASE_URL);

if (AppConstants.DEBUG_MODE) {
System.out.println("Debug mode is enabled");
}

// Использование API-ключа
// makeApiRequest(AppConstants.API_KEY);
}
}

ext {
appVersionName = "1.0.0"
appVersionCode = 100
isDebugBuild = true
serverUrl = "https://api.example.com"
// Другие переменные конфигурации
}

task generateBuildConfig {
def outputDir = file("${buildDir}/generated/source/buildConfig/main/java")
outputs.dir outputDir

doLast {
def buildConfigFile = file("${outputDir}/com/example/BuildConfig.java")
buildConfigFile.parentFile.mkdirs()
buildConfigFile.text = """package com.example;

public final class BuildConfig {
private BuildConfig() {}

// Версионирование
public static final String VERSION_NAME = "${project.ext.appVersionName}";
public static final int VERSION_CODE = ${project.ext.appVersionCode};

// Режим сборки
public static final boolean DEBUG = ${project.ext.isDebugBuild};

// Конфигурации сервера
public static final String SERVER_URL = "${project.ext.serverUrl}";

// Временная метка сборки
public static final long BUILD_TIMESTAMP = ${System.currentTimeMillis()}L;
}
"""
}
}

// Добавляем сгенерированный каталог в sourceSets
sourceSets {
main {
java {
srcDir "${buildDir}/generated/source/buildConfig/main/java"
}
}
}

// Привязываем генерацию к процессу компиляции
compileJava.dependsOn generateBuildConfig

import com.example.BuildConfig;

public class Application {
public void initialize() {
System.out.println("Starting application version: " + BuildConfig.VERSION_NAME);

if (BuildConfig.DEBUG) {
System.out.println("Running in DEBUG mode");
System.out.println("Using server: " + BuildConfig.SERVER_URL);
}

System.out.println("Build timestamp: " + new Date(BuildConfig.BUILD_TIMESTAMP));
}
}

plugins {
id 'java'
id 'com.github.gmazzo.buildconfig' version '3.1.0'
}

buildConfig {
// Пакет для генерируемого класса BuildConfig
packageName("com.example.config")

// Базовые поля
buildConfigField("String", "VERSION", "\"${project.version}\"")
buildConfigField("String", "API_URL", "\"https://api.example.com\"")
buildConfigField("boolean", "DEBUG", "${project.hasProperty('debug') ? 'true' : 'false'}")
buildConfigField("long", "BUILD_TIME", "${System.currentTimeMillis()}L")

// Поля из gradle.properties
def apiKey = project.findProperty('apiKey') ?: "development-key"
buildConfigField("String", "API_KEY", "\"${apiKey}\"")

// Массивы и сложные структуры
buildConfigField("String[]", "ENVIRONMENTS", """new String[] {"dev", "test", "prod"}""")

// Условная логика на основе профиля сборки
if (project.hasProperty('production')) {
buildConfigField("int", "CACHE_SIZE", "1000")
} else {
buildConfigField("int", "CACHE_SIZE", "100")
}
}

import com.example.config.BuildConfig;

public class ApiClient {
public ApiClient() {
System.out.println("Initializing API client v" + BuildConfig.VERSION);

if (BuildConfig.DEBUG) {
System.out.println("Running in DEBUG mode with cache size: " + BuildConfig.CACHE_SIZE);
}

// Использование конфигурационных параметров
connectToApi(BuildConfig.API_URL, BuildConfig.API_KEY);
}

private void connectToApi(String url, String key) {
// Реализация соединения с API
}
}

buildConfig {
// Общие настройки
packageName("com.example.config")
className("AppConfig") // По умолчанию "BuildConfig"

// Базовые поля
buildConfigField("String", "APP_NAME", "\"${project.name}\"")
buildConfigField("String", "VERSION", "\"${project.version}\"")

// Создаем отдельную конфигурацию для сетевого модуля
forClass("NetworkConfig") {
packageName("com.example.config.network")
buildConfigField("String", "BASE_URL", "\"https://api.example.com\"")
buildConfigField("int", "TIMEOUT_SECONDS", "30")
buildConfigField("boolean", "USE_HTTPS", "true")
}

// Конфигурация для модуля хранилища
forClass("StorageConfig") {
packageName("com.example.config.storage")
buildConfigField("String", "DATABASE_NAME", "\"app_database\"")
buildConfigField("int", "DATABASE_VERSION", "3")
buildConfigField("boolean", "ENABLE_ENCRYPTION", "${project.hasProperty('enableEncryption')}")
}
}

// В build.gradle
ext {
versionMajor = 2
versionMinor = 5
versionPatch = 3
versionBuild = System.getenv("BUILD_NUMBER") ?: 0
}

version = "${versionMajor}.${versionMinor}.${versionPatch}"

buildConfig {
packageName("com.example.version")

buildConfigField("int", "VERSION_MAJOR", "${versionMajor}")
buildConfigField("int", "VERSION_MINOR", "${versionMinor}")
buildConfigField("int", "VERSION_PATCH", "${versionPatch}")
buildConfigField("int", "VERSION_BUILD", "${versionBuild}")
buildConfigField("String", "VERSION_NAME", "\"${version}\"")
buildConfigField("String", "VERSION_FULL", "\"${version}+${versionBuild}\"")
buildConfigField("long", "BUILD_TIME", "${System.currentTimeMillis()}L")
buildConfigField("String", "GIT_SHA", "\"${getGitHash()}\"")
}

// Функция для получения текущего Git-хэша
def getGitHash() {
try {
def stdout = new ByteArrayOutputStream()
exec {
commandLine 'git', 'rev-parse', '--short', 'HEAD'
standardOutput = stdout
}
return stdout.toString().trim()
} catch (Exception e) {
return "unknown"
}
}

import com.example.version.BuildConfig;

public class AboutScreen {
public void showVersionInfo() {
System.out.println("App Version: " + BuildConfig.VERSION_NAME);
System.out.println("Build: " + BuildConfig.VERSION_FULL);
System.out.println("Build Time: " + new Date(BuildConfig.BUILD_TIME));
System.out.println("Git Commit: " + BuildConfig.GIT_SHA);
}

public boolean needsUpdate(String minRequiredVersion) {
String[] required = minRequiredVersion.split("\\.");

// Простая проверка на необходимость обновления
if (Integer.parseInt(required[0]) > BuildConfig.VERSION_MAJOR) return true;
if (Integer.parseInt(required[0]) == BuildConfig.VERSION_MAJOR && 
Integer.parseInt(required[1]) > BuildConfig.VERSION_MINOR) return true;
if (Integer.parseInt(required[0]) == BuildConfig.VERSION_MAJOR && 
Integer.parseInt(required[1]) == BuildConfig.VERSION_MINOR && 
Integer.parseInt(required[2]) > BuildConfig.VERSION_PATCH) return true;

return false;
}
}

// В build.gradle
def environment = project.hasProperty('env') ? project.property('env') : 'development'

def environmentConfig = [
'development': [
apiUrl: 'https://dev-api.example.com',
loggingEnabled: true,
mockResponses: true,
databaseName: 'dev_db'
],
'staging': [
apiUrl: 'https://staging-api.example.com',
loggingEnabled: true,
mockResponses: false,
databaseName: 'staging_db'
],
'production': [
apiUrl: 'https://api.example.com',
loggingEnabled: false,
mockResponses: false,
databaseName: 'production_db'
]
]

def config = environmentConfig[environment]

buildConfig {
packageName("com.example.config")

buildConfigField("String", "ENVIRONMENT", "\"${environment}\"")
buildConfigField("String", "API_URL", "\"${config.apiUrl}\"")
buildConfigField("boolean", "LOGGING_ENABLED", "${config.loggingEnabled}")
buildConfigField("boolean", "MOCK_RESPONSES", "${config.mockResponses}")
buildConfigField("String", "DATABASE_NAME", "\"${config.databaseName}\"")
}

./gradlew build -Penv=staging

import com.example.config.BuildConfig;

public class ApiClientFactory {
public static ApiClient createApiClient() {
ApiClient client = new ApiClient(BuildConfig.API_URL);

if (BuildConfig.LOGGING_ENABLED) {
client.enableLogging();
}

if (BuildConfig.MOCK_RESPONSES) {
client.useMockResponses();
}

System.out.println("Creating API client for " + BuildConfig.ENVIRONMENT + " environment");
return client;
}
}

// В build.gradle
buildConfig {
packageName("com.example.deployment")

// Информация из CI-системы
buildConfigField("String", "CI_PIPELINE_ID", "\"${System.getenv('CI_PIPELINE_ID') ?: 'local'}\"")
buildConfigField("String", "CI_COMMIT_SHA", "\"${System.getenv('CI_COMMIT_SHA') ?: getGitHash()}\"")
buildConfigField("String", "CI_COMMIT_BRANCH", "\"${System.getenv('CI_COMMIT_BRANCH') ?: getGitBranch()}\"")
buildConfigField("String", "BUILD_NUMBER", "\"${System.getenv('BUILD_NUMBER') ?: '0'}\"")

// Время сборки
buildConfigField("long", "BUILD_TIMESTAMP", "${System.currentTimeMillis()}L")
buildConfigField("String", "BUILD_DATE", "\"${new Date().format('yyyy-MM-dd HH:mm:ss')}\"")

// Информация о JDK
buildConfigField("String", "JAVA_VERSION", "\"${System.getProperty('java.version')}\"")

// Имя сборщика
def userName = System.getProperty('user.name')
buildConfigField("String", "BUILT_BY", "\"${userName}\"")
}

def getGitBranch() {
try {
def stdout = new ByteArrayOutputStream()
exec {
commandLine 'git', 'rev-parse', '--abbrev-ref', 'HEAD'
standardOutput = stdout
}
return stdout.toString().trim()
} catch (Exception e) {
return "unknown"
}
}

import com.example.deployment.BuildConfig;

public class DiagnosticService {
public void reportError(Exception e) {
ErrorReport report = new ErrorReport();
report.setException(e);
report.setTimestamp(System.currentTimeMillis());
report.setVersionInfo(BuildConfig.VERSION_NAME);
report.setBuildInfo(String.format("Build #%s, Git commit: %s, Branch: %s",
BuildConfig.BUILD_NUMBER,
BuildConfig.CI_COMMIT_SHA,
BuildConfig.CI_COMMIT_BRANCH));
report.setEnvironment(BuildConfig.ENVIRONMENT);

// Отправка отчета об ошибке на сервер
errorReportingService.send(report);
}
}

// В build.gradle
def featureFile = file("${projectDir}/features.properties")
Properties features = new Properties()

if (featureFile.exists()) {
featureFile.withInputStream { features.load(it) }
}

buildConfig {
packageName("com.example.features")

// Загружаем все определенные флаги функций
features.each { key, value ->
buildConfigField("boolean", "FEATURE_${key.toString().toUpperCase()}", value)
}

// Добавляем несколько флагов по умолчанию
if (!features.containsKey("newLoginScreen")) {
buildConfigField("boolean", "FEATURE_NEW_LOGIN_SCREEN", "false")
}

if (!features.containsKey("darkMode")) {
buildConfigField("boolean", "FEATURE_DARK_MODE", "true")
}
}

import com.example.features.BuildConfig;

public class UserInterface {
public Screen createLoginScreen() {
if (BuildConfig.FEATURE_NEW_LOGIN_SCREEN) {
return new NewLoginScreen();
} else {
return new LegacyLoginScreen();
}
}

public void initTheme() {
if (BuildConfig.FEATURE_DARK_MODE) {
ThemeManager.enableDarkModeSupport();
}
}
}