小小旭GISer
小小旭GISer

Spring 循环引用 ——理解singleton与prototype初始化的区别

所谓的循环引用，就是A依赖B，B又依赖A，A与B两个对象相互持有。像下面这种情况：

class A
{
	 B b;
	public A(B b) {
		this.b=b;
	}
}

class B
{
	A a;
	public B(A a )
	{
		this.a=a;
	}
	
}
我们知道spring在获取对象或者在加载的时候，触发依赖注入。例如触发A对象的依赖注入，发现需要B对象，而此时B还没有初始化，就去实例化B对象，而又需要A对象，这样就进入了一种死循环状态，有点像操作系统里面的死锁。似乎这种情况发生了，Spring就陷入僵局了。显然Spring有方法去解决这个问题。对于依赖注入的情况，大致分为构造注入和设值注入两种方式，而实际上因为Spring注入的触发机制不一样，这个问题又被分为singleton对象和prototype(其他三个作用域大致相同)对象的区别。我们可以把问题大致分为三类。

1 singleton对象循环引用

1.1 构造器循环依赖

这种依赖Spring是无法给你解决的，将会抛出BeanCurrentlyInCreationException异常。来看一下测试代码

（1） 定义两个类 A,B 构成构造成循环依赖的情况

class A
{
	 B b;
	public A(B b) {
		this.b=b;
	}
}

class B
{
	A a;
	public B(A a )
	{
		this.a=a;
	}
	
}

（2） 配置文件中配置两个类，在不指明作用域的时候，默认为singleton对象

（3）加载配置文件，两个类默认被加载以及注入 

ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
（4） 结果抛出了异常，来看一下日志输出 

  2015-08-01 02:39:15,869>>>>[org.springframework.beans.factory.support.DefaultListableBeanFactory]-[DEBUG] >>>>Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@2ef5e5e3: defining beans [xiaoA,xiaoB]; root of factory hierarchy
  2015-08-01 02:39:15,869>>>>[org.springframework.beans.factory.support.DefaultSingletonBeanRegistry]-[DEBUG] >>>>Creating shared instance of singleton bean 'xiaoA'
  2015-08-01 02:39:15,869>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Creating instance of bean 'xiaoA'
  2015-08-01 02:39:15,889>>>>[org.springframework.beans.factory.support.DefaultSingletonBeanRegistry]-[DEBUG] >>>>Creating shared instance of singleton bean 'xiaoB'
  2015-08-01 02:39:15,889>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Creating instance of bean 'xiaoB'
  2015-08-01 02:39:15,889>>>>[org.springframework.beans.factory.support.DefaultSingletonBeanRegistry]-[DEBUG] >>>>Creating shared instance of singleton bean 'xiaoA'
  2015-08-01 02:39:15,889>>>>[org.springframework.context.support.AbstractApplicationContext]-[WARN] >>>>Exception encountered during context initialization - cancelling refresh attempt
  org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'xiaoA' defined in class path resource [applicationContext.xml]: Cannot resolve reference to bean 'xiaoB' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'xiaoB' defined in class path resource [applicationContext.xml]: Cannot resolve reference to bean 'xiaoA' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'xiaoA': Requested bean is currently in creation: Is there an unresolvable circular reference?

这个过程是这样的，容器构造Class A的对象，发现构造参数需要一个ClassB的对象，而此时容器中没有ClassB的实例，因此转到ClassB的实例化过程，ClassB构造又需要ClassA,这样进入了循环状态。双方都无法完成构造的过程，因此抛出了异常。

1.2 设值注入循环依赖

对于设值注入的情况，循环依赖是可以完成的。来看一下测试代码。

（1） 构造两个类 A,B  构成循环依赖，并且使用设值注入的方式。

class CircleA
{
	private CircleB b;
	public CircleA(CircleB b)
	{
		this.b=b;
	}
	public CircleB getB() {
		return b;
	}
	public void setB(CircleB b) {
		this.b = b;
	}
	public CircleA()
	{
		
	}

}

class CircleB
{
	private CircleA a;
	
	public CircleA getA() {
		return a;
	}

	public void setA(CircleA a) {
		this.a = a;
	}

	public CircleB(CircleA a)
	{
		this.a=a;
	}
	public CircleB()
	{
		
	}
}

（2） 配置文件 采用默认的方式

（3）加载配置文件，两个类默认被加载以及注入 

ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");

（4）结果运行通过，看一下日志输出 

 2015-08-01 03:41:32,302>>>>[org.springframework.beans.factory.support.DefaultListableBeanFactory]-[DEBUG] >>>>Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@100fc185: defining beans [circleA,circleB]; root of factory hierarchy
  2015-08-01 03:41:32,302>>>>[org.springframework.beans.factory.support.DefaultSingletonBeanRegistry]-[DEBUG] >>>>Creating shared instance of singleton bean 'circleA'
  2015-08-01 03:41:32,302>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Creating instance of bean 'circleA'
  2015-08-01 03:41:32,312>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Eagerly caching bean 'circleA' to allow for resolving potential circular references
  2015-08-01 03:41:32,312>>>>[org.springframework.beans.factory.support.DefaultSingletonBeanRegistry]-[DEBUG] >>>>Creating shared instance of singleton bean 'circleB'
  2015-08-01 03:41:32,312>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Creating instance of bean 'circleB'
  2015-08-01 03:41:32,312>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Eagerly caching bean 'circleB' to allow for resolving potential circular references
  2015-08-01 03:41:32,312>>>>[org.springframework.beans.factory.support.AbstractBeanFactory]-[DEBUG] >>>>Returning eagerly cached instance of singleton bean 'circleA' that is not fully initialized yet - a consequence of a circular reference
  2015-08-01 03:41:32,322>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Finished creating instance of bean 'circleB'
  2015-08-01 03:41:32,322>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Finished creating instance of bean 'circleA'
  2015-08-01 03:41:32,322>>>>[org.springframework.beans.factory.support.AbstractBeanFactory]-[DEBUG] >>>>Returning cached instance of singleton bean 'circleB'
这个过程是这样的， A构造空对象放入缓存池中（暂且称为A空），触发了B对象注入，然后去构造B对象，又触发了对A对象的注入，这个时候缓存中已经有一个空的A对象，就把A空对象注入给B， 然后B构造完成，返回给A，这时A对象已经完成了注入。而同时B中持有的A对象也不再是A空了， 因为A是单例的，且A完成了注入，此时A=A空。也就完成了整个注入过程。

1.3设值与构造混合的循环依赖

依然设置A,B两个类，构成循环依赖，A采用设值注入B，B采用构造器注入A。对于这种情况，Spring是可以完成注入的。来查看示例代码

（1） 构造两个类 A,B 构成循环依赖关系，A采用设值注入B，B采用构造器注入A

class A
{
	 B b;
	
	public B getB()
	{
		return b;
	}
	public void setB(B b)
	{
		this.b = b;
	}
}

class B
{
	A a;
	public B(A a )
	{
		this.a=a;
	}
	
}

（2） 配置文件中配置两个类，在不指明作用域的时候，默认为singleton对象

（3）加载配置文件，两个类默认被加载以及注入 
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
（4） 结果正常，A,B注入完成，查看一下日志输出 

2015-08-01 04:00:32,884>>>>[org.springframework.beans.factory.support.DefaultListableBeanFactory]-[DEBUG] >>>>Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@6d00a15d: defining beans [xiaoA,xiaoB]; root of factory hierarchy
  2015-08-01 04:00:32,884>>>>[org.springframework.beans.factory.support.DefaultSingletonBeanRegistry]-[DEBUG] >>>>Creating shared instance of singleton bean 'xiaoA'
  2015-08-01 04:00:32,884>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Creating instance of bean 'xiaoA'
  2015-08-01 04:00:32,894>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Eagerly caching bean 'xiaoA' to allow for resolving potential circular references
  2015-08-01 04:00:32,904>>>>[org.springframework.beans.factory.support.DefaultSingletonBeanRegistry]-[DEBUG] >>>>Creating shared instance of singleton bean 'xiaoB'
  2015-08-01 04:00:32,904>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Creating instance of bean 'xiaoB'
  2015-08-01 04:00:32,904>>>>[org.springframework.beans.factory.support.AbstractBeanFactory]-[DEBUG] >>>>Returning eagerly cached instance of singleton bean 'xiaoA' that is not fully initialized yet - a consequence of a circular reference
  2015-08-01 04:00:32,914>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Eagerly caching bean 'xiaoB' to allow for resolving potential circular references
  2015-08-01 04:00:32,914>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Finished creating instance of bean 'xiaoB'
  2015-08-01 04:00:32,924>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Finished creating instance of bean 'xiaoA'
  2015-08-01 04:00:32,924>>>>[org.springframework.beans.factory.support.AbstractBeanFactory]-[DEBUG] >>>>Returning cached instance of singleton bean 'xiaoB'

1.4 Singleton的循环依赖注入总结

两个类构成循环依赖并且需要完成Spring注入的唯一条件是，可以构造一个空的对象放入缓存，否则将会失败。而这种空对象的构造必须采用设值注入的方式。在后面将给出深度解析。

2 Prototype的循环依赖

依然采用上面的三种情况去分析

2.1 构造器依赖注入

（1）类与上面的一样，只是配置文件稍作修改

（2）测试代码需要调用getBean方法，否则无法触发依赖注入 

ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
		A xiaoA=(A)applicationContext.getBean("xiaoA");

（3）结果抛出异常BeanCurrentlyInCreationException。下面看日志输出 

2015-08-01 04:09:31,425>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Creating instance of bean 'xiaoA'
  2015-08-01 04:09:31,435>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Creating instance of bean 'xiaoB'
  Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'xiaoA' defined in class path resource [applicationContext.xml]: Cannot resolve reference to bean 'xiaoB' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'xiaoB' defined in class path resource [applicationContext.xml]: Cannot resolve reference to bean 'xiaoA' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'xiaoA': Requested bean is currently in creation: Is there an unresolvable circular reference?

2.2 设值注入

（1）类与上面的一样，只是配置文件稍作修改


        
    
    
        
      

（2）测试代码需要调用getBean方法，否则无法触发依赖注入 
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        CircleB b=(CircleB)applicationContext.getBean("circleB");
       

（3）结果抛出异常BeanCurrentlyInCreationException。下面看日志输出 

 2015-08-01 04:13:29,505>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Creating instance of bean 'circleB'
  2015-08-01 04:13:29,515>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Creating instance of bean 'circleA'
  Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'circleB' defined in class path resource [applicationContext.xml]: Cannot resolve reference to bean 'circleA' while setting bean property 'a'; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'circleA' defined in class path resource [applicationContext.xml]: Cannot resolve reference to bean 'circleB' while setting bean property 'b'; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'circleB': Requested bean is currently in creation: Is there an unresolvable circular reference?

2.3 混合模式

测试代码与上面类似，结果同样是无法完成注入，抛出BeanCurrentlyInCreationException异常。

2.4 小结

对于prototype来说，只有存在循环引用的情况，是无法完成注入的。


3 prototype与singleton的混合模式循环引用

这种混合模式在某些情况下是成立的。这里只给出一种成功的案例，其他模式下无法完成。这一成功的类型是AB两个类都采用设值注入的方式。

（1） 构造A ,B两个类，构成循环依赖关系

class CircleA
{
	private CircleB b;
	
	public CircleB getB() {
		return b;
	}
	public void setB(CircleB b) {
		this.b = b;
	}
	public CircleA()
	{
		
	}

}

class CircleB
{
	private CircleA a;
	public CircleB()
	{
		
	}
	public CircleA getA() {
		return a;
	}

	public void setA(CircleA a) {
		this.a = a;
	}

	}

（2） 配置文件 配置A为prototype B为默认  AB均采用设值注入的方式

（3） 测试结果 通过，而且B中持有的A对象 与getBean得到的A对象不是一个对象。 

ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
		CircleA A=(CircleA)applicationContext.getBean("circleA");
		CircleB B=(CircleB)applicationContext.getBean("circleB");
		System.out.println(A==B.getA());

（4）查看一下日志输出 

2015-08-01 04:45:08,952>>>>[org.springframework.beans.factory.support.DefaultListableBeanFactory]-[DEBUG] >>>>Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@100fc185: defining beans [circleA,circleB]; root of factory hierarchy
  2015-08-01 04:45:08,952>>>>[org.springframework.beans.factory.support.DefaultSingletonBeanRegistry]-[DEBUG] >>>>Creating shared instance of singleton bean 'circleB'
  2015-08-01 04:45:08,952>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Creating instance of bean 'circleB'
  2015-08-01 04:45:08,962>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Eagerly caching bean 'circleB' to allow for resolving potential circular references
  2015-08-01 04:45:08,962>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Creating instance of bean 'circleA'
  2015-08-01 04:45:08,962>>>>[org.springframework.beans.factory.support.AbstractBeanFactory]-[DEBUG] >>>>Returning eagerly cached instance of singleton bean 'circleB' that is not fully initialized yet - a consequence of a circular reference
  2015-08-01 04:45:08,972>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Finished creating instance of bean 'circleA'
  2015-08-01 04:45:08,972>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Finished creating instance of bean 'circleB'
  2015-08-01 04:45:08,972>>>>[org.springframework.context.support.AbstractApplicationContext]-[DEBUG] >>>>Unable to locate LifecycleProcessor with name 'lifecycleProcessor': using default [org.springframework.context.support.DefaultLifecycleProcessor@1dfe2924]
  2015-08-01 04:45:08,972>>>>[org.springframework.beans.factory.support.AbstractBeanFactory]-[DEBUG] >>>>Returning cached instance of singleton bean 'lifecycleProcessor'
  2015-08-01 04:45:08,982>>>>[org.springframework.core.env.PropertySourcesPropertyResolver]-[DEBUG] >>>>Searching for key 'spring.liveBeansView.mbeanDomain' in [systemProperties]
  2015-08-01 04:45:08,982>>>>[org.springframework.core.env.PropertySourcesPropertyResolver]-[DEBUG] >>>>Searching for key 'spring.liveBeansView.mbeanDomain' in [systemEnvironment]
  2015-08-01 04:45:08,982>>>>[org.springframework.core.env.PropertySourcesPropertyResolver]-[DEBUG] >>>>Could not find key 'spring.liveBeansView.mbeanDomain' in any property source. Returning [null]
  init finished============================================
2015-08-01 04:45:08,982>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Creating instance of bean 'circleA'
  2015-08-01 04:45:08,982>>>>[org.springframework.beans.factory.support.AbstractBeanFactory]-[DEBUG] >>>>Returning cached instance of singleton bean 'circleB'
  2015-08-01 04:45:08,982>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Finished creating instance of bean 'circleA'
  2015-08-01 04:45:08,982>>>>[org.springframework.beans.factory.support.AbstractBeanFactory]-[DEBUG] >>>>Returning cached instance of singleton bean 'circleB'
  false


4 singleton与prototype的初始化的区别

4.1 singleton初始化过程

下面的示意图大致显示了这个过程的关键步骤，关于细节的代码，可以查看另一篇博客。

这个图中的数字标识了各个过程，红色填图的区域表示关键步骤，黄色填图的区域为logger日志输出内容，虚线边框代表一个方法的内部。

Spring 循环引用 ——理解singleton与prototype初始化的区别_第1张图片

下面是一段 singleon对象循环引用的日志输出。用来配合理解这个过程

2015-08-01 09:51:34,966>>>>[org.springframework.beans.factory.support.DefaultListableBeanFactory]-[DEBUG] >>>>Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@100fc185: defining beans [circleA,circleB]; root of factory hierarchy
  2015-08-01 09:51:34,966>>>>[org.springframework.beans.factory.support.DefaultSingletonBeanRegistry]-[DEBUG] >>>>Creating shared instance of singleton bean 'circleA'
  2015-08-01 09:51:34,966>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Creating instance of bean 'circleA'
  A开始初始化
2015-08-01 09:51:34,976>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Eagerly caching bean 'circleA' to allow for resolving potential circular references
  2015-08-01 09:51:34,976>>>>[org.springframework.beans.factory.support.DefaultSingletonBeanRegistry]-[DEBUG] >>>>Creating shared instance of singleton bean 'circleB'
  2015-08-01 09:51:34,976>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Creating instance of bean 'circleB'
  B开始初始化
2015-08-01 09:51:34,976>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Eagerly caching bean 'circleB' to allow for resolving potential circular references
  2015-08-01 09:51:34,976>>>>[org.springframework.beans.factory.support.AbstractBeanFactory]-[DEBUG] >>>>Returning eagerly cached instance of singleton bean 'circleA' that is not fully initialized yet - a consequence of a circular reference
  B开始注入
B完成注入
2015-08-01 09:51:34,986>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Finished creating instance of bean 'circleB'
  A开始注入
A完成注入
2015-08-01 09:51:34,986>>>>[org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory]-[DEBUG] >>>>Finished creating instance of bean 'circleA'

4.1.1 辅助关键属性

在DefaultSingletonBeanRegistry类中，定义了一些属性，它决定着整个依赖注入过程的关键步骤跳转，同时也伴随着整个bean的关键周期.

/** 保存所有的singletonBean的实例 */
	private final Map singletonObjects = new ConcurrentHashMap(64);

	/** singletonBean的生产工厂*/
	private final Map> singletonFactories = new HashMap>(16);

	/** 保存所有早期创建的Bean对象，这个Bean还没有完成依赖注入 */
	private final Map earlySingletonObjects = new HashMap(16);

	/** 保存所有已经完成初始化的Bean的名字（name） */
	private final Set registeredSingletons = new LinkedHashSet(64);

	/** 标识指定name的Bean对象是否处于创建状态  这个状态非常重要 */
	private final Set singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap(16));

4.1.2 singleton的创建流程

singleton的创建开始于getBean方法，关于这个流程，可以查看另外一篇博客。这个方法调用了doGetBean方法，也是示意图中最顶端的方法，这是创建singleton的开始。

  1. 进入1号代码区域，这是一个关键的代码，getSingleton方法去查找缓存，如果存在未创建完成的Bean(earlyBean)，就返回这个结果，作为doGetBean的返回值，并输出一段日志内容，流程结束：
  2. 否则进入2号代码区，创建一个ObjectFactory，作为创建singleton的工厂，注册给getSingleton方法，进入红色方法区；
  3. 输出3号日志内容；
  4. 进入4号方法，这是一个关键节点，在这里把当前正常初始化的BeanName放入singletonsCurrentlyInCreation集合中，此时与BeanName绑定的属性为true，表示这个beanName正在创建；
  5. 进入5号方法，也就是绿色代码区，这是调用前面注册的工厂的创建方法，也是Spring中所有的Bean的初始化的入口；
  6. 输出6号日志内容；
  7. 调用doGetBean方法，进入蓝色代码区，这是创建Bean的核心代码区；
  8. 进入7号关键代码区，这个地方完成了构造方法的匹配工作，构造注入与设值注入的区别点就在这；采用构造注入的话，需要在这里面获得所有构造方法参数的属性值，如果属性值为另一个Bean的话，就会调用getBean方法，递归地回到整个流程的入口处；注意，在这个时候4.1.1中的关键属性的状态为 singletonsCurrentlyInCreation.get(Beanname)=true; singgletonFactories.get(name)=null;singletonObjects.get(beanName)=null;
  9. 如果采用设值注入的话，此处仅仅会调用默认的空的构造方法，此时已经创建了一个空的Bean对象（earlyBean）然后向下进入8号区域；
  10. 进入8号区域输出日志内容；
  11. 进入9号方法，这是一个singleton创建后的一个后处理方法，在这里又一次注册了一个工厂，并且注册的工厂方法为getEarlyBeanReference，并把这个方法加入到singletonFactories中，此时singletonFactories.get(name)！=null;
  12. 进入10号代码区，这里完成了依赖注入的过程，如果需要注入Bean的话，就会调用getBean的方法；
  13. 进入11号区域，整个singletonBean创建完成，输出日志内容，然后进行一些后处理工作，流程退出

4.1.3源码

整个过程的源码很多，这里仅截取与singleton创建相关的部分

（1）图中1号代码getSingleton

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		//在已经完成创建的singleton集合中查找
		Object singletonObject = this.singletonObjects.get(beanName);
		//如果没有找到 并且还处于当前创建状态，就应该可以找到earlyReference
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				singletonObject = this.earlySingletonObjects.get(beanName);//在earlyReference查找
				if (singletonObject == null && allowEarlyReference) {
					//如果还没有找到，就去找对应的工厂方法，这里与9号代码回应。
					//如果创建了空的Bean的话，在此处一定能拿到对应的工厂
					ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						singletonObject = singletonFactory.getObject();//在这获得对应的earlyBean
						this.earlySingletonObjects.put(beanName, singletonObject);//放入earlyBeanObjects集合中
						this.singletonFactories.remove(beanName);//移除工厂方法
					}
				}
			}
		}
		return (singletonObject != NULL_OBJECT ? singletonObject : null);
	}

(2)第一个日志输出的地方，这里的getSingleton就是上面（1）里面的方法 

// Eagerly check singleton cache for manually registered singletons.
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isDebugEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

（3） 如果getSingleton返回null,就进入创建阶段 

if (mbd.isSingleton()) {
					//注册工厂  调用另一个getSingleton
					sharedInstance = getSingleton(beanName, new ObjectFactory() {
						@Override
						public Object getObject() throws BeansException {
							try {
								//创建Bean的实际方法
								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);
				} 
  
 (4) 红色代码框的getSingleton的方法 
  
 
  
public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
			//非空校验
		Assert.notNull(beanName, "'beanName' must not be null");
		synchronized (this.singletonObjects) {
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
				if (this.singletonsCurrentlyInDestruction) {
					throw new BeanCreationNotAllowedException(beanName,
							"Singleton bean creation not allowed while the singletons of this factory are in destruction " +
							"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
				}
				//前置处理
				beforeSingletonCreation(beanName);
				boolean newSingleton = false;
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet();
				}
				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) {
					if (recordSuppressedExceptions) {
						for (Exception suppressedException : this.suppressedExceptions) {
							ex.addRelatedCause(suppressedException);
						}
					}
					throw ex;
				}
				finally {
					if (recordSuppressedExceptions) {
						this.suppressedExceptions = null;
					}
					//后置处理
					afterSingletonCreation(beanName);
				}
				if (newSingleton) {
					addSingleton(beanName, singletonObject);
				}
			}
			return (singletonObject != NULL_OBJECT ? singletonObject : null);
		}
	}		
 
  
 （5） beforeSingletonCreation 前置处理， 
  在这可能抛出重复创建的异常 
  
 
  
protected void beforeSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
	}
 
  
 （6）doCreateBean方法 已略去无关代码 
  
 
  
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
		//...
		if (instanceWrapper == null) {
			//创建Bean的实际方法
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		//...

		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			//注册getEaryBean的工厂方法
			addSingletonFactory(beanName, new ObjectFactory() {
				@Override
				public Object getObject() throws BeansException {
					return getEarlyBeanReference(beanName, mbd, bean);
				}
			});
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			//开始依赖注入  触发getBean方法
			populateBean(beanName, mbd, instanceWrapper);
			if (exposedObject != null) {
				exposedObject = initializeBean(beanName, exposedObject, mbd);
			}
		}
		catch (Throwable ex) {
			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
				throw (BeanCreationException) ex;
			}
			else {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
			}
		}

		//...

		return exposedObject;
	} 
  
 
  
（7 ）createBeanInstance方法，实际创建Bean的方法
 
  
 
  
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
		//...

		// 在这里去匹配合适的构造方法，如果存在构造注入，需要找到所有的注入的值，触发getBean
		Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// No special handling: simply use no-arg constructor.
		return instantiateBean(beanName, mbd);
	}
 
  
 
  
4.1.4不能采用构造注入的原因
 
  
通过上面的分析，已经基本可以看出设值注入与构造注入的区别在哪里，就是触发getBean递归的时机不一致，导致1号的getSingleton的结果不一样。
 
  
对于设值注入来说，首先进入getA的getBean，此时getSingleton返回null,进入Bean的创建阶段，此时采用设值注入，构造默认的空的Bean，并注册一个工厂方法，然后依赖注入，getBean的时候触发了对B的构造过程，与A一样，构造默认的空的Bean，并注册一个工厂方法，然后依赖注入，这时需要A，第二次进入A的getBean流程，而此时因为存在工厂方法，所以1号的getSingleton不再返回空，这样就返回了一个Earlybean对象注入到B中；然后B完成注入，接着A完成注入。
 
  
对于构造注入来说，首先进入getA的getBean，此时getSingleton返回null,进入Bean的创建阶段，此时采用构造注入，在查找注入参数的时候，就触发了B的getBean方法，注意此时并没有注册工厂方法，B的创建流程开始，采用构造注入，查找注入参数，第二次进入A的getBean方法，因为没有提供可以拿到earlyBean的工厂方法，1号getSingleton将返回空，此时将再次进入红色方法区，再次调用4号方法时，就会抛出重复创建的异常。
 
  
对于混合方式来说，因为其中之一采用设值注入，再第二个进入这个对象的getBean方法的时候，总会得到earlyBean，因此不会抛出异常，也就可以完成创建。
 
  
在此可以得出结论，Spring对于循环引用的解决方案就是暴露一个ObjectFactroy，对于未创建完成的Bean,可以通过这个工厂得到一个earlyBean保证“锁”被释放，完成流程。而可以暴露这个ObjectFactory的唯一条件就是必须采用设值注入，以保证可以提前构造一个空的earlyBean。
 
  
4.2 prototype的初始化流程
 
  
4.2.1 prototype的初始化流程
 
  
相对于singleton来说，prototype就简单的多，由于方法名都类似，在这直接给出整个流程的代码。
 
  
（1） 关键属性  只有一个，保存着正在创建的prototype的beanName
 
  
 
  
/** Names of beans that are currently in creation */
	private final ThreadLocal prototypesCurrentlyInCreation =
			new NamedThreadLocal("Prototype beans currently in creation");
 
  
 
  (2) 流程代码 ，这里没有像前面给出那么多代码的原因，是因为后面的代码都一样，并没有添加与prototype相关的，也就是说prototype的创建流程也米有对外暴露什么工厂之类的辅助。 
  
 
  
 
  
//流程1  检验当前的bean是否处于
	// Fail if we're already creating this bean instance:
	// We're assumably within a circular reference.
	if (isPrototypeCurrentlyInCreation(beanName)) {
		throw new BeanCurrentlyInCreationException(beanName);
	}
	//流程2  创建Bean
	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);
	}			
 
  
 
  （3） 前置处理、检验部分代码 
  
前置处理看着挺复杂，其实就是把每个正在创建的prototype的BeanName放入一个set中
 
  
 
  
protected void beforePrototypeCreation(String beanName) {
		Object curVal = this.prototypesCurrentlyInCreation.get();
		if (curVal == null) {
			this.prototypesCurrentlyInCreation.set(beanName);
		}
		else if (curVal instanceof String) {
			Set beanNameSet = new HashSet(2);
			beanNameSet.add((String) curVal);
			beanNameSet.add(beanName);
			this.prototypesCurrentlyInCreation.set(beanNameSet);
		}
		else {
			Set beanNameSet = (Set) curVal;
			beanNameSet.add(beanName);
		}
	}
 
  
 
  检验就是检查当前的beanName是否处于创建状态，如果是就抛出异常 
  
 
  
 
  
protected boolean isPrototypeCurrentlyInCreation(String beanName) {
		Object curVal = this.prototypesCurrentlyInCreation.get();
		return (curVal != null &&
				(curVal.equals(beanName) || (curVal instanceof Set && ((Set) curVal).contains(beanName))));
	}
 
  
 
  
 
  
4.2.2 prototype不能实现循环引用的原因
 
  
从流程上就可以查看，无论是构造注入还是设值注入，第二次进入同一个Bean的getBean方法是，一定会在校验部分抛出异常，因此不能完成注入，也就不能实现循环引用。
 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  
 
  
 
  
 
  
 
  
 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Spring技术,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技术内幕：设计理念和整体架构概述
                        各自安好吧
spring架构java后端
                        
    程序员都很崇拜技术大神，很大一部分是因为他们发现和解决问题的能力，特别是线上出现紧急问题时，总是能够快速定位和解决。一方面，他们有深厚的技术基础，对应用的技术知其所以然，另一方面，在采坑的过程中不断总结，积累了很多经验。相信大家都使用过Spring，有些人了解它的核心：IOC和AOP，但只是了解它们的基本概念、使用了反射和动态代理，关于如何管理对象、代理的具体实现了解的比较浅。有些人使用Sprin
    
                    
    • 
                    
  • 手写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技术内幕学习-1
                        Sunny_damon

                        
    Spring的核心：IoC容器和AOP1.IoC基本概念IoC：依赖反转，它可以在对象生成或者初始化时直接将数据注入到对象中，也可以通过将对象注入到对象数据域中的方式来注入对方法调用的依赖。IoC的作用：降低面向对象设计的复杂性（将复杂的依赖关系简单化即起到解耦的作用）、提高系统可测试性。IoC容器注入方式：接口注入、setter注入、构造方法注入2.IoC容器系列设计与实现BeanFactory
    
                    
    • 
                    
  • 专治不会看源码的毛病--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
    
                    
    • 
                                
  • jquery实现的jsonp掉java后台
                                    知了ing
javajsonpjquery
                                    
     什么是JSONP？ 
 
先说说JSONP是怎么产生的： 
 
其实网上关于JSONP的讲解有很多，但却千篇一律，而且云里雾里，对于很多刚接触的人来讲理解起来有些困难，小可不才，试着用自己的方式来阐释一下这个问题，看看是否有帮助。 
 
1、一个众所周知的问题，Ajax直接请求普通文件存在跨域无权限访问的问题，甭管你是静态页面、动态网页、web服务、WCF，只要是跨域请求，一律不准； 
 
2、
    
                                
    • 
                                
  • Struts2学习笔记
                                    caoyong
struts2
                                    
    SSH : Spring + Struts2 + Hibernate 
三层架构(表示层,业务逻辑层,数据访问层) MVC模式 (Model View Controller) 
分层原则:单向依赖，接口耦合 
 
1、Struts2  =  Struts  + Webwork 
2、搭建struts2开发环境 
   a>、到www.apac
    
                                
    • 
                                
  • SpringMVC学习之后台往前台传值方法
                                    满城风雨近重阳
springMVC
                                    
    springMVC控制器往前台传值的方法有以下几种： 
1.ModelAndView 
   通过往ModelAndView中存放viewName：目标地址和attribute参数来实现传参： 
    
 ModelAndView mv=new ModelAndView(); 
 mv.setViewName="success
    
                                
    • 
                                
  • WebService存在的必要性？
                                    一炮送你回车库
webservice
                                    
    做Java的经常在选择Webservice框架上徘徊很久，Axis  Xfire Axis2 CXF ，他们只有一个功能，发布HTTP服务然后用XML做数据传输。 
是的，他们就做了两个功能，发布一个http服务让客户端或者浏览器连接，接收xml参数并发送xml结果。 
当在不同的平台间传输数据时，就需要一个都能解析的数据格式。 
但是为什么要使用xml呢？不能使json或者其他通用数据
    
                                
    • 
                                
  • js年份下拉框
                                    3213213333332132
java web ee
                                    
    
  <div id="divValue">test...</div>测试

 //年份 
    <select id="year"></select>
   <script type="text/javascript">
     window.onload = 
    
                                
    • 
                                
  • 简单链式调用的实现技术
                                    归来朝歌
方法调用链式反应编程思想
                                    
    在编程中，我们可以经常遇到这样一种场景：一个实例不断调用它自身的方法，像一条链条一样进行调用 
这样的调用你可能在Ajax中，在页面中添加标签： 
$("<p>").append($("<span>").text(list[i].name)).appendTo("#result"); 
  
也可能在HQ
    
                                
    • 
                                
  • JAVA调用.net 发布的webservice 接口
                                    darkranger
webservice
                                    
     /** 
	* @Title: callInvoke 
	* @Description: TODO(调用接口公共方法) 
	* @param @param url 地址
	* @param @param method 方法
	* @param @param pama 参数
	* @param @return
	* @param @throws BusinessException  
    
                                
    • 
                                
  • Javascript模糊查找 | 第一章 循环不能不重视。
                                    aijuans
Way
                                    
      最近受我的朋友委托用js+HTML做一个像手册一样的程序，里面要有可展开的大纲，模糊查找等功能。我这个人说实在的懒，本来是不愿意的，但想起了父亲以前教我要给朋友搞好关系，再加上这也可以巩固自己的js技术，于是就开始开发这个程序，没想到却出了点小问题，我做的查找只能绝对查找。具体的js代码如下： 
  
function search(){
	var arr=new Array("my
    
                                
    • 
                                
  • 狼和羊，该怎么抉择
                                    atongyeye
工作
                                    
    狼和羊，该怎么抉择 
 
在做一个链家的小项目，只有我和另外一个同事两个人负责，各负责一部分接口，我的接口写完，并全部测联调试通过。所以工作就剩下一下细枝末节的，工作就轻松很多。每天会帮另一个同事测试一些功能点，协助他完成一些业务型不强的工作。 
 
今天早上到公司没多久，领导就在QQ上给我发信息，让我多协助同事测试，让我积极主动些，有点责任心等等，我听了这话，心里面立马凉半截，首先一个领导轻易说
    
                                
    • 
                                
  • 读取android系统的联系人拨号
                                    百合不是茶
androidsqlite数据库内容提供者系统服务的使用
                                    
      
     联系人的姓名和号码是保存在不同的表中,不要一下子把号码查询来,我开始就是把姓名和电话同时查询出来的,导致系统非常的慢 
  
关键代码: 
  
  
1, 使用javabean操作存储读取到的数据 
package com.example.bean;

/**
 * 
 * @author Admini
    
                                
    • 
                                
  • ORACLE自定义异常
                                    bijian1013
数据库自定义异常
                                    
    实例： 
CREATE OR REPLACE PROCEDURE test_Exception
(
  ParameterA IN varchar2,
  ParameterB IN varchar2,
  ErrorCode  OUT varchar2  --返回值,错误编码
)
AS
  /*以下是一些变量的定义*/
  V1    NUMBER;
  V2    nvarc
    
                                
    • 
                                
  • 查看端号使用情况
                                    征客丶
windows
                                    
    一、查看端口 
在windows命令行窗口下执行： 
>netstat -aon|findstr "8080" 
显示结果： 
TCP     127.0.0.1:80         0.0.0.0:0    &
    
                                
    • 
                                
  • 【Spark二十】运行Spark Streaming的NetworkWordCount实例
                                    bit1129
wordcount
                                    
    Spark Streaming简介 
  NetworkWordCount代码 
  
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with

    
                                
    • 
                                
  • Struts2 与 SpringMVC的比较
                                    BlueSkator
struts2spring mvc
                                    
    1. 机制：spring mvc的入口是servlet，而struts2是filter，这样就导致了二者的机制不同。 2. 性能：spring会稍微比struts快。spring mvc是基于方法的设计，而sturts是基于类，每次发一次请求都会实例一个action，每个action都会被注入属性，而spring基于方法，粒度更细，但要小心把握像在servlet控制数据一样。spring
    
                                
    • 
                                
  • Hibernate在更新时，是可以不用session的update方法的(转帖）
                                    BreakingBad
Hibernateupdate
                                    
    地址：http://blog.csdn.net/plpblue/article/details/9304459 
public void synDevNameWithItil() 
{Session session = null;Transaction tr = null;try{session = HibernateUtil.getSession();tr = session.beginTran
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-观察者模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;

/**
 * “观
    
                                
    • 
                                
  • 重置MySQL密码
                                    chenhbc
mysql重置密码忘记密码
                                    
    如果你也像我这么健忘，把MySQL的密码搞忘记了，经过下面几个步骤就可以重置了（以Windows为例，Linux/Unix类似）： 
1、关闭MySQL服务 
2、打开CMD，进入MySQL安装目录的bin目录下，以跳过权限检查的方式启动MySQL 
mysqld --skip-grant-tables 
 3、新开一个CMD窗口，进入MySQL 
mysql -uroot 
 
    
                                
    • 
                                
  • 再谈系统论，控制论和信息论
                                    comsci
设计模式生物能源企业应用领域模型
                                    
     
                           再谈系统论，控制论和信息论 
 
 
    偶然看
    
                                
    • 
                                
  • oracle moving window size与 AWR retention period关系
                                    daizj
oracle
                                    
    转自： http://tomszrp.itpub.net/post/11835/494147 
 
晚上在做11gR1的一个awrrpt报告时,顺便想调整一下AWR snapshot的保留时间,结果遇到了ORA-13541这样的错误.下面是这个问题的发生和解决过程. 
 
SQL> select * from v$version; 
 
BANNER 
-------------------
    
                                
    • 
                                
  • Python版B树
                                    dieslrae
python
                                    
    话说以前的树都用java写的,最近发现python有点生疏了,于是用python写了个B树实现,B树在索引领域用得还是蛮多了,如果没记错mysql的默认索引好像就是B树... 
 
首先是数据实体对象,很简单,只存放key,value 
 

class Entity(object):
    '''数据实体'''
    
    def __init__(self,key,value)
    
                                
    • 
                                
  • C语言冒泡排序
                                    dcj3sjt126com
算法
                                    
    代码示例： 
# include <stdio.h>

//冒泡排序
void sort(int * a, int len)
{
	int i, j, t;

	for (i=0; i<len-1; i++)
	{
		for (j=0; j<len-1-i; j++)
		{
			if (a[j] > a[j+1])	// >表示升序 
    
                                
    • 
                                
  • 自定义导航栏样式
                                    dcj3sjt126com
自定义
                                    
    -(void)setupAppAppearance
{
    [[UILabel appearance] setFont:[UIFont fontWithName:@"FZLTHK—GBK1-0" size:20]];
    [UIButton appearance].titleLabel.font =[UIFont fontWithName:@"FZLTH
    
                                
    • 
                                
  • 11.性能优化-优化-JVM参数总结
                                    frank1234
jvm参数性能优化
                                    
    1.堆 
-Xms --初始堆大小 
-Xmx --最大堆大小 
-Xmn --新生代大小 
-Xss --线程栈大小 
-XX:PermSize  --永久代初始大小 
-XX:MaxPermSize  --永久代最大值 
-XX:SurvivorRatio --新生代和suvivor比例,默认为8 
-XX:TargetSurvivorRatio --survivor可使用
    
                                
    • 
                                
  • nginx日志分割 for linux
                                    HarborChung
nginxlinux脚本
                                    
    nginx日志分割 for linux   默认情况下，nginx是不分割访问日志的，久而久之，网站的日志文件将会越来越大，占用空间不说，如果有问题要查看网站的日志的话，庞大的文件也将很难打开，于是便有了下面的脚本        使用方法，先将以下脚本保存为 cutlog.sh，放在/root 目录下，然后给予此脚本执行的权限    
   
复制代码代码如下:   
chmo
    
                                
    • 
                                
  • Spring4新特性——泛型限定式依赖注入
                                    jinnianshilongnian
springspring4泛型式依赖注入
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • centOS安装GCC和G++
                                    liuxihope
centosgcc
                                    
    Centos支持yum安装，安装软件一般格式为yum install .......，注意安装时要先成为root用户。 
 
按照这个思路，我想安装过程如下： 
 
安装gcc：yum install gcc 
 
安装g++： yum install g++ 
 
实际操作过程发现，只能有gcc安装成功，而g++安装失败，提示g++ command not found。上网查了一下，正确安装应该
    
                                
    • 
                                
  • 第13章 Ajax进阶（上）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • How to determine BusinessObjects service pack and fix pack
                                    blueoxygen
BO
                                    
    http://bukhantsov.org/2011/08/how-to-determine-businessobjects-service-pack-and-fix-pack/ 
  
The table below is helpful. Reference 
  BOE XI 3.x 
     12.0.0.
y  BOE XI 3.0   12.0.
x.
y  BO
    
                                
    • 
                                
  • Oracle里的自增字段设置
                                    tomcat_oracle
oracle
                                    
    　大家都知道吧，这很坑，尤其是用惯了mysql里的自增字段设置，结果oracle里面没有的。oh，no   　　我用的是12c版本的，它有一个新特性，可以这样设置自增序列，在创建表是，把id设置为自增序列   
create table t
(
id 　　 　　  number generated by default as identity (start with 1 increment b
    
                                
    • 
                                
  • Spring Security（01）——初体验
                                    yang_winnie
springSecurity
                                    
    Spring Security（01）——初体验 
 
    博客分类： spring Security 
 
Spring Security入门安全认证 
 
       首先我们为Spring Security专门建立一个Spring的配置文件，该文件就专门用来作为Spring Security的配置
    
                                
    •