Spring闲谈

依赖注入(Inverse of Control)

---

Spring 实现IoC(Inverse of Control)，就是通过 Spring容器 来创建，管理所有的Java对象(Java Bean)。
并且Spring容器使用配置文件来组织各个Java Bean之间的依赖关系，而不是以硬编码的方式让它们耦合在一起！
没有各种new真爽，配置文件管理各个Bean 之间的协作关系真的炒鸡解耦，谁用谁知道。

Bean 的作用域 singleton (默认) ,prototype ，request，session，global session 后面三个只在web应用中有效

创建Bean的三种形式

• 构造器，最常见的形式，如果不采用构造注入，Spring底层会调用Bean类的无参数构造器来创建实例，因此要求该Bean类提供无参数的构造器。Spring容器会默认初始化所有属性，基础类型0或false，引用类型null

• 静态工厂 ，要创建的实例的Bean，class属性要是静态工厂类(因为Spring需要的是哪个工厂类来创建Bean实例)，用factory-method指定工厂方法。

  ```
    package com.example.factory;
  
    public class ExampleFactory{  //静态工厂方法
    public static Example newInstance(String message,int index){  
        return  new Example(message,index);  
    }  
  
    ---- xml配置文件
    
      
            
            
      
   
   ```
  

• 实例工厂，先配置实例工厂类，配置Bean无需class属性, 用factory-bean指定工厂类id，factory-method指定工厂方法

    ---- xml配置文件
    
        
  
        
            
            
        
   
  

---

循环依赖问题

---

• 构造器注入的循环依赖问题是无法解决的
• setter循环依赖是可以提前暴露刚完成的构造器来解决(需要是singleton)

怎么检测循环依赖

检测循环依赖相对比较容易，Bean在创建的时候可以给该Bean打标，如果递归调用回来发现正在创建中的话， 即说明了循环依赖了。

Spring容器将每一个正在创建的Bean 标识符放在一个“当前创建Bean池”中，Bean标识符在创建过程中将一直保持在这个池中，因此如果在发现已经在“当前创建Bean池”里,将抛出BeanCurrentlyInCreationException异常表示循环依赖；而对于创建完毕的Bean将从“当前创建Bean池”中清除掉。

//DefaultSingletonBeanRegistry
protected void beforeSingletonCreation(String beanName) {        
  if (!this.singletonsCurrentlyInCreation.add(beanName)) {            
    throw new BeanCurrentlyInCreationException(beanName);       
  }    
}

怎么检测循环依赖

提前暴露。
假如A，B循环依赖

1. 实例Ａ，将未注入属性的A，暴露给容器(Wrap)
2. 给A注入属性，发现要用B
3. 实例Ｂ，注入属性，发现要用Ａ，在单例缓存中没有找到Ａ，又去Warp中找到了，注入完成
4. 递归回来，A成功注入Ｂ

//初始化Bean之前提前把Factory暴露出去
addSingletonFactory(beanName, new ObjectFactory() {                
  public Object getObject() throws BeansException {                   
   return getEarlyBeanReference(beanName, mbd, bean);                
  }            
});

//通过暴露Factory的方式暴露，是因为有些Bean是需要被代理的
protected Object getEarlyBeanReference(String beanName, 
RootBeanDefinition mbd, 
Object bean) {        
  Object exposedObject = bean;        

  if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {            
    for (Iterator it = getBeanPostProcessors().iterator(); it.hasNext(); ) {               
       BeanPostProcessor bp = (BeanPostProcessor) it.next();             

       if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {                   
        SmartInstantiationAwareBeanPostProcessor ibp 
          = (SmartInstantiationAwareBeanPostProcessor) bp;                    
        exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);               
       }          
    }        
  }        
  return exposedObject;   
}

// 在Bean 的单例缓存中获取Bean
protected Object getSingleton(String beanName, boolean allowEarlyReference) {        
  Object singletonObject = this.singletonObjects.get(beanName);        
  if (singletonObject == null) {           
   synchronized (this.singletonObjects) {               
      // 单例缓存中没有，找提前暴露的                
      singletonObject = this.earlySingletonObjects.get(beanName);
      if (singletonObject == null && allowEarlyReference) {                    
        ObjectFactory singletonFactory = (ObjectFactory) this
                            .singletonFactories.get(beanName);       
             
        // 如果只是提前暴露了工厂(没有实例)，执行工厂方法         
          if (singletonFactory != null) {                                           
            singletonObject = singletonFactory.getObject(); 
            this.earlySingletonObjects.put(beanName, singletonObject);                      
            this.singletonFactories.remove(beanName);                   
         }               
       }            
    }       
   }       
 return (singletonObject != NULL_OBJECT ? singletonObject : null);    
}

Spring 的几个缓存池 :

• alreadyCreated：已经创建好的Bean ，检测创建好的Bean是否依赖正在创建的Bean，如果是，说明原创建好多不可用了
• singletonObjects：单例Bean
• singletonFactories : 单例Bean 提前暴露的工厂
• earlySingletonObjects：执行了工厂方法生产出的Bean
• singletonsCurrentlyCreation：创建中的Bean ，用于检测循环依赖

所以循环依赖无法解决的有
构造器注入
代理类改变了Bean的版本(见alreadyCreated，提前暴露的别的Bean 依赖了，之后)
原型Bean (prototype)
参考乌哇哇这里

---

协调不同步的Bean

---

简单的说，一个如果一个singleton的Bean 依赖一个prototype 的Bean的时候，会产生不同步的情况(因为singleton只创建一次，当singleton调用 prototype 的时候，一般的注入没办法让 Spring 容器每次都返回一个新的 prototype的Bean)。
两种方法：

1. 让singleton 的bean 实现 ApplicationContextAware 接口

public class A implements ApplicationContextAware {  
    //用于保存ApplicationContext的引用，set方式注入  
    private ApplicationContext applicationContext;  
    //模拟业务处理的方法  
    public Object process(){  
        B b = createB();  
        return b.execute();  
    }  
    private B createB() {  
        return (B) this.applicationContext.getBean("b"); //  
    }    
    public void setApplicationContext(ApplicationContext applicationContext)  
            throws BeansException {  
        this.applicationContext=applicationContext;//获得该ApplicationContext引用  
    }  
}  

2 . lookup 方法

public abstract class A{  
    //模拟业务处理的方法  
    public Object process(){  
        B b= createB();  
        return b.execute();  
    }  
    protected abstract B createB();  
}  

  
  
        
  

推荐用第二种方法，这样和Spring的代码没有耦合。
createB() 方法是个抽象方法，我们并没有实现它啊，那它是怎么拿到B类的呢。这里的奥妙就是Srping应用了CGLIB（动态代理）类库。这个方法是不是抽象都无所谓，不影响CGLIB动态代理。
在这个方法的代码签名处有个标准：

[abstract] theMethodName(no-arguments);

• public|protected要求方法必须是可以被子类重写和调用的；
• abstract可选，如果是抽象方法，CGLIB的动态代理类就会实现这个方法，如果不是抽象方法，就会覆盖这个方法，所以没什么影响；
• return-type就是non-singleton-bean的类型咯，当然可以是它的父类或者接口。
• no-arguments不允许有参数。

---

AOP

AOP （Aspect-OrientedProgramming，面向方面编程），是对OOP（Object-Oriented Programing，面向对象编程）的补充。
传统的OOP模式编程，会在每个类调用一些共同的方法（log，安全检查，事务，性能统计，异常处理等）。
这些方法会造成代码的冗余，而且曾加的代码的耦合性(功能逻辑和业务逻辑没有分开)

实现AOP的两种方式：

• XML风格，使用

首先定义一个要被切的类

public interface PersonService {
    public String getPersonName(Integer id);
    public void save(String name);
}


public class PersonServiceBean implements PersonService {
    @Override
    public String getPersonName(Integer id) {
        // TODO Auto-generated method stub
        return null;
    }
    @Override
    public void save(String name) {
        // TODO Auto-generated method stub
        System.out.println("您输入的是" + name);
    }    
}

然后，我们来定义切点类和切点

public class MyInterceptor {
    
    public void anyMethod(){}

    public void doBefore(String name){
        System.out.println("前置通知" + name);
    }
    
    public void doAfterReturn(String result){
        System.out.println("后置通知" + result);
    }
    
    public Object doAfter(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("进入方法");
        Object result = pjp.proceed();
        System.out.println("最终通知");
        return result;
    }
    
    public void doAfterThrowing(Exception e){
        System.out.println("异常通知" + e);
    }
    
    public void doAround(){
        System.out.println("环绕通知");
    }
}



    
    
        
             
            
            
            
            
            
            
        
    

    
    

• @Aspect 风格

//启动 aspectj 代理


public class MyInterceptor {
    @Pointcut("execution (* cn.qdlg.service.impl.PersonServiceBean.*(..))")
    public void anyMethod(){}

    @Before("anyMethod()")
    public void doBefore(String name){
        System.out.println("前置通知" + name);
    }
    
    @AfterReturning("anyMethod() && args(name)")
    public void doAfterReturn(String result){
        System.out.println("后置通知" + result);
    }
    
    @After("anyMethod()")
    public Object doAfter(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("进入方法");
        Object result = pjp.proceed();
        System.out.println("最终通知");
        return result;
    }
    
    @AfterThrowing("anyMethod()")
    public void doAfterThrowing(Exception e){
        System.out.println("异常通知" + e);
    }
    
    @Around("anyMethod()")
    public void doAround(){
        System.out.println("环绕通知");
    }
}

AOP 实现的方式，动态代理----- >http://www.jianshu.com/p/6411406ef7c3

https://my.oschina.net/elain/blog/382494