術(shù)語(yǔ)

Guice：整個(gè)框架的門面
Injector：一個(gè)依賴的管理上下文
Binder：一個(gè)接口和實(shí)現(xiàn)的綁定
Module：一組Binder
Provider：bean的提供者
Key：Binder中對(duì)應(yīng)一個(gè)Provider
Scope：Provider的作用域
Stage：運(yùn)行方式（為了不同的要求）

使用實(shí)例

public class FooApplication {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(
            new ModuleA(),
            new ModuleB(),
            . . .
            new FooApplicationFlagsModule(args)
        );
        // Now just bootstrap the application and you're done
        FooStarter starter = injector.getInstance(FooStarter.class);
        starter.runApplication();
    }
}

關(guān)于Stage以及如何選擇？

　　stage分為三種，是三個(gè)不同場(chǎng)景下對(duì)應(yīng)的值，選擇Stage.TOOL時(shí)一些操作則不會(huì)支持，例如：java.lang.UnsupportedOperationException:Injector.injectMembers(Object) is not supported in Stage.TOOL

TOOL（最小代價(jià)，有些功能會(huì)無(wú)法使用）
DEVELOPMENT（快速啟動(dòng)，但不會(huì)做校驗(yàn)）
PRODUCTION（異常檢查與性能，啟動(dòng)會(huì)比較慢）

Guice.createInjector(Stage.PRODUCTION, new ModuleA());
Guice.createInjector(new ModuleA());//默認(rèn)DEVELOPMENT

Module（模塊）
　　Module內(nèi)利用BindingBuilder生成Binder，如何實(shí)現(xiàn)一個(gè)Module?

public class EventModule extends AbstractModule {
    @Override
    protected void configure() {
　　　　bind(EventBusManager.class).annotatedWith(Names.named("eventBusManager")).to(EventBusManager.class);
    }
}

幾種bind方式

bind(EventService.class).to(SpringEventService.class);
bind(EventService.class).toInstance(new SpringEventService());
bind(SpringEventService.class).asEagerSingleton();
bind(EventService.class).toProvider(new Provider<EventService>(){    
    @Override    
    public EventService get(){        
       return new SpringEventService();    
    }
});
bind(EventService.class).toConstructor((Constructor<SpringEventService>)SpringEventService.class.getConstructors()[0]);

　　注意：第一個(gè)直接to(implemet)的方式是getProvider時(shí)new出的Provider，第二種是用Providers.of(instance)生成的ConstantProvider

注入依賴@Inject

@Singleton
public class MyHandler {    
   @Inject    
   @Named("springEventService")    
   private EventService eventService;    
   @Subscribe    
   public void handleEvent(MyEvent event) {     
      eventService.post("MyHandler",event);    
   }
}

　　@Inject和@Named結(jié)合使用達(dá)到按名字注入，@Inject的optional默認(rèn)為false，注入時(shí)如果依賴不存在，則報(bào)錯(cuò)停止，當(dāng)使用@Inject(optional = true)時(shí)可達(dá)到忽視依賴是否存在的效果

實(shí)例創(chuàng)建

FooStarter starter = injector.getInstance(FooStarter.class);

　　如果injector已經(jīng)有則直接返回已有對(duì)象，沒(méi)有則創(chuàng)建一個(gè)（利用依賴注入，如果沒(méi)有綁定過(guò)則不會(huì)被依賴注入），默認(rèn)prototype模式（每次都新建一個(gè)），@Singleton可以指定singleton模式

getInstance的過(guò)程

　　先根據(jù)指定的class類new Key()，Key包括class信息和注解信息，class的hashcode和注解的hashcode決定了Key的hashcode，getProvider時(shí)是根據(jù)Key的hashcode來(lái)判斷是否是同一個(gè)Key，然后取到Provider，由Provider提供最終的instance
注意：無(wú)注解時(shí)會(huì)有一個(gè)默認(rèn)的hashcode

Key的hashcode計(jì)算公式

class.hashcode * 31 + annotation.hashcode
會(huì)出現(xiàn)多個(gè)組合得到的hashcode是相同的情況么？
2 * 31 + 3 = 65
1 * 31 + 34 = 65
為什么用這樣的公式？(java中String是如何計(jì)算hashcode的？)

Joshua Bloch's Effective Java中是這樣解釋的：
The value 31 was chosen because it is an odd prime. If it were even and the multiplication overflowed, information would be lost, as multiplication by 2 is equivalent to shifting. The advantage of using a prime is less clear, but it is traditional. A nice property of 31 is that the multiplication can be replaced by a shift and a subtraction for better performance: 31 * i == (i << 5) - i. Modern VMs do this sort of optimization automatically.(from Chapter 3, Item 9: Always override hashcode when you override equals, page 48)
選擇值31是因?yàn)樗瞧鏀?shù)。 如果是偶數(shù)并且乘法溢出，則信息將丟失，因?yàn)槌艘?等效于移位。 使用素?cái)?shù)的優(yōu)點(diǎn)不太清楚，但它是傳統(tǒng)的。 31的一個(gè)好的屬性是乘法可以由移位和減法替換以獲得更好的性能：31 * i ==（i << 5） - i。 現(xiàn)代虛擬機(jī)自動(dòng)進(jìn)行這種優(yōu)化。（從第3章，項(xiàng)9：覆蓋equals時(shí)始終覆蓋hashcode，第48頁(yè)）

參考：
http://stackoverflow.com/questions/299304/why-does-javas-hashcode-in-string-use-31-as-a-multiplier
https://www.cs.cmu.edu/~adamchik/15-121/lectures/Hashing/hashing.html

Guice對(duì)于classloader的依賴有多重要？

　　由于一個(gè)class被加載后是否唯一由加載的classloader決定，所以不同的classloader加載同一個(gè)class會(huì)生成兩個(gè)class實(shí)例（反射中一個(gè)class也會(huì)有一個(gè)實(shí)例），兩個(gè)不同的class生成的Key的hashcode則不同，所以在Guice中根據(jù)Key來(lái)獲取時(shí)必須要用同一個(gè)classloader加載的類，否則獲取不到，所以在OSGI方式下用Guice需要注意

injector.injectMembers(instance)

Injector injectorBase = Guice.createInjector(new EventModule());
Injector injector = injectorBase.createChildInjector(new SpringModule());
MyHandler handler = new MyHandler();// eventService is null
injector.injectMembers(handler);// eventService use instance

　　用一個(gè)已經(jīng)有的實(shí)例，但依賴的對(duì)象為null，這時(shí)可以用injector注入依賴對(duì)象，但這個(gè)實(shí)例不會(huì)有綁定關(guān)系，所以如果其他有需要依賴這個(gè)實(shí)例的也無(wú)法注入這個(gè)實(shí)例

Injector繼承

Injector parent = Guice.createInjector(new EventModule());
Injector child = parent .createChildInjector(new SpringModule());

　　child 可以依賴parent ，但反過(guò)來(lái)則不可以

依賴范圍

　　一個(gè)Injector中如果包含了多個(gè)Module，各Module中的是可以相互使用的，也就是可以相互依賴
　　如果一個(gè)Injector想依賴另一個(gè)Injector中的實(shí)例，那就要通過(guò)繼承了，例如功能模塊想要依賴基礎(chǔ)模塊，那功能模塊可以繼承基礎(chǔ)模塊

依賴Tree

AOP in Guice

Binder#bindInterceptor(Matcher<? super Class<?>> classMatcher,    Matcher<? super Method> methodMatcher,    org.aopalliance.intercept.MethodInterceptor... interceptors)
bindInterceptor(Matchers.any(),Matchers.annotatedWith(Named.class),new MethodInterceptor(){    
@Override    
public Object invoke(MethodInvocation invocation) throws Throwable {        
   System.out.println("do something before...");
   Object result = invocation.proceed();        
   System.out.println("do something after...");        
   return result;    
   }
});

Matcher通過(guò)Matchers來(lái)生成

與spring整合

如何解決這種相互依賴？

達(dá)到的效果：

處理過(guò)程：

代碼：

將spring中的bean暴露給Guice：

public class SpringModule extends AbstractModule {    
   private ConfigurableListableBeanFactory beanFactory;    
   public SpringModule(ConfigurableListableBeanFactory beanFactory){        
      this.beanFactory = beanFactory;    }    
      @Override    
      protected void configure() {        
         bind(BeanFactory.class).toInstance(this.beanFactory);        
         String[] names = this.beanFactory.getBeanDefinitionNames();        
         for (String name : names) {            
            try {                
               Object instance = this.beanFactory.getBean(name);                
               Class clazz = instance.getClass();                
               bind(clazz).toInstance(instance);                
               Class[] intefaces = clazz.getInterfaces();                
               for (Class inteface: intefaces) {                    
                  if (!inteface.getName().contains("com.xxxxxx")) {                        
                     continue;                    
                  }                    
                  bind(inteface).annotatedWith(Names.named(name)).toInstance(instance);                
               }                
               bind(clazz).annotatedWith(Names.named(name)).toInstance(instance);            
            } catch (Exception e) {            
         }        
      }    
   }
}

將Guice里的beans暴露給spring：

@Component
public class PbfInitProcesser implements BeanFactoryPostProcessor {    
   @Override    
   public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {        
      // map injector to spring beanFactory        
      Injector spring = Guice.createInjector(new SpringModule(beanFactory));        
      Injector injector = spring.createChildInjector(new ProductModule());        
      PbfEnvInitUtil.shareGuiceToSpring("injector", beanFactory, injector);    
   }
}

public class PbfEnvInitUtil {    
   public static final void refresh(ApplicationContext context) {        
      // refresh inject bean to autowire        
      String names[] = context.getBeanDefinitionNames();        
      for (String name : names) {            
         context.getAutowireCapableBeanFactory().autowireBean(context.getBean(name));        
      }    
   }    
   public static void shareGuiceToSpring(String bizName, ConfigurableListableBeanFactory beanFactory, Injector injector) {        
      Map<Key<?>, Binding<?>> map = injector.getAllBindings();        
      Iterator<Map.Entry<Key<?>, Binding<?>>> iterator = map.entrySet().iterator();        
      while (iterator.hasNext()) {            
         Map.Entry<Key<?>, Binding<?>> entry = iterator.next();            
         Binding<?> binding = entry.getValue();            
         Object listener = binding.getProvider().get();            
         Annotation annotation = entry.getKey().getAnnotation();            
         if (null != annotation && annotation instanceof Named) {                
            String name = ((Named)annotation).value();                
            try {                    
               beanFactory.registerSingleton(name, listener);                
            } catch (Exception e) {                
            }            
         }         
      }        
      beanFactory.registerSingleton(bizName, injector);    
   }
}

springboot中使用：

ApplicationContext context = SpringApplication.run(Application.class, args);
PbfEnvInitUtil.refresh(context);

總結(jié)

以上是生活随笔為你收集整理的深入剖析Guice（Google依赖注入框架）的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。