anchor.diff:  
   * On a `BeanPostProcessor` bean, to replace its runtime behavior.
   For instance <<beans-factory-extension-bpp-examples-aabpp,`AutowiredAnnotationBeanPostProcessor`>> is implementing this interface to generate code that injects members annotated with `@Autowired`.
  -* On a type registered in `META-INF/aot/spring.factories` with a key matching the fully qualified name of the interface.
  +* On a type registered in `META-INF/spring/aot.factories` with a key equals to the fully qualified name of the interface.
   Typically used whe the bean definition needs to be tuned for specific features of the core framework.
   
   [NOTE]
  
positive.code: An AOT contribution is a component that contributes generated code that reproduce a particular behavior.
  It can also contribute `RuntimeHints` to indicate the need for reflection, resource loading, serialization, or JDK proxy.
  
  `BeanFactoryInitializationAotProcessor` implementation should be registered in `META-INF/aot/spring.factories` with a key matching the fully qualified name of the interface.
  
  It can also be implemented on a bean directly.
  In this mode, the bean provides an AOT contribution equivalent to the feature it provides with a regular runtime.
  
negative.code: There is a bean definition for "`dataSourceConfiguration`" bean and one for "`dataSourceBean`".
  When a `datasource` instance is required, a `BeanInstanceSupplier` is called.
  This supplier invokes the `dataSource()` method on the `dataSourceConfiguration` bean.
  
  
  [[aot-hints]]
  == Runtime Hints
  Running an application as a native image requires additional information compared to a regular JVM runtime.
  For instance, GraalVM needs to know ahead of time if a component uses reflection.
  Similarly, classpath resources are not shipped in a native image unless specified explicitly.
  If the application needs to load a resource, it needs to be referenced.
  
  The {api-spring-framework}/aot/hint/RuntimeHints.html[`RuntimeHints`] API collects the need for reflection, resource loading, serialization, and JDK proxy at runtime.
  The following example makes sure that `config/app.properties` can be loaded from the classpath at runtime:
  
  [source,java,indent=0]
  ----
  	runtimeHints.resources().registerPattern("config/app.properties");
  ----
  
  A number of contracts are handled automatically during AOT processing.
  For instance, the return type of a `@Controller` method is inspected, and relevant reflection hints are added if we detect that the type should be serialized (typically to JSON).
  
  For the cases that the core container cannot infer, you can register such hints programmatically.
  A number of convenient annotations are also provided for common use cases.
  
  
  [[aot-hints-import-runtime-hints]]
  === `@ImportRuntimeHints`
  `RuntimeHintsRegistrar` implementations allow you to get a callback to the `RuntimeHints` instance managed by the AOT engine.
  Implementations of this interface can be registered using `@ImportRuntimeHints` on any Spring bean, or on a `@Bean` factory method.
  `RuntimeHintsRegistrar` implementations are detected and invoked at build-time.
  
  [source,java,indent=0]
  ----
  	@Component
      @ImportRuntimeHints(MyComponentRuntimeHints.class)
      public class MyComponent {
  
  
  	    private static class MyComponentRuntimeHints implements RuntimeHintsRegistrar {
  
  			@Override
  	        public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
  
  	        }
  
  	    }
  	}
  ----
  
  If at all possible, `@ImportRuntimeHints` should be used as close as possible to the component that requires the hints.
  This way, if the component is not contributed to the `BeanFactory`, the hints won't either.
  
  It is also possible to register an implementation statically by adding an entry in `META-INF/spring/aot.factories` with a key equals to the fully qualified name of the `RuntimeHintsRegistrar` interface.
  
  
  [[aot-hints-reflective]]
  === `@Reflective`
  {api-spring-framework}/aot/hint/annotation/Reflective.html[`@Reflective`] provides an idiomatic way to flag the need for reflection on an annotated element.
  For instance, `@EventListener` is meta annotated with `@Reflective` as the underlying implementation invokes the annotated method using reflection.
  
  By default, only Spring beans are considered and an invocation hint is added on the annotated element.
  This can be tuned by specifying a different `ReflectiveProcessor` implementation.
  
  Library authors can reuse this annotation for their own use.
  If non-Spring beans need to be processed, a `BeanFactoryInitializationAotProcessor` can detect the relevant types and use `ReflectiveRuntimeHintsRegistrar` to process them.
  
  
  [[aot-hints-register-reflecting-for-binding]]
  === `@RegisterReflectionForBinding`
  {api-spring-framework}/aot/hint/annotation/RegisterReflectionForBinding.html[`@RegisterReflectionForBinding`] is a specialization of `@Reflective` to register the need for serializing arbitrary types.
  A typical use case is the use of DTOs that the container cannot infer, such as using a web client within a method body.
  
  `@RegisterReflectionForBinding` can be added on any Spring bean at class-level, but can also be specified on a method, field, or constructor to better indicate where the hints are actually required.
  The following example registers `Account` for serialization.
  
  [source,java,indent=0]
  ----
  	@Component
  	public class OrderService {
  
  	    @RegisterReflectionForBinding(Account.class)
  		public void process(Order order) {
  			...
  		}
  
  	}
  ----
  