import com.google.inject.Exposed; //导入依赖的package包/类
@Exposed
@Provides
@Singleton
private LanternAssetManager provideAssetManager(@Option({ "asset-repository-config", "asset-repo-config" })
        @Nullable Path repoConfig, LanternPluginManager pluginManager) {
    final Gson gson = new GsonBuilder().registerTypeAdapter(AssetRepository.class,
            new AssetRepositoryJsonDeserializer(pluginManager)).create();
    try {
        URL url;
        if (repoConfig != null) {
            url = PathUtils.toURL(repoConfig);
        } else {
            url = getClass().getClassLoader().getResource("assets_repo.json");
            checkNotNull(url);
        }
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()))) {
            return new LanternAssetManager(gson.fromJson(reader, AssetRepository.class));
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
@Override
public Module getModule(Configuration configuration)
{
    return new PrivateModule()
    {
        @Override
        protected void configure()
        {
            bind(ObjectMapper.class).toProvider(ObjectMapperProvider.class);
            bind(HttpClient.class).toInstance(new JettyHttpClient());
        }

        @Inject
        @Provides
        @Exposed
        @Singleton
        QueryStatsClient getQueryStatsClient(HttpClient httpClient, ObjectMapper objectMapper, @Named("presto_rest.base_uri") String prestoRestInterfaceBaseUri)
        {
            return new HttpQueryStatsClient(httpClient, objectMapper, URI.create(prestoRestInterfaceBaseUri));
        }
    };
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
CheckedProviderMethod(
    Key<T> key,
    Method method,
    Object instance,
    ImmutableSet<Dependency<?>> dependencies,
    List<Provider<?>> parameterProviders,
    Class<? extends Annotation> scopeAnnotation,
    Class<? extends CheckedProvider> checkedProvider,
    List<TypeLiteral<?>> exceptionTypes,
    boolean scopeExceptions) {
  this.key = key;
  this.scopeAnnotation = scopeAnnotation;
  this.instance = instance;
  this.dependencies = dependencies;
  this.method = method;
  this.parameterProviders = parameterProviders;
  this.exposed = method.isAnnotationPresent(Exposed.class);
  this.checkedProvider = checkedProvider;
  this.exceptionTypes = exceptionTypes;
  this.scopeExceptions = scopeExceptions;

  method.setAccessible(true);
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
/** @param method the method to invoke. It's return type must be the same type as {@code key}. */
private ProviderMethod(
    Key<T> key,
    Method method,
    Object instance,
    ImmutableSet<Dependency<?>> dependencies,
    Class<? extends Annotation> scopeAnnotation,
    Annotation annotation) {
  // We can be safely initialized eagerly since our bindings must exist statically and it is an
  // error for them not to.
  super(InitializationTiming.EAGER);
  this.key = key;
  this.scopeAnnotation = scopeAnnotation;
  this.instance = instance;
  this.dependencies = dependencies;
  this.method = method;
  this.exposed = method.isAnnotationPresent(Exposed.class);
  this.annotation = annotation;
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
public void testPrivateModuleInheritScanner_usingPrivateModule() {
  Injector injector =
      Guice.createInjector(
          NamedMunger.module(),
          new PrivateModule() {
            @Override
            protected void configure() {}

            @Exposed
            @TestProvides
            @Named("foo")
            String foo() {
              return "foo";
            }
          });
  assertMungedBinding(injector, String.class, "foo", "foo");
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
public void testPrivateModule_skipSourcesWithinPrivateModule() {
  Injector injector =
      Guice.createInjector(
          NamedMunger.module(),
          new PrivateModule() {
            @Override
            protected void configure() {
              binder()
                  .skipSources(getClass())
                  .install(
                      new AbstractModule() {

                        @Exposed
                        @TestProvides
                        @Named("foo")
                        String foo() {
                          return "foo";
                        }
                      });
            }
          });
  assertMungedBinding(injector, String.class, "foo", "foo");
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
public void testPrivateModule_skipSourcesForPrivateModule() {
  Injector injector =
      Guice.createInjector(
          NamedMunger.module(),
          new AbstractModule() {
            @Override
            protected void configure() {
              binder()
                  .skipSources(getClass())
                  .install(
                      new PrivateModule() {
                        @Override
                        protected void configure() {}

                        @Exposed
                        @TestProvides
                        @Named("foo")
                        String foo() {
                          return "foo";
                        }
                      });
            }
          });
  assertMungedBinding(injector, String.class, "foo", "foo");
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
public void testPrivateModuleInheritScanner_usingPrivateBinder() {
  Injector injector =
      Guice.createInjector(
          NamedMunger.module(),
          new AbstractModule() {
            @Override
            protected void configure() {
              binder()
                  .newPrivateBinder()
                  .install(
                      new AbstractModule() {

                        @Exposed
                        @TestProvides
                        @Named("foo")
                        String foo() {
                          return "foo";
                        }
                      });
            }
          });
  assertMungedBinding(injector, String.class, "foo", "foo");
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
public void testPrivateModuleInheritScanner_skipSourcesFromPrivateBinder() {
  Injector injector =
      Guice.createInjector(
          NamedMunger.module(),
          new AbstractModule() {
            @Override
            protected void configure() {
              binder()
                  .newPrivateBinder()
                  .skipSources(getClass())
                  .install(
                      new AbstractModule() {

                        @Exposed
                        @TestProvides
                        @Named("foo")
                        String foo() {
                          return "foo";
                        }
                      });
            }
          });
  assertMungedBinding(injector, String.class, "foo", "foo");
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
public void testPrivateModuleInheritScanner_skipSourcesFromPrivateBinder2() {
  Injector injector =
      Guice.createInjector(
          NamedMunger.module(),
          new AbstractModule() {
            @Override
            protected void configure() {
              binder()
                  .skipSources(getClass())
                  .newPrivateBinder()
                  .install(
                      new AbstractModule() {

                        @Exposed
                        @TestProvides
                        @Named("foo")
                        String foo() {
                          return "foo";
                        }
                      });
            }
          });
  assertMungedBinding(injector, String.class, "foo", "foo");
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
public void testPrivateModuleWithinPrivateModule() {
  Injector injector =
      Guice.createInjector(
          NamedMunger.module(),
          new PrivateModule() {
            @Override
            protected void configure() {
              expose(Key.get(String.class, named("foo-munged")));
              install(
                  new PrivateModule() {
                    @Override
                    protected void configure() {}

                    @Exposed
                    @TestProvides
                    @Named("foo")
                    String foo() {
                      return "foo";
                    }
                  });
            }
          });
  assertMungedBinding(injector, String.class, "foo", "foo");
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
CheckedProviderMethod(
    Key<T> key,
    Method method,
    Object instance,
    ImmutableSet<Dependency<?>> dependencies,
    List<Provider<?>> parameterProviders,
    Class<? extends Annotation> scopeAnnotation,
    Class<? extends CheckedProvider> checkedProvider,
    List<TypeLiteral<?>> exceptionTypes) {
  this.key = key;
  this.scopeAnnotation = scopeAnnotation;
  this.instance = instance;
  this.dependencies = dependencies;
  this.method = method;
  this.parameterProviders = parameterProviders;
  this.exposed = method.isAnnotationPresent(Exposed.class);
  this.checkedProvider = checkedProvider;
  this.exceptionTypes = exceptionTypes;

  method.setAccessible(true);
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
@Provides
@Singleton
@Exposed
ServiceGroupMonitor provideServiceGroupMonitor(
    CuratorFramework client,
    Codec<ServiceInstance> codec) {

  PathChildrenCache groupCache =
      new PathChildrenCache(client, discoveryPath, true /* cacheData */);
  return new CuratorServiceGroupMonitor(groupCache, MEMBER_SELECTOR, codec);
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
@Provides
@Singleton
@Exposed
SingletonService provideSingletonService(
    ZooKeeperClient client,
    ServerSetImpl serverSet,
    @ServiceDiscoveryBindings.ZooKeeper List<ACL> zookeeperAcls) {

  return new SingletonServiceImpl(
      serverSet,
      SingletonServiceImpl.createSingletonCandidate(client, discoveryPath, zookeeperAcls));
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
@Provides
@Singleton
@Exposed
@Named("AdminKey")
String provideAdminKey(AuthorizationConfiguration config, ApiKeyEncryption encryption) {
    return configurationKeyAsPlaintext(config.getAdminApiKey(), encryption, "admin");
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
private EventualProvider<?> providerFor(Invokable<T, ?> method, Errors methodErrors) {
  Annotation[] annotations = method.getAnnotations();

  verifyMethodAccessibility(methodErrors, method, source);

  @Nullable Annotation bindingAnnotation =
      Annotations.findBindingAnnotation(methodErrors, method, annotations);

  verifyAbsenseOfScopeAnnotation(methodErrors, annotations, source);

  List<Dependency<ListenableFuture<?>>> dependencies =
      Lists.newArrayListWithCapacity(method.getParameters().size());

  for (Parameter parameter : method.getParameters()) {
    dependencies.add(extractDependency(methodErrors, parameter));
  }

  Key<ListenableFuture<?>> bindingKey;
  boolean exposedBinding = method.isAnnotationPresent(Exposed.class);

  if (isVoid(method)) {
    bindingKey = futureKey(TypeToken.of(Boolean.class), new BlackholedAnnotation());
    exposedBinding = false;
  } else {
    bindingKey = futureKey(method.getReturnType(), bindingAnnotation);
  }

  return new EventualProvider<>(
      method,
      exposedBinding,
      dependencies,
      bindingKey,
      scopeAnnotation,
      source);
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
@Exposed
@Eventually.Provides
@Named("separator")
String separator() {
  tracker.add(0);
  return ":";
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
@Exposed
@Eventually.Provides
@Named("output")
String output(
    @Named("first") String first,
    @Named("second") String second,
    @Named("separator") String separator) {
  tracker.add(3);
  return first + separator + second;
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
@Exposed
@Named(DirectoryKeys.CONFIG)
@Provides
@Singleton
private Path provideConfigDirectory(@Option({ "config-directory", "config-dir" }) @Nullable Path configDir) {
    return configDir == null ? DirectoryKeys.DefaultValues.CONFIG : configDir;
}
 

import com.google.inject.Exposed; //导入依赖的package包/类
@Exposed
@Named(DirectoryKeys.CONFIG)
@Provides
@Singleton
private File provideConfigDirectoryAsFile(@Named(DirectoryKeys.CONFIG) Path configDir) {
    return configDir.toFile();
}