io microsphere spring beans factory AbstractInjectionPointDependencyResolver

AbstractInjectionPointDependencyResolver

Type: Class | Module: microsphere-spring-context | Package: io.microsphere.spring.beans.factory | Since: 1.0.0

Source: microsphere-spring-context/src/main/java/io/microsphere/spring/beans/factory/AbstractInjectionPointDependencyResolver.java

Overview

Abstract base class for implementing InjectionPointDependencyResolver.

This class provides a foundation for resolving dependencies at injection points within Spring-managed beans. It handles common tasks such as bean factory awareness, dependency type resolution, and logging using the Logger interface.

Key Responsibilities

- Tracking and resolving dependencies based on injection points (fields, methods, constructors).
- Filtering resolvable dependency types via the configured `ResolvableDependencyTypeFilter`.
- Providing consistent logging capabilities through the injected logger.
- Supporting custom resolution logic by allowing subclasses to implement specific strategies.

Example Usage

Basic Implementation

`public class MyDependencyResolver extends AbstractInjectionPointDependencyResolver {
    // Custom implementation details here
`
}

Resolving Dependencies from a Field

`public void resolve(Field field, ConfigurableListableBeanFactory beanFactory, Set dependentBeanNames) {
    String dependentBeanName = resolveDependentBeanNameByName(field, beanFactory);
    if (dependentBeanName == null) {
        resolveDependentBeanNamesByType(field::getGenericType, beanFactory, dependentBeanNames);
    ` else {
        dependentBeanNames.add(dependentBeanName);
    }
}
}

Resolving Dependencies from a Method Parameter

`public void resolve(Parameter parameter, ConfigurableListableBeanFactory beanFactory, Set dependentBeanNames) {
    String dependentBeanName = resolveDependentBeanNameByName(parameter, beanFactory);
    if (dependentBeanName == null) {
        resolveDependentBeanNamesByType(parameter::getParameterizedType, beanFactory, dependentBeanNames);
    ` else {
        dependentBeanNames.add(dependentBeanName);
    }
}
}

Declaration

public abstract class AbstractInjectionPointDependencyResolver implements InjectionPointDependencyResolver, BeanFactoryAware

Author: Mercy

Version Information

• Introduced in: 1.0.0
• Current Project Version: 0.2.27-SNAPSHOT

Version Compatibility

This component is tested and compatible with the following Java versions:

Java Version	Status
Java 17	✅ Compatible
Java 21	✅ Compatible
Java 25	✅ Compatible

Examples

Example 1

public class MyDependencyResolver extends AbstractInjectionPointDependencyResolver {
    // Custom implementation details here
}

Example 2

public void resolve(Field field, ConfigurableListableBeanFactory beanFactory, Set<String> dependentBeanNames) {
    String dependentBeanName = resolveDependentBeanNameByName(field, beanFactory);
    if (dependentBeanName == null) {
        resolveDependentBeanNamesByType(field::getGenericType, beanFactory, dependentBeanNames);
    } else {
        dependentBeanNames.add(dependentBeanName);
    }
}

Example 3

public void resolve(Parameter parameter, ConfigurableListableBeanFactory beanFactory, Set<String> dependentBeanNames) {
    String dependentBeanName = resolveDependentBeanNameByName(parameter, beanFactory);
    if (dependentBeanName == null) {
        resolveDependentBeanNamesByType(parameter::getParameterizedType, beanFactory, dependentBeanNames);
    } else {
        dependentBeanNames.add(dependentBeanName);
    }
}

Method Examples

resolve

AbstractInjectionPointDependencyResolver resolver = ...;
  resolver.setBeanFactory(beanFactory);
  Field field = ReflectionUtils.findField(MyConfig.class, "myDependency");
  Set<String> dependentBeanNames = new LinkedHashSet<>();
  resolver.resolve(field, beanFactory, dependentBeanNames);
  // dependentBeanNames now contains the bean names matching the field

resolve

AbstractInjectionPointDependencyResolver resolver = ...;
  resolver.setBeanFactory(beanFactory);
  Method method = MethodUtils.findMethod(MyConfig.class, "user", MyDependency[].class);
  Set<String> dependentBeanNames = new LinkedHashSet<>();
  resolver.resolve(method, beanFactory, dependentBeanNames);
  // dependentBeanNames now contains bean names matching the method parameters

resolve

AbstractInjectionPointDependencyResolver resolver = ...;
  resolver.setBeanFactory(beanFactory);
  Constructor<?> constructor = ConstructorUtils.findConstructor(MyConfig.class, Map.class);
  Set<String> dependentBeanNames = new LinkedHashSet<>();
  resolver.resolve(constructor, beanFactory, dependentBeanNames);
  // dependentBeanNames now contains bean names matching the constructor parameters

resolve

AbstractInjectionPointDependencyResolver resolver = ...;
  resolver.setBeanFactory(beanFactory);
  Method method = MethodUtils.findMethod(MyConfig.class, "user", MyDependency[].class);
  Parameter parameter = method.getParameters()[0];
  Set<String> dependentBeanNames = new LinkedHashSet<>();
  resolver.resolve(parameter, beanFactory, dependentBeanNames);
  // dependentBeanNames now contains bean names matching the parameter type

setBeanFactory

AbstractInjectionPointDependencyResolver resolver = new MyDependencyResolver();
  resolver.setBeanFactory(beanFactory);
  // resolver is now ready to resolve injection point dependencies

Usage

Maven Dependency

Add the following dependency to your pom.xml:

<dependency>
    <groupId>io.github.microsphere-projects</groupId>
    <artifactId>microsphere-spring-context</artifactId>
    <version>${microsphere-spring.version}</version>
</dependency>

Tip: Use the BOM (microsphere-spring-dependencies) for consistent version management. See the Getting Started guide.

Import

import io.microsphere.spring.beans.factory.AbstractInjectionPointDependencyResolver;

API Reference

Public Methods

Method	Description
resolve	Resolve the dependent bean names from the given Field injection point.
resolve	Resolve the dependent bean names from the given Method injection point.
resolve	Resolve the dependent bean names from the given Constructor injection point.
resolve	Resolve the dependent bean names from the given Parameter injection point.
setBeanFactory	Initialize this resolver by extracting the ResolvableDependencyTypeFilter

Method Details

resolve

public void resolve(Field field, ConfigurableListableBeanFactory beanFactory, Set<String> dependentBeanNames)

Resolve the dependent bean names from the given Field injection point.

First attempts to resolve by name using the AutowireCandidateResolver. If no name is suggested, falls back to resolving by the field's generic type.

Example Usage

`AbstractInjectionPointDependencyResolver resolver = ...;
  resolver.setBeanFactory(beanFactory);
  Field field = ReflectionUtils.findField(MyConfig.class, "myDependency");
  Set dependentBeanNames = new LinkedHashSet<>();
  resolver.resolve(field, beanFactory, dependentBeanNames);
  // dependentBeanNames now contains the bean names matching the field
`

resolve

public void resolve(Method method, ConfigurableListableBeanFactory beanFactory, Set<String> dependentBeanNames)

Resolve the dependent bean names from the given Method injection point.

Iterates over each parameter of the method and delegates resolution to #resolve(Parameter, ConfigurableListableBeanFactory, Set). Methods with no parameters are ignored.

Example Usage

`AbstractInjectionPointDependencyResolver resolver = ...;
  resolver.setBeanFactory(beanFactory);
  Method method = MethodUtils.findMethod(MyConfig.class, "user", MyDependency[].class);
  Set dependentBeanNames = new LinkedHashSet<>();
  resolver.resolve(method, beanFactory, dependentBeanNames);
  // dependentBeanNames now contains bean names matching the method parameters
`

resolve

public void resolve(Constructor constructor, ConfigurableListableBeanFactory beanFactory, Set<String> dependentBeanNames)

Resolve the dependent bean names from the given Constructor injection point.

Iterates over each parameter of the constructor and delegates resolution to #resolve(Parameter, ConfigurableListableBeanFactory, Set). Constructors with no parameters are ignored.

Example Usage

`AbstractInjectionPointDependencyResolver resolver = ...;
  resolver.setBeanFactory(beanFactory);
  Constructor constructor = ConstructorUtils.findConstructor(MyConfig.class, Map.class);
  Set dependentBeanNames = new LinkedHashSet<>();
  resolver.resolve(constructor, beanFactory, dependentBeanNames);
  // dependentBeanNames now contains bean names matching the constructor parameters
`

resolve

public void resolve(Parameter parameter, ConfigurableListableBeanFactory beanFactory, Set<String> dependentBeanNames)

Resolve the dependent bean names from the given Parameter injection point.

First attempts to resolve by name using the AutowireCandidateResolver. If no name is suggested, falls back to resolving by the parameter's parameterized type.

Example Usage

`AbstractInjectionPointDependencyResolver resolver = ...;
  resolver.setBeanFactory(beanFactory);
  Method method = MethodUtils.findMethod(MyConfig.class, "user", MyDependency[].class);
  Parameter parameter = method.getParameters()[0];
  Set dependentBeanNames = new LinkedHashSet<>();
  resolver.resolve(parameter, beanFactory, dependentBeanNames);
  // dependentBeanNames now contains bean names matching the parameter type
`

setBeanFactory

public void setBeanFactory(BeanFactory beanFactory)

Initialize this resolver by extracting the ResolvableDependencyTypeFilter and AutowireCandidateResolver from the given BeanFactory.

Example Usage

`AbstractInjectionPointDependencyResolver resolver = new MyDependencyResolver();
  resolver.setBeanFactory(beanFactory);
  // resolver is now ready to resolve injection point dependencies
`

---

This documentation was auto-generated from the source code of microsphere-spring.