码上遇见你
码上遇见你

一文带你解读Spring5源码解析 IOC之开启Bean的加载，以及FactoryBean和BeanFactory的区别。

前言

通过往期的文章我们已经了解了Spring对XML配置文件的解析，将分析的信息组装成BeanDefinition，并将其保存到相应的BeanDefinitionRegistry中，至此Spring IOC的初始化工作已经完成，这篇文章主要对Bean的加载进行一个深入的了解及探索。

想要了解Bean就必要要知道接口BeanFactory，接下来我们就从BeanFactory切入

BeanFactory

我们在调用getBean()方法时，无论是显示调用还是隐式调用。都会触发Bean加载的阶段。demo如下：

@Test
public void Test(){
	//使用BeanFactory方式加载XML.
	BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
	MyTestBean myTestBean = (MyTestBean) beanFactory.getBean("myTestBean");
	System.out.println(myTestBean.getName());
}

实际上这个getBean方法是在接口BeanFactory中定义的。我们先看一下BeanFactory的类图：

一文带你解读Spring5源码解析 IOC之开启Bean的加载，以及FactoryBean和BeanFactory的区别。_第1张图片

根据如上类图最一个简单的整理：

  • BeanFactory作为一个主接口不继承实现任何接口，我们可以定义为一级接口。

  • 有3个子接口都继承了它，进行功能上的增强，这3个子接口我们可以定义为二级接口。

  • ConfiguratbleBeanFactory我们可以定义为三级接口，对二级接口HierarchicalBeanFactory，进行再次增强。它还继承了另外一个接口SingletomBeanRegistry

  • ConfigurableListableBeanFactory是一个更强大的接口，继承了上述的所有接口，无所不包，我们可以定义为四级接口，(这4级接口是BeanFactory的基本接口体系，继续，下面是继承关系的2个抽象类和2个实现类)

  • AbstractBeanFactory作为一个抽象类，实现了三级接口ConfigurableBe·anFactory

  • AbstractAutowireCapableBeanFactory同样是抽象类继承自AbstractBeanFactory，并额外实现了二级接口AutowireCapableBeanFactory

  • DefaultListableBeanFactory继承自AbstractAutowireCapableBeanFactory实现了强大的四级接口ConfigurableListableBeanFactory，并实现了一个外来接口BeanDefinitionRegistry，它并非抽象类。

  • 最后就是强大的XmlBeanFactory继承自DefaultListableBeanFactory，重写了一些功能，是自己更强大。

一文带你解读Spring5源码解析 IOC之开启Bean的加载，以及FactoryBean和BeanFactory的区别。_第2张图片

BeanFactory，以Factory结尾，表示它是一个工厂类(接口)，它负责生产和管理Bean的一个工厂。在Spring中，BeanFactory是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。BeanFactory只是一个接口，并不是IOC的具体实现，但Spring容器给出了很多种实现，如：DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等，其中XmlBeanFactory就是常用的一个，该实现将以XML方式描述组件应用的对象及对象之间的依赖关系。XmlBeanFactory类将持有此Xml配置元数据，并用它来构建一个完全可配置的系统或应用。

BeanFactory是Spring IOC容器的鼻祖，是IOC容器的基础接口，所有的容器都是从它这里继承实现而来的。可以见其地位是多么重要。BeanFactory提供了最基本的IOC容器的功能，即所有的容器至少需要实现的标准。

XmlBeanFactory，只是提供了最基本的IOC容器的功能。而且XmlBeanFactory继承自DefaultListableBeanFactory。DefaultListableBeanFactory实际包含了基本IOC容器所具有的所有重要功能，是一个完整的IOC容器

ApplicationContext包含了BeanFactory的所有功能，通常建议比BeanFactory优先。

BeanFactory体系结构是典型的工厂方法模式，即什么样的工厂生产什么样的产品。BeanFactory是最基本的抽象工厂，而其它的IOC容器只不过是具体的工厂，对应着各自的Bean定义方法。但同时，其它容器也针对具体场景不同，进行了扩充，提供了具体的服务，如下：

// 1
Resource resource = new FileSystemResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);
// 2
ClassPathResource resource = new ClassPathResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);
// 3
ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"applicationContext.xml"});
BeanFactory factory = (BeanFactory) context;

大概就是这些了，接着使用getBean(String beanName)方法取得bean的实例；BeanFactory提供的方法极其简单，仅仅提供了六种方法供客户调用：

  • boolean containsBean(String name);判断工厂中是否包含了给定名称的Bean定义，若有则返回true
  • Object getBean(String name);返回给定名称注册的bean实例。根据Bean的配置情况，如果是singleton模式将返回一个共享的实例，否则将返回一个新建的实例，如果没有找到指定Bean，该方法会抛出异常(BeansException)。
  • < T> T getBean(String name, Class requiredType) ;返回给定名称注册的Bean实例，并转换为给定class类型。
  • boolean isSingleton(String name); 判断给定名称的Bean定义是否是单例模式。
  • Class getType(String name); 返回给定名称的Bean的Class，如果没有找到指定的Bean实例，则抛出NoSuchBeanDefinitionException异常。
  • String[] getAliases(String name); 返回给定名称Bean的所有别名。

我们大致看一下BeanFactory源码里的所有方法。

public interface BeanFactory {
	String FACTORY_BEAN_PREFIX = "&";
	Object getBean(String name) throws BeansException;
	 T getBean(String name, Class requiredType) throws BeansException;
	Object getBean(String name, Object... args) throws BeansException;
	 T getBean(Class requiredType) throws BeansException;
	 T getBean(Class requiredType, Object... args) throws BeansException;
	 ObjectProvider getBeanProvider(Class requiredType);
	 ObjectProvider getBeanProvider(ResolvableType requiredType);
	Boolean containsBean(String name);
	Boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
	Boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
	Boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
	Boolean isTypeMatch(String name, Class typeToMatch) throws NoSuchBeanDefinitionException;
	@Nullable
	Class getType(String name) throws NoSuchBeanDefinitionException;
	@Nullable
	Class getType(String name, Boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
	String[] getAliases(String name);
}

FactoryBean

概述：一一般情况下，Spring通过反射机制利用< bean>的class属性指定实现类实例化Bean，在某些情况下，实例化Bean的过程比较复杂，如果按照传统的方式，则需要在< bean>中提供大量的配置信息；配置方式的灵活性是受限的，这是采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.beans.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑。FactoryBean接口对于Spring框架来说占有重要的地位，Spring自身就提供了70多个Factory Bean的实现，它们隐藏实例化一些复杂Bean的细节，给上层应用带来了便利，从Spring3.0开始，FactoryBean开始支持泛型，即接口声明改为FactoryBean< T>的形式。

以Bean结尾，表示它是一个Bean，不同于普通Bean的是：它实现了FactoryBean< T> 接口的Bean，根据该Bean的ID从BeanFactory中获取的实际上是FactoryBean的getObject()返回的对象，而不是FactoryBean本身，如果想要获取FactoryBean对象，请在id前面加一个&符号来获取。

  • 看源码(FactoryBean.java)
public interface FactoryBean {
	String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
	@Nullable
	T getObject() throws Exception;
	@Nullable
	Class getObjectType();
	default Boolean isSingleton() {
		return true;
	}
}

从上述源码中我们可以看到，该接口一共定义了3个方法：

  • T getObject() throws Exception; 返回由FactoryBean创建的Bean实例，如果isSingleton()返回true，则该实例会放到Spring容器中单例实例缓存池中；
  • Class getObjectType(); 返回FactoryBean创建的Bean实例；
  • default boolean isSingleton() { return true;} 返回FactoryBean创建的Bean实例的作用域是singleton还是prototype；

补充：当配置文件中< bean>的class属性配置的实现类是FactoryBean时，通过getBean()方法返回的不是FactoryBean本身，而是FactoryBean中的getObject()方法所返回的对象，相当于FactoryBean的getObject()代理了getBean()方法。

例如：如果使用传统方式配置下面的Car的< bean>时，Car的每个属性分别对应一个< property>元素标签。

public class Car {
	private int maxSpeed ;
	private String brand ;
	private double price ;
	//get//set 方法
}

如果使用FactoryBean的方式实现的话就比较灵活，下例通过逗号的分割的方式一次性为Car的所有属性指定配置值。

import  org.springframework.beans.factory.FactoryBean;
public  class CarFactoryBean implements  FactoryBean {
	private String carInfo ;
	public  Car getObject()  throws  Exception  {
		Car car = new  Car();
		String[] infos = carInfo.split(",");
		car.setBrand(infos[0]);
		car.setMaxSpeed(Integer.valueOf(infos[1]));
		car.setPrice(double.valueOf(infos[2]));
		return  car;
	}
	public  Class getObjectType(){
		return Car.class ;
	}
	public Boolean isSingleton(){
		return false ;
	}
	public String getCarInfo(){
		return  this.carInfo;
	}
	//接受逗号分割符设置属性信息  
	public void setCarInfo (String carInfo){
		this.carInfo = carInfo;
	}
}

根据上述的CarFactoryBean，在配置文件中使用如下的方式进行配置

当调用getBean("car")时，Spring通过反射机制发现CarFactoryBean实现了FactoryBean的接口，这时Spring容器就调用接口方法CarFactoryBean的getObject()方法返回。如果希望获取CarFactoryBean的实例，则需要在使用getBean(BeanName)方法时在BeanName前面加上"&"前缀：比如：getBean("&car");

获取Bean

接下来我们继续回到文章一开始讲的bean的加载阶段，当我们显式或隐式调用getBean()时，则会触发加载Bean的阶段，具体实现如下：

  • 看源码(AbstractBeanFactory.java)
@Override
public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

getBean()方法内部又调用了dogetBean()方法：

  • 看源码(AbstractBeanFactory.java)
protected  T doGetBean(
			String name, @Nullable Class requiredType, @Nullable Object[] args, Boolean typeCheckOnly)
			throws BeansException {
	// 获取 beanName，这里是一个转换动作，将 name 转换为 beanName
	String beanName = transformedBeanName(name);
	Object beanInstance;
	/*
			检查缓存中的实例工程是否存在对应的bean实例。
			为何要优先使用这段代码呢？
				因为在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，Spring创建Bean的原则是在不等Bean创建完就会将
				创建Bean的 objectFactory 提前曝光，即将其加入到缓存中，一旦下一个 Bean 创建时依赖上一个Bean则直接使用 objectFactory，直接
			从缓存中或 singletonFactories 获取 objectFactory
				就算没有循环依赖，只是单纯的依赖注入，如：B依赖A，如果A已经初始化完成，B进行初始化时，需要递归调用getBean()获取去A，这时A已经在
				缓存里了，可以直接在这里获取到。
		 */
	// Eagerly check singleton cache for manually registered singletons.
	Object sharedInstance = getSingleton(beanName);
	if (sharedInstance != null && args == null) {
		if (logger.isTraceEnabled()) {
			if (isSingletonCurrentlyInCreation(beanName)) {
				logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
											"' that is not fully initialized yet - a consequence of a circular reference");
			} else {
				logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
			}
		}
		// 返回对应的实例，有些时候并不是直接返回实例，而是返回某些方法返回的实例
		/*
			 这里涉及到我们上面讲的FactoryBean，如果此 Bean 是 FactoryBean 的实现类，如果name前缀为 "&"，则直接返回此实现类的Bean，如果
			  没有前缀，则需要调用此实现类的getObject方法，返回getObject里真实的返回对象。
			 */
		beanInstance = 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.
		// 尝试从 parentBeanFactory 中查找 bean
		BeanFactory parentBeanFactory = getParentBeanFactory();
		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
			// Not found -> check parent.
			String nameToLookup = originalBeanName(name);
			if (parentBeanFactory instanceof AbstractBeanFactory) {
				return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
											nameToLookup, requiredType, args, typeCheckOnly);
			} else if (args != null) {
				// Delegation to parent with explicit args.
				return (T) parentBeanFactory.getBean(nameToLookup, args);
			} else if (requiredType != null) {
				// No args -> delegate to standard getBean method.
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			} else {
				return (T) parentBeanFactory.getBean(nameToLookup);
			}
		}
		// 如果不是仅仅做类型检查，则这里需要创建bean，并做记录
		if (!typeCheckOnly) {
			markBeanAsCreated(beanName);
		}
		StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
							.tag("beanName", name);
		try {
			if (requiredType != null) {
				beanCreation.tag("beanType", requiredType::toString);
			}
			// 将存储XML配置文件的GenericBeanDefinition转换成RootBeanDefinition，同时如果存在父Bean合并父Bean的相关属性
			RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
			checkMergedBeanDefinition(mbd, beanName, args);
			// Guarantee initialization of beans that the current bean depends on.
			// 如果存在依赖，则需要递归实例化依赖的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 new BeanCreationException(mbd.getResourceDescription(), beanName,
															"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
					}
				}
			}
			// Create bean instance.
			// 单例模式的Bean
			if (mbd.isSingleton()) {
				// 实例化依赖的Bean后对Bean本身进行实例化
				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;
					}
				}
				);
				beanInstance = 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);
				}
				beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
			}
			// 从指定的 scope 模式下创建 Bean else {
				String scopeName = mbd.getScope();
				if (!StringUtils.hasLength(scopeName)) {
					throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
				}
				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);
						}
					}
					);
					beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
				}
				catch (IllegalStateException ex) {
					throw new ScopeNotActiveException(beanName, scopeName, ex);
				}
			}
		}
		catch (BeansException ex) {
			beanCreation.tag("exception", ex.getClass().toString());
			beanCreation.tag("message", String.valueOf(ex.getMessage()));
			cleanupAfterBeanCreationFailure(beanName);
			throw ex;
		}
		finally {
			beanCreation.end();
		}
	}
	return adaptBeanInstance(name, beanInstance, requiredType);
}

@SuppressWarnings("unchecked")
 T adaptBeanInstance(String name, Object bean, @Nullable Class requiredType) {
	// Check if required type matches the type of the actual bean instance.
	if (requiredType != null && !requiredType.isInstance(bean)) {
		try {
			Object convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
			if (convertedBean == null) {
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
			return (T) convertedBean;
		}
		catch (TypeMismatchException ex) {
			if (logger.isTraceEnabled()) {
				logger.trace("Failed to convert bean '" + name + "' to required type '" +
											ClassUtils.getQualifiedName(requiredType) + "'", ex);
			}
			throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
		}
	}
	return (T) bean;
}

dogetBean()方法的源码时相当的长，一共包含了两部分，也可以说是一部分，接下来：进行拆分讲解：

1. 获取BeanName
  • 看源码(AbstractBeanFactory.java)
// 获取 beanName，这里是一个转换动作，将 name 转换为 beanName
String beanName = transformedBeanName(name);

protected String transformedBeanName(String name) {
	return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
  • 源码分析

这里要注意传递的name，不一定就是beanName，也有可能是aliasName 别名，也有可能是FactoryBean(带有”&“前缀)，因此这里需要调用transformeBeanName()进行一下转换，主要内容如下：

  • 看源码(BeanFactoryUtils.java)
public static String transformedBeanName(String name) {
	// 这个方法主要是去掉FactoryBean的修饰符 &
	Assert.notNull(name, "'name' must not be null");
	if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
		return name;
	}
	return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
		do {
			beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
		}
		while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
		return beanName;
	}
	);
}

对aliasName别名的转换

public String canonicalName(String name) {
	// 这个方法是转换aliasName
	String canonicalName = name;
	// Handle aliasing...
	String resolvedName;
	do {
		resolvedName = this.aliasMap.get(canonicalName);
		if (resolvedName != null) {
			canonicalName = resolvedName;
		}
	}
	while (resolvedName != null);
	return canonicalName;
}
  • 源码分析

上述的处理过程大致可以分为两步：

  1. 去除FactoryBean的修饰符，如果name以"&"为前缀，那么会去掉"&"，例如：name="&testService"，去除之后的结果是name=”testService“
  2. 取出指定的alias所表示的最终的beanName，主要是一个循环beanName的过程，例如别名A指向名称为B的bean则返回B，若别名A指向别名B，别名B指向名称为C的bean，则返回C。
缓存中获取单例Bean

单例在Spring的同一个容器中只会被创建一次，后续再获取Bean直接从单例缓存中获取即可，当然这里也只是尝试加载，首先尝试先从缓存中加载，然后再次从singletonFactory加载；因为在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，Spring创建bean的原则是不等bean创建完成就会创建bean的ObjectFactory提早曝光加入到缓存中，一旦下一个bean创建时需要依赖上个bean，则直接使用ObejectFactory；就算没有循环依赖，只是单纯的依赖注入，如：B依赖A，如果A已经初始化完成，B进行初始化时，需要递归调用getBean()获取A，这时A已经在缓存里面了，直接可以从缓存里面获取到，接下来我们看获取单例bean的方法：

Object sharedInstance = getSingleton(beanName);

  • 看源码(DefaultSingletonBeanRegistry.java)
@Override
@Nullable
public Object getSingleton(String beanName) {
	// 参数true，代表允许早期依赖
	return getSingleton(beanName, true);
}

@Nullable
protected Object getSingleton(String beanName, Boolean allowEarlyReference) {
	// Quick check for existing instance without full singleton lock
	// 检查缓存中是否存在实例，这里就是说上面的单纯的依赖注入，假设B依赖A，如果A已经初始化完成，B进行初始化时，需要递归调用getBean获取A，这时
	// A已经在缓存里面了，直接可以从缓存中获取到。
	Object singletonObject = this.singletonObjects.get(beanName);
	// 如果缓存为空，且单例Bean正在创建中，则锁定全局变量，
	// 为什么要判断单例Bean是否在创建中呢？
	// 		这里就是可以判断是否是循环依赖了。
	//		A依赖B，B也依赖A，A实例化的时候发现依赖B，则递归去实例化B；B又发现依赖A，则递归实例化A。这个时候就会回到原点A的实例化，第一次A的
	//		实例化还没有完成，只不过是把实例化的对象加入到缓存中了，但是状态还是正在创建中。由此回到原点A发现A正在创建中，便可以根据此来判断这
	//		是循环依赖了
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		// 尝试从 earlySingletonObjects 里面获取 如果此Bean正在加载，则不对其进行处理
		singletonObject = this.earlySingletonObjects.get(beanName);
		if (singletonObject == null && allowEarlyReference) {
			synchronized (this.singletonObjects) {
				// Consistent creation of early reference within full singleton lock
				// 尝试从singletonObjects里面获取实例
				singletonObject = this.singletonObjects.get(beanName);
				if (singletonObject == null) {
					// 当某些方法需要提前初始化的时候会直接调用 addSingletonFactory 把对应的 ObjectFactory 初始化策略 存储在
					// singletonFactories中。
					singletonObject = this.earlySingletonObjects.get(beanName);
					if (singletonObject == null) {
						ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
						if (singletonFactory != null) {
							// 使用预先设定的getObject方法
							singletonObject = singletonFactory.getObject();
							this.earlySingletonObjects.put(beanName, singletonObject);
							this.singletonFactories.remove(beanName);
						}
					}
				}
			}
		}
	}
	return singletonObject;
}
  • 源码分析

我们对上述方法进行一个简单的梳理，

首先该方法先从singletonObjects里获取实例；

如果获取不到会从earlySingletonObjects里面获取实例；

如果还是获取不到，再次尝试从singletonFactories里面获取beanName对应的ObjectFactory，并从singletonFactories里面remove掉这个ObjectFactory，而对于后续所有的内存操作都只为了循环依赖检测时候使用，即allowEarlyReference为true时才会使用。

以上代码涉及到了很多个存储bean的不同Map：

singletonObjects：用于保存BeanName和创建Bean实例之间的关系，beanName->bean Instance

singletonFactories：用于保存BeanName和创建Bean的工厂之间的联系，beanName->ObjectFactory

earlySingletonObjects：同样也是用于保存BeanName和创建Bean实例之间的关系，与singletonObjects的不同之处在于：当一个单例bean被放到这里面后，那么当bean还在创建过程中，就可以通过getBean方法获取到了，其目的是用来检测循环依赖的引用。

registeredSingletons：用来保存当前所有已经注册的bean。

从bean的实例中获取对象

获取到bean以后就要获取实例对象了，这里用到的时getObjectForBeanInstance方法。getObjectForBeanInstance是一个频繁使用的方法，无论是从缓存中获取bean还是根据不同的scope策略加载Bean；总之，我们得到bean的实例后，要做的第一步就是调用这个方法来检测一下正确性，其实就是检测获得的Bean是不是FactoryBean类型的bean，

如果是那么需要调用该bean对应的FactoryBean实例中的getObject()作为返回值。

  • 看源码(AbstractBeanFactory.java)
protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
	// Don't let calling code try to dereference the factory if the bean isn't a factory.
	// 如果指定的name 是工厂相关的
	if (BeanFactoryUtils.isFactoryDereference(name)) {
		// 如果是 NullBean 则直接返回此Bean
		if (beanInstance instanceof NullBean) {
			return beanInstance;
		}
		// 如果不是FactoryBean 类型，则直接抛出异常
		if (!(beanInstance instanceof FactoryBean)) {
			throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
		}
		if (mbd != null) {
			mbd.isFactoryBean = true;
		}
		return beanInstance;
	}
	// Now we have the bean instance, which may be a normal bean or a FactoryBean.
	// If it's a FactoryBean, we use it to create a bean instance, unless the
	// caller actually wants a reference to the factory.
	// 如果获取的beanInstance不是FactoryBean类型，说明是普通的Bean，可直接返回
	// 如果获取的beanInstance是FactoryBean 类型，但是是以&开头，也可直接返回，此时返回的是FactoryBean实例
	if (!(beanInstance instanceof FactoryBean)) {
		return beanInstance;
	}
	Object object = null;
	if (mbd != null) {
		mbd.isFactoryBean = true;
	} else {
		object = getCachedObjectForFactoryBean(beanName);
	}
	if (object == null) {
		// Return bean instance from factory.
		FactoryBean factory = (FactoryBean) beanInstance;
		// Caches object obtained from FactoryBean if it is a singleton.
		if (mbd == null && containsBeanDefinition(beanName)) {
			mbd = getMergedLocalBeanDefinition(beanName);
		}
		Boolean synthetic = (mbd != null && mbd.isSynthetic());
		// 到这里说明了获取的beanInstance是FactoryBean类型的，但是没有以&开头，此时就要返回factory内部的getObject里面的对象了。
		// getObjectFromFactoryBean 核心方法
		object = getObjectFromFactoryBean(factory, beanName, !synthetic);
	}
	return object;
}

接下来我们继续看一下里面的核心方法getObjectFromFactoryBean()

  • 看源码(FactoryBeanRegistrySupport.java)
protected Object getObjectFromFactoryBean(FactoryBean factory, String beanName, Boolean shouldPostProcess) {
	// 满足是单例并且缓存中存在的
	if (factory.isSingleton() && containsSingleton(beanName)) {
		synchronized (getSingletonMutex()) {
			// 从缓存中获取FactoryBean根据BeanName
			Object object = this.factoryBeanObjectCache.get(beanName);
			if (object == null) {
				// 为空，则从FactoryBean中获取对象
				object = doGetObjectFromFactoryBean(factory, beanName);
				// Only post-process and store if not put there already during getObject() call above
				// (e.g. because of circular reference processing triggered by custom getBean calls)
				// 从缓存中获取
				Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
				if (alreadyThere != null) {
					object = alreadyThere;
				} else {
					// 需要后续处理
					if (shouldPostProcess) {
						// 若该 bean 处于创建中，则返回非处理对象，而不是存储它
						if (isSingletonCurrentlyInCreation(beanName)) {
							// Temporarily return non-post-processed object, not storing it yet..
							return object;
						}
						// 前置处理
						beforeSingletonCreation(beanName);
						try {
							// 对从 FactoryBean 获取的对象进行后处理
							// 生成的对象将暴露给bean引用
							object = postProcessObjectFromFactoryBean(object, beanName);
						}
						catch (Throwable ex) {
							throw new BeanCreationException(beanName,
																	"Post-processing of FactoryBean's singleton object failed", ex);
						}
						finally {
							// 后置处理
							afterSingletonCreation(beanName);
						}
					}
					// 缓存
					if (containsSingleton(beanName)) {
						this.factoryBeanObjectCache.put(beanName, object);
					}
				}
			}
			return object;
		}
	}
	// 非单例 else {
		Object object = doGetObjectFromFactoryBean(factory, beanName);
		if (shouldPostProcess) {
			try {
				object = postProcessObjectFromFactoryBean(object, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
			}
		}
		return object;
	}
}
  • 源码分析

getObjectFromFactoryBean()该方法就是创建实例对象中的核心方法之一。我们关注它之中的单个方法即可：beforeSingletonCreation，afterSingletonCreation，postProcessObjectFromFactoryBean，这三个方法十分重要，万分重要！！！！！！！！因为前两个方法记录着bean的加载状态，是检测当前bean是否处于创建中的关键之处，对解决bean循环依赖起着关键的作用。

before方法用于标记当前bean处于创建中，

after则是移除。

其实文章一开始的getSingleton源码分析就已经提到了isSingletonCurrentlyInCreation()是用于检测当前bean是否处于创建之中，

  • 看源码(DefaultSingletonBeanRegistry.java)
public Boolean isSingletonCurrentlyInCreation(String beanName) {
	return this.singletonsCurrentlyInCreation.contains(beanName);
}
beforeSingletonCreation()

上述代码是根据变量singletonsCurrentlyInCreation集合中是否包含了beanName判断，集合的元素则一定是在beforeSingletonCreation()中添加的，如下：

protected void beforeSingletonCreation(String beanName) {
	if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
		throw new BeanCurrentlyInCreationException(beanName);
	}
}
afterSingletonCreation

afterSingletonCreation()为移除，则一定就是对singletonsCurrentlyInCreation集合remove了，如下：

protected void afterSingletonCreation(String beanName) {
	if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
		throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
	}
}

接下来我们再来看看真正的核心方法 doGetObjectFromFactoryBean

  • 看源码(FactoryBeanRegistrySupport.java)
private Object doGetObjectFromFactoryBean(FactoryBean factory, String beanName) throws BeanCreationException {
	Object object;
	try {
		if (System.getSecurityManager() != null) {
			AccessControlContext acc = getAccessControlContext();
			try {
				object = AccessController.doPrivileged((PrivilegedExceptionAction) factory::getObject, acc);
			}
			catch (PrivilegedActionException pae) {
				throw pae.getException();
			}
		} else {
			object = factory.getObject();
		}
	}
	catch (FactoryBeanNotInitializedException ex) {
		throw new BeanCurrentlyInCreationException(beanName, ex.toString());
	}
	catch (Throwable ex) {
		throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
	}
	// Do not accept a null value for a FactoryBean that's not fully
	// initialized yet: Many FactoryBeans just return null then.
	if (object == null) {
		if (isSingletonCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(
									beanName, "FactoryBean which is currently in creation returned null from getObject");
		}
		object = new NullBean();
	}
	return object;
}
 
 
     
  
  • 源码分析
    •  
 
 
 
在文章开始我们有介绍FactoryBean的调用方法，如果bean声明为FactoryBean类型，则当提取bean的是否提取的不是FactoryBean，而是FactoryBean中对应的getObject方法返回的bean，而doGetObjectRFromFactoryBean正是实现这一功能的。
 
 
调用完doGetObjectFromFactoryBean方法后，并没有直接返回，getObjectFromFactoryBean方法中还调用了object = postProcessObjectFromFactoryBean(object, beanName);方法，在子类AbstractAutowireCapableBeanFactory有该方法的具体实现：
 
 
     
  
  • 看源码(AbstractAutowireCapableBeanFactory.java)
    •  
 
 
 
@Override
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
	return applyBeanPostProcessorsAfterInitialization(object, beanName);
}

 
 
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {
	Object result = existingBean;
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		Object current = processor.postProcessAfterInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

 
 
对于后处理器的使用，目前还没有讲到，后面再重新开篇去说，这里我们只需要了解在Spring获取Bean的规则中有这样一条，尽可能保证所有bean初始化后都会调用注册的BeanPostProcessor的postProcessAfterInitialization方法进行处理，在实际开发中大可针对此特性设计自己的业务处理。
 
 
整理不易，如果对你有所帮助欢迎点赞关注
 
 
微信搜索【码上遇见你】获取更多精彩内容
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(一文带你解读Spring5源码解析 IOC之开启Bean的加载，以及FactoryBean和BeanFactory的区别。)

        

            

                
    
                    
  • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    
                    
    • 
                    
  • 情绪觉察日记第37天
                        露露_e800

                        
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    
                    
    • 
                    
  • 芦花鞋一四
                        许叶晗

                        
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
    
                    
    • 
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • 关于沟通这件事，项目经理不需要每次都面对面进行
                        流程大师兄

                        
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

                        
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    
                    
    • 
                    
  • 2020-01-25
                        晴岚85

                        
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
    
                    
    • 
                    
  • 随笔 | 仙一般的灵气
                        海思沧海

                        
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
    
                    
    • 
                    
  • 想家
                        爆米花机

                        
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
    
                    
    • 
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • OC语言多界面传值五大方式
                        Magnetic_h
iosui学习objective-c开发语言
                        
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
    
                    
    • 
                    
  • 一百九十四章. 自相矛盾
                        巨木擎天

                        
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • 10月|愿你的青春不负梦想-读书笔记-01
                        Tracy的小书斋

                        
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    
                    
    • 
                    
  • C语言宏函数
                        南林yan
C语言c语言
                        
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
                    
    • 
                    
  • 地推话术，如何应对地推过程中家长的拒绝
                        校师学

                        
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
    
                    
    • 
                    
  • 谢谢你们，爱你们！
                        鹿游儿

                        
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
    
                    
    • 
                    
  • C语言如何定义宏函数？
                        小九格物
c语言
                        
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • 小丽成长记（四十三）
                        玲玲54321

                        
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    
                    
    • 
                    
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断
                        尐尐呅

                        
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
    
                    
    • 
                    
  • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    
                    
    • 
                    
  • 瑶池防线
                        谜影梦蝶

                        
    冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
    
                    
    • 
                    
  • 爬山后遗症
                        璃绛

                        
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
    
                    
    • 
                                
  • 项目中 枚举与注解的结合使用
                                    飞翔的马甲
javaenumannotation
                                    
    前言：版本兼容，一直是迭代开发头疼的事，最近新版本加上了支持新题型，如果新创建一份问卷包含了新题型，那旧版本客户端就不支持，如果新创建的问卷不包含新题型，那么新旧客户端都支持。这里面我们通过给问卷类型枚举增加自定义注解的方式完成。顺便巩固下枚举与注解。 
 
一、枚举 
1.在创建枚举类的时候，该类已继承java.lang.Enum类，所以自定义枚举类无法继承别的类，但可以实现接口。 
 
   
    
                                
    • 
                                
  • 【Scala十七】Scala核心十一：下划线_的用法
                                    bit1129
scala
                                    
    下划线_在Scala中广泛应用，_的基本含义是作为占位符使用。_在使用时是出问题非常多的地方，本文将不断完善_的使用场景以及所表达的含义 
  1. 在高阶函数中使用 
scala> val list = List(-3,8,7,9)
list: List[Int] = List(-3, 8, 7, 9)

scala> list.filter(_ > 7)
r
    
                                
    • 
                                
  • web缓存基础：术语、http报头和缓存策略
                                    dalan_123
Web
                                    
    对于很多人来说，去访问某一个站点，若是该站点能够提供智能化的内容缓存来提高用户体验，那么最终该站点的访问者将络绎不绝。缓存或者对之前的请求临时存储，是http协议实现中最核心的内容分发策略之一。分发路径中的组件均可以缓存内容来加速后续的请求，这是受控于对该内容所声明的缓存策略。接下来将讨web内容缓存策略的基本概念，具体包括如如何选择缓存策略以保证互联网范围内的缓存能够正确处理的您的内容，并谈论下
    
                                
    • 
                                
  • crontab 问题
                                    周凡杨
linuxcrontabunix
                                    
      
一：  0481-079   Reached   a   symbol   that   is   not   expected.   
   
背景：  
*/5   *   *   *   *  /usr/IBMIHS/rsync.sh  
    
                                
    • 
                                
  • 让tomcat支持2级域名共享session
                                    g21121
session
                                    
    tomcat默认情况下是不支持2级域名共享session的，所有有些情况下登陆后从主域名跳转到子域名会发生链接session不相同的情况，但是只需修改几处配置就可以了。 
打开tomcat下conf下context.xml文件 
找到Context标签,修改为如下内容 
如果你的域名是www.test.com 
<Context sessionCookiePath="/path&q
    
                                
    • 
                                
  • web报表工具FineReport常用函数的用法总结（数学和三角函数）
                                    老A不折腾
Webfinereport总结
                                    
      
ABS 
ABS(number):返回指定数字的绝对值。绝对值是指没有正负符号的数值。 
Number:需要求出绝对值的任意实数。 
示例: 
ABS(-1.5)等于1.5。 
ABS(0)等于0。 
ABS(2.5)等于2.5。 
  
ACOS 
ACOS(number):返回指定数值的反余弦值。反余弦值为一个角度，返回角度以弧度形式表示。 
Number:需要返回角
    
                                
    • 
                                
  • linux 启动java进程 sh文件
                                    墙头上一根草
linuxshelljar
                                    
    #!/bin/bash
#初始化服务器的进程PId变量
user_pid=0;
robot_pid=0;
loadlort_pid=0;
gateway_pid=0;

#########
#检查相关服务器是否启动成功
#说明：
#使用JDK自带的JPS命令及grep命令组合，准确查找pid
#jps 加 l 参数，表示显示java的完整包路径
#使用awk，分割出pid 
    
                                
    • 
                                
  • 我的spring学习笔记5-如何使用ApplicationContext替换BeanFactory
                                    aijuans
Spring 3 系列
                                    
    如何使用ApplicationContext替换BeanFactory？ 
 
package onlyfun.caterpillar.device;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import
    
                                
    • 
                                
  • Linux 内存使用方法详细解析
                                    annan211
linux内存Linux内存解析
                                    
    来源 http://blog.jobbole.com/45748/ 
 
 

我是一名程序员，那么我在这里以一个程序员的角度来讲解Linux内存的使用。

一提到内存管理，我们头脑中闪出的两个概念，就是虚拟内存，与物理内存。这两个概念主要来自于linux内核的支持。

Linux在内存管理上份为两级，一级是线性区，类似于00c73000-00c88000，对应于虚拟内存，它实际上不占用
    
                                
    • 
                                
  • 数据库的单表查询常用命令及使用方法(-)
                                    百合不是茶
oracle函数单表查询
                                    
      
  
创建数据库; 
      
--建表
create table bloguser(username varchar2(20),userage number(10),usersex char(2));

 
      创建bloguser表,里面有三个字段 
  
  
&nbs
    
                                
    • 
                                
  • 多线程基础知识
                                    bijian1013
java多线程threadjava多线程
                                    
    一．进程和线程 
进程就是一个在内存中独立运行的程序，有自己的地址空间。如正在运行的写字板程序就是一个进程。 
“多任务”：指操作系统能同时运行多个进程（程序）。如WINDOWS系统可以同时运行写字板程序、画图程序、WORD、Eclipse等。 
线程：是进程内部单一的一个顺序控制流。 
线程和进程 
a.       每个进程都有独立的
    
                                
    • 
                                
  • fastjson简单使用实例
                                    bijian1013
fastjson
                                    
    一.简介 
        阿里巴巴fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法，把JSON Parse的性能提升到极致，是目前Java语言中最快的JSON库；包括“序列化”和“反序列化”两部分，它具备如下特征：     
    
                                
    • 
                                
  • 【RPC框架Burlap】Spring集成Burlap
                                    bit1129
spring
                                    
    Burlap和Hessian同属于codehaus的RPC调用框架，但是Burlap已经几年不更新，所以Spring在4.0里已经将Burlap的支持置为Deprecated,所以在选择RPC框架时，不应该考虑Burlap了。 
这篇文章还是记录下Burlap的用法吧，主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成 
 
    
                                
    • 
                                
  • 【Mahout一】基于Mahout 命令参数含义
                                    bit1129
Mahout
                                    
    1. mahout seqdirectory 
  
    $ mahout seqdirectory 
        --input (-i) input               Path to job input directory(原始文本文件).
        --output (-o) output             The directory pathna
    
                                
    • 
                                
  • linux使用flock文件锁解决脚本重复执行问题
                                    ronin47
linux lock　重复执行
                                    
    linux的crontab命令，可以定时执行操作，最小周期是每分钟执行一次。关于crontab实现每秒执行可参考我之前的文章《linux crontab 实现每秒执行》现在有个问题，如果设定了任务每分钟执行一次，但有可能一分钟内任务并没有执行完成，这时系统会再执行任务。导致两个相同的任务在执行。 
例如：       
<?         
// 
test
.php      
    
                                
    • 
                                
  • java-74-数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字
                                    bylijinnan
java
                                    
    

public class OcuppyMoreThanHalf {

	/**
	 * Q74 数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字
	 * two solutions:
	 * 1.O(n)
	 * see <beauty of coding>--每次删除两个不同的数字，不改变数组的特性
	 * 2.O(nlogn)
	 * 排序。中间
    
                                
    • 
                                
  • linux 系统相关命令
                                    candiio
linux
                                    
    系统参数 
cat /proc/cpuinfo  cpu相关参数 
cat /proc/meminfo 内存相关参数 
cat /proc/loadavg 负载情况 
性能参数 
1）top 
M：按内存使用排序 
P：按CPU占用排序 
1：显示各CPU的使用情况 
k：kill进程 
o：更多排序规则 
回车：刷新数据 
2）ulimit 
ulimit -a：显示本用户的系统限制参
    
                                
    • 
                                
  • [经营与资产]保持独立性和稳定性对于软件开发的重要意义
                                    comsci
软件开发
                                    
     
 
     一个软件的架构从诞生到成熟，中间要经过很多次的修正和改造 
 
      如果在这个过程中，外界的其它行业的资本不断的介入这种软件架构的升级过程中 
    
      那么软件开发者原有的设计思想和开发路线
    
                                
    • 
                                
  • 在CentOS5.5上编译OpenJDK6
                                    Cwind
linuxOpenJDK
                                    
    几番周折终于在自己的CentOS5.5上编译成功了OpenJDK6，将编译过程和遇到的问题作一简要记录，备查。  
0. OpenJDK介绍 
OpenJDK是Sun（现Oracle）公司发布的基于GPL许可的Java平台的实现。其优点： 
1、它的核心代码与同时期Sun（-> Oracle）的产品版基本上是一样的，血统纯正，不用担心性能问题，也基本上没什么兼容性问题；（代码上最主要的差异是
    
                                
    • 
                                
  • java乱码问题
                                    dashuaifu
java乱码问题js中文乱码
                                    
    swfupload上传文件参数值为中文传递到后台接收中文乱码               在js中用setPostParams（{"tag" : encodeURI( document.getElementByIdx_x("filetag").value，"utf-8")}）; 
然后在servlet中String t
    
                                
    • 
                                
  • cygwin很多命令显示command not found的解决办法
                                    dcj3sjt126com
cygwin
                                    
    cygwin很多命令显示command not found的解决办法 
  
修改cygwin.BAT文件如下 
@echo off 
D: 
set CYGWIN=tty notitle glob 
set PATH=%PATH%;d:\cygwin\bin;d:\cygwin\sbin;d:\cygwin\usr\bin;d:\cygwin\usr\sbin;d:\cygwin\us
    
                                
    • 
                                
  • [介绍]从 Yii 1.1 升级
                                    dcj3sjt126com
PHPyii2
                                    
    2.0 版框架是完全重写的，在 1.1 和 2.0 两个版本之间存在相当多差异。因此从 1.1 版升级并不像小版本间的跨越那么简单，通过本指南你将会了解两个版本间主要的不同之处。 
如果你之前没有用过 Yii 1.1，可以跳过本章，直接从"入门篇"开始读起。 
请注意，Yii 2.0 引入了很多本章并没有涉及到的新功能。强烈建议你通读整部权威指南来了解所有新特性。这样有可能会发
    
                                
    • 
                                
  • Linux SSH免登录配置总结
                                    eksliang
ssh-keygenLinux SSH免登录认证Linux SSH互信
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2187265 一、原理 
     我们使用ssh-keygen在ServerA上生成私钥跟公钥，将生成的公钥拷贝到远程机器ServerB上后,就可以使用ssh命令无需密码登录到另外一台机器ServerB上。 
     生成公钥与私钥有两种加密方式，第一种是
    
                                
    • 
                                
  • 手势滑动销毁Activity
                                    gundumw100
android
                                    
    老是效仿ios，做android的真悲催！ 
有需求：需要手势滑动销毁一个Activity 
怎么办尼？自己写？ 
不用~，网上先问一下百度。 
结果： 
http://blog.csdn.net/xiaanming/article/details/20934541 
 
 
首先将你需要的Activity继承SwipeBackActivity，它会在你的布局根目录新增一层SwipeBackLay
    
                                
    • 
                                
  • JavaScript变换表格边框颜色
                                    ini
JavaScripthtmlWebhtml5css
                                    
    效果查看：http://hovertree.com/texiao/js/2.htm代码如下，保存到HTML文件也可以查看效果： 
<html>
<head>
<meta charset="utf-8">
<title>表格边框变换颜色代码-何问起</title>
</head>
<body&
    
                                
    • 
                                
  • Kafka Rest : Confluent
                                    kane_xie
kafkaRESTconfluent
                                    
    最近拿到一个kafka rest的需求，但kafka暂时还没有提供rest api（应该是有在开发中，毕竟rest这么火），上网搜了一下，找到一个Confluent Platform，本文简单介绍一下安装。 
这里插一句，给大家推荐一个九尾搜索，原名叫谷粉SOSO，不想fanqiang谷歌的可以用这个。以前在外企用谷歌用习惯了，出来之后用度娘搜技术问题，那匹配度简直感人。 
 
 环境声明：Ubu
    
                                
    • 
                                
  • Calender不是单例
                                    men4661273
单例Calender
                                    
             在我们使用Calender的时候，使用过Calendar.getInstance()来获取一个日期类的对象，这种方式跟单例的获取方式一样，那么它到底是不是单例呢，如果是单例的话，一个对象修改内容之后，另外一个线程中的数据不久乱套了吗？从试验以及源码中可以得出，Calendar不是单例。 
测试： 
  Calendar c1 = 
    
                                
    • 
                                
  • 线程内存和主内存之间联系
                                    qifeifei
java thread
                                    
    1， java多线程共享主内存中变量的时候，一共会经过几个阶段，    
  lock:将主内存中的变量锁定，为一个线程所独占。 
  unclock:将lock加的锁定解除，此时其它的线程可以有机会访问此变量。 
  read:将主内存中的变量值读到工作内存当中。 
  load:将read读取的值保存到工作内存中的变量副本中。 
  
    
                                
    • 
                                
  • schedule和scheduleAtFixedRate
                                    tangqi609567707
javatimerschedule
                                    
    原文地址：http://blog.csdn.net/weidan1121/article/details/527307 
import java.util.Timer;import java.util.TimerTask;import java.util.Date; 
/** * @author vincent */public class TimerTest { 
 
    
                                
    • 
                                
  • erlang 部署
                                    wudixiaotie
erlang
                                    
    1.如果在启动节点的时候报这个错 ： 
{"init terminating in do_boot",{'cannot load',elf_format,get_files}} 
则需要在reltool.config中加入 
{app, hipe, [{incl_cond, exclude}]}, 
  
  
2.当generate时，遇到： 
ERROR
    
                                
    •