spring揭秘读书笔记一 IoC初探

最新推荐文章于 2021-09-01 11:06:53 发布

程序员小董

最新推荐文章于 2021-09-01 11:06:53 发布

阅读量1.8k

点赞数

分类专栏： spring spring揭秘读书笔记文章标签： spring 读书笔记 IoC

本文链接：https://blog.csdn.net/dlf123321/article/details/47813985

版权

spring 同时被 2 个专栏收录

29 篇文章 1 订阅

订阅专栏

spring揭秘读书笔记

8 篇文章 10 订阅

订阅专栏

本文是王福强所著<<spring揭秘>>一书的读书笔记

ioc的基本概念

一个例子

我们看下面这个类,getAndPersistNews方法干了四件事
1 通过newsListener获得所有的新闻id;
2 通过newsListener,用新闻id获得新闻实体
3 用newPersistener存储新闻实体
4 再使用newsListener发布新闻

public class FXNewsProvider  
{ 


  private IFXNewsListener  newsListener; 
  private IFXNewsPersister newPersistener; 
  
    public void getAndPersistNews() { 
     String[] newsIds = newsListener.getAvailableNewsIds(); 
     if(ArrayUtils.isEmpty(newsIds)) { 
	  return; 
     }     
   
   for(String newsId : newsIds) { 
     FXNewsBean newsBean = newsListener.getNewsByPK(newsId); 
     newPersistener.persistNews(newsBean); 
     newsListener.postProcessIfNecessary(newsId); 
    }
    
  } 
}

但是newsListener与newPersistener到底从什么地方来呢?
一般情况下或者说我们自己写代码的时候一般在FXNewsProvider的构造方法里生成newsListener与newPersistener。代码如下:

public FXNewsProvider()  { 
  newsListener   = new DowJonesNewsListener(); 
  newPersistener = new DowJonesNewsPersister(); 
}

我们分析一下上面的代码,如果对照我们现实生活,那就是我们在造房子的同时自己手工造出(通过new方式)家具。
当然还有可能,你可以去工厂,让他们给你生产。

从代码角度来说,上面的没有问题,还很简洁。
可是,之前是用的一家公司(例如新华社)提供的IFXNewsListener,IFXNewsPersister。如果我想用另一家公司(例如法新社)的IFXNewsListener,IFXNewsPersister怎么办?
方法1 新建一个类继承FXNewsProvider,在FXNewsProvider2的构造方法里使用法新社的IFXNewsListener,IFXNewsPersister,然后getAndPersistNews方法就引用父类的即可。
方法2 重新写一个类似的类,如FXNewsProvider2.....
之前的代码,我们可以理解为是FXNewsProvider自己去取所依赖的组件,那么一旦使用新的组件,我们的更新就会比较麻烦。

那么如果把主动的"取",改为被动地"接受"呢?
构造方法如下:

public FXNewsProvider(IFXNewsListener newsListner,IFXNewsPersister newsPersister)  { 
  this.newsListener   = newsListner; 
  this.newPersistener = newsPersister; 
}

//使用DowJones家的新闻
FXNewsProvider dowJonesNewsProvider =
new FXNewsProvider(new DowJonesNewsListener(),new DowJonesNewsPersister()); 
//MarketWin24家的新闻
FXNewsPrivider marketWin24NewsProvider = 
new FXNewsProvider(new MarketWin24NewsListener(),new DowJonesNewsPersister());

这样一来,你想用谁的就用谁的。因为是别人给你推送(注入)过来的嘛。

注入方式

有三种,接口注入,构造方法注入,setter方法注入。
构造方法注入上面已经介绍了。
接口注入现在基本已经不用了,大家不用理会。
setter方法注入,例子如下:

public class FXNewsProvider  { 
  private IFXNewsListener  newsListener; 
  private IFXNewsPersister newPersistener; 
  
  public IFXNewsListener getNewsListener() { 
   return newsListener; 
  } 
  public void setNewsListener(IFXNewsListener newsListener) { 
   this.newsListener = newsListener; 
  } 
  public IFXNewsPersister getNewPersistener() { 
   return newPersistener; 
  } 
  public void setNewPersistener(IFXNewsPersister newPersistener) { 
   this.newPersistener = newPersistener; 
  } 
}

看上去太简单了,不是吗。

掌管大局的IoC Service Provider

我们第二章说了,让别人来来给我"推送"我所需要的组件。
那么这个别人到底是谁?
别人就是IoC Service Provider。
IoC Service Provider在这里是一个抽象出来的概念，它可以指代任何将IoC场景中的业务对象绑定到一起的实现方式。它可以是一段代码，也可以是一组相关的类，甚至可以是比较通用的IoC框架或者IoC容器实现。
我们可以认为下面这4行代码就是IoC Service Provider,因为它完成了任务----将IoC场景中的业务对象绑定到一起

IFXNewsListener newsListener = new DowJonesNewsListener(); 
IFXNewsPersister newsPersister = new DowJonesNewsPersister(); 
FXNewsProvider newsProvider = new FXNewsProvider(newsListener,newsPersister); 
newsProvider.getAndPersistNews();

IoC Service Provider的职责

1 生产对象
2 绑定对象间的依赖关系。

如何管理依赖关系

硬编码

IoContainer container = ...; 
container.register(FXNewsProvider.class,new FXNewsProvider()); 
container.register(IFXNewsListener.class,new DowJonesNewsListener()); 
container.register(IFXNewsPersister.class,new DowJonesNewsPersister()); 


//setRelation这个方法是我自己写的 sping不会这么干的 但是大概能说明问题
container.setRelation(FXNewsProvider.class,newsListener,IFXNewsListener.class);
container.setRelation(FXNewsProvider.class,newPersistener,IFXNewsPersister.class);


FXNewsProvider newsProvider = (FXNewsProvider)container.get(FXNewsProvider.class); 
newProvider.getAndPersistNews();

在书的第四章,有一个硬编码的列子:

public static void main(String[] args)  {  
  DefaultListableBeanFactory beanRegistry = new DefaultListableBeanFactory(); 
  BeanFactory container = (BeanFactory)bindViaCode(beanRegistry); 
  FXNewsProvider newsProvider = 
  (FXNewsProvider)container.getBean("djNewsProvider"); 
  newsProvider.getAndPersistNews(); 
} 
 
public static BeanFactory bindViaCode(BeanDefinitionRegistry registry) { 
    AbstractBeanDefinition newsProvider = 
    new RootBeanDefinition(FXNewsProvider.class,true); 
    AbstractBeanDefinition newsListener = 
    new RootBeanDefinition(DowJonesNewsListener.class,true); 
    AbstractBeanDefinition newsPersister = 
    new RootBeanDefinition(DowJonesNewsPersister.class,true); 


    // 将bean定义注册到容器中 
    registry.registerBeanDefinition("djNewsProvider", newsProvider); 
    registry.registerBeanDefinition("djListener", newsListener); 
    registry.registerBeanDefinition("djPersister", newsPersister); 


    // 指定依赖关系 
    // 1. 可以通过构造方法注入方式 
    ConstructorArgumentValues argValues = new ConstructorArgumentValues(); 
    argValues.addIndexedArgumentValue(0, newsListener); 
    argValues.addIndexedArgumentValue(1, newsPersister); 
    newsProvider.setConstructorArgumentValues(argValues); 
  
    // 2. 或者通过setter方法注入方式 
    MutablePropertyValues propertyValues = new MutablePropertyValues(); 
    propertyValues.addPropertyValue(new ropertyValue("newsListener",newsListener)); 
    propertyValues.addPropertyValue(new PropertyValue("newPersistener",newsPersister)); 
    newsProvider.setPropertyValues(propertyValues); 
    // 绑定完成      
    return (BeanFactory)registry; 
}

不是很难,大家应该能看懂。

配置文件方式

<bean id="newsProvider" class="..FXNewsProvider"> 
  <property name="newsListener"> 
   <ref bean="djNewsListener"/> 
  </property> 
  <property name="newPersistener"> 
   <ref bean="djNewsPersister"/> 
  </property> 
</bean> 
 
<bean id="djNewsListener"  
  class="..impl.DowJonesNewsListener"> 
</bean> 
<bean id="djNewsPersister"  
  class="..impl.DowJonesNewsPersister"> 
</bean>

... 
container.readConfigurationFiles(...); 
FXNewsProvider newsProvider = (FXNewsProvider)container.getBean("newsProvider"); 
newsProvider.getAndPersistNews();

元数据方式(注解方式)

这种方式的代表实现是Google Guice。我们可以直接在类中使用元数据信息来标注各个对象之间的依赖关系，然后由Guice框架根据这些注解所提供的信息将这些对象组装后，交给客户端对象使用。

public class FXNewsProvider  {   
  private IFXNewsListener  newsListener; 
  private IFXNewsPersister newPersistener; 


  @Inject 
  public FXNewsProvider(IFXNewsListener listener,IFXNewsPersister persister)    { 
    this.newsListener   = listener; 
    this.newPersistener = persister; 
  } 


}

通过构造方法上的 @Inject,Guice就知道这个用构造方法注入方式,当然具体注入哪个对象,还需要别的信息,在Guice中是由Module提供的

 public class NewsBindingModule extends AbstractModule  { 


  @Override 
  protected void configure() { 
   bind(IFXNewsListener.class).to(DowJonesNewsListener.class).in(Scopes.SINGLETON); 
   bind(IFXNewsPersister.class).to(DowJonesNewsPersister.class).in(Scopes.SINGLETON); 
  } 


}

最后的使用

Injector injector = Guice.createInjector(new NewsBindingModule()); 
FXNewsProvider newsProvider = injector.getInstance(FXNewsProvider.class); 
newsProvider.getAndPersistNews();

感谢glt