Specification & JPA Auditing — dynamic filter và timestamp tự động

5 field optional → tối đa 2^5 = 32 method

// File: org/springframework/data/jpa/domain/Specification.java (rut gon)
@FunctionalInterface
public interface Specification<T> {

    @Nullable
    Predicate toPredicate(Root<T> root,
                          CriteriaQuery<?> query,
                          CriteriaBuilder criteriaBuilder);

    default Specification<T> and(Specification<T> other) { ... }
    default Specification<T> or(Specification<T> other)  { ... }

    static <T> Specification<T> where(@Nullable Specification<T> spec) { ... }
    static <T> Specification<T> not(Specification<T> spec)             { ... }
}

// Simplified internal (Specification.java)
default Specification<T> and(Specification<T> other) {
    return (root, query, cb) -> {
        Predicate left  = this.toPredicate(root, query, cb);
        Predicate right = other.toPredicate(root, query, cb);
        if (left == null)  return right;
        if (right == null) return left;
        return cb.and(left, right);      // JPA CriteriaBuilder.and()
    };
}

// SimpleJpaRepository.java (rut gon)
public Page<T> findAll(Specification<T> spec, Pageable pageable) {
    TypedQuery<T> query = getQuery(spec, pageable.getSort());
    return readPage(query, getDomainClass(), pageable, spec);
}

protected TypedQuery<T> getQuery(Specification<T> spec, Sort sort) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<T> cq = cb.createQuery(domainClass);
    Root<T> root = cq.from(domainClass);

    Predicate predicate = spec.toPredicate(root, cq, cb);   // <-- goi Specification
    if (predicate != null) {
        cq.where(predicate);                                  // <-- nhet vao WHERE
    }
    // apply sort...
    return em.createQuery(cq);
}

public interface ProjectRepository
    extends JpaRepository<Project, Long>,
            JpaSpecificationExecutor<Project> {   // them interface nay
}

public class ProjectSpecs {

    public static Specification<Project> hasStatus(ProjectStatus status) {
        return status == null ? null
            : (root, q, cb) -> cb.equal(root.get("status"), status);
    }

    public static Specification<Project> createdAfter(Instant from) {
        return from == null ? null
            : (root, q, cb) -> cb.greaterThan(root.get("createdAt"), from);
    }

    public static Specification<Project> createdBefore(Instant to) {
        return to == null ? null
            : (root, q, cb) -> cb.lessThan(root.get("createdAt"), to);
    }

    public static Specification<Project> nameContains(String fragment) {
        return fragment == null ? null
            : (root, q, cb) ->
                cb.like(cb.lower(root.get("name")),
                        "%" + fragment.toLowerCase() + "%");
    }
}

@Service
@RequiredArgsConstructor
public class ProjectService {

    private final ProjectRepository repo;

    public Page<Project> search(ProjectFilter filter, Pageable pageable) {
        Specification<Project> spec =
            Specification.where(ProjectSpecs.hasStatus(filter.status()))
                .and(ProjectSpecs.createdAfter(filter.createdAfter()))
                .and(ProjectSpecs.createdBefore(filter.createdBefore()))
                .and(ProjectSpecs.nameContains(filter.nameContains()));

        return repo.findAll(spec, pageable);
    }
}

-- filter: status=ACTIVE, nameContains="Mobile"
SELECT p.* FROM projects p
WHERE p.status = 'ACTIVE'
  AND LOWER(p.name) LIKE '%mobile%'
ORDER BY p.created_at DESC
LIMIT 20 OFFSET 0;

// KHONG nen — service polluted
public Project create(Project p) {
    p.setCreatedAt(Instant.now());   // de quen
    p.setUpdatedAt(Instant.now());
    return repo.save(p);
}

public Project update(Long id, ProjectUpdate req) {
    Project p = repo.findById(id).orElseThrow();
    p.setName(req.name());
    p.setUpdatedAt(Instant.now());   // de quen
    return repo.save(p);
}

// Simplified AuditingEntityListener (Spring Data Commons)
public class AuditingEntityListener {

    @PrePersist
    public void touchForCreate(Object target) {
        AuditableBeanWrapper<?> wrapper = factory.getBeanWrapperFor(target);
        wrapper.setCreatedDate(dateTimeForNow());        // @CreatedDate field
        wrapper.setCreatedBy(auditor.getCurrentAuditor()); // @CreatedBy field
        wrapper.setLastModifiedDate(dateTimeForNow());   // @LastModifiedDate
        wrapper.setLastModifiedBy(auditor.getCurrentAuditor()); // @LastModifiedBy
    }

    @PreUpdate
    public void touchForUpdate(Object target) {
        AuditableBeanWrapper<?> wrapper = factory.getBeanWrapperFor(target);
        wrapper.setLastModifiedDate(dateTimeForNow());   // @LastModifiedDate
        wrapper.setLastModifiedBy(auditor.getCurrentAuditor()); // @LastModifiedBy
        // createdDate va createdBy KHONG set lai
    }
}

@Configuration
@EnableJpaAuditing
public class JpaConfig {
    // Neu chi dung @CreatedDate / @LastModifiedDate (timestamp),
    // khong can AuditorAware
}

@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public abstract class AuditableEntity {

    @CreatedDate
    @Column(name = "created_at", nullable = false, updatable = false)
    private Instant createdAt;

    @LastModifiedDate
    @Column(name = "updated_at", nullable = false)
    private Instant updatedAt;

    public Instant getCreatedAt() { return createdAt; }
    public Instant getUpdatedAt() { return updatedAt; }
}

@Entity
@Table(name = "projects")
public class Project extends AuditableEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @Enumerated(EnumType.STRING)
    private ProjectStatus status;

    // createdAt, updatedAt inherit tu AuditableEntity
}

@Service
@Transactional
@RequiredArgsConstructor
public class ProjectService {

    private final ProjectRepository repo;

    public Project create(String name) {
        Project p = new Project();
        p.setName(name);
        p.setStatus(ProjectStatus.ACTIVE);
        return repo.save(p);
        // AuditingEntityListener tu set createdAt, updatedAt truoc INSERT
    }
}

@Component
public class SecurityAuditorAware implements AuditorAware<String> {

    @Override
    public Optional<String> getCurrentAuditor() {
        return Optional.ofNullable(
                SecurityContextHolder.getContext().getAuthentication())
            .filter(Authentication::isAuthenticated)
            .map(Authentication::getName)
            .or(() -> Optional.of("system"));   // fallback cho background job
    }
}

// Tham chieu auditor bean:
@EnableJpaAuditing(auditorAwareRef = "securityAuditorAware")

@CreatedBy
@Column(name = "created_by", updatable = false, length = 50)
private String createdBy;

@LastModifiedBy
@Column(name = "updated_by", length = 50)
private String updatedBy;

// SAI: Entity extend AuditableEntity nhung base class thieu @EntityListeners
@MappedSuperclass                                // thieu @EntityListeners(...)
public abstract class AuditableEntity { ... }

// Van dung index cho prefix search:
cb.like(root.get("name"), fragment + "%")   // LIKE 'Mobile%' → index range scan

// KHONG dung index:
cb.like(cb.lower(root.get("name")), "%" + fragment.toLowerCase() + "%")
// LIKE '%mobile%' → full table scan

// SAI:
public interface ProjectRepository extends JpaRepository<Project, Long> { }

// Service:
repo.findAll(spec, pageable);   // compile error: no matching method

// SAI: conflict voi AuditingEntityListener
public Project create(Project p) {
    p.setCreatedAt(Instant.now());   // Listener se ghi de, nhung code gay confusion
    return repo.save(p);
}