Spring闲谈

作者: 赐我理由在披甲上阵 | 来源:发表于2016-12-05 16:07 被阅读18次

    依赖注入(Inverse of Control)


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

    Bean 的作用域 singleton (默认) ,prototyperequestsessionglobal 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,将未注入属性的A,暴露给容器(Wrap)
    2. 给A注入属性,发现要用B 
    3. 实例B,注入属性,发现要用A,在单例缓存中没有找到A,又去Warp中找到了,注入完成
    4. 递归回来,A成功注入B
    
    

    //初始化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

    相关文章

      网友评论

        本文标题:Spring闲谈

        本文链接:https://www.haomeiwen.com/subject/tdaxmttx.html