Java for Beginner

Rollback и Commit транзакций

Транзакции в приложениях обеспечивают выполнение группы операций над базой данных как единого целого. Два основных действия, которые завершают транзакцию, — это commit и rollback.

Что такое Commit?

Commit фиксирует все изменения, сделанные в рамках транзакции, и делает их видимыми для других транзакций. После выполнения команды commit изменения становятся постоянными и не могут быть отменены.

Пример в SQL:

BEGIN TRANSACTION;

UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
UPDATE accounts SET balance = balance + 100 WHERE account_id = 2;

COMMIT;
В этом случае изменения будут сохранены в базе данных.

Что такое Rollback?

Rollback отменяет все изменения, сделанные в рамках текущей транзакции, возвращая базу данных в состояние, предшествующее началу транзакции. Это полезно при возникновении ошибок, когда необходимо гарантировать, что никакие частично выполненные изменения не будут зафиксированы.

Пример в SQL:

BEGIN TRANSACTION;

UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
UPDATE accounts SET balance = balance + 100 WHERE account_id = 2;

ROLLBACK;
В этом случае все изменения будут отменены.

Rollback и Commit в Spring

В Spring транзакции можно управлять как вручную, так и декларативно с помощью аннотации @Transactional.

Пример ручного управления:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

@Service
public class ManualTransactionService {

    @Autowired
    private PlatformTransactionManager transactionManager;

    public void transferMoney(Long fromAccountId, Long toAccountId, double amount) {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        TransactionStatus status = transactionManager.getTransaction(def);

        try {
            // Дебет с одного счета
            debitAccount(fromAccountId, amount);

            // Кредит на другой счет
            creditAccount(toAccountId, amount);

            // Подтверждение транзакции
            transactionManager.commit(status);
        } catch (Exception ex) {
            // Откат транзакции в случае ошибки
            transactionManager.rollback(status);
            throw ex;
        }
    }

    private void debitAccount(Long accountId, double amount) {
        // Логика дебетовой операции
    }

    private void creditAccount(Long accountId, double amount) {
        // Логика кредитной операции
    }
}

#Java #Training #Spring #Rollback #Commit

185 views05:29

Java for Beginner

Rollback с использованием @Transactional

В декларативном подходе Spring автоматически выполняет rollback для транзакций, если метод выбрасывает RuntimeException или Error.

Пример:

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class PaymentService {

    @Transactional
    public void processPayment(Long orderId) {
        try {
            // Обновление информации о заказе
            updateOrder(orderId);

            // Обновление платежной информации
            updatePayment(orderId);
        } catch (Exception e) {
            // Логика обработки исключения
            throw new RuntimeException("Ошибка при обработке платежа");
        }
    }

    private void updateOrder(Long orderId) {
        // Логика обновления заказа
    }

    private void updatePayment(Long orderId) {
        // Логика обновления платежа
    }
}
Если возникает RuntimeException, Spring автоматически откатывает транзакцию.

Принудительный rollback

Если требуется явно указать Spring, что транзакция должна быть откатана, можно использовать TransactionAspectSupport:

import org.springframework.transaction.interceptor.TransactionAspectSupport;

public void performOperation() {
    try {
        // Код операции
    } catch (Exception e) {
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
}

#Java #Training #Spring #Rollback #Commit

174 views05:29

Java for Beginner

Что выведет код?

public class Task261124_1 {
    public static void main(String[] args) {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Index error");
            throw new RuntimeException("Runtime exception thrown");
        } finally {
            System.out.println("Finally block");
        }
    }
}

#Tasks

143 views08:44

Java for Beginner

Варианты ответа:

Anonymous Quiz

50%

Index error Finally block

13%

Index error Runtime exception thrown

Finally block Index error

38%

Index error Finally block Exception in thread "main" RuntimeException: Runtime exception thrown

8 voters138 views08:48

Java for Beginner

🧐 хороший план...😂

https://t.me/Java_for_beginner_dev

#Mems

149 views10:29

Java for Beginner

Исключения в транзакциях

Исключения — важная часть управления транзакциями в Spring. Они влияют на поведение транзакции, определяя, будет ли она зафиксирована или откатана.

Влияние исключений на транзакции

Spring по умолчанию откатывает транзакцию при выбросе RuntimeException или Error. Однако, если выбрасывается Checked Exception, транзакция будет зафиксирована, если явно не указано иное.

Пример:

import org.springframework.transaction.annotation.Transactional;

@Transactional
public void processOrder(Long orderId) throws Exception {
    // Обновление данных
    updateOrder(orderId);

    if (someCondition()) {
        throw new Exception("Проверяемое исключение");
    }
}

@Transactional
public void processPayment(Long paymentId) {
    // Обновление платежа
    updatePayment(paymentId);

    if (someCondition()) {
        throw new RuntimeException("Непроверяемое исключение");
    }
}
В методе processOrder транзакция не будет откатана при выбросе Exception.
В методе processPayment транзакция будет откатана из-за RuntimeException.

Управление rollback для Checked Exception

Если нужно, чтобы транзакция откатывалась при выбросе Checked Exception, можно использовать параметр rollbackFor аннотации @Transactional:

import org.springframework.transaction.annotation.Transactional;

@Transactional(rollbackFor = Exception.class)
public void processOrder(Long orderId) throws Exception {
    // Обновление данных
    updateOrder(orderId);

    if (someCondition()) {
        throw new Exception("Проверяемое исключение");
    }
}
Теперь транзакция откатится, даже если выброшено проверяемое исключение.

Исключения, при которых не происходит rollback

Иногда нужно исключить определенные исключения из списка тех, которые вызывают откат транзакции. Это можно сделать с помощью параметра noRollbackFor.

Пример:

@Transactional(noRollbackFor = IllegalArgumentException.class)
public void performOperation() {
    // Код операции

    if (someCondition()) {
        throw new IllegalArgumentException("Некорректные данные");
    }
}
В этом случае транзакция будет зафиксирована, даже если выбросить IllegalArgumentException.

Обработка исключений в методах с @Transactional

Важно помнить, что @Transactional работает только при вызове метода из другого бина или извне. Внутренние вызовы метода, содержащего аннотацию @Transactional, не будут иметь эффекта.

Пример:

@Service
public class ExampleService {

    @Transactional
    public void method1() {
        // Операции в транзакции
        method2(); // Не будет выполнено в рамках транзакции
    }

    @Transactional
    public void method2() {
        // Операции в транзакции
    }
}

Принудительный откат при исключении

Для явного указания отката транзакции, даже если исключение не требует этого, можно использовать TransactionAspectSupport:

import org.springframework.transaction.interceptor.TransactionAspectSupport;

public void executeWithRollback() {
    try {
        // Код операции
    } catch (Exception e) {
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        throw e;
    }
}

#Java #Training #Spring #TransactionException

133 views13:59

Java for Beginner

Оптимизация работы с транзакциями

Транзакции обеспечивают надежность и согласованность данных, но их использование может оказывать значительное влияние на производительность. Чтобы минимизировать затраты на транзакции, важно понимать, как их оптимизировать.

1. Минимизация времени жизни транзакции

Длительные транзакции увеличивают риск блокировок и могут негативно сказаться на производительности.

Чтобы уменьшить время жизни транзакции, нужно:
Выполнять только необходимые операции в рамках транзакции.
Исключить операции, не связанные с базой данных, из транзакции (например, обработку данных, вызовы внешних API).

Неоптимальный код:

@Transactional
public void processOrder(Long orderId) {
    Order order = orderRepository.findById(orderId).orElseThrow();
    
    // Обработка заказа (долгая операция)
    processOrderDetails(order);

    order.setStatus("PROCESSED");
    orderRepository.save(order);
}

Оптимизированный код:

public void processOrder(Long orderId) {
    Order order = orderRepository.findById(orderId).orElseThrow();
    
    // Вынесение обработки за пределы транзакции
    processOrderDetails(order);

    updateOrderStatus(order);
}

@Transactional
public void updateOrderStatus(Order order) {
    order.setStatus("PROCESSED");
    orderRepository.save(order);
}

2. Использование правильного уровня изоляции

Высокие уровни изоляции, такие как SERIALIZABLE, обеспечивают максимальную целостность данных, но снижают производительность из-за блокировок. Используйте самый низкий уровень изоляции, который удовлетворяет требованиям:
READ COMMITTED — подходит для большинства приложений.
REPEATABLE READ или SERIALIZABLE — используйте только для критичных операций.

Пример настройки уровня изоляции:

@Transactional(isolation = Isolation.READ_COMMITTED)
public void performOperation() {
    // Логика работы с базой данных
}

3. Использование транзакций только при необходимости

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

@Transactional(readOnly = true)
public List<Order> getOrders() {
    return orderRepository.findAll();
}

Преимущества readOnly = true:
Уменьшает накладные расходы.
Улучшает производительность запросов.

4. Группировка операций

Если транзакции используются часто, можно группировать операции для уменьшения количества транзакций.

Без группировки:

@Transactional
public void updateCustomerInfo(Customer customer) {
    customerRepository.save(customer);
}

@Transactional
public void updateOrderInfo(Order order) {
    orderRepository.save(order);
}

С группировкой:

@Transactional
public void updateCustomerAndOrder(Customer customer, Order order) {
    customerRepository.save(customer);
    orderRepository.save(order);
}

5. Lazy Loading и транзакции

Использование ленивой загрузки (Lazy Loading) может вызвать ошибки при работе с транзакциями, если транзакция закрыта до момента доступа к связанным данным.

@Transactional
public Order getOrderWithDetails(Long orderId) {
    Order order = orderRepository.findById(orderId).orElseThrow();
    order.getDetails().size(); // Инициализация ленивой коллекции внутри транзакции
    return order;
}

Без правильной настройки или за пределами транзакции ленивые коллекции могут привести к LazyInitializationException.

#Java #Training #Spring #Transactions

127 views05:29

Java for Beginner

Что выведет код?

class CustomObject {
    private String value;

    public CustomObject(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Value: " + value;
    }
}

public class Task271124_1 {
    public static void main(String[] args) {
        CustomObject obj1 = new CustomObject("Test");
        CustomObject obj2 = new CustomObject("Test");
        Object obj3 = obj1;

        System.out.println(obj1.equals(obj2));
        System.out.println(obj1 == obj2);
        System.out.println(obj1 == obj3);
        System.out.println(obj3.toString());
    }
}

#Tasks

126 views08:44

Java for Beginner

Варианты ответа:

Anonymous Quiz

23%

true true true Value: Test

46%

false false true Value: Test

false false false Value: Test

31%

true false true Value: Test

13 voters131 views08:48

Java for Beginner

И не детям в принципе...🧐😂

https://t.me/Java_for_beginner_dev

#Mems

146 views10:29

Java for Beginner

Нюансы работы с транзакциями в Spring

Работа с транзакциями в Spring — это не только использование аннотации @Transactional, но и знание различных особенностей и подводных камней.

1. Работа @Transactional с внутренними вызовами

Аннотация @Transactional применима только при вызовах методов из внешнего контекста. Внутренние вызовы методов одного класса не активируют механизмы транзакции.

@Service
public class ExampleService {

    @Transactional
    public void method1() {
        method2(); // method2 вызван напрямую, @Transactional не сработает
    }

    @Transactional
    public void method2() {
        // Логика
    }
}
Решение: Вынести вызов метода в другой бин.

2. Проксирование и прокси Spring

Spring использует динамические прокси или CGLIB для управления транзакциями. Это означает, что транзакционная логика добавляется через прокси-объект.

Динамические прокси работают только с интерфейсами.
CGLIB-прокси работают с классами и методами.
Если транзакции не работают, убедитесь, что используется корректный тип прокси.

Конфигурация прокси:

@EnableTransactionManagement(proxyTargetClass = true)
public class AppConfig {
    // Конфигурация
}

3. Вложенные транзакции

Spring поддерживает вложенные транзакции с использованием PROPAGATION_NESTED. Это полезно, когда нужно откатить только часть операций, если в ней возникла ошибка.

@Transactional
public void mainTransaction() {
    try {
        nestedTransaction();
    } catch (Exception e) {
        // Ошибка в вложенной транзакции
    }
}

@Transactional(propagation = Propagation.NESTED)
public void nestedTransaction() {
    // Вложенная транзакция
    throw new RuntimeException("Ошибка во вложенной транзакции");
}
Если возникает ошибка в nestedTransaction(), основная транзакция продолжит выполнение.

4. Тайм-ауты транзакций

Для предотвращения долгих операций можно задать тайм-аут транзакции:

@Transactional(timeout = 5)
public void processWithTimeout() {
    // Транзакция завершится, если длится более 5 секунд
}

5. Работа с транзакциями в тестах

Spring позволяет удобно тестировать транзакционные методы. Используйте @Transactional в тестах для автоматического отката изменений после выполнения теста.

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;
import org.junit.jupiter.api.Test;

@SpringBootTest
public class TransactionalTest {

    @Test
    @Transactional
    public void testTransaction() {
        // Изменения в базе данных
    }
    // После завершения теста транзакция откатывается
}

#Java #Training #Spring #Transactions

139 views13:59

Java for Beginner

Введение в кеширование в Spring

Кеширование (caching) – это техника оптимизации производительности, которая позволяет сохранять результаты вычислений или запросов для их повторного использования, избегая лишних операций. В Spring кеширование реализуется просто и эффективно благодаря интеграции с Spring Cache.

Как работает кеширование?

При запросе данных приложение сначала проверяет, есть ли результат в кеше:
Если данные найдены, они возвращаются напрямую из кеша.
Если данных нет, выполняется вычисление (или запрос к базе данных), результат сохраняется в кеше и возвращается пользователю.

Spring Cache – основы

Spring Cache предоставляет аннотации и интерфейсы для простого внедрения кеширования.

Основные компоненты:
Кеш-менеджер (Cache Manager) – отвечает за создание и управление кешами.
Аннотации – для указания, какие методы или результаты кешировать.

Spring поддерживает различные провайдеры кеша, например:
ConcurrentMapCache (в памяти, по умолчанию),
Ehcache,
Redis,
Caffeine.

Подключение кеша в Spring

Для начала нужно включить кеширование в вашем приложении:

@Configuration
@EnableCaching // Включаем поддержку кеширования
public class CacheConfig {
    // Конфигурация кеша, если требуется (например, Redis или Ehcache)
}

Создадим сервис, который возвращает данные из базы:

@Service
public class DataService {
    public String getDataById(Long id) {
        // Имитация долгого выполнения, например, запроса к БД
        try {
            Thread.sleep(2000); // Задержка 2 секунды
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "Data for ID: " + id;
    }
}

Теперь добавим кеш:

@Service
public class CachedDataService {
    @Cacheable("dataCache") // Кешируем результат метода
    public String getDataById(Long id) {
        // Имитация долгого выполнения
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "Cached data for ID: " + id;
    }
}

#Java #Training #Spring #Caching

141 views05:29

Java for Beginner

Что выведет код?

class SharedResource {
    private int counter = 0;

    public synchronized void increment() {
        counter++;
        System.out.println(Thread.currentThread().getName() + " incremented to " + counter);
    }

    public int getCounter() {
        return counter;
    }
}

public class Task281124_1 {
    public static void main(String[] args) throws InterruptedException {
        SharedResource resource = new SharedResource();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                resource.increment();
            }
        }, "Thread-1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                resource.increment();
            }
        }, "Thread-2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("Final counter: " + resource.getCounter());
    }
}

#Tasks

135 views08:44

Java for Beginner

Варианты ответа:

Anonymous Quiz

11 voters129 views08:48

Java for Beginner

Ага, еще на кухню забежать надо...🤪😂

https://t.me/Java_for_beginner_dev

#Mems

128 views10:29

Java for Beginner

Аннотации @Cacheable и @CacheEvict

@Cacheable

Аннотация @Cacheable указывает, что результат метода должен быть сохранён в кеше. Если метод вызывается с теми же аргументами, то возвращается кешированное значение, а не выполняется метод.

Параметры

value / cacheNames (обязательный параметр)
Имя кеша, в который сохраняется результат. Можно указать одно или несколько значений.
```
@Cacheable("usersCache")
```
key (опциональный)
Позволяет задать ключ для кеша. Если не указано, ключ формируется автоматически на основе аргументов метода.
Можно использовать SpEL (Spring Expression Language) для создания ключей.
```
@Cacheable(value = "usersCache", key = "#id")
public User getUser(Long id) {
return userRepository.findById(id).orElse(null);
}
```

condition (опциональный)
Условие, при котором результат метода будет закеширован. Используется SpEL. Если условие не выполнено, кеширование не происходит.

@Cacheable(value = "usersCache", condition = "#id > 10")
public User getUser(Long id) {
    return userRepository.findById(id).orElse(null);
}

unless (опциональный)
Условие, при котором результат НЕ будет кешироваться, даже если метод выполнен. Отличается от condition, так как проверяется после выполнения метода.

@Cacheable(value = "usersCache", unless = "#result == null")
public User getUser(Long id) {
    return userRepository.findById(id).orElse(null);
}

sync (опциональный)
Если true, запросы для одного и того же ключа будут синхронизированы, чтобы предотвратить одновременное выполнение метода для одного ключа.

@Cacheable(value = "usersCache", sync = true)
public User getUser(Long id) {
    return userRepository.findById(id).orElse(null);
}

Пример использования

1. Простое кеширование
Кеширование результата метода:

@Cacheable("usersCache")
public User getUser(Long id) {
    System.out.println("Fetching user from database...");
    return userRepository.findById(id).orElse(null);
}
Первый вызов с ID 1 сохранит результат в кеше.
Повторные вызовы с тем же ID вернут кешированные данные.

2. Сложный ключ для кеша

@Cacheable(value = "usersCache", key = "#user.id + '-' + #user.name")
public User getUserWithCustomKey(User user) {
    return userRepository.findById(user.getId()).orElse(null);
}
Здесь ключом будет строка, содержащая ID и имя пользователя.

3. Использование условий

@Cacheable(value = "usersCache", condition = "#id > 1000")
public User getUser(Long id) {
    return userRepository.findById(id).orElse(null);
}
Данные кешируются только для ID больше 1000.

#Java #Training #Spring #Cacheable

117 views13:59

Java for Beginner

@CacheEvict

Аннотация @CacheEvict используется для удаления записей из кеша. Это необходимо, когда данные в кеше устарели, например, после обновления или удаления записи.

Параметры

value / cacheNames (обязательный параметр)
Указывает имя кеша, из которого нужно удалить записи.

@CacheEvict("usersCache")

key (опциональный)
Указывает ключ, который нужно удалить. Если не указано, удаляется запись, соответствующая ключу, сформированному из аргументов метода.

@CacheEvict(value = "usersCache", key = "#id")
public void deleteUser(Long id) {
    userRepository.deleteById(id);
}

allEntries (опциональный)
Если true, очищает весь кеш. Используется для полного удаления всех записей в кеше.

@CacheEvict(value = "usersCache", allEntries = true)
public void clearCache() {
    System.out.println("Cache cleared!");
}

beforeInvocation (опциональный)
Если true, удаление из кеша происходит до выполнения метода. По умолчанию удаление происходит после успешного выполнения метода.

@CacheEvict(value = "usersCache", key = "#id", beforeInvocation = true)
public void deleteUser(Long id) {
    throw new RuntimeException("Error occurred!");
}

Примеры использования

1. Удаление записи из кеша по ключу

@CacheEvict(value = "usersCache", key = "#id")
public void updateUser(Long id, User user) {
    userRepository.save(user);
}
Обновляем пользователя и удаляем устаревшие данные из кеша.

2. Очистка всего кеша

@CacheEvict(value = "usersCache", allEntries = true)
public void clearAllUsersCache() {
    System.out.println("All users cache cleared!");
}
Этот метод полностью очищает кеш usersCache.

3. Очистка перед выполнением метода

@CacheEvict(value = "usersCache", key = "#id", beforeInvocation = true)
public void deleteUser(Long id) {
    // Логика удаления пользователя
    userRepository.deleteById(id);
}
Кеш удаляется перед удалением пользователя из базы.

Совместное использование @Cacheable и @CacheEvict

Эти аннотации можно использовать вместе для полного управления кешем.

@Service
public class ProductService {

    @Cacheable("productCache")
    public Product getProduct(Long id) {
        System.out.println("Fetching product from database...");
        return productRepository.findById(id).orElse(null);
    }

    @CacheEvict(value = "productCache", key = "#id")
    public void updateProduct(Long id, Product product) {
        System.out.println("Updating product in database...");
        productRepository.save(product);
    }

    @CacheEvict(value = "productCache", allEntries = true)
    public void clearAllProductsCache() {
        System.out.println("Clearing all product cache...");
    }
}

Метод getProduct кеширует продукт.
Метод updateProduct удаляет устаревшие данные из кеша для обновлённого продукта.
Метод clearAllProductsCache очищает весь кеш продуктов.

Советы по использованию

Выбирайте правильный ключ: Убедитесь, что ключ уникален и логичен.
Учитывайте размер кеша: Не храните в кеше слишком большие данные.
Обновляйте кеш своевременно: Используйте @CacheEvict для предотвращения устаревания данных.
Избегайте чрезмерного кеширования: Не кешируйте часто изменяющиеся данные.

#Java #Training #Spring #Cacheable #CacheEvict

99 views13:59

Java for Beginner

Виды кеша в Spring и настройки конфигурации для Redis, Ehcache и Caffeine

Spring поддерживает разные провайдеры кеширования, что делает его универсальным инструментом. Настроим кеш для Redis, Ehcache и Caffeine.

1. Redis

Redis – это распределённый in-memory хранилище данных, которое поддерживает сложные структуры данных, TTL для кешей, и обеспечивает масштабируемость.

Нюансы работы с Redis

Хранение в памяти:
Все данные в Redis хранятся в оперативной памяти, что обеспечивает быструю скорость доступа.
Обязательно учитывайте объём данных и доступную оперативную память.

Поддержка TTL (время жизни):
Redis позволяет задавать время жизни для каждого ключа.
Это полезно для автоматического удаления устаревших данных.

@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    return RedisCacheManager.builder(redisConnectionFactory)
            .cacheDefaults(RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(Duration.ofMinutes(10))) // Устанавливаем TTL 10 минут
            .build();
}

Ключи кеша:
Redis кеширует данные по ключам, которые генерируются автоматически, если явно не указаны.
Рекомендуется явно задавать ключи с помощью параметра key в @Cacheable.

@Cacheable(value = "productCache", key = "#id")
public Product getProductById(Long id) {
    return productRepository.findById(id).orElse(null);
}

Проблемы с сериализацией:
Redis по умолчанию использует сериализацию JDK. Это может быть неэффективно.
Лучше использовать JSON-сериализацию, например, через Jackson.

@Bean
public RedisCacheConfiguration redisCacheConfiguration() {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.findAndRegisterModules();

    return RedisCacheConfiguration.defaultCacheConfig()
            .serializeValuesWith(
                RedisSerializationContext.SerializationPair.fromSerializer(
                    new GenericJackson2JsonRedisSerializer(objectMapper)
                )
            );
}

Конкуренция за доступ к кешу:
Redis идеален для распределённых систем, но сетевые задержки могут влиять на производительность.
В локальных приложениях для небольших объёмов данных Redis использовать необязательно.

Шаги настройки Redis-кеша

Добавьте зависимости:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>io.lettuce.core</groupId>
    <artifactId>lettuce-core</artifactId>
</dependency>

Настройте application.yml:

spring:
  redis:
    host: localhost
    port: 6379
  cache:
    type: redis

Конфигурация Redis-кеша:

@Configuration
@EnableCaching
public class RedisCacheConfig {
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        return RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(RedisCacheConfiguration.defaultCacheConfig())
                .build();
    }
}
Теперь кеширование данных с помощью Redis работает.

#Java #Training #Spring #Redis

112 views05:29

Java for Beginner

2. Caffeine

Caffeine – это высокопроизводительная библиотека кеширования в памяти, которая отличается от Ehcache максимальной скоростью работы и расширенными возможностями.

Нюансы работы с Caffeine

Стратегии удаления:
Кеш автоматически удаляет устаревшие или редко используемые записи.

Поддерживаются три механизма:
Удаление на основе времени (TTL).
Удаление на основе неактивности (time-to-idle).
Удаление при достижении максимального размера.

Caffeine.newBuilder()
        .maximumSize(500) // Максимум 500 записей
        .expireAfterWrite(10, TimeUnit.MINUTES) // Удаление через 10 минут
        .expireAfterAccess(5, TimeUnit.MINUTES) // Удаление через 5 минут неактивности
        .build();

Мониторинг:
Caffeine поддерживает метрики, что позволяет отслеживать использование кеша, количество попаданий и промахов.

@Bean
public CaffeineCacheManager cacheManager() {
    CaffeineCacheManager cacheManager = new CaffeineCacheManager("usersCache");
    cacheManager.setCaffeine(Caffeine.newBuilder()
            .recordStats() // Включаем статистику
            .maximumSize(1000));
    return cacheManager;
}

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

LoadingCache<Long, User> userCache = Caffeine.newBuilder()
        .maximumSize(100)
        .build(id -> loadUserById(id)); // Метод для загрузки данных

Ограничения:
Как и Ehcache, Caffeine работает только локально.
Подходит для небольших и средних объёмов данных.

Шаги настройки Caffeine-кеша

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>

Конфигурация Caffeine-кеша:

@Configuration
@EnableCaching
public class CaffeineCacheConfig {
    @Bean
    public CaffeineCacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager("usersCache");
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .initialCapacity(100)
                .maximumSize(500)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .recordStats());
        return cacheManager;
    }
}
Теперь кеширование данных с Caffeine готово.

#Java #Training #Spring #Caffeine

97 views05:29

Java for Beginner

3. Ehcache

Ehcache – это высокопроизводительный провайдер кеша, который работает локально в памяти приложения. Он также поддерживает персистентность данных.

Нюансы работы с Ehcache

Хранение данных:
Данные кешируются в памяти, но могут быть настроены для сохранения на диск (для долговременного хранения).

<cache alias="persistentCache">
    <heap unit="entries">1000</heap>
    <disk persistent="true" directory="./cache-data" />
</cache>

Конфигурация TTL и TTI:
TTL (time-to-live) определяет максимальное время хранения записи.
TTI (time-to-idle) сбрасывается при каждом доступе к записи.

<cache alias="myCache">
    <heap unit="entries">500</heap>
    <expiry>
        <ttl unit="seconds">300</ttl> <!-- 5 минут -->
        <tti unit="seconds">60</tti>  <!-- 1 минута неактивности -->
    </expiry>
</cache>

Гибкость настройки:
Ehcache можно настроить с разной стратегией хранения, например, только в памяти или с поддержкой записи на диск.

Ограничения:
Ehcache работает только локально, что делает его менее подходящим для распределённых систем.
В высоконагруженных приложениях использование кеша в памяти может быть ограничено объёмом оперативной памяти.

Шаги настройки Ehcache

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

Создайте конфигурацию Ehcache (ehcache.xml):

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://www.ehcache.org/v3">
    <cache alias="myCache">
        <heap unit="entries">100</heap>
        <expiry>
            <ttl unit="seconds">300</ttl>
        </expiry>
    </cache>
</config>

Конфигурация Spring для Ehcache:

@Configuration
@EnableCaching
public class EhcacheConfig {
    @Bean
    public CacheManager cacheManager() {
        return new EhCacheCacheManager(CacheManager.newInstance("ehcache.xml"));
    }
}
Теперь можно использовать кеширование с Ehcache.

Рекомендации по выбору

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

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

Используйте Caffeine, если:
Вы ищете максимальную производительность и минимальное потребление ресурсов.
Приложение работает локально и не требует масштабируемости.

#Java #Training #Spring #Ehcache

121 views05:29

About

Blog

Apps

Platform