Spring service componentlerinde business-dto validation için spesification pattern kullanımı, örnek kodlar

Spring framework'te, business ve Data Transfer Object (DTO) validasyonları için Specification pattern kullanımı, daha temiz, modüler ve yeniden kullanılabilir kod yazmayı sağlar. Bu pattern, özellikle büyük ve karmaşık iş kurallarını yönetirken etkilidir. İşte Specification pattern kullanarak Spring service componentlerinde validasyon yapmanın temel adımları:

Specification Interface Tanımlama: İlk adım, bir Specification interface'i tanımlamaktır. Bu interface, genellikle tek bir isSatisfiedBy metoduna sahiptir ve bu metod, belirli bir kuralın bir DTO nesnesi tarafından karşılanıp karşılanmadığını kontrol eder.

java

Copy code

public interface Specification<T> {

    boolean isSatisfiedBy(T t);

}

Concrete Specification Sınıfları Oluşturma: Her iş kuralı için ayrı bir Specification sınıfı oluşturulur. Bu sınıflar, Specification interface'ini uygular ve kurala özgü mantığı içerir.

java

Copy code

public class CustomerAgeSpecification implements Specification<CustomerDTO> {

    public boolean isSatisfiedBy(CustomerDTO customer) {

        return customer.getAge() >= 18;

    }

}

Specification'ları Kullanma: Business servislerde, bu specificationları kullanarak DTO'ları doğrulayabilirsiniz. Birden fazla specification'ı birleştirmek için composite pattern kullanılabilir.

java

Copy code

public class CustomerService {

    private Specification<CustomerDTO> customerSpecification = new CustomerAgeSpecification();

    public void addCustomer(CustomerDTO customer) throws ValidationException {

        if (!customerSpecification.isSatisfiedBy(customer)) {

            throw new ValidationException("Customer does not meet the age requirement");

        }

        // ... müşteri işlemleri ...

    }

}

Composite Specifications: Farklı specificationları birleştirmek için, AndSpecification, OrSpecification gibi composite sınıflar oluşturabilirsiniz. Bu sınıflar, birden fazla specification'ı bir arada değerlendirir.

java

Copy code

public class AndSpecification<T> implements Specification<T> {

    private Specification<T> first, second;

    public AndSpecification(Specification<T> first, Specification<T> second) {

        this.first = first;

        this.second = second;

    }

    public boolean isSatisfiedBy(T t) {

        return first.isSatisfiedBy(t) && second.isSatisfiedBy(t);

    }

}

Bu yaklaşım, iş kurallarınızı merkezi olmayan, daha yönetilebilir ve test edilebilir hale getirir. Spring'in Dependency Injection özelliklerini kullanarak, bu specificationları servislerinize kolayca enjekte edebilir ve esnek bir şekilde kullanabilirsiniz.

Specification pattern kullanımının devamında, Spring framework içerisinde daha gelişmiş senaryolar için aşağıdaki yaklaşımları da uygulayabilirsiniz:

Specification Factory Oluşturma: Birden fazla yerde kullanılacak specification kombinasyonları için bir factory sınıfı oluşturabilirsiniz. Bu, kod tekrarını azaltır ve specification oluşturma sürecini merkezileştirir.

java

Copy code

public class CustomerSpecificationFactory {

    public static Specification<CustomerDTO> createEligibilitySpecification() {

        return new AndSpecification<>(

            new CustomerAgeSpecification(),

            // Diğer specificationlar eklenebilir

        );

    }

}

Dynamic Specification Oluşturma: Bazı durumlarda, runtime sırasında dinamik olarak specification oluşturmanız gerekebilir. Bu, özellikle kullanıcı girişlerine veya uygulama durumuna bağlı kural değişiklikleri için yararlıdır.

java

Copy code

public class DynamicCustomerSpecification implements Specification<CustomerDTO> {

    private int requiredAge;

    public DynamicCustomerSpecification(int requiredAge) {

        this.requiredAge = requiredAge;

    }

    @Override

    public boolean isSatisfiedBy(CustomerDTO customer) {

        return customer.getAge() >= requiredAge;

    }

}

Specificationların Test Edilmesi: Her bir specification sınıfı, bağımsız olarak test edilebilir. Bu, iş kurallarınızın doğru şekilde çalıştığını doğrulamanızı sağlar.

java

Copy code

@Test

public void customerAgeSpecification_ShouldValidateCorrectly() {

    CustomerDTO customer = new CustomerDTO();

    customer.setAge(20);

    Specification<CustomerDTO> spec = new CustomerAgeSpecification();

    assertTrue(spec.isSatisfiedBy(customer));

}

Spring'e Entegre Etme: Spring'in Dependency Injection özelliklerini kullanarak, bu specificationları bean olarak tanımlayıp, gerektiği yerlerde enjekte edebilirsiniz. Bu, uygulamanızın genel yapılandırmasını ve yönetilebilirliğini artırır.

java

Copy code

@Configuration

public class SpecificationConfig {

    @Bean

    public Specification<CustomerDTO> customerAgeSpecification() {

        return new CustomerAgeSpecification();

    }

}

java

Copy code

@Service

public class CustomerService {

    @Autowired

    private Specification<CustomerDTO> customerAgeSpecification;

    // Servis metodları...

}

Bu tekniklerle, Spring uygulamanızda iş kurallarınızı modüler, test edilebilir ve sürdürülebilir bir şekilde yönetebilirsiniz. Specification pattern, karmaşık iş kuralları ve validasyonlar için güçlü ve esnek bir çözüm sunar.

Specification pattern'ın Spring framework'te kullanımının devamında, daha gelişmiş teknikler ve en iyi uygulamaları da göz önünde bulundurabilirsiniz:

Specification Zincirleri Oluşturma: Birden fazla specification'ı zincirleme yoluyla birleştirebilirsiniz. Bu, daha karmaşık iş kurallarını kolayca yönetmenize olanak tanır.

java

Copy code

public class CustomerService {

    @Autowired

    private Specification<CustomerDTO> ageSpecification;

    @Autowired

    private Specification<CustomerDTO> incomeSpecification;

    public void processCustomer(CustomerDTO customer) {

        Specification<CustomerDTO> combinedSpec = ageSpecification.and(incomeSpecification);

        if (!combinedSpec.isSatisfiedBy(customer)) {

            throw new ValidationException("Customer does not meet the criteria");

        }

        // ... müşteri işlemleri ...

    }

}

Context-Aware Specifications: Bazı durumlarda, specification'larınızın bağlam bilgisine ihtiyacı olabilir. Bu, external servislerden gelen verilere veya uygulamanın diğer bölümlerine bağlı kurallar için kullanışlıdır.

java

Copy code

public class PremiumCustomerSpecification implements Specification<CustomerDTO> {

    private CustomerHistoryService historyService;

    public PremiumCustomerSpecification(CustomerHistoryService historyService) {

        this.historyService = historyService;

    }

    @Override

    public boolean isSatisfiedBy(CustomerDTO customer) {

        return historyService.getCustomerHistory(customer.getId()).isPremium();

    }

}

Error Reporting: Doğrulama hatası durumunda, hangi kuralın başarısız olduğunu belirten detaylı hata mesajları sağlamak kullanıcı deneyimi açısından önemlidir. Bu, özellikle kullanıcı girişlerinin doğrulanması durumlarında yararlıdır.

java

Copy code

public class ValidationResult {

    private boolean valid;

    private String errorMessage;

    // Getter ve setter metodları...

}

public interface Specification<T> {

    ValidationResult isSatisfiedBy(T t);

}

Spring Validation ile Entegrasyon: Spring'in yerleşik validation framework'ü ile Specification pattern'ı entegre edebilirsiniz. Böylece, Spring'in güçlü validation altyapısından yararlanırken, iş kurallarınızı modüler ve test edilebilir tutabilirsiniz.

java

Copy code

public class CustomerValidator implements Validator {

    private Specification<CustomerDTO> customerSpec;

    @Override

    public boolean supports(Class<?> clazz) {

        return CustomerDTO.class.isAssignableFrom(clazz);

    }

    @Override

    public void validate(Object target, Errors errors) {

        CustomerDTO customer = (CustomerDTO) target;

        if (!customerSpec.isSatisfiedBy(customer)) {

            errors.reject("CustomerValidation", "Customer does not meet the specifications");

        }

    }

}

Bu teknikler, Spring uygulamanızda iş kurallarınızı daha etkin bir şekilde yönetmenize ve kullanıcılarınıza daha iyi bir deneyim sunmanıza yardımcı olur. Specification pattern, esnekliği ve test edilebilirliği artırırken, Spring ile entegrasyonu sayesinde güçlü ve ölçeklenebilir uygulamalar geliştirmenizi sağlar.

Sonuç

Specification pattern'ın Spring framework içinde kullanımı, özellikle karmaşık ve dinamik iş kuralları için oldukça etkilidir. Bu yaklaşım, aşağıdaki avantajları sunar:

Modülerlik ve Yeniden Kullanılabilirlik: İş kurallarını küçük, bağımsız specification sınıflarına ayırarak, kodun modülerliğini ve yeniden kullanılabilirliğini artırır.

Kolay Test Edilebilirlik: Her bir specification, bağımsız olarak test edilebilir, bu da iş kurallarının doğruluğunu sağlamak için test yazmayı kolaylaştırır.

Esneklik: Specificationları runtime'da dinamik olarak oluşturabilir veya birleştirebilirsiniz, bu da iş kurallarınızın değişen gereksinimlere hızlı bir şekilde uyum sağlamasına olanak tanır.

Açık ve Anlaşılır Kod: İş kurallarını açıkça tanımlayan ve ifade eden specificationlar, kodun okunabilirliğini ve bakımını kolaylaştırır.

Spring Entegrasyonu: Spring'in Dependency Injection ve validation framework'leriyle kolay entegrasyon, specification pattern'ının gücünü ve esnekliğini artırır.

Detaylı Hata Raporlama: Doğrulama hatalarını daha iyi yönetebilir ve kullanıcılara anlaşılır hata mesajları sağlayabilirsiniz.

Bağlam Farkındalığı: External servisler ve uygulamanın diğer bölümleri ile etkileşimde bulunan, bağlam bilgisine dayalı kurallar oluşturabilirsiniz.

Bu avantajlar, Spring tabanlı uygulamalarınızda iş kurallarını daha etkin, sürdürülebilir ve ölçeklenebilir bir şekilde yönetmenize yardımcı olur. Specification pattern, karmaşık iş kurallarını yönetme konusunda güçlü ve esnek bir çözüm sunar.

Spring'de DTO'larda custom validation annotationlar nasıl gerçekleştirilir? İleri düzey Java kod örnekleriyle beraber

Spring Framework'te özelleştirilmiş doğrulama kurallarını oluşturmanın birkaç yolu vardır. En popüler yaklaşım, Java'nın Bean Validation API'sini (JSR 380) kullanmaktır. Bu yaklaşımı kullanarak kendi özel doğrulama annotation'larınızı oluşturabilirsiniz.

Bu adımları takip ederek bir özel doğrulama annotation oluşturabilirsiniz:

İlk olarak özel bir annotation oluşturmanız gerekir. Bu annotation, doğrulamanın kullanılacağı yerlerde kullanılacak:

import javax.validation.Constraint;

import javax.validation.Payload;

import java.lang.annotation.*;

@Documented

@Constraint(validatedBy = CustomValidator.class)

@Target( { ElementType.METHOD, ElementType.FIELD })

@Retention(RetentionPolicy.RUNTIME)

public @interface CustomValidation {

    String message() default "{customvalidation}";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

}

Bu kod, bir "CustomValidation" adında özel bir doğrulama annotation oluşturur. @Constraint(validatedBy = CustomValidator.class) satırı, bu annotation'ı kullandığınızda hangi sınıfın kullanılacağını belirtir.

Şimdi, belirlediğimiz CustomValidator sınıfını oluşturmalıyız. Bu sınıf, özel doğrulamanın nasıl gerçekleştirileceğini belirler:

import javax.validation.ConstraintValidator;

import javax.validation.ConstraintValidatorContext;

public class CustomValidator implements ConstraintValidator<CustomValidation, Object> {

    @Override

    public void initialize(CustomValidation constraintAnnotation) {

        // Özelleştirilmiş doğrulamanın başlatılması gereken herhangi bir şey varsa, burada yapılır.

    }

    @Override

    public boolean isValid(Object value, ConstraintValidatorContext context) {

        // value, doğrulamayı yapacağınız değerdir.

        // Bu değeri kontrol edip, true veya false döndürmelisiniz.

        // Örneğin: 

        if(value == null){

            return false;

        }

        return true;

    }

}

Son adımda, oluşturduğunuz annotation'ı DTO'da istediğiniz yerde kullanabilirsiniz:

public class MyDto {

    @CustomValidation

    private String myField;

    // getter ve setter'lar

}

Bu şekilde, myField'ın null olmadığını kontrol eden özel bir doğrulama oluşturduk. Özelleştirilmiş doğrulamanızı genişletebilir ve farklı senaryolar için değiştirebilirsiniz.

Bu örnek, basit bir senaryo için oluşturulmuştur ve genellikle karmaşık durumlar için daha fazla kod ve düşünme gerektirir. Ayrıca, bu doğrulamanın nasıl çalıştığını ve hatalarını nasıl işleyeceğinizi de düşünmelisiniz. Her durumda, Spring'in güçlü doğrulama mekanizması size bu konuda yardımcı olabilir.

Daha karmaşık bir senaryo için tam bir örnek verir misin?

Elbette, daha karmaşık bir senaryo için özelleştirilmiş bir doğrulama annotation'ı oluşturabiliriz. Örneğin, bir @ValidPassword annotation'ı oluşturalım. Bu annotation, parolanın belirli kurallara (en az bir büyük harf, en az bir küçük harf, en az bir sayı ve belirli bir minimum uzunluk) uyup uymadığını kontrol eder.

Öncelikle, @ValidPassword annotation'ını oluştururuz:

import javax.validation.Constraint;

import javax.validation.Payload;

import java.lang.annotation.*;

@Documented

@Constraint(validatedBy = PasswordValidator.class)

@Target({ElementType.FIELD, ElementType.ANNOTATION_TYPE})

@Retention(RetentionPolicy.RUNTIME)

public @interface ValidPassword {

    String message() default "Invalid password. Password must have at least 8 characters, including at least one uppercase letter, one lowercase letter and one number.";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

}

Daha sonra, belirlediğimiz PasswordValidator sınıfını oluştururuz:

import javax.validation.ConstraintValidator;

import javax.validation.ConstraintValidatorContext;

import java.util.regex.Pattern;

public class PasswordValidator implements ConstraintValidator<ValidPassword, String> {

    private static final String PASSWORD_PATTERN = "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z]).{8,}$";

    @Override

    public void initialize(ValidPassword constraintAnnotation) {

        // Initialization code if needed

    }

    @Override

    public boolean isValid(String password, ConstraintValidatorContext context) {

        return password != null && Pattern.matches(PASSWORD_PATTERN, password);

    }

}

Bu sınıf, parolanın belirli bir düzeni karşılayıp karşılamadığını kontrol eder. Regex (düzenli ifade) kullanılarak bir pattern oluşturulur ve bu pattern ile parolanın uyumlu olup olmadığı kontrol edilir.

Son olarak, oluşturduğumuz annotation'ı DTO'da kullanabiliriz:

public class UserDto {

    private String username;

    @ValidPassword

    private String password;

    // getter ve setter'lar

}

Bu örnekte, password alanının belirli kurallara (en az 8 karakter, en az bir büyük harf, en az bir küçük harf ve en az bir sayı içerme) uyması gerektiğini belirttik.

Bu, daha karmaşık bir özelleştirilmiş doğrulama örneğidir. Ancak, burada belirttiğimiz doğrulama kuralları hala oldukça basittir ve genellikle daha karmaşık ve özelleştirilmiş kurallar gerekebilir. Her durumda, burada gösterildiği gibi özelleştirilmiş annotation'lar oluşturarak bu tür kuralları kolayca belirleyebilirsiniz.

Advanced bir örnek daha verir misin?

Elbette, biraz daha karmaşık bir örnek verelim. Bu örnekte, bir DTO'nun birden fazla alanı üzerinde bir doğrulama yapacağız. "Başlangıç tarihi", "Bitiş tarihi"nden önce olmalı ve bu iki tarihi doğrulayacak bir özel annotation oluşturacağız.

İlk olarak, @DateRange annotation'ı oluştururuz:

import javax.validation.Constraint;

import javax.validation.Payload;

import java.lang.annotation.*;

@Documented

@Constraint(validatedBy = DateRangeValidator.class)

@Target({ElementType.TYPE})

@Retention(RetentionPolicy.RUNTIME)

public @interface DateRange {

    String message() default "Start date must be before end date";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

    String startDate();

    String endDate();

}

Ardından DateRangeValidator sınıfını oluştururuz:

import javax.validation.ConstraintValidator;

import javax.validation.ConstraintValidatorContext;

import java.time.LocalDate;

public class DateRangeValidator implements ConstraintValidator<DateRange, Object> {

    private String startDateFieldName;

    private String endDateFieldName;

    @Override

    public void initialize(DateRange constraintAnnotation) {

        this.startDateFieldName = constraintAnnotation.startDate();

        this.endDateFieldName = constraintAnnotation.endDate();

    }

    @Override

    public boolean isValid(Object value, ConstraintValidatorContext context) {

        try {

            LocalDate startDate = (LocalDate) value.getClass().getDeclaredField(startDateFieldName).get(value);

            LocalDate endDate = (LocalDate) value.getClass().getDeclaredField(endDateFieldName).get(value);

            return startDate.isBefore(endDate);

        } catch (Exception e) {

            // Handle the exception appropriately

            e.printStackTrace();

        }

        return false;

    }

}

Son olarak, oluşturduğumuz @DateRange annotation'ı DTO üzerinde kullanabiliriz:

@DateRange(startDate = "startDate", endDate = "endDate")

public class EventDto {

    private String name;

    private LocalDate startDate;

    private LocalDate endDate;

    // getter ve setter'lar

}

Bu örnekte, startDate ve endDate alanlarının başlangıç tarihinin bitiş tarihinden önce olması gerektiğini belirttik. Bu, birden çok alanın değerlerini karşılaştırmak için özelleştirilmiş bir annotation oluşturmak için karmaşık bir örnektir.

Ayrıca ConstraintValidator sınıfında reflection kullanmayı ve bir hata durumunda ne yapılacağını (hatayı bastırmayı, özel bir hata atmayı vs.) düşünmeyi de not edin. Bu tür durumlar genellikle uygulamanın gereksinimlerine ve uygulama içerisinde nasıl hata yönetimi yapılacağına bağlıdır.

Daha advanced bir örnek verir misin?

Çok ileri düzey bir senaryoda, DTO'nun bir bölümünün başka bir bölümünün durumuna bağlı olarak doğrulanması gerektiğini düşünelim. Bir kullanıcının kredi kartı bilgilerini sakladığımız bir DTO'nun örneğini ele alalım. Bir kullanıcı eğer "Kartı Kaydet" seçeneğini seçerse, kart bilgilerinin eksiksiz olduğunu kontrol etmek isteyebiliriz.

Bu durumda DTO'muz şu şekilde görünebilir:

public class UserDto {

    private String username;

    private String password;

    private boolean saveCard;

    private String cardNumber;

    private String cardHolderName;

    private String expiryDate;

    // getter ve setter'lar

}

saveCard boolean değeri true olduğunda, cardNumber, cardHolderName ve expiryDate alanlarının doldurulmuş olması gerekiyor. Bu durumu özel bir validation annotation ile kontrol edebiliriz.

Öncelikle, @ValidCardInfo annotation'ını oluştururuz:

import javax.validation.Constraint;

import javax.validation.Payload;

import java.lang.annotation.*;

@Documented

@Constraint(validatedBy = CardInfoValidator.class)

@Target({ElementType.TYPE})

@Retention(RetentionPolicy.RUNTIME)

public @interface ValidCardInfo {

    String message() default "Card information must be provided when save card option is selected.";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

}

Ardından CardInfoValidator sınıfını oluştururuz:

import javax.validation.ConstraintValidator;

import javax.validation.ConstraintValidatorContext;

public class CardInfoValidator implements ConstraintValidator<ValidCardInfo, UserDto> {

    @Override

    public void initialize(ValidCardInfo constraintAnnotation) {

        // Initialization code if needed

    }

    @Override

    public boolean isValid(UserDto userDto, ConstraintValidatorContext context) {

        if (userDto.isSaveCard()) {

            return userDto.getCardNumber() != null && !userDto.getCardNumber().isEmpty() &&

                    userDto.getCardHolderName() != null && !userDto.getCardHolderName().isEmpty() &&

                    userDto.getExpiryDate() != null && !userDto.getExpiryDate().isEmpty();

        } else {

            return true;

        }

    }

}

Bu sınıf, saveCard boolean değeri true olduğunda kart bilgilerinin dolu olup olmadığını kontrol eder.

Son olarak, oluşturduğumuz @ValidCardInfo annotation'ını DTO üzerinde kullanabiliriz:

@ValidCardInfo

public class UserDto {

    private String username;

    private String password;

    private boolean saveCard;

    private String cardNumber;

    private String cardHolderName;

    private String expiryDate;

    // getter ve setter'lar

}

Bu örnekte, birden fazla alanın değerlerini karşılaştırmak için özelleştirilmiş bir annotation oluşturduk ve bu doğrulamanın bir alanın durumuna bağlı olarak tetiklendiğini belirttik. Bu, daha karmaşık bir durum için ileri düzey bir örnektir ve DTO'nun birden fazla alanının durumunu kontrol etmek gerektiğinde kullanışlıdır.

Spring servis sınıflarında dto validasyonları için arka arkaya validasyon ihtiyacında iterator ve chain of responsibility patternleri nasıl kullanılır? : https://www.turkninja.com/2023/07/spring-servis-snflarnda-dto.html

Spring servis sınıflarında dto validasyonları için arka arkaya validasyon ihtiyacında iterator ve chain of responsibility patternleri nasıl kullanılır?

Bir Spring servisinde DTO (Data Transfer Object) validasyonları için Iterator ve Chain of Responsibility (Sorumluluk Zinciri) tasarım kalıplarını nasıl kullanabileceğinizi açıklayacağım.

Öncelikle, Sorumluluk Zinciri tasarım kalıbı, birçok farklı durumda işlevsel olabilir ve belirli bir isteği veya bir dizi operasyonu uygulamanız gerektiğinde oldukça yararlıdır. Bu tasarım kalıbı, bir dizi nesnenin bir talebi veya operasyonu işleyebileceği bir yapı oluşturur.

İlk olarak, DTO'larımız için bir Validator arayüzü oluşturacağız. Bu arayüz, validasyonu gerçekleştirecek olan validate() metodunu tanımlar.

public interface Validator {

    ValidationResult validate(DTO dto);

}

Burada ValidationResult her validasyon işleminden sonra bir sonuç döndüreceğiz.

Sonraki adımda, validatörleri bir listede saklayan ve bir sonraki validatörü belirleyen bir ValidatorChain sınıfı oluşturuyoruz:

public class ValidatorChain implements Validator {

    private Iterator<Validator> validators;

    public ValidatorChain(List<Validator> validators) {

        this.validators = validators.iterator();

    }

    @Override

    public ValidationResult validate(DTO dto) {

        if (validators.hasNext()) {

            return validators.next().validate(dto);

        } else {

            return new ValidationResult(true, "Validation successful");

        }

    }

}

Bu noktada, belirli bir DTO için validasyon gereksinimlerini karşılayacak çeşitli Validator sınıfları oluşturabiliriz. Bu sınıflar Validator arayüzünü uygulamalı ve validate() metodunu belirli bir validasyon kuralına göre uygulamalıdır.

java

Copy code

public class LengthValidator implements Validator {

    @Override

    public ValidationResult validate(DTO dto) {

        // implementation of validation logic

    }

}

public class FormatValidator implements Validator {

    @Override

    public ValidationResult validate(DTO dto) {

        // implementation of validation logic

    }

}

// You can add more validators as per your requirements

Son olarak, Spring servis sınıfınızda, gerektiği gibi validatör zincirini oluşturabilir ve DTO'yu ona doğrulatabilirsiniz:

@Service

public class YourService {

    public void yourMethod(DTO dto) {

        List<Validator> validators = Arrays.asList(new LengthValidator(), new FormatValidator());

        ValidatorChain validatorChain = new ValidatorChain(validators);

        ValidationResult result = validatorChain.validate(dto);

        if (!result.isSuccess()) {

            throw new ValidationException(result.getMessage());

        }

        // continue your logic

    }

}

Bu şekilde, istediğiniz kadar validatör ekleyebilir ve belirli bir DTO'yu validate etmek için aynı diziyi kullanabilirsiniz. Bir validasyon başarısız olursa, döngü orada duracak ve bir hata mesajı dönecektir. Ayrıca her validatörün kendi validasyon mantığını uyguladığından emin olun. Bu, validasyon işlemlerinin kolayca genişletilmesine olanak sağlar.

Spring'de DTO'larda custom validation annotationlar nasıl gerçekleştirilir? İleri düzey Java kod örnekleriyle beraber : https://www.turkninja.com/2023/07/springde-dtolarda-custom-validation.html