import no.priv.garshol.duke.Processor; //导入依赖的package包/类
@Before
public void setup() throws CorruptIndexException, IOException {
  listener = new TestUtils.TestListener();
  List<Property> props = new ArrayList();
  GeopositionComparator comp = new GeopositionComparator();
  comp.setMaxDistance(100);
  props.add(new PropertyImpl("ID"));
  props.add(new PropertyImpl("LOCATION", comp, 0.3, 0.9));

  config = new ConfigurationImpl();
  // Define database as LuceneDatabase (not default anymore)
  config.addDatabase(new LuceneDatabase());
  config.setProperties(props);
  config.setThreshold(0.85);
  config.setMaybeThreshold(0.8);
  processor = new Processor(config, true);
  processor.addMatchListener(listener);
}
 

import no.priv.garshol.duke.Processor; //导入依赖的package包/类
@Before
public void setup() throws CorruptIndexException, IOException {
  listener = new TestUtils.TestListener();
  Levenshtein comp = new Levenshtein();
  List<Property> props = new ArrayList();
  props.add(new PropertyImpl("ID"));
  props.add(new PropertyImpl("NAME", comp, 0.3, 0.8));
  props.add(new PropertyImpl("EMAIL", comp, 0.3, 0.8));

  config = new ConfigurationImpl();
  config.setProperties(props);
  config.setThreshold(0.85);
  config.setMaybeThreshold(0.8);

  source1 = new InMemoryDataSource();
  source2 = new InMemoryDataSource();
  config.addDataSource(1, source1);
  config.addDataSource(2, source2);
  
  processor = new Processor(config, true);
  processor.addMatchListener(listener);
}
 

import no.priv.garshol.duke.Processor; //导入依赖的package包/类
@Before
public void setup() throws IOException {
  listener = new TestUtils.TestListener();
  Levenshtein comp = new Levenshtein();
  List<Property> props = new ArrayList();
  props.add(new PropertyImpl("ID"));
  props.add(new PropertyImpl("NAME", comp, 0.3, 0.8));
  props.add(new PropertyImpl("EMAIL", comp, 0.3, 0.8));

  config = new ConfigurationImpl();
  config.setProperties(props);
  config.setThreshold(0.85);
  config.setMaybeThreshold(0.8);
  processor = new Processor(config, true);
  processor.addMatchListener(listener);
}
 

import no.priv.garshol.duke.Processor; //导入依赖的package包/类
@Override
protected Map<B, Collection<C>> subStitch(Collection<B> filteredBaseElements,
        Collection<C> filteredCandidateElements, Map<B, Collection<C>> stitches) {
    // Set Datasources
    DataSource baseDataSource, candidateDataSource;
    baseDataSource = generateBaseDataSource(filteredBaseElements);
    candidateDataSource = generateCandidateDataSource(filteredCandidateElements);
    config.addDataSource(1, candidateDataSource); // NOTE: Read comment below
    config.addDataSource(2, baseDataSource); // NOTE: Read comment below

    // IMPORTANT NOTICE:
    // Duke's linking process takes its data source number 1 and indexes it, then traverses its
    // data source number 2 to look for matches from the first one. This means that Duke's
    // candidates group is its data source 1 and its base group is its data source 2.
    // As in this stitcher we are considering that the base data source is our first group and
    // the candidate data source is our second group, these needs to be swapped to comply with
    // Duke's behaviour. This explains why in the two previous lines our "candidateDataSource"
    // is set as data source number 1 and our "baseDataSource" is set as data source number 2.

    // Validate configuration before starting linking
    config.validate(); // Will throw a RuntimeException if not correct

    @SuppressWarnings("unused")
    long startTime, stopTime;
    startTime = System.currentTimeMillis();

    try {
        Processor proc = new Processor(config);
        proc.addMatchListener(new DukeStitcherMatchListener(stitches));
        proc.link();
        proc.close();
    } catch (IOException e) {
        return null;
    }

    stopTime = System.currentTimeMillis();

    return stitches;
}
 

import no.priv.garshol.duke.Processor; //导入依赖的package包/类
/**
 * Creates a test file listener.
 */
public TestFileListener(String testfile, Configuration config,
                        boolean debug, Processor processor,
                        boolean showmatches, boolean pretty)
  throws IOException {
  InMemoryLinkDatabase testdb = new InMemoryLinkDatabase();
  //testdb.setDoInference(true);
  LinkDatabaseUtils.loadTestFile(testfile, testdb);
  init(testdb, config, debug, processor, showmatches, pretty);
}
 

import no.priv.garshol.duke.Processor; //导入依赖的package包/类
private void init(LinkDatabase linkdb, Configuration config,
                  boolean debug, Processor processor,
                  boolean showmatches, boolean pretty) {
  this.golddb = linkdb;
  this.dukedb = new InMemoryLinkDatabase();
  //((InMemoryLinkDatabase) this.dukedb).setDoInference(true);
  this.idprops = config.getIdentityProperties();
  this.props = config.getProperties();
  this.debug = debug;
  this.processor = processor;
  this.database = processor.getDatabase();
  this.linkage = !config.isDeduplicationMode();
  this.showmatches = showmatches;
  this.pretty = pretty;
}
 

import no.priv.garshol.duke.Processor; //导入依赖的package包/类
public DukeController(Properties props) {
  this.status = "Initialized, inactive";
  String configfile = get(props, "duke.configfile");
  
  try {
    // setting up logger
    String loggerclass = get(props, "duke.logger-class", null);
    if (loggerclass != null) {
      logger = (Logger) ObjectUtils.instantiate(loggerclass);
      logger.debug("DukeController starting up");
    }

    // loading configuration
    Configuration config = ConfigLoader.load(configfile); 
    this.processor = new Processor(config, false);
    this.linkdb = makeLinkDatabase(props);
    processor.addMatchListener(new LinkDatabaseMatchListener(config, linkdb));
    processor.addMatchListener(this);
    batch_size = get(props, "duke.batch-size", 40000);
    error_factor = get(props, "duke.error-wait-skips", 6);

    // add loggers
    if (logger != null) {
      processor.setLogger(logger);
      if (linkdb instanceof RDBMSLinkDatabase)
        ((RDBMSLinkDatabase) linkdb).setLogger(logger);
    }
  } catch (Throwable e) {
    // this means init failed, and we need to clean up so that we can try
    // again later. unfortunately, we don't know what failed, so we need
    // to be careful
    if (processor != null)
      try {
        processor.close();
      } catch (Exception e2) {
        if (logger != null)
          logger.error("Couldn't close processor", e2);
      }
    if (linkdb != null)
      linkdb.close();

    throw new DukeException(e); // we failed, so signal that
  }
}