Support ConstraintValidator#initialize

[pfichtner]

public class IbanValidator implements ConstraintValidator<IbanOfType, String> {

	private Pattern pattern;

	@Override
	public void initialize(IbanOfType type) {
		pattern = Pattern.compile(getPattern(type.value()));
	}

	private String getPattern(IbanOfType.Type type) {
		return switch (type) {
		// "IBAN muss eine deutsche IBAN (DE + 20 Ziffern) sein"
		case GERMAN -> "^DE\\d{20}$";
		// "IBAN muss eine valide IBAN sein"
		case INTERNATIONAL -> "^[A-Z]{2}\\d{2}[A-Z0-9]{11,30}$";
		};
	}

	@Override
	public boolean isValid(String value, ConstraintValidatorContext context) {
		return pattern.matcher(value).matches();
	}

}

[pfichtner]

• Introduces state
• Validation frameworks create one instance per annotation (IbanOfType) values
• vaadoo could hold a map (key: annotation values, value: ConstraintValidator instance) like we do for regexps

[pfichtner]

✦ To support ConstraintValidator#initialize without creating additional class files (keeping the output 1:1 with the input), you can leverage the JDK's
dynamic proxy mechanism combined with INVOKEDYNAMIC to implement the InvocationHandler entirely within the existing class's bytecode.

Here is a suggestion for a "self-contained" initialization strategy:

1. Static Validator Cache
   Instead of instantiating the validator on every method call, weave a private static final field for each validator instance into the class being
   transformed. This allows you to perform the initialization once during class loading.

2. Weave Initialization into
   In the static initializer of the class, weave the following logic:

3. Instantiate the validator: new MyValidator().

4. Create the Annotation Proxy: Use java.lang.reflect.Proxy.newProxyInstance.

5. Implement InvocationHandler via INVOKEDYNAMIC:

   • To avoid a separate .class file for the handler, use LambdaMetafactory to create an InvocationHandler on the fly.
   • This handler will point to a private static method (which you also weave into the class) that returns the constant values of the annotation known at
     compile-time.

6. Call initialize(proxy) on the validator instance.

7. Store the initialized validator in the static field.

8. The "Handler" Static Method
   You weave a private static method with a signature like Object accessAnno(String methodName) into the target class.

1 // Conceptually, the weaved method looks like this:
2 private static Object _$vaadoo_anno_1(String name) {
3 if ("value".equals(name)) return 5; // The value from the annotation
4 if ("message".equals(name)) return "Invalid length";
5 return null; // Or default value
6 }

4. Bytecode Hook
   The transformation in CustomAnnotations.java would change its strategy:

• Before: It weaved NEW, DUP, INVOKESPECIAL , then isValid.
• After:
  1. Check if initialized is needed: If the validator overrides initialize, it uses the static field approach.
  2. Usage Site: Weave a GETSTATIC to load the pre-initialized validator from the field, then call isValid.

Why this works with your constraints:

• No Additional Classes: INVOKEDYNAMIC allows the JVM to create the necessary "glue" class at runtime in memory, avoiding any new .class files in your
  project's distribution.
• Performance: The validator and its proxy are created only once. Subsequent validation calls only perform a GETSTATIC and the isValid call.
• Compatibility: It fully satisfies the ConstraintValidator lifecycle as defined by JSR 380.

Alternative: Field Inlining (Advanced)
If you truly want to "directly weave" the logic (inline it), you would need to:

1. Analyze the validator's bytecode to see which fields are assigned in initialize.
2. When inlining isValid, replace all GETFIELD instructions for those fields with the LDC constants from the annotation.
3. Note: This is much harder to implement as it requires a deep analysis of the validator's implementation.

Recommendation: The Static Field + Proxy via INVOKEDYNAMIC approach is the most robust and matches the existing architecture of vaadoo while respecting the
"no extra classes" constraint.