Data Processor

// Anotação principal para marcar classes processáveis @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface DataProcessor { String value() default ""; String version() default "1.0"; ProcessingMode mode() default ProcessingMode.SYNC; public enum ProcessingMode { SYNC, ASYNC, BATCH } } // Anotação para validação de campos @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) public @interface Validate { String pattern() default ""; boolean required() default true; int minLength() default 0; int maxLength() default Integer.MAX_VALUE; String message() default ""; } // Anotação para transformação de dados @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) public @interface Transform { Class<? extends DataTransformer<?>> transformer(); String[] params() default {}; } // Anotação para persistência @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) public @interface Persist { String strategy() default "DEFAULT"; boolean async() default false; }

// Interface para transformadores de dados public interface DataTransformer<T> { T transform(T input, String... params); } // Interface para validadores public interface DataValidator { boolean validate(Object value, Validate annotation); String getErrorMessage(); } // Interface para persistência public interface DataPersister { void persist(Object data, Persist annotation); Object retrieve(String id, Class<?> type); }

// Processador principal public class DataProcessorEngine { private final Map<Class<?>, DataValidator> validators; private final Map<Class<?>, DataTransformer<?>> transformers; private final Map<String, DataPersister> persisters; public <T> ProcessingResult<T> process(T data) { Class<?> dataClass = data.getClass(); if (!dataClass.isAnnotationPresent(DataProcessor.class)) { throw new IllegalArgumentException("Class not annotated with @DataProcessor"); } ProcessingResult<T> result = new ProcessingResult<>(); // Validação validateFields(data, result); if (!result.isValid()) { return result; } // Transformação T transformed = transformFields(data); // Persistência persistFields(transformed); result.setProcessedData(transformed); return result; } private <T> void validateFields(T data, ProcessingResult<T> result) { // Implementação da validação } private <T> T transformFields(T data) { // Implementação da transformação } private <T> void persistFields(T data) { // Implementação da persistência } }

// Transformador de criptografia public class EncryptTransformer implements DataTransformer<String> { @Override public String transform(String input, String... params) { // Implementação da criptografia return encrypt(input, params[0]); // params[0] = chave de criptografia } private String encrypt(String data, String key) { // Lógica de criptografia return /* dados criptografados */; } } // Transformador de formatação de data public class DateFormatTransformer implements DataTransformer<Date> { @Override public Date transform(Date input, String... params) { String pattern = params[0]; // formato da data // Implementação da formatação return /* data formatada */; } }

@DataProcessor( value = "userProcessor", version = "1.0", mode = ProcessingMode.ASYNC ) public class UserData { @Validate( pattern = "^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,6}$", message = "Email inválido" ) private String email; @Transform(transformer = EncryptTransformer.class) @Validate(required = true, minLength = 8) private String password; @Transform( transformer = DateFormatTransformer.class, params = "yyyy-MM-dd" ) private Date birthDate; @Persist(strategy = "JDBC", async = true) private UserProfile profile; // Getters e Setters } // Uso do processador public class UserService { private final DataProcessorEngine processor; public void registerUser(UserData userData) { ProcessingResult<UserData> result = processor.process(userData); if (result.isValid()) { // Usuário processado com sucesso UserData processedData = result.getProcessedData(); // Continuar com o fluxo } else { // Tratar erros de validação List<String> errors = result.getErrors(); // Tratamento de erros } } }

@Validate(async = true, validator = EmailExistsValidator.class) private String email;

@DataProcessor( pipeline = { @Stage(type = VALIDATION, order = 1), @Stage(type = TRANSFORMATION, order = 2), @Stage(type = PERSISTENCE, order = 3) } )

@Transform({ @SingleTransform(transformer = TrimTransformer.class), @SingleTransform(transformer = LowerCaseTransformer.class), @SingleTransform(transformer = EncryptTransformer.class) }) private String data;