@Entity
@EntityListeners({AuditListener.class, CacheInvalidationListener.class})
public class User {
    // поля сущности
}

@Component
public class AuditListener {
    
    @PrePersist
    public void prePersist(Object entity) {
        System.out.println("PrePersist: " + entity);
    }
    
    @PreUpdate
    public void preUpdate(Object entity) {
        System.out.println("PreUpdate: " + entity);
    }
}

public class AuditListener {
    @PrePersist
    public void setCreationDate(Object entity) {
        if (entity instanceof Auditable) {
            ((Auditable) entity).setCreatedAt(LocalDateTime.now());
        }
    }
}

public class ValidationListener {
    @PrePersist
    @PreUpdate
    public void validate(Object entity) {
        if (entity instanceof Validatable) {
            ((Validatable) entity).validate();
        }
    }
}

public class CacheListener {
    @PostPersist
    @PostUpdate
    @PostRemove
    public void invalidateCache(Object entity) {
        CacheManager.evict(entity.getClass(), entity.getId());
    }
}

import java.util.function.Function;

public class Task030425 {
    public static void main(String[] args) {
        Function<Integer, Integer> func = x -> x % 2 == 0 ? x * 2 : x / 2;
        System.out.println(func.apply(5));
    }
}

@Projection(types = {User.class})
public interface UserSummary {
    String getUsername();
    String getEmail();
}

@Projection(name = "summary", types = User.class)
public interface UserSummary {...}

@Projection(types = User.class)
public interface UserView {
    String getUsername();
    String getEmail();
    
    // Можно включать связанные сущности
    @Value("#{target.department.name}")
    String getDepartmentName();
}

@Projection(types = User.class)
public class UserDto {
    private final String username;
    private final String email;
    
    public UserDto(String username, String email) {
        this.username = username;
        this.email = email;
    }
    
    // Геттеры
}

@Projection(types = User.class)
public interface DynamicUserView {
    @Value("#{target.username + ' (' + target.email + ')'}")
    String getDisplayName();
}

public interface UserRepository extends JpaRepository<User, Long> {
    <T> List<T> findBy(Class<T> type);
    UserSummary findSummaryById(Long id);
}

GET /users/1?projection=summary

@Entity
public class User {
    private Long id;
    private String username;
    private String email;
    // геттеры/сеттеры
}

@Projection(types = User.class)
public interface UserSummary {
    String getUsername();
    String getEmail();
}

// В репозитории
UserSummary findSummaryById(Long id);

@Projection(types = {User.class, Department.class})
public interface UserDetailView {
    String getUsername();
    
    @Value("#{target.department.name}")
    String getDepartmentName();
    
    default String getDisplayInfo() {
        return getUsername() + " from " + getDepartmentName();
    }
}

@Projection(types = Order.class)
public interface OrderView {
    String getOrderNumber();
    
    @Value("#{target.customer}")
    CustomerView getCustomer();
}

@Projection(types = Customer.class)
public interface CustomerView {
    String getName();
}

@Configuration
public class ProjectionConfig {
    @Bean
    public ProjectionDefinitionRegistrar projectionRegistrar() {
        return registrar -> {
            registrar.addProjection(UserSummary.class);
        };
    }
}

spring.data.rest.default-projection=summary

@AnyMetaDef(
    name = "animalMetaDef",
    metaType = "string",
    idType = "long",
    metaValues = {
        @MetaValue(value = "DOG", targetEntity = Dog.class),
        @MetaValue(value = "CAT", targetEntity = Cat.class)
    }
)

@Entity
public class Zoo {
    @Id
    private Long id;

    @Any(metaDef = "animalMetaDef", metaColumn = @Column(name = "animal_type"))
    @JoinColumn(name = "animal_id")
    private Animal animal;  // Может быть Dog или Cat
}

import java.util.function.Predicate;

public class Task040425 {
    public static void main(String[] args) {
        Predicate<String> p1 = s -> s.length() > 4;
        Predicate<String> p2 = s -> s.startsWith("J");
        
        System.out.println(p1.and(p2).test("Java"));
    }
}

@Entity
public class Author {
    @Id
    private Long id;

    @OneToMany(mappedBy = "author")
    @BatchSize(size = 10)  // Загружает до 10 книг за один запрос
    private List<Book> books;
}

@Entity
public class Book {
    @Id
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @BatchSize(size = 5)  // Загружает авторов пачками по 5
    private Author author;
}

SELECT * FROM author WHERE id IN (1, 2, 3, 4, 5)

spring.jpa.properties.hibernate.default_batch_fetch_size=20
Устанавливает глобальный размер пакета для всех ленивых загрузок.