├── README.md
└── springboot
    ├── pom.xml
    ├── springboot.iml
    ├── src
        ├── main
        │   ├── java
        │   │   └── com
        │   │   │   └── mn
        │   │   │       └── springboot
        │   │   │           ├── SpringbootApplication.java
        │   │   │           ├── controller
        │   │   │               └── TeacherController.java
        │   │   │           ├── pojo
        │   │   │               ├── Student.java
        │   │   │               └── Teacher.java
        │   │   │           └── utils
        │   │   │               ├── GenericsUtils.java
        │   │   │               └── es
        │   │   │                   ├── ESClient.java
        │   │   │                   └── ESUtil.java
        │   └── resources
        │   │   ├── application.yml
        │   │   └── esmapper
        │   │       ├── student.xml
        │   │       └── teacher.xml
        └── test
        │   └── java
        │       └── com
        │           └── mn
        │               └── springboot
        │                   └── SpringbootApplicationTests.java
    └── target
        ├── classes
            ├── application.yml
            ├── com
            │   └── mn
            │   │   └── springboot
            │   │       ├── SpringbootApplication.class
            │   │       ├── controller
            │   │           └── TeacherController.class
            │   │       ├── pojo
            │   │           ├── Student.class
            │   │           └── Teacher.class
            │   │       └── utils
            │   │           ├── GenericsUtils.class
            │   │           └── es
            │   │               ├── ESClient.class
            │   │               └── ESUtil.class
            └── esmapper
            │   ├── student.xml
            │   └── teacher.xml
        └── test-classes
            └── com
                └── mn
                    └── springboot
                        └── SpringbootApplicationTests.class


/README.md:
--------------------------------------------------------------------------------
 1 | # springboot-bboss-elasticsearch
 2 | ##### https://blog.csdn.net/qq_31748587/article/details/84134864
 3 | ##### 整合springboot+bboss+elasticsearch，实现java对es的操作
 4 | ##### 需要修改的配置
 5 | ##### application.yml文件：
 6 | ##### basePath：对应mapper.xml文件存放的位置
 7 | ##### indexs：es的全部索引，以逗号分隔
 8 | ```
 9 | es:
10 |   basePath: esmapper
11 |   indexs: teacher,student
12 | ```
13 | ##### 创建对应的mapper.xml文件即可
14 | 


--------------------------------------------------------------------------------
/springboot/pom.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3 | 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 4 | 	<modelVersion>4.0.0</modelVersion>
 5 | 
 6 | 	<groupId>com.mn</groupId>
 7 | 	<artifactId>springboot</artifactId>
 8 | 	<version>0.0.1-SNAPSHOT</version>
 9 | 	<packaging>jar</packaging>
10 | 
11 | 	<name>springboot</name>
12 | 	<description>Demo project for Spring Boot</description>
13 | 
14 | 	<parent>
15 | 		<groupId>org.springframework.boot</groupId>
16 | 		<artifactId>spring-boot-starter-parent</artifactId>
17 | 		<version>2.0.5.RELEASE</version>
18 | 		<relativePath/> <!-- lookup parent from repository -->
19 | 	</parent>
20 | 
21 | 	<properties>
22 | 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
23 | 		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
24 | 		<java.version>1.8</java.version>
25 | 	</properties>
26 | 
27 | 	<dependencies>
28 | 		<dependency>
29 | 			<groupId>org.springframework.boot</groupId>
30 | 			<artifactId>spring-boot-starter-web</artifactId>
31 | 		</dependency>
32 | 		<dependency>
33 | 			<groupId>org.springframework.boot</groupId>
34 | 			<artifactId>spring-boot-starter-test</artifactId>
35 | 			<scope>test</scope>
36 | 		</dependency>
37 | 
38 | 		<dependency>
39 | 			<groupId>com.bbossgroups.plugins</groupId>
40 | 			<artifactId>bboss-elasticsearch-spring-boot-starter</artifactId>
41 | 			<version>5.1.5</version>
42 | 		</dependency>
43 | 	</dependencies>
44 | 
45 | 	<build>
46 | 		<plugins>
47 | 			<plugin>
48 | 				<groupId>org.springframework.boot</groupId>
49 | 				<artifactId>spring-boot-maven-plugin</artifactId>
50 | 			</plugin>
51 | 		</plugins>
52 | 	</build>
53 | 
54 | 
55 | </project>
56 | 


--------------------------------------------------------------------------------
/springboot/springboot.iml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
 3 |   <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_5">
 4 |     <output url="file://$MODULE_DIR$/target/classes" />
 5 |     <output-test url="file://$MODULE_DIR$/target/test-classes" />
 6 |     <content url="file://$MODULE_DIR$">
 7 |       <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
 8 |       <sourceFolder url="file://$MODULE_DIR$/src/main/resources" type="java-resource" />
 9 |       <sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
10 |       <excludeFolder url="file://$MODULE_DIR$/target" />
11 |     </content>
12 |     <orderEntry type="jdk" jdkName="1.8" jdkType="JavaSDK" />
13 |     <orderEntry type="sourceFolder" forTests="false" />
14 |   </component>
15 | </module>


--------------------------------------------------------------------------------
/springboot/src/main/java/com/mn/springboot/SpringbootApplication.java:
--------------------------------------------------------------------------------
 1 | package com.mn.springboot;
 2 | 
 3 | import org.springframework.boot.SpringApplication;
 4 | import org.springframework.boot.autoconfigure.SpringBootApplication;
 5 | 
 6 | @SpringBootApplication
 7 | public class SpringbootApplication {
 8 | 
 9 | 	public static void main(String[] args) {
10 | 		SpringApplication.run(SpringbootApplication.class, args);
11 | 	}
12 | }
13 | 


--------------------------------------------------------------------------------
/springboot/src/main/java/com/mn/springboot/controller/TeacherController.java:
--------------------------------------------------------------------------------
 1 | package com.mn.springboot.controller;
 2 | 
 3 | import com.mn.springboot.pojo.Teacher;
 4 | import com.mn.springboot.utils.es.ESClient;
 5 | import com.mn.springboot.utils.es.ESUtil;
 6 | import org.springframework.beans.factory.annotation.Autowired;
 7 | import org.springframework.web.bind.annotation.GetMapping;
 8 | import org.springframework.web.bind.annotation.RestController;
 9 | 
10 | import java.util.ArrayList;
11 | import java.util.List;
12 | 
13 | @RestController
14 | public class TeacherController {
15 |     @Autowired
16 |     private ESUtil esUtil;
17 | 
18 |     @GetMapping("add")
19 |     public String add(){
20 |         Teacher teacher = new Teacher();
21 |         teacher.setTeacherId("2");
22 |         teacher.setName("吴老师");
23 |         teacher.setSex("男");
24 |         teacher.setAge(50);
25 |         Teacher teacher1 = new Teacher();
26 |         teacher1.setTeacherId("1");
27 |         teacher1.setName("王老师");
28 |         teacher1.setSex("女");
29 |         teacher1.setAge(20);
30 |         List<Teacher> list = new ArrayList<>();
31 |         list.add(teacher);
32 |         list.add(teacher1);
33 |         esUtil.addOrUpdateDocuments("teacher",list);
34 |         return "ok";
35 |     }
36 | 
37 |     @GetMapping("delete")
38 |     public String delete(){
39 |         esUtil.deleteDocumentById("teacher","1");
40 |         return "ok";
41 |     }
42 | 
43 |     @GetMapping("get")
44 |     public List<Teacher> get(){
45 |         Teacher teacher = new Teacher();
46 |         teacher.setTeacherId("2");
47 |         List<Teacher> t = esUtil.exec("teacher",teacher,"searchTeacher");
48 |         return t;
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/springboot/src/main/java/com/mn/springboot/pojo/Student.java:
--------------------------------------------------------------------------------
 1 | package com.mn.springboot.pojo;/*
 2 | 
 3 | import com.frameworkset.orm.annotation.ESId;
 4 | import org.frameworkset.elasticsearch.entity.ESBaseData;
 5 | 
 6 | /**
 7 |  * 测试实体，可以从ESBaseData对象继承meta属性，检索时会将文档的一下meta属性设置到对象实例中
 8 |  */
 9 | 
10 | import com.frameworkset.orm.annotation.ESId;
11 | import org.frameworkset.elasticsearch.entity.ESBaseData;
12 | 
13 | public class Student extends ESBaseData {
14 | 	//设定文档标识字段
15 | 	@ESId
16 | 	private String studentId;
17 | 	private String name;
18 | 	private Integer age;
19 | 	private String sex;
20 | 
21 | 	public String getStudentId() {
22 | 		return studentId;
23 | 	}
24 | 
25 | 	public void setStudentId(String studentId) {
26 | 		this.studentId = studentId;
27 | 	}
28 | 
29 | 	/**  当在mapping定义中指定了日期格式时，则需要指定以下两个注解,例如
30 | 	 *
31 | 	 "agentStarttime": {
32 | 	 "type": "date",###指定多个日期格式
33 | 	 "format":"yyyy-MM-dd HH:mm:ss.SSS||yyyy-MM-dd'T'HH:mm:ss.SSS||yyyy-MM-dd HH:mm:ss||epoch_millis"
34 | 	 }
35 | 	 @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss.SSS")
36 | 	 @Column(dataformat = "yyyy-MM-dd HH:mm:ss.SSS")
37 | 	 */
38 | 
39 | 	public String getName() {
40 | 		return name;
41 | 	}
42 | 
43 | 	public void setName(String name) {
44 | 		this.name = name;
45 | 	}
46 | 
47 | 	public Integer getAge() {
48 | 		return age;
49 | 	}
50 | 
51 | 	public void setAge(Integer age) {
52 | 		this.age = age;
53 | 	}
54 | 
55 | 	public String getSex() {
56 | 		return sex;
57 | 	}
58 | 
59 | 	public void setSex(String sex) {
60 | 		this.sex = sex;
61 | 	}
62 | }
63 | 


--------------------------------------------------------------------------------
/springboot/src/main/java/com/mn/springboot/pojo/Teacher.java:
--------------------------------------------------------------------------------
 1 | package com.mn.springboot.pojo;/*
 2 | 
 3 | import com.frameworkset.orm.annotation.ESId;
 4 | import org.frameworkset.elasticsearch.entity.ESBaseData;
 5 | 
 6 | /**
 7 |  * 测试实体，可以从ESBaseData对象继承meta属性，检索时会将文档的一下meta属性设置到对象实例中
 8 |  */
 9 | 
10 | import com.frameworkset.orm.annotation.ESId;
11 | import org.frameworkset.elasticsearch.entity.ESBaseData;
12 | 
13 | public class Teacher extends ESBaseData {
14 | 	//设定文档标识字段
15 | 	@ESId
16 | 	private String teacherId;
17 | 	private String name;
18 | 	private Integer age;
19 | 	private String sex;
20 | 	/**  当在mapping定义中指定了日期格式时，则需要指定以下两个注解,例如
21 | 	 *
22 | 	 "agentStarttime": {
23 | 	 "type": "date",###指定多个日期格式
24 | 	 "format":"yyyy-MM-dd HH:mm:ss.SSS||yyyy-MM-dd'T'HH:mm:ss.SSS||yyyy-MM-dd HH:mm:ss||epoch_millis"
25 | 	 }
26 | 	 @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss.SSS")
27 | 	 @Column(dataformat = "yyyy-MM-dd HH:mm:ss.SSS")
28 | 	 */
29 | 	public String getTeacherId() {
30 | 		return teacherId;
31 | 	}
32 | 
33 | 	public void setTeacherId(String teacherId) {
34 | 		this.teacherId = teacherId;
35 | 	}
36 | 
37 | 	public String getName() {
38 | 		return name;
39 | 	}
40 | 
41 | 	public void setName(String name) {
42 | 		this.name = name;
43 | 	}
44 | 
45 | 	public Integer getAge() {
46 | 		return age;
47 | 	}
48 | 
49 | 	public void setAge(Integer age) {
50 | 		this.age = age;
51 | 	}
52 | 
53 | 	public String getSex() {
54 | 		return sex;
55 | 	}
56 | 
57 | 	public void setSex(String sex) {
58 | 		this.sex = sex;
59 | 	}
60 | }
61 | 


--------------------------------------------------------------------------------
/springboot/src/main/java/com/mn/springboot/utils/GenericsUtils.java:
--------------------------------------------------------------------------------
 1 | package com.mn.springboot.utils;
 2 | 
 3 | import java.lang.reflect.ParameterizedType;
 4 | import java.lang.reflect.Type;
 5 | 
 6 | public class GenericsUtils {
 7 |     /**
 8 |      * 通过反射,获得定义Class时声明的父类的范型参数的类型. 如public BookManager extends
 9 |      * GenricManager<Book>
10 |      * 
11 |      * @param clazz The class to introspect
12 |      * @return the first generic declaration, or <code>Object.class</code> if cannot be determined
13 |      */
14 |     public static Class getSuperClassGenricType(Class clazz) {
15 |         return getSuperClassGenricType(clazz, 0);
16 |     }
17 | 
18 |     /**
19 |      * 通过反射,获得定义Class时声明的父类的范型参数的类型. 如public BookManager extends GenricManager<Book>
20 |      * 
21 |      * @param clazz clazz The class to introspect
22 |      * @param index the Index of the generic ddeclaration,start from 0.
23 |      */
24 |     public static Class getSuperClassGenricType(Class clazz, int index)
25 |             throws IndexOutOfBoundsException {
26 |         Type genType = clazz.getGenericSuperclass();
27 |         if (!(genType instanceof ParameterizedType)) {
28 |             return Object.class;
29 |         }
30 |         Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
31 |         if (index >= params.length || index < 0) {
32 |             return Object.class;
33 |         }
34 |         if (!(params[index] instanceof Class)) {
35 |             return Object.class;
36 |         }
37 |         return (Class) params[index];
38 |     }
39 | }


--------------------------------------------------------------------------------
/springboot/src/main/java/com/mn/springboot/utils/es/ESClient.java:
--------------------------------------------------------------------------------
 1 | package com.mn.springboot.utils.es;
 2 | 
 3 | import org.frameworkset.elasticsearch.ElasticSearchHelper;
 4 | import org.frameworkset.elasticsearch.client.ClientInterface;
 5 | import org.springframework.beans.factory.annotation.Value;
 6 | import org.springframework.stereotype.Component;
 7 | 
 8 | import java.util.Map;
 9 | import java.util.concurrent.ConcurrentHashMap;
10 | 
11 | /**
12 |  * 管理es rest client组件实例
13 |  */
14 | @Component
15 | public class ESClient {
16 | 	//基础不需要xml
17 | 	private static ClientInterface restClient;
18 | 	private static String basePath;
19 | 	private static String indexs;
20 | 	//客户端
21 | 	private static Map<String,ClientInterface> client = new ConcurrentHashMap<>();
22 | 
23 | 	/**
24 | 	 * 获取操作默认的es集群的客户端工具组件
25 | 	 * @return
26 | 	 */
27 | 	public static ClientInterface restClient(){
28 | 		if(restClient == null) {
29 | 			synchronized (ClientInterface.class) {
30 | 				if (restClient == null) {
31 | 					restClient = ElasticSearchHelper.getRestClientUtil();
32 | 				}
33 | 			}
34 | 		}
35 | 		return restClient;
36 | 	}
37 | 
38 | 	/**
39 | 	 * 获取操作配置文件的es集群的客户端工具组件
40 | 	 * @return
41 | 	 */
42 | 	public static ClientInterface restClient(String index){
43 | 		if(client.isEmpty()){
44 | 			String[] indexArr = indexs.split(",");
45 | 			for(int i=0;i<indexArr.length;i++){
46 | 				client.put(indexArr[i],ElasticSearchHelper.getConfigRestClientUtil(basePath+indexArr[i]+".xml"));
47 | 			}
48 | 		}
49 | 		return client.get(index);
50 | 	}
51 | 
52 | 	@Value("${es.basePath}")
53 | 	public void setBasePath(String basePath) {
54 | 		ESClient.basePath = basePath;
55 | 	}
56 | 
57 | 	@Value("${es.indexs}")
58 | 	public void setIndexs(String indexs) {
59 | 		ESClient.indexs = indexs;
60 | 	}
61 | }
62 | 


--------------------------------------------------------------------------------
/springboot/src/main/java/com/mn/springboot/utils/es/ESUtil.java:
--------------------------------------------------------------------------------
  1 | package com.mn.springboot.utils.es;
  2 | 
  3 | import com.mn.springboot.utils.GenericsUtils;
  4 | import org.frameworkset.elasticsearch.client.ClientInterface;
  5 | import org.frameworkset.elasticsearch.entity.ESDatas;
  6 | import org.springframework.stereotype.Service;
  7 | 
  8 | import java.util.List;
  9 | 
 10 | /**
 11 |  * es工具类
 12 |  */
 13 | @Service
 14 | public class ESUtil {
 15 | 	/**
 16 | 	 * 添加或修改文档
 17 | 	 */
 18 | 	public void addOrUpdateDocument(String index,Object obj){
 19 | 		//获取文档的客户端对象，单实例多线程安全
 20 | 		ClientInterface clientUtil = ESClient.restClient();
 21 | 		//向固定index添加或者修改文档,如果id已经存在做修改操作，否则做添加文档操作，返回处理结果
 22 | 		//索引表 索引类型
 23 | 		clientUtil.addDocument(index,index,obj);
 24 | 	}
 25 | 
 26 | 	/**
 27 | 	 * 添加或修改文档
 28 | 	 */
 29 | 	public <T> void addOrUpdateDocuments(String index,List<T> list){
 30 | 		//获取文档的客户端对象，单实例多线程安全
 31 | 		ClientInterface clientUtil = ESClient.restClient();
 32 | 		//向固定index添加或者修改文档,id，否则做添加文档操作，返回处理结果
 33 | 		//索引表 索引类型
 34 | 		clientUtil.addDocuments(index,index,list);
 35 | 	}
 36 | 	/**
 37 | 	 * 获取文档
 38 | 	 */
 39 | 	public String getDocumentById(String index,String id){
 40 | 		//获取文档的客户端对象，单实例多线程安全
 41 | 		ClientInterface clientUtil = ESClient.restClient();
 42 | 		//索引表 索引类型 id
 43 | 		String res = clientUtil.getDocument(index,index,id);
 44 | 		return res;
 45 | 	}
 46 | 	/**
 47 | 	 * 获取文档
 48 | 	 */
 49 | 	public <T> T getDocumentById(String index,String id,Class<T> t){
 50 | 		//获取文档的客户端对象，单实例多线程安全
 51 | 		ClientInterface clientUtil = ESClient.restClient();
 52 | 		//索引表 索引类型 id 对象
 53 | 		return clientUtil.getDocument(index,index,id,t);
 54 | 	}
 55 | 	/**
 56 | 	 * 删除文档
 57 | 	 */
 58 | 	public void deleteDocumentById(String index,String id){
 59 | 		//获取文档的客户端对象，单实例多线程安全
 60 | 		ClientInterface clientUtil = ESClient.restClient();
 61 | 		//索引表 索引类型 id 对象
 62 | 		clientUtil.deleteDocument(index,index,id);
 63 | 	}
 64 | 	/**
 65 | 	 * 删除文档
 66 | 	 */
 67 | 	public void deleteDocumentByIds(String index,String[] ids){
 68 | 		//获取文档的客户端对象，单实例多线程安全
 69 | 		ClientInterface clientUtil = ESClient.restClient();
 70 | 		StringBuilder builder = new StringBuilder();
 71 | 		String[] var5 = ids;
 72 | 		for(int i = 0; i < ids.length; ++i) {
 73 | 			String id = ids[i];
 74 | 			builder.append("{ \"delete\" : { \"_index\" : \"").append(index).append("\", \"_type\" : \"").append(index).append("\", \"_id\" : \"").append(id).append("\" } }\n");
 75 | 		}
 76 | 		//索引表 索引类型 id 对象
 77 | 		clientUtil.executeHttp("_bulk",builder.toString(),"post");
 78 | 	}
 79 | 
 80 | 	/**
 81 | 	 * 通过mapper文件执行查询语句
 82 | 	 * @param index 索引
 83 | 	 * @param params 传递的参数
 84 | 	 * @param dsl 对应mapper文件的name
 85 | 	 */
 86 | 	public <T> List<T> exec(String index,T params,String dsl){
 87 | 		//获取索引对应的客户端
 88 | 		ClientInterface clientUtil = ESClient.restClient(index);
 89 | 		//设定查询条件,通过map传递变量参数值,key对于dsl中的变量名称
 90 | 		//执行查询，index为索引表，_search为检索操作action
 91 | 		//使用反射获取Class<T>
 92 | 		Class<T> clazz = GenericsUtils.getSuperClassGenricType(params.getClass());
 93 | 		ESDatas<T> esDatas =  //ESDatas包含当前检索的记录集合，最多1000条记录，由dsl中的size属性指定
 94 | 				clientUtil.searchList(index+"/_search",//demo为索引表，_search为检索操作action
 95 | 						dsl,//esmapper/xxx.xml中定义的dsl语句的name
 96 | 						params,//变量参数
 97 | 						clazz);//返回的文档封装对象类型
 98 | 		//获取结果对象列表，最多返回1000条记录
 99 | 		List<T> list = esDatas.getDatas();
100 | 		//获取总记录数
101 | 		long totalSize = esDatas.getTotalSize();
102 | 		return list;
103 | 	}
104 | }
105 | 


--------------------------------------------------------------------------------
/springboot/src/main/resources/application.yml:
--------------------------------------------------------------------------------
 1 | server:
 2 |   port: 8888
 3 | spring:
 4 |   elasticsearch:
 5 |     bboss:
 6 |       elasticUser:
 7 |       elasticPassword:
 8 |       elasticsearch:
 9 |         rest:
10 |           hostNames: 127.0.0.1:9200
11 |         dateFormat: yyyy-MM-dd hh:mm:ss
12 |         timeZone: Asia/Shanghai
13 |         ttl: 2d
14 |         showTemplate: true
15 |         discoverHost: false
16 |       dslfile:
17 |         refreshInterval: -1
18 |       http:
19 |          timeoutConnection: 400000
20 |          timeoutSocket: 400000
21 |          connectionRequestTimeout: 400000
22 |          retryTime: 1
23 |          maxLineLength: -1
24 |          maxHeaderCount: 200
25 |          maxTotal: 400
26 |          defaultMaxPerRoute: 200
27 |          soReuseAddress: false
28 |          soKeepAlive: false
29 |          timeToLive: 3600000
30 |          keepAlive: 3600000
31 |          keystore:
32 |          keyPassword:
33 |          hostnameVerifier:
34 | es:
35 |   basePath: esmapper/
36 |   indexs: teacher,student
37 | 


--------------------------------------------------------------------------------
/springboot/src/main/resources/esmapper/student.xml:
--------------------------------------------------------------------------------
  1 | <properties>
  2 | 
  3 | 
  4 |     <!--
  5 |         一个简单的检索dsl,中有四个变量
  6 |         name 全文检索字段
  7 |         startTime
  8 |         endTime
  9 |         通过map传递变量参数值
 10 | 
 11 |         变量语法参考文档：https://my.oschina.net/bboss/blog/1556866
 12 |     -->
 13 |     <property name="searchStudent">
 14 |         <![CDATA[{
 15 |             "query": {
 16 |                 "match": {
 17 |                    "_id": "2"
 18 |                 }
 19 |             }
 20 |         }]]>
 21 |     </property>
 22 | 
 23 |     <!--
 24 |         一个简单的检索dsl,中有四个变量
 25 |         applicationName1
 26 |         applicationName2
 27 |         startTime
 28 |         endTime
 29 |         通过map传递变量参数值
 30 | 
 31 |         变量语法参考文档：
 32 |     -->
 33 |     <property name="searchDatas">
 34 |         <![CDATA[{
 35 |             "query": {
 36 |                 "bool": {
 37 |                     "filter": [
 38 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
 39 |                             "terms": {
 40 |                                 "applicationName.keyword": [#[applicationName1],#[applicationName2]]
 41 |                             }
 42 |                         },
 43 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
 44 |                             "range": {
 45 |                                 "agentStarttime": {
 46 |                                     "gte": #[startTime],##统计开始时间
 47 |                                     "lt": #[endTime]  ##统计截止时间
 48 |                                 }
 49 |                             }
 50 |                         }
 51 |                     ]
 52 |                 }
 53 |             },
 54 |             ## 最多返回1000条记录
 55 |             "size":1000
 56 |         }]]>
 57 |     </property>
 58 | 
 59 | 
 60 |     <property name="searchWithCustomEscapeWithError">
 61 |         <![CDATA[{## 这是一个错误的案例，本条dsl会运行失败，变量中的特殊字符，日期类型都没有得到正确处理
 62 |             "query": {
 63 |                 "bool": {
 64 |                     "filter": [
 65 |                         {  ## 多值检索，查找多个应用名称对应的文档记录,参数applicationName1和applicationName2中都包含特殊字符
 66 |                            ## 通过escape属性禁用applicationName1变量的自动转义
 67 |                            ## $applicationName2 模式变量不会自动转移义，不会对日期自动进行格式化处理，这种模式的变量适用于逻辑判断/foreach循环变量/以及不带特殊字符的String/数字参数
 68 |                             "terms": {
 69 |                                 "applicationName.keyword": [#[applicationName1,escape=false],"$applicationName2"]
 70 |                             }
 71 |                         },
 72 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
 73 |                             "range": {
 74 |                                 "agentStarttime": {
 75 |                                     "gte": #[startTime],##统计开始时间，startTime为日期类型，#[startTime]自动对日期类型进行正确的格式化处理
 76 |                                     "lt": "$endTime"  ## 统计截止时间,endTime为日期类型参数，但是$endTime变量不会对日期进行格式化处理，会有日期格式问题,这里会报错
 77 |                                 }
 78 |                             }
 79 |                         }
 80 |                     ]
 81 |                 }
 82 |             },
 83 |             ## 最多返回1000条记录
 84 |             "size":1000
 85 |         }]]>
 86 |     </property>
 87 |     <property name="queryPid"><![CDATA[{
 88 |         "query": { "match": { "pid": #[pid] } }
 89 |      }]]>
 90 |     </property>
 91 |     <property name="searchWithCustomEscape">
 92 |         <![CDATA[{
 93 |             "query": {
 94 |                 "bool": {
 95 |                     "filter": [
 96 |                         {  ## 多值检索，查找多个应用名称对应的文档记录,自动转义，可以正常运行
 97 |                             "terms": {
 98 |                                 "applicationName.keyword": [#[applicationName1],#[applicationName2]]
 99 |                             }
100 |                         },
101 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
102 |                             "range": {
103 |                                 "agentStarttime": {
104 |                                     "gte": #[startTime],##统计开始时间
105 |                                     "lt": #[endTime]  ##统计截止时间
106 |                                 }
107 |                             }
108 |                         }
109 |                     ]
110 |                 }
111 |             },
112 |             ## 最多返回1000条记录
113 |             "size":1000
114 |         }]]>
115 |     </property>
116 | 
117 |     <!--
118 |        一个简单的检索dsl,中有四个变量
119 |        applicationName1
120 |        applicationName2
121 |        startTime
122 |        endTime
123 |        通过map传递变量参数值
124 | 
125 |        变量语法参考文档：
126 |    -->
127 |     <property name="searchPagineDatas">
128 |         <![CDATA[{
129 |             "query": {
130 |                 "bool": {
131 |                     "filter": [
132 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
133 |                             "terms": {
134 |                                 "applicationName.keyword": [#[applicationName1],#[applicationName2]]
135 |                             }
136 |                         },
137 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
138 |                             "range": {
139 |                                 "agentStarttime": {
140 |                                     "gte": #[startTime],##统计开始时间
141 |                                     "lt": #[endTime]  ##统计截止时间
142 |                                 }
143 |                             }
144 |                         }
145 |                     ]
146 |                 }
147 |             },
148 |             ## 分页起点
149 |             "from":#[from],
150 |             ## 最多返回size条记录
151 |             "size":#[size]
152 |         }]]>
153 |     </property>
154 | 
155 |     <!--
156 |         一个简单的检索dsl,中有四个变量
157 |         applicationName1
158 |         applicationName2
159 |         startTime
160 |         endTime
161 |         通过map传递变量参数值
162 | 
163 |         变量语法参考文档：
164 |     -->
165 |     <property name="searchDatasArray">
166 |         <![CDATA[{
167 |             "query": {
168 |                 "bool": {
169 |                     "filter": [
170 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
171 |                             "terms": {
172 |                                 "applicationName.keyword":#[applicationNames,serialJson=true]
173 |                             }
174 |                         },
175 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
176 |                             "range": {
177 |                                 "agentStarttime": {
178 |                                     "gte": #[startTime],##统计开始时间
179 |                                     "lt": #[endTime]  ##统计截止时间
180 |                                 }
181 |                             }
182 |                         }
183 |                     ]
184 |                 }
185 |             },
186 |             ## 最多返回1000条记录
187 |             "size":1000
188 |         }]]>
189 |     </property>
190 | 
191 |     <!--
192 |         一个SourceFilter的检索dsl,中有四个参数变量
193 |         applicationName1
194 |         applicationName2
195 |         startTime
196 |         endTime
197 |         通过map传递变量参数值
198 | 
199 |         {
200 |             "_source": {
201 |                 "includes": [ "agentStarttime", "applicationName" ],
202 |                 "excludes": [ "contentbody" ]
203 |             },
204 |             "query" : {
205 |                 "term" : { "user" : "kimchy" }
206 |             }
207 |         }
208 | 
209 |     -->
210 |     <property name="searchSourceFilter">
211 |         <![CDATA[{
212 |         #if($includes || $excludes) ## 只有指定了includes或者excludes才需要添加source filter
213 |             "_source": {
214 |                 #if($includes && $includes.size() > 0) ##设置includes filter
215 |                     "includes": [
216 |                         #foreach($include in $includes)
217 |                              #if($velocityCount > 0),#end "$include"
218 |                         #end
219 |                     ]
220 |                     #if($excludes && $excludes.size() > 0),#end ##如果还存在排斥字段，则需要加一个逗号
221 |                 #end
222 |                 #if($excludes && $excludes.size() > 0)  ##设置excludes filter
223 |                     "excludes": [
224 |                         #foreach($exclude in $excludes)
225 |                              #if($velocityCount > 0),#end "$exclude"
226 |                         #end
227 |                     ]
228 |                 #end
229 |             },
230 |         #end
231 |             "query": {
232 |                 "bool": {
233 |                     "filter": [
234 |                     #if($applicationNames && $applicationNames.size() > 0) ##只有传递了需要检索的应用名称集合，才需要添加下面的条件
235 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
236 |                             "terms": {
237 |                                 "applicationName.keyword":[
238 |                                     #foreach($applicationName in $applicationNames)
239 |                                          #if($velocityCount > 0),#end "$applicationName"
240 |                                     #end
241 |                                 ]
242 |                             }
243 |                         },
244 |                     #end
245 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
246 |                             "range": {
247 |                                 "agentStarttime": {
248 |                                     "gte": #[startTime],##统计开始时间
249 |                                     "lt": #[endTime]  ##统计截止时间
250 |                                 }
251 |                             }
252 |                         }
253 |                     ]
254 |                 }
255 |             },
256 |             ## 最多返回pageSize参数对应记录条数
257 |             "size":#[pageSize]
258 |         }]]>
259 |     </property>
260 | 
261 | 
262 |     <!--部分更新,注意：dsl不能换行-->
263 |     <property name="updatePartDocument">
264 |         <![CDATA[{"applicationName" : #[applicationName],"agentStarttime" : #[agentStarttime],"contentbody" : #[contentbody]}]]>
265 |     </property>
266 | 
267 |     <property name="demoTemplate">
268 |         <![CDATA[{
269 |             "index_patterns": "demo-*", ## 5.x版本中请使用语法："template": "demo-*"
270 |             "settings": {
271 |                 "number_of_shards": 30,
272 |                 "number_of_replicas" : 2,
273 |                 "index.refresh_interval": "5s"
274 |             },
275 |             "mappings": {
276 |                 "demo": {
277 |                     "properties": {
278 |                         "contentbody": {
279 |                             "type": "text",
280 |                             "fields": {
281 |                                 "keyword": {
282 |                                     "type": "keyword",
283 |                                     "ignore_above": 256
284 |                                 }
285 |                             }
286 |                         },
287 |                         "agentStarttime": {
288 |                             "type": "date",
289 |                             "format":"yyyy-MM-dd HH:mm:ss.SSS||yyyy-MM-dd'T'HH:mm:ss.SSS||yyyy-MM-dd HH:mm:ss||epoch_millis"
290 |                         },
291 |                         "applicationName": {
292 |                             "type": "text",
293 |                             "fields": {
294 |                                 "keyword": {
295 |                                     "type": "keyword",
296 |                                     "ignore_above": 256
297 |                                 }
298 |                             }
299 |                         }
300 |                     }
301 |                 }
302 |             }
303 |         }]]>
304 |     </property>
305 | 
306 |     <!--
307 |     修改demo 索引表的结构，增加email字段
308 |     https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-put-mapping.html
309 |     -->
310 |     <property name="updateDemoIndice">
311 |         <![CDATA[{
312 |           "properties": {
313 |             "email": {
314 |               "type": "keyword"
315 |             }
316 |           }
317 |         }]]>
318 |     </property>
319 | 
320 | 
321 |     <property name="scriptPianduan1">
322 |         <![CDATA[
323 |             "params": {
324 |               "last": #[last],
325 |               "nick": #[nick],
326 |               "goodsId": #[dynamicPriceTemplate->goodsId],
327 |               "rules":[
328 |                    #foreach($rule in $dynamicPriceTemplate.rules)
329 |                        #if($velocityCount > 0),#end
330 |                    {
331 |                         "ruleId": #[dynamicPriceTemplate->rules[$velocityCount]->ruleId],
332 |                         "ruleCount": #[dynamicPriceTemplate->rules[$velocityCount]->ruleCount],
333 |                         "ruleExist": #[dynamicPriceTemplate->rules[$velocityCount]->ruleExist]
334 |                     }
335 |                    #end
336 |               ]
337 |             }
338 |         ]]>
339 |     </property>
340 | 
341 |     <property name="scriptPianduan">
342 |         <![CDATA[
343 |             "params": {
344 |               "last": #[last],
345 |               "nick": #[nick],
346 |               "goodsId": #[dynamicPriceTemplate->goodsId],
347 |               "rules":[
348 |                    #foreach($rule in $dynamicPriceTemplate.rules)
349 |                        #if($velocityCount > 0),#end
350 |                    {
351 | 
352 |                         "ruleId": "$rule.ruleId",
353 |                         "ruleCount": $rule.ruleCount,
354 |                         "ruleExist":  $rule.ruleExist
355 | 
356 |                     }
357 |                    #end
358 |               ]
359 |             }
360 |         ]]>
361 |     </property>
362 |     <property name="scriptDsl">
363 |         <![CDATA[{
364 |           "script": {
365 |             "lang": "painless",
366 |             "source": @"""
367 |               ctx._source.last = params.last;
368 |               ctx._source.nick = params.nick;
369 |               ctx._source.rules = params.rules
370 |             """,
371 |             @{scriptPianduan}
372 |           }
373 |         }]]>
374 |     </property>
375 | 
376 |     <property name="scriptPianduan2">
377 |         <![CDATA[
378 |             "params": {
379 |               "last": #[last],
380 |               "nick": #[nick],
381 |               "goodsId": #[dynamicPriceTemplate->goodsId],
382 |               "rules":[
383 |                    #foreach($rule in $dynamicPriceTemplate.rules)
384 |                        #[dynamicPriceTemplate->rules[$velocityCount],serialJson=true] ## 通过属性serialJson指示框架直接将对象序列化为json数据
385 |                         #if($velocityCount != ($dynamicPriceTemplate.rules.size() - 1)),#end
386 |                    #end
387 |               ]
388 |             }
389 |         ]]>
390 |     </property>
391 |     <property name="scriptDslByQuery">
392 |         <![CDATA[{
393 |           "query": {
394 |             "bool": {
395 |               "must": [
396 |                 {
397 |                   "term": {
398 |                     "_id": #[id]
399 |                   }
400 |                 }
401 |               ]
402 |             }
403 |           },
404 |           "script": {
405 |             "lang": "painless",
406 |             "source": @"""
407 |               ctx._source.last = params.last;
408 |               ctx._source.lastSpecial = "#[last,quoted=false]";
409 |               ctx._source.nick = params.nick;
410 |               ctx._source.goodName = #[dynamicPriceTemplate->goodName,escapeCount=2];#*在脚本中，含有特殊字符的goodName需要转义2次*#
411 |               ctx._source.goodsId = #[dynamicPriceTemplate->goodsId];
412 |               ctx._source.dynamicPriceTemplate.goodsId = params.goodsId;
413 |               ctx._source.rules = params.rules
414 |             """,
415 |             @{scriptPianduan2}
416 |           }
417 |         }]]>
418 |     </property>
419 | 
420 |     <property name="mapbianli"><![CDATA[
421 |         ## map遍历实例，通过$item.value直接输出值，如果值中存在的特殊字符，不会对特殊字符进行转义处理，请自行处理
422 |         #foreach($item in $softTypeMap.entrySet())
423 |             #if($velocityCount > 0),#end
424 |             { "match": { "$item.key": "$item.value" } }
425 |         #end
426 |     ]]>
427 |     </property>
428 | 
429 | 
430 |     <property name="mapbianliescape"><![CDATA[
431 |         ## map<String,List<String>>遍历实例，可以通过#[]绑定变量对值中存在的特殊字符进行转义处理
432 |         #foreach($item in $softTypeMap.entrySet())
433 |             #if($item.value)
434 |                 #if($velocityCount > 0),#end
435 |                 { "match": { "$item.key": #[softTypeMap[$item.key],serialJson=true] } }
436 |             #end
437 |         #end
438 |     ]]>
439 |     </property>
440 | 
441 |     <property name="queryArray">
442 |         <![CDATA[
443 |         {
444 |             "size":10000,
445 |             "query": {
446 |                 "bool": {
447 |                     "must": [
448 |                             #foreach($item in $softTypeMap.entrySet())
449 |                                 #if($velocityCount > 0),#end
450 |                                 { "match":
451 |                                     {
452 |                                     #if($item.value)
453 |                                     "$item.key":
454 |                                     [
455 |                                         #foreach($applicationName in $item.value)
456 |                                              #if($velocityCount > 0),#end #[softTypeMap[$item.key][$velocityCount]]
457 |                                         #end
458 |                                     ]
459 |                                     #end
460 |                                     }
461 |                                  }
462 |                             #end
463 |                     ]
464 |                  }
465 |             }
466 |         }
467 |         ]]>
468 |     </property>
469 | 
470 |     <property name="queryArray1">
471 |         <![CDATA[
472 |         #if($mustShouldMap)
473 |                         #foreach($item in $mustShouldMap.entrySet())
474 |                             ,
475 |                             "must":{
476 |                                 "bool":{
477 |                                     "should":[
478 |                                         #foreach($children in $item)
479 |                                             #if($velocityCount > 0),#end
480 |                                             { "match": { "$item.key": #[$mustShouldMap[$item.key][$velocityCount]] } }
481 |                                         #end
482 |                                     ]
483 |                                 }
484 |                             }
485 |                         #end
486 |                     #end
487 |         ]]>
488 |     </property>
489 | </properties>


--------------------------------------------------------------------------------
/springboot/src/main/resources/esmapper/teacher.xml:
--------------------------------------------------------------------------------
  1 | <properties>
  2 | 
  3 | 
  4 |     <!--
  5 |         一个简单的检索dsl,中有四个变量
  6 |         name 全文检索字段
  7 |         startTime
  8 |         endTime
  9 |         通过map传递变量参数值
 10 | 
 11 |         变量语法参考文档：https://my.oschina.net/bboss/blog/1556866
 12 |     -->
 13 |     <property name="searchTeacher">
 14 |         <![CDATA[{
 15 |             "query": {
 16 |                 "match": {
 17 |                    "_id": "2"
 18 |                 }
 19 |             }
 20 |         }]]>
 21 |     </property>
 22 | 
 23 |     <!--
 24 |         一个简单的检索dsl,中有四个变量
 25 |         applicationName1
 26 |         applicationName2
 27 |         startTime
 28 |         endTime
 29 |         通过map传递变量参数值
 30 | 
 31 |         变量语法参考文档：
 32 |     -->
 33 |     <property name="searchDatas">
 34 |         <![CDATA[{
 35 |             "query": {
 36 |                 "bool": {
 37 |                     "filter": [
 38 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
 39 |                             "terms": {
 40 |                                 "applicationName.keyword": [#[applicationName1],#[applicationName2]]
 41 |                             }
 42 |                         },
 43 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
 44 |                             "range": {
 45 |                                 "agentStarttime": {
 46 |                                     "gte": #[startTime],##统计开始时间
 47 |                                     "lt": #[endTime]  ##统计截止时间
 48 |                                 }
 49 |                             }
 50 |                         }
 51 |                     ]
 52 |                 }
 53 |             },
 54 |             ## 最多返回1000条记录
 55 |             "size":1000
 56 |         }]]>
 57 |     </property>
 58 | 
 59 | 
 60 |     <property name="searchWithCustomEscapeWithError">
 61 |         <![CDATA[{## 这是一个错误的案例，本条dsl会运行失败，变量中的特殊字符，日期类型都没有得到正确处理
 62 |             "query": {
 63 |                 "bool": {
 64 |                     "filter": [
 65 |                         {  ## 多值检索，查找多个应用名称对应的文档记录,参数applicationName1和applicationName2中都包含特殊字符
 66 |                            ## 通过escape属性禁用applicationName1变量的自动转义
 67 |                            ## $applicationName2 模式变量不会自动转移义，不会对日期自动进行格式化处理，这种模式的变量适用于逻辑判断/foreach循环变量/以及不带特殊字符的String/数字参数
 68 |                             "terms": {
 69 |                                 "applicationName.keyword": [#[applicationName1,escape=false],"$applicationName2"]
 70 |                             }
 71 |                         },
 72 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
 73 |                             "range": {
 74 |                                 "agentStarttime": {
 75 |                                     "gte": #[startTime],##统计开始时间，startTime为日期类型，#[startTime]自动对日期类型进行正确的格式化处理
 76 |                                     "lt": "$endTime"  ## 统计截止时间,endTime为日期类型参数，但是$endTime变量不会对日期进行格式化处理，会有日期格式问题,这里会报错
 77 |                                 }
 78 |                             }
 79 |                         }
 80 |                     ]
 81 |                 }
 82 |             },
 83 |             ## 最多返回1000条记录
 84 |             "size":1000
 85 |         }]]>
 86 |     </property>
 87 |     <property name="queryPid"><![CDATA[{
 88 |         "query": { "match": { "pid": #[pid] } }
 89 |      }]]>
 90 |     </property>
 91 |     <property name="searchWithCustomEscape">
 92 |         <![CDATA[{
 93 |             "query": {
 94 |                 "bool": {
 95 |                     "filter": [
 96 |                         {  ## 多值检索，查找多个应用名称对应的文档记录,自动转义，可以正常运行
 97 |                             "terms": {
 98 |                                 "applicationName.keyword": [#[applicationName1],#[applicationName2]]
 99 |                             }
100 |                         },
101 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
102 |                             "range": {
103 |                                 "agentStarttime": {
104 |                                     "gte": #[startTime],##统计开始时间
105 |                                     "lt": #[endTime]  ##统计截止时间
106 |                                 }
107 |                             }
108 |                         }
109 |                     ]
110 |                 }
111 |             },
112 |             ## 最多返回1000条记录
113 |             "size":1000
114 |         }]]>
115 |     </property>
116 | 
117 |     <!--
118 |        一个简单的检索dsl,中有四个变量
119 |        applicationName1
120 |        applicationName2
121 |        startTime
122 |        endTime
123 |        通过map传递变量参数值
124 | 
125 |        变量语法参考文档：
126 |    -->
127 |     <property name="searchPagineDatas">
128 |         <![CDATA[{
129 |             "query": {
130 |                 "bool": {
131 |                     "filter": [
132 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
133 |                             "terms": {
134 |                                 "applicationName.keyword": [#[applicationName1],#[applicationName2]]
135 |                             }
136 |                         },
137 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
138 |                             "range": {
139 |                                 "agentStarttime": {
140 |                                     "gte": #[startTime],##统计开始时间
141 |                                     "lt": #[endTime]  ##统计截止时间
142 |                                 }
143 |                             }
144 |                         }
145 |                     ]
146 |                 }
147 |             },
148 |             ## 分页起点
149 |             "from":#[from],
150 |             ## 最多返回size条记录
151 |             "size":#[size]
152 |         }]]>
153 |     </property>
154 | 
155 |     <!--
156 |         一个简单的检索dsl,中有四个变量
157 |         applicationName1
158 |         applicationName2
159 |         startTime
160 |         endTime
161 |         通过map传递变量参数值
162 | 
163 |         变量语法参考文档：
164 |     -->
165 |     <property name="searchDatasArray">
166 |         <![CDATA[{
167 |             "query": {
168 |                 "bool": {
169 |                     "filter": [
170 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
171 |                             "terms": {
172 |                                 "applicationName.keyword":#[applicationNames,serialJson=true]
173 |                             }
174 |                         },
175 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
176 |                             "range": {
177 |                                 "agentStarttime": {
178 |                                     "gte": #[startTime],##统计开始时间
179 |                                     "lt": #[endTime]  ##统计截止时间
180 |                                 }
181 |                             }
182 |                         }
183 |                     ]
184 |                 }
185 |             },
186 |             ## 最多返回1000条记录
187 |             "size":1000
188 |         }]]>
189 |     </property>
190 | 
191 |     <!--
192 |         一个SourceFilter的检索dsl,中有四个参数变量
193 |         applicationName1
194 |         applicationName2
195 |         startTime
196 |         endTime
197 |         通过map传递变量参数值
198 | 
199 |         {
200 |             "_source": {
201 |                 "includes": [ "agentStarttime", "applicationName" ],
202 |                 "excludes": [ "contentbody" ]
203 |             },
204 |             "query" : {
205 |                 "term" : { "user" : "kimchy" }
206 |             }
207 |         }
208 | 
209 |     -->
210 |     <property name="searchSourceFilter">
211 |         <![CDATA[{
212 |         #if($includes || $excludes) ## 只有指定了includes或者excludes才需要添加source filter
213 |             "_source": {
214 |                 #if($includes && $includes.size() > 0) ##设置includes filter
215 |                     "includes": [
216 |                         #foreach($include in $includes)
217 |                              #if($velocityCount > 0),#end "$include"
218 |                         #end
219 |                     ]
220 |                     #if($excludes && $excludes.size() > 0),#end ##如果还存在排斥字段，则需要加一个逗号
221 |                 #end
222 |                 #if($excludes && $excludes.size() > 0)  ##设置excludes filter
223 |                     "excludes": [
224 |                         #foreach($exclude in $excludes)
225 |                              #if($velocityCount > 0),#end "$exclude"
226 |                         #end
227 |                     ]
228 |                 #end
229 |             },
230 |         #end
231 |             "query": {
232 |                 "bool": {
233 |                     "filter": [
234 |                     #if($applicationNames && $applicationNames.size() > 0) ##只有传递了需要检索的应用名称集合，才需要添加下面的条件
235 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
236 |                             "terms": {
237 |                                 "applicationName.keyword":[
238 |                                     #foreach($applicationName in $applicationNames)
239 |                                          #if($velocityCount > 0),#end "$applicationName"
240 |                                     #end
241 |                                 ]
242 |                             }
243 |                         },
244 |                     #end
245 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
246 |                             "range": {
247 |                                 "agentStarttime": {
248 |                                     "gte": #[startTime],##统计开始时间
249 |                                     "lt": #[endTime]  ##统计截止时间
250 |                                 }
251 |                             }
252 |                         }
253 |                     ]
254 |                 }
255 |             },
256 |             ## 最多返回pageSize参数对应记录条数
257 |             "size":#[pageSize]
258 |         }]]>
259 |     </property>
260 | 
261 | 
262 |     <!--部分更新,注意：dsl不能换行-->
263 |     <property name="updatePartDocument">
264 |         <![CDATA[{"applicationName" : #[applicationName],"agentStarttime" : #[agentStarttime],"contentbody" : #[contentbody]}]]>
265 |     </property>
266 | 
267 |     <property name="demoTemplate">
268 |         <![CDATA[{
269 |             "index_patterns": "demo-*", ## 5.x版本中请使用语法："template": "demo-*"
270 |             "settings": {
271 |                 "number_of_shards": 30,
272 |                 "number_of_replicas" : 2,
273 |                 "index.refresh_interval": "5s"
274 |             },
275 |             "mappings": {
276 |                 "demo": {
277 |                     "properties": {
278 |                         "contentbody": {
279 |                             "type": "text",
280 |                             "fields": {
281 |                                 "keyword": {
282 |                                     "type": "keyword",
283 |                                     "ignore_above": 256
284 |                                 }
285 |                             }
286 |                         },
287 |                         "agentStarttime": {
288 |                             "type": "date",
289 |                             "format":"yyyy-MM-dd HH:mm:ss.SSS||yyyy-MM-dd'T'HH:mm:ss.SSS||yyyy-MM-dd HH:mm:ss||epoch_millis"
290 |                         },
291 |                         "applicationName": {
292 |                             "type": "text",
293 |                             "fields": {
294 |                                 "keyword": {
295 |                                     "type": "keyword",
296 |                                     "ignore_above": 256
297 |                                 }
298 |                             }
299 |                         }
300 |                     }
301 |                 }
302 |             }
303 |         }]]>
304 |     </property>
305 | 
306 |     <!--
307 |     修改demo 索引表的结构，增加email字段
308 |     https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-put-mapping.html
309 |     -->
310 |     <property name="updateDemoIndice">
311 |         <![CDATA[{
312 |           "properties": {
313 |             "email": {
314 |               "type": "keyword"
315 |             }
316 |           }
317 |         }]]>
318 |     </property>
319 | 
320 | 
321 |     <property name="scriptPianduan1">
322 |         <![CDATA[
323 |             "params": {
324 |               "last": #[last],
325 |               "nick": #[nick],
326 |               "goodsId": #[dynamicPriceTemplate->goodsId],
327 |               "rules":[
328 |                    #foreach($rule in $dynamicPriceTemplate.rules)
329 |                        #if($velocityCount > 0),#end
330 |                    {
331 |                         "ruleId": #[dynamicPriceTemplate->rules[$velocityCount]->ruleId],
332 |                         "ruleCount": #[dynamicPriceTemplate->rules[$velocityCount]->ruleCount],
333 |                         "ruleExist": #[dynamicPriceTemplate->rules[$velocityCount]->ruleExist]
334 |                     }
335 |                    #end
336 |               ]
337 |             }
338 |         ]]>
339 |     </property>
340 | 
341 |     <property name="scriptPianduan">
342 |         <![CDATA[
343 |             "params": {
344 |               "last": #[last],
345 |               "nick": #[nick],
346 |               "goodsId": #[dynamicPriceTemplate->goodsId],
347 |               "rules":[
348 |                    #foreach($rule in $dynamicPriceTemplate.rules)
349 |                        #if($velocityCount > 0),#end
350 |                    {
351 | 
352 |                         "ruleId": "$rule.ruleId",
353 |                         "ruleCount": $rule.ruleCount,
354 |                         "ruleExist":  $rule.ruleExist
355 | 
356 |                     }
357 |                    #end
358 |               ]
359 |             }
360 |         ]]>
361 |     </property>
362 |     <property name="scriptDsl">
363 |         <![CDATA[{
364 |           "script": {
365 |             "lang": "painless",
366 |             "source": @"""
367 |               ctx._source.last = params.last;
368 |               ctx._source.nick = params.nick;
369 |               ctx._source.rules = params.rules
370 |             """,
371 |             @{scriptPianduan}
372 |           }
373 |         }]]>
374 |     </property>
375 | 
376 |     <property name="scriptPianduan2">
377 |         <![CDATA[
378 |             "params": {
379 |               "last": #[last],
380 |               "nick": #[nick],
381 |               "goodsId": #[dynamicPriceTemplate->goodsId],
382 |               "rules":[
383 |                    #foreach($rule in $dynamicPriceTemplate.rules)
384 |                        #[dynamicPriceTemplate->rules[$velocityCount],serialJson=true] ## 通过属性serialJson指示框架直接将对象序列化为json数据
385 |                         #if($velocityCount != ($dynamicPriceTemplate.rules.size() - 1)),#end
386 |                    #end
387 |               ]
388 |             }
389 |         ]]>
390 |     </property>
391 |     <property name="scriptDslByQuery">
392 |         <![CDATA[{
393 |           "query": {
394 |             "bool": {
395 |               "must": [
396 |                 {
397 |                   "term": {
398 |                     "_id": #[id]
399 |                   }
400 |                 }
401 |               ]
402 |             }
403 |           },
404 |           "script": {
405 |             "lang": "painless",
406 |             "source": @"""
407 |               ctx._source.last = params.last;
408 |               ctx._source.lastSpecial = "#[last,quoted=false]";
409 |               ctx._source.nick = params.nick;
410 |               ctx._source.goodName = #[dynamicPriceTemplate->goodName,escapeCount=2];#*在脚本中，含有特殊字符的goodName需要转义2次*#
411 |               ctx._source.goodsId = #[dynamicPriceTemplate->goodsId];
412 |               ctx._source.dynamicPriceTemplate.goodsId = params.goodsId;
413 |               ctx._source.rules = params.rules
414 |             """,
415 |             @{scriptPianduan2}
416 |           }
417 |         }]]>
418 |     </property>
419 | 
420 |     <property name="mapbianli"><![CDATA[
421 |         ## map遍历实例，通过$item.value直接输出值，如果值中存在的特殊字符，不会对特殊字符进行转义处理，请自行处理
422 |         #foreach($item in $softTypeMap.entrySet())
423 |             #if($velocityCount > 0),#end
424 |             { "match": { "$item.key": "$item.value" } }
425 |         #end
426 |     ]]>
427 |     </property>
428 | 
429 | 
430 |     <property name="mapbianliescape"><![CDATA[
431 |         ## map<String,List<String>>遍历实例，可以通过#[]绑定变量对值中存在的特殊字符进行转义处理
432 |         #foreach($item in $softTypeMap.entrySet())
433 |             #if($item.value)
434 |                 #if($velocityCount > 0),#end
435 |                 { "match": { "$item.key": #[softTypeMap[$item.key],serialJson=true] } }
436 |             #end
437 |         #end
438 |     ]]>
439 |     </property>
440 | 
441 |     <property name="queryArray">
442 |         <![CDATA[
443 |         {
444 |             "size":10000,
445 |             "query": {
446 |                 "bool": {
447 |                     "must": [
448 |                             #foreach($item in $softTypeMap.entrySet())
449 |                                 #if($velocityCount > 0),#end
450 |                                 { "match":
451 |                                     {
452 |                                     #if($item.value)
453 |                                     "$item.key":
454 |                                     [
455 |                                         #foreach($applicationName in $item.value)
456 |                                              #if($velocityCount > 0),#end #[softTypeMap[$item.key][$velocityCount]]
457 |                                         #end
458 |                                     ]
459 |                                     #end
460 |                                     }
461 |                                  }
462 |                             #end
463 |                     ]
464 |                  }
465 |             }
466 |         }
467 |         ]]>
468 |     </property>
469 | 
470 |     <property name="queryArray1">
471 |         <![CDATA[
472 |         #if($mustShouldMap)
473 |                         #foreach($item in $mustShouldMap.entrySet())
474 |                             ,
475 |                             "must":{
476 |                                 "bool":{
477 |                                     "should":[
478 |                                         #foreach($children in $item)
479 |                                             #if($velocityCount > 0),#end
480 |                                             { "match": { "$item.key": #[$mustShouldMap[$item.key][$velocityCount]] } }
481 |                                         #end
482 |                                     ]
483 |                                 }
484 |                             }
485 |                         #end
486 |                     #end
487 |         ]]>
488 |     </property>
489 | </properties>


--------------------------------------------------------------------------------
/springboot/src/test/java/com/mn/springboot/SpringbootApplicationTests.java:
--------------------------------------------------------------------------------
 1 | package com.mn.springboot;
 2 | 
 3 | import org.junit.Test;
 4 | import org.junit.runner.RunWith;
 5 | import org.springframework.boot.test.context.SpringBootTest;
 6 | import org.springframework.test.context.junit4.SpringRunner;
 7 | 
 8 | @RunWith(SpringRunner.class)
 9 | @SpringBootTest
10 | public class SpringbootApplicationTests {
11 | 
12 | 	@Test
13 | 	public void contextLoads() {
14 | 	}
15 | 
16 | }
17 | 


--------------------------------------------------------------------------------
/springboot/target/classes/application.yml:
--------------------------------------------------------------------------------
 1 | server:
 2 |   port: 8888
 3 | spring:
 4 |   elasticsearch:
 5 |     bboss:
 6 |       elasticUser:
 7 |       elasticPassword:
 8 |       elasticsearch:
 9 |         rest:
10 |           hostNames: 127.0.0.1:9200
11 |         dateFormat: yyyy-MM-dd hh:mm:ss
12 |         timeZone: Asia/Shanghai
13 |         ttl: 2d
14 |         showTemplate: true
15 |         discoverHost: false
16 |       dslfile:
17 |         refreshInterval: -1
18 |       http:
19 |          timeoutConnection: 400000
20 |          timeoutSocket: 400000
21 |          connectionRequestTimeout: 400000
22 |          retryTime: 1
23 |          maxLineLength: -1
24 |          maxHeaderCount: 200
25 |          maxTotal: 400
26 |          defaultMaxPerRoute: 200
27 |          soReuseAddress: false
28 |          soKeepAlive: false
29 |          timeToLive: 3600000
30 |          keepAlive: 3600000
31 |          keystore:
32 |          keyPassword:
33 |          hostnameVerifier:
34 | es:
35 |   basePath: esmapper/
36 |   indexs: teacher,student
37 | management:
38 |     port: 54001
39 |   endpoints:
40 |     web:
41 |       exposure:
42 |         include: /*
43 | 


--------------------------------------------------------------------------------
/springboot/target/classes/com/mn/springboot/SpringbootApplication.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/IsFive/springboot-bboss-elasticsearch/8f8bcf1cb57ed9a6b4b77e620b0694cac4e324d6/springboot/target/classes/com/mn/springboot/SpringbootApplication.class


--------------------------------------------------------------------------------
/springboot/target/classes/com/mn/springboot/controller/TeacherController.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/IsFive/springboot-bboss-elasticsearch/8f8bcf1cb57ed9a6b4b77e620b0694cac4e324d6/springboot/target/classes/com/mn/springboot/controller/TeacherController.class


--------------------------------------------------------------------------------
/springboot/target/classes/com/mn/springboot/pojo/Student.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/IsFive/springboot-bboss-elasticsearch/8f8bcf1cb57ed9a6b4b77e620b0694cac4e324d6/springboot/target/classes/com/mn/springboot/pojo/Student.class


--------------------------------------------------------------------------------
/springboot/target/classes/com/mn/springboot/pojo/Teacher.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/IsFive/springboot-bboss-elasticsearch/8f8bcf1cb57ed9a6b4b77e620b0694cac4e324d6/springboot/target/classes/com/mn/springboot/pojo/Teacher.class


--------------------------------------------------------------------------------
/springboot/target/classes/com/mn/springboot/utils/GenericsUtils.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/IsFive/springboot-bboss-elasticsearch/8f8bcf1cb57ed9a6b4b77e620b0694cac4e324d6/springboot/target/classes/com/mn/springboot/utils/GenericsUtils.class


--------------------------------------------------------------------------------
/springboot/target/classes/com/mn/springboot/utils/es/ESClient.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/IsFive/springboot-bboss-elasticsearch/8f8bcf1cb57ed9a6b4b77e620b0694cac4e324d6/springboot/target/classes/com/mn/springboot/utils/es/ESClient.class


--------------------------------------------------------------------------------
/springboot/target/classes/com/mn/springboot/utils/es/ESUtil.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/IsFive/springboot-bboss-elasticsearch/8f8bcf1cb57ed9a6b4b77e620b0694cac4e324d6/springboot/target/classes/com/mn/springboot/utils/es/ESUtil.class


--------------------------------------------------------------------------------
/springboot/target/classes/esmapper/student.xml:
--------------------------------------------------------------------------------
  1 | <properties>
  2 | 
  3 | 
  4 |     <!--
  5 |         一个简单的检索dsl,中有四个变量
  6 |         name 全文检索字段
  7 |         startTime
  8 |         endTime
  9 |         通过map传递变量参数值
 10 | 
 11 |         变量语法参考文档：https://my.oschina.net/bboss/blog/1556866
 12 |     -->
 13 |     <property name="searchStudent">
 14 |         <![CDATA[{
 15 |             "query": {
 16 |                 "match": {
 17 |                    "_id": "2"
 18 |                 }
 19 |             }
 20 |         }]]>
 21 |     </property>
 22 | 
 23 |     <!--
 24 |         一个简单的检索dsl,中有四个变量
 25 |         applicationName1
 26 |         applicationName2
 27 |         startTime
 28 |         endTime
 29 |         通过map传递变量参数值
 30 | 
 31 |         变量语法参考文档：
 32 |     -->
 33 |     <property name="searchDatas">
 34 |         <![CDATA[{
 35 |             "query": {
 36 |                 "bool": {
 37 |                     "filter": [
 38 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
 39 |                             "terms": {
 40 |                                 "applicationName.keyword": [#[applicationName1],#[applicationName2]]
 41 |                             }
 42 |                         },
 43 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
 44 |                             "range": {
 45 |                                 "agentStarttime": {
 46 |                                     "gte": #[startTime],##统计开始时间
 47 |                                     "lt": #[endTime]  ##统计截止时间
 48 |                                 }
 49 |                             }
 50 |                         }
 51 |                     ]
 52 |                 }
 53 |             },
 54 |             ## 最多返回1000条记录
 55 |             "size":1000
 56 |         }]]>
 57 |     </property>
 58 | 
 59 | 
 60 |     <property name="searchWithCustomEscapeWithError">
 61 |         <![CDATA[{## 这是一个错误的案例，本条dsl会运行失败，变量中的特殊字符，日期类型都没有得到正确处理
 62 |             "query": {
 63 |                 "bool": {
 64 |                     "filter": [
 65 |                         {  ## 多值检索，查找多个应用名称对应的文档记录,参数applicationName1和applicationName2中都包含特殊字符
 66 |                            ## 通过escape属性禁用applicationName1变量的自动转义
 67 |                            ## $applicationName2 模式变量不会自动转移义，不会对日期自动进行格式化处理，这种模式的变量适用于逻辑判断/foreach循环变量/以及不带特殊字符的String/数字参数
 68 |                             "terms": {
 69 |                                 "applicationName.keyword": [#[applicationName1,escape=false],"$applicationName2"]
 70 |                             }
 71 |                         },
 72 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
 73 |                             "range": {
 74 |                                 "agentStarttime": {
 75 |                                     "gte": #[startTime],##统计开始时间，startTime为日期类型，#[startTime]自动对日期类型进行正确的格式化处理
 76 |                                     "lt": "$endTime"  ## 统计截止时间,endTime为日期类型参数，但是$endTime变量不会对日期进行格式化处理，会有日期格式问题,这里会报错
 77 |                                 }
 78 |                             }
 79 |                         }
 80 |                     ]
 81 |                 }
 82 |             },
 83 |             ## 最多返回1000条记录
 84 |             "size":1000
 85 |         }]]>
 86 |     </property>
 87 |     <property name="queryPid"><![CDATA[{
 88 |         "query": { "match": { "pid": #[pid] } }
 89 |      }]]>
 90 |     </property>
 91 |     <property name="searchWithCustomEscape">
 92 |         <![CDATA[{
 93 |             "query": {
 94 |                 "bool": {
 95 |                     "filter": [
 96 |                         {  ## 多值检索，查找多个应用名称对应的文档记录,自动转义，可以正常运行
 97 |                             "terms": {
 98 |                                 "applicationName.keyword": [#[applicationName1],#[applicationName2]]
 99 |                             }
100 |                         },
101 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
102 |                             "range": {
103 |                                 "agentStarttime": {
104 |                                     "gte": #[startTime],##统计开始时间
105 |                                     "lt": #[endTime]  ##统计截止时间
106 |                                 }
107 |                             }
108 |                         }
109 |                     ]
110 |                 }
111 |             },
112 |             ## 最多返回1000条记录
113 |             "size":1000
114 |         }]]>
115 |     </property>
116 | 
117 |     <!--
118 |        一个简单的检索dsl,中有四个变量
119 |        applicationName1
120 |        applicationName2
121 |        startTime
122 |        endTime
123 |        通过map传递变量参数值
124 | 
125 |        变量语法参考文档：
126 |    -->
127 |     <property name="searchPagineDatas">
128 |         <![CDATA[{
129 |             "query": {
130 |                 "bool": {
131 |                     "filter": [
132 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
133 |                             "terms": {
134 |                                 "applicationName.keyword": [#[applicationName1],#[applicationName2]]
135 |                             }
136 |                         },
137 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
138 |                             "range": {
139 |                                 "agentStarttime": {
140 |                                     "gte": #[startTime],##统计开始时间
141 |                                     "lt": #[endTime]  ##统计截止时间
142 |                                 }
143 |                             }
144 |                         }
145 |                     ]
146 |                 }
147 |             },
148 |             ## 分页起点
149 |             "from":#[from],
150 |             ## 最多返回size条记录
151 |             "size":#[size]
152 |         }]]>
153 |     </property>
154 | 
155 |     <!--
156 |         一个简单的检索dsl,中有四个变量
157 |         applicationName1
158 |         applicationName2
159 |         startTime
160 |         endTime
161 |         通过map传递变量参数值
162 | 
163 |         变量语法参考文档：
164 |     -->
165 |     <property name="searchDatasArray">
166 |         <![CDATA[{
167 |             "query": {
168 |                 "bool": {
169 |                     "filter": [
170 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
171 |                             "terms": {
172 |                                 "applicationName.keyword":#[applicationNames,serialJson=true]
173 |                             }
174 |                         },
175 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
176 |                             "range": {
177 |                                 "agentStarttime": {
178 |                                     "gte": #[startTime],##统计开始时间
179 |                                     "lt": #[endTime]  ##统计截止时间
180 |                                 }
181 |                             }
182 |                         }
183 |                     ]
184 |                 }
185 |             },
186 |             ## 最多返回1000条记录
187 |             "size":1000
188 |         }]]>
189 |     </property>
190 | 
191 |     <!--
192 |         一个SourceFilter的检索dsl,中有四个参数变量
193 |         applicationName1
194 |         applicationName2
195 |         startTime
196 |         endTime
197 |         通过map传递变量参数值
198 | 
199 |         {
200 |             "_source": {
201 |                 "includes": [ "agentStarttime", "applicationName" ],
202 |                 "excludes": [ "contentbody" ]
203 |             },
204 |             "query" : {
205 |                 "term" : { "user" : "kimchy" }
206 |             }
207 |         }
208 | 
209 |     -->
210 |     <property name="searchSourceFilter">
211 |         <![CDATA[{
212 |         #if($includes || $excludes) ## 只有指定了includes或者excludes才需要添加source filter
213 |             "_source": {
214 |                 #if($includes && $includes.size() > 0) ##设置includes filter
215 |                     "includes": [
216 |                         #foreach($include in $includes)
217 |                              #if($velocityCount > 0),#end "$include"
218 |                         #end
219 |                     ]
220 |                     #if($excludes && $excludes.size() > 0),#end ##如果还存在排斥字段，则需要加一个逗号
221 |                 #end
222 |                 #if($excludes && $excludes.size() > 0)  ##设置excludes filter
223 |                     "excludes": [
224 |                         #foreach($exclude in $excludes)
225 |                              #if($velocityCount > 0),#end "$exclude"
226 |                         #end
227 |                     ]
228 |                 #end
229 |             },
230 |         #end
231 |             "query": {
232 |                 "bool": {
233 |                     "filter": [
234 |                     #if($applicationNames && $applicationNames.size() > 0) ##只有传递了需要检索的应用名称集合，才需要添加下面的条件
235 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
236 |                             "terms": {
237 |                                 "applicationName.keyword":[
238 |                                     #foreach($applicationName in $applicationNames)
239 |                                          #if($velocityCount > 0),#end "$applicationName"
240 |                                     #end
241 |                                 ]
242 |                             }
243 |                         },
244 |                     #end
245 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
246 |                             "range": {
247 |                                 "agentStarttime": {
248 |                                     "gte": #[startTime],##统计开始时间
249 |                                     "lt": #[endTime]  ##统计截止时间
250 |                                 }
251 |                             }
252 |                         }
253 |                     ]
254 |                 }
255 |             },
256 |             ## 最多返回pageSize参数对应记录条数
257 |             "size":#[pageSize]
258 |         }]]>
259 |     </property>
260 | 
261 | 
262 |     <!--部分更新,注意：dsl不能换行-->
263 |     <property name="updatePartDocument">
264 |         <![CDATA[{"applicationName" : #[applicationName],"agentStarttime" : #[agentStarttime],"contentbody" : #[contentbody]}]]>
265 |     </property>
266 | 
267 |     <property name="demoTemplate">
268 |         <![CDATA[{
269 |             "index_patterns": "demo-*", ## 5.x版本中请使用语法："template": "demo-*"
270 |             "settings": {
271 |                 "number_of_shards": 30,
272 |                 "number_of_replicas" : 2,
273 |                 "index.refresh_interval": "5s"
274 |             },
275 |             "mappings": {
276 |                 "demo": {
277 |                     "properties": {
278 |                         "contentbody": {
279 |                             "type": "text",
280 |                             "fields": {
281 |                                 "keyword": {
282 |                                     "type": "keyword",
283 |                                     "ignore_above": 256
284 |                                 }
285 |                             }
286 |                         },
287 |                         "agentStarttime": {
288 |                             "type": "date",
289 |                             "format":"yyyy-MM-dd HH:mm:ss.SSS||yyyy-MM-dd'T'HH:mm:ss.SSS||yyyy-MM-dd HH:mm:ss||epoch_millis"
290 |                         },
291 |                         "applicationName": {
292 |                             "type": "text",
293 |                             "fields": {
294 |                                 "keyword": {
295 |                                     "type": "keyword",
296 |                                     "ignore_above": 256
297 |                                 }
298 |                             }
299 |                         }
300 |                     }
301 |                 }
302 |             }
303 |         }]]>
304 |     </property>
305 | 
306 |     <!--
307 |     修改demo 索引表的结构，增加email字段
308 |     https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-put-mapping.html
309 |     -->
310 |     <property name="updateDemoIndice">
311 |         <![CDATA[{
312 |           "properties": {
313 |             "email": {
314 |               "type": "keyword"
315 |             }
316 |           }
317 |         }]]>
318 |     </property>
319 | 
320 | 
321 |     <property name="scriptPianduan1">
322 |         <![CDATA[
323 |             "params": {
324 |               "last": #[last],
325 |               "nick": #[nick],
326 |               "goodsId": #[dynamicPriceTemplate->goodsId],
327 |               "rules":[
328 |                    #foreach($rule in $dynamicPriceTemplate.rules)
329 |                        #if($velocityCount > 0),#end
330 |                    {
331 |                         "ruleId": #[dynamicPriceTemplate->rules[$velocityCount]->ruleId],
332 |                         "ruleCount": #[dynamicPriceTemplate->rules[$velocityCount]->ruleCount],
333 |                         "ruleExist": #[dynamicPriceTemplate->rules[$velocityCount]->ruleExist]
334 |                     }
335 |                    #end
336 |               ]
337 |             }
338 |         ]]>
339 |     </property>
340 | 
341 |     <property name="scriptPianduan">
342 |         <![CDATA[
343 |             "params": {
344 |               "last": #[last],
345 |               "nick": #[nick],
346 |               "goodsId": #[dynamicPriceTemplate->goodsId],
347 |               "rules":[
348 |                    #foreach($rule in $dynamicPriceTemplate.rules)
349 |                        #if($velocityCount > 0),#end
350 |                    {
351 | 
352 |                         "ruleId": "$rule.ruleId",
353 |                         "ruleCount": $rule.ruleCount,
354 |                         "ruleExist":  $rule.ruleExist
355 | 
356 |                     }
357 |                    #end
358 |               ]
359 |             }
360 |         ]]>
361 |     </property>
362 |     <property name="scriptDsl">
363 |         <![CDATA[{
364 |           "script": {
365 |             "lang": "painless",
366 |             "source": @"""
367 |               ctx._source.last = params.last;
368 |               ctx._source.nick = params.nick;
369 |               ctx._source.rules = params.rules
370 |             """,
371 |             @{scriptPianduan}
372 |           }
373 |         }]]>
374 |     </property>
375 | 
376 |     <property name="scriptPianduan2">
377 |         <![CDATA[
378 |             "params": {
379 |               "last": #[last],
380 |               "nick": #[nick],
381 |               "goodsId": #[dynamicPriceTemplate->goodsId],
382 |               "rules":[
383 |                    #foreach($rule in $dynamicPriceTemplate.rules)
384 |                        #[dynamicPriceTemplate->rules[$velocityCount],serialJson=true] ## 通过属性serialJson指示框架直接将对象序列化为json数据
385 |                         #if($velocityCount != ($dynamicPriceTemplate.rules.size() - 1)),#end
386 |                    #end
387 |               ]
388 |             }
389 |         ]]>
390 |     </property>
391 |     <property name="scriptDslByQuery">
392 |         <![CDATA[{
393 |           "query": {
394 |             "bool": {
395 |               "must": [
396 |                 {
397 |                   "term": {
398 |                     "_id": #[id]
399 |                   }
400 |                 }
401 |               ]
402 |             }
403 |           },
404 |           "script": {
405 |             "lang": "painless",
406 |             "source": @"""
407 |               ctx._source.last = params.last;
408 |               ctx._source.lastSpecial = "#[last,quoted=false]";
409 |               ctx._source.nick = params.nick;
410 |               ctx._source.goodName = #[dynamicPriceTemplate->goodName,escapeCount=2];#*在脚本中，含有特殊字符的goodName需要转义2次*#
411 |               ctx._source.goodsId = #[dynamicPriceTemplate->goodsId];
412 |               ctx._source.dynamicPriceTemplate.goodsId = params.goodsId;
413 |               ctx._source.rules = params.rules
414 |             """,
415 |             @{scriptPianduan2}
416 |           }
417 |         }]]>
418 |     </property>
419 | 
420 |     <property name="mapbianli"><![CDATA[
421 |         ## map遍历实例，通过$item.value直接输出值，如果值中存在的特殊字符，不会对特殊字符进行转义处理，请自行处理
422 |         #foreach($item in $softTypeMap.entrySet())
423 |             #if($velocityCount > 0),#end
424 |             { "match": { "$item.key": "$item.value" } }
425 |         #end
426 |     ]]>
427 |     </property>
428 | 
429 | 
430 |     <property name="mapbianliescape"><![CDATA[
431 |         ## map<String,List<String>>遍历实例，可以通过#[]绑定变量对值中存在的特殊字符进行转义处理
432 |         #foreach($item in $softTypeMap.entrySet())
433 |             #if($item.value)
434 |                 #if($velocityCount > 0),#end
435 |                 { "match": { "$item.key": #[softTypeMap[$item.key],serialJson=true] } }
436 |             #end
437 |         #end
438 |     ]]>
439 |     </property>
440 | 
441 |     <property name="queryArray">
442 |         <![CDATA[
443 |         {
444 |             "size":10000,
445 |             "query": {
446 |                 "bool": {
447 |                     "must": [
448 |                             #foreach($item in $softTypeMap.entrySet())
449 |                                 #if($velocityCount > 0),#end
450 |                                 { "match":
451 |                                     {
452 |                                     #if($item.value)
453 |                                     "$item.key":
454 |                                     [
455 |                                         #foreach($applicationName in $item.value)
456 |                                              #if($velocityCount > 0),#end #[softTypeMap[$item.key][$velocityCount]]
457 |                                         #end
458 |                                     ]
459 |                                     #end
460 |                                     }
461 |                                  }
462 |                             #end
463 |                     ]
464 |                  }
465 |             }
466 |         }
467 |         ]]>
468 |     </property>
469 | 
470 |     <property name="queryArray1">
471 |         <![CDATA[
472 |         #if($mustShouldMap)
473 |                         #foreach($item in $mustShouldMap.entrySet())
474 |                             ,
475 |                             "must":{
476 |                                 "bool":{
477 |                                     "should":[
478 |                                         #foreach($children in $item)
479 |                                             #if($velocityCount > 0),#end
480 |                                             { "match": { "$item.key": #[$mustShouldMap[$item.key][$velocityCount]] } }
481 |                                         #end
482 |                                     ]
483 |                                 }
484 |                             }
485 |                         #end
486 |                     #end
487 |         ]]>
488 |     </property>
489 | </properties>


--------------------------------------------------------------------------------
/springboot/target/classes/esmapper/teacher.xml:
--------------------------------------------------------------------------------
  1 | <properties>
  2 | 
  3 | 
  4 |     <!--
  5 |         一个简单的检索dsl,中有四个变量
  6 |         name 全文检索字段
  7 |         startTime
  8 |         endTime
  9 |         通过map传递变量参数值
 10 | 
 11 |         变量语法参考文档：https://my.oschina.net/bboss/blog/1556866
 12 |     -->
 13 |     <property name="searchTeacher">
 14 |         <![CDATA[{
 15 |             "query": {
 16 |                 "match": {
 17 |                    "_id": "2"
 18 |                 }
 19 |             }
 20 |         }]]>
 21 |     </property>
 22 | 
 23 |     <!--
 24 |         一个简单的检索dsl,中有四个变量
 25 |         applicationName1
 26 |         applicationName2
 27 |         startTime
 28 |         endTime
 29 |         通过map传递变量参数值
 30 | 
 31 |         变量语法参考文档：
 32 |     -->
 33 |     <property name="searchDatas">
 34 |         <![CDATA[{
 35 |             "query": {
 36 |                 "bool": {
 37 |                     "filter": [
 38 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
 39 |                             "terms": {
 40 |                                 "applicationName.keyword": [#[applicationName1],#[applicationName2]]
 41 |                             }
 42 |                         },
 43 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
 44 |                             "range": {
 45 |                                 "agentStarttime": {
 46 |                                     "gte": #[startTime],##统计开始时间
 47 |                                     "lt": #[endTime]  ##统计截止时间
 48 |                                 }
 49 |                             }
 50 |                         }
 51 |                     ]
 52 |                 }
 53 |             },
 54 |             ## 最多返回1000条记录
 55 |             "size":1000
 56 |         }]]>
 57 |     </property>
 58 | 
 59 | 
 60 |     <property name="searchWithCustomEscapeWithError">
 61 |         <![CDATA[{## 这是一个错误的案例，本条dsl会运行失败，变量中的特殊字符，日期类型都没有得到正确处理
 62 |             "query": {
 63 |                 "bool": {
 64 |                     "filter": [
 65 |                         {  ## 多值检索，查找多个应用名称对应的文档记录,参数applicationName1和applicationName2中都包含特殊字符
 66 |                            ## 通过escape属性禁用applicationName1变量的自动转义
 67 |                            ## $applicationName2 模式变量不会自动转移义，不会对日期自动进行格式化处理，这种模式的变量适用于逻辑判断/foreach循环变量/以及不带特殊字符的String/数字参数
 68 |                             "terms": {
 69 |                                 "applicationName.keyword": [#[applicationName1,escape=false],"$applicationName2"]
 70 |                             }
 71 |                         },
 72 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
 73 |                             "range": {
 74 |                                 "agentStarttime": {
 75 |                                     "gte": #[startTime],##统计开始时间，startTime为日期类型，#[startTime]自动对日期类型进行正确的格式化处理
 76 |                                     "lt": "$endTime"  ## 统计截止时间,endTime为日期类型参数，但是$endTime变量不会对日期进行格式化处理，会有日期格式问题,这里会报错
 77 |                                 }
 78 |                             }
 79 |                         }
 80 |                     ]
 81 |                 }
 82 |             },
 83 |             ## 最多返回1000条记录
 84 |             "size":1000
 85 |         }]]>
 86 |     </property>
 87 |     <property name="queryPid"><![CDATA[{
 88 |         "query": { "match": { "pid": #[pid] } }
 89 |      }]]>
 90 |     </property>
 91 |     <property name="searchWithCustomEscape">
 92 |         <![CDATA[{
 93 |             "query": {
 94 |                 "bool": {
 95 |                     "filter": [
 96 |                         {  ## 多值检索，查找多个应用名称对应的文档记录,自动转义，可以正常运行
 97 |                             "terms": {
 98 |                                 "applicationName.keyword": [#[applicationName1],#[applicationName2]]
 99 |                             }
100 |                         },
101 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
102 |                             "range": {
103 |                                 "agentStarttime": {
104 |                                     "gte": #[startTime],##统计开始时间
105 |                                     "lt": #[endTime]  ##统计截止时间
106 |                                 }
107 |                             }
108 |                         }
109 |                     ]
110 |                 }
111 |             },
112 |             ## 最多返回1000条记录
113 |             "size":1000
114 |         }]]>
115 |     </property>
116 | 
117 |     <!--
118 |        一个简单的检索dsl,中有四个变量
119 |        applicationName1
120 |        applicationName2
121 |        startTime
122 |        endTime
123 |        通过map传递变量参数值
124 | 
125 |        变量语法参考文档：
126 |    -->
127 |     <property name="searchPagineDatas">
128 |         <![CDATA[{
129 |             "query": {
130 |                 "bool": {
131 |                     "filter": [
132 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
133 |                             "terms": {
134 |                                 "applicationName.keyword": [#[applicationName1],#[applicationName2]]
135 |                             }
136 |                         },
137 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
138 |                             "range": {
139 |                                 "agentStarttime": {
140 |                                     "gte": #[startTime],##统计开始时间
141 |                                     "lt": #[endTime]  ##统计截止时间
142 |                                 }
143 |                             }
144 |                         }
145 |                     ]
146 |                 }
147 |             },
148 |             ## 分页起点
149 |             "from":#[from],
150 |             ## 最多返回size条记录
151 |             "size":#[size]
152 |         }]]>
153 |     </property>
154 | 
155 |     <!--
156 |         一个简单的检索dsl,中有四个变量
157 |         applicationName1
158 |         applicationName2
159 |         startTime
160 |         endTime
161 |         通过map传递变量参数值
162 | 
163 |         变量语法参考文档：
164 |     -->
165 |     <property name="searchDatasArray">
166 |         <![CDATA[{
167 |             "query": {
168 |                 "bool": {
169 |                     "filter": [
170 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
171 |                             "terms": {
172 |                                 "applicationName.keyword":#[applicationNames,serialJson=true]
173 |                             }
174 |                         },
175 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
176 |                             "range": {
177 |                                 "agentStarttime": {
178 |                                     "gte": #[startTime],##统计开始时间
179 |                                     "lt": #[endTime]  ##统计截止时间
180 |                                 }
181 |                             }
182 |                         }
183 |                     ]
184 |                 }
185 |             },
186 |             ## 最多返回1000条记录
187 |             "size":1000
188 |         }]]>
189 |     </property>
190 | 
191 |     <!--
192 |         一个SourceFilter的检索dsl,中有四个参数变量
193 |         applicationName1
194 |         applicationName2
195 |         startTime
196 |         endTime
197 |         通过map传递变量参数值
198 | 
199 |         {
200 |             "_source": {
201 |                 "includes": [ "agentStarttime", "applicationName" ],
202 |                 "excludes": [ "contentbody" ]
203 |             },
204 |             "query" : {
205 |                 "term" : { "user" : "kimchy" }
206 |             }
207 |         }
208 | 
209 |     -->
210 |     <property name="searchSourceFilter">
211 |         <![CDATA[{
212 |         #if($includes || $excludes) ## 只有指定了includes或者excludes才需要添加source filter
213 |             "_source": {
214 |                 #if($includes && $includes.size() > 0) ##设置includes filter
215 |                     "includes": [
216 |                         #foreach($include in $includes)
217 |                              #if($velocityCount > 0),#end "$include"
218 |                         #end
219 |                     ]
220 |                     #if($excludes && $excludes.size() > 0),#end ##如果还存在排斥字段，则需要加一个逗号
221 |                 #end
222 |                 #if($excludes && $excludes.size() > 0)  ##设置excludes filter
223 |                     "excludes": [
224 |                         #foreach($exclude in $excludes)
225 |                              #if($velocityCount > 0),#end "$exclude"
226 |                         #end
227 |                     ]
228 |                 #end
229 |             },
230 |         #end
231 |             "query": {
232 |                 "bool": {
233 |                     "filter": [
234 |                     #if($applicationNames && $applicationNames.size() > 0) ##只有传递了需要检索的应用名称集合，才需要添加下面的条件
235 |                         {  ## 多值检索，查找多个应用名称对应的文档记录
236 |                             "terms": {
237 |                                 "applicationName.keyword":[
238 |                                     #foreach($applicationName in $applicationNames)
239 |                                          #if($velocityCount > 0),#end "$applicationName"
240 |                                     #end
241 |                                 ]
242 |                             }
243 |                         },
244 |                     #end
245 |                         {   ## 时间范围检索，返回对应时间范围内的记录，接受long型的值
246 |                             "range": {
247 |                                 "agentStarttime": {
248 |                                     "gte": #[startTime],##统计开始时间
249 |                                     "lt": #[endTime]  ##统计截止时间
250 |                                 }
251 |                             }
252 |                         }
253 |                     ]
254 |                 }
255 |             },
256 |             ## 最多返回pageSize参数对应记录条数
257 |             "size":#[pageSize]
258 |         }]]>
259 |     </property>
260 | 
261 | 
262 |     <!--部分更新,注意：dsl不能换行-->
263 |     <property name="updatePartDocument">
264 |         <![CDATA[{"applicationName" : #[applicationName],"agentStarttime" : #[agentStarttime],"contentbody" : #[contentbody]}]]>
265 |     </property>
266 | 
267 |     <property name="demoTemplate">
268 |         <![CDATA[{
269 |             "index_patterns": "demo-*", ## 5.x版本中请使用语法："template": "demo-*"
270 |             "settings": {
271 |                 "number_of_shards": 30,
272 |                 "number_of_replicas" : 2,
273 |                 "index.refresh_interval": "5s"
274 |             },
275 |             "mappings": {
276 |                 "demo": {
277 |                     "properties": {
278 |                         "contentbody": {
279 |                             "type": "text",
280 |                             "fields": {
281 |                                 "keyword": {
282 |                                     "type": "keyword",
283 |                                     "ignore_above": 256
284 |                                 }
285 |                             }
286 |                         },
287 |                         "agentStarttime": {
288 |                             "type": "date",
289 |                             "format":"yyyy-MM-dd HH:mm:ss.SSS||yyyy-MM-dd'T'HH:mm:ss.SSS||yyyy-MM-dd HH:mm:ss||epoch_millis"
290 |                         },
291 |                         "applicationName": {
292 |                             "type": "text",
293 |                             "fields": {
294 |                                 "keyword": {
295 |                                     "type": "keyword",
296 |                                     "ignore_above": 256
297 |                                 }
298 |                             }
299 |                         }
300 |                     }
301 |                 }
302 |             }
303 |         }]]>
304 |     </property>
305 | 
306 |     <!--
307 |     修改demo 索引表的结构，增加email字段
308 |     https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-put-mapping.html
309 |     -->
310 |     <property name="updateDemoIndice">
311 |         <![CDATA[{
312 |           "properties": {
313 |             "email": {
314 |               "type": "keyword"
315 |             }
316 |           }
317 |         }]]>
318 |     </property>
319 | 
320 | 
321 |     <property name="scriptPianduan1">
322 |         <![CDATA[
323 |             "params": {
324 |               "last": #[last],
325 |               "nick": #[nick],
326 |               "goodsId": #[dynamicPriceTemplate->goodsId],
327 |               "rules":[
328 |                    #foreach($rule in $dynamicPriceTemplate.rules)
329 |                        #if($velocityCount > 0),#end
330 |                    {
331 |                         "ruleId": #[dynamicPriceTemplate->rules[$velocityCount]->ruleId],
332 |                         "ruleCount": #[dynamicPriceTemplate->rules[$velocityCount]->ruleCount],
333 |                         "ruleExist": #[dynamicPriceTemplate->rules[$velocityCount]->ruleExist]
334 |                     }
335 |                    #end
336 |               ]
337 |             }
338 |         ]]>
339 |     </property>
340 | 
341 |     <property name="scriptPianduan">
342 |         <![CDATA[
343 |             "params": {
344 |               "last": #[last],
345 |               "nick": #[nick],
346 |               "goodsId": #[dynamicPriceTemplate->goodsId],
347 |               "rules":[
348 |                    #foreach($rule in $dynamicPriceTemplate.rules)
349 |                        #if($velocityCount > 0),#end
350 |                    {
351 | 
352 |                         "ruleId": "$rule.ruleId",
353 |                         "ruleCount": $rule.ruleCount,
354 |                         "ruleExist":  $rule.ruleExist
355 | 
356 |                     }
357 |                    #end
358 |               ]
359 |             }
360 |         ]]>
361 |     </property>
362 |     <property name="scriptDsl">
363 |         <![CDATA[{
364 |           "script": {
365 |             "lang": "painless",
366 |             "source": @"""
367 |               ctx._source.last = params.last;
368 |               ctx._source.nick = params.nick;
369 |               ctx._source.rules = params.rules
370 |             """,
371 |             @{scriptPianduan}
372 |           }
373 |         }]]>
374 |     </property>
375 | 
376 |     <property name="scriptPianduan2">
377 |         <![CDATA[
378 |             "params": {
379 |               "last": #[last],
380 |               "nick": #[nick],
381 |               "goodsId": #[dynamicPriceTemplate->goodsId],
382 |               "rules":[
383 |                    #foreach($rule in $dynamicPriceTemplate.rules)
384 |                        #[dynamicPriceTemplate->rules[$velocityCount],serialJson=true] ## 通过属性serialJson指示框架直接将对象序列化为json数据
385 |                         #if($velocityCount != ($dynamicPriceTemplate.rules.size() - 1)),#end
386 |                    #end
387 |               ]
388 |             }
389 |         ]]>
390 |     </property>
391 |     <property name="scriptDslByQuery">
392 |         <![CDATA[{
393 |           "query": {
394 |             "bool": {
395 |               "must": [
396 |                 {
397 |                   "term": {
398 |                     "_id": #[id]
399 |                   }
400 |                 }
401 |               ]
402 |             }
403 |           },
404 |           "script": {
405 |             "lang": "painless",
406 |             "source": @"""
407 |               ctx._source.last = params.last;
408 |               ctx._source.lastSpecial = "#[last,quoted=false]";
409 |               ctx._source.nick = params.nick;
410 |               ctx._source.goodName = #[dynamicPriceTemplate->goodName,escapeCount=2];#*在脚本中，含有特殊字符的goodName需要转义2次*#
411 |               ctx._source.goodsId = #[dynamicPriceTemplate->goodsId];
412 |               ctx._source.dynamicPriceTemplate.goodsId = params.goodsId;
413 |               ctx._source.rules = params.rules
414 |             """,
415 |             @{scriptPianduan2}
416 |           }
417 |         }]]>
418 |     </property>
419 | 
420 |     <property name="mapbianli"><![CDATA[
421 |         ## map遍历实例，通过$item.value直接输出值，如果值中存在的特殊字符，不会对特殊字符进行转义处理，请自行处理
422 |         #foreach($item in $softTypeMap.entrySet())
423 |             #if($velocityCount > 0),#end
424 |             { "match": { "$item.key": "$item.value" } }
425 |         #end
426 |     ]]>
427 |     </property>
428 | 
429 | 
430 |     <property name="mapbianliescape"><![CDATA[
431 |         ## map<String,List<String>>遍历实例，可以通过#[]绑定变量对值中存在的特殊字符进行转义处理
432 |         #foreach($item in $softTypeMap.entrySet())
433 |             #if($item.value)
434 |                 #if($velocityCount > 0),#end
435 |                 { "match": { "$item.key": #[softTypeMap[$item.key],serialJson=true] } }
436 |             #end
437 |         #end
438 |     ]]>
439 |     </property>
440 | 
441 |     <property name="queryArray">
442 |         <![CDATA[
443 |         {
444 |             "size":10000,
445 |             "query": {
446 |                 "bool": {
447 |                     "must": [
448 |                             #foreach($item in $softTypeMap.entrySet())
449 |                                 #if($velocityCount > 0),#end
450 |                                 { "match":
451 |                                     {
452 |                                     #if($item.value)
453 |                                     "$item.key":
454 |                                     [
455 |                                         #foreach($applicationName in $item.value)
456 |                                              #if($velocityCount > 0),#end #[softTypeMap[$item.key][$velocityCount]]
457 |                                         #end
458 |                                     ]
459 |                                     #end
460 |                                     }
461 |                                  }
462 |                             #end
463 |                     ]
464 |                  }
465 |             }
466 |         }
467 |         ]]>
468 |     </property>
469 | 
470 |     <property name="queryArray1">
471 |         <![CDATA[
472 |         #if($mustShouldMap)
473 |                         #foreach($item in $mustShouldMap.entrySet())
474 |                             ,
475 |                             "must":{
476 |                                 "bool":{
477 |                                     "should":[
478 |                                         #foreach($children in $item)
479 |                                             #if($velocityCount > 0),#end
480 |                                             { "match": { "$item.key": #[$mustShouldMap[$item.key][$velocityCount]] } }
481 |                                         #end
482 |                                     ]
483 |                                 }
484 |                             }
485 |                         #end
486 |                     #end
487 |         ]]>
488 |     </property>
489 | </properties>


--------------------------------------------------------------------------------
/springboot/target/test-classes/com/mn/springboot/SpringbootApplicationTests.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/IsFive/springboot-bboss-elasticsearch/8f8bcf1cb57ed9a6b4b77e620b0694cac4e324d6/springboot/target/test-classes/com/mn/springboot/SpringbootApplicationTests.class


--------------------------------------------------------------------------------