🧵 Virtual Threads (Project Loom) — тысячи потоков без overhead’а

Хочешь запускать 10 000 параллельных задач в Java без боли с thread pool?
Теперь можно — с virtual threads. Это не абстракция, это реальность с Java 21.

🔧 Пример 1: 100 000 задач — без проблем

import java.util.concurrent.*;

public class Demo {
    public static void main(String[] args) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 100_000; i++) {
                executor.submit(() -> {
                    Thread.sleep(1000);
                    return null;
                });
            }
        }
    }
}

⏱️ В обычных потоках такой код бы уронил JVM или занял бы гигабайты памяти.
А здесь — запускается моментально.

🔧 Пример 2: простой виртуальный поток без Executor'а

Thread.startVirtualThread(() -> {
    System.out.println("Привет из виртуального потока!");
});

Никаких ExecutorService, никаких пулов — просто и понятно.

🔧 Пример 3: параллельные HTTP-запросы

var urls = List.of(
    "https://example.com", "https://google.com", "https://github.com"
);

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    urls.forEach(url -> executor.submit(() -> {
        var content = new String(new URL(url).openStream().readAllBytes());
        System.out.println("Получено с " + url + ": " + content.length() + " байт");
    }));
}

📎 Virtual threads идеально подходят для сетевого I/O.

🔧 Пример 4: обработка запросов к серверу

while (true) {
    var socket = serverSocket.accept();
    Thread.startVirtualThread(() -> handle(socket));
}

Каждое подключение — отдельный виртуальный поток.
Такой сервер обрабатывает десятки тысяч клиентов — легко.


🗣️ Запомни: Ты больше не пишешь async-коллбеки и не страдаешь с пулом.
Теперь можно писать простой, читаемый blocking-код,
а JVM делает всю тяжёлую работу под капотом.

☕️ `var` в Java — типы без шума

Java 10 принес var — возможность писать меньше кода без потери типов. Он не делает Java динамической, но помогает писать чище и быстрее.

⚡️ До и после var

📌 Было:

HashMap<String, List<Integer>> map = new HashMap<String, List<Integer>>();

📌 Стало:

var map = new HashMap<String, List<Integer>>();

👉 Код стал вдвое короче, но компилятор по-прежнему знает точный тип.


🔁 Циклы:

var list = List.of("A", "B", "C");

for (var item : list) {
    System.out.println(item);
}

🔍 item — автоматически String. Работает идеально с Map:

var map = Map.of("one", 1, "two", 2);

for (var entry : map.entrySet()) {
    System.out.println(entry.getKey() + " = " + entry.getValue());
}

🔄 Stream API

var names = List.of("john", "jane", "max");

var upper = names.stream()
    .map((var name) -> name.toUpperCase())
    .filter(n -> n.startsWith("J"))
    .toList();

👉 Лаконично, читаемо, с сохранением типовой строгости.

🧪 Использование с методами

var user = getUser(); // Что возвращает getUser?

⚠️ Неочевидно. Лучше явно:

User user = getUser();

или хотя бы:

var user = getUser(); // getUser() → User

✍️ Пиши комментарий, если тип важен для читаемости.

💡 Когда var — 🔥

Тип очевиден из правой части:

  var url = new URL("https://example.com");
  

Тип слишком громоздкий:

  var map = new HashMap<String, Map<Integer, Set<List<String>>>>();
  

В локальных временных переменных:

  var tmp = Files.readAllLines(Path.of("file.txt"));
  

❌ Когда лучше не использовать

var result = doStuff();

⚠️ Тип неочевиден — хуже читается. Особенно в API, сигнатурах и публичных методах:

// Так нельзя
public var getUser() { ... }

📛 var работает только локально, и только с инициализацией:

var x;           // ❌ ошибка
var list = null; // ❌ ошибка

🗣️ Запомни: var — не фишка ради фишки. Он помогает избавиться от шума там, где типы очевидны. Не злоупотребляй, но используй — особенно в стримах, циклах, дженериках и временных переменных.

⌨️ Полезные стримы. Группировка

Дан список людей с именем и городом проживания. Нужно сгруппировать их по городам.

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

record Person(String name, String city) {}

public class StreamExample {
    public static void main(String[] args) {
        List<Person> people = List.of(
    new Person("Alice", "New York"),
    new Person("Bob", "Los Angeles"),
    new Person("Charlie", "New York"),
    new Person("David", "Los Angeles"),
    new Person("Edward", "San Francisco")
        );

        Map<String, List<Person>> peopleByCity = people.stream()
                .collect(Collectors.groupingBy(Person::city));

        peopleByCity.forEach((city, peopleInCity) -> {
            System.out.println(city + ": " + peopleInCity.stream()
                    .map(Person::name)
                    .collect(Collectors.joining(", ")));
        });
        // Вывод:
        // San Francisco: Edward
        // New York: Alice, Charlie
        // Los Angeles: Bob, David
    }
}

#java #stream #grouping

☕️ Эффектом observability: мониторинг Java‑микросервисов без бюджета

В микросервисной архитектуре наблюдаемость — не роскошь, а умение выжить в проде. Как сделать качественный мониторинг без затратных решений? Ответ в новой статье от Anderson Kuntz Meurer.

🔍 В статье вы узнаете:

📌 Три ключевых слоя наблюдаемости: метрики (Prometheus+Grafana), логи (Loki/ELK) и трассировки.
📌 Реальный пример: Docker‑стек с Spring Boot и Open Telemetry агентом.
📌 Как привязать @RestController к метрикам — HTTP‑статы, latency, ошибки.
📌 Как настроить сбор и визуализацию трассировки (spans, trace‑ID) между микро сервисами .
📌 Почему это — тот минимум, без которого продакшн‑микросервисы — не Продакшн.

➡️ Читайте и наслаждайтесь

🗣️ Бюджетный стек — не значит посредственный. Если хочешь стабильный, масштабируемый прод, начни с observability, сделай стек понятным и системным.

🤩 Java Фишки и трюки || #Java #Observability #Статья

🛰 Embedded JavaScript в JVM — запускаем JS в Java без WebView

Хочешь встроить JavaScript в Java-приложение?
Без браузера, без WebView, просто для вычислений, шаблонов, скриптов или конфигов?

Это возможно — через встроенные скриптовые движки. Работает с JDK 8+, на проде, без зависимостей (или с GraalVM).

✅ Как это вообще работает?

Java включает JS-движок (Nashorn до Java 14), а после — можно подключить GraalVM JavaScript.

Через javax.script.ScriptEngine ты можешь:
🟢 выполнять JS-код;
🟢 вызывать JS-функции из Java;
🟢 передавать переменные между языками;
🟢 использовать JS как DSL внутри проекта.

🔧 Простой запуск скрипта

import javax.script.*;

public class Demo {
    public static void main(String[] args) throws Exception {
        ScriptEngine engine = new ScriptEngineManager().getEngineByName("javascript");
        engine.eval("print('Привет из JavaScript');");
    }
}

✔️ Всё — ты только что исполнил JS прямо в JVM.

📥 Передаём переменные

engine.put("name", "Neo");
engine.eval("print('Hello, ' + name);");  // Hello, Neo

Ты можешь прокидывать данные из Java в JS — и наоборот.

📌 Вызываем JS-функцию из Java

engine.eval("function add(a, b) { return a + b; }");

Invocable inv = (Invocable) engine;
Object result = inv.invokeFunction("add", 5, 7);

System.out.println(result);  // 12

➡️ Используй как простую встроенную логику.

🧠 Пример — вычисление формулы из строки

String expr = "price * qty + tax";
Bindings vars = engine.createBindings();
vars.put("price", 100);
vars.put("qty", 2);
vars.put("tax", 50);

Object result = engine.eval(expr, vars);
System.out.println(result);  // 250

Очень удобно для настройки расчётов пользователем без пересборки кода.

⚙️ Подключение GraalVM JS (если JDK >14)

<dependency>
  <groupId>org.graalvm.js</groupId>
  <artifactId>js</artifactId>
  <version>23.1.1</version>
</dependency>

Context context = Context.create("js");
Value result = context.eval("js", "2 + 2");
System.out.println(result.asInt());  // 4

GraalVM даёт современный JS с поддержкой всего ES6+.


🗣️ Запомни:Embedded JavaScript — это про гибкость без внешних зависимостей.
Хочешь дать пользователю конфиги на JS? Или динамически описывать поведение? Или быстро собрать вычислитель формул?Ты можешь запускать JavaScript напрямую в JVM — просто, безопасно и эффективно.

⛓️ Chain of Responsibility на enum-ах — антипаттерн, который работает

Chain of Responsibility — это когда у тебя есть цепочка проверок или действий, которые обрабатываются по очереди, пока не будет «готово» или «отказ».
В Java обычно это: интерфейс + куча обработчиков.
Но можно сделать проще: на `enum` с абстрактными методами.

🔧 Пример: валидация пользователя

enum UserValidator {
    CHECK_NAME {
        boolean validate(User u) {
            return u.name != null && !u.name.trim().isEmpty();
        }
    },
    CHECK_AGE {
        boolean validate(User u) {
            return u.age >= 18;
        }
    },
    CHECK_EMAIL {
        boolean validate(User u) {
            return u.email != null && u.email.contains("@");
        }
    };

    abstract boolean validate(User u);
}

Каждый enum — это как мини-обработчик.
Ты прямо внутри перечисления задаёшь поведение.
Код не размазан по 10 классам и не требует интерфейсов.

🔁 Проверка по цепочке

User user = new User("Neo", 30, "neo@matrix.io");

boolean valid = Arrays.stream(UserValidator.values())
    .allMatch(v -> v.validate(user));

➡️ Если все валидаторы вернули true — пользователь валиден.

⚠️ Обработка ошибок поимённо

Arrays.stream(UserValidator.values())
    .filter(v -> !v.validate(user))
    .forEach(v -> System.out.println("⛔️ Ошибка в: " + v.name()));

📌Ты можешь узнать, что именно не прошло, без лишних if'ов.

🧪 Альтернатива: остановиться на первом ошибочном

Optional<UserValidator> failed = Arrays.stream(UserValidator.values())
    .filter(v -> !v.validate(user))
    .findFirst();

if (failed.isPresent()) {
    System.out.println("Провал на шаге: " + failed.get().name());
}

➡️ Удобно, если хочешь быстро выйти из цепочки.

📦 Всё это работает с обычными классами

class User {
    String name;
    int age;
    String email;

    User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
}

🗣️ Запомни: Иногда enum с методами — это рабочий компромисс, когда не хочется поднимать тяжёлый Chain of Responsibility.Просто, читаемо, удобно. Особенно для валидаций, фильтров, конвертаций и тестов.

☕️Введение в Swing | Как создать графический калькулятор на Java?

Это видео показывает, как создать простой графический калькулятор на Java с использованием Swing. Подойдёт новичкам: шаг за шагом разбирается создание кнопок, полей ввода и обработка событий. Отличный старт для изучения GUI-разработки на Java.

🤩 Java Фишки и трюки || #Видео

👻 Ghost Interfaces: тип как флаг без логики — и это работает

Java позволяет создавать интерфейсы без методов. Они ничего не делают.
Но если ты дашь этот интерфейс классу — ты отмечаешь объект как "особенный".
Это и есть ghost interface — маркерный интерфейс, флаг через тип.

📛 Пример: метка для доступа

public interface AdminAccess {
    // ничего не требует, просто существует
}

public class User {}

public class AdminUser extends User implements AdminAccess {}

➡️ AdminUser не обязан ничего переопределять.
Но теперь ты можешь понять, что это админ, просто глядя на тип.

🧪 Проверка — через instanceof

void check(User u) {
    if (u instanceof AdminAccess) {
        System.out.println("✅ Доступ разрешён");
    } else {
        System.out.println("⛔️ Нет прав");
    }
}

➡️ Вот где начинается магия: поведение зависит от типа, а не от полей или флагов.

🛠 Применение на практике

Смотри, тебе нужно различать обычные запросы и те, что требуют валидации.
Не хочешь городить if (request.needsValidation())? — решается в один тип.

public interface RequiresValidation {}

public class LoginRequest implements RequiresValidation {}
public class PingRequest {}

void handle(Object req) {
    if (req instanceof RequiresValidation) {
        System.out.println("🔍 Проверка данных");
    } else {
        System.out.println("🚀 Без валидации");
    }
}

➡️ Никаких полей. Просто интерфейс как ярлык.

💾 Другой кейс — запрет на сохранение

public interface ReadOnly {}

public class ConfigFile implements ReadOnly {}
public class LogFile {}

void save(Object file) {
    if (file instanceof ReadOnly) {
        throw new RuntimeException("❌ Это read-only");
    }
    System.out.println("💾 Сохраняем файл...");
}

➡️ Без boolean readonly, без .getPermissions() — просто instanceof.

📦 Комбинации: объект — это набор флагов

public interface JsonSerializable {}
public interface RequiresAuth {}

public class ApiRequest implements JsonSerializable, RequiresAuth {}

if (req instanceof JsonSerializable) {
    System.out.println("📤 Преобразуем в JSON");
}
if (req instanceof RequiresAuth) {
    System.out.println("🔐 Проверяем токен");
}

➡️ Всё как в декларации типа: сам объект описывает себя.

📚 enum тоже работает

public interface Internal {}

public enum Command implements Internal {
    REBOOT, SHUTDOWN
}

void dispatch(Enum<?> cmd) {
    if (cmd instanceof Internal) {
        System.out.println("🔐 Внутренняя команда");
    } else {
        System.out.println("🌍 Публичная");
    }
}

➡️ Даже enum может быть "помечен" ghost-интерфейсом.


🗣 Запомни: Ghost Interfaces — это не костыль, а чистый, типовой способ описывать поведение.Они не делают, а говорят. Всё, что нужно — instanceof.Пиши логику по типу, не по данным.

🧪 Java Agents — как влезть в чужой .jar и следить за ним изнутри

Нужно посмотреть, какие классы грузятся в рантайме?
Или вставить лог прямо в чужой метод, не трогая исходник?

Java Agent запускается до `main()` и даёт доступ ко всему, что загружается в JVM.

🔧 Шаг 🔢: создаём агент

public class SpyAgent {
    public static void premain(String args, Instrumentation inst) {
        System.out.println("👁 Агент стартовал");
    }
}

➡️ Метод premain() будет вызван раньше `main()` обычного приложения.
Параметры:

🟢 args — аргументы, переданные агенту
🟢 Instrumentation — интерфейс для перехвата и изменения классов

🧲 Шаг 🔢: перехватываем загрузку классов

inst.addTransformer(new ClassFileTransformer() {
    @Override
    public byte[] transform(ClassLoader loader, String className,
                            Class<?> classBeingRedefined, ProtectionDomain domain,
                            byte[] classfileBuffer) {
        if (className.contains("Service")) {
            System.out.println("🎯 Загружается: " + className);
        }
        return null;
    }
});

➡️ Каждый раз, когда JVM грузит класс — агент получает байты.
Если хочешь, можешь их изменить и отдать «новую» версию класса.

🗂 Шаг🔢: манифест — как JVM узнает, что это агент

Создаём MANIFEST.MF:

Premain-Class: SpyAgent
Can-Redefine-Classes: true

Собираем .jar с этим манифестом:

jar cmf MANIFEST.MF spy-agent.jar SpyAgent.class

🚀 Шаг 4: подключаем агент к приложению

java -javaagent:spy-agent.jar -jar victim.jar

➡️ JVM загрузит твой агент, вызовет premain(), и только потом запустит main() из victim.jar.

🔁 Пример: вставляем поведение с ByteBuddy

new AgentBuilder.Default()
    .type(named("com.example.Target"))
    .transform((builder, type, cl, module) ->
        builder.method(named("process"))
               .intercept(MethodDelegation.to(LoggerInterceptor.class))
    ).installOn(inst);

public class LoggerInterceptor {
    @RuntimeType
    public static void intercept() {
        System.out.println("📦 Метод process() вызван");
    }
}

➡️ Агент находит нужный класс, перехватывает метод и вставляет лог.
Ты не меняешь исходник — всё происходит на лету, при загрузке.

🧱 Структура проекта:

spy-agent/
├── SpyAgent.java
├── LoggerInterceptor.java
├── MANIFEST.MF

🗣️ Запомни: Java Agent — это способ влезть в чужое приложение до его запуска.Ты можешь видеть всё, что грузится, менять методы, добавлять поведение — не касаясь исходников и не пересобирая .jar.

⚙️ "Bytecode Engineering" с ASM и Byte Buddy: правим классы на лету

Хочешь подменить метод в чужом классе, не трогая исходники? Или генерировать новый класс динамически? В Java это делается через байткод-инжиниринг — на уровне JVM-инструкций.

ASM: низкоуровневый контроль

public class AddPrintAdapter extends MethodVisitor {
    public AddPrintAdapter(MethodVisitor mv) {
        super(Opcodes.ASM9, mv);
    }

    @Override
    public void visitCode() {
        super.visitCode();
        mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
        mv.visitLdcInsn("🔥 Метод вызван");
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream",
                           "println", "(Ljava/lang/String;)V", false);
    }
}

➡️ Этот адаптер добавит System.out.println() в начало любого метода. Работа с visitCode() — прямой доступ к байткоду.

ClassReader reader = new ClassReader("com.example.Foo");
ClassWriter writer = new ClassWriter(reader, 0);
ClassVisitor visitor = new ClassVisitor(Opcodes.ASM9, writer) {
    @Override
    public MethodVisitor visitMethod(int access, String name, String desc,
                                     String signature, String[] exceptions) {
        MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
        if (name.equals("run")) {
            return new AddPrintAdapter(mv);
        }
        return mv;
    }
};
reader.accept(visitor, 0);
byte[] modifiedClass = writer.toByteArray();

➡️ Прочитали класс, нашли метод run, встроили println() — и получили новый .class.

🧠 Byte Buddy: высокоуровневая альтернатива

new ByteBuddy()
  .subclass(Object.class)
  .name("com.example.DynamicClass")
  .defineMethod("hello", void.class, Modifier.PUBLIC)
  .intercept(MethodDelegation.to(HelloInterceptor.class))
  .make()
  .load(ClassLoader.getSystemClassLoader());

➡️ Создаём класс с методом hello() прямо во время выполнения. Без .java-файлов, всё в памяти.

public class HelloInterceptor {
    @RuntimeType
    public static void intercept() {
        System.out.println("👋 Hello from dynamic method");
    }
}

➡️ При вызове hello() будет выполнен этот перехватчик. Никаких аннотаций, никакой магии — только Java.

🗣️ Запомни:Bytecode-инжиниринг даёт тебе контроль над классами после компиляции. ASM — это scalpel. Byte Buddy — это лего. Если нужно вставить поведение в рантайме — это твой инструмент.

⚙️ Java Core — что реально важно понимать

Java Core — это не просто "синтаксис", это то, на чём держится весь язык: классы, объекты, память, потоки, исключения. Ни Spring, ни фреймворки не помогут, если ты не знаешь базу.

📦 Классы и объекты

class User {
    String name;
    int age;

    void sayHello() {
        System.out.println("Привет, меня зовут " + name);
    }
}

User u = new User();
u.name = "Иван";
u.sayHello();

➡️ Всё в Java — объект. Класс — это чертёж. Объект — это реальность.

👷 Конструкторы и перегрузка

class Point {
    int x, y;

    Point() {
        this(0, 0);
    }

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

➡️ this(...) вызывает другой конструктор — удобно задавать значения по умолчанию.

🧱 Наследование и super

class Animal {
    void speak() {
        System.out.println("звук");
    }
}

class Dog extends Animal {
    void speak() {
        super.speak();
        System.out.println("гав");
    }
}

➡️ super нужен, когда хочешь использовать поведение родителя, а не полностью переопределять.

🧠 Интерфейсы и абстракции

interface Printable {
    void print();
}

class Book implements Printable {
    public void print() {
        System.out.println("Печать книги");
    }
}

➡️ Интерфейс задаёт что умеет объект, но не как именно.

🔁 Память: stack vs heap

void run() {
    int x = 10;              // stack
    String name = "Java";    // heap (объект)
}

➡️ Локальные переменные — в стеке. Объекты и массивы — в куче (heap).

🪓 Final, static, this

class Example {
    static int count = 0;
    final int id;

    Example() {
        this.id = ++count;
    }
}

🟢 final — нельзя переопределить/изменить
🟢 static — общая переменная на все объекты
🟢 this — текущий объект

🔄 Циклы, итераторы, foreach

List<String> names = List.of("Alice", "Bob");

for (String name : names) {
    System.out.println(name);
}

➡️ Работает с коллекциями, массивами, любым, что реализует Iterable.

🧰 try-catch-finally

try {
    int x = 1 / 0;
} catch (ArithmeticException e) {
    System.out.println("Ошибка: деление на 0");
} finally {
    System.out.println("Завершение");
}

➡️ finally выполнится всегда. Можно использовать для закрытия ресурсов.

⚡️ Вложенные классы и лямбды

Runnable r = () -> System.out.println("Привет из потока");
new Thread(r).start();

➡️ Лямбды — краткий способ описать анонимный метод.

⛓️equals() 🆚 ==

String a = "test";
String b = new String("test");

System.out.println(a == b);        // false
System.out.println(a.equals(b));   // true

🟢 == сравнивает ссылки
🟢 .equals() сравнивает содержимое

🧵 Потоки (Thread) и синхронизация

class Task extends Thread {
    public void run() {
        System.out.println("Поток: " + Thread.currentThread().getName());
    }
}
new Task().start();

➡️ start() запускает поток асинхронно. run() — просто метод, вызовется как обычный.

🔑 Ключевые коллекции

List<String> list = new ArrayList<>();
Set<String> set = new HashSet<>();
Map<String, Integer> map = new HashMap<>();

🟢List — упорядоченный список
🟢Set — уникальные элементы
🟢 Map — пары ключ-значение

📚 Generic'и

class Box<T> {
    T value;

    void set(T value) { this.value = value; }
    T get() { return value; }
}

➡️ Box<String>, Box<Integer> — типизируешь класс под себя.


🗣️ Запомни:
Java Core — это то, что ты используешь каждый день, даже если не замечаешь. Понимание классов, памяти, коллекций, исключений и потоков — это не “для экзамена”, это основа всей архитектуры твоего кода.

🌐 Java:Что выбрать — виртуальные потоки или реактивный подход?

В 2025 году Java предлагает два мощных и актуальных подхода к масштабируемому коду: виртуальные потоки (Project Loom) и реактивное программирование (Project Reactor, RxJava). Какой из них выбрать, зависит от задач, но важно понять различия.

В статье ты узнаешь:

📌 Что такое виртуальные потоки и как они упрощают многозадачность, устраняя сложности с потоками ОС.
📌 Когда классический реактивный подход через Flux/Mono оправдан — и где он будет эффективнее.
📌 Конкретные примеры — REST‑сервисы, WebFlux и виртуальные потоки одновременно.
📌 Почему виртуальные потоки могут заменить реактив на большинстве задач, но не всегда.

➡️ Читайте и наслаждайтесь

🗣️ Вывод: Java - это мир гибкого выбора: хочешь простоту и читаемость — бери Loom, нужна экстремальная отказоустойчивость — Reactivity остаётся в деле.

🤩 Java Фишки и трюки || #Cтатья #ProjectLoom #Reactive

☕️ ThreadPool в Java: управляем потоками по-взрослому

Если тебе нужно запускать задачи параллельно — не создавай 1000 new Thread() руками.
ThreadPool даст тебе контроль, переиспользование потоков и экономию ресурсов.

🚀 Простой пул через Executors

ExecutorService pool = Executors.newFixedThreadPool(4);

for (int i = 0; i < 10; i++) {
    int taskId = i;
    pool.submit(() -> {
        System.out.println("🔧 Задача " + taskId + " в потоке " + Thread.currentThread().getName());
    });
}

pool.shutdown();

➡️ Пул из 4 потоков. Все 10 задач выполнятся по очереди, переиспользуя потоки.
➡️ shutdown() завершает работу пула после выполнения задач.

⚖️ Типы пулов

Executors.newFixedThreadPool(4);       // фиксированное количество потоков
Executors.newCachedThreadPool();       // динамически растёт при нагрузке
Executors.newSingleThreadExecutor();   // один поток на всё

🟢 Fixed — стабильный.
🟢 Cached — вспышки нагрузки.
🟢 Single — последовательные задачи.

🧠 Почему не new Thread()?

new Thread(() -> doStuff()).start();  // плохо для большого числа задач

👍 Каждый Thread — это новый объект + ресурсы ОС.
👍 Пулы переиспользуют потоки, управляют ими и не перегружают систему.

🧰 Завершение работы пула

pool.shutdown();                    // мягкое завершение
pool.awaitTermination(10, TimeUnit.SECONDS);

pool.shutdownNow();                 // жёсткая остановка

➡️ Сначала shutdown(), потом awaitTermination() — ждёшь окончания.
➡️ shutdownNow() — кидает InterruptedException в задачи.

⛓️ Callable и Future

ExecutorService pool = Executors.newSingleThreadExecutor();

Callable<String> task = () -> {
    Thread.sleep(1000);
    return "Готово!";
};

Future<String> result = pool.submit(task);

System.out.println(result.get());  // блокирует до результата
pool.shutdown();

➡️ Callable возвращает значение, в отличие от Runnable.
➡️ Future.get() — ждёт выполнения.

🔍 Настройка вручную через ThreadPoolExecutor

ExecutorService pool = new ThreadPoolExecutor(
    2, 4, 60, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>()
);

➡️ Полный контроль: минимальное/максимальное число потоков, очередь, поведение.

🗣️ Запомни:
ThreadPool — это не про скорость, а про контроль и стабильность. Не плодишь потоки — а держишь их в узде. Подходит для бэкенда, ботов, парсеров, фоновых задач и всего, что живёт в многопоточке.

🌿 Фишки и тонкости Spring — которые реально нужны в проектах

Spring — не только @Autowired и @Controller. Он умеет кэшировать, обрабатывать события, внедрять бин по условию, управлять конфигурацией, проксировать методы и даже сам себя обновлять.

Вот то, что ты точно начнёшь использовать в реальных проектах 👇

🔄 @PostConstruct — инициализация после DI

@Component
public class MyService {
    @PostConstruct
    public void init() {
        System.out.println("✅ Всё сконфигурировано, запускаем...");
    }
}

➡️ Метод вызовется сразу после того, как все зависимости внедрены. Не путать с конструктором — в нём ещё может не быть других бинов.

💥 @EventListener — реакция на внутренние события

@Component
public class UserEventHandler {

    @EventListener
    public void onRegistered(UserRegisteredEvent event) {
        System.out.println("🎉 Новый пользователь: " + event.getEmail());
    }
}

// где-то в коде:
applicationEventPublisher.publishEvent(new UserRegisteredEvent(email));

➡️ Это удобнее, чем коллбэки и наблюдатели — разнесённая логика, ничего не жёстко связано.

🧪 Условная загрузка бинов

@Bean
@ConditionalOnProperty(name = "feature.cool", havingValue = "true")
public CoolFeature coolFeature() {
    return new CoolFeature();
}

➡️ Бин создастся только если в `application.properties` прописано `feature.cool=true`

⚙️ @ConfigurationProperties — структурированная конфигурация

@ConfigurationProperties(prefix = "mail")
@Component
public class MailSettings {
    private String host;
    private int port;
    // getters/setters
}

➡️ В application.yml:

mail:
  host: smtp.example.com
  port: 587

📌 И всё это уже лежит в MailSettings бин — без @Value, без хардкода.

🧠 Внедрение значений через @Value

@Value("${app.name:DefaultApp}")
private String appName;

➡️ Подтянет app.name из пропертей. Если не указано — будет "DefaultApp".

📍 Логика до и после вызова метода — через AOP

@Aspect
@Component
public class LogAspect {
    @Around("@annotation(Loggable)")
    public Object log(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("▶️ Вызов: " + pjp.getSignature());
        Object result = pjp.proceed();
        System.out.println("⏹️ Результат: " + result);
        return result;
    }
}

➡️ Работает на любой метод с аннотацией @Loggable. Реальный способ вклиниваться в методы без изменения кода.

⚡️ Кеширование результатов методов

@Cacheable("users")
public User getById(Long id) {
    return userRepository.findById(id).orElseThrow();
}

➡️ При повторных вызовах с тем же id результат будет из кеша. Настраивается в пару строк через @EnableCaching.

🧵 Асинхронные методы без Thread

@Async
public void sendMailAsync(String email) {
    mailSender.send(email);
}

➡️ Метод вызовется в фоне, результат (если Future) можно отследить. Главное — не забыть @EnableAsync.

📦 Создание прототипов: новый бин каждый раз

@Bean
@Scope("prototype")
public Connection tempConnection() {
    return new Connection();
}

➡️ Каждый вызов getBean(Connection.class) даст новый объект, а не singleton.

🔁 Рефреш контекста без перезапуска

@Autowired
private ConfigurableApplicationContext context;

public void reload() {
    context.refresh();
}

➡️ Можно подгрузить новые проперти, обновить бины, не трогая процесс.


🗣️ Запомни:
Spring — не фреймворк, это платформа.
Настоящая сила — в деталях: события, прокси, AOP, конфигурации, кеш, асинхронность.
Чем лучше ты понимаешь эти фишки — тем меньше шаблонного кода и больше магии под контролем.

🔐 Java и Безопасность: как защищают приложения в 2025 году

Безопасность давно перестала быть опцией — это must-have. В 2025 Java предлагает разработчику целый арсенал встроенных решений и новых подходов для защиты своих сервисов.

В статье ты узнаешь:

📌 Какие уязвимости до сих пор типичны для Java-приложений и как их избежать.
📌 Как работают современные security-фреймворки: Spring Security, OPA, Keycloak.
📌 Что такое Zero Trust архитектура и как реализовать её на Java.
📌 Почему OAuth 2.1, JWT и mTLS — это уже не “просто мода”, а стандарт де-факто.

➡️ Читайте и наслаждайтесь

🗣️ Вывод: в мире Java безопасность — это уже не боль, а гибкий и удобный инструментарий. Главное — начать использовать правильно.

🤩 Java Фишки и трюки || #Cтатья #JavaSecurity #SpringSecurity #ZeroTrust

☕️ Hibernate: ORM без боли

Hibernate — это Object-Relational Mapping.
Он превращает твои Java-классы в таблицы и наоборот.
Без JDBC, без ручных SQL-запросов — читаешь и сохраняешь объекты как есть.

📦 Сущность = таблица

@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue
    private Long id;

    private String name;

    @Column(name = "email_address")
    private String email;

    // геттеры/сеттеры
}

🟢 @Entity превращает класс в таблицу
🟢 @Id — это первичный ключ
🟢 @Column — имя колонки, если отличается от поля

🔁 Чтение и запись без SQL

User u = new User();
u.setName("Alice");
u.setEmail("a@example.com");

session.save(u);

🟢 Hibernate сам делает INSERT INTO users ... под капотом.
🟢 Объекты = строки в таблице. Не нужно писать SQL — только работать с Java.

🔍 Поиск через HQL (Hibernate Query Language)

List<User> users = session
    .createQuery("from User where email like :e", User.class)
    .setParameter("e", "%@gmail.com")
    .getResultList();

➡️ from User — это не SQL, а HQL. Работает на уровне классов, не таблиц.

🤝 Связи между таблицами

@Entity
public class Order {

    @Id @GeneratedValue
    private Long id;

    @ManyToOne
    private User user;

    private String product;
}

➡️ Один User — много Order. Hibernate сам создаст user_id в таблице заказов.

User u = session.get(User.class, 1L);
List<Order> orders = u.getOrders(); // автоматический join

➡️ Хочешь lazy, eager — всё регулируется аннотациями.

📋 Обновление и удаление

User u = session.get(User.class, 2L);
u.setName("Bob");
session.update(u);

session.delete(u);

➡️ Hibernate сам решает, какие SQL-команды вызвать — ты просто работаешь с объектами.

🔄 Автоматическое создание таблиц

spring.jpa.hibernate.ddl-auto=update

➡️ Таблицы создаются автоматически по твоим сущностям.

🗣️ Запомни:
Hibernate — это способ писать код, а не SQL. Он мапит Java-объекты на реляционные таблицы, сам управляет транзакциями, связями, сессиями.
Но главное — он не магия, и работает только если ты понимаешь, что под капотом.

☕️ ООП в Java: как писать поддерживаемый код, а не “инкапсуляция + наследование”

Ты не обязан учить ООП по книжке. Но обязан понимать, как структурировать код, чтобы его можно было:

🟢 расширять без боли,
🟢 не дублировать,
🟢 легко тестировать.

Вот как это делается в боевом коде 👇

📦 1. Интерфейсы = API, классы = реализация

public interface Storage {
    void save(String data);
}

public class FileStorage implements Storage {
    public void save(String data) {
        // записать в файл
    }
}

public class DBStorage implements Storage {
    public void save(String data) {
        // сохранить в БД
    }
}

➡️ Теперь всё приложение работает с Storage, а не с FileStorage или DBStorage.

public class App {
    private final Storage storage;

    public App(Storage storage) {
        this.storage = storage;
    }

    public void run() {
        storage.save("some data");
    }
}

👍 Меняешь реализацию — ничего не ломается. Архитектура устойчива.


🔄 2. Поведение через композицию, не через наследование

public class Logger {
    public void log(String message) {
        System.out.println("[LOG] " + message);
    }
}

public class UserService {
    private final Logger logger = new Logger();

    public void register(String name) {
        logger.log("Регистрация пользователя " + name);
    }
}

➡️ Вместо extends Logger — просто вставили поведение. Гибче, проще, безопаснее.

🧩 3. Объекты = поведение, а не мешок полей

public class Order {
    private final List<Product> products;

    public Order(List<Product> products) {
        this.products = products;
    }

    public BigDecimal total() {
        return products.stream()
                       .map(Product::price)
                       .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

➡️ Объект умеет что-то делать, а не просто хранить данные. Это и есть "настоящее ООП".

⚙️ 4. Варианты поведения — через делегаты, не if/else

public interface DiscountPolicy {
    BigDecimal apply(BigDecimal price);
}

public class NoDiscount implements DiscountPolicy {
    public BigDecimal apply(BigDecimal price) {
        return price;
    }
}

public class BlackFridayDiscount implements DiscountPolicy {
    public BigDecimal apply(BigDecimal price) {
        return price.multiply(new BigDecimal("0.7"));
    }
}

public class Checkout {
    private final DiscountPolicy discount;

    public Checkout(DiscountPolicy discount) {
        this.discount = discount;
    }

    public BigDecimal finalPrice(BigDecimal basePrice) {
        return discount.apply(basePrice);
    }
}

➡️ Новый тип скидки? Просто добавь класс. Никаких switch/case/if.

🧠 Реальное ООП — это:

👍 контейнеры поведения с чётким контрактом,
👍 код, который расширяется, а не переписывается,
👍 минимум зависимостей, максимум гибкости,
👍 отделённые обязанности (SRP без декламации).


🗣️ Запомни:
ООП в Java — это не “инкапсуляция — наследование — полиморфизм”, а грамотно разложенные по объектам ответственности и поведение.
Если твой код не надо переписывать, чтобы добавить новый сценарий — это оно.

⌨️ Методы hashCode() и equals()

Методы hashCode() и equals() в Java тесно связаны и играют ключевую роль в работе хеш-структур, таких как HashMap, HashSet, Hashtable.

🔹 Метод equals(Object obj)

Этот метод определяет логическое равенство объектов. По умолчанию (Object.equals) сравниваются ссылки (то есть ==), но обычно его переопределяют, чтобы сравнивать содержимое объектов.

📜 Контракт equals:

1️⃣ Рефлексивность — x.equals(x) должно быть true.
2️⃣ Симметричность — x.equals(y) ⇒ y.equals(x).
3️⃣ Транзитивность — x.equals(y) и y.equals(z) ⇒ x.equals(z).
4️⃣ Согласованность — многократные вызовы x.equals(y) возвращают один и тот же результат, если объекты не меняются.
5️⃣ Сравнение с null — x.equals(null) должно быть false.


🔹 Метод hashCode()

Возвращает целое число, которое используется, например, для определения "корзины" (bucket) в хеш-таблицах.

📜 Контракт hashCode:

👍Если x.equals(y) — обязательно x.hashCode() == y.hashCode().
👍Обратное не обязательно: если x.hashCode() == y.hashCode(), это не значит, что x.equals(y).

🔄 Связь между equals и hashCode:
Если вы переопределяете equals(), вы обязательно должны переопределить и hashCode(), иначе, например, объект не будет корректно работать в HashSet или HashMap.

⛔️ Пример ошибки:

Set<Person> people = new HashSet<>();
people.add(new Person("Alice"));
System.out.println(people.contains(new Person("Alice"))); // false, если hashCode не переопределен

✅ Правильный шаблон:

@Override
public boolean equals(Object obj) {
    if (this == obj) return true;
    if (obj == null || getClass() != obj.getClass()) return false;
    Person person = (Person) obj;
    return name.equals(person.name);
}

@Override
public int hashCode() {
    return Objects.hash(name);
}