import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
public static void main(String[] args) {
    LifeManager manager = new LifeManager();
    manager.add(Guice.createInjector(new PrivateModule() {
        @Override
        protected void configure() {
            bind(Service.class).annotatedWith(Names.named("1"))
                    .to(ServiceImpl.class)
                    .in(Scopes.SINGLETON);
            expose(Service.class).annotatedWith(Names.named("1"));
            bind(ImplWorker.class).toInstance(new ImplWorker() {
                @Override
                public void work() {
                    System.out.println("work 1 done");
                }
            });
        }
    }, new PrivateModule() {
        @Override
        protected void configure() {
            bind(Service.class).annotatedWith(Names.named("2"))
                    .to(ServiceImpl.class)
                    .in(Scopes.SINGLETON);
            expose(Service.class).annotatedWith(Names.named("2"));

            bind(ImplWorker.class).toInstance(new ImplWorker() {
                @Override
                public void work() {
                    System.out.println("work 2 done");
                }
            });
        }
    }, new AbstractModule() {
        @Override
        protected void configure() {
            final Annotation id = UniqueAnnotations.create();
            bind(Listener.class).annotatedWith(id).to(Client.class).asEagerSingleton();
        }
    }));
    manager.start();
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
@Override
protected void configure() {
  bind(DestinationFactory.class).in(Scopes.SINGLETON);
  bind(ReplicationQueue.class).in(Scopes.SINGLETON);

  DynamicSet.bind(binder(), GitReferenceUpdatedListener.class).to(ReplicationQueue.class);
  DynamicSet.bind(binder(), NewProjectCreatedListener.class).to(ReplicationQueue.class);
  DynamicSet.bind(binder(), ProjectDeletedListener.class).to(ReplicationQueue.class);
  DynamicSet.bind(binder(), HeadUpdatedListener.class).to(ReplicationQueue.class);

  bind(OnStartStop.class).in(Scopes.SINGLETON);
  bind(LifecycleListener.class).annotatedWith(UniqueAnnotations.create()).to(OnStartStop.class);
  bind(LifecycleListener.class)
      .annotatedWith(UniqueAnnotations.create())
      .to(ReplicationLogFile.class);
  bind(CredentialsFactory.class)
      .to(AutoReloadSecureCredentialsFactoryDecorator.class)
      .in(Scopes.SINGLETON);
  bind(CapabilityDefinition.class)
      .annotatedWith(Exports.named(START_REPLICATION))
      .to(StartReplicationCapability.class);

  install(new FactoryModuleBuilder().build(PushAll.Factory.class));
  install(new FactoryModuleBuilder().build(RemoteSiteUser.Factory.class));

  bind(ReplicationConfig.class).to(AutoReloadConfigDecorator.class);
  bind(ReplicationStateListener.class).to(ReplicationStateLogger.class);

  EventTypes.register(RefReplicatedEvent.TYPE, RefReplicatedEvent.class);
  EventTypes.register(RefReplicationDoneEvent.TYPE, RefReplicationDoneEvent.class);
  EventTypes.register(ReplicationScheduledEvent.TYPE, ReplicationScheduledEvent.class);
  bind(SshSessionFactory.class).toProvider(ReplicationSshSessionFactoryProvider.class);
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
@Override
protected final void configure()
{
    internalConfigure();
    configureServlets();

    for ( FilterDefinition filterDefinition : filterDefinitions )
    {
        bind(FilterDefinition.class).annotatedWith(UniqueAnnotations.create()).toInstance(filterDefinition);
    }
    for ( ServletDefinition servletDefinition : servletDefinitions )
    {
        bind(ServletDefinition.class).annotatedWith(UniqueAnnotations.create()).toInstance(servletDefinition);
    }
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
@Override
public <T> Void visit(Binding<T> binding) {
  final Key<T> key = binding.getKey();

  if (!keysToIntercept.contains(key)) {
    return super.visit(binding);
  }

  binding.acceptTargetVisitor(new DefaultBindingTargetVisitor<T, Void>() {
    @Override
    public Void visit(UntargettedBinding<? extends T> untargettedBinding) {
      binder.addError("Cannot intercept bare binding of %s. " +
          		"You may only intercept bindings that bind a class to something.", key);
      return null;
    }
  });

  Key<T> anonymousKey = Key.get(key.getTypeLiteral(), UniqueAnnotations.create());
  binder.bind(key).toProvider(new InterceptingProvider<T>(key, binder.getProvider(anonymousKey)));

  ScopedBindingBuilder scopedBindingBuilder = bindKeyToTarget(binding, binder, anonymousKey);

  // we scope the user's provider, not the interceptor. This is dangerous,
  // but convenient. It means that although the user's provider will live
  // in its proper scope, the intereptor gets invoked without a scope
  applyScoping(binding, scopedBindingBuilder);

  keysIntercepted.add(key);
  return null;
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
@Override
public <T> Void visit(Binding<T> binding) {
  final Key<T> key = binding.getKey();

  if (!keysToIntercept.contains(key)) {
    return super.visit(binding);
  }

  binding.acceptTargetVisitor(new DefaultBindingTargetVisitor<T, Void>() {
    @Override
    public Void visit(UntargettedBinding<? extends T> untargettedBinding) {
      binder.addError("Cannot intercept bare binding of %s. " +
          		"You may only intercept bindings that bind a class to something.", key);
      return null;
    }
  });

  Key<T> anonymousKey = Key.get(key.getTypeLiteral(), UniqueAnnotations.create());
  binder.bind(key).toProvider(new InterceptingProvider<T>(key, binder.getProvider(anonymousKey)));

  ScopedBindingBuilder scopedBindingBuilder = bindKeyToTarget(binding, binder, anonymousKey);

  // we scope the user's provider, not the interceptor. This is dangerous,
  // but convenient. It means that although the user's provider will live
  // in its proper scope, the interceptor gets invoked without a scope
  applyScoping(binding, scopedBindingBuilder);

  keysIntercepted.add(key);
  return null;
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
protected <T extends HttpServlet> ServletBindingBuilder bindServlet(Class<T> servlet)
{
    Annotation annotation = UniqueAnnotations.create();
    Key<T> servletKey = Key.get(servlet, UniqueAnnotations.create());
    binder().bind(servletKey).to(servlet).in(Scopes.SINGLETON);
    return new ServletBindingBuilder(binder(), servletKey);
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public ApplicationBindingBuilder addResources(Class<?>... annotatedClass)
{
    for (Class<?> clazz : annotatedClass) {
        Key<Object> key = Key.get((Class<Object>) clazz, UniqueAnnotations.create());
        binder.bind(key).to(clazz);
        initializer.addResource(key, clazz);
    }
    return this;
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public ApplicationBindingBuilder addProvider(Class<?> annotatedClass)
{
    Key<Object> key = Key.get((Class<Object>) annotatedClass, UniqueAnnotations.create());
    binder.bind(key).to(annotatedClass);
    initializer.addProvider(key);
    return this;
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public ApplicationBindingBuilder addProviderInstance(Object object)
{
    Key<Object> key = Key.get((Class<Object>) object.getClass(), UniqueAnnotations.create());
    binder.bind(key).toInstance(object);
    initializer.addProvider(key);
    return this;
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
protected void rpc(String name, Class<? extends RemoteJsonService> clazz) {
  final Key<GerritJsonServlet> srv = Key.get(GerritJsonServlet.class, UniqueAnnotations.create());
  final GerritJsonServletProvider provider = new GerritJsonServletProvider(clazz);
  bind(clazz);
  serve(prefix + name).with(srv);
  bind(srv).toProvider(provider).in(Scopes.SINGLETON);
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
private Key<HttpServlet> key(HttpServlet servlet) {
  final Key<HttpServlet> srv = Key.get(HttpServlet.class, UniqueAnnotations.create());
  bind(srv)
      .toProvider(
          new Provider<HttpServlet>() {
            @Override
            public HttpServlet get() {
              return servlet;
            }
          })
      .in(SINGLETON);
  return srv;
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
public static ServletModule module() {
  return new ServletModule() {
    @Override
    protected void configureServlets() {
      DynamicSet.setOf(binder(), AllRequestFilter.class);
      filter("/*").through(FilterProxy.class);

      bind(StopPluginListener.class)
          .annotatedWith(UniqueAnnotations.create())
          .to(FilterProxy.class);
    }
  };
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
@Override
protected void configureServlets() {
  bind(HttpPluginServlet.class);
  serveRegex("^/(?:a/)?plugins/(.*)?$").with(HttpPluginServlet.class);

  bind(LfsPluginServlet.class);
  serveRegex(LfsDefinitions.LFS_URL_REGEX).with(LfsPluginServlet.class);

  bind(StartPluginListener.class)
      .annotatedWith(UniqueAnnotations.create())
      .to(HttpPluginServlet.class);

  bind(ReloadPluginListener.class)
      .annotatedWith(UniqueAnnotations.create())
      .to(HttpPluginServlet.class);

  bind(StartPluginListener.class)
      .annotatedWith(UniqueAnnotations.create())
      .to(LfsPluginServlet.class);

  bind(ReloadPluginListener.class)
      .annotatedWith(UniqueAnnotations.create())
      .to(LfsPluginServlet.class);

  bind(ModuleGenerator.class).to(HttpAutoRegisterModuleGenerator.class);

  install(
      new CacheModule() {
        @Override
        protected void configure() {
          cache(PLUGIN_RESOURCES, ResourceKey.class, Resource.class)
              .maximumWeight(2 << 20)
              .weigher(ResourceWeigher.class);
        }
      });

  DynamicMap.mapOf(binder(), DynamicOptions.DynamicBean.class);
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
public static Annotation calculateBindAnnotation(Class<Object> impl) {
  Annotation n = impl.getAnnotation(Export.class);
  if (n == null) {
    n = impl.getAnnotation(javax.inject.Named.class);
  }
  if (n == null) {
    n = impl.getAnnotation(com.google.inject.name.Named.class);
  }
  if (n == null) {
    n = UniqueAnnotations.create();
  }
  return n;
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
private void with(
    Key<? extends HttpServlet> servletKey,
    Map<String, String> initParams,
    HttpServlet servletInstance) {
  for (UriPatternMatcher pattern : uriPatterns) {
    binder
        .bind(Key.get(ServletDefinition.class, UniqueAnnotations.create()))
        .toProvider(new ServletDefinition(servletKey, pattern, initParams, servletInstance));
  }
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
private void through(
    Key<? extends Filter> filterKey, Map<String, String> initParams, Filter filterInstance) {
  for (UriPatternMatcher pattern : uriPatterns) {
    binder
        .bind(FilterDefinition.class)
        .annotatedWith(UniqueAnnotations.create())
        .toProvider(new FilterDefinition(filterKey, pattern, initParams, filterInstance));
  }
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
private static <T> Key<T> processSetBinding(Binder binder, Key<T> key) {
  Annotation annotation = key.getAnnotation();
  Multibinder<T> setBinder =
      (annotation != null)
          ? Multibinder.newSetBinder(binder, key.getTypeLiteral(), annotation)
          : Multibinder.newSetBinder(binder, key.getTypeLiteral());
  Key<T> newKey = Key.get(key.getTypeLiteral(), UniqueAnnotations.create());
  setBinder.addBinding().to(newKey);
  return newKey;
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
ScopedBindingBuilder toProviderMethod(CheckedProviderMethod<?> target) {
  Key<CheckedProviderMethod<?>> targetKey =
      Key.get(CHECKED_PROVIDER_METHOD_TYPE, UniqueAnnotations.create());
  binder.bind(targetKey).toInstance(target);

  return toInternal(targetKey);
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
private void with(Key<? extends HttpServlet> servletKey, Map<String, String> initParams,
    HttpServlet servletInstance) {
  for (String pattern : uriPatterns) {
    // Ensure two servlets aren't bound to the same pattern.
    if (!servletUris.add(pattern)) {
      binder.addError("More than one servlet was mapped to the same URI pattern: " + pattern);
    } else {
      binder.bind(Key.get(ServletDefinition.class, UniqueAnnotations.create())).toProvider(
          new ServletDefinition(pattern, servletKey, UriPatternType
              .get(uriPatternType, pattern), initParams, servletInstance));
    }
  }
}
 

import com.google.inject.internal.UniqueAnnotations; //导入依赖的package包/类
private void through(Key<? extends Filter> filterKey,
    Map<String, String> initParams,
    Filter filterInstance) {
  for (String pattern : uriPatterns) {
    binder.bind(FilterDefinition.class).annotatedWith(UniqueAnnotations.create()).toProvider(
        new FilterDefinition(pattern, filterKey, UriPatternType.get(uriPatternType, pattern),
            initParams, filterInstance));
  }
}