dependencies {
    implementation 'org.springframework:spring-core:5.3.20'
}

Использование: Для внутренних зависимостей, которые не должны быть видны внешним модулям.

plugins {
    id 'java-library'
}
dependencies {
    api 'org.apache.commons:commons-lang3:3.12.0'
}

Использование: Для библиотек, которые должны быть доступны в classpath потребителей (например, интерфейсы или DTO).

dependencies {
    compileOnly 'javax.servlet:javax.servlet-api:4.0.1'
}

Использование: Для API, предоставляемых контейнером (например, Servlet API в веб-приложениях).

dependencies {
    runtimeOnly 'mysql:mysql-connector-java:8.0.28'
}

Использование: Для драйверов баз данных или библиотек, используемых только во время выполнения.

dependencies {
    testImplementation 'junit:junit:4.13.2'
}

Использование: Для тестовых фреймворков и библиотек.

В памяти: Каждая конфигурация представлена как объект в модели Gradle, содержащий список зависимостей и их метаданные. Gradle хранит граф зависимостей в памяти как Directed Acyclic Graph (DAG), что увеличивает потребление памяти пропорционально количеству зависимостей и конфигураций.

configurations {
    customConfig
}
dependencies {
    customConfig 'com.example:library:1.0'
}
tasks.register('useCustomConfig') {
    doLast {
        configurations.customConfig.each { file ->
            println "Using ${file.name}"
        }
    }
}

Назначение: Кастомные конфигурации позволяют группировать зависимости для нестандартных задач, таких как интеграционные тесты или обработка ресурсов.

configurations {
    customConfig.extendsFrom implementation
}

Это добавляет все зависимости implementation в customConfig.

В памяти: Кастомные конфигурации увеличивают объем графа зависимостей, так как Gradle создает дополнительные объекты для каждой конфигурации. Это требует больше памяти, особенно если конфигурации содержат много транзитивных зависимостей.

dependencies {
    implementation 'org.springframework:spring-core:5.+'
}

В памяти: Gradle строит граф зависимостей и разрешает конфликты во время фазы конфигурации, храня временные структуры для сравнения версий.

configurations.all {
    resolutionStrategy {
        force 'org.springframework:spring-core:5.3.20'
    }
}

В памяти: Форсинг добавляет правила в граф зависимостей, что минимально влияет на память, но требует дополнительных вычислений.

dependencies {
    implementation('org.springframework:spring-core:5.3.20') {
        exclude group: 'commons-logging'
    }
}

В памяти: Исключения уменьшают размер графа зависимостей, снижая потребление памяти и вероятность конфликтов.

dependencies {
    implementation platform('org.springframework.boot:spring-boot-dependencies:2.7.18')
    implementation 'org.springframework.boot:spring-boot-starter'
}

В памяти: BOM увеличивает объем графа зависимостей, так как Gradle загружает и парсит дополнительный POM-файл. Однако это упрощает управление версиями, снижая вероятность конфликтов.

dependencies {
    implementation project(':module-core')
}

В памяти: Зависимости от модулей добавляются в граф как узлы, увеличивая его размер. Gradle кэширует артефакты модулей в ~/.gradle/caches, снижая сетевые запросы, но требуя места на диске

В памяти: Кэширование снижает потребность в сетевых операциях, но увеличивает использование диска. Gradle загружает метаданные зависимостей в память только для активных конфигураций, оптимизируя ресурсы.

dependencyLocking {
    lockAllConfigurations()
}

./gradlew dependencies --write-locks

org.springframework:spring-core:5.3.20
org.junit:junit:4.13.2

Использование: Gradle использует версии из lockfile, игнорируя динамические версии или новейшие доступные.

В памяти: Lockfiles загружаются как часть модели зависимостей, добавляя минимальный overhead. Они уменьшают время разрешения зависимостей, так как Gradle не проверяет удаленные репозитории.

./gradlew dependencies

implementation - Implementation dependencies for the main source set.
\--- org.springframework:spring-core:5.3.20
     \--- commons-logging:commons-logging:1.2
testImplementation - Implementation dependencies for the test source set.
\--- junit:junit:4.13.2

В памяти: Gradle загружает полный граф зависимостей в память для генерации отчета, что может быть ресурсоемким для крупных проектов. Кэширование метаданных в ~/.gradle/caches ускоряет повторные вызовы.

dependencies {
    implementation 'org.example:library:1.0' {
        attributes {
            attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 11)
        }
    }
}

В памяти: Gradle хранит атрибуты и варианты в графе зависимостей, что увеличивает сложность и потребление памяти, особенно для библиотек с множеством вариантов.

Security.insertProviderAt(Conscrypt.newProvider(), 1);

Request request = new Request.Builder()
    .url("https://api.example.com/data")
    .get()
    .build();

HttpUrl url = new HttpUrl.Builder()
    .scheme("https")
    .host("api.example.com")
    .addPathSegment("data")
    .addQueryParameter("id", "1")
    .build();

Request request = new Request.Builder()
    .url(url)
    .build();

OkHttpClient client = new OkHttpClient();
Call call = client.newCall(request);
Response response = call.execute();

Call call = client.newCall(request);
call.enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        System.err.println("Request failed: " + e.getMessage());
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        if (response.isSuccessful()) {
            String body = response.body().string();
            System.out.println("Response: " + body);
        }
    }
});

if (response.isSuccessful()) {
    String body = response.body().string(); // Важно: вызывать .string() только один раз
    System.out.println("Response body: " + body);
} else {
    System.err.println("Request failed with code: " + response.code());
}
response.close(); // Закрытие ответа для освобождения ресурсов

try (ResponseBody body = response.body()) {
    InputStream inputStream = body.byteStream();
    // Чтение потока
}

public class LoggingInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        long t1 = System.nanoTime();
        System.out.println(String.format("Sending request %s on %s%n%s",
                request.url(), chain.connection(), request.headers()));

        Response response = chain.proceed(request);
        long t2 = System.nanoTime();
        System.out.println(String.format("Received response for %s in %.1fms%n%s",
                response.request().url(), (t2 - t1) / 1e6d, response.headers()));

        return response;
    }
}

OkHttpClient client = new OkHttpClient.Builder()
    .addInterceptor(new LoggingInterceptor())
    .build();

public class CacheControlInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        Response response = chain.proceed(request);
        return response.newBuilder()
                .header("Cache-Control", "max-age=60")
                .build();
    }
}

OkHttpClient client = new OkHttpClient.Builder()
    .connectTimeout(10, TimeUnit.SECONDS)
    .readTimeout(30, TimeUnit.SECONDS)
    .writeTimeout(30, TimeUnit.SECONDS)
    .build();

OkHttpClient client = new OkHttpClient.Builder()
    .followRedirects(false)
    .build();

File file = new File("src/test/resources/test.txt");
RequestBody fileBody = RequestBody.create(MediaType.parse("application/octet-stream"), file);
RequestBody requestBody = new MultipartBody.Builder()
    .setType(MultipartBody.FORM)
    .addFormDataPart("file", file.getName(), fileBody)
    .build();

Request request = new Request.Builder()
    .url("https://api.example.com/upload")
    .post(requestBody)
    .build();

public class ProgressRequestWrapper extends RequestBody {
    private final RequestBody requestBody;
    private final ProgressListener listener;

    public ProgressRequestWrapper(RequestBody requestBody, ProgressListener listener) {
        this.requestBody = requestBody;
        this.listener = listener;
    }

    @Override
    public MediaType contentType() {
        return requestBody.contentType();
    }

    @Override
    public void writeTo(BufferedSink sink) throws IOException {
        CountingSink countingSink = new CountingSink(sink, this, contentLength());
        BufferedSink bufferedSink = Okio.buffer(countingSink);
        requestBody.writeTo(bufferedSink);
        bufferedSink.flush();
    }

    public interface ProgressListener {
        void update(long bytesWritten, long contentLength, boolean done);
    }
}

Call call = client.newCall(request);
ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
executor.schedule(() -> {
    call.cancel();
    System.out.println("Request cancelled");
}, 1, TimeUnit.SECONDS);

File cacheDirectory = new File("src/test/resources/cache");
int cacheSize = 10 * 1024 * 1024; // 10 MiB
Cache cache = new Cache(cacheDirectory, cacheSize);

OkHttpClient client = new OkHttpClient.Builder()
    .cache(cache)
    .build();

OkHttpClient client = new OkHttpClient.Builder()
    .addInterceptor(new LoggingInterceptor())
    .build();

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .client(client)
    .addConverterFactory(GsonConverterFactory.create())
    .build();

MockWebServer server = new MockWebServer();
server.enqueue(new MockResponse().setBody("Hello, world!"));
server.start();

HttpUrl baseUrl = server.url("/test");
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url(baseUrl).build();
Response response = client.newCall(request).execute();

assertEquals("Hello, world!", response.body().string());
server.shutdown();

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>mockwebserver</artifactId>
    <version>5.1.0</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>5.1.0</version>
</dependency>

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp-bom</artifactId>
    <version>5.1.0</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

./gradlew okcurl:nativeImage
./okcurl/build/graal/okcurl https://httpbin.org/get

javac HelloWorld.java
java HelloWorld

Совет для новичков: Текстовые редакторы подходят для изучения основ, но для реальной разработки лучше использовать IDE, так как они экономят время и упрощают работу.

Рекомендация: Для новичков я советую IntelliJ IDEA Community Edition как основной выбор благодаря интуитивному интерфейсу и мощным функциям. OpenIDE и GigaIDE — отличные альтернативы для российских разработчиков, особенно если важна независимость от зарубежных сервисов. Cursor подойдет, если вы хотите попробовать ИИ-поддержку, но требует дополнительных затрат и настройки для Java.

Выбор IDE: Начните с IntelliJ IDEA Community для универсальности. Используйте OpenIDE или GigaIDE для работы в российской инфраструктуре. Cursor подойдет для экспериментов с ИИ, но требует затрат.
Изучите горячие клавиши: Например, в IntelliJ IDEA и OpenIDE/GigaIDE: Ctrl+Alt+L (форматирование кода), Alt+Enter (исправление ошибок).
Практикуйтесь: Создайте простые программы, такие как калькулятор, в каждой IDE, чтобы сравнить их.
Ресурсы:
IntelliJ IDEA: www.jetbrains.com/idea/documentation.
OpenIDE: openide.ru.
GigaIDE: gitverse.ru/features/gigaide.
Cursor: cursor.com/docs.
Stack Overflow для решения проблем.

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction

class CustomTask extends DefaultTask {
    @TaskAction
    void executeTask() {
        println 'Executing custom task'
    }
}

tasks.register('customTask', CustomTask)

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction

open class CustomTask : DefaultTask() {
    @TaskAction
    fun executeTask() {
        println("Executing custom task")
    }
}

tasks.register<CustomTask>("customTask")

В памяти: Каждая задача представлена как объект в JVM, содержащий метаданные (имя, зависимости, действия). Gradle загружает все задачи в память во время фазы конфигурации, что увеличивает потребление памяти пропорционально их количеству. Плагины, такие как java, добавляют множество задач (например, compileJava, test), увеличивая overhead.

В памяти: Минимальная фаза по потреблению ресурсов, так как загружается только settings.gradle и связанные плагины. Объем памяти зависит от количества модулей (обычно 50-100 МБ).

В памяти: Самая ресурсоемкая фаза, так как Gradle загружает и компилирует все скрипты, плагины и зависимости. Для крупных проектов может потребоваться 500-1000 МБ памяти.

./gradlew build --configure-on-demand

В памяти: Зависит от сложности задач. Например, compileJava загружает исходные файлы и зависимости, а test — тестовые классы и фреймворки. Параллельное выполнение (--parallel) увеличивает пиковое потребление памяти.

./gradlew build --no-daemon

task compileJava {
    doLast { println 'Compiling Java' }
}
task test(dependsOn: compileJava) {
    doLast { println 'Running tests' }
}

Gradle выполнит compileJava перед test.

task taskA {
    doLast { println 'Task A' }
}
task taskB {
    mustRunAfter 'taskA'
    doLast { println 'Task B' }
}

Если обе задачи выполняются, taskB будет после taskA, но taskB может выполняться отдельно.

task build {
    doLast { println 'Building' }
}
task cleanUp {
    doLast { println 'Cleaning up' }
}
build.finalizedBy cleanUp

В памяти: DAG задач хранится как структура данных в JVM, где каждая задача — объект с метаданными (зависимости, действия). Размер графа пропорционален количеству задач, что может увеличить потребление памяти до нескольких сотен МБ в крупных проектах.

> Task :compileJava UP-TO-DATE

tasks.named('compileJava') {
    inputs.files('src/main/java')
    outputs.dir('build/classes/java/main')
}

В памяти: Gradle хранит хэши входов/выходов в памяти и в ~/.gradle/caches для сравнения. Это добавляет небольшой overhead (около 10-50 МБ), но значительно ускоряет сборку.

./gradlew build --info

task processFiles {
    inputs.files fileTree('src/main/resources')
    doLast {
        println 'Processing files'
    }
}

task generateReport {
    outputs.file file('build/report.txt')
    doLast {
        file('build/report.txt').text = 'Report content'
    }
}

В памяти: Gradle хранит метаданные входов/выходов в памяти и кэширует хэши в ~/.gradle/caches. Для задач с большим количеством файлов (например, compileJava) это увеличивает потребление памяти, так как Gradle сканирует файловую систему.

task customTask {
    inputs.property 'version', project.version
    doLast { println "Version: ${project.version}" }
}

task example {
    doFirst { println 'Starting task' }
    doLast { println 'Ending task' }
}

task printVersion {
    doLast {
        println "Version: ${version.get()}"
    }
}

task customTask {
    def outputFile = objects.property(String)
    outputFile.set('build/output.txt')
    doLast {
        println "Output: ${outputFile.get()}"
    }
}

В памяти: doFirst и doLast добавляют действия как объекты в задачу, минимально увеличивая память. Ленивые Provider и Property хранят ссылки на значения, а не сами значения, что оптимизирует память до их вычисления в фазе выполнения.

gradle.buildFinished {
    println 'Build completed'
}

gradle.taskGraph.whenReady {
    println 'Task graph is ready'
}

project.afterEvaluate {
    println 'Project configured'
}

В памяти: Хуки создают дополнительные объекты-слушатели в памяти, увеличивая overhead. Для крупных проектов с множеством слушателей это может добавить 10-50 МБ памяти.

buildCache {
    local {
        enabled = true
    }
    remote(HttpBuildCache) {
        url = 'https://cache.example.com/'
        push = true
    }
}

./gradlew build --build-cache

rm -rf ~/.gradle/caches/build-cache

В памяти: Build Cache требует хранения хэшей и метаданных в памяти во время выполнения, что добавляет 50-100 МБ overhead. Удаленный кэш увеличивает сетевые операции, но снижает локальные вычисления.