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

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore() {
        System.out.println("Logging before method execution");
    }
}

@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceLayerMethods() {}

@Before("serviceLayerMethods()")
public void logBeforeServiceMethod() {
    System.out.println("Executing service method...");
}

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

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {}

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore() {
        System.out.println("Method execution intercepted by AOP.");
    }
}

@Service
public class UserService {
    public void getUserById(Long id) {
        System.out.println("Getting user by ID: " + id);
    }
}

@Aspect
@Component
public class PerformanceLoggingAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();

        Object result = joinPoint.proceed(); // Выполнение метода

        long executionTime = System.currentTimeMillis() - start;
        System.out.println(joinPoint.getSignature() + " executed in " + executionTime + "ms");
        return result;
    }
}
Теперь при вызове методов сервисного слоя будет логироваться время выполнения.

import java.util.ArrayList;
import java.util.List;

public class Task021224_1 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            list.add(i * i);
        }

        list.add(2, 10);
        list.set(0, list.get(3));
        list.remove(Integer.valueOf(16));

        for (int i = 0; i < list.size(); i++) {
            list.set(i, list.get(i) % 7);
        }

        System.out.println(list);
    }
}