Spring中的ObjectProvider


在springboot的自动配置类中,看到了很多自动配置类使用ObjectProvider来使用。

为什么需要ObjectProvider

在Spring的使用过程中,我们可以通过多种形式将一个类注入到另外一个类当中,比如通过@Autowired和@Resources注解,而@Autowired又可以注解在不同的地方来达到注入的效果

注解在构造函数上

@Service
public class FooService {
    private final FooRepository repository;
    @Autowired
    public FooService(FooRepository repository) {
        this.repository = repository
    }
}

注解在属性上

@Service
public class FooService {
    @Autowired
    private final FooRepository repository;
}

注解在setter方法上

@Service
public class FooService {
    private final FooRepository repository;
    @Autowired
    public void setFooRepository(FooRepository repository) {
        this.repository = repository
    }
}

spring4.3新特性

上面是最常见的注入方式,如果忘记写@Autowired注解,那么在启动的时候就会抛出异常。但在spring 4.3之后,引入了一个新特性:当构造方法的参数为单个构造参数时,可以不使用@Autowired进行注解。因此,上面的代码可变为如下形式(亲测是可以的):

@Service
public class FooService {
    private final FooRepository repository;
    public FooService(FooRepository repository) {
        this.repository = repository
    }
}

使用此种形式便会显得优雅一些。该特性,在Spring Boot的自动配置类中大量被使用。

依赖关系的改进

同样是在Spring 4.3版本中,不仅隐式的注入了单构造参数的属性。还引入了ObjectProvider接口。

ObjectProvider接口是ObjectFactory接口的扩展,专门为注入点设计的,可以让注入变得更加宽松和更具有可选项。

public interface ObjectProvider<T> extends ObjectFactory<T>, Iterable<T> {
  .........
}

什么时候使用ObjectProvider接口?

如果待注入参数的Bean为空或有多个时,便是ObjectProvider发挥作用的时候了。

如果注入实例为空时,使用ObjectProvider则避免了强依赖导致的依赖对象不存在异常;

如果有多个实例,ObjectProvider的方法会根据Bean实现的Ordered接口或@Order注解指定的先后顺序获取一个Bean。从而了提供了一个更加宽松的依赖注入方式。

Spring 5.1之后提供了基于Stream的orderedStream方法来获取有序的Stream的方法。

使用ObjectProvider之后,上面的代码便变为如下方式:

@Service
public class FooService {
    private final FooRepository repository;
    public FooService(ObjectProvider<FooRepository> repositoryProvider) {
        this.repository = repositoryProvider.getIfUnique();
    }
}

或者这样也是一个不错的选择

@Service
public class FooService {
    private final FooRepository repository;
    public FooService(ObjectProvider<FooRepository> repositoryProvider) {
        this.repository = repositoryProvider.orderedStream().findFirst().orElse(null);
    }
}

这样的好处很显然,当容器中不存在FooRepository或存在多个时,可以从容处理。

但坏处也很明显,如果FooRepository不能为null,则可能将异常从启动阶段转移到业务运行阶段。

所以在使用的时候就可以来进行判断使用

ObjectProvider解决的问题

问题一

容器中没有Bean时,抛出Parameter 0 of constructor in com.example.demo.FooServicerequired a bean of type 'com.example.demo.FooRepository' that could not be found.。

解决方式:

@Component
public class IndexService {
    private B b;
    public IndexService(ObjectProvider<B> b) {
        this.b = b.getIfAvailable();
    }
}

但是上面这种解决方式的弊病也很明显,就是b可能为空,则可能将异常从启动阶段转移到业务运行阶段。

问题二

容器中存在多个Bean时,抛出No qualifying bean of type 'com.example.demo.FooRepository'' available: expected single matching bean but found 2

@Component
public class IndexService {
    private B b;
    public IndexService(ObjectProvider<B> b) {
        this.b = b.orderedStream().findFirst().orElse(null);
    }
}

当容器存在多个Bean,我们可以调用它的流式方法获取一个自己想要的依赖。

ObjectProvider的源码及解析

public interface ObjectProvider<T> extends ObjectFactory<T>, Iterable<T> {

  // 返回指定类型的bean, 如果容器中不存在, 抛出NoSuchBeanDefinitionException异常
  // 如果容器中有多个此类型的bean, 抛出NoUniqueBeanDefinitionException异常
  T getObject(Object... args) throws BeansException;

  // 如果指定类型的bean注册到容器中, 返回 bean 实例, 否则返回 null
  @Nullable
  T getIfAvailable() throws BeansException;

  // 如果返回对象不存在,则进行回调,回调对象由Supplier传入
  default T getIfAvailable(Supplier<T> defaultSupplier) throws BeansException {
    T dependency = getIfAvailable();
    return (dependency != null ? dependency : defaultSupplier.get());
  }

  // 消费对象的一个实例(可能是共享的或独立的),如果存在通过Consumer回调消耗目标对象。
  default void ifAvailable(Consumer<T> dependencyConsumer) throws BeansException {
    T dependency = getIfAvailable();
    if (dependency != null) {
      dependencyConsumer.accept(dependency);
    }
  }

  // 如果不可用或不唯一(没有指定primary)则返回null。否则,返回对象。
  @Nullable
  T getIfUnique() throws BeansException;

  // 如果存在唯一对象,则调用Supplier的回调函数
  default T getIfUnique(Supplier<T> defaultSupplier) throws BeansException {
    T dependency = getIfUnique();
    return (dependency != null ? dependency : defaultSupplier.get());
  }

  // 如果存在唯一对象,则消耗掉该对象
  default void ifUnique(Consumer<T> dependencyConsumer) throws BeansException {
    T dependency = getIfUnique();
    if (dependency != null) {
      dependencyConsumer.accept(dependency);
    }
  }

  // 返回符合条件的对象的Iterator,没有特殊顺序保证(一般为注册顺序)
  @Override
  default Iterator<T> iterator() {
    return stream().iterator();
  }

  // 返回符合条件对象的连续的Stream,没有特殊顺序保证(一般为注册顺序)
  default Stream<T> stream() {
    throw new UnsupportedOperationException("Multi element access not supported");
  }

  // 返回符合条件对象的连续的Stream。在标注Spring应用上下文中采用@Order注解或实现Order接口的顺序
  default Stream<T> orderedStream() {
    throw new UnsupportedOperationException("Ordered element access not supported");
  }
}

看下具体的实现类DependencyObjectProvider,看下实现类对应的实现细节:

public Object getIfAvailable() throws BeansException {
  // 用于解决嵌套的情况,像这种:ObjectProvider<Optional<T>>
  if (this.optional) {
    return createOptionalDependency(this.descriptor, this.beanName);
  }
  else {
    DependencyDescriptor descriptorToUse = new DependencyDescriptor(this.descriptor) {
      @Override
      public boolean isRequired() {
        return false;
      }
    };
    // 最终还是会调用这个方法解决依赖
    return doResolveDependency(descriptorToUse, this.beanName, null, null);
  }
}

从上面的过程中我们可以看出,但Spring中某个Bean的依赖类型为ObjectProvider时,我们不需要提供一个ObjectProvider类型的Bean到容器中,只需要提供一个T类型的Bean到容器中,容器会自动将其包装成一个ObjectProvider,然后注入到依赖中。

而基于ObjectProvider的一系列方法,我们就能解决之前提到的问题。

参考:https://blog.csdn.net/asdfsadfasdfsa/article/details/114219540

posted @ 2022-09-20 14:57  雩娄的木子  阅读(409)  评论(0编辑  收藏  举报