import com.google.gerrit.extensions.events.LifecycleListener; //导入依赖的package包/类
/** Stop all listeners, in the reverse order they were registered. */
public void stop() {
  for (int i = handles.size() - 1; 0 <= i; i--) {
    handles.get(i).remove();
  }
  handles.clear();

  for (int i = startedIndex; 0 <= i; i--) {
    LifecycleListener obj = listeners.get(i).get();
    try {
      obj.stop();
    } catch (Throwable err) {
      LoggerFactory.getLogger(obj.getClass()).warn("Failed to stop", err);
    }
    startedIndex = i - 1;
  }
}
 

import com.google.gerrit.extensions.events.LifecycleListener; //导入依赖的package包/类
@Override
protected void configure() {
  listener()
      .toInstance(
          new LifecycleListener() {
            @Inject MetricMaker metrics;

            @Override
            public void start() {
              configure(metrics);
            }

            @Override
            public void stop() {}
          });
}
 

import com.google.gerrit.extensions.events.LifecycleListener; //导入依赖的package包/类
public static LifecycleListener start(Path sitePath, Config config) throws IOException {
  Path logdir =
      FileUtil.mkdirsOrDie(new SitePaths(sitePath).logs_dir, "Cannot create log directory");
  if (SystemLog.shouldConfigure()) {
    initLogSystem(logdir, config);
  }

  return new LifecycleListener() {
    @Override
    public void start() {}

    @Override
    public void stop() {
      LogManager.shutdown();
    }
  };
}
 

import com.google.gerrit.extensions.events.LifecycleListener; //导入依赖的package包/类
@Override
protected void configure() {
  bind(SessionFactory.class).toProvider(SessionFactoryProvider.class);

  Multibinder<Section> sectionBinder = Multibinder.newSetBinder(binder(), Section.class);
  sectionBinder.addBinding().to(AMQP.class);
  sectionBinder.addBinding().to(Exchange.class);
  sectionBinder.addBinding().to(Gerrit.class);
  sectionBinder.addBinding().to(Message.class);
  sectionBinder.addBinding().to(Monitor.class);

  Multibinder<Solver> solverBinder = Multibinder.newSetBinder(binder(), Solver.class);
  solverBinder.addBinding().to(V1.class);

  install(new FactoryModuleBuilder().implement(Publisher.class, MessagePublisher.class).build(PublisherFactory.class));
  install(new FactoryModuleBuilder().implement(Properties.class, PluginProperties.class).build(PropertiesFactory.class));
  install(new FactoryModuleBuilder().implement(EventWorker.class, UserEventWorker.class).build(EventWorkerFactory.class));

  DynamicSet.bind(binder(), LifecycleListener.class).to(Manager.class);
  DynamicSet.bind(binder(), ChangeListener.class).to(DefaultEventWorker.class);
}
 

import com.google.gerrit.extensions.events.LifecycleListener; //导入依赖的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.gerrit.extensions.events.LifecycleListener; //导入依赖的package包/类
/**
 * Add all {@link LifecycleListener}s registered in the Injector.
 *
 * @param injector the injector to add.
 */
public void add(Injector injector) {
  Preconditions.checkState(startedIndex < 0, "Already started");
  for (Binding<LifecycleListener> binding : get(injector)) {
    add(binding.getProvider());
  }
}
 

import com.google.gerrit.extensions.events.LifecycleListener; //导入依赖的package包/类
/** Start all listeners, in the order they were registered. */
public void start() {
  for (int i = startedIndex + 1; i < listeners.size(); i++) {
    LifecycleListener listener = listeners.get(i).get();
    startedIndex = i;
    listener.start();
  }
}
 

import com.google.gerrit.extensions.events.LifecycleListener; //导入依赖的package包/类
@Inject
IndexManagerOnInit(
    @Named(IndexModuleOnInit.INDEX_MANAGER) LifecycleListener indexManager,
    Collection<IndexDefinition<?, ?, ?>> defs) {
  this.indexManager = indexManager;
  this.defs = defs;
}
 

import com.google.gerrit.extensions.events.LifecycleListener; //导入依赖的package包/类
@Override
protected void configure() {
  // The AccountIndex implementations (LuceneAccountIndex and
  // ElasticAccountIndex) need AccountCache only for reading from the index.
  // On init we only want to write to the index, hence we don't need the
  // account cache.
  bind(AccountCache.class).toProvider(Providers.of(null));

  // AccountIndexDefinition wants to have AllAccountsIndexer but it is only
  // used by the Reindex program and the OnlineReindexer which are both not
  // used during init, hence we don't need AllAccountsIndexer.
  bind(AllAccountsIndexer.class).toProvider(Providers.of(null));

  bind(AccountIndexCollection.class);

  // The GroupIndex implementations (LuceneGroupIndex and ElasticGroupIndex)
  // need GroupCache only for reading from the index. On init we only want to
  // write to the index, hence we don't need the group cache.
  bind(GroupCache.class).toProvider(Providers.of(null));

  // GroupIndexDefinition wants to have AllGroupsIndexer but it is only used
  // by the Reindex program and the OnlineReindexer which are both not used
  // during init, hence we don't need AllGroupsIndexer.
  bind(AllGroupsIndexer.class).toProvider(Providers.of(null));

  bind(GroupIndexCollection.class);

  bind(new TypeLiteral<Map<String, Integer>>() {})
      .annotatedWith(Names.named(SingleVersionModule.SINGLE_VERSIONS))
      .toInstance(ImmutableMap.<String, Integer>of());
  bind(LifecycleListener.class)
      .annotatedWith(Names.named(INDEX_MANAGER))
      .to(SingleVersionListener.class);
}
 

import com.google.gerrit.extensions.events.LifecycleListener; //导入依赖的package包/类
public static LifecycleListener registerInParentInjectors() {
  return new LifecycleListener() {
    private List<RegistrationHandle> handles;

    @Inject private Injector self;

    @Override
    public void start() {
      handles = new ArrayList<>(4);
      Injector parent = self.getParent();
      while (parent != null) {
        handles.addAll(attachSets(self, dynamicSetsOf(parent)));
        handles.addAll(attachMaps(self, "gerrit", dynamicMapsOf(parent)));
        parent = parent.getParent();
      }
      if (handles.isEmpty()) {
        handles = null;
      }
    }

    @Override
    public void stop() {
      remove(handles);
      handles = null;
    }
  };
}
 

import com.google.gerrit.extensions.events.LifecycleListener; //导入依赖的package包/类
private static List<Binding<LifecycleListener>> get(Injector i) {
  return i.findBindingsByType(new TypeLiteral<LifecycleListener>() {});
}
 

import com.google.gerrit.extensions.events.LifecycleListener; //导入依赖的package包/类
private boolean shouldCopy(Key<?> key) {
  if (copyConfigKeys.contains(key)) {
    return false;
  }
  Class<?> type = key.getTypeLiteral().getRawType();
  if (LifecycleListener.class.isAssignableFrom(type)
      // This is needed for secondary index to work from plugin listeners
      && !is("com.google.gerrit.server.index.IndexCollection", type)) {
    return false;
  }
  if (StartPluginListener.class.isAssignableFrom(type)) {
    return false;
  }
  if (StopPluginListener.class.isAssignableFrom(type)) {
    return false;
  }
  if (MetricMaker.class.isAssignableFrom(type)) {
    return false;
  }

  if (type.getName().startsWith("com.google.inject.")) {
    return false;
  }

  if (is("org.apache.sshd.server.Command", type)) {
    return false;
  }

  if (is("javax.servlet.Filter", type)) {
    return false;
  }
  if (is("javax.servlet.ServletContext", type)) {
    return false;
  }
  if (is("javax.servlet.ServletRequest", type)) {
    return false;
  }
  if (is("javax.servlet.ServletResponse", type)) {
    return false;
  }
  if (is("javax.servlet.http.HttpServlet", type)) {
    return false;
  }
  if (is("javax.servlet.http.HttpServletRequest", type)) {
    return false;
  }
  if (is("javax.servlet.http.HttpServletResponse", type)) {
    return false;
  }
  if (is("javax.servlet.http.HttpSession", type)) {
    return false;
  }
  if (Map.class.isAssignableFrom(type)
      && key.getAnnotationType() != null
      && "com.google.inject.servlet.RequestParameters"
          .equals(key.getAnnotationType().getName())) {
    return false;
  }
  if (type.getName().startsWith("com.google.gerrit.httpd.GitOverHttpServlet$")) {
    return false;
  }
  return true;
}
 

import com.google.gerrit.extensions.events.LifecycleListener; //导入依赖的package包/类
@Override
protected void configureServlets() {
	log.info("Configuring servlet and filters");
	// Plugin life-cycle listener
	bind(PluginActivator.class);
	bind(LifecycleListener.class).annotatedWith(UniqueAnnotations.create()).to(PluginActivator.class);

	// Changed things
	bind(IStoredSettings.class).to(GitBlitSettings.class);
	bind(IRuntimeManager.class).to(GerritGitBlitRuntimeManager.class);
	bind(IUserManager.class).to(GerritGitBlitUserManager.class);
	bind(IAuthenticationManager.class).to(GerritGitBlitAuthenticationManager.class);
	bind(IRepositoryManager.class).to(GerritGitBlitRepositoryManager.class);
	bind(GitblitContext.class).to(GerritGitBlitContext.class);
	bind(GitBlitWebApp.class).to(GerritGitBlitWebApp.class);
	bind(IPluginManager.class).to(NullPluginManager.class);
	bind(ITicketService.class).to(ReallyNullTicketService.class);

	// Gitblit bindings
	bind(XssFilter.class).to(JSoupXssFilter.class);
	bind(AvatarGenerator.class).to(GravatarGenerator.class);
	bind(WorkQueue.class).toProvider(WorkQueueProvider.class);

	bind(IGitblit.class).to(GitblitManager.class);

	// core managers
	bind(IPluginManager.class).to(NullPluginManager.class);
	bind(INotificationManager.class).to(NotificationManager.class);
	bind(IProjectManager.class).to(ProjectManager.class);
	bind(IFederationManager.class).to(FederationManager.class);
	bind(IFilestoreManager.class).to(FilestoreManager.class);
	bind(IPublicKeyManager.class).toProvider(IPublicKeyManagerProvider.class);

	// manager for long-running daemons and services
	bind(IServicesManager.class).to(ServicesManager.class);

	// Servlets -- note: FilestoreServlet is not configured
	serve('/' + WrappedPagesFilter.SERVLET_RELATIVE_PATH + '*').with(PagesServlet.class);
	serve('/' + WrappedRawFilter.SERVLET_RELATIVE_PATH + '*').with(RawServlet.class);
	serve('/' + WrappedSyndicationFilter.SERVLET_RELATIVE_PATH + '*').with(WrappedSyndicationServlet.class);
	serve("/zip/*").with(DownloadZipServlet.class);
	serve("/logo.png").with(LogoServlet.class);
	serve("/static/logo.png").with(LogoServlet.class);
	serve("/graph/*").with(BranchGraphServlet.class);
	serve("/static/*").with(StaticResourcesServlet.class);
	serve("/clippy.swf").with(StaticResourcesServlet.class);
	serve("/pt").with(PtServlet.class);

	// Filters
	filter("/*").through(GerritWicketFilter.class);
	filter('/' + WrappedPagesFilter.SERVLET_RELATIVE_PATH + '*').through(WrappedPagesFilter.class);
	filter('/' + WrappedRawFilter.SERVLET_RELATIVE_PATH + '*').through(WrappedRawFilter.class);
	filter('/' + WrappedSyndicationFilter.SERVLET_RELATIVE_PATH + '*').through(WrappedSyndicationFilter.class);
}
 

import com.google.gerrit.extensions.events.LifecycleListener; //导入依赖的package包/类
/**
 * @return a unique listener binding.
 *     <p>To create a listener binding use:
 *     <pre>
 * listener().to(MyListener.class);
 * </pre>
 *     where {@code MyListener} is a {@link Singleton} implementing the {@link LifecycleListener}
 *     interface.
 */
protected LinkedBindingBuilder<LifecycleListener> listener() {
  final Annotation id = UniqueAnnotations.create();
  return bind(LifecycleListener.class).annotatedWith(id);
}