import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
public CreateBatchUser(@PluginName String pluginName, SchemaFactory<ReviewDb> schema,
					   PluginConfigFactory configFactory, SshKeyCache sshKeyCache, VersionedAuthorizedKeys.Accessor authorizedKeys,
					   AccountCache accountCache, AccountByEmailCache byEmailCache, AccountLoader.Factory infoLoader,
					   GroupsCollection groupsCollection, WorkQueue queue, ThreadLocalRequestContext context,
					   IdentifiedUser.GenericFactory userFactory) {
	this.schema = schema;
	this.sshKeyCache = sshKeyCache;
	this.authorizedKeys = authorizedKeys;
	this.accountCache = accountCache;
	this.byEmailCache = byEmailCache;
	this.infoLoader = infoLoader;
	this.groupsCollection = groupsCollection;
	this.context = context;
	this.userFactory = userFactory;
	pluginConfig = configFactory.getFromGerritConfig(pluginName);
	username = pluginConfig.getString("username", "jenkins");
	sshKey = pluginConfig.getString("sshKey");
	name = pluginConfig.getString("name", "Batch user");
	executor = queue.getDefaultQueue();

	createBatchUserIfNotExistsYet();
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
Upload(
    Provider<CurrentUser> userProvider,
    VisibleRefFilter.Factory refFilterFactory,
    TransferConfig transferConfig,
    DynamicSet<UploadPackInitializer> uploadPackInitializers,
    DynamicSet<PreUploadHook> preUploadHooks,
    UploadValidators.Factory uploadValidatorsFactory,
    ThreadLocalRequestContext threadContext,
    ProjectCache projectCache,
    PermissionBackend permissionBackend) {
  this.userProvider = userProvider;
  this.refFilterFactory = refFilterFactory;
  this.transferConfig = transferConfig;
  this.uploadPackInitializers = uploadPackInitializers;
  this.preUploadHooks = preUploadHooks;
  this.uploadValidatorsFactory = uploadValidatorsFactory;
  this.threadContext = threadContext;
  this.projectCache = projectCache;
  this.permissionBackend = permissionBackend;
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
Receive(
    Provider<CurrentUser> userProvider,
    ProjectCache projectCache,
    AsyncReceiveCommits.Factory factory,
    TransferConfig config,
    DynamicSet<ReceivePackInitializer> receivePackInitializers,
    DynamicSet<PostReceiveHook> postReceiveHooks,
    ThreadLocalRequestContext threadContext,
    PermissionBackend permissionBackend) {
  this.userProvider = userProvider;
  this.projectCache = projectCache;
  this.factory = factory;
  this.config = config;
  this.receivePackInitializers = receivePackInitializers;
  this.postReceiveHooks = postReceiveHooks;
  this.threadContext = threadContext;
  this.permissionBackend = permissionBackend;
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
EmailMerge(
    @SendEmailExecutor ExecutorService executor,
    MergedSender.Factory mergedSenderFactory,
    SchemaFactory<ReviewDb> schemaFactory,
    ThreadLocalRequestContext requestContext,
    IdentifiedUser.GenericFactory identifiedUserFactory,
    @Assisted Project.NameKey project,
    @Assisted Change.Id changeId,
    @Assisted @Nullable Account.Id submitter,
    @Assisted NotifyHandling notifyHandling,
    @Assisted ListMultimap<RecipientType, Account.Id> accountsToNotify) {
  this.sendEmailsExecutor = executor;
  this.mergedSenderFactory = mergedSenderFactory;
  this.schemaFactory = schemaFactory;
  this.requestContext = requestContext;
  this.identifiedUserFactory = identifiedUserFactory;
  this.project = project;
  this.changeId = changeId;
  this.submitter = submitter;
  this.notifyHandling = notifyHandling;
  this.accountsToNotify = accountsToNotify;
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@AssistedInject
ChangeIndexer(
    @GerritServerConfig Config cfg,
    SchemaFactory<ReviewDb> schemaFactory,
    NotesMigration notesMigration,
    ChangeNotes.Factory changeNotesFactory,
    ChangeData.Factory changeDataFactory,
    ThreadLocalRequestContext context,
    DynamicSet<ChangeIndexedListener> indexedListeners,
    StalenessChecker stalenessChecker,
    @IndexExecutor(BATCH) ListeningExecutorService batchExecutor,
    @Assisted ListeningExecutorService executor,
    @Assisted ChangeIndex index) {
  this.executor = executor;
  this.schemaFactory = schemaFactory;
  this.notesMigration = notesMigration;
  this.changeNotesFactory = changeNotesFactory;
  this.changeDataFactory = changeDataFactory;
  this.context = context;
  this.indexedListeners = indexedListeners;
  this.stalenessChecker = stalenessChecker;
  this.batchExecutor = batchExecutor;
  this.autoReindexIfStale = autoReindexIfStale(cfg);
  this.index = index;
  this.indexes = null;
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
public AdministrateServerGroupsProvider(
    GroupBackend groupBackend,
    @GerritServerConfig Config config,
    ThreadLocalRequestContext threadContext,
    ServerRequestContext serverCtx) {
  RequestContext ctx = threadContext.setContext(serverCtx);
  try {
    ImmutableSet.Builder<GroupReference> builder = ImmutableSet.builder();
    for (String value : config.getStringList("capability", null, "administrateServer")) {
      PermissionRule rule = PermissionRule.fromString(value, false);
      String name = rule.getGroup().getName();
      GroupReference g = GroupBackends.findBestSuggestion(groupBackend, name);
      if (g != null) {
        builder.add(g);
      } else {
        Logger log = LoggerFactory.getLogger(getClass());
        log.warn("Group \"{}\" not available, skipping.", name);
      }
    }
    groups = builder.build();
  } finally {
    threadContext.setContext(ctx);
  }
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
protected GroupSetProvider(
    GroupBackend groupBackend,
    ThreadLocalRequestContext threadContext,
    ServerRequestContext serverCtx,
    List<String> groupNames) {
  RequestContext ctx = threadContext.setContext(serverCtx);
  try {
    ImmutableSet.Builder<AccountGroup.UUID> builder = ImmutableSet.builder();
    for (String n : groupNames) {
      GroupReference g = GroupBackends.findBestSuggestion(groupBackend, n);
      if (g != null) {
        builder.add(g.getUUID());
      } else {
        Logger log = LoggerFactory.getLogger(getClass());
        log.warn("Group \"{}\" not available, skipping.", n);
      }
    }
    groupIds = builder.build();
  } finally {
    threadContext.setContext(ctx);
  }
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
public GitReceivePackGroupsProvider(
    GroupBackend gb,
    @GerritServerConfig Config config,
    ThreadLocalRequestContext threadContext,
    ServerRequestContext serverCtx) {
  super(
      gb,
      threadContext,
      serverCtx,
      ImmutableList.copyOf(config.getStringList("receive", null, "allowGroup")));

  // If no group was set, default to "registered users"
  //
  if (groupIds.isEmpty()) {
    groupIds = Collections.singleton(SystemGroupBackend.REGISTERED_USERS);
  }
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
public GitUploadPackGroupsProvider(
    GroupBackend gb,
    @GerritServerConfig Config config,
    ThreadLocalRequestContext threadContext,
    ServerRequestContext serverCtx) {
  super(
      gb,
      threadContext,
      serverCtx,
      ImmutableList.copyOf(config.getStringList("upload", null, "allowGroup")));

  // If no group was set, default to "registered users" and "anonymous"
  //
  if (groupIds.isEmpty()) {
    groupIds =
        ImmutableSet.of(SystemGroupBackend.REGISTERED_USERS, SystemGroupBackend.ANONYMOUS_USERS);
  }
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
ChangeUpdatedListener(final SmartReviewers.Factory smartReviewersFactory,
    final GitRepositoryManager repoManager, final WorkQueue workQueue,
    final IdentifiedUser.GenericFactory identifiedUserFactory,
    final ThreadLocalRequestContext tl,
    final SchemaFactory<ReviewDb> schemaFactory,
    final PluginConfigFactory cfg,
    final @PluginName String pluginName) {
  this.smartReviewersFactory = smartReviewersFactory;
  this.repoManager = repoManager;
  this.workQueue = workQueue;
  this.identifiedUserFactory = identifiedUserFactory;
  this.tl = tl;
  this.schemaFactory = schemaFactory;
  this.cfg = cfg;
  this.pluginName = pluginName;
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
public UserEventWorker(
    ChangeHooks hooks,
    WorkQueue workQueue,
    AccountResolver accountResolver,
    IdentifiedUser.GenericFactory userFactory,
    ThreadLocalRequestContext threadLocalRequestContext,
    PluginUser pluginUser,
    SchemaFactory<ReviewDb> schemaFactory) {
  this.hooks = hooks;
  this.workQueue = workQueue;
  this.accountResolver = accountResolver;
  this.userFactory = userFactory;
  this.threadLocalRequestContext = threadLocalRequestContext;
  this.pluginUser = pluginUser;
  this.schemaFactory = schemaFactory;
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
Propagator(
    AcceptanceTestRequestScope atrScope,
    ThreadLocalRequestContext local,
    Provider<RequestScopedReviewDbProvider> dbProviderProvider) {
  super(REQUEST, current, local, dbProviderProvider);
  this.atrScope = atrScope;
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
Propagator(
    SshScope sshScope,
    ThreadLocalRequestContext local,
    Provider<RequestScopedReviewDbProvider> dbProviderProvider) {
  super(REQUEST, current, local, dbProviderProvider);
  this.sshScope = sshScope;
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
RequestContextFilter(
    Provider<RequestCleanup> r, Provider<HttpRequestContext> c, ThreadLocalRequestContext l) {
  cleanup = r;
  requestContext = c;
  local = l;
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
Builder(
    GerritServerConfigProvider configProvider,
    SitePaths sitePaths,
    SchemaFactory<ReviewDb> schemaFactory,
    GitRepositoryManager repoManager,
    NoteDbUpdateManager.Factory updateManagerFactory,
    ChangeBundleReader bundleReader,
    AllProjectsName allProjects,
    ThreadLocalRequestContext requestContext,
    InternalUser.Factory userFactory,
    ChangeRebuilderImpl rebuilder,
    WorkQueue workQueue,
    MutableNotesMigration globalNotesMigration,
    PrimaryStorageMigrator primaryStorageMigrator,
    DynamicSet<NotesMigrationStateListener> listeners) {
  // Reload gerrit.config/notedb.config on each migrator invocation, in case a previous
  // migration in the same process modified the on-disk contents. This ensures the defaults for
  // trial/autoMigrate get set correctly below.
  this.cfg = configProvider.get();
  this.sitePaths = sitePaths;
  this.schemaFactory = schemaFactory;
  this.repoManager = repoManager;
  this.updateManagerFactory = updateManagerFactory;
  this.bundleReader = bundleReader;
  this.allProjects = allProjects;
  this.requestContext = requestContext;
  this.userFactory = userFactory;
  this.rebuilder = rebuilder;
  this.workQueue = workQueue;
  this.globalNotesMigration = globalNotesMigration;
  this.primaryStorageMigrator = primaryStorageMigrator;
  this.listeners = listeners;
  this.trial = getTrialMode(cfg);
  this.autoMigrate = getAutoMigrate(cfg);
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
public ProjectOwnerGroupsProvider(
    GroupBackend gb,
    ThreadLocalRequestContext context,
    ServerRequestContext serverCtx,
    RepositoryConfig repositoryCfg,
    @Assisted Project.NameKey project) {
  super(gb, context, serverCtx, repositoryCfg.getOwnerGroups(project));
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
EmailReviewComments(
    @SendEmailExecutor ExecutorService executor,
    PatchSetInfoFactory patchSetInfoFactory,
    CommentSender.Factory commentSenderFactory,
    SchemaFactory<ReviewDb> schemaFactory,
    ThreadLocalRequestContext requestContext,
    @Assisted NotifyHandling notify,
    @Assisted ListMultimap<RecipientType, Account.Id> accountsToNotify,
    @Assisted ChangeNotes notes,
    @Assisted PatchSet patchSet,
    @Assisted IdentifiedUser user,
    @Assisted ChangeMessage message,
    @Assisted List<Comment> comments,
    @Nullable @Assisted String patchSetComment,
    @Assisted List<LabelVote> labels) {
  this.sendEmailsExecutor = executor;
  this.patchSetInfoFactory = patchSetInfoFactory;
  this.commentSenderFactory = commentSenderFactory;
  this.schemaFactory = schemaFactory;
  this.requestContext = requestContext;
  this.notify = notify;
  this.accountsToNotify = accountsToNotify;
  this.notes = notes;
  this.patchSet = patchSet;
  this.user = user;
  this.message = message;
  this.comments = COMMENT_ORDER.sortedCopy(comments);
  this.patchSetComment = patchSetComment;
  this.labels = labels;
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
PluginGuiceEnvironment(
    Injector sysInjector,
    ThreadLocalRequestContext local,
    ServerInformation srvInfo,
    CopyConfigModule ccm,
    MetricMaker serverMetrics) {
  this.sysInjector = sysInjector;
  this.srvInfo = srvInfo;
  this.local = local;
  this.copyConfigModule = ccm;
  this.copyConfigKeys = Guice.createInjector(ccm).getAllBindings().keySet();
  this.serverMetrics = serverMetrics;

  onStart = new CopyOnWriteArrayList<>();
  onStart.addAll(listeners(sysInjector, StartPluginListener.class));

  onStop = new CopyOnWriteArrayList<>();
  onStop.addAll(listeners(sysInjector, StopPluginListener.class));

  onReload = new CopyOnWriteArrayList<>();
  onReload.addAll(listeners(sysInjector, ReloadPluginListener.class));

  sysItems = dynamicItemsOf(sysInjector);
  sysSets = dynamicSetsOf(sysInjector);
  sysMaps = dynamicMapsOf(sysInjector);
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
ChangeEventListener(
    final AccountResolver accountResolver,
    final AccountByEmailCache byEmailCache,
    final Provider<GroupsCollection> groupsCollection,
    final GroupMembers.Factory groupMembersFactory,
    final DefaultReviewers.Factory reviewersFactory,
    final GitRepositoryManager repoManager,
    final WorkQueue workQueue,
    final IdentifiedUser.GenericFactory identifiedUserFactory,
    final ThreadLocalRequestContext tl,
    final SchemaFactory<ReviewDb> schemaFactory,
    final ChangeData.Factory changeDataFactory,
    final ReviewersConfig.Factory configFactory,
    final Provider<CurrentUser> user,
    final ChangeQueryBuilder queryBuilder) {
  this.accountResolver = accountResolver;
  this.byEmailCache = byEmailCache;
  this.groupsCollection = groupsCollection;
  this.groupMembersFactory = groupMembersFactory;
  this.reviewersFactory = reviewersFactory;
  this.repoManager = repoManager;
  this.workQueue = workQueue;
  this.identifiedUserFactory = identifiedUserFactory;
  this.tl = tl;
  this.schemaFactory = schemaFactory;
  this.changeDataFactory = changeDataFactory;
  this.configFactory = configFactory;
  this.user = user;
  this.queryBuilder = queryBuilder;
}
 

import com.google.gerrit.server.util.ThreadLocalRequestContext; //导入依赖的package包/类
@Inject
Propagator(
    ThreadLocalRequestContext local,
    Provider<RequestScopedReviewDbProvider> dbProviderProvider) {
  super(REQUEST, current, local, dbProviderProvider);
}