Adds Spring Starter (#200)

* adds spring starter

* Update module-info.java

* Update pom.xml

* Update pom.xml

* add inject plugin directly to main validator

* add named annotation  to generated method validators

Spring doesn't actually respect @singleton

* working

Author: SentryMan

pom.xml

@@ -37,6 +37,7 @@
     <module>validator-generator</module>
     <module>validator-http-plugin</module>
     <module>validator-inject-plugin</module>
+    <module>validator-spring-starter</module>
   </modules>
 
   <profiles>

validator-generator/src/main/java/io/avaje/validation/generator/SimpleParamBeanWriter.java

@@ -64,10 +64,10 @@ private void writeClassStart() {
     writer
         .append(
             """
-    		@Generated
-    		@%s
-    		public final class %s implements MethodAdapterProvider {
-    		""",
+                @Generated("avaje-validator-generator")
+                @Named
+                @%s
+                public final class %s implements MethodAdapterProvider {""",
             Util.shortName(diAnnotation()), adapterShortName)
         .eol();
   }

validator-generator/src/main/java/io/avaje/validation/generator/ValidMethodReader.java

@@ -25,14 +25,16 @@ final class ValidMethodReader {
     this.params = element.getParameters();
     importTypes.add(type);
     importTypes.add("java.util.List");
-    importTypes.add(diAnnotation());
     importTypes.add("java.util.Set");
     importTypes.add("java.util.Map");
     importTypes.add("io.avaje.validation.adapter.MethodAdapterProvider");
     importTypes.add("io.avaje.validation.adapter.ValidationAdapter");
     importTypes.add("io.avaje.validation.adapter.ValidationContext");
     importTypes.add("io.avaje.validation.spi.Generated");
     importTypes.add("java.lang.reflect.Method");
+    final var diAnnotation = diAnnotation();
+    importTypes.add(diAnnotation);
+    importTypes.add(diAnnotation.contains("javax") ? "javax.inject.Named" : "jakarta.inject.Named");
     paramAnnotations = params.stream().map(ElementAnnotationContainer::create).toList();
     returnElementAnnotation = ElementAnnotationContainer.create(element);
   }

validator-generator/src/main/java/io/avaje/validation/generator/ValidationProcessor.java

@@ -269,7 +269,7 @@ private boolean isController(TypeElement typeElement) {
   private void writeAdapterForConstraint(TypeElement typeElement) {
     if (ElementFilter.methodsIn(typeElement.getEnclosedElements()).stream()
         .noneMatch(m -> "message".equals(m.getSimpleName().toString()))) {
-      logError(typeElement, "Constraint annotations must contain a message method");
+      logError(typeElement, "Constraint annotations must contain a `String message()` method");
     }
     final ContraintReader beanReader = new ContraintReader(typeElement);
     writeAdapter(typeElement, beanReader);

validator-http-plugin/pom.xml

@@ -15,7 +15,7 @@
     <dependency>
       <groupId>io.avaje</groupId>
       <artifactId>avaje-validator</artifactId>
-      <version>1.2</version>
+      <version>1.4</version>
       <scope>provided</scope>
       <optional>true</optional>
     </dependency>

validator-inject-plugin/pom.xml

@@ -15,7 +15,7 @@
     <dependency>
       <groupId>io.avaje</groupId>
       <artifactId>avaje-validator</artifactId>
-      <version>1.0-RC3</version>
+      <version>1.4</version>
       <scope>provided</scope>
       <optional>true</optional>
     </dependency>

validator-inject-plugin/src/main/java/io/avaje/validation/inject/aspect/AOPMethodValidator.java

@@ -30,12 +30,7 @@ public void post(ValidationContext ctx, Map<Method, MethodAdapterProvider> map)
   public MethodInterceptor interceptor(Method method, ValidMethod aspectAnnotation) {
 
     final var localeStr = aspectAnnotation.locale();
-    final Locale locale;
-    if (localeStr.isBlank()) {
-      locale = null;
-    } else {
-      locale = Locale.forLanguageTag(localeStr);
-    }
+    final Locale locale = localeStr.isBlank() ? null : Locale.forLanguageTag(localeStr);
     final var interceptor =
         new ParamInterceptor(locale, method, aspectAnnotation.throwOnParamFailure());
     consumers.add(interceptor::postConstruct);

validator-inject-plugin/src/main/java/module-info.java

@@ -1,7 +1,5 @@
 module io.avaje.validation.plugin {
 
-  exports io.avaje.validation.inject.aspect;
-
   requires transitive io.avaje.validation;
   requires transitive io.avaje.inject;
 

validator-spring-starter/pom.xml

@@ -0,0 +1,76 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>io.avaje</groupId>
+    <artifactId>avaje-validator-parent</artifactId>
+    <version>1.5-SNAPSHOT</version>
+  </parent>
+  <artifactId>avaje-validator-spring-starter</artifactId>
+
+  <dependencyManagement>
+    <dependencies>
+      <dependency>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-dependencies</artifactId>
+        <version>3.3.0</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
+    </dependencies>
+  </dependencyManagement>
+
+  <dependencies>
+    <dependency>
+      <groupId>io.avaje</groupId>
+      <artifactId>avaje-validator</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+
+    <dependency>
+      <groupId>jakarta.inject</groupId>
+      <artifactId>jakarta.inject-api</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-aop</artifactId>
+      <exclusions>
+        <exclusion>
+          <groupId>org.springframework.boot</groupId>
+          <artifactId>spring-boot-starter-logging</artifactId>
+        </exclusion>
+        <exclusion>
+          <groupId>org.yaml</groupId>
+          <artifactId>snakeyaml</artifactId>
+        </exclusion>
+        <exclusion>
+          <groupId>io.micrometer</groupId>
+          <artifactId>micrometer-observation</artifactId>
+        </exclusion>
+        <exclusion>
+          <groupId>org.springframework</groupId>
+          <artifactId>spring-core</artifactId>
+        </exclusion>
+        <exclusion>
+          <groupId>jakarta.annotation</groupId>
+          <artifactId>jakarta.annotation-api</artifactId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+
+    <dependency>
+      <groupId>io.avaje</groupId>
+      <artifactId>avaje-validator-constraints</artifactId>
+      <version>${project.version}</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-test</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+</project>

validator-spring-starter/src/main/java/io/avaje/validation/spring/aspect/MethodValidationAutoConfiguration.java

@@ -0,0 +1,22 @@
+package io.avaje.validation.spring.aspect;
+
+import java.util.List;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.EnableAspectJAutoProxy;
+
+import io.avaje.validation.Validator;
+import io.avaje.validation.adapter.MethodAdapterProvider;
+
+@Configuration
+@EnableAspectJAutoProxy
+public class MethodValidationAutoConfiguration {
+
+  @Bean
+  public SpringAOPMethodValidator methodValidator(
+      Validator validator, List<MethodAdapterProvider> providers) throws Exception {
+    return new SpringAOPMethodValidator(validator, providers);
+  }
+}

validator-spring-starter/src/main/java/io/avaje/validation/spring/aspect/ParamInterceptor.java

@@ -0,0 +1,52 @@
+package io.avaje.validation.spring.aspect;
+
+import java.util.List;
+import java.util.Locale;
+
+import org.aspectj.lang.ProceedingJoinPoint;
+
+import io.avaje.validation.adapter.ValidationAdapter;
+import io.avaje.validation.adapter.ValidationContext;
+
+final class ParamInterceptor {
+
+  private final Locale locale;
+  private final boolean throwOnParamFailure;
+  private final List<ValidationAdapter<Object>> paramValidationAdapter;
+  private final ValidationAdapter<Object> returnValidationAdapter;
+  private final ValidationContext ctx;
+  private final ValidationAdapter<Object[]> crossParamAdapter;
+
+  public ParamInterceptor(
+      Locale locale,
+      boolean throwOnParamFailure,
+      ValidationContext ctx,
+      List<ValidationAdapter<Object>> paramValidationAdapter,
+      ValidationAdapter<Object> returnValidationAdapter,
+      ValidationAdapter<Object[]> crossParamAdapter) {
+    this.locale = locale;
+    this.throwOnParamFailure = throwOnParamFailure;
+    this.paramValidationAdapter = paramValidationAdapter;
+    this.returnValidationAdapter = returnValidationAdapter;
+    this.ctx = ctx;
+    this.crossParamAdapter = crossParamAdapter;
+  }
+
+  public void invoke(ProceedingJoinPoint invocation) throws Throwable {
+
+    final var args = invocation.getArgs();
+    final var req = ctx.request(locale, List.of());
+    var i = 0;
+    for (final var adapter : paramValidationAdapter) {
+      final Object object = args[i];
+      adapter.validate(object, req);
+      ++i;
+    }
+    crossParamAdapter.validate(args, req);
+    if (throwOnParamFailure) {
+      req.throwWithViolations();
+    }
+    returnValidationAdapter.validate(invocation.proceed(), req);
+    req.throwWithViolations();
+  }
+}

validator-spring-starter/src/main/java/io/avaje/validation/spring/aspect/SpringAOPMethodValidator.java

@@ -0,0 +1,54 @@
+package io.avaje.validation.spring.aspect;
+
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.reflect.MethodSignature;
+
+import io.avaje.validation.ValidMethod;
+import io.avaje.validation.Validator;
+import io.avaje.validation.adapter.MethodAdapterProvider;
+
+@Aspect
+public class SpringAOPMethodValidator {
+
+  private final Map<Method, ParamInterceptor> interceptorMap = new HashMap<>();
+
+  public SpringAOPMethodValidator(Validator validator, List<MethodAdapterProvider> providers)
+      throws Exception {
+    var ctx = validator.context();
+    for (var provider : providers) {
+
+      var method = provider.method();
+      ValidMethod validMethod = method.getAnnotation(ValidMethod.class);
+      final var localeStr = validMethod.locale();
+      final Locale locale = localeStr.isBlank() ? null : Locale.forLanguageTag(localeStr);
+      var paramValidationAdapter = provider.paramAdapters(ctx);
+      var returnValidationAdapter = provider.returnAdapter(ctx);
+      var crossParamAdapter = provider.crossParamAdapter(ctx);
+
+      interceptorMap.put(
+          method,
+          new ParamInterceptor(
+              locale,
+              validMethod.throwOnParamFailure(),
+              ctx,
+              paramValidationAdapter,
+              returnValidationAdapter,
+              crossParamAdapter));
+    }
+  }
+
+  @Around("@annotation(io.avaje.validation.ValidMethod)")
+  public void interceptor(ProceedingJoinPoint joinPoint) throws Throwable {
+    MethodSignature signature = (MethodSignature) joinPoint.getSignature();
+    var methodValidator = interceptorMap.get(signature.getMethod());
+    methodValidator.invoke(joinPoint);
+  }
+}

validator-spring-starter/src/main/java/io/avaje/validation/spring/validator/AvajeValidatorAutoConfiguration.java

@@ -0,0 +1,48 @@
+package io.avaje.validation.spring.validator;
+
+import java.time.Duration;
+import java.time.temporal.ChronoUnit;
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.Optional;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import io.avaje.validation.Validator;
+
+/** Autoconfiguration of Avaje Validator. */
+@Configuration
+public class AvajeValidatorAutoConfiguration {
+
+  @Bean
+  @ConditionalOnMissingBean
+  Validator validator(
+      @Value("${validation.failFast:false}") boolean failFast,
+      @Value("${validation.resourcebundle.names:#{null}}") Optional<String> resourceBundleNames,
+      @Value("${validation.locale.default:#{null}}") Optional<String> defaultLocal,
+      @Value("${validation.locale.addedLocales:#{null}}") Optional<String> addedLocales,
+      @Value("${validation.temporal.tolerance.value:#{null}}") Optional<String> temporalTolerance,
+      @Value("${validation.temporal.tolerance.chronoUnit:MILLIS}") ChronoUnit chronoUnit) {
+    final var validator = Validator.builder().failFast(failFast);
+
+    resourceBundleNames.map(s -> s.split(",")).ifPresent(validator::addResourceBundles);
+    defaultLocal.map(Locale::forLanguageTag).ifPresent(validator::setDefaultLocale);
+
+    addedLocales.stream()
+        .flatMap(s -> Arrays.stream(s.split(",")))
+        .map(Locale::forLanguageTag)
+        .forEach(validator::addLocales);
+
+    temporalTolerance
+        .map(Long::valueOf)
+        .ifPresent(
+            duration -> {
+              final var unit = chronoUnit;
+              validator.temporalTolerance(Duration.of(duration, unit));
+            });
+    return validator.build();
+  }
+}

validator-spring-starter/src/main/java/module-info.java

@@ -0,0 +1,13 @@
+module io.avaje.validation.spring {
+
+  exports io.avaje.validation.spring.aspect;
+  exports io.avaje.validation.spring.validator;
+
+  requires transitive io.avaje.validation;
+  requires transitive jakarta.inject;
+  requires transitive org.aspectj.weaver;
+  requires transitive spring.beans;
+  requires transitive spring.context;
+  requires transitive spring.boot.autoconfigure;
+
+}

validator-spring-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

@@ -0,0 +1,2 @@
+io.avaje.validation.spring.validator.AvajeValidatorAutoConfiguration
+io.avaje.validation.spring.aspect.MethodValidationAutoConfiguration