Java Extractor类代码示例

import at.punkt.lodms.spi.extract.Extractor; //导入依赖的package包/类
@Test
public void testRunCompletedEventProperties() throws InterruptedException {
    MockApplicationEventPublisher eventPublisher = new MockApplicationEventPublisher();
    ETLPipelineImpl instance = new ETLPipelineImpl(id, eventPublisher, repository);

    Extractor delayingExtractor = new Extractor() {
        @Override
        public void extract(RDFHandler handler, ExtractContext context) throws ExtractException {
            try {
                Thread.sleep(10);
            } catch (InterruptedException ex) {
                throw new ExtractException(ex);
            }
        }
    };
    instance.setExtractors(Arrays.asList(delayingExtractor));

    instance.run();
    PipelineCompletedEvent completedEvent = eventPublisher.getPublishedEventsOfType(PipelineCompletedEvent.class).get(0);
    Assert.assertEquals(instance, completedEvent.getPipeline());
    Assert.assertNotNull(completedEvent.getId());
    Assert.assertTrue(completedEvent.getDuration() > 0);
}
 

import at.punkt.lodms.spi.extract.Extractor; //导入依赖的package包/类
@Test
public void testRunExtractFailedEventFired() {
    MockApplicationEventPublisher eventPublisher = new MockApplicationEventPublisher();
    ETLPipelineImpl instance = new ETLPipelineImpl(id, eventPublisher, repository);

    Extractor extractor = new MockExtractor() {
        @Override
        public void extract(RDFHandler handler, ExtractContext context) throws ExtractException {
            throw new ExtractException("Test");
        }
    };
    instance.setExtractors(Arrays.asList(extractor));
    instance.run();

    ExtractFailedEvent failedEvent = eventPublisher.getPublishedEventsOfType(ExtractFailedEvent.class).get(0);
    Assert.assertEquals(extractor, failedEvent.getExtractor());
    Assert.assertNotNull(failedEvent.getException());
}
 

import at.punkt.lodms.spi.extract.Extractor; //导入依赖的package包/类
@Test
public void testRunExtractorAbortedEventFired() {
    MockApplicationEventPublisher eventPublisher = new MockApplicationEventPublisher();
    ETLPipelineImpl instance = new ETLPipelineImpl(id, eventPublisher, repository);

    Extractor extractor = new MockExtractor() {
        @Override
        public void extract(RDFHandler handler, ExtractContext context) throws ExtractException {
            context.cancelPipeline("Test");
        }
    };
    instance.setExtractors(Arrays.asList(extractor));
    instance.run();

    PipelineAbortedEvent abortedEvent = eventPublisher.getPublishedEventsOfType(PipelineAbortedEvent.class).get(0);
    Assert.assertEquals(instance, abortedEvent.getPipeline());
    Assert.assertEquals("Test", abortedEvent.getMessage());
}
 

import at.punkt.lodms.spi.extract.Extractor; //导入依赖的package包/类
@Test
public void testRunExtractorSkippedAfterAbortedEvent() {
    MockApplicationEventPublisher eventPublisher = new MockApplicationEventPublisher();
    ETLPipelineImpl instance = new ETLPipelineImpl(id, eventPublisher, repository);

    Extractor extractor = new MockExtractor() {
        @Override
        public void extract(RDFHandler handler, ExtractContext context) throws ExtractException {
            context.cancelPipeline("Test");
        }
    };
    MockExtractor skippedExtractor = new MockExtractor();
    instance.setExtractors(Arrays.asList(extractor, skippedExtractor));
    instance.run();

    Assert.assertEquals(false, skippedExtractor.executed);
}
 

import at.punkt.lodms.spi.extract.Extractor; //导入依赖的package包/类
public void init() {
    TabSheet tabsheet = new TabSheet();
    tabsheet.setWidth("100%");

    selectedExtractors = new BeanItemContainer<Extractor>(Extractor.class, job.getPipeline().getExtractors());
    selectedTransformers = new BeanItemContainer<Transformer>(Transformer.class, job.getPipeline().getTransformers());
    selectedLoaders = new BeanItemContainer<Loader>(Loader.class, job.getPipeline().getLoaders());
    initGenericDialog(Extractor.class, extractorDialog, provider.getAvailableExtractors(), job.getPipeline().getExtractors(), selectedExtractors);
    initGenericDialog(Loader.class, loaderDialog, provider.getAvailableLoaders(), job.getPipeline().getLoaders(), selectedLoaders);
    initGenericDialog(Transformer.class, transformerDialog, provider.getAvailableTransformers(), job.getPipeline().getTransformers(), selectedTransformers);

    initJobDialog(job);
    addComponent(jobDialog);
    tabsheet.addTab(extractorDialog, "Extractors", null, 0);
    tabsheet.addTab(transformerDialog, "Transformers", null, 1);
    tabsheet.addTab(loaderDialog, "Loaders", null, 2);
    tabsheet.setSizeFull();
    addComponent(tabsheet);
    setExpandRatio(tabsheet, 0.75f);
    setSizeFull();
}
 

import at.punkt.lodms.spi.extract.Extractor; //导入依赖的package包/类
private void runExtractors(String runId, URI namedGraph, Map<String, Object> customData) throws RepositoryException, RDFHandlerException {
    RepositoryConnection con = repository.getConnection();
    con.setAutoCommit(false);
    RDFInserter inserter = new RDFInserter(con);
    inserter.enforceContext(namedGraph);
    NoStartEndWrapper wrapper = new NoStartEndWrapper(inserter);
    try {
        for (Extractor extractor : extractors) {
            if (extractor instanceof Disableable && ((Disableable) extractor).isDisabled()) {
                continue;
            }
            ExtractContext context = new ExtractContext(runId, customData);
            context.setPipeline(this);
            TripleCountingWrapper tripleCounter = new TripleCountingWrapper(wrapper);
            try {
                long start = System.currentTimeMillis();
                extractor.extract(tripleCounter, context);
                con.commit();
                context.setDuration(System.currentTimeMillis() - start);
                context.setTriplesExtracted(tripleCounter.getTriples());
                eventPublisher.publishEvent(new ExtractCompletedEvent(extractor, context, this));
            } catch (ExtractException ex) {
                con.rollback();
                eventPublisher.publishEvent(new ExtractFailedEvent(ex, extractor, context, this));
            }
            if (cancelAllowed && context.isCancelPipeline()) {
                eventPublisher.publishEvent(new PipelineAbortedEvent(context.getCancelMessage(), this, runId, extractor));
                return;
            }
        }
        inserter.endRDF();
    } finally {
        con.commit();
        con.close();
    }
}
 

import at.punkt.lodms.spi.extract.Extractor; //导入依赖的package包/类
@Test
public void testSetAndGetExtractors() {
    List<Extractor> extractors = new ArrayList<Extractor>();
    extractors.add(new MockExtractor());
    ETLPipelineImpl instance = new ETLPipelineImpl();
    instance.setExtractors(extractors);

    assertEquals(extractors, instance.getExtractors());
}
 

import at.punkt.lodms.spi.extract.Extractor; //导入依赖的package包/类
@Test
public void testRunExecuteExtractors() {
    ETLPipelineImpl instance = new ETLPipelineImpl(id, new MockApplicationEventPublisher(), repository);

    instance.setExtractors(getMockExtractors(2));
    instance.run();
    for (Extractor extractor : instance.getExtractors()) {
        assertTrue(((MockExtractor) extractor).executed);
    }
}
 

import at.punkt.lodms.spi.extract.Extractor; //导入依赖的package包/类
@Test
public void testRunExtractCompletedEventFired() {
    MockApplicationEventPublisher eventPublisher = new MockApplicationEventPublisher();
    ETLPipelineImpl instance = new ETLPipelineImpl(id, eventPublisher, repository);

    Extractor extractor = new MockExtractor();
    instance.setExtractors(Arrays.asList(extractor));
    instance.run();

    ExtractCompletedEvent completedEvent = eventPublisher.getPublishedEventsOfType(ExtractCompletedEvent.class).get(0);
    Assert.assertEquals(extractor, completedEvent.getExtractor());
}
 

import at.punkt.lodms.spi.extract.Extractor; //导入依赖的package包/类
private List<Extractor> getMockExtractors(int i) {
    List<Extractor> extractors = new ArrayList<Extractor>(i);
    for (int j = 0; j < i; j++) {
        extractors.add(new MockExtractor());
    }
    return extractors;
}
 

import at.punkt.lodms.spi.extract.Extractor; //导入依赖的package包/类
@Override
public List<Extractor> getExtractors() {
    return extractors;
}
 

import at.punkt.lodms.spi.extract.Extractor; //导入依赖的package包/类
@Override
public void setExtractors(List<Extractor> extractors) {
    this.extractors = extractors;
}
 

import at.punkt.lodms.spi.extract.Extractor; //导入依赖的package包/类
public List<ComponentBlueprint<Extractor>> getExtractors() {
  return extractors;
}
 

import at.punkt.lodms.spi.extract.Extractor; //导入依赖的package包/类
public void setExtractors(List<ComponentBlueprint<Extractor>> extractors) {
  this.extractors = extractors;
}
 

import at.punkt.lodms.spi.extract.Extractor; //导入依赖的package包/类
public Extractor getExtractor() {
    return extractor;
}