@Service

public class LoginServiceImpl implements LoginService {

//    @Resource

    private UserService userService;

    public LoginServiceImpl() {

        // 无参构造器是给默认创建的bean使用的

    }

    @Autowired

    public LoginServiceImpl(UserService userService) {

        this.userService = userService;

    }

    public void setUserService(UserService userService) {

        this.userService = userService;

    }

    public Integer login(UserInfo userInfo) {

        System.out.println("login...");

        return 0;

    }

    public void logAction(String userId, String action) throws Exception {

        UserInfo userInfo = userService.getUser(userId);

        System.out.println("logged..." + userInfo + ",action: " + action);

    }

}

@Service

public class UserServiceImpl implements UserService {

//    @Resource

    private LoginService loginService;

    public UserServiceImpl() {

        // 无参构造器是给默认创建的bean使用的

    }

//    @Autowired

    public UserServiceImpl(LoginService loginService) {

        this.loginService = loginService;

    }

    @Autowired

    public void setLoginService(LoginService loginService) {

        this.loginService = loginService;

    }

    public Integer addUser(UserInfo userInfo) throws Exception {

        userInfo.setId("111");

        System.out.println("user added. " + userInfo);

        // 登录

        loginService.login(userInfo);

        return 1;

    }

    public UserInfo getUser(String id) throws Exception {

        UserInfo userInfo = null;

        if("111".equals(id)) {

            userInfo = new UserInfo();

            userInfo.setId(id);

            userInfo.setAge(22);

            userInfo.setName("mocking");

            return userInfo;

        }

        throw new Exception("err:" + ErrorCodeEnum.API_CALL_ERROR.getCode() + "," + ErrorCodeEnum.API_CALL_ERROR.getErrMsg());

    }

}

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations = {"classpath:applicationContext.xml"})

public class UserServiceTest {

    @Resource

    private UserService userService;

    @Test

    public void testAddUserForLoopDI() throws Exception {

        UserInfo userInfo = new UserInfo();

        userInfo.setId("12");

        userInfo.setAddress("sdfds");

        userService.addUser(userInfo);

        System.out.println("ok");

    }

}

    <context:annotation-config/>

    <context:component-scan base-package="com.xx"></context:component-scan>

    // 只有单例的创建会存在循环依赖问题

    // org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

    /** Set of registered singletons, containing the bean names in registration order */

    private final Set<String> registeredSingletons = new LinkedHashSet<String>(256);

    /** Names of beans that are currently in creation */

    private final Set<String> singletonsCurrentlyInCreation =

            Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));

    /** Names of beans currently excluded from in creation checks */

    private final Set<String> inCreationCheckExclusions =

            Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));

    protected void beforeSingletonCreation(String beanName) {

        if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {

            throw new BeanCurrentlyInCreationException(beanName);

        }

    }
    

    public void setCurrentlyInCreation(String beanName, boolean inCreation) {

        Assert.notNull(beanName, "Bean name must not be null");

        if (!inCreation) {

            this.inCreationCheckExclusions.add(beanName);

        }

        else {

            this.inCreationCheckExclusions.remove(beanName);

        }

    }
    

    // org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean()

    /**

     * Actually create the specified bean. Pre-creation processing has already happened

     * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.

     * <p>Differentiates between default bean instantiation, use of a

     * factory method, and autowiring a constructor.

     * @param beanName the name of the bean

     * @param mbd the merged bean definition for the bean

     * @param args explicit arguments to use for constructor or factory method invocation

     * @return a new instance of the bean

     * @throws BeanCreationException if the bean could not be created

     * @see #instantiateBean

     * @see #instantiateUsingFactoryMethod

     * @see #autowireConstructor

     */

    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)

            throws BeanCreationException {

        // 第一步，创建bean实例

        // Instantiate the bean.

        BeanWrapper instanceWrapper = null;

        if (mbd.isSingleton()) {

            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);

        }

        if (instanceWrapper == null) {

            instanceWrapper = createBeanInstance(beanName, mbd, args);

        }

        final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);

        Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);

        mbd.resolvedTargetType = beanType;

        // Allow post-processors to modify the merged bean definition.

        synchronized (mbd.postProcessingLock) {

            if (!mbd.postProcessed) {

                try {

                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

                }

                catch (Throwable ex) {

                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,

                            "Post-processing of merged bean definition failed", ex);

                }

                mbd.postProcessed = true;

            }

        }

        // 对于提前暴露的bean, 将它加入单例缓存中，从而使后续的依赖调用时，可以将此实例返回

        // Eagerly cache singletons to be able to resolve circular references

        // even when triggered by lifecycle interfaces like BeanFactoryAware.

        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&

                isSingletonCurrentlyInCreation(beanName));

        if (earlySingletonExposure) {

            if (logger.isDebugEnabled()) {

                logger.debug("Eagerly caching bean '" + beanName +

                        "' to allow for resolving potential circular references");

            }

            // 针对提前暴露的 singleton, 添加一个 获取实例 工厂，以备后续获取实例时使用

            addSingletonFactory(beanName, new ObjectFactory<Object>() {

                @Override

                public Object getObject() throws BeansException {

                    return getEarlyBeanReference(beanName, mbd, bean);

                }

            });

        }

        // 第二步，初始化实例，完成依赖注入等工作

        // Initialize the bean instance.

        Object exposedObject = bean;

        try {

            populateBean(beanName, mbd, instanceWrapper);

            if (exposedObject != null) {

                exposedObject = initializeBean(beanName, exposedObject, mbd);

            }

        }

        catch (Throwable ex) {

            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {

                throw (BeanCreationException) ex;

            }

            else {

                throw new BeanCreationException(

                        mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);

            }

        }

        if (earlySingletonExposure) {

            Object earlySingletonReference = getSingleton(beanName, false);

            if (earlySingletonReference != null) {

                if (exposedObject == bean) {

                    exposedObject = earlySingletonReference;

                }

                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {

                    String[] dependentBeans = getDependentBeans(beanName);

                    Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);

                    for (String dependentBean : dependentBeans) {

                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {

                            actualDependentBeans.add(dependentBean);

                        }

                    }

                    if (!actualDependentBeans.isEmpty()) {

                        throw new BeanCurrentlyInCreationException(beanName,

                                "Bean with name '" + beanName + "' has been injected into other beans [" +

                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +

                                "] in its raw version as part of a circular reference, but has eventually been " +

                                "wrapped. This means that said other beans do not use the final version of the " +

                                "bean. This is often the result of over-eager type matching - consider using " +

                                "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");

                    }

                }

            }

        }

        // 第三步，对外暴露bean，如 singleton 入 容器中注册实例

        // Register bean as disposable.

        try {

            registerDisposableBeanIfNecessary(beanName, bean, mbd);

        }

        catch (BeanDefinitionValidationException ex) {

            throw new BeanCreationException(

                    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);

        }

        return exposedObject;

    }

    // org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

    protected Object getSingleton(String beanName, boolean allowEarlyReference) {

        Object singletonObject = this.singletonObjects.get(beanName);

        // 针对正在创建中的 singleton, 将其放入 earlySingletonObjects

        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {

            synchronized (this.singletonObjects) {

                singletonObject = this.earlySingletonObjects.get(beanName);

                if (singletonObject == null && allowEarlyReference) {

                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);

                    if (singletonFactory != null) {

                        // 将 singleton 实例从工厂中取出后，存入 提前暴露的缓存中，交将创建工厂删除，避免后续反复从中获取 singleton

                        singletonObject = singletonFactory.getObject();

                        this.earlySingletonObjects.put(beanName, singletonObject);

                        this.singletonFactories.remove(beanName);

                    }

                }

            }

        }

        return (singletonObject != NULL_OBJECT ? singletonObject : null);

    }

    // org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.getEarlyBeanReference()

    protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {

        Object exposedObject = bean;

        if (bean != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {

            for (BeanPostProcessor bp : getBeanPostProcessors()) {

                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {

                    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;

                    exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);

                    if (exposedObject == null) {

                        return null;

                    }

                }

            }

        }

        return exposedObject;

    }

    // org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean()

    // 会先尝试从单例缓存中获取bean，获取不到再进行创建

    /**

     * Return an instance, which may be shared or independent, of the specified bean.

     * @param name the name of the bean to retrieve

     * @param requiredType the required type of the bean to retrieve

     * @param args arguments to use when creating a bean instance using explicit arguments

     * (only applied when creating a new instance as opposed to retrieving an existing one)

     * @param typeCheckOnly whether the instance is obtained for a type check,

     * not for actual use

     * @return an instance of the bean

     * @throws BeansException if the bean could not be created

     */

    @SuppressWarnings("unchecked")

    protected <T> T doGetBean(

            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)

            throws BeansException {

        final String beanName = transformedBeanName(name);

        Object bean;

        // 先从缓存获取，失败则进行创建

        // Eagerly check singleton cache for manually registered singletons.

        Object sharedInstance = getSingleton(beanName);

        if (sharedInstance != null && args == null) {

            if (logger.isDebugEnabled()) {

                if (isSingletonCurrentlyInCreation(beanName)) {

                    logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +

                            "' that is not fully initialized yet - a consequence of a circular reference");

                }

                else {

                    logger.debug("Returning cached instance of singleton bean '" + beanName + "'");

                }

            }

            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

        }

        else {

            // Fail if we're already creating this bean instance:

            // We're assumably within a circular reference.

            if (isPrototypeCurrentlyInCreation(beanName)) {

                throw new BeanCurrentlyInCreationException(beanName);

            }

            // Check if bean definition exists in this factory.

            BeanFactory parentBeanFactory = getParentBeanFactory();

            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {

                // Not found -> check parent.

                String nameToLookup = originalBeanName(name);

                if (args != null) {

                    // Delegation to parent with explicit args.

                    return (T) parentBeanFactory.getBean(nameToLookup, args);

                }

                else {

                    // No args -> delegate to standard getBean method.

                    return parentBeanFactory.getBean(nameToLookup, requiredType);

                }

            }

            if (!typeCheckOnly) {

                markBeanAsCreated(beanName);

            }

            try {

                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

                checkMergedBeanDefinition(mbd, beanName, args);

                // Guarantee initialization of beans that the current bean depends on.

                String[] dependsOn = mbd.getDependsOn();

                if (dependsOn != null) {

                    for (String dep : dependsOn) {

                        if (isDependent(beanName, dep)) {

                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,

                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");

                        }

                        registerDependentBean(dep, beanName);

                        getBean(dep);

                    }

                }

                // Create bean instance.

                if (mbd.isSingleton()) {

                    // 此时根据对象工厂，创建bean，创建时检测依赖情况

                    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {

                        @Override

                        public Object getObject() throws BeansException {

                            try {

                                return createBean(beanName, mbd, args);

                            }

                            catch (BeansException ex) {

                                // Explicitly remove instance from singleton cache: It might have been put there

                                // eagerly by the creation process, to allow for circular reference resolution.

                                // Also remove any beans that received a temporary reference to the bean.

                                destroySingleton(beanName);

                                throw ex;

                            }

                        }

                    });

                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

                }

                else if (mbd.isPrototype()) {

                    // It's a prototype -> create a new instance.

                    Object prototypeInstance = null;

                    try {

                        beforePrototypeCreation(beanName);

                        prototypeInstance = createBean(beanName, mbd, args);

                    }

                    finally {

                        afterPrototypeCreation(beanName);

                    }

                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);

                }

                else {

                    String scopeName = mbd.getScope();

                    final Scope scope = this.scopes.get(scopeName);

                    if (scope == null) {

                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");

                    }

                    try {

                        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {

                            @Override

                            public Object getObject() throws BeansException {

                                beforePrototypeCreation(beanName);

                                try {

                                    return createBean(beanName, mbd, args);

                                }

                                finally {

                                    afterPrototypeCreation(beanName);

                                }

                            }

                        });

                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);

                    }

                    catch (IllegalStateException ex) {

                        throw new BeanCreationException(beanName,

                                "Scope '" + scopeName + "' is not active for the current thread; consider " +

                                "defining a scoped proxy for this bean if you intend to refer to it from a singleton",

                                ex);

                    }

                }

            }

            catch (BeansException ex) {

                cleanupAfterBeanCreationFailure(beanName);

                throw ex;

            }

        }

        // Check if required type matches the type of the actual bean instance.

        if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {

            try {

                return getTypeConverter().convertIfNecessary(bean, requiredType);

            }

            catch (TypeMismatchException ex) {

                if (logger.isDebugEnabled()) {

                    logger.debug("Failed to convert bean '" + name + "' to required type '" +

                            ClassUtils.getQualifiedName(requiredType) + "'", ex);

                }

                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());

            }

        }

        return (T) bean;

    }

    // org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton()

    // 进行 singleton 创建时，做安全检查，成功后放入缓存中

    /**

     * Return the (raw) singleton object registered under the given name,

     * creating and registering a new one if none registered yet.

     * @param beanName the name of the bean

     * @param singletonFactory the ObjectFactory to lazily create the singleton

     * with, if necessary

     * @return the registered singleton object

     */

    public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {

        Assert.notNull(beanName, "'beanName' must not be null");

        synchronized (this.singletonObjects) {

            Object singletonObject = this.singletonObjects.get(beanName);

            if (singletonObject == null) {

                if (this.singletonsCurrentlyInDestruction) {

                    throw new BeanCreationNotAllowedException(beanName,

                            "Singleton bean creation not allowed while singletons of this factory are in destruction " +

                            "(Do not request a bean from a BeanFactory in a destroy method implementation!)");

                }

                if (logger.isDebugEnabled()) {

                    logger.debug("Creating shared instance of singleton bean '" + beanName + "'");

                }

                // 创建前检查，循环依赖失败在此时检测到，即单例只能被创建一次

                beforeSingletonCreation(beanName);

                boolean newSingleton = false;

                boolean recordSuppressedExceptions = (this.suppressedExceptions == null);

                if (recordSuppressedExceptions) {

                    this.suppressedExceptions = new LinkedHashSet<Exception>();

                }

                try {

                    // createBean()

                    singletonObject = singletonFactory.getObject();

                    newSingleton = true;

                }

                catch (IllegalStateException ex) {

                    // Has the singleton object implicitly appeared in the meantime ->

                    // if yes, proceed with it since the exception indicates that state.

                    singletonObject = this.singletonObjects.get(beanName);

                    if (singletonObject == null) {

                        throw ex;

                    }

                }

                catch (BeanCreationException ex) {

                    if (recordSuppressedExceptions) {

                        for (Exception suppressedException : this.suppressedExceptions) {

                            ex.addRelatedCause(suppressedException);

                        }

                    }

                    throw ex;

                }

                finally {

                    if (recordSuppressedExceptions) {

                        this.suppressedExceptions = null;

                    }

                    // 最后，清除正在创建的标识

                    afterSingletonCreation(beanName);

                }

                // 单例创建成功，则将其加入到缓存中，并清理之前的标记

                if (newSingleton) {

                    addSingleton(beanName, singletonObject);

                }

            }

            return (singletonObject != NULL_OBJECT ? singletonObject : null);

        }

    }

    /**

     * Add the given singleton object to the singleton cache of this factory.

     * <p>To be called for eager registration of singletons.

     * @param beanName the name of the bean

     * @param singletonObject the singleton object

     */

    protected void addSingleton(String beanName, Object singletonObject) {

        synchronized (this.singletonObjects) {

            this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));

            this.singletonFactories.remove(beanName);

            this.earlySingletonObjects.remove(beanName);

            this.registeredSingletons.add(beanName);

        }

    }