戴着眼镜看不清
戴着眼镜看不清

从Spring源码看Spring是如何实现HelloWorld

很多人想读Spring的源码都不知道从何看起，我个人的观点，大家知道我们学习一门语言的时候，都是开始于HelloWorld的编写，我觉的Spring的学习也可以开始于最简单的HelloWorld。

Spring实现HelloWorld

直接上代码

首先我们需要一个HelloWorld的实体类：

package org.xiomanixi.spring.analyse.bean;

/**
 * @program: spring_analyse
 * @description: Spring实现HelloWorld
 * @author: xiaomanixi 小码blog
 * @create: 2020-05-10 21:35
 **/

public class HelloWorld {
    private static final String HELLO_WORLD = "Hello World !";

    public String getHelloWorld(){
        return HELLO_WORLD;
    }
}

然后需要配置一个xml文件，用来配置bean：

 最后需要一个测试类，我们通过xml来构造bean：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.xiomanixi.spring.analyse.bean.HelloWorld;

/**
 * @program: spring_analyse
 * @description: Spring实现HW测试类
 * @author: xiaomanixi 小码blog
 * @create: 2020-05-10 21:42
 **/

public class HelloWorldTest {

    public static void main(String[] args) {
        //读取xml配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("/hello_world.xml");

        //读取配置好的Bean
        HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");

        //执行对象方法
        System.out.println(helloWorld.getHelloWorld());
    }
}

如果你是一个Java小白，会使用Spring就足够了，但是如果你是个Java爱好者，想要提升自己，谋求更好的发展，你就要好好研究一下这段代码了。

根据上面的实例，我们可以提出两个问题：

  1. ApplicationContext context = new ClassPathXmlApplicationContext("/hello_world.xml") 容器创建的时候做了什么？
  2. getBean 是如何实现的？

没错，其实就是Spring是如何构造容器并获取到对象的？我们来分析一下Spring的源代码。

ClassPathXmlApplicationContext源码解析

 首先来看ClassPathXmlApplicationContext的类继承关系，这样我们会有一个宏观的认识：

从Spring源码看Spring是如何实现HelloWorld_第1张图片

怎么查看ApplicationContext的构造过程呢，对于复杂的实现，最好的办法就是debug断点调试来看完整的执行路径。

ClassPathXmlApplicationContext构造器源码，断点调试进入AbstractXmlApplicationContext类

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
		this(new String[] {configLocation}, true, null);
	}

public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {

		super(parent);
		setConfigLocations(configLocations);
		if (refresh) {
			refresh();
		}
	}

这个方法的注释是： Create a new ClassPathXmlApplicationContext, loading the definitions from the given XML file and automatically refreshing the context. 创建一个xml上下文路径，加载路径，并自动刷新上下文。

我们通过super不断调用父类的构造器直到AbstractApplicationContext，查看AbstractApplicationContext构造器源码：

	/**
	 * Create a new AbstractApplicationContext with no parent.
	 */
	public AbstractApplicationContext() {
		this.resourcePatternResolver = getResourcePatternResolver();
	}

	/**
	 * Create a new AbstractApplicationContext with the given parent context.
	 * @param parent the parent context
	 */
	public AbstractApplicationContext(@Nullable ApplicationContext parent) {
		this();
		setParent(parent);
	}

其中 getResourcePatternResolver的作用是创建一个资源处理器：

protected ResourcePatternResolver getResourcePatternResolver() {
        return new PathMatchingResourcePatternResolver(this);
    }

到目前为止，ClassPathXmlApplicationContext已经有了两个资源加载器(一个由AbstractApplicationContext继承DefaultResourceLoader而来，一个是AbstractApplicationContext主动创建的PathMatchingResourcePatternResolver)
DefaultResourceLoader只能加载一个特定类路径的资源，PathMatchingResourcePatternResolver可以根据Ant风格加载多个资源。

每个父类的构造方法返回后调用AbstractRefreshableConfigApplicationContext的setConfigLocations(configLocations)方法，此方法的目的在于将占位符(placeholder)解析成实际的地址：主要构造方法是setConfigLocations，我们进入这个方法就到达了AbstractRefreshableConfigApplicationContext类：

public void setConfigLocations(@Nullable String... locations) {
		if (locations != null) {
			Assert.noNullElements(locations, "Config locations must not be null");
			this.configLocations = new String[locations.length];
			for (int i = 0; i < locations.length; i++) {
				this.configLocations[i] = resolvePath(locations[i]).trim();
			}
		}
		else {
			this.configLocations = null;
		}
	}

这个方法的主要作用是设置配置文件路径，主要方法是resolvePath(解决路径)。进入resolvePath：

protected String resolvePath(String path) {
		return getEnvironment().resolveRequiredPlaceholders(path);
	}

其中getEnvironment获取环境参数：

@Override
	public ConfigurableEnvironment getEnvironment() {
		if (this.environment == null) {
			this.environment = createEnvironment();
		}
		return this.environment;
	}

getEnvironment()方法是由ConfigurableApplicationContext接口定义，在AbstractApplicationContext实现，其实就是判断environment 是否为空，不为空就创建一个StandardEnvironment，可获取的环境参数是系统参数或者是JVM参数，如下： 

从Spring源码看Spring是如何实现HelloWorld_第2张图片

关于 Environment的作用解释：Environment是什么

顺着代码继续走，可以发现解析占位符的核心方法是parseStringValue，实现如下：

protected String parseStringValue(
			String value, PlaceholderResolver placeholderResolver, @Nullable Set visitedPlaceholders) {

		int startIndex = value.indexOf(this.placeholderPrefix);
		if (startIndex == -1) {
			return value;
		}

		StringBuilder result = new StringBuilder(value);
		while (startIndex != -1) {
			int endIndex = findPlaceholderEndIndex(result, startIndex);
			if (endIndex != -1) {
				String placeholder = result.substring(startIndex + this.placeholderPrefix.length(), endIndex);
				String originalPlaceholder = placeholder;
				if (visitedPlaceholders == null) {
					visitedPlaceholders = new HashSet<>(4);
				}
				if (!visitedPlaceholders.add(originalPlaceholder)) {
					throw new IllegalArgumentException(
							"Circular placeholder reference '" + originalPlaceholder + "' in property definitions");
				}
				// Recursive invocation, parsing placeholders contained in the placeholder key.
				placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);
				// Now obtain the value for the fully resolved key...
				String propVal = placeholderResolver.resolvePlaceholder(placeholder);
				if (propVal == null && this.valueSeparator != null) {
					int separatorIndex = placeholder.indexOf(this.valueSeparator);
					if (separatorIndex != -1) {
						String actualPlaceholder = placeholder.substring(0, separatorIndex);
						String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());
						propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);
						if (propVal == null) {
							propVal = defaultValue;
						}
					}
				}
				if (propVal != null) {
					// Recursive invocation, parsing placeholders contained in the
					// previously resolved placeholder value.
					propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
					result.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);
					if (logger.isTraceEnabled()) {
						logger.trace("Resolved placeholder '" + placeholder + "'");
					}
					startIndex = result.indexOf(this.placeholderPrefix, startIndex + propVal.length());
				}
				else if (this.ignoreUnresolvablePlaceholders) {
					// Proceed with unprocessed value.
					startIndex = result.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());
				}
				else {
					throw new IllegalArgumentException("Could not resolve placeholder '" +
							placeholder + "'" + " in value \"" + value + "\"");
				}
				visitedPlaceholders.remove(originalPlaceholder);
			}
			else {
				startIndex = -1;
			}
		}
		return result.toString();
	}

Spring bean解析就在refresh方法，Spring所有的初始化都在这个方法中完成，该方法在AbstractApplicationContext实现：

@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

根据注释得知prepareRefresh主要是准备工作，包括设置启动时间，是否激活标识位，初始化属性源(property source)配置。

/**
	 * Prepare this context for refreshing, setting its startup date and
	 * active flag as well as performing any initialization of property sources.
	 */
	protected void prepareRefresh() {
		// Switch to active.
		this.startupDate = System.currentTimeMillis();
		this.closed.set(false);
		this.active.set(true);

		if (logger.isDebugEnabled()) {
			if (logger.isTraceEnabled()) {
				logger.trace("Refreshing " + this);
			}
			else {
				logger.debug("Refreshing " + getDisplayName());
			}
		}

		// Initialize any placeholder property sources in the context environment.
		initPropertySources();

		// Validate that all properties marked as required are resolvable:
		// see ConfigurablePropertyResolver#setRequiredProperties
		getEnvironment().validateRequiredProperties();

		// Store pre-refresh ApplicationListeners...
		if (this.earlyApplicationListeners == null) {
			this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
		}
		else {
			// Reset local application listeners to pre-refresh state.
			this.applicationListeners.clear();
			this.applicationListeners.addAll(this.earlyApplicationListeners);
		}

		// Allow for the collection of early ApplicationEvents,
		// to be published once the multicaster is available...
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}

下一步就是创建beanFactory，调用AbstractApplicationContext的obtainFreshBeanFactory方法获取obtainFreshBeanFactory 。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		refreshBeanFactory();
		return getBeanFactory();
	}

我们来看refreshBeanFactory在AbstractRefreshableApplicationContext中的具体实现：

@Override
	protected final void  refreshBeanFactory() throws BeansException {
		if (hasBeanFactory()) { //如果已经存在的BeanFactory则销毁
			destroyBeans();
			closeBeanFactory();
		}
		try {
                        //1、创建一个DefaultListableBeanFactory 
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());

                        //2、定制beanFactory，由AbstractRefreshableApplicationContext实现
			customizeBeanFactory(beanFactory);

                        //3、加载bean,由AbstractXmlApplicationContext实现
			loadBeanDefinitions(beanFactory);

			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

第2步定制bean，customizeBeanFactory方法具体实现：

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
        if (this.allowBeanDefinitionOverriding != null) {
            beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
        if (this.allowCircularReferences != null) {
            beanFactory.setAllowCircularReferences(this.allowCircularReferences);
        }
    }

加载bean的loadBeanDefinitions具体实现：

@Override
    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        // Create a new XmlBeanDefinitionReader for the given BeanFactory.
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

        // Configure the bean definition reader with this context's
        // resource loading environment.
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

        // Allow a subclass to provide custom initialization of the reader,
        // then proceed with actually loading the bean definitions.
        initBeanDefinitionReader(beanDefinitionReader);
        loadBeanDefinitions(beanDefinitionReader);
    }

 getBean源码解析

看了很多资料，网上一张图我觉的是Spring getBean实现的很好的原理逻辑示意图，给我们展示了一个完整的调用过程：

从Spring源码看Spring是如何实现HelloWorld_第3张图片

我们参考上图的调用链，结合代码断点调试，来看getBean的实现，getBean远没有我想象的那么简单。

首先是AbstractApplicationContext中：

@Override
	public Object getBean(String name) throws BeansException {
		assertBeanFactoryActive();
		return getBeanFactory().getBean(name);
	}

调用了抽象beanFactory工厂，调用AbstractBeanFactory的getBean：

	@Override
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}

我们来看doGetBean的实现：

protected  T doGetBean(final String name, @Nullable final Class requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
        //会包括解析别名等操作
        final String beanName = transformedBeanName(name);
        Object bean;

        // 先检查单例列表中是否已经注册了这个bean
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }
        else {
            // 检查bean是否并发被创建
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
            // 检查是否在父类工厂中,逻辑和这个差不多,这里省略....

           //标记bean正在被创建
            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }
            try {
                //合并父类中的方法及属性,下面会细讲                      
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                //检查这个bean是否为抽象类
                checkMergedBeanDefinition(mbd, beanName, args);

                // 这里是为了保证获取的bean的依赖都需要先生成
                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);
                        try {
                            getBean(dep);
                        }
                        catch (NoSuchBeanDefinitionException ex){
                            throw ex;
                        }
                    }
                }

                // 创建单例的bean,看下方的createBean方法
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            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, () -> {
                            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;
            }
        }

        // 检查需要的类型和实际传参类型是否一致. 这里省略....
        return (T) bean;
    }

上面的代码什么意思呢？过程是这样的：

  • 获取实际的beanName,其中会处理带&号前缀的beanName，并解析别名。
  • 检查单例列表中是否存在该beanName的bean，若存在则无需走下面的创建bean的流程。
  • 若单例列表中并不存在此bean，则检查是否有并发创建。这里的判断只针对scope为prototype类型的bean。
  • 检查bean是否存在于父类工厂中，若存在，则走父类工厂的getBean流程。向上委托，保证容器中只会存在一个同名的bean。
  • 标记bean正在被创建。
  • 如果有父类，这里会递归合并父类的方法以及属性。并会用自己重写的方法覆盖其父类的方法。合并完成并检查这个bean的是否是抽象类。
  • 如果该bean上有注解@DependsOn,或者配置文件上配置有该属性,则需保证该bean的所有依赖需要先在容器内注册。
  • 分单例和原型以及其他scope类型来创建bean。
  • 检查需要的类型和生成的bean类型是否一致。
  • 返回创建好的bean。

其中重要的方法你注意到了吗，getSingleton方法，获取bean单例，实现如下：

	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		Object singletonObject = this.singletonObjects.get(beanName);
		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) {
						singletonObject = singletonFactory.getObject();
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}

上述流程是：

  • 这里的singletonObjects是一个缓存了beanName和bean的Map,若存在，直接返回。
  • 不存在，则检查是否这个bean是否正在创建的过程中，先检查earlySingletonObjects这个容器,这个容器里面放着的是已经构造完成但是没有注入属性的对象，若存在，也会直接返回。
  • 尝试着从singletonFactories中获取，然后调用getObject方法去获取对象。并将获取到的对象放到earlySingletonObjects容器中，然后从singletonFactories容器中移除。

这里这么设计是为了解决循环依赖的问题。若A依赖B，B依赖C，C又依赖A，这样三个bean就形成了一个环（这里只是针对set方法注入的bean,构造器注入还是会有循环依赖的问题而抛出异常的），spring会将创建的bean实例提前暴露在缓存中，一旦下一个bean创建的时候需要依赖上个bean，则直接使用ObjectFactory来获取bean。

doGetBean还需要注意这段代码：

	// Create bean instance.
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						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);
				}

这里的getSingleton，是DefaultSingletonBeanRegistry类中实现的：

public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
        Assert.notNull(beanName, "Bean name 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);
                //定义异常
                ...
                try {
                    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) {
                    //封装异常
                    ...
                }
                finally {
                    ...
                    afterSingletonCreation(beanName);
                }
                if (newSingleton) {
                    addSingleton(beanName, singletonObject);
                }
            }
            return singletonObject;
        }
    }
  • 因为singleton的bean只能存在一个，所以对singletonObjects这个缓存做加锁获取
  • 做循环依赖判断
  • beforeSingletonCreation(beanName);//也就是把这个beanName标记成正在创建中
  • 通过singletonFactory的方法获取bean --> 也就是调用createBean方法
  • afterSingletonCreation(beanName);//去除该beanName正在创建中的标记
  • 如果是新创建的singleton的bean的话，把他加入singletonObjects缓存中
  • 这个singletonObjects缓存也就是上面所说的三级缓存的中的第一级。

不管是singleton还是Prototype还是其他的scope，在从作用域中获取不到bean的情况下，都是调用的createBean。

我们看一下createBean的实现：

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {

        RootBeanDefinition mbdToUse = mbd;

        // 要保证RootBeanDefinition的beanClass是存在的
        Class resolvedClass = resolveBeanClass(mbd, beanName);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        // 这一块没什么研究，注解意思是（检查所有带有override的方法是否都是存在的）
        try {
            mbdToUse.prepareMethodOverrides();
        }
        catch (BeanDefinitionValidationException ex) {
        }

        try {
            //这一块我猜测大概是看咱们自己有提供实例化的方法不，若有，则不会走下面的doCreateBean方法。
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        }
        catch (Throwable ex) {
        }

        try {
            //创建bean的真正方法
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            }
            return beanInstance;
        }
        catch (Exception e){
           throw e;
        }
    }

穿件Bean的真正方法是doCreateBean，我们来看他的实现：

  • protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {

        // Instantiate the bean.
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            // 创建这个bean,真正构建时有分两种情况，jdk反射和cglib动态代理
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = instanceWrapper.getWrappedInstance();
        Class beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        // 允许后置处理器来修改这个BeanDefinition
        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;
            }
        }

        // 用来解决循环依赖问题的，上面已经有过详细解释了。看上面循环依赖模块
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            if (logger.isTraceEnabled()) {
                logger.trace("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        // Initialize the bean instance.
        Object exposedObject = bean;
        try {
            //进行属性的注入，调用bean的set方法进行字段的初始化
            populateBean(beanName, mbd, instanceWrapper);
            //进行一些初始化方法的调用，比如afterPropertiesSet等等。
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        catch (Throwable ex) {
            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
                throw (BeanCreationException) ex;
            }
        }

        if (earlySingletonExposure) {
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                }
                //在出现循环依赖后，从earlySingletonObjects中获取的bean对象和initializeBean后
                //的不一致，证明被后置处理器处理过了，前后bean不一致，需要抛出异常
                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set actualDependentBeans = new LinkedHashSet<>(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的销毁方法
        try {
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }

        return exposedObject;
    }

doCreateBean大概有以下步骤：

  • 调用createBeanInstance方法初始化bean实例，这里不包括属性的注入。
  • 调用合并bean的后置处理器修改这个bean的BeanDefinition的一些定义。即调用MergedBeanDefinitionPostProcessor的实现类的postProcessMergedBeanDefinition方法对BeanDefinition进行一些额外的处理。
  • 为早期的循环依赖做准备，将包装了bean的工厂方法塞到singletonFactories中。
  • 调用populateBean方法进行一些属性的注入。
  • 执行initializeBean方法进行一些初始化方法的调用，例如：afterPropertiesSet方法的调用。与此同时，其后置处理器有可能对指定的bean进行增强。
  • 如果出现了bean的增强，然后又有依赖它的类先生成，则需抛出异常。例如：对象A被增强了，得到A+对象，而此时对象B有依赖对象A，循环依赖时通过singletonFactories获取到的对象却是增强前的A对象，这时就会出现问题。如果不抛出异常，spring容器缓存的是A+对象，但是B引用的却是A，这样就会出现不可预测的问题。

来看createBeanInstance中调用的instantiateBean的实现：

	protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
		try {
			Object beanInstance;
			final BeanFactory parent = this;
			if (System.getSecurityManager() != null) {
				beanInstance = AccessController.doPrivileged((PrivilegedAction) () ->
						getInstantiationStrategy().instantiate(mbd, beanName, parent),
						getAccessControlContext());
			}
			else {
				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
			}
			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
			initBeanWrapper(bw);
			return bw;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
		}
	} 
  
这里是createBeanInstance方法中最终调用的方法，这里有三个流程：
 
  
     
   
  • 进行对象的构造，这里关注下CglibSubclassingInstantiationStrategy这个策略类，有继承SimpleInstantiationStrategy类，调用其instantiate可以调用对象的构造器进行对象的初始化，在BeanDefinition属性MethodOverrides不存在时，可以用jdk的反射进行获取对象，否则则必须使用cglib动态代理。
    •  
   
  • 用BeanWrapperImpl对生成的对象进行包装，并激活注册默认编辑器的属性。
    •  
   
  • 注册默认的编辑器，然后将ConversionService这个类的引用设置到BeanWrapper对象上。ConversionService是用来进行类型转换的，里面的属性converters用一个map维护着各种类型的转换器。
    •  
  
 
  
populateBean源码部分：
 
  
    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        ......
        PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

        if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
            // 这里是根据bean名称进行依赖注入的
            if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }
            // 这里是根据bean的类型进行依赖注入的
            if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }
            pvs = newPvs;
        }
        ......
        if (pvs != null) {
//实际上注入属性值的方法，这里是populateBean方法的重点
            applyPropertyValues(beanName, mbd, bw, pvs);
        }
    }
 
  
这里注释下applyPropertyValues的部分源码：
 
  
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
        MutablePropertyValues mpvs = null;
        List original;

        if (pvs instanceof MutablePropertyValues) {
            mpvs = (MutablePropertyValues) pvs;
            if (mpvs.isConverted()) {
                // 这里可以迅速返回。当这个PropertyValues对象中的值都是处理过后便可以触发。状态值会在下面几行代码设置。
                try {
                    bw.setPropertyValues(mpvs);
                    return;
                }
                catch (BeansException ex) {
                    throw new BeanCreationException(
                            mbd.getResourceDescription(), beanName, "Error setting property values", ex);
                }
            }
            original = mpvs.getPropertyValueList();
        }
        else {
            original = Arrays.asList(pvs.getPropertyValues());
        }

        TypeConverter converter = getCustomTypeConverter();
        if (converter == null) {
            converter = bw;
        }
        BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

        // 这里是个深拷贝，解析所有引用的值。
        List deepCopy = new ArrayList<>(original.size());
        boolean resolveNecessary = false;
        for (PropertyValue pv : original) {
            if (pv.isConverted()) {
                deepCopy.add(pv);
            }
            else {
                String propertyName = pv.getName();
                Object originalValue = pv.getValue();
                //这里的resolveValueIfNecessary是一个需要关注的方法，有兴趣的小伙伴可以点进去看看，
                //里面封装了针对各种类型的属性的解析，例如List,Map,Set等等类型。
                Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
                Object convertedValue = resolvedValue;
                boolean convertible = bw.isWritableProperty(propertyName) &&
                        !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
                if (convertible) {
                    convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
                }
                //为了避免每次创建都去转换属性
                if (resolvedValue == originalValue) {
                //这里的触发条件必须为该属性得是有写权限的，并且里面不能带有“.”和“[”这个符号，这里我的理解是
                    //teacher.name以及student[1].name这样的propertyName便不能触发这个条件
                    if (convertible) {
                        pv.setConvertedValue(convertedValue);
                    }
                    deepCopy.add(pv);
                }
                else if (convertible && originalValue instanceof TypedStringValue &&
                        !((TypedStringValue) originalValue).isDynamic() &&
                        !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
                    //这一块的条件比上一个多了几个，源值必须是string类型，且不能是动态的，并且不能是集合和数组中的任意一个。
                    pv.setConvertedValue(convertedValue);
                    deepCopy.add(pv);
                }
                else {
                    //条件在这里触发后就不会打开快捷返回的开关了
                    resolveNecessary = true;
                    deepCopy.add(new PropertyValue(pv, convertedValue));
                }
            }
        }
        //设置converted状态值，供其组装属性时快捷返回。
        if (mpvs != null && !resolveNecessary) {
            mpvs.setConverted();
        }

        // 将我们深拷贝出来的值设置到包装类BeanWrapperImpl包装的对象上
        try {
            bw.setPropertyValues(new MutablePropertyValues(deepCopy));
        }
        catch (BeansException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Error setting property values", ex);
        }
    }
 
  
setPropertyValues方法的源码最终调用的是AbstractNestablePropertyAccessor类的setPropertyValue方法，在这里BeanWrapperImpl是它的实现类，从名字上看也能猜出来这个类是个处理嵌套属性的访问器。
 
  
    public void setPropertyValue(String propertyName, @Nullable Object value) throws BeansException {
        AbstractNestablePropertyAccessor nestedPa;
        try {
            //这里可以解析嵌套的属性
            nestedPa = getPropertyAccessorForPropertyPath(propertyName);
        }
        catch (NotReadablePropertyException ex) {
            throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
                    "Nested property in path '" + propertyName + "' does not exist", ex);
        }
        //这里获取到了最终解析到的属性名
        PropertyTokenHolder tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
       //给最终解析到的属性名赋值操作
        nestedPa.setPropertyValue(tokens, new PropertyValue(propertyName, value));
    }
 
  
上面有个getPropertyAccessorForPropertyPath方法，点进去会发现他会有个解析“.”和“[]”的方法getNestedPropertySeparatorIndex，它的作用我举个例子来说明一下：一个班级有多个学生，我想设置某个学生的名字，班级是个Class对象,里面有属性：private Student[] students这里我想修改下student[2]的name属性，我就必须先用getStudent方法取出 Student[] 数组，然后再在 Student[] 数组中找到索引为2的Student，最后修改Student身上的name属性。
 
  
以上就是Spring的getBean的实现。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Spring源码)

        

            

                
    
                    
  • Java基础：单例模式，Spring源码中有哪些单例模式
                        生活诙谐号
Java基础Spring源码设计模式单例模式javaspring
                        
    单例模式是一种常用的软件设计模式，其目的是确保一个类仅有一个实例，并提供一个全局访问点来获取这个唯一实例。在Java中，实现单例模式通常需要遵循以下几个关键原则：私有化构造器：将类的构造器声明为private，以防止外部代码通过new操作符直接创建该类的实例。静态工厂方法：提供一个静态方法（通常称为getInstance()），用于获取单例对象。这个方法负责检查是否已经创建过实例，如果尚未创建，则
    
                    
    • 
                    
  • 单例模式详解（DLC和spring源码中的应用）
                        CCCCVVVVCCCC
单例模式springjava
                        
    单例模式详解（DLC和spring源码中的应用）单例模式通过确保一个类只有一个实例并提供一个全局访问点来访问该实例来实现。通常，实现单例模式有两种方法：饿汉式和懒汉式。饿汉式单例在类加载时就创建了实例，所以不存在线程安全问题。懒汉式单例在第一次调用时才创建实例，并且必须通过同步机制来保证线程安全。下面是一个简单的饿汉式单例类的示例：publicclassSingleton{//创建Singleto
    
                    
    • 
                    
  • Spring源码浅析の循环依赖
                        西岭千秋雪_
源码分析springjava后端springboot
                        
    AbstractBeanFactory#doGetBean:尝试获取bean如果bean是单例的：if(mbd.isSingleton()){//尝试获取beansharedInstance=getSingleton(beanName,()->{try{//获取不到就创建returncreateBean(beanName,mbd,args);}catch(BeansExceptionex){//E
    
                    
    • 
                    
  • Spring系列之设计模式
                        johnny233
设计模式Springspring设计模式
                        
    Spring作为Java世界当之无愧的No.1开源框架，其架构设计非常优秀，使用很多设计模式。注：本文参考Spring-6.1.5版本源码；本文目录设置参考设计模式三大类来划分，Spring家族包括Spring、SpringMVC、SpringBoot、SpringCloud、SpringData等，总之Spring源码博大精深；某一种设计模式会在若干个Spring接口、类、或模块里有所体现，不可
    
                    
    • 
                    
  • Spring Boot 一个极简且完整的后台框架
                        搬砖养女人
数据库架构javaspringsqltomcat
                        
    一个完整的极简后台框架，方便做小项目的时候可以快速开发。这里面多贴图片和代码，做个参考吧，代码可以下载下来自己看看，里面这套后台模板不错，喜欢的拿去。先放几张图imageimageimage项目介绍SpringBoot，实现了一个极简单的后台框架image小编提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redi
    
                    
    • 
                    
  • Spring 源码解读专栏：从零到一深度掌握 Spring 框架
                        捕风捉你
spring源码解读springjava后端
                        
    前言Spring是Java世界中无可争议的王者框架，它以其灵活、轻量、强大而著称，成为企业级开发的首选工具。然而，很多开发者在使用Spring时，往往只停留在会用的层面，对于其内部实现和设计原理知之甚少。本专栏旨在通过系统化的Spring源码解读，从实践到源码分析，再到设计模式的探讨，带你逐步揭开Spring的神秘面纱，真正掌握这款框架的精髓。专栏目标在这个专栏中，我们将通过以下几个步骤，帮助你深
    
                    
    • 
                    
  • 手写spring源码
                        augisTrench
springpythonwindows
                        
    gitlub地址：仓库地址spring源码springboot基于spring的底层去实现，在springboot进行启动时候手写启动类和tomcat，加载启动类的注解进行扫描加载全部的bean。讲数据发送给tomcat后，tomcat才能将接口的信息进行展示出来。这边就不手写了。packagecom.trench.springUtil;importcom.trench.interfa.*;imp
    
                    
    • 
                    
  • 我的2023，如履薄冰，你说我能保住这份工吗
                        
2023-年度总结
                        
    最近刷B站发现李连杰的投名状电影片段配合上void这首曲子，还挺魔性的，看了挺上头。也有不少据此二创的视频，都还挺好玩的。感觉用这个来总结2023似乎也挺恰当。我想从技术成长和生活两方面来聊一聊我的2023。技术成长今年写的系列教程很少，总结起来就三个：年初完结了gRPC系列。4、5月份的时候完善了之前的MySQL系列。7月份开始连载Spring源码系列。相比于往年，今年的技术更新确实慢了很多，有
    
                    
    • 
                    
  • Spring源码笔记之SpringIOC--（3）什么是BeanFactory？
                        冷雨夜中漫步
spring全家桶spring笔记java
                        
    什么是BeanFactory？BeanFactory是SpringIOC的最顶层接口，涵盖了IOC容器最基本的操作。ListableBeanFactory、ConfigurableBeanFactory提供了IOC容器获取所有Bean、配置Bean的额外能力。所有BeanFactory的实现类持有所有Bean的定义BeanDefinition，用一个唯一的字符串（即Bean的名字）区分。BeanF
    
                    
    • 
                    
  • redo log —— MySQL宕机时数据不丢失的原理
                        天堂2013
MySQLMySQLredologjava
                        
    扫描下方二维码或者微信搜索公众号菜鸟飞呀飞，即可关注微信公众号，阅读更多Spring源码分析、Java并发编程和Netty源码系列文章。问题在开始阅读本文之前，可以先思考一下下面两个问题。众所周知，MySQL有四大特性：ACID，其中D指的是持久性（Durability），它的含义是MySQL的事务一旦提交，它对数据库的改变是永久性的，即数据不会丢失，那么MySQL究竟是如何实现的呢？MySQL数
    
                    
    • 
                    
  • 【Spring源码分析】解析配置类-ConfigurationClassPostProcessor源码分析
                        假正经的小柴
Java源码分析spring数据库前端
                        
    阅读此需阅读下面这些博客先【Spring源码分析】Bean的元数据和一些Spring的工具【Spring源码分析】BeanFactory系列接口解读【Spring源码分析】执行流程之非懒加载单例Bean的实例化逻辑【Spring源码分析】从源码角度去熟悉依赖注入（一）【Spring源码分析】从源码角度去熟悉依赖注入（二）【Spring源码分析】@Resource注入的源码解析【Spring源码分析
    
                    
    • 
                    
  • 【手撕Spring源码】容器与Bean
                        十八岁讨厌编程
手撕框架源码springspringbootjava源码
                        
    文章目录什么是容器？容器接口容器实现BeanFactory容器实现ApplicationContext容器实现Bean的生命周期模板方法设计模式Bean后处理器BeanFactory后处理器有关后处理器(PostProcessor)的调用时期Aware接口和InitializingBean接口初始化和销毁Scope什么是容器？Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种用于
    
                    
    • 
                    
  • spring源码解析流程，一步一步在源码加注释带你了解bean的加载过程
                        笨蛋CXJ
springspringjava
                        
    spring前述：spring源码环境搭建以及源码下载在文章后方有链接，可自行参考搭建，这里只是对加载过程做一个解析，spring全家桶远不止这些东东，感兴趣的小伙伴可以去官网看一下，本文将以源码加注释的方式进行过程解析，带你了解spring中bean到底是如何一步步加载完成了解重点：bean的生命周期、加载过程最终目的：学习spring源码短期内不对对你的技术有太大提升，可能只是了解到漂亮的代码
    
                    
    • 
                    
  • 【Spring源码分析】循环依赖的底层源码剖析
                        假正经的小柴
Java源码分析spring数据库java
                        
    循环依赖的底层源码剖析一、预知知识二、循环依赖的底层源码剖析1.Spring是如何存储半成品Bean的？getEarlyBeanReference方法的源码分析2.Spring是如何解决的循环依赖呢？测试3.哪些循环依赖Spring是无法解决的呢？@Async引起的循环依赖解决方案单构造注入引起的循环依赖解决方案三、总结阅读此需阅读下面这些博客先【Spring源码分析】Bean的元数据和一些Spr
    
                    
    • 
                    
  • 【Spring源码分析】推断构造方法
                        假正经的小柴
Java源码分析springjava数据库
                        
    推断构造方法源码解析一、确认候选构造——AutowireAnnotationBeanPostProcessor#determineCandidateConstructors二、autowireConstructor方法源码解析三、总结阅读此需阅读下面这些博客先【Spring源码分析】Bean的元数据和一些Spring的工具【Spring源码分析】BeanFactory系列接口解读【Spring源码
    
                    
    • 
                    
  • 【Spring源码分析】@Resource注入的源码解析
                        假正经的小柴
Java源码分析springjava数据库
                        
    @Resource注入的源码解析一、绪论二、CommonAnnotationBeanPostProcessor源码分析postProcessMergedBeanDefinition源码解析postProcessProperties源码解析ResourceElement构造函数分析inject方法解析三、总结不愿看这段可跳过系列：话是针对可能是刷到这篇博客的人写的（而非订阅从头到尾跟着去阅读的）：还
    
                    
    • 
                    
  • 【Spring源码分析】Spring的启动流程源码解析
                        假正经的小柴
Java源码分析spring数据库java
                        
    阅读此需阅读下面这些博客先【Spring源码分析】Bean的元数据和一些Spring的工具【Spring源码分析】BeanFactory系列接口解读【Spring源码分析】执行流程之非懒加载单例Bean的实例化逻辑【Spring源码分析】从源码角度去熟悉依赖注入（一）【Spring源码分析】从源码角度去熟悉依赖注入（二）【Spring源码分析】@Resource注入的源码解析【Spring源码分析
    
                    
    • 
                    
  • 【Spring源码分析】37-Spring MVC的异常处理
                        一直不懂
SpringFramework源码分析
                        
    在SpringMVC中处理HTTP请求时如果抛出异常会使用DispatcherServlet#processHandlerException()处理，这个方法内部使用SpringMVC默认的注册的HandlerExceptionResolver进行处理。@NullableprotectedModelAndViewprocessHandlerException(HttpServletRequestr
    
                    
    • 
                    
  • 源码分析怎么做？
                        _tison
编程语言javaspring人工智能移动开发
                        
    近日在知乎上看到一个关于源码分析的提问《程序员阅读源码是一种什么心态？源码对编程意义何在？如何才能更好阅读代码？》，正好结合对比读完的两本讲解Spring源码的书《Spring源码深度解析（第2版）》（简称《Spring》）和《深入理解SpringMVC源代码》（简称《SpringMVC》），聊一聊阅读的体验，顺便讲一讲阅读分析怎么做、怎么写这回事。首先要明确的是，源码分析的入手点是软件而不是源代
    
                    
    • 
                    
  • 模拟mybatis实现接口依赖注入
                        瞿大官人

                        
    一、前言这一节基于前面两节mybatis中Mapper注入spring源码分析与mybatis接口依赖注入源码分析的理论，手动实现将接口放入Spring工厂中，并且能够依赖注入。二、实践这里先把已写好的类贴出来，下面会一一介绍。这篇文章的两个目的如下。image.png目的一：将TestInterface接口放入Spring的工厂中.@ComponentpublicinterfaceTestInt
    
                    
    • 
                    
  • 【Spring框架】Spring事务同步
                        小七mod
Java#Spring数据库SpringSpring事务事务同步Java事务
                        
    目录一、什么是Spring事务同步二、事务同步管理器2.1TransactionSynchronizationManager事务同步管理器2.1.1资源同步2.1.2事务同步2.1.3总结三、事务同步管理器保障事务的原理四、spring事务为何使用TransactionSynchronizationManagerspring源码实现五、TransactionSynchronization--(be
    
                    
    • 
                    
  • 浅谈SpringMVC执行过程
                        程序员日常填坑

                        
    通过深入分析Spring源码，我们知道Spring框架包括大致六大模块，如Web模块，数据库访问技术模块，面向切面模块，基础设施模块，核心容器模块和模块，其中，在Spring框架的Web模块中，又包含很多前端技术，如SpringMVC,SpringWebSocket,SpringWebPortlet等，在本篇文章中，我们主要分析SpringMVC模块，在分析SpringMVC技术时，本篇文章将通过
    
                    
    • 
                    
  • 手写Spring之BeanFactory(三级缓存)
                        pq217

                        
    概述看了好久spring源码，有些地方理解的不深刻，决定手写一下BeanFactory来加深理解规范spring中最主要的bean工厂实现就是DefaultListableBeanFactory，看一下它实现的接口publicclassDefaultListableBeanFactoryextendsAbstractAutowireCapableBeanFactoryimplementsConfi
    
                    
    • 
                    
  • 专治不会看源码的毛病--spring源码解析AOP篇
                        八年码农

                        
    公众号编程一生昨天有个大牛说我啰嗦，眼光比较细碎，看不到重点。太他爷爷的有道理了！要说看人品，还是女孩子强一些。原来记得看到一个男孩子的抱怨，说怎么两人刚刚开始在一起，女孩子在心里就已经和他过完了一辈子。哥哥们，不想这么远行吗？看看何洁，看看带着俩娃跳楼的妈妈。所以现在的女孩子是很明白的，有些男孩子个子不高，其貌不扬，但是一看那人品气质就知道能找个不错的女盆友。不过要说看人的技术能力，男孩子确实更
    
                    
    • 
                    
  • Spring源码剖析（二） - Bean对象的三级缓存
                        Jasper_Chen

                        
    前面讲到Spring在创建Bean的过程中使用了三级缓存来对Bean对象进行缓存。这个三级缓存是用来解决对象的循环依赖问题。什么是对象的循环依赖？举个例子：classA{privateBb;privateCc;}classB{privateAa;}classC{privateAa;}classA中引用了B和C，而B和C中又引用了A。那么在spring中创建Bean对象时，需要先创建对象，然后对其属
    
                    
    • 
                    
  • 联合使用Spring的@Transactional和@Async注解的思考
                        API调用Engineer
Programmingspringjava后端
                        
    背景在工作过程中因为一些特殊的原因，想通过@Transactional和@Async注解来实现特殊的业务场景。不过在使用的过程中遇到了一些出乎意料的情况，也是因为对Spring源码框架的不熟悉，在经过几天的断点调试和csdn结合的方式终于梳理清楚遇到的问题的脉络，以及产生意料之外情况的原因。故在此做一个总结，以及分享一下学习到的相关知识点。至于为什么要联合使用@Transactional和@Asy
    
                    
    • 
                    
  • idea搭建spring5.3.x源码环境
                        泗水长流
springspring5.3.x源码gradle安装配置spring5.3.x源码环境spring源码搭建
                        
    1.写在前面的话碰到了不少想阅读或者学习spring源码的同学，但是第一步搭建这个源码阅读环境就能难倒了一大批人。下面我就以spring5.3.x这个源码分支，来具体演示一下搭建过程。2.下载源码下载源码这一步，说实话，由于某些原因，会导致我们用git做clone的时候，老是中断，clone不下来。所以我们可以先把github的源码，复制到gitee上，然后从gitee上来下载。打开spring的
    
                    
    • 
                    
  • spring源码之IOC容器资源定位过程
                        rofeya

                        
    铺垫平时我们在使用spring进行项目实践的时候，对于底层的某些实现逻辑大部分都被忽略过，但是对底层实现的了解却往往是我们在实践中解决出现的问题最有利的帮助。以下是我阅读源码进行并整理的一些学习笔记。准备工作在开发环境中构建自己的spring源码环境，本人是使用IDEA开发工具，构建步骤网上一搜一大把，下面就附上一个在IDEA搭建spring源码环境的链接：https://blog.csdn.ne
    
                    
    • 
                    
  • 自己整理的一些关于Spring源码的总结，面试之前回来看看（不定期更新）
                        学到头冷

                        
    Spring中的设计模式？1.工厂2.单例（看看内部枚举实现的单例）3.委派（delegate）4.模板方法（refresh方法算一个）5.策略模式6.访问者模式7.责任链模式（beanPostProcess这些后置处理器执行）Spring事务是怎么运作的？待更新Spring中的obtainfreshbeanfactory？（XML方式BeanDefinition如何注册）1.newDefault
    
                    
    • 
                    
  • Spring源码深度解析：十三、JdbcTemplate 的源码分析
                        代码的知行者
Spring源码springjava后端
                        
    一、前言文章目录：Spring源码深度解析：文章目录二、JdbcTemplateJdbcTemplate是SpringTemplate设置模式中的一员。类似的还有TransactionTemplate、MongoTemplate等。通过JdbcTemplate我们可以使得Spring访问数据库的过程简单化。在JdbcTemplate中执行SQL语句的方法大致分为3类：execute：可以执行所有S
    
                    
    • 
                                
  • apache ftpserver-CentOS config
                                    gengzg
apache
                                    
    <server xmlns="http://mina.apache.org/ftpserver/spring/v1"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
       http://mina.apache.o
    
                                
    • 
                                
  • 优化MySQL数据库性能的八种方法
                                    AILIKES
sqlmysql
                                    
    1、选取最适用的字段属性 　　MySQL可以很好的支持大数据量的存取，但是一般说来，数据库中的表越小，在它上面执行的查询也就会越快。因此，在创建表的时候，为了获得更好的 性能，我们可以将表中字段的宽度设得尽可能小。例如，在定义邮政编码这个字段时，如果将其设置为CHAR(255),显然给数据库增加了不必要的空间，甚至使用VARCHAR这种类型也是多余的，因为CHAR(6)就可以很
    
                                
    • 
                                
  • JeeSite 企业信息化快速开发平台
                                    Kai_Ge
JeeSite
                                    
    JeeSite 企业信息化快速开发平台  
平台简介 
JeeSite是基于多个优秀的开源项目，高度整合封装而成的高效，高性能，强安全性的开源Java EE快速开发平台。 
JeeSite本身是以Spring Framework为核心容器，Spring MVC为模型视图控制器，MyBatis为数据访问层， Apache Shiro为权限授权层，Ehcahe对常用数据进行缓存，Activit为工作流
    
                                
    • 
                                
  • 通过Spring Mail Api发送邮件
                                    120153216
邮件main
                                    
    原文地址：http://www.open-open.com/lib/view/open1346857871615.html 
使用Java Mail API来发送邮件也很容易实现，但是最近公司一个同事封装的邮件API实在让我无法接受，于是便打算改用Spring Mail API来发送邮件，顺便记录下这篇文章。 【Spring Mail API】 
Spring Mail API都在org.spri
    
                                
    • 
                                
  • Pysvn 程序员使用指南
                                    2002wmj
SVN
                                    
    源文件:http://ju.outofmemory.cn/entry/35762 
这是一篇关于pysvn模块的指南. 
完整和详细的API请参考 http://pysvn.tigris.org/docs/pysvn_prog_ref.html. 
pysvn是操作Subversion版本控制的Python接口模块. 这个API接口可以管理一个工作副本, 查询档案库, 和同步两个. 
该
    
                                
    • 
                                
  • 在SQLSERVER中查找被阻塞和正在被阻塞的SQL
                                    357029540
SQL Server
                                    
    SELECT  R.session_id AS BlockedSessionID ,  
        S.session_id AS BlockingSessionID ,  
        Q1.text AS Block
    
                                
    • 
                                
  • Intent 常用的用法备忘
                                    7454103
.netandroidGoogleBlogF#
                                    
    Intent 
    应该算是Android中特有的东西。你可以在Intent中指定程序 要执行的动作（比如：view,edit,dial），以及程序执行到该动作时所需要的资料 。都指定好后，只要调用startActivity()，Android系统 会自动寻找最符合你指定要求的应用 程序，并执行该程序。 
 
下面列出几种Intent 的用法 
显示网页: 
 

    
                                
    • 
                                
  • Spring定时器时间配置
                                    adminjun
spring时间配置定时器
                                    
    红圈中的值由6个数字组成，中间用空格分隔。第一个数字表示定时任务执行时间的秒，第二个数字表示分钟，第三个数字表示小时，后面三个数字表示日，月，年，< xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" />  
测试的时候，由于是每天定时执行，所以后面三个数
    
                                
    • 
                                
  • POJ 2421 Constructing Roads 最小生成树
                                    aijuans
最小生成树
                                    
    来源：http://poj.org/problem?id=2421 
题意：还是给你n个点，然后求最小生成树。特殊之处在于有一些点之间已经连上了边。 
思路：对于已经有边的点，特殊标记一下，加边的时候把这些边的权值赋值为0即可。这样就可以既保证这些边一定存在，又保证了所求的结果正确。 
代码： 
 
#include <iostream>
#include <cstdio>
    
                                
    • 
                                
  • 重构笔记——提取方法（Extract Method）
                                    ayaoxinchao
java重构提炼函数局部变量提取方法
                                    
    提取方法（Extract Method）是最常用的重构手法之一。当看到一个方法过长或者方法很难让人理解其意图的时候，这时候就可以用提取方法这种重构手法。 
  
下面是我学习这个重构手法的笔记： 
  
提取方法看起来好像仅仅是将被提取方法中的一段代码，放到目标方法中。其实，当方法足够复杂的时候，提取方法也会变得复杂。当然，如果提取方法这种重构手法无法进行时，就可能需要选择其他
    
                                
    • 
                                
  • 为UILabel添加点击事件
                                    bewithme
UILabel
                                    
        默认情况下UILabel是不支持点击事件的，网上查了查居然没有一个是完整的答案，现在我提供一个完整的代码。 
  
  UILabel *l = [[UILabel alloc] initWithFrame:CGRectMake(60, 0, listV.frame.size.width - 60, listV.frame.size.height)]
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(PHP-REDIS实例)
                                    bijian1013
redis数据库NoSQL
                                    
    一.redis.php 
<?php
      //实例化
      $redis = new Redis();
      //连接服务器
      $redis->connect("localhost");
      //授权
      $redis->auth("lamplijie");
      //相关操
    
                                
    • 
                                
  • SecureCRT使用备注
                                    bingyingao
secureCRT每页行数
                                    
    SecureCRT日志和卷屏行数设置 
 
一、使用securecrt时，设置自动日志记录功能。 
 
1、在C:\Program Files\SecureCRT\下新建一个文件夹(也就是你的CRT可执行文件的路径），命名为Logs； 
 
2、点击Options -> Global Options -> Default Session -> Edite Default Sett
    
                                
    • 
                                
  • 【Scala九】Scala核心三：泛型
                                    bit1129
scala
                                    
    泛型类 
package spark.examples.scala.generics

class GenericClass[K, V](val k: K, val v: V) {
  def print() {
    println(k + "," + v)
  }
}

object GenericClass {
  def main(args: Arr
    
                                
    • 
                                
  • 素数与音乐
                                    bookjovi
素数数学haskell
                                    
        由于一直在看haskell，不可避免的接触到了很多数学知识，其中数论最多，如素数，斐波那契数列等，很多在学生时代无法理解的数学现在似乎也能领悟到那么一点。 
    闲暇之余，从图书馆找了<<The music of primes>>和<<世界数学通史>>读了几遍。其中素数的音乐这本书与软件界熟知的&l
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-IdentityHashMap
                                    BrokenDreams
Collections
                                    
            这篇总结一下java.util.IdentityHashMap。从类名上可以猜到，这个类本质应该还是一个散列表，只是前面有Identity修饰，是一种特殊的HashMap。 
        简单的说，IdentityHashMap和HashM
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-享元模式-Flyweight
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 



import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java
    
                                
    • 
                                
  • PS人像润饰&调色教程集锦
                                    cherishLC
PS
                                    
      1、仿制图章沿轮廓润饰——柔化图像，凸显轮廓 
 
http://www.howzhi.com/course/retouching/ 
  新建一个透明图层，使用仿制图章不断Alt+鼠标左键选点，设置透明度为21%，大小为修饰区域的1/3左右（比如胳膊宽度的1/3），再沿纹理方向（比如胳膊方向）进行修饰。 
  所有修饰完成后，对该润饰图层添加噪声，噪声大小应该和
    
                                
    • 
                                
  • 更新多个字段的UPDATE语句
                                    crabdave
update
                                    
    更新多个字段的UPDATE语句 
  
                 
                update tableA a
                   set (a.v1, a.v2, a.v3, a.v4) =   --使用括号确定更新的字段范围
          
    
                                
    • 
                                
  • hive实例讲解实现in和not in子句
                                    daizj
hivenot inin
                                    
    本文转自：http://www.cnblogs.com/ggjucheng/archive/2013/01/03/2842855.html 
 
 
当前hive不支持 in或not in 中包含查询子句的语法，所以只能通过left join实现。 
 
假设有一个登陆表login(当天登陆记录,只有一个uid),和一个用户注册表regusers(当天注册用户，字段只有一个uid)，这两个表都包含
    
                                
    • 
                                
  • 一道24点的10+种非人类解法（2,3,10,10）
                                    dsjt
算法
                                    
    这是人类算24点的方法？！！！ 
 
事件缘由：今天晚上突然看到一条24点状态，当时惊为天人，这NM叫人啊？以下是那条状态 
 
朱明西 : 24点，算2 3 10 10，我LX炮狗等面对四张牌痛不欲生，结果跑跑同学扫了一眼说，算出来了，2的10次方减10的3次方。。我草这是人类的算24点啊。。 
 
然后么。。。我就在深夜很得瑟的问室友求室友算 
 
刚出完题，文哥的暴走之旅开始了 
 
5秒后
    
                                
    • 
                                
  • 关于YII的菜单插件 CMenu和面包末breadcrumbs路径管理插件的一些使用问题
                                    dcj3sjt126com
yiiframework
                                    
    在使用 YIi的路径管理工具时，发现了一个问题。                    <?php         
    
                                
    • 
                                
  • 对象与关系之间的矛盾：“阻抗失配”效应[转]
                                    come_for_dream
对象
                                    
    概述 
  
“阻抗失配”这一词组通常用来描述面向对象应用向传统的关系数据库（RDBMS）存放数据时所遇到的数据表述不一致问题。C++程序员已经被这个问题困扰了好多年，而现在的Java程序员和其它面向对象开发人员也对这个问题深感头痛。 
  
“阻抗失配”产生的原因是因为对象模型与关系模型之间缺乏固有的亲合力。“阻抗失配”所带来的问题包括：类的层次关系必须绑定为关系模式（将对象
    
                                
    • 
                                
  • 学习编程那点事
                                    gcq511120594
编程互联网
                                    
    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 
接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
    
                                
    • 
                                
  • Reverse Linked List II
                                    hcx2013
list
                                    
    Reverse a linked list from position m to n. Do it in-place and in one-pass. 
For example:Given 1->2->3->4->5->NULL, m = 2 and n = 4, 
return 
    
                                
    • 
                                
  • Spring4.1新特性——页面自动化测试框架Spring MVC Test HtmlUnit简介
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • Hadoop集群工具distcp
                                    liyonghui160com

                                    
      
  
1. 环境描述 
两个集群：rock 和 stone 
rock无kerberos权限认证，stone有要求认证。 
1. 从rock复制到stone，采用hdfs 
Hadoop distcp -i hdfs://rock-nn:8020/user/cxz/input hdfs://stone-nn:8020/user/cxz/运行在rock端，即源端问题：报版本
    
                                
    • 
                                
  • 一个备份MySQL数据库的简单Shell脚本
                                    pda158
mysql脚本
                                    
    　　主脚本（用于备份mysql数据库）：   　　该Shell脚本可以自动备份 
数据库。只要复制粘贴本脚本到文本编辑器中，输入数据库用户名、密码以及数据库名即可。我备份数据库使用的是mysqlump 命令。后面会对每行脚本命令进行说明。   　　 
1. 分别建立目录“backup”和“oldbackup”   　　#mkdir /backup   　　#mkdir /oldbackup   　
    
                                
    • 
                                
  • 300个涵盖IT各方面的免费资源（中）——设计与编码篇
                                    shoothao
IT资源图标库图片库色彩板字体
                                    
     
 A. 免费的设计资源 
 
 
  Freebbble:来自于Dribbble的免费的高质量作品。 
  Dribbble:Dribbble上“免费”的搜索结果——这是巨大的宝藏。 
  Graphic Burger:每个像素点都做得很细的绝佳的设计资源。 
  Pixel Buddha:免费和优质资源的专业社区。 
  Premium Pixels:为那些有创意的人提供免费的素材。 
  
    
                                
    • 
                                
  • thrift总结 - 跨语言服务开发
                                    uule
thrift
                                    
    官网 
官网JAVA例子 
thrift入门介绍 
IBM-Apache Thrift - 可伸缩的跨语言服务开发框架 
Thrift入门及Java实例演示 
thrift的使用介绍 
  
RPC  
  
POM： 
<dependency>
  <groupId>org.apache.thrift</groupId>
  
    
                                
    •