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());
    }
}

@Service
public class ExampleService {

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

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

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

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

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

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

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() {
        // Изменения в базе данных
    }
    // После завершения теста транзакция откатывается
}

@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;
    }
}

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());
    }
}

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

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

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

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

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

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

@CacheEvict("usersCache")

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

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

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

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

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

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

@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...");
    }
}

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

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

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

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

<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>

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

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

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

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

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

<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>

@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 готово.

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

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

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

<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>

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

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);
    }
}

@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...");
        // Обновление в базе
    }
}

@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...");
        // Обновление в базе
    }
}

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");
        }
    }
}

Fetching user from database...

Cache cleared

Fetching user from database...