itasyurt

val tokens = analyzer.analyze("A Blog Post on <b>Elasticsearch</b>")
Assert.assertEquals(listOf("blogpost", "elasticsearch"), tokens)

itasyurt

  fun analyze(text: String): List<String> {
        val result = mutableListOf<String>()

        val analyzer = createAnalyzer()
        var ts = analyzer.tokenStream("", text)
        ts.reset()
        while (ts.incrementToken()) {
            val attr = ts.getAttribute(CharTermAttribute::class.java)
            result.add(attr.toString())
        }

itasyurt

 private fun createAnalyzer(): Analyzer {
        val tokenizerFactory = createTokenizerFactory()
        val charFilterFactories = createCharFilterFactories()
        val tokenFilterFactories = createTokenFilterFactories()

        return CustomAnalyzer(tokenizerFactory, charFilterFactories, tokenFilterFactories)
    }

itasyurt

private fun createTokenFilterFactories(): Array<TokenFilterFactory> {
        val stopwords = CharArraySet(listOf("a", "an", "on"), false)
        val stopTokenFilterFactory = object : TokenFilterFactory {
            override fun create(tokenStream: TokenStream?) = StopFilter(tokenStream, stopwords)
            override fun name() = "stop"
        }


        val lowercaseFilterFactory = object : TokenFilterFactory {
            override fun create(tokenStream: TokenStream?) = LowerCaseFilter(tokenStream)

itasyurt

 private fun createCharFilterFactories(): Array<CharFilterFactory> {
        val htmlStripFilterFactory = object : CharFilterFactory {
            override fun name() = "htmlStrip"

            override fun create(reader: Reader?) = HTMLStripCharFilter(reader)


        }
        return arrayOf(htmlStripFilterFactory)
    }

itasyurt

private fun createTokenizerFactory(): TokenizerFactory {
        return TokenizerFactory.newFactory("whitespace",
            Supplier { WhitespaceTokenizer() }
        )
    }

itasyurt

package com.udemy.search.elasticanalyzers

import org.apache.lucene.analysis.*
import org.apache.lucene.analysis.core.LowerCaseFilter
import org.apache.lucene.analysis.core.WhitespaceTokenizer
import org.apache.lucene.analysis.synonym.SolrSynonymParser
import org.apache.lucene.analysis.synonym.SynonymGraphFilter
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute
import org.elasticsearch.index.analysis.CharFilterFactory
import org.elasticsearch.index.analysis.CustomAnalyzer

itasyurt

@Component
class PassthruSimpleHostRoutingFilter(@Autowired val helper: ProxyRequestHelper,
                                      @Autowired val zuulProperties: ZuulProperties,
                                      @Autowired val httpClientConnectionManagerFactory: ApacheHttpClientConnectionManagerFactory,
                                      @Autowired val httpClientFactory: ApacheHttpClientFactory) : SimpleHostRoutingFilter(helper, zuulProperties, httpClientConnectionManagerFactory, httpClientFactory) {


    override fun buildHttpRequest(verb: String?, uri: String?, entity: InputStreamEntity?, headers: MultiValueMap<String, String>?, params: MultiValueMap<String, String>?, request: HttpServletRequest): HttpRequest {

        return if (verb?.toUpperCase() == "GET") {

itasyurt

@Component
class PassthruPostFilter : ZuulFilter() {

    override fun shouldFilter() = true

    override fun filterType() = "post"

    override fun filterOrder() = 1

itasyurt

            val bytes = ctx.responseDataStream.readAllBytes()

            responseBody = CharStreams.toString(GZIPInputStream(bytes.inputStream()).reader())
            ctx.responseDataStream = bytes.inputStream()