// 一個(gè)對(duì)象工廠
public interface ObjectFactory<T> {

    // 返回一個(gè)對(duì)象
    T getObject() throws BeansException;

}

public interface FactoryBean<T> {

	@Nullable
	T getObject() throws Exception;

	@Nullable
	Class<?> getObjectType();

	default boolean isSingleton() {
		return true;
	}

}

Object get(String name, ObjectFactory<?> objectFactory);

void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);

beanFactory.registerResolvableDependency(ServletRequest.class, new RequestObjectFactory());
beanFactory.registerResolvableDependency(ServletResponse.class, new ResponseObjectFactory());
beanFactory.registerResolvableDependency(HttpSession.class, new SessionObjectFactory());
beanFactory.registerResolvableDependency(WebRequest.class, new WebRequestObjectFactory());

private static class RequestObjectFactory implements ObjectFactory<ServletRequest>, Serializable {

    @Override
    // 是從當(dāng)前線程中獲取的
    public ServletRequest getObject() {
        return currentRequestAttributes().getRequest();
    }

    @Override
    public String toString() {
        return "Current HttpServletRequest";
    }
}

@RestController
public class AutowiredRequestController {
 
    @Autowired
    private HttpServletRequest request;
}

// 1.可以看到ObjectProvider本身繼承了ObjectFactory接口，所以它本身就是一個(gè)ObjectFactory
// 2.從5.1之后，這個(gè)接口還多繼承了一個(gè)Iterable接口，意味著能對(duì)它進(jìn)行迭代以及流式操作
public interface ObjectProvider<T> extends ObjectFactory<T>, Iterable<T> {

	// 返回用指定參數(shù)創(chuàng)建的bean, 如果容器中不存在, 拋出異常
	T getObject(Object... args) throws BeansException;

	// 如果指定類型的bean注冊(cè)到容器中, 返回 bean 實(shí)例, 否則返回 null
	@Nullable
	T getIfAvailable() throws BeansException;

	// 如果返回對(duì)象不存在，則用傳入的Supplier獲取一個(gè)Bean并返回，否則直接返回存在的對(duì)象
	default T getIfAvailable(Supplier<T> defaultSupplier) throws BeansException {
		T dependency = getIfAvailable();
		return (dependency != null ? dependency : defaultSupplier.get());
	}

	 // 消費(fèi)對(duì)象的一個(gè)實(shí)例（可能是共享的或獨(dú)立的），如果存在通過Consumer回調(diào)消耗目標(biāo)對(duì)象。
     // 如果不存在則直接返回
	default void ifAvailable(Consumer<T> dependencyConsumer) throws BeansException {
		T dependency = getIfAvailable();
		if (dependency != null) {
			dependencyConsumer.accept(dependency);
		}
	}

	// 如果不可用或不唯一（沒有指定primary）則返回null。否則，返回對(duì)象。
	@Nullable
	T getIfUnique() throws BeansException;

	// 如果不存在唯一對(duì)象，則調(diào)用Supplier的回調(diào)函數(shù)
	default T getIfUnique(Supplier<T> defaultSupplier) throws BeansException {
		T dependency = getIfUnique();
		return (dependency != null ? dependency : defaultSupplier.get());
	}

	// 如果存在唯一對(duì)象，則消耗掉該對(duì)象
	default void ifUnique(Consumer<T> dependencyConsumer) throws BeansException {
		T dependency = getIfUnique();
		if (dependency != null) {
			dependencyConsumer.accept(dependency);
		}
	}

	// 返回符合條件的對(duì)象的Iterator，沒有特殊順序保證（一般為注冊(cè)順序）
	@Override
	default Iterator<T> iterator() {
		return stream().iterator();
	}

	// 返回符合條件對(duì)象的連續(xù)的Stream，沒有特殊順序保證（一般為注冊(cè)順序）
	default Stream<T> stream() {
		throw new UnsupportedOperationException("Multi element access not supported");
	}

	// 返回符合條件對(duì)象的連續(xù)的Stream。在標(biāo)注Spring應(yīng)用上下文中采用@Order注解或?qū)崿F(xiàn)Order接口的順序
	default Stream<T> orderedStream() {
		throw new UnsupportedOperationException("Ordered element access not supported");
	}
}

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

@Override
public Object resolveDependency(DependencyDescriptor descriptor, String requestingBeanName, Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
	// descriptor代表當(dāng)前需要注入的那個(gè)字段，或者方法的參數(shù)，也就是注入點(diǎn)
    // ParameterNameDiscovery用于解析方法參數(shù)名稱
    descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
    // 1. Optional<T>
    if (Optional.class == descriptor.getDependencyType()) {
        return createOptionalDependency(descriptor, requestingBeanName);
    // 2. ObjectFactory<T>、ObjectProvider<T>
    } else if (ObjectFactory.class == descriptor.getDependencyType() ||
             ObjectProvider.class == descriptor.getDependencyType()) {
        return new DependencyObjectProvider(descriptor, requestingBeanName);
    // 3. javax.inject.Provider<T>
    } else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
        return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
    } else {
        // 4. @Lazy
        Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
            descriptor, requestingBeanName);
        // 5. 正常情況
        if (result == null) {
            result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
        }
        return result;
    }
}

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;
            }
        };
        // 最終還是會(huì)調(diào)用這個(gè)方法解決依賴
        return doResolveDependency(descriptorToUse, this.beanName, null, null);
    }
}

@Component
public class IndexService {

	B b;

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

@Component
public class IndexService {

	B b;

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