版本分支提交

elab-es/README.md

@@ -137,11 +137,6 @@ public class Main2 implements Serializable {
 ```
 
 
-
-
-
-
-
 #### 新增数据
 
 ```java
@@ -240,3 +235,20 @@ for (SearchHit hit : searchHits) {
 
 #### 高亮查询
 
+
+
+
+
+## 关于集成Spring-jdbc记录:
+
+1. 尝试过使用 [ElasticSearch-sql](https://github.com/NLPchina/elasticsearch-sql)去做SQL转换，兼容Druid数据源等等。但是由于ES以后的版本都只会往**RestHighLevelClient**靠，但是该框架又是基于老的`Client`接口去做的，8.0版本之后会被移除，所以还得看看其他方式
+2. 使用ElasticSearch-sql的另一个版本[elasticsearch-sql](https://github.com/iamazy/elasticsearch-sql/wiki/Jdbc) 该版本基于SQL的转换做了非常多的兼容，包括SQL转DSL，包括SQL转DSL的String对象，对于JDBC的操作也支持的算到位吧，结果集可能需要根据需求转换一下。但是对于复杂的SQL条件，例如`1=1` 可能还是兼容不够好。但是功能还是挺丰富的，比如高亮、GEO、嵌套等等
+   1. https://github.com/iamazy/elasticsearch-sql2  还可以参考一下这个文档
+3. 如果使用RestHighLevelClient高版本的去做也没啥问题,也就是将SQL作为明文参数直接传递给ES去解析，利用SQL插件去查找，功能会稍微简单，可能就是不会支持高亮、GEO等等高级搜索。功能比较简单。SQL兼容性好。
+
+可以将这几种结合一下。
+
+
+
+
+

elab-es/pom.xml

@@ -25,6 +25,12 @@
         </dependency>
         <dependency>
             <artifactId>elab-core</artifactId>
+            <exclusions>
+                <exclusion>
+                    <artifactId>jackson-core</artifactId>
+                    <groupId>com.fasterxml.jackson.core</groupId>
+                </exclusion>
+            </exclusions>
             <groupId>com.elab.core</groupId>
             <version>${project.version}</version>
         </dependency>
@@ -44,6 +50,27 @@
             <artifactId>esclientrhl</artifactId>
             <version>7.0.0</version>
         </dependency>
+        <dependency>
+            <groupId>io.github.iamazy.elasticsearch.dsl</groupId>
+            <artifactId>elasticsearch-sql-all</artifactId>
+            <version>7.8.1.1</version>
+        </dependency>
+<!--        <dependency>-->
+<!--            <groupId>org.nlpcn</groupId>-->
+<!--            <artifactId>elasticsearch-sql</artifactId>-->
+<!--            <version>7.8.0.1</version>-->
+<!--        </dependency>-->
+        <!-- https://mvnrepository.com/artifact/org.elasticsearch.client/x-pack-transport -->
+<!--        <dependency>-->
+<!--            <groupId>org.elasticsearch.client</groupId>-->
+<!--            <artifactId>x-pack-transport</artifactId>-->
+<!--            <version>7.8.1</version>-->
+<!--        </dependency>-->
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>druid</artifactId>
+            <version>1.1.16</version>
+        </dependency>
         <!--        <dependency>-->
         <!--            <groupId>org.springframework.boot</groupId>-->
         <!--            <artifactId>spring-boot-redisson-data-elasticsearch</artifactId>-->
@@ -57,13 +84,23 @@
         <dependency>
             <groupId>org.elasticsearch</groupId>
             <artifactId>elasticsearch</artifactId>
-            <version>7.4.0</version>
+            <version>7.8.0</version>
         </dependency>
         <dependency>
             <groupId>org.elasticsearch.client</groupId>
             <artifactId>elasticsearch-rest-high-level-client</artifactId>
-            <version>7.4.0</version>
+            <version>7.8.0</version>
         </dependency>
+<!--        <dependency>-->
+<!--            <groupId>org.elasticsearch</groupId>-->
+<!--            <artifactId>elasticsearch</artifactId>-->
+<!--            <version>7.4.0</version>-->
+<!--        </dependency>-->
+<!--        <dependency>-->
+<!--            <groupId>org.elasticsearch.client</groupId>-->
+<!--            <artifactId>elasticsearch-rest-high-level-client</artifactId>-->
+<!--            <version>7.4.0</version>-->
+<!--        </dependency>-->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>
@@ -79,6 +116,12 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
             <version>${springboot.version}</version>
+            <exclusions>
+                <exclusion>
+                    <artifactId>jackson-core</artifactId>
+                    <groupId>com.fasterxml.jackson.core</groupId>
+                </exclusion>
+            </exclusions>
         </dependency>
     </dependencies>
 

elab-es/src/main/java/com/elab/es/client/DefaultElasticSearchTemplate.java

@@ -1,7 +1,15 @@
 package com.elab.es.client;
 
-import org.springframework.stereotype.Component;
+import org.elasticsearch.action.search.SearchRequest;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.search.SearchHit;
+import org.elasticsearch.search.SearchHits;
 import org.zxp.esclientrhl.repository.ElasticsearchTemplateImpl;
+import org.zxp.esclientrhl.util.JsonUtils;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * 默认的ES模版处理器
@@ -9,8 +17,27 @@ import org.zxp.esclientrhl.repository.ElasticsearchTemplateImpl;
  * @author ： liukx
  * @time ： 2019/8/6 - 15:05
  */
-@Component
 public class DefaultElasticSearchTemplate<K, V> extends ElasticsearchTemplateImpl<K, V> {
 
+    @Override
+    public SearchResponse search(SearchRequest searchRequest) throws IOException {
+        SearchResponse search = super.search(searchRequest);
+        return search;
+    }
+
+    public <T> List<T> search(SearchRequest searchRequest, Class<T> clazz) throws IOException {
+        SearchResponse searchResponse = super.search(searchRequest);
+        SearchHits hits = searchResponse.getHits();
+        SearchHit[] searchHits = hits.getHits();
+
+        List<T> result = new ArrayList<>();
+        for (SearchHit hit : searchHits) {
+            T t = JsonUtils.string2Obj(hit.getSourceAsString(), clazz);
+            result.add(t);
+        }
+        return result;
+
+    }
+
 
 }

elab-es/src/main/java/com/elab/es/client/annotation/EnableElastaticSearch.java

@@ -1,16 +1,27 @@
 package com.elab.es.client.annotation;
 
 import com.elab.es.client.configuration.ESConfiguration;
+import com.elab.es.client.spring.ElasticSearchScannerRegister;
 import org.springframework.context.annotation.Import;
 
 import java.lang.annotation.*;
 
+/**
+ * 开启ES功能
+ *
+ * @author liukx
+ */
 @Target({ElementType.TYPE})
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 @Inherited
-@Import({ESConfiguration.class})
+@Import({ESConfiguration.class, ElasticSearchScannerRegister.class})
 public @interface EnableElastaticSearch {
+    /**
+     * 特定的包扫描
+     *
+     * @return
+     */
     String[] basePackages() default {};
 
     String[] value() default {};
@@ -18,4 +29,13 @@ public @interface EnableElastaticSearch {
     String[] entityPath() default {};
 
     boolean printregmsg() default false;
+
+    /**
+     * 特定的ES解析SQL处理
+     *
+     * @return
+     */
+    String configurableLocations() default "es";
+
+    Class<?>[] basePackageClasses() default {};
 }

elab-es/src/main/java/com/elab/es/client/configuration/ESConfiguration.java

@@ -1,5 +1,6 @@
 package com.elab.es.client.configuration;
 
+import com.elab.es.client.DefaultElasticSearchTemplate;
 import org.apache.http.HttpHost;
 import org.apache.http.auth.AuthScope;
 import org.apache.http.auth.UsernamePasswordCredentials;
@@ -10,10 +11,13 @@ import org.elasticsearch.client.RestClient;
 import org.elasticsearch.client.RestClientBuilder;
 import org.elasticsearch.client.RestHighLevelClient;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
+import org.zxp.esclientrhl.config.ElasticsearchProperties;
 import org.zxp.esclientrhl.index.ElasticsearchIndexImpl;
 
 /**
@@ -24,14 +28,33 @@ import org.zxp.esclientrhl.index.ElasticsearchIndexImpl;
  */
 @Configuration
 @ComponentScan(basePackages = {"com.elab.es.*"})
-@Import({ElabESProperties.class, ElasticsearchIndexImpl.class})
+@Import({ElasticsearchIndexImpl.class})
+@EnableConfigurationProperties(value = ElabESProperties.class)
 public class ESConfiguration {
 
     @Bean
+    @ConditionalOnProperty(prefix = "elab.es", name = "uris")
+    public ElasticsearchProperties elasticsearchProperties(@Autowired ElabESProperties properties) {
+        ElasticsearchProperties elasticsearchProperties = new ElasticsearchProperties();
+        elasticsearchProperties.setHost(properties.getUris().get(0));
+        elasticsearchProperties.setUsername(properties.getUsername());
+        elasticsearchProperties.setPassword(properties.getPassword());
+        return elasticsearchProperties;
+    }
+
+    @Bean
+    public DefaultElasticSearchTemplate elasticSearchTemplate(){
+        return new DefaultElasticSearchTemplate();
+    }
+
+    @Bean
+    @ConditionalOnProperty(prefix = "elab.es", name = "uris")
     public RestHighLevelClient restHighLevelClient(@Autowired ElabESProperties properties) throws Exception {
         CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
         //访问用户名和密码为您创建阿里云Elasticsearch实例时设置的用户名和密码，也是Kibana控制台的登录用户名和密码。
-        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(properties.getUsername(), properties.getPassword()));
+        if (properties.getUsername() != null && properties.getPassword() != null) {
+            credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(properties.getUsername(), properties.getPassword()));
+        }
         // 通过builder创建rest client，配置http client的HttpClientConfigCallback。
         // 单击所创建的Elasticsearch实例ID，在基本信息页面获取公网地址，即为ES集群地址。
         if (properties.getUris().size() == 1) {
@@ -48,6 +71,8 @@ public class ESConfiguration {
         } else if (properties.getUris().size() > 1) {
             throw new Exception("bucket type is not support");
         }
-        throw new Exception("RestHighLevelClient 需要指定URL。yaml配置中elab.elasticsearch.jest.uris ..");
+        throw new Exception("RestHighLevelClient 需要指定URL。yaml配置中elab.elasticsearch.uris ..");
     }
+
+
 }

elab-es/src/main/java/com/elab/es/client/configuration/ElabESProperties.java

@@ -1,6 +1,7 @@
 package com.elab.es.client.configuration;
 
 import org.springframework.boot.autoconfigure.elasticsearch.jest.JestProperties;
+import org.springframework.boot.context.properties.ConfigurationProperties;
 
 import java.time.Duration;
 import java.util.ArrayList;
@@ -13,6 +14,7 @@ import java.util.List;
  * @author ： liukx
  * @time ： 2020/3/31 - 10:38
  */
+@ConfigurationProperties("elab.es") //描述了当前pojo对应的配置文件前缀
 public class ElabESProperties {
     /**
      * Comma-separated list of the Elasticsearch instances to use.

elab-es/src/main/java/com/elab/es/client/db/IElasticSearchSupport.java

@@ -0,0 +1,13 @@
+package com.elab.es.client.db;
+
+import com.elab.core.dao.IExampleDaoSupport;
+
+/**
+ * @Module ES 搜索支持
+ * @Description 结合Elab-db兼容ES操作
+ * @Author liukaixiong
+ * @Date 2021/1/29 10:48
+ */
+public interface IElasticSearchSupport<T, E> extends IExampleDaoSupport<T, E> {
+
+}

elab-es/src/main/java/com/elab/es/client/spring/ClassCacheRegister.java

@@ -0,0 +1,65 @@
+package com.elab.es.client.spring;
+
+import com.elab.core.spring.binding.BindingException;
+import com.elab.core.spring.method.ProxyDataProcess;
+import com.elab.core.sql.ConfigurableFactory;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * dao类接口的注册
+ * <p>
+ * 这里会将dao类的接口统一进行注册到Map中,并且会对应一个处理工厂
+ * </p>
+ *
+ * @author Liukx
+ * @create 2018-01-03 14:40
+ * @email liukx@elab-plus.com
+ **/
+public class ClassCacheRegister<T> {
+
+    // 承装动态代理的容器
+    private final Map<Class<?>, ProxyCacheFactory> knownMappers = new HashMap();
+
+    public <T> T getMapper(Class<T> type, Object invokeBean, ConfigurableFactory configurableFactory, ProxyDataProcess proxyDataProcess) {
+        ProxyCacheFactory daoProxyFactory = this.knownMappers.get(type);
+        if (daoProxyFactory == null) {
+            throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
+        } else {
+            try {
+                return (T) daoProxyFactory.newInstance(invokeBean, configurableFactory);
+            } catch (Exception var5) {
+                throw new BindingException("Error getting mapper instance. Cause: " + var5, var5);
+            }
+        }
+    }
+
+    public <T> boolean hasMapper(Class<T> type) {
+        return this.knownMappers.containsKey(type);
+    }
+
+    /**
+     * 注册一个类型到map中,并对应一个对象
+     *
+     * @param type
+     * @param <T>
+     */
+    public <T> void addMapper(Class<T> type) {
+        if (type.isInterface()) {
+            if (this.hasMapper(type)) {
+                throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
+            }
+            boolean loadCompleted = false;
+            try {
+                this.knownMappers.put(type, new ProxyCacheFactory(type));
+                loadCompleted = true;
+            } finally {
+                if (!loadCompleted) {
+                    this.knownMappers.remove(type);
+                }
+            }
+        }
+
+    }
+}

elab-es/src/main/java/com/elab/es/client/spring/ClassPathElasticSearchScanner.java

@@ -0,0 +1,238 @@
+package com.elab.es.client.spring;
+
+import com.alibaba.druid.support.logging.Resources;
+import com.elab.core.spring.common.utils.StringUtils;
+import com.elab.core.spring.method.DefaultProxyDataProcess;
+import com.elab.core.spring.method.ProxyDataProcess;
+import com.elab.core.sql.ConfigurableFactory;
+import com.elab.es.client.db.IElasticSearchSupport;
+import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
+import org.springframework.beans.factory.config.BeanDefinitionHolder;
+import org.springframework.beans.factory.config.RuntimeBeanReference;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.beans.factory.support.GenericBeanDefinition;
+import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
+import org.springframework.core.env.Environment;
+import org.springframework.core.type.classreading.MetadataReader;
+import org.springframework.core.type.classreading.MetadataReaderFactory;
+import org.springframework.core.type.filter.AssignableTypeFilter;
+import org.springframework.core.type.filter.TypeFilter;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Set;
+
+/**
+ * 具体扫描包下的类的共同属性类构建
+ *
+ * @author Liukx
+ * @create 2018-01-03 10:21
+ * @email liukx@elab-plus.com
+ **/
+public class ClassPathElasticSearchScanner extends ClassPathBeanDefinitionScanner {
+
+    /**
+     * 具体的执行者
+     */
+    private String invokeBeanId;
+
+    /**
+     * 抽象的接口名称
+     */
+    private Class<?> markerInterface;
+
+    private ClassCacheRegister classCacheRegister;
+
+    private String proxyDataProcessName;
+
+    private ConfigurableFactory configurableFactory;
+    /**
+     * 代理数据处理器
+     */
+    private ProxyDataProcess proxyDataProcess = new DefaultProxyDataProcess();
+
+    public ClassCacheRegister getClassCacheRegister() {
+        if (this.classCacheRegister == null) {
+            this.classCacheRegister = new ClassCacheRegister();
+        }
+        return classCacheRegister;
+    }
+
+    public void setProxyDataProcessName(String proxyDataProcessName) {
+        this.proxyDataProcessName = proxyDataProcessName;
+    }
+
+    public ConfigurableFactory getConfigurableFactory() {
+        return configurableFactory;
+    }
+
+    public void setConfigurableFactory(ConfigurableFactory configurableFactory) {
+        this.configurableFactory = configurableFactory;
+    }
+
+    public void setClassCacheRegister(ClassCacheRegister classCacheRegister) {
+        this.classCacheRegister = classCacheRegister;
+    }
+
+    public ClassPathElasticSearchScanner(BeanDefinitionRegistry registry) {
+        super(registry);
+    }
+
+    public ClassPathElasticSearchScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
+        super(registry, useDefaultFilters);
+    }
+
+    public ClassPathElasticSearchScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment) {
+        super(registry, useDefaultFilters, environment);
+    }
+
+    public String getInvokeBeanId() {
+        return invokeBeanId;
+    }
+
+    public void setInvokeBeanId(String invokeBeanId) {
+        this.invokeBeanId = invokeBeanId;
+    }
+
+    public Class<?> getMarkerInterface() {
+        return markerInterface;
+    }
+
+    public void setMarkerInterface(Class<?> markerInterface) {
+        this.markerInterface = markerInterface;
+    }
+
+    /**
+     * 扫描指定路径的文件
+     * <p>
+     * 将扫描到的类解析成对应的BeanDefinition对象,并注册到ioc容器中
+     * </p>
+     *
+     * @param basePackages 扫描地址
+     * @return
+     */
+    @Override
+    public Set<BeanDefinitionHolder> doScan(String... basePackages) {
+        Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
+        if (beanDefinitions.isEmpty()) {
+            logger.warn("No jdbc dao was found in '" + Arrays.toString(basePackages) + "' package. Please check your doc.");
+        } else {
+            for (BeanDefinitionHolder holder : beanDefinitions) {
+                GenericBeanDefinition definition = (GenericBeanDefinition) holder.getBeanDefinition();
+
+                if (logger.isDebugEnabled()) {
+                    logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName()
+                            + "' and '" + definition.getBeanClassName() + "' mapperInterface");
+                }
+                Class<?> interfaceClass = null;
+                // 拿到当前BeanDefinition对象的接口
+                try {
+                    interfaceClass = Resources.classForName(definition.getBeanClassName());
+                } catch (ClassNotFoundException e) {
+                    e.printStackTrace();
+                }
+                // 注册到一个容器中
+                getClassCacheRegister().addMapper(interfaceClass);
+
+                // 重新构建BeanDefinition对象的属性
+                //mapperInterface 是接口类,实际上引用的是工厂类生产出来的bean
+                definition.getPropertyValues().add("mapperInterface", definition.getBeanClassName());
+                // 这里是非常关键的一步
+                definition.setBeanClass(ElasticSearchFactoryBean.class);
+                boolean explicitFactoryUsed = false;
+                if (!StringUtils.isEmpty(this.invokeBeanId)) {
+                    definition.getPropertyValues().add("invokeBean", new RuntimeBeanReference(invokeBeanId));
+                } else {
+                    logger.error(" basicBaseDaoName is not null !!!");
+                }
+                if (!StringUtils.isEmpty(this.proxyDataProcessName)) {
+                    definition.getPropertyValues().add("proxyDataProcess", new RuntimeBeanReference
+                            (proxyDataProcessName));
+                } else {
+                    definition.getPropertyValues().add("proxyDataProcess", proxyDataProcess);
+                }
+                definition.getPropertyValues().add("classCacheRegister", getClassCacheRegister());
+                definition.getPropertyValues().add("configurableFactory", configurableFactory);
+                explicitFactoryUsed = true;
+                if (!explicitFactoryUsed) {
+                    if (logger.isDebugEnabled()) {
+                        logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
+                    }
+                    // 表示需要根据类型获取
+                    definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
+                }
+            }
+        }
+
+        return beanDefinitions;
+    }
+
+
+    /**
+     * Configures parent scanner to search for the right interfaces. It can search
+     * for all interfaces or just for those that extends a markerInterface or/and
+     * those annotated with the annotationClass
+     */
+    public void registerFilters() {
+        boolean acceptAllInterfaces = true;
+
+        // if specified, use the given annotation and / or marker interface
+//        if (this.annotationClass != null) {
+//            addIncludeFilter(new AnnotationTypeFilter(this.annotationClass));
+//            acceptAllInterfaces = false;
+//        }
+
+        // override AssignableTypeFilter to ignore matches on the actual marker interface
+        if (this.markerInterface != null) {
+            addIncludeFilter(new AssignableTypeFilter(this.markerInterface) {
+                @Override
+                protected boolean matchClassName(String className) {
+                    return false;
+                }
+            });
+            acceptAllInterfaces = false;
+        }
+
+        if (acceptAllInterfaces) {
+            // default include filter that accepts all classes
+            // 默认接受所有的注册类,只要是该类扫描的统统注册
+            addIncludeFilter(new TypeFilter() {
+                @Override
+                public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
+                    String[] interfaceNames = metadataReader.getClassMetadata().getInterfaceNames();
+
+                    if (interfaceNames.length > 0) {
+                        for (int i = 0; i < interfaceNames.length; i++) {
+                            //允许扫描注册的bean
+                            if (IElasticSearchSupport.class.getName().equals(interfaceNames[i])) {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                }
+            });
+        }
+
+        // exclude package-info.java
+        addExcludeFilter(new TypeFilter() {
+            @Override
+            public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
+                String className = metadataReader.getClassMetadata().getClassName();
+                return className.endsWith("package-info");
+            }
+        });
+    }
+
+    /**
+     * 这里决定是否能够被注册到ioc的容器中
+     *
+     * @param beanDefinition
+     * @return
+     */
+    @Override
+    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
+        return (beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent());
+    }
+}

elab-es/src/main/java/com/elab/es/client/spring/ElasticSearchFactoryBean.java

@@ -0,0 +1,99 @@
+package com.elab.es.client.spring;
+
+import com.elab.core.spring.method.ProxyDataProcess;
+import com.elab.core.sql.ConfigurableFactory;
+import org.springframework.beans.factory.FactoryBean;
+
+/**
+ * dao层代理工厂
+ * <p>
+ * 所有通过当前工厂产出的bean的一系列过程都会经过该类去处理
+ * </p>
+ *
+ * @author Liukx
+ * @create 2018-01-03 11:13
+ * @email liukx@elab-plus.com
+ **/
+public class ElasticSearchFactoryBean<T> implements FactoryBean<T> {
+
+    //具体执行者
+    private Object invokeBean;
+
+    //检查父类
+    private Class<?> mapperInterface;
+
+    // dao注册工厂
+    private ClassCacheRegister classCacheRegister;
+
+    private ProxyDataProcess proxyDataProcess;
+
+    private ConfigurableFactory configurableFactory;
+
+    public ConfigurableFactory getConfigurableFactory() {
+        return configurableFactory;
+    }
+
+    public void setConfigurableFactory(ConfigurableFactory configurableFactory) {
+        this.configurableFactory = configurableFactory;
+    }
+
+    public Class<?> getMapperInterface() {
+        return mapperInterface;
+    }
+
+    public ClassCacheRegister getClassCacheRegister() {
+        return classCacheRegister;
+    }
+
+    public void setClassCacheRegister(ClassCacheRegister classCacheRegister) {
+        this.classCacheRegister = classCacheRegister;
+    }
+
+    public void setMapperInterface(Class<?> mapperInterface) {
+        this.mapperInterface = mapperInterface;
+    }
+
+
+    public Object getInvokeBean() {
+        return invokeBean;
+    }
+
+    public void setInvokeBean(Object invokeBean) {
+        this.invokeBean = invokeBean;
+    }
+
+    public void setProxyDataProcess(ProxyDataProcess proxyDataProcess) {
+        this.proxyDataProcess = proxyDataProcess;
+    }
+
+    /**
+     * beanDefinition中的beanClass只要是这个工厂类的,就会从这里开始调用
+     *
+     * @return
+     * @throws Exception
+     */
+    @Override
+    public T getObject() throws Exception {
+        return (T) classCacheRegister.getMapper(mapperInterface, invokeBean, configurableFactory, proxyDataProcess);
+    }
+
+    /**
+     * 获取工厂中的对象的类型
+     *
+     * @return
+     */
+    @Override
+    public Class<?> getObjectType() {
+        return this.mapperInterface;
+    }
+
+    /**
+     * 从这个工厂中获取的对象是否是单例的
+     *
+     * @return
+     */
+    @Override
+    public boolean isSingleton() {
+        return true;
+    }
+}

elab-es/src/main/java/com/elab/es/client/spring/ElasticSearchScannerRegister.java

@@ -0,0 +1,85 @@
+package com.elab.es.client.spring;
+
+import com.elab.core.sql.ConfigurableFactory;
+import com.elab.es.client.annotation.EnableElastaticSearch;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
+import org.springframework.core.type.AnnotationMetadata;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.StringUtils;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * 需要代理类的注册
+ *
+ * @author ： liukx
+ * @time ： 2020/4/1 - 19:17
+ */
+public class ElasticSearchScannerRegister implements ImportBeanDefinitionRegistrar, ApplicationContextAware {
+    private Logger logger = LoggerFactory.getLogger(ElasticSearchScannerRegister.class);
+    private ApplicationContext applicationContext;
+
+    @Override
+    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+        this.applicationContext = applicationContext;
+    }
+
+    public ConfigurableFactory getConfigurableFactory(String configPath) {
+        ConfigurableFactory configurableFactory = new ConfigurableFactory();
+        configurableFactory.setSqlConfigurableLocations(configPath);
+        configurableFactory.buildSqlConfigurableFactory();
+        return configurableFactory;
+    }
+
+    @Override
+    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry beanDefinitionRegistry) {
+        Map<String, Object> defaultAttrs = metadata
+                .getAnnotationAttributes(EnableElastaticSearch.class.getName());
+        if (defaultAttrs != null) {
+            Set<String> basePackageList = getBasePackages(defaultAttrs);
+            if (basePackageList.size() > 0) {
+                String[] basePackages = basePackageList.stream().toArray(String[]::new);
+                logger.debug(" 开启ElabES , 注解扫描指定的包 : {} ", Arrays.toString(basePackages));
+                ConfigurableFactory configuration = getConfigurableFactory(defaultAttrs.get("configurableLocations").toString
+                        ());
+                ClassPathElasticSearchScanner scanner = new ClassPathElasticSearchScanner(beanDefinitionRegistry);
+                scanner.setInvokeBeanId("elasticSearchTemplate");
+                scanner.setResourceLoader(this.applicationContext);
+                scanner.setConfigurableFactory(configuration);
+                //
+                scanner.registerFilters();
+                //注册对应的daoInterface
+                scanner.scan(basePackages);
+            }
+        }
+    }
+
+    protected Set<String> getBasePackages(Map<String, Object> attributes) {
+
+        Set<String> basePackages = new HashSet<>();
+        for (String pkg : (String[]) attributes.get("value")) {
+            if (StringUtils.hasText(pkg)) {
+                basePackages.add(pkg);
+            }
+        }
+        for (String pkg : (String[]) attributes.get("basePackages")) {
+            if (StringUtils.hasText(pkg)) {
+                basePackages.add(pkg);
+            }
+        }
+        for (Class<?> clazz : (Class[]) attributes.get("basePackageClasses")) {
+            basePackages.add(ClassUtils.getPackageName(clazz));
+        }
+
+        return basePackages;
+    }
+}

elab-es/src/main/java/com/elab/es/client/spring/MethodCacheProxy.java

@@ -0,0 +1,64 @@
+package com.elab.es.client.spring;
+
+import com.elab.core.sql.ConfigurableFactory;
+
+import java.io.Serializable;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.util.Map;
+
+/**
+ * 具体的jdk代理
+ * <p>
+ * JDK动态代理的具体实现类,这里会将具体的代理过程交给DaoMethod处理,该类只对做一次缓存
+ * </p>
+ *
+ * 方法的缓存
+ *
+ * @author Liukx
+ * @create 2018-01-03 11:31
+ * @email liukx@elab-plus.com
+ **/
+public class MethodCacheProxy<T> implements InvocationHandler, Serializable {
+    private static final long serialVersionUID = -6424540398559729838L;
+    private final Object invokeBean;
+    private final Class<T> mapperInterface;
+    private final Map<Method, ProxyMethodInvoke> methodCache;
+    private ConfigurableFactory configurableFactory;
+
+    public MethodCacheProxy(Object invokeBean, Class<T> mapperInterface, Map<Method, ProxyMethodInvoke> methodCache, ConfigurableFactory configurableFactory) {
+        this.invokeBean = invokeBean;
+        this.mapperInterface = mapperInterface;
+        this.methodCache = methodCache;
+        this.configurableFactory = configurableFactory;
+    }
+
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        if (Object.class.equals(method.getDeclaringClass())) {
+            try {
+                return method.invoke(this, args);
+            } catch (Throwable var5) {
+                throw new Exception(var5);
+            }
+        } else {
+            ProxyMethodInvoke mapperMethod = this.cachedMapperMethod(method);
+            return mapperMethod.execute(args);
+        }
+    }
+
+    /**
+     * 缓存DaoMethod对象
+     *
+     * @param method
+     * @return
+     */
+    private ProxyMethodInvoke cachedMapperMethod(Method method) {
+        ProxyMethodInvoke daoMethod = this.methodCache.get(method);
+        if (daoMethod == null) {
+            daoMethod = new ProxyMethodInvoke(this.mapperInterface, method, this.invokeBean, this.configurableFactory );
+            this.methodCache.put(method, daoMethod);
+        }
+        return daoMethod;
+    }
+}

elab-es/src/main/java/com/elab/es/client/spring/ProxyCacheFactory.java

@@ -0,0 +1,48 @@
+package com.elab.es.client.spring;
+
+import com.elab.core.sql.ConfigurableFactory;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * 具体代理dao类的工厂
+ * <p>
+ * 持有整个dao集合对象,每当方法调用会从工厂里面找指定的代理方法
+ * </p>
+ * <p>
+ * 代理的缓存
+ *
+ * @author Liukx
+ * @create 2018-01-03 11:30
+ * @email liukx@elab-plus.com
+ **/
+public class ProxyCacheFactory<T> {
+
+    private final Class<T> mapperInterface;
+    private Map<Method, MethodCacheProxy> methodCache = new ConcurrentHashMap();
+
+    public ProxyCacheFactory(Class<T> mapperInterface) {
+        this.mapperInterface = mapperInterface;
+    }
+
+    public Class<T> getMapperInterface() {
+        return this.mapperInterface;
+    }
+
+    public Map<Method, MethodCacheProxy> getMethodCache() {
+        return this.methodCache;
+    }
+
+    protected T newInstance(MethodCacheProxy<T> mapperProxy) {
+        return (T) Proxy.newProxyInstance(this.mapperInterface.getClassLoader(), new Class[]{this.mapperInterface}, mapperProxy);
+    }
+
+    public T newInstance(Object invokeBean, ConfigurableFactory configurableFactory) {
+        MethodCacheProxy<T> mapperProxy = new MethodCacheProxy(invokeBean, this.mapperInterface, this.methodCache,
+                configurableFactory);
+        return this.newInstance(mapperProxy);
+    }
+}

elab-es/src/main/java/com/elab/es/client/spring/ProxyMethodInvoke.java

@@ -0,0 +1,570 @@
+package com.elab.es.client.spring;
+
+import com.alibaba.druid.sql.SQLUtils;
+import com.elab.core.aop.annotations.XmlGroupName;
+import com.elab.core.bean.PageModel;
+import com.elab.core.dao.IExampleDaoSupport;
+import com.elab.core.dao.model.JdbcParamsModel;
+import com.elab.core.dao.model.ListDynamicSearch;
+import com.elab.core.dao.params.NamedParameterUtils2;
+import com.elab.core.dao.params.ParsedSql2;
+import com.elab.core.spring.base.EntityOperation;
+import com.elab.core.spring.common.SqlInfoModel;
+import com.elab.core.spring.common.TypeGroupModel;
+import com.elab.core.spring.common.utils.BeanUtils;
+import com.elab.core.spring.common.utils.DataUtils;
+import com.elab.core.spring.method.DefaultSQLBuilderSupport;
+import com.elab.core.spring.method.ISQLBuliderSupport;
+import com.elab.core.sql.ConfigurableFactory;
+import com.elab.core.sql.config.SqlCommandType;
+import com.elab.core.utils.StringUtils;
+import com.elab.es.client.DefaultElasticSearchTemplate;
+import com.elab.es.client.db.IElasticSearchSupport;
+import io.github.iamazy.elasticsearch.dsl.sql.ElasticSql2DslParser;
+import io.github.iamazy.elasticsearch.dsl.sql.model.ElasticSqlParseResult;
+import org.apache.commons.lang3.ArrayUtils;
+import org.elasticsearch.action.search.SearchRequest;
+import org.elasticsearch.action.search.SearchResponse;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.jdbc.core.RowMapper;
+import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.jdbc.core.namedparam.SqlParameterSource;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * dao层方法拦截根据指定的类型调用方法
+ * <p>
+ * 具体dao类执行的方法,根据方法名进行判断类型
+ * </p>
+ *
+ * @author Liukx
+ * @create 2018-01-03 11:36
+ * @email liukx@elab-plus.com
+ **/
+public class ProxyMethodInvoke {
+
+    /**
+     * 具体的执行接口
+     */
+    private Class<?> mapperInterface;
+
+    /**
+     * 执行的方法
+     */
+    private Method method;
+
+    /**
+     * DB层的SQL执行器
+     */
+    private DefaultElasticSearchTemplate beanInvoke;
+
+    /**
+     * 父类的构造参数
+     */
+    private Class<?> supperGenricType;
+
+    /**
+     * 父类的接口
+     */
+    private String supperInterfaceName;
+
+    /**
+     * entity的操作对象
+     */
+    private EntityOperation entityOperation;
+
+    /**
+     * 配置文件对象,将sql.xml描述成对象
+     */
+    private ConfigurableFactory configurableFactory;
+
+    /**
+     * example类型 例如UserExample
+     */
+    private Class<?> exampleType;
+
+    /**
+     * 自动生成的SQL对象接口
+     */
+    private List<ISQLBuliderSupport> sqlBuilderSupportList = new ArrayList<ISQLBuliderSupport>();
+
+    /**
+     * 缓存一些反射的信息
+     */
+    private Map<String, Class<?>> methodReturnCacheMap = new ConcurrentHashMap<String, Class<?>>();
+
+    private ElasticSql2DslParser parser = new ElasticSql2DslParser();
+
+    /**
+     * 默认的API接口描述
+     */
+    private final String defaultSupperInterface = IElasticSearchSupport.class.getName();
+
+    /**
+     * 默认的example的API接口对象
+     */
+    private final String defaultExampleInterface = IExampleDaoSupport.class.getName();
+
+    /**
+     * 当前类的sql文件中的groupName对象
+     */
+    private String xmlGroupName;
+
+    private Logger logger = LoggerFactory.getLogger(ProxyMethodInvoke.class);
+
+    /**
+     * 构建一个DaoMethod的方法对象
+     *
+     * @param <T>
+     * @param mapperInterface     dao的接口類
+     * @param method              方法信息
+     * @param invokeBean          jdbc操作类
+     * @param configurableFactory 配置工厂
+     */
+    public <T> ProxyMethodInvoke(Class<?> mapperInterface, Method method, Object invokeBean, ConfigurableFactory configurableFactory) {
+        // 接口信息
+        this.mapperInterface = mapperInterface;
+        // 方法信息
+        this.method = method;
+        // 具体操作类
+        this.beanInvoke = (DefaultElasticSearchTemplate) invokeBean;
+        // 配置工厂
+        this.configurableFactory = configurableFactory;
+        //默认先将初始化的sql构建加入进来
+        this.sqlBuilderSupportList.add(new DefaultSQLBuilderSupport());
+        // 类的信息提取
+        // 父类的接口类
+        this.supperInterfaceName = mapperInterface.getGenericInterfaces()[0].getTypeName();
+        // 泛型对象
+        List<String> classGenricTypeString = BeanUtils.getClassGenricTypeString(this.supperInterfaceName);
+        // 第一个db对象
+        this.supperGenricType = BeanUtils.getClassByString(classGenricTypeString.get(0));
+        // 第二个,案例对象
+        this.exampleType = classGenricTypeString.size() > 1 ? BeanUtils.getClassByString(classGenricTypeString.get(1)) : null;
+        // 实体操作类
+        this.entityOperation = new EntityOperation(this.supperGenricType, "id");
+        if (this.mapperInterface.isAnnotationPresent(XmlGroupName.class)) {
+            this.xmlGroupName = this.mapperInterface.getAnnotation(XmlGroupName.class).value();
+        }
+    }
+
+    /**
+     * 具体执行sql的方法
+     * 1. 判断sql的类型
+     * 2. 根据类型判断调用的方法
+     * 3.
+     *
+     * @param args
+     * @return
+     */
+    public Object execute(Object[] args) throws Exception {
+        int argsLength = args.length;
+        String sqlSource = method.getName();
+        String statementName = getSqlId();
+        String tableName = this.entityOperation.tableName;
+        Object arg = args[0];
+        SqlCommandType sqlType = this.configurableFactory.getSqlConfigurableFactory().getSqlType(statementName);
+
+        // 如果是没有找到对应的SQL情况下
+        if (sqlType == null) {
+            // 表示配置文件中没有找到,则会从父类接口去获取
+            if (!StringUtils.isEmpty(this.supperInterfaceName)) {
+                if (this.supperInterfaceName.startsWith(defaultSupperInterface)) {
+                    // 如果是其他增删改类型的方法
+                    if (createSql(statementName)) {
+                        return execute(args);
+                    }
+                }
+
+                if (this.defaultExampleInterface.startsWith(defaultExampleInterface)) {
+                    // 如果是查找类型的方法
+                    if ("find".equals(method.getName())) {
+                        return findMethodInvoke(arg);
+                    }
+                }
+            }
+            // 抛出异常
+            throw new Exception(" 找不到[" + statementName + "]对应的处理sql");
+        } else {
+            // 这里是找到SQL的情况下
+            String sql = this.configurableFactory.getSqlConfigurableFactory().getSql(statementName);
+            logger.debug(" SQL ID : " + statementName);
+            if (sqlType == SqlCommandType.INSERT) {
+                if (arg instanceof List) {
+                    return this.beanInvoke.saveBatch((List) arg);
+                } else {
+                    boolean save = this.beanInvoke.save(arg);
+                    return save ? 1 : 0;
+                }
+            } else if (sqlType == SqlCommandType.UPDATE || sqlType == SqlCommandType.DELETE) {
+                if (arg instanceof List) {
+                    return this.beanInvoke.bulkUpdateBatch((List) arg);
+                }
+                boolean update = this.beanInvoke.update(arg);
+                return update ? 1 : 0;
+            } else {
+                if (sqlType != SqlCommandType.SELECT) {
+                    System.out.println("语句类型有误!");
+                    return null;
+                }
+                return selectInvokeMethod(statementName, sql, args);
+            }
+        }
+    }
+
+    /**
+     * 获取sql文件中的对应sql编号
+     *
+     * @return
+     */
+    private String getSqlId() {
+        String statementName;
+        if (StringUtils.isEmpty(this.xmlGroupName)) {
+            statementName = mapperInterface.getName() + "." + method.getName();
+        } else {
+            statementName = this.xmlGroupName + "." + method.getName();
+        }
+        return statementName;
+    }
+
+    /**
+     * 执行特殊的find的方法处理过程
+     *
+     * @param arg
+     * @return
+     */
+    private Object findMethodInvoke(Object arg) {
+        List oredCriteriaList = (List) BeanUtils.invokegetGetterMethod(arg, "oredCriteria");
+        List<Object> paramsList = new LinkedList<Object>();
+        StringBuffer sb = new StringBuffer();
+        sb.append("select " + entityOperation.allColumn + " from " + entityOperation.tableName + " ");
+
+        if (oredCriteriaList.size() > 0) {
+            for (int i = 0; i < oredCriteriaList.size(); i++) {
+                Object o = oredCriteriaList.get(i);
+                List criteriaList = (List) BeanUtils.invokegetGetterMethod(o, "criteria");
+                boolean flag = true;
+                for (int j = 0; j < criteriaList.size(); j++) {
+                    if (flag) {
+                        sb.append(" where ");
+                        flag = false;
+                    } else {
+                        sb.append(" and ");
+                    }
+                    Object o2 = criteriaList.get(j);
+                    // key 条件
+                    String condition = (String) BeanUtils.invokegetGetterMethod(o2, "condition");
+                    // 对应的值
+                    Object valueObject = BeanUtils.invokegetGetterMethod(o2, "value");
+                    Object secondValue = BeanUtils.invokegetGetterMethod(o2, "secondValue");
+                    // 如果是在集合的话需要单独处理  比如 in
+                    if (valueObject instanceof List) {
+                        List valueObject1 = (List) valueObject;
+                        sb.append(condition + " ( ");
+                        flag = false;
+                        for (int k = 0; k < valueObject1.size(); k++) {
+                            if (flag) {
+                                sb.append(" , ");
+                            }
+                            Object o1 = valueObject1.get(i);
+                            paramsList.add(o1);
+                            sb.append(" ? ");
+                            flag = true;
+                        }
+                        sb.append(" )");
+                    } else {
+
+                        sb.append(condition);
+
+                        // is null , is not null
+                        if (!com.elab.core.utils.ObjectUtils.isEmpty(valueObject)) {
+                            paramsList.add(valueObject);
+                            sb.append(" ? ");
+                        }
+
+                        // between 的情况
+                        if (!com.elab.core.utils.ObjectUtils.isEmpty(secondValue)) {
+                            sb.append(" and ? ");
+                            paramsList.add(secondValue);
+                        }
+                    }
+                }
+            }
+        }
+        Object[] objects = paramsList.toArray();
+        logger.debug(" SQL - " + sb.toString() + " \n " + Arrays.toString(objects));
+        return null;
+    }
+
+
+    /**
+     * 删除第一个and
+     *
+     * @param sql
+     * @return
+     */
+    private String removeFirstAnd(String sql) {
+        if (StringUtils.isEmpty(sql)) {
+            return sql;
+        }
+        return sql.trim().toLowerCase().replaceAll("^\\s*and", "") + " ";
+    }
+
+
+    /**
+     * 查询执行方法
+     *
+     * @param statementName SQL的唯一编号
+     * @param sql           SQL执行的内容
+     * @param args          参数列表
+     * @return
+     */
+    private Object selectInvokeMethod(String statementName, String sql, Object[] args) throws Exception {
+        Class<?> returnType = this.method.getReturnType();
+        TypeGroupModel paramsByType = DataUtils.getParamsByType(this.method, args);
+        Object arg = args[0];
+        // 确定最终要执行的入参对象
+        // 这里的处理方式就是要么就是Map、要么就是Object、要么就是普通数组
+        if (paramsByType.getMap() != null && paramsByType.getMap().size() > 0) {
+            arg = paramsByType.getMap();
+        } else if (paramsByType.getObj() != null && paramsByType.getObj().length > 0) {
+            arg = paramsByType.getObj()[0];
+        }
+        // 构建SQL相关的对象信息
+        SqlInfoModel sqlInfo = getSqlInfo(statementName, sql, returnType, arg, paramsByType);
+        return processSelectSQL(sql, returnType, paramsByType, arg);
+    }
+
+    /**
+     * 执行查询SQL
+     *
+     * @param sql          SQL内容
+     * @param returnType   SQL的返回结果
+     * @param paramsByType SQL的特殊参数对象
+     * @param arg          SQL的正常参数对象
+     * @return
+     * @throws Exception
+     */
+    private Object processSelectSQL(String sql, Class<?> returnType, TypeGroupModel paramsByType, Object arg) throws Exception {
+        boolean returnsMany = (returnType == List.class);
+        boolean returnsMap = (returnType == Map.class);
+        boolean returnPage = (returnType == PageModel.class);
+        // 如果需要追加动态参数对象处理
+        ListDynamicSearch listDynamicSearch = paramsByType.getListDynamicSearch();
+        Class typeClass = getCacheMethodReturnClass();
+        // 是否是返回多个对象,例如List
+        if (returnsMany) {
+            if (typeClass == Map.class) {
+                return executorSqlByList(sql, arg, listDynamicSearch, typeClass);
+            } else {
+                RowMapper rowMapper = paramsByType.getRowMapper();
+                if (rowMapper == null) {
+                    return executorSqlByList(sql, arg, listDynamicSearch, typeClass);
+                } else {
+                    return executorSqlByList(sql, arg, listDynamicSearch, typeClass);
+                }
+            }
+        }
+        // 返回是Map的
+        else if (returnsMap) {
+            return executorSqlByList(sql, arg, listDynamicSearch, typeClass);
+        }
+        // 返回是分页对象的
+        else if (returnPage) {
+            arg = paramsByType.getObj().length == 0 ? paramsByType.getMap() : paramsByType.getObj()[0];
+            PageModel pageModel = paramsByType.getPageModel();
+
+            if (pageModel == null) {
+                throw new Exception(" PageModel is not null !!!");
+            }
+
+            String sqlCount = "select count(1) from ( " + sql + " ) a";
+            String sqlLimit = " " + sql + " " + pageModel.getOrderby() + "  limit " + (pageModel.getCount() - 1) * pageModel.getPageSize() + "," + pageModel.getPageSize();
+            List list = null;
+            if (typeClass == Map.class) {
+                list = (List) executorSqlByList(sql, pageModel, listDynamicSearch, typeClass);
+            } else {
+                list = (List) executorSqlByList(sql, pageModel, listDynamicSearch, typeClass);
+            }
+            pageModel.setResultSet(list);
+            return pageModel;
+        } else if (returnType == Integer.class || returnType == Long.class) {
+
+        } else {
+            if (returnType == Object.class) {
+                returnType = supperGenricType;
+            }
+            return executorSqlByObject(sql, arg, listDynamicSearch, returnType);
+        }
+        return null;
+    }
+
+    private <T> List<T> executorSqlByList(String sql, Object arg, ListDynamicSearch listDynamicSearch, Class<T> typeClass) throws Exception {
+        JdbcParamsModel jdbcParamsModel = commonParseSql(sql, arg, listDynamicSearch);
+        Object[] objects = jdbcParamsModel.getObjects();
+        //  select  postDate,id,message,user from posts where 1=1   and  user =?
+        String newSQL = jdbcParamsModel.getSql().replace("1=1   and", " ");
+        String formatMysql = SQLUtils.format(newSQL, "MYSQL", Arrays.asList(objects.clone())).replace("\n", " ");
+        ElasticSqlParseResult sqlParseResult = parser.parse(formatMysql);
+        SearchRequest searchRequest = sqlParseResult.getSearchRequest();
+        return this.beanInvoke.search(searchRequest, typeClass);
+    }
+
+    private <T> T executorSqlByObject(String sql, Object arg, ListDynamicSearch listDynamicSearch, Class<T> typeClass) throws Exception {
+        List<T> result = executorSqlByList(sql, arg, listDynamicSearch, typeClass);
+        return result.size() == 0 ? null : result.get(0);
+    }
+
+    private SearchResponse executorSQL(String sql, Object arg, ListDynamicSearch listDynamicSearch) throws Exception {
+        JdbcParamsModel jdbcParamsModel = commonParseSql(sql, arg, listDynamicSearch);
+        Object[] objects = jdbcParamsModel.getObjects();
+        //  select  postDate,id,message,user from posts where 1=1   and  user =?
+        String newSQL = jdbcParamsModel.getSql().replace("1=1   and", " ");
+        String formatMysql = SQLUtils.format(newSQL, "MYSQL", Arrays.asList(objects.clone())).replace("\n", " ");
+        ElasticSqlParseResult sqlParseResult = parser.parse(formatMysql);
+        SearchRequest searchRequest = sqlParseResult.getSearchRequest();
+        SearchResponse search = this.beanInvoke.search(searchRequest);
+        return search;
+    }
+
+    /**
+     * 构建SQL相关的信息对象
+     *
+     * @param statementName SQL的id
+     * @param sql           SQL的原始内容
+     * @param returnType    SQL的返回类型
+     * @param arg           SQL的参数
+     * @param paramsByType  SQL的特殊参数组对象
+     * @return
+     */
+    private SqlInfoModel getSqlInfo(String statementName, String sql, Class<?> returnType, Object arg,
+                                    TypeGroupModel paramsByType) {
+        SqlInfoModel sqlInfoModel = new SqlInfoModel();
+        sqlInfoModel.setTableName(this.entityOperation.tableName);
+        sqlInfoModel.setArgs(arg);
+        sqlInfoModel.setSql(sql);
+        sqlInfoModel.setReturnType(returnType);
+        sqlInfoModel.setSqlId(statementName);
+        sqlInfoModel.setReturnClass(getCacheMethodReturnClass());
+        sqlInfoModel.setParamGroup(paramsByType);
+        sqlInfoModel.setMapType(this.method.getGenericReturnType());
+        return sqlInfoModel;
+    }
+
+
+    /**
+     * 获取方法返回值
+     *
+     * @return
+     */
+    private Class getCacheMethodReturnClass() {
+        String methodName = this.method.getName();
+        Class typeClass = methodReturnCacheMap.get(methodName);
+        if (typeClass == null) {
+            Type type = this.method.getGenericReturnType();
+            typeClass = BeanUtils.getClassGenricType(type.getTypeName());
+            // 可能是父类interface的方法的情况
+            if (typeClass == null) {
+                typeClass = this.supperGenricType == null ? Map.class : this.supperGenricType;
+            } else {
+                methodReturnCacheMap.put(methodName, typeClass);
+            }
+        }
+        return typeClass;
+    }
+
+    /**
+     * 创建sql的执行方法
+     *
+     * @param statementName
+     * @return
+     * @throws Exception
+     */
+    private boolean createSql(String statementName) throws Exception {
+        List<ISQLBuliderSupport> sqlBuliderSupportList = getSqlBuilderSupportList();
+        String sql = "";
+        boolean isSQLNotNull = false;
+        for (int i = 0; i < sqlBuliderSupportList.size(); i++) {
+            // 执行每个sql构建器来匹配
+            ISQLBuliderSupport sqlBuilderSupport = sqlBuliderSupportList.get(i);
+            sql = sqlBuilderSupport.doCreateSQL(entityOperation, method);
+            if (!StringUtils.isEmpty(sql)) {
+                isSQLNotNull = true;
+                break;
+            }
+        }
+
+        // 注册到sql容器中
+        this.configurableFactory.getSqlConfigurableFactory().registerSqlMap(statementName, sql);
+        return isSQLNotNull;
+    }
+
+    public JdbcParamsModel commonParseSql(String sql, Object param, ListDynamicSearch search) throws Exception {
+        long start = System.currentTimeMillis();
+        JdbcParamsModel model = new JdbcParamsModel();
+        if (param instanceof String) {
+            model.setSql(sql);
+            model.setObjects(ArrayUtils.toArray(param));
+            logger.debug(" 转换后的sql - " + sql);
+            logger.debug(" 对应参数    -  " + param);
+            return model;
+        }
+        // 将sql和参数进行绑定
+        ParsedSql2 parsedSql = NamedParameterUtils2.parseSqlStatement(sql);
+        // 解析参数类型 , 这里会根据Map和Object对象做装换
+        SqlParameterSource sqlParameterSource = getSqlParameterSource(param);
+        // 获取有效的参数,将为null和""的参数给替换掉
+        Object[] data = NamedParameterUtils2.buildValueArray(parsedSql, sqlParameterSource, null);
+        // 正常解析sql为jdbc与参数对应
+        String s = NamedParameterUtils2.substituteNamedParameters(parsedSql, sqlParameterSource);
+        // 校验第一个参数为空的情况下
+        s = NamedParameterUtils2.validFirstCheckSql(sql, s, parsedSql, sqlParameterSource);
+        // 替换动态表名存在的情况下
+        s = NamedParameterUtils2.replaceDynamic(s, sqlParameterSource);
+
+        if (search != null) {
+            model = NamedParameterUtils2.appendSQLContent(s, data, search);
+        } else {
+            model.setSql(s);
+            model.setObjects(data);
+        }
+
+        logger.debug(" 转换后的sql - " + model.getSql());
+        logger.debug(" 对应参数    -  " + Arrays.toString(model.getObjects()));
+
+        long time = System.currentTimeMillis() - start;
+        logger.debug(" sql 语句处理耗时 : " + time);
+        return model;
+    }
+
+    /**
+     * 参数转换 , 参数类型分别为 Map,Model
+     *
+     * @param params
+     * @return
+     */
+    private SqlParameterSource getSqlParameterSource(Object params) {
+        SqlParameterSource sqlParameterSource = null;
+        if (params instanceof Map) {
+            sqlParameterSource = new MapSqlParameterSource((Map) params);
+        } else {
+            sqlParameterSource = new BeanPropertySqlParameterSource(params);
+        }
+        return sqlParameterSource;
+    }
+
+
+    public List<ISQLBuliderSupport> getSqlBuilderSupportList() {
+        return sqlBuilderSupportList;
+    }
+
+    public void setSqlBuilderSupportList(List<ISQLBuliderSupport> sqlBuilderSupportList) {
+        this.sqlBuilderSupportList = sqlBuilderSupportList;
+    }
+}

elab-es/src/test/java/com/elab/es/App.java

@@ -21,7 +21,7 @@ import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
 @SpringBootApplication
-@EnableElastaticSearch(basePackages = "com.elab.es.es", printregmsg = true)
+@EnableElastaticSearch(basePackages = "com.elab.es", printregmsg = true)
 public class App {
 
     public static void main(String[] args) {

elab-es/src/test/java/com/elab/es/client/spring/ElasticSearchScannerRegisterTest.java

@@ -0,0 +1,42 @@
+package com.elab.es.client.spring;
+
+import com.elab.es.App;
+import com.elab.es.client.annotation.EnableElastaticSearch;
+import com.elab.es.db.PostDao;
+import com.elab.es.model.Posts;
+import junit.framework.TestCase;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.Date;
+
+/**
+ * @Module TODO
+ * @Description TODO
+ * @Author liukaixiong
+ * @Date 2021/1/28 19:43
+ */
+@EnableElastaticSearch(basePackages = "com.elab.es.db")
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = App.class)
+public class ElasticSearchScannerRegisterTest extends TestCase {
+
+    @Autowired
+    private PostDao postDao;
+
+    @Test
+    public void getConfigurableFactory() throws Exception {
+        Posts posts = new Posts();
+//        posts.setId("1");
+        posts.setMessage("从前从前,有个人...");
+        posts.setPostDate(new Date());
+        posts.setUser("lkx");
+        postDao.insert(posts);
+
+        Posts posts1 = postDao.selectById("1");
+        System.out.println(posts1);
+    }
+}

elab-es/src/test/java/com/elab/es/config/ElabDBConfiguration.java

@@ -0,0 +1,34 @@
+package com.elab.es.config;
+
+import com.elab.es.client.configuration.ElabESProperties;
+import io.github.iamazy.elasticsearch.dsl.jdbc.ElasticConnectionDataSource;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import javax.sql.DataSource;
+
+/**
+ * @Module TODO
+ * @Description TODO
+ * @Author liukaixiong
+ * @Date 2021/1/29 14:25
+ */
+@Configuration
+public class ElabDBConfiguration {
+    String JDBC_DRIVER = "io.github.iamazy.elasticsearch.dsl.jdbc.ElasticDriver";
+    String DB_URL = "jdbc:es://localhost:9200/posts?useSSL=false&mode=single";
+
+    @Bean
+    public DataSource getDefaultDataSource(ElabESProperties props) throws Exception {
+        ElasticConnectionDataSource elasticConnectionDataSource = new ElasticConnectionDataSource(DB_URL, true);
+        elasticConnectionDataSource.setDriverClassName(JDBC_DRIVER);
+        java.util.Properties info = new java.util.Properties();
+        if (props.getUsername() != null) {
+            info.put("user", props.getUsername());
+        }
+        if (props.getPassword() != null) {
+            info.put("password", props.getPassword());
+        }
+        return elasticConnectionDataSource;
+    }
+}

elab-es/src/test/java/com/elab/es/data/ElabDbTest.java

@@ -0,0 +1,57 @@
+package com.elab.es.data;
+
+import com.elab.core.spring.DaoScannerRegister;
+import com.elab.core.spring.config.BasicDaoConfig;
+import com.elab.core.spring.config.JdbcBeanConfig;
+import com.elab.core.spring.config.TransactionConfigBean;
+import com.elab.es.App;
+import com.elab.es.config.ElabDBConfiguration;
+import com.elab.es.db.PostDbDao;
+import com.elab.es.model.Posts;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.Date;
+import java.util.List;
+
+/**
+ * @Module 持久层
+ * @Description 基于ELabDb测试
+ * @Author liukaixiong
+ * @Date 2021/1/29 14:23
+ */
+@Import({DaoScannerRegister.class, JdbcBeanConfig.class, BasicDaoConfig.class, TransactionConfigBean.class})
+//@EnableAutoConfiguration(exclude = {DataSourceConfigBean.class})
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = {App.class, ElabDBConfiguration.class})
+public class ElabDbTest {
+
+    @Autowired
+    PostDbDao postDbDao;
+
+    @Test
+    public void testInsert() throws Exception {
+        Posts posts = new Posts();
+        posts.setMessage("从前从前,有个人...");
+        posts.setPostDate(new Date());
+        posts.setUser("lkx");
+        int insert = postDbDao.insert(posts);
+
+        System.out.println(insert);
+    }
+
+    @Test
+    public void testQuery() throws Exception {
+        Posts posts = new Posts();
+        posts.setUser("某某某");
+        List<Posts> posts1 = postDbDao.selectByList(posts);
+
+        System.out.println(posts1);
+    }
+
+
+}

elab-es/src/test/java/com/elab/es/data/ElasticSQLAPITest.java

@@ -0,0 +1,483 @@
+package com.elab.es.data;//package com.elab.es.data;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson.parser.Feature;
+import com.elab.es.model.Posts;
+import io.github.iamazy.elasticsearch.dsl.sql.ElasticSql2DslParser;
+import io.github.iamazy.elasticsearch.dsl.sql.model.ElasticSqlParseResult;
+import org.elasticsearch.client.RestHighLevelClient;
+import org.junit.Test;
+import org.zxp.esclientrhl.repository.ElasticsearchTemplateImpl;
+
+import java.sql.*;
+import java.util.function.Supplier;
+
+/**
+ * @Module TODO
+ * @Description TODO
+ * @Author liukaixiong
+ * @Date 2021/1/29 15:34
+ */
+public class ElasticSQLAPITest {
+
+    static final String JDBC_DRIVER = "io.github.iamazy.elasticsearch.dsl.jdbc.ElasticDriver";
+    static final String DB_URL = "jdbc:es://localhost:9200/posts?useSSL=false&mode=single";
+    ElasticSql2DslParser parser = new ElasticSql2DslParser();
+    private RestHighLevelClient restHighLevelClient;
+    private ElasticsearchTemplateImpl<Posts, String> elasticsearchTemplate;
+
+//    @Before
+//    public void before() throws Exception {
+////        client = new RestHighLevelClient(
+////                RestClient.builder(
+////                        new HttpHost("localhost", 9200, "http")));
+////                        new HttpHost("192.168.0.24", 9200, "http")));
+//        String host = "localhost";
+//        String port = "9300";
+//        TransportAddress transportAddress = new TransportAddress(InetAddress.getByName(host), Integer.parseInt(port));
+//        Settings settings = Settings.builder().put("client.transport.ignore_cluster_name", true).build();
+//    }
+
+    @Test
+    public void connect() {
+        Connection conn = null;
+        Statement stmt = null;
+        try {
+            Class.forName(JDBC_DRIVER);
+            conn = DriverManager.getConnection(DB_URL, null, null);
+            stmt = conn.createStatement();
+            String sql;
+            sql = "SELECT postDate, id, message, user FROM posts WHERE id = '1'";
+            ResultSet rs = stmt.executeQuery(sql);
+            while (rs.next()) {
+                String id = rs.getString("_id");
+                String name = rs.getString("name");
+                String url = rs.getString("list");
+                System.out.print("ID: " + id);
+                System.out.print(", 站点名称: " + name);
+                System.out.print(", 站点 URL: " + url);
+                System.out.print("\n");
+            }
+            rs.close();
+            stmt.close();
+            conn.close();
+        } catch (Exception se) {
+            se.printStackTrace();
+        } finally {
+            try {
+                if (stmt != null) stmt.close();
+            } catch (SQLException ignored) {
+            }
+            try {
+                if (conn != null) conn.close();
+            } catch (SQLException se) {
+                se.printStackTrace();
+            }
+        }
+    }
+
+
+    @Test
+    public void parse() {
+        long now = System.currentTimeMillis();
+        String sql = "select name,^h!age,h!gender from student where ((a in (1,2,3,4)) and has_parent(apple,bb~='fruit')) and c=1 and (location.coordinate = [40.0,30.0] and distance = '1km' or t='bb') limit 2,5";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void nested() {
+        long now = System.currentTimeMillis();
+        String sql = "select name from student where (([class1, age>1 and [class1.class2, name='hhha']] and c=1) or b~=='hhhhh') and query by 'apppple' limit 2,5";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void nested2() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from class where [student,student.name is null]";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void exists() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from student where name is not null and age >15";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        parseResult.toPrettyDsl(parseResult.getSearchRequest());
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void group() {
+        long now = System.currentTimeMillis();
+        String sql = "select name from student aggregate by terms(name,1)>(terms(aa,2),terms(bb,3)>(terms(cc,4))),terms(age,10)>(terms(weight,10))";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void nestedAgg() {
+        long now = System.currentTimeMillis();
+        String sql = "select name from student aggregate by terms(name,1)>(terms(aa,2),[apple,cardinality(ip),terms(aaa,1)>(terms(bb,1),terms(cc,10)>(terms(hh,3),avg(age)),terms(vv,1))]) limit 2,5";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void distinct() {
+        String sql = "select distinct name from student where a like '%appl%' limit 2,5";
+
+        ElasticSqlParseResult parseResult = time("1", () -> {
+            return parser.parse(sql);
+        });
+
+        time("2", () -> {
+            System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+            return null;
+        });
+
+    }
+
+
+    public <T> T time(String key, Supplier<T> supplier) {
+        long start = System.currentTimeMillis();
+        T o = supplier.get();
+        long time = System.currentTimeMillis() - start;
+        System.out.println("--->>>>" + time);
+        return o;
+    }
+
+    @Test
+    public void betweenAnd() {
+        long now = System.currentTimeMillis();
+        String sql = "select distinct name from student where a between 'dfsfsd' and 'ffff' aggregate by [apple,terms(a,1)],terms(b,1) limit 2,5";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void betweenAnd2() {
+        long now = System.currentTimeMillis();
+        String sql = "select distinct name from student where a ranged in (1,2] aggregate by [apple,terms(a,1)],terms(b,1) limit 2,5";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void agg1() {
+        long now = System.currentTimeMillis();
+        String sql = "select distinct h!name,h!age from student aggregate by [apple,terms(a,1)],terms(bb,2),cardinality(ip) limit 2,5";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void agg2() {
+        long now = System.currentTimeMillis();
+        String sql = "select distinct name from student aggregate by terms(bb,2)>([apple,terms(a,1)]),cardinality(ip) limit 2,5";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void agg3() {
+        long now = System.currentTimeMillis();
+        String sql = "select distinct name from student aggregate by terms(bb,2)>([apple,terms(a,1)],cardinality(ip)) limit 2,5";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void agg4() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from student aggregate by terms(bb,2)>(terms(cc,2)),[apple,terms(a,1)],cardinality(ip) limit 2,5";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void compositeAgg() {
+
+    }
+
+    @Test
+    public void desc() {
+        long now = System.currentTimeMillis();
+        String sql = "describe student/xiaoming";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.getFieldMappingsRequest());
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void functionScore() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from student where h!age> 10 and h!weight between 80 and 90 and color = 'red' func_score high > 160 && name ='小明' aggregate by terms(name,10),terms(age,10)>(cardinality(clazz))";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void multiMatch() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from student where (name,age) ~= 'hahah'";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void reindex() {
+        long now = System.currentTimeMillis();
+        String sql = "insert into port_info_v1 select * from port_info where a=1";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.getReindexRequest());
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void highlighter() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from student where (h!name,age) ~= 'hahah' and h!ab='haliluya'";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void geoDistance() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from student where location.coordinate=[40,30] and distance='100km' ";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void geoBoundingBox() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from student where location.coordinate between [30,70] and [20,50]";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void geoPolygon() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from student where location.coordinate in [[30.132,50],[40,60],[50,212]]";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void geoShape() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from student where location.coordinate within [[10,11],[21,22]] shaped as envelope";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void geoShape2() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from student where location.coordinate contains [[[10,10],[20,20]],[[11,11],[21,21]]] shaped as multilinestring";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void geoShape3() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from student where location.coordinate within [10,10] shaped as point";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void geoShape4() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from student where location.coordinate intersects [[[10,10],[20,20],[11,11],[10,10]]] shaped as polygon";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void geoShape5() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from student where location.coordinate disjoint [[[[10,10],[22,21],[11,11],[10,10]]],[[[10,10],[20,20],[11,11],[10,10]]]] shaped as multipolygon ";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void geoShape6() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from student where location.coordinate disjoint `{\"coordinates\": [[-155.52, 19.61], [-156.22, 20.74], [-157.97, 21.46]], \"type\": \"linestring\"}`";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void groupBy() {
+        long now = System.currentTimeMillis();
+        String sql = "select max(name) as max_name,avg(height) as avg_height,avg(name) as avg_name,min(name) as min_name from student group by name,age,height";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void disMax() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from student dis_max age>11 || name='小米宁' and ( height>1.6 or fruit ='apple') || firstName is not null and tie_breaker=0.7";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void trackTotalHits() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from aaa where resCategory='port_info' aggregate by terms(deviceInfo.deviceType,10) limit 0 track total";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void fuzzyLike() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from aaa where resCategory fuzzy like'port_info'";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void wildcardLike() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from aaa where resCategory wildcard like 'port_info'";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void prefixLike() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from aaa where resCategory prefix like 'port_info'";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void regexpLike() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from aaa where resCategory regexp like 'port*'";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void like() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from aaa where resCategory like 'port*'";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void not() {
+        long now = System.currentTimeMillis();
+        String sql = "select * from aaa where (not resCategory ~=== 'port*') or aa ~='apple'";
+
+        ElasticSqlParseResult parseResult = parser.parse(sql);
+        System.out.println(parseResult.toPrettyDsl(parseResult.getSearchRequest()));
+        System.out.println(System.currentTimeMillis() - now);
+    }
+
+    @Test
+    public void dataParse() {
+        String json = " {\n" +
+                "    mts:'1353358',\n" +
+                "    province:'广东',\n" +
+                "    catName:'中国移动',\n" +
+                "    telString:'13533588275',\n" +
+                "  areaVid:'30517',\n" +
+                "  ispVid:'3236139',\n" +
+                "  carrier:'广东移动'\n" +
+                "}";
+        JSONObject jsonObject = JSON.parseObject(json, Feature.AllowUnQuotedFieldNames);
+
+        String s = jsonObject.toJSONString();
+
+        jsonObject = JSON.parseObject(s, Feature.AllowUnQuotedFieldNames);
+
+        System.out.println(jsonObject);
+
+    }
+
+
+}

elab-es/src/test/java/com/elab/es/data/ElasticSearchSQLAPITest.java

@@ -0,0 +1,65 @@
+//package com.elab.es.data;
+//
+//import com.elab.es.model.Posts;
+//import org.elasticsearch.action.ActionRequest;
+//import org.elasticsearch.client.RestHighLevelClient;
+//import org.elasticsearch.client.transport.TransportClient;
+//import org.elasticsearch.common.settings.Settings;
+//import org.elasticsearch.common.transport.TransportAddress;
+//import org.elasticsearch.plugin.nlpcn.QueryActionElasticExecutor;
+//import org.elasticsearch.xpack.client.PreBuiltXPackTransportClient;
+//import org.junit.Before;
+//import org.junit.Test;
+//import org.nlpcn.es4sql.SearchDao;
+//import org.nlpcn.es4sql.jdbc.ObjectResult;
+//import org.nlpcn.es4sql.jdbc.ObjectResultsExtractor;
+//import org.nlpcn.es4sql.query.QueryAction;
+//import org.zxp.esclientrhl.repository.ElasticsearchTemplateImpl;
+//
+//import java.net.InetAddress;
+//
+///**
+// * @Module TODO
+// * @Description TODO
+// * @Author liukaixiong
+// * @Date 2021/1/29 15:34
+// */
+//public class ElasticSearchSQLAPITest {
+//
+//    private SearchDao searchDao;
+//
+//    private RestHighLevelClient restHighLevelClient;
+//    private ElasticsearchTemplateImpl<Posts, String> elasticsearchTemplate;
+//    private TransportClient client;
+//
+//    @Before
+//    public void before() throws Exception {
+////        client = new RestHighLevelClient(
+////                RestClient.builder(
+////                        new HttpHost("localhost", 9200, "http")));
+////                        new HttpHost("192.168.0.24", 9200, "http")));
+//        String host = "localhost";
+//        String port = "9300";
+//        TransportAddress transportAddress = new TransportAddress(InetAddress.getByName(host), Integer.parseInt(port));
+//        Settings settings = Settings.builder().put("client.transport.ignore_cluster_name", true).build();
+//        client = new PreBuiltXPackTransportClient(settings).addTransportAddress(transportAddress);
+//        searchDao = new SearchDao(client);
+//    }
+//
+//
+//    @Test
+//    public void parseSQLSelectTest() throws Exception {
+//
+//        String sql = "select * from posts where user like '某%'";
+//        QueryAction explain = searchDao.explain(sql);
+//        ActionRequest request = explain.explain().request();
+//        // restHighLevelClient.search(request,null);
+////        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("", "");
+////        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("", "");
+//        Object execution = QueryActionElasticExecutor.executeAnyAction(searchDao.getClient(), explain);
+//        ObjectResult result = (new ObjectResultsExtractor(true, true, true, false, explain)).extractResults(execution, false);
+//        System.out.println(result);
+//    }
+//
+//
+//}

elab-es/src/test/java/com/elab/es/data/ElasticsearchTemplateImplCase.java

@@ -1,5 +1,9 @@
 package com.elab.es.data;
 
+import com.alibaba.druid.sql.ast.SQLStatement;
+import com.alibaba.druid.sql.dialect.mysql.parser.MySqlStatementParser;
+import com.alibaba.druid.sql.dialect.mysql.visitor.MySqlSchemaStatVisitor;
+import com.alibaba.druid.sql.parser.SQLStatementParser;
 import com.alibaba.fastjson.JSON;
 import com.elab.es.App;
 import com.elab.es.model.Posts;
@@ -54,7 +58,21 @@ public class ElasticsearchTemplateImplCase {
 
     @Test
     public void querySQL() throws Exception {
-        String s = searchTemplate.queryBySQL("select message from posts limit 5", SqlFormat.TXT);
+//        String sql = "select message from posts limit 5";
+//        String sql = "select message from posts where user like '%某'";
+//        String sql = "select message from posts where user in ('某某某','测试')";
+        String sql = "SELECT postDate, id, message, user FROM posts WHERE user = '某某某'";
+        SQLStatementParser parser = new MySqlStatementParser(sql);
+        SQLStatement statement = parser.parseStatement();
+        MySqlSchemaStatVisitor visitor = new MySqlSchemaStatVisitor();
+        statement.accept(visitor);
+
+        String s = searchTemplate.queryBySQL(sql, SqlFormat.JSON);
+        String s1 = searchTemplate.queryBySQL(sql, SqlFormat.TXT);
+        String s2 = searchTemplate.queryBySQL(sql, SqlFormat.CBOR);
+        String s3 = searchTemplate.queryBySQL(sql, SqlFormat.YAML);
+        String s4 = searchTemplate.queryBySQL(sql, SqlFormat.SMILE);
+        String s5 = searchTemplate.queryBySQL(sql, SqlFormat.TSV);
         System.out.println(s);
     }
 
@@ -103,7 +121,6 @@ public class ElasticsearchTemplateImplCase {
         message.setPostTag("</em>");
         psh.setHighLight(message);
 
-
         PageList<Posts> pageList = new PageList<>();
         MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("message", "我");
         pageList = searchTemplate.search(matchQueryBuilder, psh, Posts.class);

elab-es/src/test/java/com/elab/es/data/EsProxyDaoTest.java

@@ -0,0 +1,35 @@
+package com.elab.es.data;
+
+import com.elab.es.App;
+import com.elab.es.db.PostDao;
+import com.elab.es.model.Posts;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.List;
+
+/**
+ * @Module TODO
+ * @Description TODO
+ * @Author liukaixiong
+ * @Date 2021/2/2 14:12
+ */
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = {App.class})
+public class EsProxyDaoTest {
+
+    @Autowired
+    PostDao postDbDao;
+
+    @Test
+    public void testQuery() throws Exception {
+        Posts posts = new Posts();
+        posts.setUser("某");
+        List<Posts> posts1 = postDbDao.selectByList(posts);
+
+        System.out.println(posts1);
+    }
+}

elab-es/src/test/java/com/elab/es/data/RestHighLevelClientTest.java

@@ -58,8 +58,8 @@ public class RestHighLevelClientTest {
     public void before() {
         client = new RestHighLevelClient(
                 RestClient.builder(
-//                        new HttpHost("localhost", 9200, "http"),
-                        new HttpHost("192.168.0.24", 9200, "http")));
+                        new HttpHost("localhost", 9200, "http")));
+//                        new HttpHost("192.168.0.24", 9200, "http")));
     }
 
     @Test

elab-es/src/test/java/com/elab/es/data/SQLParseTest.java

@@ -0,0 +1,51 @@
+//package com.elab.es.data;
+//
+//import com.alibaba.druid.sql.ast.SQLExpr;
+//import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
+//import com.elab.es.model.Posts;
+//import com.sun.org.apache.bcel.internal.generic.Select;
+//import org.elasticsearch.client.RestHighLevelClient;
+//import org.junit.BeforeClass;
+//import org.junit.Test;
+//import org.zxp.esclientrhl.index.ElasticsearchIndex;
+//import org.zxp.esclientrhl.repository.ElasticsearchTemplateImpl;
+//
+//import java.util.List;
+//
+///**
+// * @Module TODO
+// * @Description TODO
+// * @Author liukaixiong
+// * @Date 2021/1/29 15:17
+// */
+//
+//public class SQLParseTest {
+//    private ElasticsearchTemplateImpl<Posts, String> searchTemplate;
+//    private ElasticsearchIndex<Posts> searchIndex;
+//    private RestHighLevelClient client;
+//    private static SqlParser parser;
+//
+//    @BeforeClass
+//    public static void init() {
+//        parser = new SqlParser();
+//    }
+//
+//    @Test
+//    public void joinParseCheckConnectedFields() throws SqlParseException {
+//        String sql = "select * from t_test where username like '%abc%'";
+//        Select select = parser.parseSelect((SQLQueryExpr) queryToExpr(sql));
+//
+//    }
+//
+//    private boolean fieldExist(List<Field> fields, String fieldName) {
+//        for (Field field : fields)
+//            if (field.getName().equals(fieldName)) return true;
+//
+//        return false;
+//    }
+//
+//    private SQLExpr queryToExpr(String query) {
+//        return new ElasticSqlExprParser(query).expr();
+//    }
+//}
+//

elab-es/src/test/java/com/elab/es/db/PostDao.java

@@ -0,0 +1,13 @@
+package com.elab.es.db;
+
+import com.elab.es.client.db.IElasticSearchSupport;
+import com.elab.es.model.Posts;
+
+/**
+ * @Module TODO
+ * @Description TODO
+ * @Author liukaixiong
+ * @Date 2021/1/28 19:44
+ */
+public interface PostDao  extends IElasticSearchSupport<Posts,Object> {
+}

elab-es/src/test/java/com/elab/es/db/PostDbDao.java

@@ -0,0 +1,13 @@
+package com.elab.es.db;
+
+import com.elab.core.dao.IBaseDaoSupport;
+import com.elab.es.model.Posts;
+
+/**
+ * @Module TODO
+ * @Description TODO
+ * @Author liukaixiong
+ * @Date 2021/1/28 19:44
+ */
+public interface PostDbDao extends IBaseDaoSupport<Posts> {
+}

elab-es/src/test/java/com/elab/es/jdbc/JdbcTest.java

@@ -0,0 +1,26 @@
+package com.elab.es.jdbc;
+
+/**
+ * @Module TODO
+ * @Description TODO
+ * @Author liukaixiong
+ * @Date 2021/1/28 16:47
+ */
+public class JdbcTest {
+
+    public void testJDBC() throws Exception {
+//        Properties properties = new Properties();
+//        properties.put("url", "jdbc:elasticsearch://127.0.0.1:9300/" + TestsConstants.TEST_INDEX);
+//        DruidDataSource dds = (DruidDataSource) ElasticSearchDruidDataSourceFactory.createDataSource(properties);
+//        Connection connection = dds.getConnection();
+//        PreparedStatement ps = connection.prepareStatement("SELECT  gender,lastname,age from  " + TestsConstants.TEST_INDEX + " where lastname='Heath'");
+//        ResultSet resultSet = ps.executeQuery();
+//        List<String> result = new ArrayList<String>();
+//        while (resultSet.next()) {
+//            System.out.println(resultSet.getString("lastname") + "," + resultSet.getInt("age") + "," + resultSet.getString("gender"))
+//        }
+//        ps.close();
+//        connection.close();
+//        dds.close();
+    }
+}

elab-es/src/test/java/com/elab/es/model/PostEntity.java

@@ -0,0 +1,12 @@
+package com.elab.es.model;
+
+/**
+ * @Module TODO
+ * @Description TODO
+ * @Author liukaixiong
+ * @Date 2021/1/28 19:44
+ */
+public class PostEntity {
+
+
+}

elab-es/src/test/java/com/elab/es/model/Posts.java

@@ -1,10 +1,13 @@
 package com.elab.es.model;
 
+import com.elab.core.dao.row.ColumnMapping;
 import org.zxp.esclientrhl.annotation.ESID;
 import org.zxp.esclientrhl.annotation.ESMetaData;
 
+import javax.persistence.Table;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.util.Date;
-import java.util.UUID;
 
 /**
  * 测试
@@ -14,10 +17,17 @@ import java.util.UUID;
  * @email liukx@elab-plus.com
  **/
 @ESMetaData(indexName = "posts", indexType = "_doc", printLog = true)
-public class Posts {
+@Table(name = "posts")
+public class Posts implements ColumnMapping {
+
+
+    @Override
+    public void mappingColumn(ResultSet rs) throws SQLException {
+        System.out.println("===>>>" + rs);
+    }
 
     @ESID
-    private String id = UUID.randomUUID().toString();
+    private String id;
 
     private String user;
 

elab-es/src/test/resources/application.yml

@@ -3,9 +3,12 @@
 #    rest:
 #      uris: http://192.168.0.24:9100
 
+#elab:
+#  elasticsearch:
+#    jest:
+#      uris: es-cn-0pp1jc07f001i1t59.public.elasticsearch.aliyuncs.com:9200
+#      username: elastic
+#      password: elab@123
 elab:
-  elasticsearch:
-    jest:
-      uris: es-cn-0pp1jc07f001i1t59.public.elasticsearch.aliyuncs.com:9200
-      username: elastic
-      password: elab@123
+  es:
+    uris: 127.0.0.1:9200

elab-log/src/main/java/com/elab/log/factory/CatThreadFactory.java

@@ -0,0 +1,29 @@
+package com.elab.log.factory;
+
+import com.dianping.cat.Cat;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ThreadFactory;
+
+/**
+ * @Module 工厂模块
+ * @Description cat对应的处理工厂
+ * @Author liukaixiong
+ * @Date 2021/1/15 18:39
+ */
+public class CatThreadFactory extends CompletableFuture implements ThreadFactory {
+    private Logger logger = LoggerFactory.getLogger(getClass());
+
+
+    @Override
+    public Thread newThread(Runnable r) {
+        String currentMessageId = Cat.getCurrentMessageId();
+        System.out.println("=====================" + currentMessageId);
+        return new Thread(r);
+    }
+
+
+
+}

elab-log/src/test/java/com/elab/log/factory/CatThreadFactoryTest.java

@@ -0,0 +1,32 @@
+package com.elab.log.factory;
+
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import org.junit.Test;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @Module TODO
+ * @Description TODO
+ * @Author liukaixiong
+ * @Date 2021/1/15 18:43
+ */
+public class CatThreadFactoryTest   {
+    ExecutorService executorService = new ThreadPoolExecutor(1, 50,
+            0L, TimeUnit.MILLISECONDS,
+            new ArrayBlockingQueue<>(5000), new ThreadFactoryBuilder().setThreadFactory(new CatThreadFactory()).setNameFormat("async_handle_%d").setDaemon(false).build());
+
+    @Test
+    public void newThread() throws Exception {
+        for (int i = 0; i < 100; i++) {
+            executorService.execute(() -> {
+                System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
+            });
+        }
+        System.in.read();
+
+    }
+}

elab-redis/src/main/java/com/elab/redis/interceptor/impl/CacheLoopProcessImpl.java

@@ -66,13 +66,13 @@ public class CacheLoopProcessImpl implements ICacheProcessService {
 
         RLock lockObject = client.getLock(cacheName);
 
-        String errorMsg = cacheLoopSubmit.errorMsg();
-
         try {
             if (tryLock(lockObject, cacheLoopSubmit)) {
                 Object proceed = invocation.proceed();
                 return proceed;
             } else {
+                String errorMsg = cacheLoopSubmit.errorMsg();
+                logger.warn("触发重复提交条件:" + cacheName);
                 throw new ReSubmitException(errorMsg);
             }
         } catch (InterruptedException e) {

elab-redis/src/test/java/com/elab/redis/spring/SpringDataTest.java

@@ -11,6 +11,7 @@ import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
 
 import java.io.IOException;
+import java.util.Set;
 
 /**
  * springData
@@ -117,6 +118,17 @@ public class SpringDataTest extends RedisSpringBoot {
 //
 //        System.out.println("OK");
 //        System.in.read();
+    }
+
+    @Test
+    public void del() {
 
+        String prefKey = "gateway:LOGIN:TOKEN:token:ecrm*";
+        Set<String> keys = redisTemplate.keys(prefKey);
+        redisTemplate.delete(keys);
+        System.out.println(keys);
+//        List<String> delKey = new ArrayList<>();
+//
+//        redisTemplate.delete(Arrays.asList(""));
     }
 }

elab-redis/src/test/resources/application.yml

@@ -1,6 +1,6 @@
 spring:
   redis:
-    database: 1
+    database: 10
     host: r-uf6e60u5cmlj0sx563pd.redis.rds.aliyuncs.com
     password: xcGm4kTks6
     port: 6379

elab-spring/src/main/java/com/elab/spring/utils/ThreadProcessUtils.java

@@ -109,7 +109,7 @@ public class ThreadProcessUtils implements ApplicationContextAware, Initializing
     }
 
     /**
-     * 多任务并行处理,并按照key分组后返回结果
+     * 多任务并行处理,并按照key分组后返回结AuthMobileDataHandleConsumer果
      *
      * @param isBlockResult 是否阻塞返回结果集
      * @param taskGroupMap  任务分组map
@@ -124,9 +124,9 @@ public class ThreadProcessUtils implements ApplicationContextAware, Initializing
     /**
      * 异步调用
      *
-     * @param isBlockResult
-     * @param taskGroupMap
-     * @param timeOutMs
+     * @param isBlockResult     是否阻塞直到结果获取完成
+     * @param taskGroupMap      任务组
+     * @param timeOutMs         等待获取时间
      * @param <U>
      * @return
      * @throws Exception