import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
@Autowired
public PullRequestListener(@ComponentImport ApplicationPropertiesService applicationPropertiesService,
                           @ComponentImport EventPublisher eventPublisher,
                           @ComponentImport ExecutorService executorService,
                           HttpClientFactory httpClientFactory,
                           @ComponentImport NavBuilder navBuilder,
                           @ComponentImport ScmService scmService,
                           @ComponentImport CommitIndex commitIndex,
                           WebHookConfigurationDao webHookConfigurationDao)
{
    this.applicationPropertiesService = applicationPropertiesService;
    this.eventPublisher = eventPublisher;
    this.executorService = executorService;
    this.navBuilder = navBuilder;
    this.scmService = scmService;
    this.commitIndex = commitIndex;
    this.webHookConfigurationDao = webHookConfigurationDao;
    String bitbucketVersion = applicationPropertiesService.getBuildVersion();
    useCanMerge = new Version(bitbucketVersion).compareTo(new Version(4, 10)) < 0;
    httpClient = httpClientFactory.create(bitbucketVersion);
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
@Autowired
public DefaultSmartcommitsService(@ComponentImport IssueManager issueManager,
        @Qualifier ("smartcommitsTransitionsHandler") TransitionHandler transitionHandler,
        @Qualifier ("smartcommitsCommentHandler") CommentHandler commentHandler,
        @Qualifier ("smartcommitsWorklogHandler") WorkLogHandler workLogHandler,
        @ComponentImport JiraAuthenticationContext jiraAuthenticationContext,
        @ComponentImport CrowdService crowdService)
{
    this.crowdService = checkNotNull(crowdService);

    NO_CACHE = new CacheControl();
    NO_CACHE.setNoCache(true);

    this.issueManager = checkNotNull(issueManager);
    this.transitionHandler = transitionHandler;
    this.commentHandler = commentHandler;
    this.workLogHandler = workLogHandler;
    this.jiraAuthenticationContext = checkNotNull(jiraAuthenticationContext);
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
public DvcsStreamsActivityProvider(@ComponentImport I18nResolver i18nResolver,
        @ComponentImport ApplicationProperties applicationProperties,
        @ComponentImport UserProfileAccessor userProfileAccessor,
        IssueLinker issueLinker,
        @ComponentImport TemplateRenderer templateRenderer,
        @ComponentImport PermissionManager permissionManager,
        @ComponentImport JiraAuthenticationContext jiraAuthenticationContext,
        @ComponentImport ProjectManager projectManager,
        ChangesetService changesetService,
        RepositoryService repositoryService,
        IssueAndProjectKeyManager issueAndProjectKeyManager)
{
    this.applicationProperties = applicationProperties;
    this.i18nResolver = i18nResolver;
    this.userProfileAccessor = userProfileAccessor;
    this.issueLinker = issueLinker;
    this.templateRenderer = checkNotNull(templateRenderer);
    this.permissionManager = permissionManager;
    this.jiraAuthenticationContext = jiraAuthenticationContext;
    this.projectManager = projectManager;
    this.changesetService = changesetService;
    this.repositoryService = repositoryService;
    this.issueAndProjectKeyManager = issueAndProjectKeyManager;
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
@Autowired
public DefaultSynchronizer(@ComponentImport final CacheManager cacheManager,
        final ClusterLockServiceFactory clusterLockServiceFactory)
{
    this.clusterLockService = checkNotNull(clusterLockServiceFactory.getClusterLockService());
    this.progressMap = cacheManager.getCache(getClass().getName() + ".progressMap");
    // clear the cache as a temp fix for BBC-744
    if (LOG.isDebugEnabled())
    {
        final Collection<Integer> keys = progressMap.getKeys();
        if (!keys.isEmpty())
        {
            LOG.debug("clearing progressMap of size {} ", keys.size());
        }
    }
    progressMap.removeAll();
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
@Autowired
public RepositoryConfigServlet(@ComponentImport SoyTemplateRenderer soyTemplateRenderer, @ComponentImport RepositoryService repositoryService, WebHookConfigurationDao webHookConfigurationDao)
{
	this.soyTemplateRenderer = soyTemplateRenderer;
	this.repositoryService = repositoryService;
	this.webHookConfigurationDao = webHookConfigurationDao;
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
public SASTScanTask(
		@ComponentImport I18nBeanFactory i18nBeanFactory, 
		@ComponentImport ProcessService processService, 
		@ComponentImport ArtifactManager artifactManager, 
		@ComponentImport CredentialsManager credentialsManager,  
		@ComponentImport CapabilityContext capabilityContext) {
	
	logger = new LogHelper(i18nBeanFactory.getI18nBean());
	scanner = new SASTScanner(logger, processService);
	
	this.artifactManager = artifactManager;
	this.credentialsManager = credentialsManager;
	this.capabilityContext = capabilityContext;
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
public SASTScanTaskConfigurator(
		@ComponentImport UIConfigSupport uiConfigSupport, 
		@ComponentImport CredentialsManager credentialsManager, 
		@ComponentImport I18nBeanFactory i18nBeanFactory) {
	
	this.uiConfigSupport = uiConfigSupport;
	this.credentialsManager = credentialsManager;
	this.i18nBean = i18nBeanFactory.getI18nBean();
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
@Autowired
public ChangesetRendererImpl(ChangesetService changesetService, RepositoryService repositoryService, IssueLinker issueLinker,
        @ComponentImport ApplicationProperties applicationProperties, @ComponentImport TemplateRenderer templateRenderer,
        IssueAndProjectKeyManager issueAndProjectKeyManager)
{
    this.changesetService = changesetService;
    this.repositoryService = repositoryService;
    this.issueLinker = issueLinker;
    this.applicationProperties = checkNotNull(applicationProperties);
    this.templateRenderer = checkNotNull(templateRenderer);
    this.issueAndProjectKeyManager = issueAndProjectKeyManager;
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
public DvcsTabPanel(PanelVisibilityManager panelVisibilityManager,
        @ComponentImport SoyTemplateRendererProvider soyTemplateRendererProvider, RepositoryService repositoryService,
        @ComponentImport WebResourceManager webResourceManager,
        ChangesetRenderer renderer, @ComponentImport EventPublisher eventPublisher)
{
    this.panelVisibilityManager = panelVisibilityManager;
    this.renderer = renderer;
    this.soyTemplateRenderer = soyTemplateRendererProvider.getRenderer();
    this.repositoryService = repositoryService;
    this.webResourceManager = webResourceManager;
    this.eventPublisher = eventPublisher;
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
@Autowired
public ChangesetIssueActionFactory(RepositoryService repositoryService, IssueLinker issueLinker,
        @ComponentImport ApplicationProperties applicationProperties, ChangesetService changesetService,
        @ComponentImport TemplateRenderer templateRenderer)
{
    this.repositoryService = repositoryService;
    this.issueLinker = issueLinker;
    this.applicationProperties = checkNotNull(applicationProperties);
    this.changesetService = changesetService;
    this.templateRenderer = checkNotNull(templateRenderer);
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
public DvcsTabPanelContextProvider(ChangesetRenderer changesetRenderer, RepositoryService repositoryService,
        @ComponentImport EventPublisher eventPublisher)
{
    this.changesetRenderer = changesetRenderer;
    this.repositoryService = repositoryService;
    this.eventPublisher = checkNotNull(eventPublisher);
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
public ConfigureDvcsOrganizations(@ComponentImport EventPublisher eventPublisher, OrganizationService organizationService,
        @ComponentImport FeatureManager featureManager, PluginFeatureDetector featuresDetector,
        @ComponentImport PluginSettingsFactory pluginSettingsFactory, OAuthStore oAuthStore, SyncDisabledHelper syncDisabledHelper)
{
    this.eventPublisher = eventPublisher;
    this.organizationService = organizationService;
    this.featureManager = featureManager;
    this.featuresDetector = featuresDetector;
    this.oAuthStore = oAuthStore;
    this.invalidOrganizationsManager = new InvalidOrganizationsManagerImpl(pluginSettingsFactory);
    this.syncDisabledHelper = syncDisabledHelper;
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
public DvcsActivityTabPanel(@ComponentImport PermissionManager permissionManager,
        RepositoryService repositoryService, RepositoryPullRequestDao activityDao,
        @Qualifier ("aggregatedIssueActionFactory") IssueActionFactory issueActionFactory,
        @ComponentImport TemplateRenderer templateRenderer, IssueAndProjectKeyManager issueAndProjectKeyManager)
{
    this.permissionManager = checkNotNull(permissionManager);
    this.repositoryService = checkNotNull(repositoryService);
    this.activityDao = checkNotNull(activityDao);
    this.issueActionFactory = checkNotNull(issueActionFactory);
    this.templateRenderer = checkNotNull(templateRenderer);
    this.issueAndProjectKeyManager = checkNotNull(issueAndProjectKeyManager);
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
@Autowired
@SuppressWarnings("SpringJavaAutowiringInspection")
public PanelVisibilityManager(@ComponentImport PermissionManager permissionManager,
        @ComponentImport PluginAccessor pluginAccessor,
        @ComponentImport FeatureManager featureManager)
{
    this.permissionManager = checkNotNull(permissionManager);
    this.pluginAccessor = checkNotNull(pluginAccessor);
    this.featureManager = checkNotNull(featureManager);
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
@Autowired
@SuppressWarnings("SpringJavaAutowiringInspection")
public IssueAndProjectKeyManagerImpl(@ComponentImport final IssueManager issueManager,
        @ComponentImport final ChangeHistoryManager changeHistoryManager,
        @ComponentImport final ProjectManager projectManager,
        @ComponentImport final PermissionManager permissionManager,
        @ComponentImport final JiraAuthenticationContext authenticationContext)
{
    this.issueManager = checkNotNull(issueManager);
    this.changeHistoryManager = checkNotNull(changeHistoryManager);
    this.projectManager = checkNotNull(projectManager);
    this.permissionManager = checkNotNull(permissionManager);
    this.authenticationContext = checkNotNull(authenticationContext);
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
@Autowired
@SuppressWarnings("SpringJavaAutowiringInspection")
public TransitionHandler(@ComponentImport IssueService issueService,
        @ComponentImport WorkflowManager workflowManager,
        @ComponentImport JiraAuthenticationContext jiraAuthenticationContext)
{
    this.issueService = checkNotNull(issueService);
    this.workflowManager = checkNotNull(workflowManager);
    this.jiraAuthenticationContext = checkNotNull(jiraAuthenticationContext);
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
@Autowired
public BitbucketAccountsConfigService(AccountsConfigProvider configProvider, OrganizationService organizationService,
        BitbucketAccountsReloadJobScheduler bitbucketAccountsReloadJob,
        @ComponentImport PluginController pluginController, @ComponentImport PluginAccessor pluginAccessor)
{
    this.configProvider = configProvider;
    this.organizationService = organizationService;
    this.bitbucketAccountsReloadJob = bitbucketAccountsReloadJob;
    this.pluginController = checkNotNull(pluginController);
    this.pluginAccessor = checkNotNull(pluginAccessor);
    this.executorService = Executors.newFixedThreadPool(1, ThreadFactories.namedThreadFactory("DVCSConnector.BitbucketAccountsConfigService"));
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
@Autowired
public CachingOrganizationDaoImpl(@ComponentImport final CacheManager cacheManager)
{
    organizationsCache = cacheManager.getCachedReference(getClass().getName() + ".organizationsCache", new Supplier<List<Organization>>()
    {
        @Override
        public List<Organization> get()
        {
            return organizationAOFacade.fetch();
        }
    }, CACHE_SETTINGS);
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
@Autowired
public SyncAuditLogDaoImpl(@ComponentImport ActiveObjects ao, @ComponentImport EventPublisher publisher)
{
    super();
    this.ao = checkNotNull(ao);
    this.eventPublisher = checkNotNull(publisher);
}
 

import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport; //导入依赖的package包/类
@Autowired
public ChangesetDaoImpl(@ComponentImport ActiveObjects activeObjects, QueryHelper queryHelper)
{
    this.activeObjects = checkNotNull(activeObjects);
    this.queryHelper = checkNotNull(queryHelper);
    this.transformer = new ChangesetTransformer(this);
}