import org.alfresco.repo.batch.BatchProcessWorkProvider; //导入依赖的package包/类
protected BatchProcessor<ImportableItem> getBatchProcessor(final BulkImportParameters bulkImportParameters,
  		final BatchProcessWorkProvider<ImportableItem> workProvider, final int loggingInterval)
  {
      final int numThreads = getNumThreads(bulkImportParameters);
      final int batchSize = getBatchSize(bulkImportParameters);

      importStatus.setNumThreads(numThreads);
      importStatus.setBatchSize(batchSize);

BatchProcessor<ImportableItem> batchProcessor = new BatchProcessor<ImportableItem>(
              "Bulk Filesystem Import",
              transactionHelper,
              workProvider,
              numThreads, batchSize,
              applicationContext,
              logger, loggingInterval);

return batchProcessor;
  }
 

import org.alfresco.repo.batch.BatchProcessWorkProvider; //导入依赖的package包/类
@Override
public BatchProcessWorkProvider<ImportableItem> getWorkProvider()
{
   	BatchProcessWorkProvider<ImportableItem> provider = new BatchProcessWorkProvider<ImportableItem>()
	{
		@Override
		public int getTotalEstimatedWorkSize()
		{
			return count();
		}

		@Override
		public Collection<ImportableItem> getNextWork()
		{
			// TODO perhaps some multiple of the batchSize to limit calls
			// to getNextWork? Add this to repository.properties.
			return getImportableItems(batchSize*1000);
		}
	};
	
	return provider;
}
 

import org.alfresco.repo.batch.BatchProcessWorkProvider; //导入依赖的package包/类
/**
 * @param progress          the thread-safe progress
 */
private synchronized void doWork(NodeStringLengthWorkResult progress) throws Exception
{
    // Build batch processor
    BatchProcessWorkProvider<NodePropertyEntity> workProvider = new NodeStringLengthWorkProvider(progress);
    BatchProcessWorker<NodePropertyEntity> worker = new NodeStringLengthBatch(progress);
    RetryingTransactionHelper retryingTransactionHelper = transactionService.getRetryingTransactionHelper();
    retryingTransactionHelper.setForceWritable(true);
    
    BatchProcessor<NodePropertyEntity> batchProcessor = new BatchProcessor<NodePropertyEntity>(
            "NodeStringLengthWorker",
            retryingTransactionHelper,
            workProvider,
            threadCount,
            batchSize,
            ctx,
            logger,
            1000);
    batchProcessor.process(worker, true);
}
 

import org.alfresco.repo.batch.BatchProcessWorkProvider; //导入依赖的package包/类
/**
 * @param progress          the thread-safe progress
 */
private synchronized void doWork(UpgradePasswordHashWorkResult progress) throws Exception
{
    // Build batch processor
    BatchProcessWorkProvider<Long> workProvider = new UpgradePasswordHashWorkProvider(progress);
    BatchProcessWorker<Long> worker = new UpgradePasswordHashBatch(progress);
    RetryingTransactionHelper retryingTransactionHelper = transactionService.getRetryingTransactionHelper();
    retryingTransactionHelper.setForceWritable(true);

    //Create the QNames if they don't exist
    retryingTransactionHelper.doInTransaction(new RetryingTransactionHelper.RetryingTransactionCallback<Void>()
    {
        @Override
        public Void execute() throws Throwable
        {
            qnameDAO.getOrCreateQName(ContentModel.PROP_PASSWORD_HASH);
            qnameDAO.getOrCreateQName(ContentModel.PROP_HASH_INDICATOR);
            return null;
        }
    }, false, true);

    BatchProcessor<Long> batchProcessor = new BatchProcessor<Long>(
            "UpgradePasswordHashWorker",
            retryingTransactionHelper,
            workProvider,
            threadCount,
            batchSize,
            ctx,
            logger,
            1000);
    batchProcessor.process(worker, true);
}
 

import org.alfresco.repo.batch.BatchProcessWorkProvider; //导入依赖的package包/类
/**
 * @return                      Returns a work provider for batch processing
 * 
 * @since 3.3.4
 */
private BatchProcessWorkProvider<NodeRef> getArchivedNodesWorkProvider(final StoreRef originalStoreRef, final String lockToken)
{
    return new BatchProcessWorkProvider<NodeRef>()
    {
        private VmShutdownListener vmShutdownLister = new VmShutdownListener("getArchivedNodesWorkProvider");
        private List<NodeRef> nodeRefs;
        private boolean done;
        private synchronized List<NodeRef> getNodeRefs()
        {
            if (nodeRefs == null)
            {
                nodeRefs = getArchivedNodes(originalStoreRef);
            }
            return nodeRefs;
        }
        /**
         * @return              Returns 0, always
         */
        public synchronized int getTotalEstimatedWorkSize()
        {
            return 0;
        }
        public synchronized Collection<NodeRef> getNextWork()
        {
            if (vmShutdownLister.isVmShuttingDown())
            {
                return Collections.emptyList();
            }
            // Make sure we still have the lock
            try
            {
                // TODO: Replace with joblock callback mechanism that provides shutdown hints
                jobLockService.refreshLock(lockToken, LOCK_QNAME, LOCK_TTL);
            }
            catch (LockAcquisitionException e)
            {
                // This is OK.  We don't have the lock so just quit
                return Collections.emptyList();
            }
            
            if (done)
            {
                return Collections.emptyList();
            }
            else
            {
                done = true;
                return getNodeRefs();
            }
        }
    };
}
 

import org.alfresco.repo.batch.BatchProcessWorkProvider; //导入依赖的package包/类
public BatchProcessWorkProvider<ImportableItem> getWorkProvider();