Основы работы с терминалом в Java


Зачем работать с терминалом?

Терминал (или командная строка в Windows) — это фундаментальный инструмент для разработчиков Java.

Хотя IDE, такие как IntelliJ IDEA, автоматизируют многие процессы, знание терминала важно по следующим причинам:
Полный контроль: Вы понимаете каждый шаг компиляции и запуска.
Обучение: Работа в терминале помогает разобраться, как Java преобразует код в исполняемые программы.
Реальные проекты: На серверах, в CI/CD-системах (например, Jenkins) и скриптах терминал используется для автоматизации.
Отладка: Знание терминала помогает решать проблемы, когда IDE недоступна или возникают ошибки.

Для работы вам нужен установленный JDK (Java Development Kit). Если JDK ещё не установлен, обратитесь к моей предыдущей инструкции по установке Java 17, 21 или 24 LTS.


Основные команды: javac и java

Java-программы проходят два основных этапа:
Компиляция: Команда javac (Java Compiler) преобразует исходный код (файлы .java) в байт-код (файлы .class), который является платформонезависимым.
Запуск: Команда java исполняет байт-код на виртуальной машине Java (JVM).


Предварительные проверки

Перед началом убедитесь, что JDK настроен:

Откройте терминал:
Windows: Win + R → cmd или PowerShell.
macOS/Linux: Откройте приложение «Терминал».

Проверьте версии:

java -version
javac -version

Ожидаемый вывод (для Java 17, например):

openjdk version "17.0.8" 2023-07-18
OpenJDK Runtime Environment (build 17.0.8+7)
javac 17.0.8

Если команды не работают, проверьте переменные JAVA_HOME и PATH:
Windows: Убедитесь, что JAVA_HOME указывает на папку JDK (например, C:\Program Files\Java\jdk-17), а %JAVA_HOME%\bin добавлен в PATH.
macOS/Linux: Проверьте, что JAVA_HOME установлена (например, export JAVA_HOME=/usr/lib/jvm/jdk-17) и добавлена в PATH в ~/.zshrc или ~/.bashrc.


Шаг 1: Подготовка рабочего пространства

Создайте папку для проекта:

mkdir java-projects
cd java-projects

Напишите простую программу:Создайте файл HelloWorld.java в текстовом редакторе (например, Notepad++, VS Code или Блокнот):

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Убедитесь, что имя файла точно совпадает с именем класса (HelloWorld.java), включая регистр.
Сохраните файл в папке java-projects.


Шаг 2: Компиляция с помощью javac

Команда javac компилирует исходный код в байт-код.

Перейдите в папку с файлом:

cd java-projects

Скомпилируйте программу:

javac HelloWorld.java

Если всё успешно, в папке появится файл HelloWorld.class — это байт-код.

Если возникла ошибка, проверьте:
Имя файла совпадает с именем класса.
Код не содержит синтаксических ошибок (например, пропущена ; или скобка).
JDK установлен (javac -version работает).


Полезные опции javac

-d <папка>: Указывает, куда сохранить .class файлы.

Например:

javac -d bin HelloWorld.java

Создает папку bin и помещает туда HelloWorld.class.

-cp <путь> или -classpath <путь>: Указывает путь к библиотекам или другим .class файлам, если программа использует зависимости.

Например:

javac -cp lib/my-lib.jar HelloWorld.java

-source <версия>: Указывает версию Java для компиляции (например, -source 17).
-target <версия>: Указывает версию байт-кода (обычно совпадает с -source).
-encoding <кодировка>: Указывает кодировку исходного файла (полезно для русских символов на Windows):

javac -encoding UTF-8 HelloWorld.java

-g: Добавляет отладочную информацию в .class файлы для упрощения отладки.
--release <версия>: Компилирует для конкретной версии Java, автоматически настраивая совместимость (например, --release 17).


Компиляция нескольких файлов

Если у вас несколько .java файлов, скомпилируйте их все:

javac *.java

Или укажите конкретные файлы:

javac Main.java Helper.java

#Java #для_новичков #beginner #Java_terminal

Шаг 3: Запуск с помощью java

Команда java запускает скомпилированный байт-код на JVM.

Запустите программу:

java HelloWorld

Ожидаемый вывод:

Hello, World!

Указывайте имя класса (HelloWorld), а не файла (HelloWorld.class

Если использовали -d

Если .class файлы находятся в другой папке (например, bin), укажите путь через -cp:

java -cp bin HelloWorld

Полезные опции java

-cp <путь> или -classpath <путь>: Указывает путь к .class файлам или библиотекам.

Например:

java -cp .:lib/my-lib.jar HelloWorld
(На Windows используйте ; вместо : для разделения путей.)

-Xmx<размер>: Устанавливает максимальный объем памяти для JVM (например, -Xmx512m для 512 МБ).
-Xms<размер>: Устанавливает начальный объем памяти (например, -Xms256m).
-D<свойство>=<значение>: Устанавливает системные свойства. Например:java -Dfile.encoding=UTF-8 HelloWorld
--enable-preview: Включает экспериментальные возможности Java (например, для новых фич в Java 17+).
-jar <файл.jar>: Запускает приложение из JAR-файла (см. ниже).



Шаг 4: Дополнительные команды и процедуры

1. Создание и запуск JAR-файлов
JAR (Java Archive) — это архив, содержащий .class файлы и ресурсы. Он удобен для распространения программ.

Создание JAR:

Скомпилируйте программу:

javac -d bin HelloWorld.java

Создайте JAR:

jar cf myapp.jar -C bin .

Это создаст myapp.jar, содержащий все файлы из папки bin.
Для запуска через main добавьте манифест:

jar cfm myapp.jar Manifest.txt -C bin .

Где Manifest.txt содержит:

Main-Class: HelloWorld

(Добавьте пустую строку в конце файла.)

Запуск JAR:

java -jar myapp.jar

2. Работа с пакетами
Если ваш код использует пакеты (например, package com.example;), структура папок должна соответствовать имени пакета.

Пример:

package com.example;

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Сохраните файл в com/example/HelloWorld.java.

Компиляция:

javac com/example/HelloWorld.java

Запуск:

java -cp . com.example.HelloWorld

(Обратите внимание: используйте полное имя класса с точками, а не слэшами.)

3. Отладка с помощью jdb
JDK включает отладчик jdb для анализа программ.

Скомпилируйте с отладочной информацией:

javac -g HelloWorld.java

Запустите отладчик:

jdb HelloWorld

Основные команды jdb:
stop at HelloWorld:3 — установить точку останова на строке 3.
run — запустить программу.
next — выполнить следующую строку.
print variable — вывести значение переменной.


4. Генерация документации с javadoc
Команда javadoc создает HTML-документацию из комментариев в коде.

Пример кода с Javadoc-комментариями:

/
 * Простая программа для вывода приветствия.
 * @author Алексей
 */
public class HelloWorld {
    /
     * Главный метод программы.
     * @param args аргументы командной строки
     */
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Создание документации:

javadoc -d docs HelloWorld.java

Это создаст папку docs с HTML-файлами документации.


5. Управление зависимостями
Для проектов с внешними библиотеками (например, JAR-файлами):
Укажите библиотеки при компиляции:

javac -cp lib/my-lib.jar MyProgram.java

Укажите их при запуске:

java -cp .:lib/my-lib.jar MyProgram

Для больших проектов используйте системы сборки, такие как Maven или Gradle, которые автоматизируют работу с зависимостями.


6. Работа с модулями (Java 9+)
С Java 9 введена модульная система (JPMS).

Если ваш проект использует модули, создайте файл module-info.java:

module my.module {
    requires java.base;
}

Компилируйте с учетом модулей:

javac --module-path lib -d bin com/example/HelloWorld.java module-info.java

Запускайте:

java --module-path bin -m my.module/com.example.HelloWorld

#Java #для_новичков #beginner #Java_terminal

Шаг 5: Частые ошибки и их решения

Ошибка: javac: command not found:
JDK не установлен или PATH не настроен. Проверьте java -version и javac -version. Настройте JAVA_HOME и добавьте %JAVA_HOME%\bin (Windows) или $JAVA_HOME/bin (macOS/Linux) в PATH.

Ошибка: Error: Could not find or load main class:
Проверьте, что файл .class существует.
Убедитесь, что вы используете имя класса (java HelloWorld), а не файла (java HelloWorld.class).
Если класс в пакете, укажите полное имя: java com.example.HelloWorld.
Проверьте -cp: java -cp bin HelloWorld.


Ошибка: Main method not found:
Убедитесь, что метод main имеет сигнатуру: public static void main(String[] args).

Кодировка (Windows):
Если русские символы отображаются некорректно, используйте:

javac -encoding UTF-8 MyProgram.java
java -Dfile.encoding=UTF-8 MyProgram

Ошибка: incompatible types или синтаксические ошибки:
Проверьте код на опечатки (например, пропущенные ; или неправильные типы).
Убедитесь, что версия Java соответствует (например, используйте --release 17).


Полезные советы для новичков

Практикуйтесь: Напишите программы, такие как калькулятор или обработчик текстовых файлов, чтобы освоить javac и java.
Организуйте проект:
Храните исходники в src (например, src/com/example/).
Компилируйте в bin: javac -d bin src/com/example/*.java.
Создавайте JAR для распространения.

Изучите документацию:
javac --help и java --help для списка опций.
Oracle Java Docs: docs.oracle.com/en/java.

Переходите к IDE: После освоения терминала попробуйте IntelliJ IDEA, OpenIDE или GigaIDE для автоматизации.
Автоматизация: Для больших проектов изучите Maven или Gradle, чтобы упростить компиляцию и управление зависимостями.
Ресурсы: Stack Overflow, Oracle Tutorials, документация OpenJDK.

#Java #для_новичков #beginner #Java_terminal

Плагины и расширение функциональности в Gradle

Плагины в Gradle — это основной механизм расширения функциональности, позволяющий добавлять задачи, конфигурации и зависимости для автоматизации сборки. Они обеспечивают модульность и гибкость, позволяя адаптировать Gradle под конкретные проекты. Эта статья подробно описывает типы плагинов, встроенные и сторонние плагины, создание собственных плагинов, публикацию на Gradle Plugin Portal, стратегии разрешения плагинов и управление через pluginManagement. Особое внимание уделяется внутренним механизмам, управлению памятью и нюансам.


Типы плагинов

Gradle поддерживает два основных типа плагинов: Script Plugins и Binary Plugins.

Script Plugin (apply from)
Описание: Скриптовые плагины — это файлы Gradle (обычно .gradle или .gradle.kts), которые содержат логику сборки и подключаются к build.gradle через apply from.

Пример (Groovy DSL):

apply from: 'other.gradle'

Содержимое other.gradle:

task customTask {
    doLast {
        println 'Custom task from script plugin'
    }
}

Kotlin DSL:

apply(from = "other.gradle.kts")

Содержимое other.gradle.kts:

tasks.register("customTask") {
    doLast {
        println("Custom task from script plugin")
    }
}

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

В памяти: Скриптовые плагины парсятся как обычные Gradle-скрипты, добавляя задачи и конфигурации в модель проекта. Это увеличивает потребление памяти, аналогично основному build.gradle, но overhead минимален (10-50 МБ).

Binary Plugin (apply plugin:)
Описание: Бинарные плагины — это скомпилированные Java/Groovy/Kotlin-классы, распространяемые как JAR-файлы. Они подключаются через apply plugin или блок plugins.

Пример (Groovy DSL):

apply plugin: 'java'

В памяти: Бинарные плагины загружаются как Java-классы в JVM, включая их зависимости. Это увеличивает потребление памяти пропорционально сложности плагина (50-200 МБ для крупных плагинов, таких как android).

plugins {} vs apply plugin:

plugins {}:
Современный способ подключения плагинов, введенный в Gradle 2.1.
Использует декларативный синтаксис и разрешает плагины из Gradle Plugin Portal или репозиториев.

Пример:

plugins {
    id 'java'
    id 'org.springframework.boot' version '2.7.18'
}

Kotlin DSL:

plugins {
    java
    id("org.springframework.boot") version "2.7.18"
}

Преимущества: Автоматическое разрешение версий, поддержка Gradle Plugin Portal, меньшая вероятность ошибок.


apply plugin:
Традиционный способ, используемый в старых версиях Gradle.

Требует явного указания зависимости в buildscript:

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.springframework.boot:spring-boot-gradle-plugin:2.7.18'
    }
}
apply plugin: 'org.springframework.boot'

Недостатки: Более многословный, требует ручного управления зависимостями.

В памяти: plugins {} использует внутренний механизм разрешения Gradle, минимизируя overhead по сравнению с buildscript, который загружает дополнительные зависимости в classpath.

Рекомендация: Используйте plugins {} для современных проектов, так как он проще и поддерживает автоматическое разрешение.


#Java #middle #Gradle #Task #Plugin

Built-in плагины

Gradle поставляется с набором встроенных плагинов, которые покрывают стандартные сценарии сборки.

java:
Добавляет задачи для компиляции, тестирования и упаковки Java-проектов (например, compileJava, test, jar).

Пример:

plugins {
    id 'java'
}

В памяти: Загружает задачи и конфигурации (implementation, testImplementation), увеличивая модель проекта (50-100 МБ).

application:
Добавляет задачи для запуска Java-приложений (run, installDist).

Пример:

plugins {
    id 'application'
}
application {
    mainClass = 'com.example.Main'
}

В памяти: Добавляет задачи и classpath, минимально увеличивая overhead.

base:
Базовый плагин, добавляющий задачи жизненного цикла (clean, assemble, check).

Пример:

plugins {
    id 'base'
}

В памяти: Легковесный, добавляет минимальное количество задач.

java-library:
Расширяет java, добавляя конфигурации api и implementation для библиотек.

Пример:

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

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

checkstyle:
Интегрирует проверку стиля кода с помощью Checkstyle.

Пример:

plugins {
    id 'checkstyle'
}
checkstyle {
    toolVersion = '8.45'
    configFile = file('config/checkstyle/checkstyle.xml')
}

В памяти: Загружает конфигурацию Checkstyle и отчеты, увеличивая потребление памяти (50-100 МБ для крупных проектов).

maven-publish:
Позволяет публиковать артефакты в Maven-репозитории.

Пример:

plugins {
    id 'maven-publish'
}
publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
        }
    }
    repositories {
        maven {
            url 'https://nexus.example.com/repository/maven-releases'
        }
    }
}

В памяти: Загружает метаданные публикации и артефакты, увеличивая overhead при публикации.

#Java #middle #Gradle #Task #Plugin

Плагины для Kotlin, Android

Kotlin:
Плагин org.jetbrains.kotlin.jvm для JVM-проектов или org.jetbrains.kotlin.android для Android.

Пример:

plugins {
    id 'org.jetbrains.kotlin.jvm' version '1.9.0'
}
dependencies {
    implementation 'org.jetbrains.kotlin:kotlin-stdlib:1.9.0'
}

В памяти: Загружает Kotlin-компилятор и зависимости, добавляя 100-200 МБ overhead.

Android:
Плагин com.android.application или com.android.library для Android-проектов.

Пример:

plugins {
    id 'com.android.application' version '8.1.0'
    id 'org.jetbrains.kotlin.android' version '1.9.0'
}
android {
    compileSdk 33
    defaultConfig {
        applicationId 'com.example.app'
        minSdk 21
        targetSdk 33
        versionCode 1
        versionName '1.0'
    }
}

В памяти: Android-плагины загружают Android SDK, инструменты сборки (dexer, aapt2) и зависимости, что может потребовать 500-1000 МБ памяти.

Создание собственных плагинов

Собственные плагины позволяют кастомизировать сборку. Они могут быть написаны на Groovy, Kotlin или Java.

Плагин на Groovy
Создайте проект с структурой:

my-plugin/
├── src/main/groovy/com/example/MyPlugin.groovy
├── build.gradle

Реализуйте плагин:

package com.example
import org.gradle.api.Plugin
import org.gradle.api.Project

class MyPlugin implements Plugin<Project> {
    void apply(Project project) {
        project.tasks.register('myTask') {
            doLast {
                println 'Hello from MyPlugin!'
            }
        }
    }
}

Настройте build.gradle:

plugins {
    id 'groovy'
    id 'maven-publish'
}
group = 'com.example'
version = '1.0'
publishing {
    publications {
        maven(MavenPublication) {
            from components.java
        }
    }
}

Опубликуйте:

./gradlew publish.

В памяти: Groovy-плагины загружают Groovy-библиотеки, добавляя 50-100 МБ overhead.

Плагин на Kotlin

Создайте проект:

my-plugin/
├── src/main/kotlin/com/example/MyPlugin.kt
├── build.gradle.kts

Реализуйте плагин:

package com.example
import org.gradle.api.Plugin
import org.gradle.api.Project

class MyPlugin : Plugin<Project> {
    override fun apply(project: Project) {
        project.tasks.register("myTask") {
            doLast {
                println("Hello from MyPlugin!")
            }
        }
    }
}

Настройте build.gradle.kts:

plugins {
    `kotlin-dsl`
    `maven-publish`
}
group = "com.example"
version = "1.0"
publishing {
    publications {
        create<MavenPublication>("maven") {
            from(components["java"])
        }
    }
}

Опубликуйте:

./gradlew publish.

В памяти: Kotlin-плагины загружают Kotlin-библиотеки, добавляя 50-100 МБ overhead, но обеспечивают строгую типизацию.

Плагин на Java
Аналогично, но используйте Java-классы:

package com.example;
import org.gradle.api.Plugin;
import org.gradle.api.Project;

public class MyPlugin implements Plugin<Project> {
    @Override
    public void apply(Project project) {
        project.getTasks().register("myTask", task -> {
            task.doLast(t -> System.out.println("Hello from MyPlugin!"));
        });
    }
}

В памяти: Java-плагины легче, чем Groovy/Kotlin, так как не требуют дополнительных библиотек DSL.

Публикация плагина
Опубликуйте в локальный репозиторий:

./gradlew publishToMavenLocal

Используйте в другом проекте:

plugins {
    id 'com.example.my-plugin' version '1.0'
}

#Java #middle #Gradle #Task #Plugin

Gradle Plugin Portal

Gradle Plugin Portal (plugins.gradle.org) — центральный репозиторий для публикации и загрузки плагинов.

Публикация:
Зарегистрируйтесь на plugins.gradle.org.
Получите API-ключ.

Настройте build.gradle:

plugins {
    id 'com.gradle.plugin-publish' version '1.2.0'
}
pluginBundle {
    plugins {
        myPlugin {
            id = 'com.example.my-plugin'
            displayName = 'My Plugin'
            description = 'A custom Gradle plugin'
            tags = ['custom', 'example']
            version = '1.0'
        }
    }
}

Опубликуйте:

./gradlew publishPlugins.

Использование:

plugins {
    id 'com.example.my-plugin' version '1.0'
}

В памяти: Gradle Plugin Portal загружает метаданные плагинов в память при разрешении, добавляя небольшой overhead (10-50 МБ).

Plugin Resolution Strategy

Gradle разрешает плагины из репозиториев, указанных в pluginManagement или buildscript.

Стратегия разрешения:
Поиск: Gradle ищет плагин в Gradle Plugin Portal, Maven Central или пользовательских репозиториях.
Конфликты: Если плагин доступен в нескольких версиях, Gradle выбирает новейшую или указанную версию.

Настройка:

configurations.all {
    resolutionStrategy {
        force 'com.example:my-plugin:1.0'
    }
}

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

pluginManagement в settings.gradle

Блок pluginManagement в settings.gradle позволяет централизованно управлять плагинами для всех модулей.

Пример:

pluginManagement {
    repositories {
        gradlePluginPortal()
        mavenCentral()
    }
    plugins {
        id 'org.springframework.boot' version '2.7.18'
    }
}

Kotlin DSL:

pluginManagement {
    repositories {
        gradlePluginPortal()
        mavenCentral()
    }
    plugins {
        id("org.springframework.boot") version "2.7.18"
    }
}

Назначение:
Указывает репозитории для плагинов.
Фиксирует версии плагинов для всех модулей.

Поддерживает кастомные разрешения:

pluginManagement {
    resolutionStrategy {
        eachPlugin {
            if (requested.id.id == 'com.example.my-plugin') {
                useModule('com.example:my-plugin:1.0')
            }
        }
    }
}

В памяти: pluginManagement загружает метаданные плагинов во время инициализации, добавляя минимальный overhead (10-30 МБ), но обеспечивая согласованность версий.

Нюансы и внутренние механизмы

Управление памятью:
Плагины загружаются как Java-классы в JVM, включая их зависимости. Крупные плагины (например, android) могут добавлять 500-1000 МБ overhead.
Скриптовые плагины парсятся как Groovy/Kotlin-скрипты, увеличивая потребление памяти из-за динамической компиляции.
Оптимизируйте с помощью pluginManagement для централизованного управления и минимизации дублирования.

Кэширование:
Плагины и их зависимости кэшируются в ~/.gradle/caches/modules-2, снижая сетевые запросы.
Очистка кэша:

rm -rf ~/.gradle/caches.

Производительность:
plugins {} быстрее, чем apply plugin:, за счет оптимизированного разрешения.
Параллельное выполнение задач (--parallel) ускоряет сборку, но увеличивает пиковое потребление памяти.
Используйте --configure-on-demand для сокращения времени конфигурации.

Отладка:
Используйте --info или --debug для анализа загрузки плагинов:

./gradlew build --debug

Проверьте список задач:

./gradlew tasks --all.

Build Scans (--scan) показывают влияние плагинов на сборку.

Совместимость:
Убедитесь, что плагины совместимы с версией Gradle (например, Android-плагины требуют Gradle 7.0+).
Используйте JAVA_HOME с JDK 8+ (рекомендуется 11+).

Безопасность:
Храните учетные данные для репозиториев в ~/.gradle/gradle.properties с ограниченными правами (chmod 600).
Проверяйте плагины из Gradle Plugin Portal на наличие GPG-подписей.

#Java #middle #Gradle #Task #Plugin