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配置文件
    <beans>
      <bean id = "byIndex"  class = "com.example.ExampleFactory"
           factory-method="newInstance">
          <constructor-arg index="0" value="Hello World!"/>  
          <constructor-arg index="1" value="1"/>  
      </bean>
   </beans>
   ```
  

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

    ---- xml配置文件
    <beans>
        <bean id = "exampleFactory" class = "com.example.ExampleFactory"/>
  
        <bean id = "byName"  factory-bean = "exampleFactory" 
            factory-method="newInstance">
          <constructor-arg name="message" value="Hello World!"/>  
          <constructor-arg name="index" value="1"/>  
        </bean>
   </beans>
  

---

循环依赖问题

---

• 构造器注入的循环依赖问题是无法解决的
• 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)
参考[乌哇哇这里](https://my.oschina.net/tryUcatchUfinallyU/blog/287936)

---
 
## 协调不同步的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();
}

<bean id="b" class="com.example.B" scope="prototype"/>
<bean id="a" class="com.example.A">
<lookup-method name="createB" bean="b"/>
</bean>

 推荐用第二种方法，这样和Spring的代码没有耦合。
createB() 方法是个抽象方法，我们并没有实现它啊，那它是怎么拿到B类的呢。这里的奥妙就是Srping应用了CGLIB（动态代理）类库。这个方法是不是抽象都无所谓，不影响CGLIB动态代理。
在这个方法的代码签名处有个标准：
> <public|protected> [abstract] <return-type> 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风格，使用<aop:config>

首先定义一个要被切的类

```java

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("环绕通知");
    }
}


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
    
    <aop:config>
        <aop:aspect id="asp" ref="myInterceptor">
             <!-- 切点-->
            <aop:pointcut  id="mycut" 
      expression="execution(* cn.qdlg.service.impl.PersonServiceBean.*(..))"/>
            <aop:before pointcut-ref="mycut" method="doBefore"/>
            <aop:after pointcut-ref="mycut" method="doAfter"/>
            <aop:after-returning pointcut-ref="mycut" method="doAfterReturn"/>
            <aop:around pointcut-ref="mycut" method="doAround"/>
            <aop:after-throwing pointcut-ref="mycut" method="doAfterThrowing"/>
        </aop:aspect>
    </aop:config>

    <bean id="myInterceptor" class="cn.qdlg.service.MyInterceptor"></bean>
    <bean id="PersonService" class="cn.qdlg.service.impl.PersonServiceBean"></bean>
</beans>

• @Aspect 风格

//启动 aspectj 代理
<aop:aspectj-autoproxy proxy-target-class="true"/>

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