Исключения в транзакциях
Исключения — важная часть управления транзакциями в Spring. Они влияют на поведение транзакции, определяя, будет ли она зафиксирована или откатана.
Влияние исключений на транзакции
Spring по умолчанию откатывает транзакцию при выбросе RuntimeException или Error. Однако, если выбрасывается Checked Exception, транзакция будет зафиксирована, если явно не указано иное.
Пример:
Управление rollback для Checked Exception
Если нужно, чтобы транзакция откатывалась при выбросе Checked Exception, можно использовать параметр rollbackFor аннотации @Transactional:
Исключения, при которых не происходит rollback
Иногда нужно исключить определенные исключения из списка тех, которые вызывают откат транзакции. Это можно сделать с помощью параметра noRollbackFor.
Пример:
Обработка исключений в методах с @Transactional
Важно помнить, что @Transactional работает только при вызове метода из другого бина или извне. Внутренние вызовы метода, содержащего аннотацию @Transactional, не будут иметь эффекта.
Пример:
Принудительный откат при исключении
Для явного указания отката транзакции, даже если исключение не требует этого, можно использовать TransactionAspectSupport:
#Java #Training #Spring #TransactionException
Исключения — важная часть управления транзакциями в 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
Оптимизация работы с транзакциями
Транзакции обеспечивают надежность и согласованность данных, но их использование может оказывать значительное влияние на производительность. Чтобы минимизировать затраты на транзакции, важно понимать, как их оптимизировать.
1. Минимизация времени жизни транзакции
Длительные транзакции увеличивают риск блокировок и могут негативно сказаться на производительности.
Чтобы уменьшить время жизни транзакции, нужно:
Выполнять только необходимые операции в рамках транзакции.
Исключить операции, не связанные с базой данных, из транзакции (например, обработку данных, вызовы внешних API).
Неоптимальный код:
Оптимизированный код:
2. Использование правильного уровня изоляции
Высокие уровни изоляции, такие как SERIALIZABLE, обеспечивают максимальную целостность данных, но снижают производительность из-за блокировок. Используйте самый низкий уровень изоляции, который удовлетворяет требованиям:
READ COMMITTED — подходит для большинства приложений.
REPEATABLE READ или SERIALIZABLE — используйте только для критичных операций.
Пример настройки уровня изоляции:
3. Использование транзакций только при необходимости
Транзакции нужны далеко не для всех операций. Например, операции только для чтения могут быть выполнены без транзакции.
Преимущества readOnly = true:
Уменьшает накладные расходы.
Улучшает производительность запросов.
4. Группировка операций
Если транзакции используются часто, можно группировать операции для уменьшения количества транзакций.
Без группировки:
С группировкой:
5. Lazy Loading и транзакции
Использование ленивой загрузки (Lazy Loading) может вызвать ошибки при работе с транзакциями, если транзакция закрыта до момента доступа к связанным данным.
Без правильной настройки или за пределами транзакции ленивые коллекции могут привести к LazyInitializationException.
#Java #Training #Spring #Transactions
Транзакции обеспечивают надежность и согласованность данных, но их использование может оказывать значительное влияние на производительность. Чтобы минимизировать затраты на транзакции, важно понимать, как их оптимизировать.
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
Что выведет код?
#Tasks
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
Варианты ответа:
Anonymous Quiz
23%
true true true Value: Test
46%
false false true Value: Test
0%
false false false Value: Test
31%
true false true Value: Test
Нюансы работы с транзакциями в Spring
Работа с транзакциями в Spring — это не только использование аннотации @Transactional, но и знание различных особенностей и подводных камней.
1. Работа @Transactional с внутренними вызовами
Аннотация @Transactional применима только при вызовах методов из внешнего контекста. Внутренние вызовы методов одного класса не активируют механизмы транзакции.
2. Проксирование и прокси Spring
Spring использует динамические прокси или CGLIB для управления транзакциями. Это означает, что транзакционная логика добавляется через прокси-объект.
Динамические прокси работают только с интерфейсами.
CGLIB-прокси работают с классами и методами.
Если транзакции не работают, убедитесь, что используется корректный тип прокси.
Конфигурация прокси:
3. Вложенные транзакции
Spring поддерживает вложенные транзакции с использованием PROPAGATION_NESTED. Это полезно, когда нужно откатить только часть операций, если в ней возникла ошибка.
4. Тайм-ауты транзакций
Для предотвращения долгих операций можно задать тайм-аут транзакции:
5. Работа с транзакциями в тестах
Spring позволяет удобно тестировать транзакционные методы. Используйте @Transactional в тестах для автоматического отката изменений после выполнения теста.
#Java #Training #Spring #Transactions
Работа с транзакциями в 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
Введение в кеширование в Spring
Кеширование (caching) – это техника оптимизации производительности, которая позволяет сохранять результаты вычислений или запросов для их повторного использования, избегая лишних операций. В Spring кеширование реализуется просто и эффективно благодаря интеграции с Spring Cache.
Как работает кеширование?
При запросе данных приложение сначала проверяет, есть ли результат в кеше:
Если данные найдены, они возвращаются напрямую из кеша.
Если данных нет, выполняется вычисление (или запрос к базе данных), результат сохраняется в кеше и возвращается пользователю.
Spring Cache – основы
Spring Cache предоставляет аннотации и интерфейсы для простого внедрения кеширования.
Основные компоненты:
Кеш-менеджер (Cache Manager) – отвечает за создание и управление кешами.
Аннотации – для указания, какие методы или результаты кешировать.
Spring поддерживает различные провайдеры кеша, например:
ConcurrentMapCache (в памяти, по умолчанию),
Ehcache,
Redis,
Caffeine.
Подключение кеша в Spring
Для начала нужно включить кеширование в вашем приложении:
Создадим сервис, который возвращает данные из базы:
Теперь добавим кеш:
#Java #Training #Spring #Caching
Кеширование (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
Что выведет код?
#Tasks
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
Варианты ответа:
Anonymous Quiz
64%
Final counter: 6
9%
Final counter: 5
9%
Final counter: 4
18%
Final counter: 3
Аннотации @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. Если условие не выполнено, кеширование не происходит.
unless (опциональный)
Условие, при котором результат НЕ будет кешироваться, даже если метод выполнен. Отличается от condition, так как проверяется после выполнения метода.
sync (опциональный)
Если true, запросы для одного и того же ключа будут синхронизированы, чтобы предотвратить одновременное выполнение метода для одного ключа.
Пример использования
1. Простое кеширование
Кеширование результата метода:
2. Сложный ключ для кеша
3. Использование условий
#Java #Training #Spring #Cacheable
@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
@CacheEvict
Аннотация @CacheEvict используется для удаления записей из кеша. Это необходимо, когда данные в кеше устарели, например, после обновления или удаления записи.
Параметры
value / cacheNames (обязательный параметр)
Указывает имя кеша, из которого нужно удалить записи.
key (опциональный)
Указывает ключ, который нужно удалить. Если не указано, удаляется запись, соответствующая ключу, сформированному из аргументов метода.
allEntries (опциональный)
Если true, очищает весь кеш. Используется для полного удаления всех записей в кеше.
beforeInvocation (опциональный)
Если true, удаление из кеша происходит до выполнения метода. По умолчанию удаление происходит после успешного выполнения метода.
Примеры использования
1. Удаление записи из кеша по ключу
2. Очистка всего кеша
3. Очистка перед выполнением метода
Совместное использование @Cacheable и @CacheEvict
Эти аннотации можно использовать вместе для полного управления кешем.
Метод getProduct кеширует продукт.
Метод updateProduct удаляет устаревшие данные из кеша для обновлённого продукта.
Метод clearAllProductsCache очищает весь кеш продуктов.
Советы по использованию
Выбирайте правильный ключ: Убедитесь, что ключ уникален и логичен.
Учитывайте размер кеша: Не храните в кеше слишком большие данные.
Обновляйте кеш своевременно: Используйте @CacheEvict для предотвращения устаревания данных.
Избегайте чрезмерного кеширования: Не кешируйте часто изменяющиеся данные.
#Java #Training #Spring #Cacheable #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
Виды кеша в Spring и настройки конфигурации для Redis, Ehcache и Caffeine
Spring поддерживает разные провайдеры кеширования, что делает его универсальным инструментом. Настроим кеш для Redis, Ehcache и Caffeine.
1. Redis
Redis – это распределённый in-memory хранилище данных, которое поддерживает сложные структуры данных, TTL для кешей, и обеспечивает масштабируемость.
Нюансы работы с Redis
Хранение в памяти:
Все данные в Redis хранятся в оперативной памяти, что обеспечивает быструю скорость доступа.
Обязательно учитывайте объём данных и доступную оперативную память.
Поддержка TTL (время жизни):
Redis позволяет задавать время жизни для каждого ключа.
Это полезно для автоматического удаления устаревших данных.
Ключи кеша:
Redis кеширует данные по ключам, которые генерируются автоматически, если явно не указаны.
Рекомендуется явно задавать ключи с помощью параметра key в @Cacheable.
Проблемы с сериализацией:
Redis по умолчанию использует сериализацию JDK. Это может быть неэффективно.
Лучше использовать JSON-сериализацию, например, через Jackson.
Конкуренция за доступ к кешу:
Redis идеален для распределённых систем, но сетевые задержки могут влиять на производительность.
В локальных приложениях для небольших объёмов данных Redis использовать необязательно.
Шаги настройки Redis-кеша
Добавьте зависимости:
Настройте application.yml:
Конфигурация Redis-кеша:
#Java #Training #Spring #Redis
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
2. Caffeine
Caffeine – это высокопроизводительная библиотека кеширования в памяти, которая отличается от Ehcache максимальной скоростью работы и расширенными возможностями.
Нюансы работы с Caffeine
Стратегии удаления:
Кеш автоматически удаляет устаревшие или редко используемые записи.
Поддерживаются три механизма:
Удаление на основе времени (TTL).
Удаление на основе неактивности (time-to-idle).
Удаление при достижении максимального размера.
Мониторинг:
Caffeine поддерживает метрики, что позволяет отслеживать использование кеша, количество попаданий и промахов.
Ленивая загрузка данных:
Caffeine позволяет автоматически загружать данные при промахе кеша.
Ограничения:
Как и Ehcache, Caffeine работает только локально.
Подходит для небольших и средних объёмов данных.
Шаги настройки Caffeine-кеша
Конфигурация Caffeine-кеша:
#Java #Training #Spring #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
3. Ehcache
Ehcache – это высокопроизводительный провайдер кеша, который работает локально в памяти приложения. Он также поддерживает персистентность данных.
Нюансы работы с Ehcache
Хранение данных:
Данные кешируются в памяти, но могут быть настроены для сохранения на диск (для долговременного хранения).
Конфигурация TTL и TTI:
TTL (time-to-live) определяет максимальное время хранения записи.
TTI (time-to-idle) сбрасывается при каждом доступе к записи.
Гибкость настройки:
Ehcache можно настроить с разной стратегией хранения, например, только в памяти или с поддержкой записи на диск.
Ограничения:
Ehcache работает только локально, что делает его менее подходящим для распределённых систем.
В высоконагруженных приложениях использование кеша в памяти может быть ограничено объёмом оперативной памяти.
Шаги настройки Ehcache
Создайте конфигурацию Ehcache (ehcache.xml):
Конфигурация Spring для Ehcache:
Рекомендации по выбору
Используйте Redis, если:
Вам нужно кеширование в распределённой системе.
Данные должны быть доступны всем экземплярам приложения.
Есть потребность в масштабируемости и гибкости.
Используйте Ehcache, если:
Вы хотите локальное кеширование с минимальными задержками.
Вам важна поддержка дисковой персистентности.
Используйте Caffeine, если:
Вы ищете максимальную производительность и минимальное потребление ресурсов.
Приложение работает локально и не требует масштабируемости.
#Java #Training #Spring #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
Что выведет код?
#Tasks
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
public class Task291124_1 {
public static void main(String[] args) {
LocalDate date = LocalDate.of(2024, 2, 28);
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
String formattedDate = date.plusDays(1).format(formatter);
String nextMonth = date.plusMonths(1).format(formatter);
System.out.println(formattedDate);
System.out.println(nextMonth);
}
}
#Tasks
Варианты ответа:
Anonymous Quiz
60%
2024-02-29 2024-03-28
10%
2024-03-01 2024-03-28
20%
2024-02-29 2024-03-01
10%
2024-03-01 2024-03-29
Примеры использования кеша на примере Caffeine и Redis
1. Пример с использованием Caffeine
Допустим, у нас есть метод, который возвращает данные пользователя.
Проверка:
Первый вызов getUserById(1L) загрузит данные из базы.
Повторный вызов вернёт данные из кеша.
Метод updateUser(1L, user) очистит устаревшие данные из кеша.
Вывод: Кеш на базе Caffeine идеально подходит для небольших объёмов данных с высокой скоростью работы.
2. Пример с использованием Redis
Допустим, мы создаём приложение, где кеш хранится в Redis.
Проверка:
При вызове getProductById(1L) данные сохраняются в Redis.
Повторный вызов с тем же ID возвращает данные из Redis без обращения к базе.
Метод updateProduct(1L, product) удаляет кешированные данные.
Преимущества Redis:
Данные доступны для всех экземпляров приложения в распределённой системе.
Redis поддерживает TTL (время жизни кеша), что удобно для управления устареванием данных.
#Java #Training #Spring #Caffeine #Redis
1. Пример с использованием Caffeine
Допустим, у нас есть метод, который возвращает данные пользователя.
@Service
public class UserService {
@Cacheable("usersCache")
public User getUserById(Long id) {
System.out.println("Fetching user from database...");
// Имитация запроса к базе данных
return new User(id, "User" + id);
}
@CacheEvict(value = "usersCache", key = "#id")
public void updateUser(Long id, User user) {
System.out.println("Updating user in database...");
// Обновление в базе
}
}
Проверка:
Первый вызов getUserById(1L) загрузит данные из базы.
Повторный вызов вернёт данные из кеша.
Метод updateUser(1L, user) очистит устаревшие данные из кеша.
Вывод: Кеш на базе Caffeine идеально подходит для небольших объёмов данных с высокой скоростью работы.
2. Пример с использованием Redis
Допустим, мы создаём приложение, где кеш хранится в Redis.
@Service
public class ProductService {
@Cacheable("productCache")
public Product getProductById(Long id) {
System.out.println("Fetching product from database...");
// Имитация запроса к базе данных
return new Product(id, "Product" + id);
}
@CacheEvict(value = "productCache", key = "#id")
public void updateProduct(Long id, Product product) {
System.out.println("Updating product in database...");
// Обновление в базе
}
}
Проверка:
При вызове getProductById(1L) данные сохраняются в Redis.
Повторный вызов с тем же ID возвращает данные из Redis без обращения к базе.
Метод updateProduct(1L, product) удаляет кешированные данные.
Преимущества Redis:
Данные доступны для всех экземпляров приложения в распределённой системе.
Redis поддерживает TTL (время жизни кеша), что удобно для управления устареванием данных.
#Java #Training #Spring #Caffeine #Redis
Что выведет код?
Задача по aннотации @Transactional, аннотациям @Cacheable и @CacheEvict, симуляция кеша в Spring. Сложность легкая.
Подробный разбор через 30 минут!🫡
#TasksSpring
Задача по aннотации @Transactional, аннотациям @Cacheable и @CacheEvict, симуляция кеша в Spring. Сложность легкая.
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.HashMap;
import java.util.Map;
@SpringBootApplication
@EnableCaching
public class Task291124_2 {
public static void main(String[] args) {
SpringApplication.run(Task291124_2.class, args);
}
@Bean
public CommandLineRunner demo(UserService2911 userService) {
return args -> {
System.out.println(userService.getUserById(1L));
System.out.println(userService.getUserById(1L));
userService.clearCache();
System.out.println(userService.getUserById(1L));
};
}
}
@Service
class UserService2911 {
private final Map<Long, String> database = new HashMap<>();
public UserService2911() {
database.put(1L, "Alice");
}
@Cacheable("users")
public String getUserById(Long id) {
System.out.println("Fetching user from database...");
return database.get(id);
}
@CacheEvict(value = "users", allEntries = true)
public void clearCache() {
System.out.println("Cache cleared");
}
@Transactional
public void updateUser(Long id, String newName) {
database.put(id, newName);
if (newName == null) {
throw new IllegalArgumentException("Name cannot be null");
}
}
}
#TasksSpring