#Git #Commit
https://uncaughtexception.ru/posts/2017/03/22/kogda-nuzhno-delat-kommit/

Столкнулся с тем, что когда делаешь коммиты попросту чаще и только по нужной части и не копишь большой снежный ком, то дышать при виде небольших и понятных для тебя изменений по коду становиться легче. Статья на тему прикладывается.
А как вы практикуете коммиты?
Пишите пока идет вдохновение а потом - все в один большой?

#CompletableFuture #Thread #Future #ThreadSafe
Сколько времени ожидать выполнения Thread потока?
А если что-то упало по дороге и где результат?

Чтобы результат отработки сервиса на базе многопоточности не приходилось контролировать по време ожидания и применять колхозные подходы отловки исключений - удобнее и безопаснее пользоваться CompletableFuture.

О CompletableFuture можно почитать здесь - https://annimon.com/article/3462.

На данном же куске кода показан пример как создаются CompletableFuture задачи (строка 53) и как эти же задачи отдают результат "неотходя от кассы" (строка 59) с помощью метода get().
Под задачами в данном контексте понимаются Runnable, которые заглатывают свои значение в рамках потока и выполняют обработку данных в параллели по ядрам процессора.

#Component #Repository #Service #Spring
Какую Spring аннотацию использовать над классом, @Component или @Repository? А может и @Service?

Статья для понимания разницы на тему:
https://coderlessons.com/articles/java/raznitsa-mezhdu-component-service-controller-i-repository-v-spring

В контексте примера из скриншота аннотация @Repository указывает Spring на то, что это класс персистентного слоя.
А для более ясной логики приложения - служит основой для хранения и вызова коллекции методов.

#Maven #bompom
https://habr.com/ru/post/344480/
Неплохая статья про Maven. Особенно интересен вариант "BOM POM" когда в проекте много модулей и надо управлять версиями зависимостей.

#Maven #DependencyScope #Scope #pom #dependencyManagement
#provided

Поговорим еще о Maven.
Что же такое область действия зависимости "Dependency scope"?
И какой вариант лучше?
<scope>?</scope>

Область действия scope определяет этап жизненного цикла проекта, в котором эта зависимость будет использоваться.
Подробнее можно почитать по ссылке:
https://java-online.ru/maven-dependency.xhtml#scope

#AtomicReference #ThreadSafe
Привет.
А как вы определяете "атомарность" в Java?
Может это тоже самое что и синхронизация?

На мой взгляд атомарность проще всего понять на примере "неделимости" операции.
То есть действие либо выполняется целиком (прочитать, прибавить значение, записать - это инкремент) либо действие и начинать не надо, чтобы объект не расколбасило в его состоянии.

Ссылка на беседу по теме:
https://ru.stackoverflow.com/questions/616278/%D0%90%D1%82%D0%BE%D0%BC%D0%B0%D1%80%D0%BD%D1%8B%D0%B5-%D0%B8-%D0%BD%D0%B5%D0%B0%D1%82%D0%BE%D0%BC%D0%B0%D1%80%D0%BD%D1%8B%D0%B5-%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8-java

#StreamAPI #Map #groupingBy #mapping
Java Stream API рулит.

Только что воспользовался одним из вариантов группировки и еще раз подчеркнул для себя удобство стримов.
Пример - группировка списка рабочих по их должности, при этом нас интересуют только имена:

Map<String, Set<String>> map4 = workers.stream().collect(

Collectors.groupingBy(Worker::getPosition,

Collectors.mapping(Worker::getName,Collectors.toSet())));

https://habr.com/ru/post/348536/

#mockbean #spybean #springboottest #ioc
Делал я тут рефакторинг тестов при бегстве от модного SpringBoot в худой компонент spring-context...

И понял что оказывается в SpringBoot есть такие интересные аннотации для разработки JUnit тестов как @SpyBean и @MockBean, которые работают со Spring IoC контейнер и позволяют внедрять зависимости в контексте тестовых классов.

Дадим краткие определения:
- @MockBean - мокирует (Mockito Mock) зависимость спринга.
- @SpyBean - делает шпиона (Mockito Spy) из спринг бина.

SpringBoot конечно жирный, но есть и приятные моменты, например как эти две аннотации, которые идут в составе.

Для почитать с примером:
https://java-ru-blog.blogspot.com/2020/04/spring-boot-testing-mock-spy.html

#superBuilder #builder #lombok

Как известно аннотация Lombok @Builder упрощает жизнь разработчику при написании кода и делает код более лаконичным и поддерживаемым, особенно при наличии множества полей в классе.

А как насчет билдера для абстрактного класса и наследников?
Для этого есть очень интересное решение - аннотация @SuperBuilder!

Общая схема применения аннотации вкупе с наследниками:
@SuperBuilder
public abstract class Parent {
// начинка...
}

@SuperBuilder
public class Son extends Parent {
// вкусная начинка...
}

@SuperBuilder
public class GrandSon extends Son {
// начинка еще вкусней...
}

Важно - @SuperBuilder нельзя смешивать с @Builder в одной иерархии классов. Это приведет к ошибке компиляции.

Более подробно о применении с примерами можно ознакомиться по ссылке:
https://javascopes.com/lombok-builder-inheritance-bce31ecd/

#builder #lombok

Как реализовать builder паттерн если аннотация вешается на конструктор родительского класса и на конструктор наследника?

На скриншоте явно определена проблема - компилятор ругается на метод builder по возвращаемому типу.

Решение заключается в том, что в аннотацию надо добавить свое имя билдер метода для наследника:
@Builder(builderMethodName = "sunnyBuilder")

Еще один пример для решения этой проблемы можно прочитать по ссылке в пункте "2.3. Сосуществование нескольких Builders".
https://javascopes.com/lombok-builder-inheritance-bce31ecd/

#jdk11 #java11

https://youtu.be/5cBECLrbIqA

#mutable #immutable #cuncurrency

https://youtu.be/f8nEQ5zDsOQ

На мой взгляд настоящее понимание мутабельности, а особенно в контексте многопоточки - это фундаментальная тема.

В этом видео автор кратко раскрывает вопрос почему иммутабельность - это выгодно!

#threadlocal

Столкнулся с проблемой - завел ThreadLocal поле, выполнил .set(), а это поле хоть ты тресни, при запуска сервиса в многопоточном режиме - null и все!

Оказывается, чтобы ThreadLocal поле получило значение внутри параллельной зоны кода - нужно задавать через .set() внутри этой многопоточной зоны кода (в рамках ThreadPool, в котором поле должно иметь определенное состояние).

А от того, что до попадания в параллельную зону делал .set() - ThreadLocal полю на это "фиолетово", оно как было "null" (по инициализации при создании класса), так "null" и зашло в зону работы ThreadPool.

Хоть 100 раз делай .set() до многопоточного режима - ThreadLocal поле окажется в параллельной зоне в таком состоянии, в которым оно было создано.

Мораль басни такова - задать значение ThreadLocal для работы в параллельности можно 2 вариантами:
1) При создании экземпляра класса.
2) С помощью .set() но только внутри многопоточной зоны.

Классные примеры "thread-safety":
https://javascopes.com/java-thread-safety-11db95ab/

#atomicreference

Почему когда пишешь Stream то IDEA предлагает конвертацию в AtomicReference?
Вообще для чего нужен этот тип полей?

Атомики - это классы, которые выполняют операции изменения своего значения атомарно, т.о. они поддерживают lock-free thread-safe использование переменных. Достигается это с помощью алгоритма compare-and-swap (CAS) и работает быстрее, чем аналогичные реализации с блокировками. На уровне инструкций большинства процессоров имеется поддержка CAS.

Например, на скриншоте метод addMissedColToDf может работать в многопоточке и потоки сильно захотят зайти в переменную resultDf и добавить колонку к набору данных, но она (resultDf) даст поработать с ней только по очереди во избежание разбитого состояния каждым из потоков одновременно!

То есть операция либо выполняется полностью либо это поле посылает java действие лесом и не дает ничего сделать.

Классное описание атомиков:
https://github.com/jmorozov/awesome-java-backend-interview-rus/blob/main/java/concurrency.md#как-работают-атомики

#idea #replace #refact

Сегодня делал много замен в коде ввиду разделения классов модуля на несколько модулей по логическому функционалу.

Стимулирующая к работе картина, когда ссылки на объекты краснеют, проект не собирается...

И тут на помощью приходит IDEA!

Горячее сочетание клавиш "Ctrl+Shift+R" и меню замены спасает это покраснение.
Особенно мне понравилась опция замены на базе выделенной зоны. Для этого в "Scope" надо выбрать "Selection".

Подробнее о замене есть в статье на сайте JetBrains: https://www.jetbrains.com/help/idea/finding-and-replacing-text-in-project.html#replace_search_string_in_project

#forkjoinpool

Конкретно в текущем проекте, где я работаю, этот вид threadpool используется для параллельной обработки порций данных.

Надо сказать, что справляется со своей задачей хорошо. Были сделаны сравнения с классическим fixedThreadPool. В результате тестов под настоящей нагрузкой forkjoin подход первым прорвал линию фронта и отработал без ошибок.

В чем сила??
В нем воровская технология отбирания задач у соседа!
Простыми словами можно сказать, что ядра-потоки помогают друг другу в беде, если кого-то из них заваливают.
На самом деле в литературе эта технология так и называется "work stealing".

Классная статья на тему:
https://www.google.com/amp/s/nuancesprog.ru/p/11996/%3famp

#functionalinterface

Допустим надо получить длину строки.
Пишем в коментах - какой вариант вам нравиться и почему?
1. s -> s.length()
2. String::length

Мне нравится, когда в коде используется method reference с двойным двоеточием :: лаконично и красиво. О рекомендации по method reference кстати пишет и Джошуа Блох в книге "Effective Java".

Есть такой вид интерфейсов - "функциональный интерфейс" – содержит только 1 абстрактный метод, и позволяют получить возможность делать method reference :: и пользоваться лямбда выражениями ->.

На такие интерфейсы обычно вешается аннотация @FunctionalInterface - обеспечивает наличие только одного абстрактного метода.
ВАЖНО - default и static методы не в счёт.

https://javarush.ru/groups/posts/592-java-functional-interfaces

#spring #enabletransactionmanagement #transaction

С версии 3.1 Spring ввел аннотацию @EnableTransactionManagement, которая используется с аннотацией @Configuration над конфигурационными классами и включает поддержку бесшовной транзакций через аннотацию @Transactional.

И че за аннотация @Transactional и почему бесшовные??
Метод помечен как @Transactional - это означает откат всех записей, если любая из операций вставки в этом методе завершится неудачей, а также Spring бросит оригинальное исключение.

ВАЖНО: если в методе с аннотацией @Transactional будут действия с БД в виде цикла и будет ошибка хотя бы в одном - то ни один элемент из списка не запишется.

Пример записи в виде цикла:
@Transactional
public void book(String... persons) {
for (String person : persons) {
log.info("Booking " + person + " in a seat...");
jdbcTemplate.update("insert into BOOKINGS(FIRST_NAME) values (?)", person);
}
};

https://spring-projects.ru/guides/managing-transactions/