Can be found: https://github.com/xbaran/guice-presentation

traditionally low level modules define how higher level modules interface with them

public class JavaGroupBrewery {

  private JavaBeerFaucet javaBeerFaucet;
  private Boolean openStatus = Boolean.FALSE;

  public JavaGroupBrewery() {
    buildBrewery();
    this.javaBeerFaucet = new JavaBeerFaucet();
  }

  public void openBrewery() { ... }
  public void closeBrewery() { ... }
  public Boolean isOpen() { ... }

  public JavaBeer orderBeer() {
    try {
      return this.javaBeerFaucet.pourBeer();
    } catch (JavaBeerKeg.EmptyKegException e) {
      this.javaBeerFaucet.replaceEmptyKeg(new JavaBeerKeg());
      return orderBeer();
    }
  }

  public JavaBeer orderSmallBeer() { ... }
  private void cleanUp(JavaBeerFaucet javaBeerFaucet) { ... }
  private void buildBrewery() { ... }

} 

   public World() {
    JavaCustomer Milan = new JavaCustomer("Milan");
    JavaCustomer Peter = new JavaCustomer("Peter");
    JavaCustomer Jaro = new JavaCustomer("Jaro");

    JavaGroupBrewery brewery = new JavaGroupBrewery();
        brewery.openBrewery();

    Milan.goGetSomeBeer(brewery);
    Peter.goGetSomeBeer(brewery);
    Jaro.goGetSomeBeer(brewery);

    Peter.goGetSomeBeer(brewery);

    brewery.closeBrewery();

    Peter.goGetSomeBeer(brewery);
    Peter.goGetSomeBeer(brewery);

  }

with IoC high level modules define interfaces that lower level modules should implement

 public interface Brewery {
  void openBrewery();
  void closeBrewery();
  Boolean isOpen();
  Beer orderBeer();
  Beer orderSmallBeer();
}

public interface BeerFaucet {
  public void replaceEmptyKeg(BeerKeg beerKeg);
  public Beer pourBeer() throws BeerKeg.EmptyKegException;
}

public interface BeerKeg {
  Beer pull(float amount) throws EmptyKegException;
  public class EmptyKegException extends Throwable {};
}

public interface Beer {
  Boolean isStrong();
  String getBrand();
}

public class GenericBeerKeg extends SimpleBeerKeg {
  private BeerFactory beerFactory;

  public GenericBeerKeg(float capacity, BeerFactory beerFactory) {
    this.beerFactory = beerFactory;
  }

  protected Beer createBeer() {
    return beerFactory.get();
  };
}

   public World() {
    BeerKegFactory javaBeerKegFactory = 
             new SimpleBeerKegFactory(50, JavaBeer.class);    Brewery javaPivarna = 
             new SimpleBrewery(
                new SimpleBeerFaucet(javaBeerKegFactory.orderBeerKeg()),
                javaBeerKegFactory);


    Customer Milan = new CommonCustomer("Milan"); 
    Customer Peter = new CommonCustomer("Peter",
                                         new NeverGoHomeStrategy());
    Customer Jaro = new CommonCustomer("Jaro",
                                        new PesimisticDrinkingStrategy(),
                                        new TimeToGoHomeStrategy());

    javaPivarna.openBrewery();

    Milan.goGetSomeBeer(zamockyBrewery);
    Milan.goGetSomeBeer(javaPivarna);
    Peter.goGetSomeBeer(zamockyBrewery);
    Jaro.goGetSomeBeer(zamockyBrewery);

    zamockyBrewery.closeBrewery();
    javaPivarna.closeBrewery();
  }

1. Multiline construtors and factories aren't fun
2. @Inject is the new new
3. Extensions and advanced features
   
4. No XML
5. Typesafe binding
   
6. More up front checking
7. Rich injection error messages
8. Small overhead
9. Small memory footprint (<700kB)

public class GuicedBrewery extends SimpleBrewery {  @Inject protected BeerFaucet beerFaucet;
  @Inject protected BeerKegFactory beerKegFactory;

public GuicedBrewery() {
   super(beerFaucet, beerKegFactory); //Cannot reference before supertype
}}

 public class SimpleWorldModule extends AbstractModule {

  @Override
  protected void configure() {
    bind(Brewery.class).to(GuicedBrewery.class);
    bind(BeerFaucet.class).to(GuicedBeerFaucet.class);
    bind(BeerKeg.class).to(GuicedBeerKeg.class);
    bindConstant().annotatedWith(Names.named("keg.capacity")).to(50F);
    bind(Beer.class).to(JavaBeer.class);
  }

• Implicitly all bindings are providers
• Binding can be declaread as Provider<BindingClass>
  
• to lazy loading
• to get multiple instances
• to mix scopes
• to debug

public interface Provider<T> {
  T get();
}

 bind(Beer.class).to(JavaBeer.class);
 bind(Beer.class).toProvider(JBeerProvider.class);//impl. Provider<Beer>
 bind(Beer.class).toProvider(new Provider<Beer>() {
      @Override
      public Beer get() {
        return new JavaBeer();
      }
 });

public class SimpleWorldModule extends AbstractModule {
@Override
  protected void configure() {...}

@Provides
public BeerKegFactory 
       providesBeerKegFactory(final Provider<BeerKeg> beerKeg) 
{    return new BeerKegFactory() {
      @Override
      public BeerKeg orderBeerKeg() {
        return beerKeg.get();
      }
    };
}

• high level interfaces
• generic low level implementation
• integraton with Guice
• and SimpleWorldModule

 [PilsnerBeer, KozelBeer, JavaBeer, CorgonBeer, SvijanyBeer]

 protected void configure() {
    bind(Brewery.class).to(GuicedBrewery.class);
    bind(BeerFaucet.class).to(GuicedBeerFaucet.class);
    bind(BeerKeg.class).to(GuicedBeerKeg.class);
    bindConstant().annotatedWith(Names.named("keg.capacity")).to(50F);
    bind(Beer.class).to(JavaBeer.class);       bind(Brewery.class).to(GuicedBrewery.class);
    bind(Beer.class).to(PilsnerBeer.class);     }

@BindingAnnotation
@Target({ FIELD, PARAMETER, METHOD })
@Retention(RUNTIME)
public @interface BreweryPub {
  String value();
}

 bind(Brewery.class)
 .annotatedWith(new BreweryPubImpl("Java")).to(GuicedBrewery.class); bind(Beer.class)
 .annotatedWith(new BreweryPubImpl("Java")).to(JavaBeer.class);

 bind(Brewery.class)
 .annotatedWith(new BreweryPubImpl("Pilsner")).to(GuicedBrewery.class);
 bind(Beer.class)
 .annotatedWith(new BreweryPubImpl("Pilsner")).to(PilsnerBeer.class);

  public class ComplexWorldModule extends AbstractModule {

  @Override
  protected void configure() {
    install(new PrivateBreweryModule(PilsnerBeer.class));
    install(new PrivateBreweryModule(KozelBeer.class));
    install(new PrivateBreweryModule(JavaBeer.class));
    install(new PrivateBreweryModule(ZamockyBeer.class));
  }

 @Inject
  public GuicedWorld(
      @BreweryPub("PilsnerBeer") Brewery pilsnerPub,
      @BreweryPub("KozelBeer")   Brewery kozelPub,
      @BreweryPub("JavaBeer")    Brewery javaPub,
      @BreweryPub("ZamockyBeer") Brewery zamockyPub
  ) {
    pilsnerPub.openBrewery();
    kozelPub.openBrewery();
    javaPub.openBrewery();
    zamockyPub.openBrewery();
        ... and get the party started!!!
  }

 public class ComplexWorldModuleTest {
  @Test
  public void testComplexWorldInjection() throws Exception {
    Injector inj = Guice.createInjector(new ComplexWorldModule());
    inj.injectMembers(this);

    Brewery pilsnerPub = inj.getInstance(
             Key.get(Brewery.class, new BreweryPubImpl("PilsnerBeer")));
    Brewery javaPub = getJavaPub();
    Assert.assertNotNull(javaPub);
    Assert.assertNotSame(javaPub,pilsnerPub);
    Assert.assertEquals("Java",javaPub.orderBeer().getBrand());  }

  @Inject
  public void getJavaPub(@BreweryPub("JavaBeer") Brewery javaPub) {
    this.javaPub = javaPub;
  }

  public Brewery getJavaPub() {
    return this.javaPub;
  };

• IoC pattern
  
• Dependency injection via creation inversion
• Guice introduction
• Types of injections
• Modules - Abstract, Private
• Module bindings
• Providers
• Annotations

• Scopes, Stages
• Extensions
• ServletModule
• MultiBindings
• AssistedInjection
• Throwing providers
• SPI
• Integration with 3th party frameworks
• Apache Shiro - security
• Apache Camel - integration
• Sitebricks - lightweight web framework
• Vaadin, Jersey, ...