PUT /my_index
{
  "mappings": {
    "properties": {
      "text": {
        "type": "text",
        "fields": {
          "semantic_text": {
            "type": "text",
            "analyzer": "semantic_analyzer"
          }
        }
      }
    },
    "settings": {
      "analysis": {
        "analyzer": {
          "semantic_analyzer": {
            "tokenizer": "standard",
            "filter": [
              "lowercase",
              "stop",
              "stemmer_override",
              "kstem",
              "reverse",
              "word_delimiter",
              "stemmer"
            ]
          }
        },
        "filter": {
          "stemmer_override": {
            "type": "stemmer_override",
            "rules_path": "analysis/stemmer_override.txt"
          },
          "stemmer": {
            "type": "stemmer",
            "language": "english"
          }
        }
      }
    }
  }
}

// 引入Reflect元数据相关的API
import 'reflect-metadata';

// 定义一个装饰器工厂，用于设置类的元数据
function setClassMetadata(metadataKey: string, metadataValue: any): ClassDecorator {
    return (target: Function) => {
        Reflect.defineMetadata(metadataKey, metadataValue, target);
    };
}

// 使用装饰器设置元数据
@setClassMetadata('author', 'John Doe')
class MyClass {}

// 获取并打印元数据
const author = Reflect.getMetadata('author', MyClass);
console.log(author); // 输出: John Doe

// 引入必要的库
const R = require('ramda');

// 定义一个简单的函数，用于展示函数式编程的用法
const showFunctionalProgramming = () => {
    // 使用Rambda库中的pipe函数来连接多个函数
    const pipeline = R.pipe(
        R.map(x => x + 1), // 将列表中的每个数值加1
        R.filter(x => x > 5), // 过滤出大于5的数值
        R.reduce((acc, x) => acc + x, 0) // 将剩余的数值累加
    );

    // 应用管道函数到输入列表
    const result = pipeline([1, 2, 3, 4, 5]);

    // 打印结果
    console.log(result); // 输出: 15 (1+2+3+4 = 10, 然后加上5本身)
};

// 执行函数
showFunctionalProgramming();

CloseableHttpClient httpClient = HttpClients.createDefault();
HttpGet httpGet = new HttpGet("http://www.example.com/");
CloseableHttpResponse httpResponse = httpClient.execute(httpGet);

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
  .url("http://www.example.com/")
  .build();
Response response = client.newCall(request).execute();

RestTemplate restTemplate = new RestTemplate();
String result = restTemplate.getForObject("http://www.example.com/", String.class);

// 数组解构
let [a, b, c] = [1, 2, 3];
console.log(a); // 输出1
console.log(b); // 输出2

// 对象解构
let {x, y} = {x: 1, y: 2};
console.log(x); // 输出1
console.log(y); // 输出2

// 可以使用rest参数获取剩余元素
let [a, ...rest] = [1, 2, 3, 4];
console.log(a); // 输出1
console.log(rest); // 输出[2, 3, 4]

// 默认值
let [a = 5, b = 7] = [1];
console.log(a); // 输出1
console.log(b); // 输出7

// 应用于函数调用
function add(x, y) {
  return x + y;
}
const numbers = [1, 2];
console.log(add(...numbers)); // 输出3

// 构造字面量
const arr1 = [1, 2];
const arr2 = [...arr1, 3, 4];
console.log(arr2); // 输出[1, 2, 3, 4]

class MyClass {
  constructor(name) {
    this.name = name;
  }

  greet() {
    console.log(`Hello, my name is ${this.name}!`);
  }
}

const myInstance = new MyClass('Alice');
myInstance.greet(); // 输出: Hello, my name is Alice!

class MySubClass extends MyClass {
  constructor(name, age) {
    super(name); // 调用父类构造函数
    this.age = age;
  }

  greet() {
    console.log(`${super.greet()}, I am ${this.age} years old.`);
  }
}

const mySubInstance = new MySubClass('Bob', 25);
mySubInstance.greet(); // 输出: Hello, my name is Bob!, I am 25 years old.

class Utils {
  static add(a, b) {
    return a + b;
  }
}

console.log(Utils.add(1, 2)); // 输出3

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        String dateTimeString = "2021-01-01T10:15:30";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
        LocalDateTime dateTime = LocalDateTime.parse(dateTimeString, formatter);
        System.out.println(dateTime);
    }
}

cluster.name: my-es-cluster
node.name: node-1
network.host: 0.0.0.0
discovery.seed_hosts:
  - node-1
  - node-2
  - node-3
cluster.initial_master_nodes:
  - node-1
  - node-2
  - node-3
http.cors.enabled: true
http.cors.allow-origin: "*"

version: '2.2'
services:
  es01:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.7.0
    container_name: es01
    environment:
      - node.name=node-1
      - cluster.name=my-es-cluster
      - discovery.seed_hosts=es02,es03
      - cluster.initial_master_nodes=node-1
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - esdata01:/usr/share/elasticsearch/data
    ports:
      - 9200:9200
    networks:
      - esnet
  es02:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.7.0
    container_name: es02
    environment:
      - node.name=node-2
      - cluster.name=my-es-cluster
      - discovery.seed_hosts=es01,es03
      - cluster.initial_master_nodes=node-1
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - esdata02:/usr/share/elasticsearch/data
    networks:
      - esnet
  es03:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.7.0
    container_name: es03
    environment:
      - node.name=node-3
      - cluster.name=my-es-cluster
      - discovery.seed_hosts=es01,es02
      - cluster.initial_master_nodes=node-1
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - esdata03:/usr/share/elasticsearch/data
    networks:
      - esnet
volumes:
  esdata01:
    driver: local
  esdata02:
    driver: local
  esdata03:
    driver: local
networks:
  esnet:
    driver:

GET /_search
{
  "query": {
    "match_phrase": {
      "field": "text to search for"
    }
  }
}

GET /_search
{
  "query": {
    "match": {
      "field": "text to search for"
    }
  }
}

GET /_search
{
  "query": {
    "multi_match": {
      "query":    "text to search for",
      "fields":   ["title", "body"]
    }
  }
}

GET /_search
{
  "query": {
    "fuzzy": {
      "field": "text to search for"
    }
  }
}

GET /_search
{
  "query": {
    "wildcard": {
      "field": "te*t"
    }
  }
}

GET /_search
{
  "query": {
    "regexp": {
      "field.keyword": "rege(xp)?"
    }
  }
}

GET /_search
{
  "query": {
    "exists": {
      "field": "user"
    }
  }
}

GET /_search
{
  "query": {
    "bool": {
      "must_not": {
        "exists": {
          "field": "user"
        }
      }
    }
  }
}

GET /_search
{
  "query": {
    "range": {
      "age": {
        "gte": 20,
        "lte": 30
      }
    }
  }
}

GET /_search
{
  "query": {
    "bool": {
      "must":     { "match": { "title": "Quick" }},
      "must_not": { "match": { "title": "lazy"  }},
      "should":   { "match": { "title": "brown" }}
    }
  }
}

GET /_search
{
  "query": {
    "constant_score": {
      "filter": {
        "term": {
          "user.id": "kimchy"
        }
      }
    }
  }
}