Java CharFilterFactory类代码示例

import org.elasticsearch.index.analysis.CharFilterFactory; //导入依赖的package包/类
public TraditionalChineseConvertCharFilterFactory(final IndexSettings indexSettings, final Environment env, final String name,
        final Settings settings, final FessAnalysisService fessAnalysisService) {
    super(indexSettings, name);

    final Class<?> charFilterFactoryClass = fessAnalysisService.loadClass(FACTORY);
    if (charFilterFactoryClass != null) {
        if (logger.isInfoEnabled()) {
            logger.info("{} is found.", FACTORY);
        }
        charFilterFactory = AccessController.doPrivileged((PrivilegedAction<CharFilterFactory>) () -> {
            try {
                final Constructor<?> constructor =
                        charFilterFactoryClass.getConstructor(IndexSettings.class, Environment.class, String.class, Settings.class);
                return (CharFilterFactory) constructor.newInstance(indexSettings, env, name, settings);
            } catch (final Exception e) {
                throw new ElasticsearchException("Failed to load " + FACTORY, e);
            }
        });
    } else if (logger.isDebugEnabled()) {
        logger.debug("{} is not found.", FACTORY);
    }
}
 

import org.elasticsearch.index.analysis.CharFilterFactory; //导入依赖的package包/类
public JapaneseIterationMarkCharFilterFactory(final IndexSettings indexSettings, final Environment env, final String name,
        final Settings settings, final FessAnalysisService fessAnalysisService) {
    super(indexSettings, name);

    for (final String factoryClass : FACTORIES) {
        final Class<?> charFilterFactoryClass = fessAnalysisService.loadClass(factoryClass);
        if (charFilterFactoryClass != null) {
            if (logger.isInfoEnabled()) {
                logger.info("{} is found.", factoryClass);
            }
            charFilterFactory = AccessController.doPrivileged((PrivilegedAction<CharFilterFactory>) () -> {
                try {
                    final Constructor<?> constructor =
                            charFilterFactoryClass.getConstructor(IndexSettings.class, Environment.class, String.class, Settings.class);
                    return (CharFilterFactory) constructor.newInstance(indexSettings, env, name, settings);
                } catch (final Exception e) {
                    throw new ElasticsearchException("Failed to load " + factoryClass, e);
                }
            });
            break;
        } else if (logger.isDebugEnabled()) {
            logger.debug("{} is not found.", factoryClass);
        }
    }
}
 

import org.elasticsearch.index.analysis.CharFilterFactory; //导入依赖的package包/类
public static CharFilterFactory charFilterFactory(String name) throws IOException {
    Settings settings = Settings.builder()
            .put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
            .put("path.home", System.getProperty("path.home", "/tmp"))
            .build();
    Environment environment = new Environment(settings);
    AnalysisRegistry analysisRegistry = analysisService(settings);
    IndexMetaData indexMetaData = IndexMetaData.builder("test")
            .settings(settings)
            .numberOfShards(1)
            .numberOfReplicas(1)
            .build();
    IndexSettings indexSettings = new IndexSettings(indexMetaData, settings);
    Map<String, CharFilterFactory> map = analysisRegistry.buildCharFilterFactories(indexSettings);
    return map.containsKey(name) ? map.get(name) :
            analysisRegistry.getCharFilterProvider(name).get(environment, name);
}
 

import org.elasticsearch.index.analysis.CharFilterFactory; //导入依赖的package包/类
@Test
public void testDefaultsIcuAnalysis() throws IOException {

    CharFilterFactory charFilterFactory = charFilterFactory("icu_normalizer");
    assertThat(charFilterFactory, instanceOf(IcuNormalizerCharFilterFactory.class));

    TokenizerFactory tf = tokenizerFactory("icu_tokenizer");
    assertThat(tf, instanceOf(IcuTokenizerFactory.class));

    TokenFilterFactory filterFactory = tokenFilterFactory("icu_normalizer");
    assertThat(filterFactory, instanceOf(IcuNormalizerTokenFilterFactory.class));

    filterFactory = tokenFilterFactory("icu_folding");
    assertThat(filterFactory, instanceOf(IcuFoldingTokenFilterFactory.class));

    filterFactory = tokenFilterFactory("icu_transform");
    assertThat(filterFactory, instanceOf(IcuTransformTokenFilterFactory.class));

    Analyzer analyzer = MapperTestUtils.analyzer( "icu_collation");
    assertThat(analyzer, instanceOf(NamedAnalyzer.class));
}
 

import org.elasticsearch.index.analysis.CharFilterFactory; //导入依赖的package包/类
public TestAnalysis(IndexAnalyzers indexAnalyzers,
                    Map<String, TokenFilterFactory> tokenFilter,
                    Map<String, TokenizerFactory> tokenizer,
                    Map<String, CharFilterFactory> charFilter) {
    this.indexAnalyzers = indexAnalyzers;
    this.tokenFilter = tokenFilter;
    this.tokenizer = tokenizer;
    this.charFilter = charFilter;
}
 

import org.elasticsearch.index.analysis.CharFilterFactory; //导入依赖的package包/类
public AnalysisModule(Environment environment, List<AnalysisPlugin> plugins) throws IOException {
    NamedRegistry<AnalysisProvider<CharFilterFactory>> charFilters = setupCharFilters(plugins);
    NamedRegistry<org.apache.lucene.analysis.hunspell.Dictionary> hunspellDictionaries = setupHunspellDictionaries(plugins);
    hunspellService = new HunspellService(environment.settings(), environment, hunspellDictionaries.getRegistry());
    NamedRegistry<AnalysisProvider<TokenFilterFactory>> tokenFilters = setupTokenFilters(plugins, hunspellService);
    NamedRegistry<AnalysisProvider<TokenizerFactory>> tokenizers = setupTokenizers(plugins);
    NamedRegistry<AnalysisProvider<AnalyzerProvider<?>>> analyzers = setupAnalyzers(plugins);
    NamedRegistry<AnalysisProvider<AnalyzerProvider<?>>> normalizers = setupNormalizers(plugins);
    analysisRegistry = new AnalysisRegistry(environment, charFilters.getRegistry(), tokenFilters.getRegistry(), tokenizers
        .getRegistry(), analyzers.getRegistry(), normalizers.getRegistry());
}
 

import org.elasticsearch.index.analysis.CharFilterFactory; //导入依赖的package包/类
private NamedRegistry<AnalysisProvider<CharFilterFactory>> setupCharFilters(List<AnalysisPlugin> plugins) {
    NamedRegistry<AnalysisProvider<CharFilterFactory>> charFilters = new NamedRegistry<>("char_filter");
    charFilters.register("html_strip", HtmlStripCharFilterFactory::new);
    charFilters.register("pattern_replace", requriesAnalysisSettings(PatternReplaceCharFilterFactory::new));
    charFilters.register("mapping", requriesAnalysisSettings(MappingCharFilterFactory::new));
    charFilters.extractAndRegister(plugins, AnalysisPlugin::getCharFilters);
    return charFilters;
}
 

import org.elasticsearch.index.analysis.CharFilterFactory; //导入依赖的package包/类
private static TokenStream createStackedTokenStream(String source, CharFilterFactory[] charFilterFactories, TokenizerFactory tokenizerFactory, TokenFilterFactory[] tokenFilterFactories, int current) {
    Reader reader = new FastStringReader(source);
    for (CharFilterFactory charFilterFactory : charFilterFactories) {
        reader = charFilterFactory.create(reader);
    }
    Tokenizer tokenizer = tokenizerFactory.create();
    tokenizer.setReader(reader);
    TokenStream tokenStream = tokenizer;
    for (int i = 0; i < current; i++) {
        tokenStream = tokenFilterFactories[i].create(tokenStream);
    }
    return tokenStream;
}
 

import org.elasticsearch.index.analysis.CharFilterFactory; //导入依赖的package包/类
@Override
public void build(final Map<String, TokenizerFactory> tokenizers,
                  final Map<String, CharFilterFactory> charFilters,
                  final Map<String, TokenFilterFactory> tokenFilters) {
    List<CharFilterFactory> myCharFilters = new ArrayList<>();
    String[] charFilterNames = analyzerSettings.getAsArray("char_filter");
    for (String charFilterName : charFilterNames) {
        CharFilterFactory charFilter = charFilters.get(charFilterName);
        if (charFilter == null) {
            throw new IllegalArgumentException("hyphen analyzer [" + name()
                    + "] failed to find char_filter under name [" + charFilterName + "]");
        }
        myCharFilters.add(charFilter);
    }
    List<TokenFilterFactory> myTokenFilters = new ArrayList<>();
    myTokenFilters.add(tokenFilterFactory);
    String[] tokenFilterNames = analyzerSettings.getAsArray("filter");
    for (String tokenFilterName : tokenFilterNames) {
        TokenFilterFactory tokenFilter = tokenFilters.get(tokenFilterName);
        if (tokenFilter == null) {
            throw new IllegalArgumentException("hyphen analyzer [" + name()
                    + "] failed to find filter under name [" + tokenFilterName + "]");
        }
        myTokenFilters.add(tokenFilter);
    }
    int positionOffsetGap = analyzerSettings.getAsInt("position_offset_gap", 0);
    int offsetGap = analyzerSettings.getAsInt("offset_gap", -1);
    this.customAnalyzer = new CustomAnalyzer(tokenizerFactory,
            myCharFilters.toArray(new CharFilterFactory[myCharFilters.size()]),
            myTokenFilters.toArray(new TokenFilterFactory[myTokenFilters.size()]),
            positionOffsetGap,
            offsetGap
    );
}
 

import org.elasticsearch.index.analysis.CharFilterFactory; //导入依赖的package包/类
@Override
public Map<String, AnalysisModule.AnalysisProvider<CharFilterFactory>> getCharFilters() {
    Map<String, AnalysisModule.AnalysisProvider<CharFilterFactory>> factories = new HashMap<>();

    factories.put("chinese-simplifying",
            (indexSettings, environment, name, settings) ->
                    new ChineseSimplifyingCharFilterFactory(indexSettings, name));

    return factories;
}
 

import org.elasticsearch.index.analysis.CharFilterFactory; //导入依赖的package包/类
@Override
public Map<String, AnalysisModule.AnalysisProvider<CharFilterFactory>> getCharFilters() {
    return Collections.singletonMap("benz_stop", (indexSettings, environment, name, settings) -> new AbstractCharFilterFactory(indexSettings, name) {

        @Override
        public Reader create(Reader tokenStream) {
            return new BenzCjkCharFilter(tokenStream);
        }
    });
}
 

import org.elasticsearch.index.analysis.CharFilterFactory; //导入依赖的package包/类
@Override
public Map<String, AnalysisProvider<CharFilterFactory>> getCharFilters() {
    final Map<String, AnalysisProvider<CharFilterFactory>> extra = new HashMap<>();
    extra.put("fess_japanese_iteration_mark",
            (indexSettings, env, name, settings) -> new JapaneseIterationMarkCharFilterFactory(indexSettings, env, name, settings,
                    pluginComponent.getFessAnalysisService()));
    extra.put("fess_traditional_chinese_convert",
            (indexSettings, env, name, settings) -> new TraditionalChineseConvertCharFilterFactory(indexSettings, env, name, settings,
                    pluginComponent.getFessAnalysisService()));
    return extra;
}
 

import org.elasticsearch.index.analysis.CharFilterFactory; //导入依赖的package包/类
@Override
public Map<String, AnalysisProvider<CharFilterFactory>> getCharFilters() {
    final Map<String, AnalysisProvider<CharFilterFactory>> extra = new HashMap<>();
    extra.put("iteration_mark", IterationMarkCharFilterFactory::new);
    extra.put("prolonged_sound_mark", ProlongedSoundMarkCharFilterFactory::new);
    extra.put("reloadable_kuromoji_iteration_mark", KuromojiIterationMarkCharFilterFactory::new);
    return extra;
}
 

import org.elasticsearch.index.analysis.CharFilterFactory; //导入依赖的package包/类
public static DocumentMapperParser newDocumentMapperParser(Settings customSettings, String index) throws IOException {
    Settings settings = Settings.builder()
            .put("path.home", System.getProperty("path.home", System.getProperty("user.dir")))
            .put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
            .put(customSettings)
            .build();
    Environment environment = new Environment(settings);
    ReferencePlugin referencePlugin = new ReferencePlugin();
    AnalysisModule analysisModule = new AnalysisModule(environment, Collections.emptyList());
    IndicesModule indicesModule = new IndicesModule(Collections.singletonList(referencePlugin));
    MapperRegistry mapperRegistry = indicesModule.getMapperRegistry();
    AnalysisRegistry analysisRegistry = analysisModule.getAnalysisRegistry();
    IndexMetaData indexMetaData = IndexMetaData.builder(index)
            .settings(settings)
            .numberOfShards(1)
            .numberOfReplicas(1)
            .build();
    IndexSettings indexSettings = new IndexSettings(indexMetaData, settings);
    SimilarityService similarityService = new SimilarityService(indexSettings, SimilarityService.BUILT_IN);
    Map<String, CharFilterFactory> charFilterFactoryMap = analysisRegistry.buildCharFilterFactories(indexSettings);
    Map<String, TokenFilterFactory> tokenFilterFactoryMap = analysisRegistry.buildTokenFilterFactories(indexSettings);
    Map<String, TokenizerFactory> tokenizerFactoryMap = analysisRegistry.buildTokenizerFactories(indexSettings);
    Map<String, AnalyzerProvider<?>> analyzerProviderMap = analysisRegistry.buildAnalyzerFactories(indexSettings);
    Map<String, AnalyzerProvider<?>> normalizerProviderMap = analysisRegistry.buildNormalizerFactories(indexSettings);
    IndexAnalyzers indexAnalyzers = analysisRegistry.build(indexSettings,
            analyzerProviderMap,
            normalizerProviderMap,
            tokenizerFactoryMap,
            charFilterFactoryMap,
            tokenFilterFactoryMap);
    MapperService mapperService = new MapperService(indexSettings, indexAnalyzers, NamedXContentRegistry.EMPTY,
            similarityService, mapperRegistry, null);
    return new DocumentMapperParser(indexSettings, mapperService, indexAnalyzers, NamedXContentRegistry.EMPTY,
            similarityService, mapperRegistry, null);
}
 

import org.elasticsearch.index.analysis.CharFilterFactory; //导入依赖的package包/类
@Override
public Map<String, AnalysisModule.AnalysisProvider<CharFilterFactory>> getCharFilters() {
    Map<String, AnalysisModule.AnalysisProvider<CharFilterFactory>> extra = new LinkedHashMap<>();
    if (settings.getAsBoolean("plugins.xbib.icu.enabled", true)) {
        extra.put("icu_normalizer", IcuNormalizerCharFilterFactory::new);
        extra.put("icu_folding", IcuFoldingCharFilterFactory::new);
    }
    return extra;
}