重新定位版本号，并为mongo重新添加监控埋点

elab-alert/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>elab-parent</artifactId>
         <groupId>com.elab.core</groupId>
-        <version>2.0.5.3-SNAPSHOT</version>
+        <version>3.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <artifactId>elab-alert</artifactId>

elab-annotation/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>elab-parent</artifactId>
         <groupId>com.elab.core</groupId>
-        <version>2.0.5.3-SNAPSHOT</version>
+        <version>3.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

elab-cache/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <groupId>com.elab.core</groupId>
         <artifactId>elab-parent</artifactId>
-        <version>2.0.5.3-SNAPSHOT</version>
+        <version>3.0.0-SNAPSHOT</version>
     </parent>
     <groupId>com.elab.cache</groupId>
     <artifactId>elab-cache</artifactId>

elab-core/pom.xml

@@ -7,7 +7,7 @@
     <parent>
         <groupId>com.elab.core</groupId>
         <artifactId>elab-parent</artifactId>
-        <version>2.0.5.3-SNAPSHOT</version>
+        <version>3.0.0-SNAPSHOT</version>
     </parent>
 
     <groupId>com.elab.core</groupId>

elab-core/src/main/java/com/elab/core/componts/chains/ChainConsumer.java

@@ -0,0 +1,9 @@
+package com.elab.core.componts.chains;
+
+/**
+ * @param <I>
+ * @param <T>
+ */
+public interface ChainConsumer<I, T> {
+    void run(I apply, T req, ComponentConsumerHandlerChain<I, T> chain);
+}

elab-core/src/main/java/com/elab/core/componts/chains/ChainSupplier.java

@@ -0,0 +1,11 @@
+package com.elab.core.componts.chains;
+
+/**
+ * @param <I>
+ * @param <T>
+ * @param <R>
+ */
+public interface ChainSupplier<I, T, R> {
+    R executor(I apply, T req, ComponentSupplierHandlerChain<I, T, R> chain);
+
+}

elab-core/src/main/java/com/elab/core/componts/chains/ComponentConsumerHandlerChain.java

@@ -0,0 +1,35 @@
+package com.elab.core.componts.chains;
+
+import java.util.List;
+import java.util.function.Consumer;
+
+/**
+ * 通用的组件处理链
+ *
+ * @param <I> 处理的接口handler类型
+ * @param <T> 入参类型
+ */
+public class ComponentConsumerHandlerChain<I, T> {
+
+    private final List<I> handlerList;
+    private final Consumer<T> consumer;
+
+    private int currentHandlerIndex = -1;
+
+    public ComponentConsumerHandlerChain(List<I> handlerList, Consumer<T> consumer) {
+        this.handlerList = handlerList;
+        this.consumer = consumer;
+    }
+
+    public void run(T req, ChainConsumer<I, T> chainConsumer) {
+
+        if (this.currentHandlerIndex == this.handlerList.size() - 1) {
+            this.consumer.accept(req);
+            return;
+        }
+
+        I handler = this.handlerList.get(++this.currentHandlerIndex);
+        chainConsumer.run(handler, req, this);
+    }
+
+}

elab-core/src/main/java/com/elab/core/componts/chains/ComponentSupplierHandlerChain.java

@@ -0,0 +1,35 @@
+package com.elab.core.componts.chains;
+
+import java.util.List;
+import java.util.function.Supplier;
+
+/**
+ * 通用的组件处理链
+ *
+ * @param <I> 处理的接口handler类型
+ * @param <T> 入参类型
+ * @param <R> 出参类型
+ */
+public class ComponentSupplierHandlerChain<I, T, R> {
+
+    protected final List<I> handlerList;
+    protected final Supplier<R> supplier;
+
+    private int currentHandlerIndex = -1;
+
+    public ComponentSupplierHandlerChain(List<I> handlerList, Supplier<R> supplier) {
+        this.handlerList = handlerList;
+        this.supplier = supplier;
+    }
+
+    public R executor(T req, ChainSupplier<I, T, R> chainFunction) {
+
+        if (this.currentHandlerIndex == this.handlerList.size() - 1) {
+            return supplier.get();
+        }
+
+        I handler = this.handlerList.get(++this.currentHandlerIndex);
+        return chainFunction.executor(handler, req, this);
+    }
+
+}

elab-db/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>com.elab.core</groupId>
         <artifactId>elab-parent</artifactId>
-        <version>2.0.5.3-SNAPSHOT</version>
+        <version>3.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <artifactId>elab-db</artifactId>

elab-es/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>elab-parent</artifactId>
         <groupId>com.elab.core</groupId>
-        <version>2.0.5.3-SNAPSHOT</version>
+        <version>3.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

elab-kafka/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>elab-parent</artifactId>
         <groupId>com.elab.core</groupId>
-        <version>2.0.5.3-SNAPSHOT</version>
+        <version>3.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

elab-log/pom.xml

@@ -7,7 +7,7 @@
     <parent>
         <groupId>com.elab.core</groupId>
         <artifactId>elab-parent</artifactId>
-        <version>2.0.5.3-SNAPSHOT</version>
+        <version>3.0.0-SNAPSHOT</version>
     </parent>
 
     <groupId>com.elab.log</groupId>

elab-log/src/main/java/com/elab/log/log4j/CatLogbackLog.java

@@ -55,7 +55,7 @@ public class CatLogbackLog extends AppenderBase<ILoggingEvent> {
      * @param event
      */
     private void logError(ILoggingEvent event) {
-        ThrowableProxy info = (ThrowableProxy) event.getThrowableProxy();
+        ThrowableProxy info = (ThrowableProxy)event.getThrowableProxy();
         if (info != null) {
             Throwable exception = info.getThrowable();
             Object message = event.getMessage();
@@ -65,25 +65,11 @@ public class CatLogbackLog extends AppenderBase<ILoggingEvent> {
                 Cat.logError(exception);
             }
         }
-
     }
 
     private void logTrace(ILoggingEvent event) {
         String name = event.getLevel().toString();
-        Object message = event.getMessage();
-        String data;
-        if (message instanceof Throwable) {
-            data = this.buildExceptionStack((Throwable) message);
-        } else {
-            data = event.getMessage().toString();
-        }
-// DEBUG 的异常不打印
-//        ThrowableProxy info = (ThrowableProxy) event.getThrowableProxy();
-//        if (info != null) {
-//            data = data + '\n' + this.buildExceptionStack(info.getThrowable());
-//            Cat.logError(data, info.getThrowable());
-//            return;
-//        }
+        String data = event.getFormattedMessage();
         Cat.logEvent(type, name, "0", formatShowData(data));
     }
 

elab-mongodb/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>elab-parent</artifactId>
         <groupId>com.elab.core</groupId>
-        <version>2.0.5.3-SNAPSHOT</version>
+        <version>3.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -39,6 +39,11 @@
             <artifactId>spring-data-mongodb</artifactId>
             <version>1.10.11.RELEASE</version>
         </dependency>
+        <dependency>
+            <groupId>com.elab.log</groupId>
+            <artifactId>elab-log</artifactId>
+            <version>${project.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-autoconfigure</artifactId>

elab-mongodb/src/main/java/com/elab/mongodb/BaseMongodb.java

@@ -1,8 +1,11 @@
 package com.elab.mongodb;
 
 import cn.hutool.core.bean.BeanUtil;
+import com.alibaba.fastjson.JSON;
 import com.mongodb.WriteResult;
 import org.apache.commons.beanutils.BeanUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.data.mongodb.core.MongoTemplate;
 import org.springframework.data.mongodb.core.query.Criteria;
 import org.springframework.data.mongodb.core.query.Query;
@@ -21,6 +24,8 @@ import java.util.Map;
  **/
 public abstract class BaseMongodb<T> {
 
+    private final Logger LOGGER = LoggerFactory.getLogger(getClass());
+
     /**
      * 由客户端指定对应的MongoTemplate数据源定义
      *
@@ -34,6 +39,7 @@ public abstract class BaseMongodb<T> {
      * @param entity
      */
     public void save(T entity) {
+        LOGGER.debug(" save request : {}", jsonToString(entity));
         if (getCollectionName() == null) {
             getMongoTemplate().save(entity);
         } else {
@@ -47,6 +53,7 @@ public abstract class BaseMongodb<T> {
      * @param entity
      */
     public void batchSave(List<T> entity) {
+        LOGGER.debug(" save batch request : {}", entity.size());
         if (getCollectionName() == null) {
             getMongoTemplate().insertAll(entity);
         } else {
@@ -67,7 +74,7 @@ public abstract class BaseMongodb<T> {
      * @return
      */
     protected String getCollectionName() {
-        return null;
+        return "user";
     }
 
     /**
@@ -78,6 +85,7 @@ public abstract class BaseMongodb<T> {
      * @throws Exception
      */
     public boolean exists(T entity) throws Exception {
+        LOGGER.debug(" mongo exists : {} ", jsonToString(entity));
         Query query = beanForQuery(entity);
         boolean exists = false;
         if (getCollectionName() == null) {
@@ -96,7 +104,6 @@ public abstract class BaseMongodb<T> {
      * @throws Exception
      */
     public Long count(T entity) throws Exception {
-
         return count(entity, getCollectionName());
     }
 
@@ -109,6 +116,7 @@ public abstract class BaseMongodb<T> {
      * @throws Exception
      */
     public Long count(T entity, String collectionName) throws Exception {
+        LOGGER.debug(" 调用mongo的count方法 : {}", jsonToString(entity));
         Query query = beanForQuery(entity);
         long count = 0;
         if (collectionName == null) {
@@ -131,7 +139,7 @@ public abstract class BaseMongodb<T> {
 
         Assert.notNull(id, "id is not null!");
         Assert.notNull(entity, "entity is not null!");
-
+        LOGGER.debug(" 调用mongo的updateById方法 : {}", jsonToString(entity));
         Query query = new Query(Criteria.where("id").is(id));
         Update update = new Update();
         //Map<String, String> describe = BeanUtils.describe(entity);
@@ -167,6 +175,7 @@ public abstract class BaseMongodb<T> {
      * @param id
      */
     public void deleteById(String id) {
+        LOGGER.debug(" 调用mongo的deleteById方法 : {}", id);
         Query query = new Query(Criteria.where("id").is(id));
         if (getCollectionName() == null) {
             getMongoTemplate().remove(query, getEntity());
@@ -175,7 +184,6 @@ public abstract class BaseMongodb<T> {
         }
     }
 
-
     /**
      * 根据指定列删除
      *
@@ -183,6 +191,7 @@ public abstract class BaseMongodb<T> {
      * @param value  值
      */
     public void deleteById(String column, String value) {
+        LOGGER.debug(" 调用mongo的deleteById方法 : {} = {}", column, value);
         Query query = new Query(Criteria.where(column).is(value));
         if (getCollectionName() == null) {
             getMongoTemplate().remove(query, getEntity());
@@ -238,4 +247,12 @@ public abstract class BaseMongodb<T> {
         return query;
     }
 
+    private String jsonToString(Object obj) {
+        try {
+            return JSON.toJSONString(obj);
+        } catch (Exception e) {
+            LOGGER.debug("json转换失败:{} , {}", obj.toString(), e.getMessage());
+        }
+        return "";
+    }
 }

elab-mongodb/src/main/java/com/elab/mongodb/SimpleMongodbTemplate.java

@@ -0,0 +1,142 @@
+package com.elab.mongodb;
+
+import com.elab.core.componts.chains.ComponentConsumerHandlerChain;
+import com.elab.core.componts.chains.ComponentSupplierHandlerChain;
+import com.elab.mongodb.chain.MongoInterceptInvoke;
+import com.elab.mongodb.chain.model.MongoExecutorRequest;
+import com.elab.mongodb.chain.model.MongoInsertRequest;
+import com.elab.mongodb.chain.model.MongoQueryRequest;
+import com.elab.mongodb.chain.model.MongoUpdateRequest;
+import com.mongodb.DBObject;
+import com.mongodb.Mongo;
+import com.mongodb.WriteResult;
+import org.springframework.data.authentication.UserCredentials;
+import org.springframework.data.mongodb.MongoDbFactory;
+import org.springframework.data.mongodb.core.CollectionCallback;
+import org.springframework.data.mongodb.core.DocumentCallbackHandler;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.convert.MongoConverter;
+import org.springframework.data.mongodb.core.convert.MongoWriter;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.Update;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Supplier;
+
+/**
+ * 简单的mongodb操作类
+ *
+ * @author liukaixiong
+ * @date 2022/8/13 - 11:18
+ */
+public class SimpleMongodbTemplate extends MongoTemplate {
+
+    private List<MongoInterceptInvoke> mongoInterceptInvokeList = new ArrayList<>();
+
+    public SimpleMongodbTemplate(Mongo mongo, String databaseName) {
+        super(mongo, databaseName);
+    }
+
+    public SimpleMongodbTemplate(Mongo mongo, String databaseName, UserCredentials userCredentials) {
+        super(mongo, databaseName, userCredentials);
+    }
+
+    public SimpleMongodbTemplate(MongoDbFactory mongoDbFactory) {
+        super(mongoDbFactory);
+    }
+
+    public SimpleMongodbTemplate(MongoDbFactory mongoDbFactory, MongoConverter mongoConverter) {
+        super(mongoDbFactory, mongoConverter);
+    }
+
+    public void setMongoInterceptInvokeList(List<MongoInterceptInvoke> mongoInterceptInvokeList) {
+        this.mongoInterceptInvokeList = mongoInterceptInvokeList;
+    }
+
+    @Override
+    public <T> T execute(String collectionName, CollectionCallback<T> callback) {
+        MongoExecutorRequest req = new MongoExecutorRequest(collectionName, callback);
+        ComponentSupplierHandlerChain<MongoInterceptInvoke, MongoExecutorRequest, T> handlerChain =
+            new ComponentSupplierHandlerChain(this.mongoInterceptInvokeList,
+                () -> super.execute(collectionName, callback));
+        return handlerChain.executor(req, MongoInterceptInvoke::execute);
+    }
+
+    @Override
+    protected <T> void doSave(String collectionName, T objectToSave, MongoWriter<T> writer) {
+
+        MongoInsertRequest request = new MongoInsertRequest(collectionName, objectToSave);
+        ComponentConsumerHandlerChain<MongoInterceptInvoke, MongoInsertRequest> chain =
+            new ComponentConsumerHandlerChain<>(this.mongoInterceptInvokeList,
+                (r) -> super.doSave(collectionName, objectToSave, writer));
+        chain.run(request, MongoInterceptInvoke::insert);
+    }
+
+    @Override
+    protected <T> void doInsert(String collectionName, T objectToSave, MongoWriter<T> writer) {
+        MongoInsertRequest request = new MongoInsertRequest(collectionName, objectToSave);
+        ComponentConsumerHandlerChain<MongoInterceptInvoke, MongoInsertRequest> chain =
+            new ComponentConsumerHandlerChain<>(this.mongoInterceptInvokeList,
+                (r) -> super.doInsert(collectionName, objectToSave, writer));
+        chain.run(request, MongoInterceptInvoke::insert);
+    }
+
+    @Override
+    protected WriteResult doUpdate(String collectionName, Query query, Update update, Class<?> entityClass,
+        boolean upsert, boolean multi) {
+        MongoUpdateRequest request = new MongoUpdateRequest(collectionName, query, update);
+        ComponentSupplierHandlerChain<MongoInterceptInvoke, MongoUpdateRequest, WriteResult> chain =
+            new ComponentSupplierHandlerChain<>(this.mongoInterceptInvokeList,
+                () -> super.doUpdate(collectionName, query, update, entityClass, upsert, multi));
+        return chain.executor(request, MongoInterceptInvoke::update);
+    }
+
+    @Override
+    public <T> List<T> find(Query query, Class<T> entityClass, String collectionName) {
+        return findListExecutor(collectionName, query.getQueryObject(), query.getFieldsObject(), entityClass,
+            () -> super.find(query, entityClass, collectionName));
+    }
+
+    @Override
+    protected <T> List<T> doFind(String collectionName, DBObject query, DBObject fields, Class<T> entityClass) {
+        return findListExecutor(collectionName, query, fields, entityClass,
+            () -> super.doFind(collectionName, query, fields, entityClass));
+    }
+
+    private <T> List<T> findListExecutor(String collectionName, DBObject query, DBObject fields, Class<T> entityClass,
+        Supplier<List<T>> supplier) {
+        MongoQueryRequest request = new MongoQueryRequest();
+        request.setCollectionName(collectionName);
+        request.setQuery(query);
+        request.setFields(fields);
+        request.setClazz(entityClass);
+        ComponentSupplierHandlerChain<MongoInterceptInvoke, MongoQueryRequest, List<T>> chain =
+            new ComponentSupplierHandlerChain<>(this.mongoInterceptInvokeList, supplier);
+        return chain.executor(request, MongoInterceptInvoke::queryList);
+    }
+
+    @Override
+    public <T> List<T> findAll(Class<T> entityClass, String collectionName) {
+        return super.findAll(entityClass, collectionName);
+    }
+
+    @Override
+    protected <T> T doFindOne(String collectionName, DBObject query, DBObject fields, Class<T> entityClass) {
+        MongoQueryRequest request = new MongoQueryRequest();
+        request.setCollectionName(collectionName);
+        request.setQuery(query);
+        request.setFields(fields);
+        request.setClazz(entityClass);
+        ComponentSupplierHandlerChain<MongoInterceptInvoke, MongoQueryRequest, T> chain =
+            new ComponentSupplierHandlerChain<>(this.mongoInterceptInvokeList,
+                () -> super.doFindOne(collectionName, query, fields, entityClass));
+        return chain.executor(request, MongoInterceptInvoke::queryOne);
+    }
+
+    @Override
+    public void executeQuery(Query query, String collectionName, DocumentCallbackHandler dch) {
+        super.executeQuery(query, collectionName, dch);
+    }
+
+}

elab-mongodb/src/main/java/com/elab/mongodb/chain/CatMongoInterceptInvoke.java

@@ -0,0 +1,157 @@
+package com.elab.mongodb.chain;
+
+import com.alibaba.fastjson.JSON;
+import com.dianping.cat.Cat;
+import com.elab.core.componts.chains.ComponentConsumerHandlerChain;
+import com.elab.core.componts.chains.ComponentSupplierHandlerChain;
+import com.elab.log.utils.CatCrossProcess;
+import com.elab.mongodb.chain.model.MongoExecutorRequest;
+import com.elab.mongodb.chain.model.MongoInsertRequest;
+import com.elab.mongodb.chain.model.MongoQueryRequest;
+import com.elab.mongodb.chain.model.MongoUpdateRequest;
+import com.mongodb.DBObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.mongodb.core.MongoActionOperation;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.Update;
+
+import java.util.List;
+
+/**
+ * mongo拦截器
+ *
+ * @author liukaixiong
+ * @date 2022/8/13 - 16:35
+ */
+public class CatMongoInterceptInvoke implements MongoInterceptInvoke {
+
+    private final Logger logger = LoggerFactory.getLogger(getClass());
+
+    @Override
+    public <T> T execute(MongoExecutorRequest request,
+        ComponentSupplierHandlerChain<MongoInterceptInvoke, MongoExecutorRequest, T> chain) {
+        //        String collectionName = request.getCollectionName();
+        //        try {
+        //            String type = String.format("%s - %s", collectionName, MongoActionOperation.INSERT.name());
+        //            return CatCrossProcess.processTransactionMsg("mongodb", type, (t) -> {
+        //                logger.info("---------->>>>>>>>>>>>>>>" + Cat.getCurrentMessageId());
+        //                T executor = chain.executor(request, MongoInterceptInvoke::execute);
+        //                logger.info("mongo result : {}", getJsonString(executor));
+        //                return executor;
+        //            });
+        //        } catch (Exception e) {
+        //            logger.error("mongodb error", e);
+        //        }
+        return chain.executor(request, MongoInterceptInvoke::execute);
+    }
+
+    @Override
+    public void insert(MongoInsertRequest request,
+        ComponentConsumerHandlerChain<MongoInterceptInvoke, MongoInsertRequest> chain) {
+        String collectionName = request.getCollectionName();
+        Object objectToSave = request.getObjectToSave();
+        try {
+            String type = String.format("%s - %s", collectionName, MongoActionOperation.INSERT.name());
+            CatCrossProcess.processTransactionMsg("mongodb", type, (t) -> {
+                logger.info("请求入参: " + JSON.toJSONString(objectToSave));
+                logger.info("---------->>>>>>>>>>>>>>>" + Cat.getCurrentMessageId());
+                chain.run(request, MongoInterceptInvoke::insert);
+                return null;
+            });
+        } catch (Exception e) {
+            logger.error("mongo insert error", e);
+        }
+    }
+
+    @Override
+    public <T> T update(MongoUpdateRequest request,
+        ComponentSupplierHandlerChain<MongoInterceptInvoke, MongoUpdateRequest, T> chain) {
+        String collectionName = request.getCollectionName();
+        Query query = request.getQuery();
+        Update update = request.getUpdate();
+
+        try {
+            String type = String.format("%s - %s", collectionName, MongoActionOperation.UPDATE.name());
+            return CatCrossProcess.processTransactionMsg("mongodb", type, (t) -> {
+                logger.info("---------->>>>>>>>>>>>>>>" + Cat.getCurrentMessageId());
+                logger.debug(" query : {}", getString(query));
+                logger.debug(" update :  {} ", getString(update));
+                T executor = chain.executor(request, MongoInterceptInvoke::update);
+                logger.info("mongo result : {}", getJsonString(executor));
+                return executor;
+            });
+        } catch (Exception e) {
+            logger.error("mongodb error", e);
+        }
+        return null;
+    }
+
+    @Override
+    public <T> List<T> queryList(MongoQueryRequest request,
+        ComponentSupplierHandlerChain<MongoInterceptInvoke, MongoQueryRequest, List<T>> chain) {
+        String collectionName = request.getCollectionName();
+        DBObject query = request.getQuery();
+        DBObject fields = request.getFields();
+        try {
+            String queryList = "QueryList";
+            String type = String.format("%s - %s", collectionName, queryList);
+            return CatCrossProcess.processTransactionMsg("mongodb", type, (t) -> {
+                logger.debug(" field :  {} ", getString(query));
+                logger.debug(" field :  {} ", getString(fields));
+                logger.info("---------->>>>>>>>>>>>>>>" + Cat.getCurrentMessageId());
+                List<T> executor = chain.executor(request, MongoInterceptInvoke::queryList);
+                logger.info("mongo result size : {} ", executor.size());
+                return executor;
+            });
+        } catch (Exception e) {
+            logger.error("mongodb error", e);
+        }
+        return null;
+    }
+
+    @Override
+    public <T> T queryOne(MongoQueryRequest request,
+        ComponentSupplierHandlerChain<MongoInterceptInvoke, MongoQueryRequest, T> chain) {
+
+        String collectionName = request.getCollectionName();
+        DBObject query = request.getQuery();
+        DBObject fields = request.getFields();
+        try {
+            String queryObject = "QueryObject";
+            String type = String.format("%s - %s", collectionName, queryObject);
+            return CatCrossProcess.processTransactionMsg("mongodb", type, (t) -> {
+                logger.debug(" query : {}", getString(query));
+                logger.debug(" field :  {} ", getString(fields));
+                logger.info("---------->>>>>>>>>>>>>>>" + Cat.getCurrentMessageId());
+                T executor = chain.executor(request, MongoInterceptInvoke::queryOne);
+                logger.info("mongo result : {}", getJsonString(executor));
+                return executor;
+            });
+        } catch (Exception e) {
+            logger.error("mongodb error", e);
+        }
+        return null;
+    }
+
+    private String getString(Object obj) {
+        if (obj == null) {
+            return "";
+        }
+        return obj.toString();
+    }
+
+    private String getJsonString(Object obj) {
+        if (obj == null) {
+            return "";
+        } else if (obj instanceof String) {
+            return (String)obj;
+        }
+        try {
+            return JSON.toJSONString(obj);
+        } catch (Exception e) {
+            logger.warn("格式转换异常:{}", e.getMessage());
+        }
+        return "";
+    }
+}

elab-mongodb/src/main/java/com/elab/mongodb/chain/MongoInterceptInvoke.java

@@ -0,0 +1,34 @@
+package com.elab.mongodb.chain;
+
+import com.elab.core.componts.chains.ComponentConsumerHandlerChain;
+import com.elab.core.componts.chains.ComponentSupplierHandlerChain;
+import com.elab.mongodb.chain.model.MongoExecutorRequest;
+import com.elab.mongodb.chain.model.MongoInsertRequest;
+import com.elab.mongodb.chain.model.MongoQueryRequest;
+import com.elab.mongodb.chain.model.MongoUpdateRequest;
+
+import java.util.List;
+
+/**
+ * mongo拦截
+ *
+ * @author liukaixiong
+ * @date 2022/8/13 - 14:42
+ */
+public interface MongoInterceptInvoke {
+
+    public <T> T execute(MongoExecutorRequest request,
+        ComponentSupplierHandlerChain<MongoInterceptInvoke, MongoExecutorRequest, T> chain);
+
+    public void insert(MongoInsertRequest request,
+        ComponentConsumerHandlerChain<MongoInterceptInvoke, MongoInsertRequest> chain);
+
+    public <T> T update(MongoUpdateRequest request,
+        ComponentSupplierHandlerChain<MongoInterceptInvoke, MongoUpdateRequest, T> chain);
+
+    public <T> List<T> queryList(MongoQueryRequest request,
+        ComponentSupplierHandlerChain<MongoInterceptInvoke, MongoQueryRequest, List<T>> chain);
+
+    public <T> T queryOne(MongoQueryRequest request,
+        ComponentSupplierHandlerChain<MongoInterceptInvoke, MongoQueryRequest, T> chain);
+}

elab-mongodb/src/main/java/com/elab/mongodb/chain/model/MongoExecutorRequest.java

@@ -0,0 +1,35 @@
+package com.elab.mongodb.chain.model;
+
+import org.springframework.data.mongodb.core.CollectionCallback;
+
+/**
+ * mongo执行方法请求参数
+ *
+ * @author liukaixiong
+ * @date 2022/8/15 - 9:51
+ */
+public class MongoExecutorRequest {
+
+    private String collectionName;
+    private CollectionCallback<Object> callback;
+
+    public MongoExecutorRequest(String collectionName, CollectionCallback callback) {
+        this.collectionName = collectionName;
+    }
+
+    public String getCollectionName() {
+        return collectionName;
+    }
+
+    public void setCollectionName(String collectionName) {
+        this.collectionName = collectionName;
+    }
+
+    public CollectionCallback<Object> getCallback() {
+        return callback;
+    }
+
+    public void setCallback(CollectionCallback<Object> callback) {
+        this.callback = callback;
+    }
+}

elab-mongodb/src/main/java/com/elab/mongodb/chain/model/MongoInsertRequest.java

@@ -0,0 +1,34 @@
+package com.elab.mongodb.chain.model;
+
+/**
+ * 插入对象
+ *
+ * @author liukaixiong
+ * @date 2022/8/16 - 16:59
+ */
+public class MongoInsertRequest {
+
+    private String collectionName;
+    private Object objectToSave;
+
+    public MongoInsertRequest(String collectionName, Object objectToSave) {
+        this.collectionName = collectionName;
+        this.objectToSave = objectToSave;
+    }
+
+    public String getCollectionName() {
+        return collectionName;
+    }
+
+    public void setCollectionName(String collectionName) {
+        this.collectionName = collectionName;
+    }
+
+    public Object getObjectToSave() {
+        return objectToSave;
+    }
+
+    public void setObjectToSave(Object objectToSave) {
+        this.objectToSave = objectToSave;
+    }
+}

elab-mongodb/src/main/java/com/elab/mongodb/chain/model/MongoQueryRequest.java

@@ -0,0 +1,46 @@
+package com.elab.mongodb.chain.model;
+
+import com.mongodb.DBObject;
+
+/**
+ * @author liukaixiong
+ * @date 2022/8/17 - 10:36
+ */
+public class MongoQueryRequest {
+    private String collectionName;
+    private DBObject query;
+    private DBObject fields;
+    private Class clazz;
+
+    public Class getClazz() {
+        return clazz;
+    }
+
+    public void setClazz(Class clazz) {
+        this.clazz = clazz;
+    }
+
+    public String getCollectionName() {
+        return collectionName;
+    }
+
+    public void setCollectionName(String collectionName) {
+        this.collectionName = collectionName;
+    }
+
+    public DBObject getQuery() {
+        return query;
+    }
+
+    public void setQuery(DBObject query) {
+        this.query = query;
+    }
+
+    public DBObject getFields() {
+        return fields;
+    }
+
+    public void setFields(DBObject fields) {
+        this.fields = fields;
+    }
+}

elab-mongodb/src/main/java/com/elab/mongodb/chain/model/MongoUpdateRequest.java

@@ -0,0 +1,45 @@
+package com.elab.mongodb.chain.model;
+
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.Update;
+
+/**
+ * @author liukaixiong
+ * @date 2022/8/16 - 17:04
+ */
+public class MongoUpdateRequest {
+
+    private String collectionName;
+    private Query query;
+    private Update update;
+
+    public MongoUpdateRequest(String collectionName, Query query, Update update) {
+        this.collectionName = collectionName;
+        this.query = query;
+        this.update = update;
+    }
+
+    public String getCollectionName() {
+        return collectionName;
+    }
+
+    public void setCollectionName(String collectionName) {
+        this.collectionName = collectionName;
+    }
+
+    public Query getQuery() {
+        return query;
+    }
+
+    public void setQuery(Query query) {
+        this.query = query;
+    }
+
+    public Update getUpdate() {
+        return update;
+    }
+
+    public void setUpdate(Update update) {
+        this.update = update;
+    }
+}

elab-mongodb/src/main/java/com/elab/mongodb/config/MongoAutoConfiguration.java

@@ -1,17 +1,22 @@
 package com.elab.mongodb.config;
 
-import com.elab.core.utils.DataUtils;
+import com.elab.mongodb.SimpleMongodbTemplate;
+import com.elab.mongodb.chain.CatMongoInterceptInvoke;
+import com.elab.mongodb.chain.MongoInterceptInvoke;
 import com.elab.mongodb.config.property.MongoConfig;
 import com.mongodb.MongoClient;
 import com.mongodb.MongoClientURI;
 import com.mongodb.MongoCredential;
 import com.mongodb.ServerAddress;
 import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.EnableAspectJAutoProxy;
 import org.springframework.data.mongodb.core.MongoTemplate;
 import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
 import org.springframework.data.mongodb.core.convert.DefaultMongoTypeMapper;
@@ -23,17 +28,34 @@ import java.util.ArrayList;
 import java.util.List;
 
 /**
+ * 监控目标:
+ * - 执行语句
+ * - 执行耗时
+ * - 结果内容
+ *
  * @author liuhx
  * @create 2019/06/06 11:31
  * @email liuhx@elab-plus.com
  **/
 @Configuration
+@EnableAspectJAutoProxy
 @EnableConfigurationProperties(value = MongoConfig.class)
 public class MongoAutoConfiguration {
+    private Logger logger = LoggerFactory.getLogger(getClass());
+
+    @Autowired(required = false)
+    private List<MongoInterceptInvoke> mongoInterceptInvokeList;
+
+    @Bean
+    public MongoInterceptInvoke catMongoInterceptInvoke() {
+        return new CatMongoInterceptInvoke();
+    }
 
     @Bean
     @ConditionalOnMissingBean(value = {MongoTemplate.class})
-    public MongoTemplate getMongoTemplate(@Autowired MongoConfig mongoConfig) throws UnknownHostException {
+    public MongoTemplate mongoTemplate(
+        @Autowired
+            MongoConfig mongoConfig) throws UnknownHostException {
         String mongoClientHost = mongoConfig.getHost();
         String[] mongoClientHosts = mongoClientHost.split(",");
         int[] mongoClientPorts = {mongoConfig.getPort()};
@@ -41,7 +63,7 @@ public class MongoAutoConfiguration {
         String clusterUrl = mongoConfig.getClusterUrl();
         String userName = mongoConfig.getUserName() == null ? "" : mongoConfig.getUserName();
         String password = mongoConfig.getPassword() == null ? "" : mongoConfig.getPassword();
-    if (null != clusterUrl && clusterUrl.length() > 0) {
+        if (null != clusterUrl && clusterUrl.length() > 0) {
             String[] hostAndPorts = clusterUrl.split(",");
             mongoClientHosts = new String[hostAndPorts.length];
             mongoClientPorts = new int[hostAndPorts.length];
@@ -77,8 +99,12 @@ public class MongoAutoConfiguration {
         } else {
             mongoDbFactory = new SimpleMongoDbFactory(mongoClient, mongodbName);
         }
+        return getMongoTemplate(mongoDbFactory);
+    }
 
-        MongoTemplate mongoTemplate = new MongoTemplate(mongoDbFactory);
+    private MongoTemplate getMongoTemplate(SimpleMongoDbFactory mongoDbFactory) {
+        SimpleMongodbTemplate mongoTemplate = new SimpleMongodbTemplate(mongoDbFactory);
+        mongoTemplate.setMongoInterceptInvokeList(mongoInterceptInvokeList);
         convertClass(mongoTemplate);
         return mongoTemplate;
     }
@@ -100,11 +126,9 @@ public class MongoAutoConfiguration {
             MongoClient mongoClient = new MongoClient(serverAddressList, userCredentialsList);
 
             SimpleMongoDbFactory mongoDbFactory = new SimpleMongoDbFactory(mongoClient, mongodbName);
-            MongoTemplate mongoTemplate = new MongoTemplate(mongoDbFactory);
-            convertClass(mongoTemplate);
-            return mongoTemplate;
+            return getMongoTemplate(mongoDbFactory);
         } catch (Exception e) {
-            e.printStackTrace();
+            logger.error("mongodb 初始化失败", e);
         }
         return null;
     }

elab-mongodb/src/test/java/com/elab/mongodb/chain/example/UserRecordHandlerChain.java

@@ -0,0 +1,116 @@
+package com.elab.mongodb.chain.example;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Supplier;
+
+/**
+ * 通用责任链拦截器
+ *
+ * @author liukaixiong
+ * @date 2022/8/13 - 16:54
+ */
+public class UserRecordHandlerChain<I, T, R> {
+
+    private final List<I> handlerList;
+    private final Supplier<R> supplier;
+
+    private int currentHandlerIndex = -1;
+
+    public UserRecordHandlerChain(List<I> handlerList, Supplier<R> supplier) {
+        this.handlerList = handlerList;
+        this.supplier = supplier;
+    }
+
+    public R executor(T req, ChainFunction<I, T, R> chainFunction) {
+
+        if (this.currentHandlerIndex == this.handlerList.size() - 1) {
+            return supplier.get();
+        }
+
+        I handler = this.handlerList.get(++this.currentHandlerIndex);
+        return chainFunction.executor(handler, req, this);
+    }
+
+    public static class UserModel {
+        private String username;
+        private int age;
+
+        public String getUsername() {
+            return username;
+        }
+
+        public void setUsername(String username) {
+            this.username = username;
+        }
+
+        public int getAge() {
+            return age;
+        }
+
+        public void setAge(int age) {
+            this.age = age;
+        }
+
+        @Override
+        public String toString() {
+            return "UserModel{" + "username='" + username + '\'' + ", age=" + age + '}';
+        }
+    }
+
+    interface ChainFunction<I, T, R> {
+        public R executor(I apply, T req, UserRecordHandlerChain<I, T, R> chain);
+    }
+
+    class DefaultChainFunction implements ChainFunction<Handler, UserModel, String> {
+        @Override
+        public String executor(Handler apply, UserModel userModel,
+            UserRecordHandlerChain<Handler, UserModel, String> chain) {
+            return apply.run(userModel, chain);
+        }
+    }
+
+    /**
+     * 通用的拦截链处理器
+     */
+    interface Handler {
+        public String run(UserModel userModel, UserRecordHandlerChain<Handler, UserModel, String> chain);
+    }
+
+    static class AHandler implements Handler {
+        @Override
+        public String run(UserModel userModel, UserRecordHandlerChain<Handler, UserModel, String> chain) {
+            System.out.println("A 开始"+userModel.toString());
+            String executor = chain.executor(userModel, Handler::run);
+            System.out.println("A 结束");
+            return executor;
+        }
+    }
+
+    static class BHandler implements Handler {
+        @Override
+        public String run(UserModel userModel, UserRecordHandlerChain<Handler, UserModel, String> chain) {
+            System.out.println("B 开始 "+userModel.toString());
+            String executor = chain.executor(userModel, Handler::run);
+            System.out.println("B 结束");
+            return executor;
+        }
+    }
+
+    public static void main(String[] args) {
+        List<Handler> handlers = Arrays.asList(new AHandler(), new BHandler());
+        UserRecordHandlerChain<Handler, UserModel, String> chain =
+            new UserRecordHandlerChain<Handler, UserModel, String>(handlers, () -> {
+                System.out.println("ok");
+                return "ok";
+            });
+
+        UserModel user = new UserModel();
+        user.setAge(1);
+        user.setUsername("liukx");
+
+        String executor = chain.executor(user, Handler::run);
+        System.out.println("得到结果:" + executor);
+
+    }
+}

elab-mongodb/src/test/java/com/elab/mongodb/chain/example/UserRecordHandlerChainTest.java

@@ -0,0 +1,38 @@
+//package com.elab.mongodb.chain.example;
+//
+//import org.junit.Test;
+//
+//import java.util.Arrays;
+//import java.util.List;
+//
+//public class UserRecordHandlerChainTest {
+//
+//    @Test
+//    public void executor() {
+//        List<Handler> handlerList = Arrays.asList(new AHandler());
+//        UserRecordHandlerChain chain = new UserRecordHandlerChain(handlerList, () -> "ok");
+//    }
+//
+//    interface Handler {
+//        public String run(String body, UserRecordHandlerChain chain);
+//    }
+//
+//    class AHandler implements Handler {
+//        @Override
+//        public String run(String body, UserRecordHandlerChain chain) {
+//            return chain.executor();
+//        }
+//    }
+//
+//    class B implements UserRecordHandlerChain.ChainFunction<Handler, String> {
+//
+//        @Override
+//        public String executor(Handler apply, UserRecordHandlerChain<Handler, String> chain) {
+//            System.out.println("B 开始");
+//            String b = apply.run("B", chain);
+//            System.out.println("B 结束");
+//            return b;
+//        }
+//    }
+//
+//}

elab-mongodb/src/test/java/com/elab/mongodb/config/MongoAutoConfigurationTest.java

@@ -0,0 +1,59 @@
+package com.elab.mongodb.config;
+
+import com.elab.log.utils.CatCrossProcess;
+import com.elab.mongodb.chain.CatMongoInterceptInvoke;
+import com.elab.test.mongodb.entity.User;
+import com.elab.test.mongodb.ext.UserMongoDB;
+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.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.Arrays;
+import java.util.List;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = {MongoAutoConfiguration.class, UserMongoDB.class, CatMongoInterceptInvoke.class})
+public class MongoAutoConfigurationTest {
+
+    @Autowired
+    private UserMongoDB userMongoDB;
+
+    @Test
+    public void insert() throws Exception {
+        List<String> strings = Arrays.asList("sss", "fff", "ddd");
+        User user = new User("uuu", "123", "11", strings);
+
+        userMongoDB.save(user);
+        System.out.println("====");
+        System.in.read();
+    }
+
+    @Test
+    public void update() throws Exception {
+        List<String> strings = Arrays.asList("sss", "fff", "ddd");
+        User user = new User("lkx", "123", "7", strings);
+        userMongoDB.updateById("7", user);
+        System.out.println("====");
+        System.in.read();
+    }
+
+    @Test
+    public void query() throws Exception {
+        Object o = CatCrossProcess.processTransactionMsg("test", "mongo", (t) -> {
+            User user = new User();
+             user.setPassword("123");
+            Query query = new Query();
+            Criteria criteria = Criteria.where("id").is("7").and("username").gt("123").and("arrayData").in("sss");
+            query.addCriteria(criteria);
+            User one = userMongoDB.getMongoTemplate().findOne(query, User.class);
+            System.out.println(one);
+            List<User> byList = userMongoDB.findByList(user);
+            return byList;
+        });
+        System.in.read();
+    }
+}

elab-mongodb/src/test/resources/META-INF/app.properties

@@ -0,0 +1 @@
+app.name=cat-mongo-demo

elab-mongodb/src/test/resources/META-INF/plexus/components-cat-client.xml

@@ -0,0 +1,112 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- THIS FILE WAS AUTO GENERATED FROM class com.dianping.cat.build.ComponentsConfigurator, DO NOT EDIT IT -->
+<plexus>
+	<components>
+		<component>
+			<role>com.dianping.cat.configuration.ClientConfigManager</role>
+			<implementation>com.dianping.cat.configuration.DefaultClientConfigManager</implementation>
+		</component>
+		<component>
+			<role>com.dianping.cat.message.internal.MessageIdFactory</role>
+			<implementation>com.dianping.cat.message.internal.MessageIdFactory</implementation>
+		</component>
+		<component>
+			<role>com.dianping.cat.message.spi.MessageManager</role>
+			<implementation>com.dianping.cat.message.internal.DefaultMessageManager</implementation>
+			<requirements>
+				<requirement>
+					<role>com.dianping.cat.configuration.ClientConfigManager</role>
+				</requirement>
+				<requirement>
+					<role>com.dianping.cat.message.io.TransportManager</role>
+				</requirement>
+				<requirement>
+					<role>com.dianping.cat.message.internal.MessageIdFactory</role>
+				</requirement>
+			</requirements>
+		</component>
+		<component>
+			<role>com.dianping.cat.message.MessageProducer</role>
+			<implementation>com.dianping.cat.message.internal.DefaultMessageProducer</implementation>
+			<!--<implementation>com.elab.log.message.CatMessageProducer</implementation>-->
+			<requirements>
+				<requirement>
+					<role>com.dianping.cat.message.spi.MessageManager</role>
+				</requirement>
+				<requirement>
+					<role>com.dianping.cat.message.internal.MessageIdFactory</role>
+				</requirement>
+			</requirements>
+		</component>
+		<component>
+			<role>com.dianping.cat.message.io.TcpSocketSender</role>
+			<implementation>com.dianping.cat.message.io.TcpSocketSender</implementation>
+			<requirements>
+				<requirement>
+					<role>com.dianping.cat.configuration.ClientConfigManager</role>
+				</requirement>
+				<requirement>
+					<role>com.dianping.cat.message.internal.MessageIdFactory</role>
+				</requirement>
+				<requirement>
+					<role>com.dianping.cat.message.spi.MessageStatistics</role>
+					<field-name>m_statistics</field-name>
+				</requirement>
+				<requirement>
+					<role>com.dianping.cat.message.spi.MessageCodec</role>
+					<role-hint>plain-text</role-hint>
+					<field-name>m_codec</field-name>
+				</requirement>
+			</requirements>
+		</component>
+		<component>
+			<role>com.dianping.cat.message.io.TransportManager</role>
+			<implementation>com.dianping.cat.message.io.DefaultTransportManager</implementation>
+			<requirements>
+				<requirement>
+					<role>com.dianping.cat.configuration.ClientConfigManager</role>
+				</requirement>
+				<requirement>
+					<role>com.dianping.cat.message.io.TcpSocketSender</role>
+				</requirement>
+			</requirements>
+		</component>
+		<component>
+			<role>com.dianping.cat.message.spi.MessageStatistics</role>
+			<implementation>com.dianping.cat.message.spi.internal.DefaultMessageStatistics</implementation>
+		</component>
+		<component>
+			<role>com.dianping.cat.status.StatusUpdateTask</role>
+			<implementation>com.dianping.cat.status.StatusUpdateTask</implementation>
+			<requirements>
+				<requirement>
+					<role>com.dianping.cat.message.spi.MessageStatistics</role>
+				</requirement>
+				<requirement>
+					<role>com.dianping.cat.configuration.ClientConfigManager</role>
+				</requirement>
+			</requirements>
+		</component>
+		<component>
+			<role>org.unidal.initialization.Module</role>
+			<role-hint>cat-client</role-hint>
+			<implementation>com.dianping.cat.CatClientModule</implementation>
+		</component>
+		<component>
+			<role>com.dianping.cat.message.spi.codec.BufferWriter</role>
+			<role-hint>escape</role-hint>
+			<implementation>com.dianping.cat.message.spi.codec.EscapingBufferWriter</implementation>
+		</component>
+		<component>
+			<role>com.dianping.cat.message.spi.MessageCodec</role>
+			<role-hint>plain-text</role-hint>
+			<implementation>com.dianping.cat.message.spi.codec.PlainTextMessageCodec</implementation>
+			<requirements>
+				<requirement>
+					<role>com.dianping.cat.message.spi.codec.BufferWriter</role>
+					<role-hint>escape</role-hint>
+				</requirement>
+			</requirements>
+		</component>
+	</components>
+</plexus>

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

@@ -0,0 +1,11 @@
+server:
+  port: 5800
+  tomcat:
+    max-threads: 2000
+    uri-encoding: UTF-8
+mongodb:
+  host: 127.0.0.1
+  port: 27017
+  databaseName: test
+
+app.name: cat-mongo-demo

elab-mongodb/src/test/resources/log4j.properties

@@ -1,10 +0,0 @@
-log4j.rootLogger=DEBUG,systemOut
-
-
-log4j.appender.systemOut = org.apache.log4j.ConsoleAppender
-log4j.appender.systemOut.layout = org.apache.log4j.PatternLayout
-log4j.appender.systemOut.layout.ConversionPattern = [%-5p][%-22d{yyyy/MM/dd HH:mm:ssS}] [%l] %n [ **************** %m ****************** ] %n%n
-log4j.appender.systemOut.Threshold = DEBUG
-log4j.appender.systemOut.ImmediateFlush = TRUE
-log4j.appender.systemOut.Target = System.out
-

elab-mongodb/src/test/resources/logback.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <include resource="org/springframework/boot/logging/logback/base.xml"/>
+    <jmxConfigurator/>
+    <property name="LOG_PATH" value="logs"/>
+    <logger name="org.apache" level="WARN"/>
+    <logger name="org.springframework" level="WARN"/>
+
+
+    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+            <Pattern>%date{yyyy-MM-dd HH:mm:ss.SSS} %-5level[%thread]%logger{56}.%method:%L -%msg%n</Pattern>
+        </encoder>
+    </appender>
+
+    <appender name="cat" class="com.elab.log.log4j.CatLogbackLog"/>
+
+    <logger name="com.elab" level="debug" additivity="false">
+        <appender-ref ref="stdout"/>
+        <appender-ref ref="cat"/>
+    </logger>
+
+<!--    <logger name="org.springframework.boot" level="INFO" additivity="false">-->
+<!--        <appender-ref ref="stdout"/>-->
+<!--    </logger>-->
+
+
+    <root level="debug">
+        <appender-ref ref="stdout"/>
+        <appender-ref ref="cat"/>
+    </root>
+    <!--    <logger name="com.elab" level="DEBUG" />-->
+</configuration>

elab-mq/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>elab-parent</artifactId>
         <groupId>com.elab.core</groupId>
-        <version>2.0.5.3-SNAPSHOT</version>
+        <version>3.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

elab-mq/src/main/java/com/elab/mq/listener/LoggerConsumerInterceptor.java

@@ -1,18 +1,17 @@
 package com.elab.mq.listener;
 
-import com.aliyun.openservices.ons.api.SendResult;
 import com.elab.mq.model.MessageModel;
-import com.elab.mq.msg.ProducerInterceptor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
- * @Module TODO
- * @Description TODO
+ * @Module 消费者拦截器
+ * @Description 负责处理消费者消费时候的拦截
  * @Author liukaixiong
  * @Date 2020/12/30 15:02
  */
-public class LoggerConsumerInterceptor implements ConsumerInterceptor, ProducerInterceptor {
+public class LoggerConsumerInterceptor implements ConsumerInterceptor {
+
     private Logger logger = LoggerFactory.getLogger(getClass());
 
     @Override
@@ -21,11 +20,6 @@ public class LoggerConsumerInterceptor implements ConsumerInterceptor, ProducerI
         return true;
     }
 
-    @Override
-    public void success(MessageModel messageModel, String groupName, SendResult result) {
-        logger.debug("发送成功:" + result);
-    }
-
     @Override
     public void error(MessageModel messageModel, String groupName, Throwable e) {
         logger.debug("消费失败:" + messageModel.getMsgID(), e);

elab-mq/src/main/java/com/elab/mq/listener/LoggerProducerInterceptor.java

@@ -0,0 +1,36 @@
+package com.elab.mq.listener;
+
+import com.aliyun.openservices.ons.api.SendResult;
+import com.elab.core.utils.RandomUtils;
+import com.elab.mq.model.MessageModel;
+import com.elab.mq.msg.ProducerInterceptor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * 生产者发送消息拦截处理器
+ *
+ * @author liukaixiong
+ * @date 2022/7/6 - 9:26
+ */
+public class LoggerProducerInterceptor implements ProducerInterceptor {
+    private final Logger logger = LoggerFactory.getLogger(getClass());
+
+    @Override
+    public boolean check(MessageModel messageModel, String groupName) {
+        String producerId = System.currentTimeMillis() + RandomUtils.randomNum(3);
+        messageModel.setProducerId(producerId);
+        logger.debug("LoggerProducerInterceptor : 通过时间戳生成的producerId : " + producerId);
+        return true;
+    }
+
+    @Override
+    public void success(MessageModel messageModel, String groupName, SendResult result) {
+
+    }
+
+    @Override
+    public void error(MessageModel messageModel, String groupName, Throwable e) {
+
+    }
+}

elab-mq/src/main/java/com/elab/mq/msg/impl/MsgProducerImpl.java

@@ -4,7 +4,7 @@ import com.aliyun.openservices.ons.api.SendResult;
 import com.aliyun.openservices.ons.api.bean.ProducerBean;
 import com.elab.core.utils.StringUtils;
 import com.elab.log.utils.CatCrossProcess;
-import com.elab.mq.listener.LoggerConsumerInterceptor;
+import com.elab.mq.listener.LoggerProducerInterceptor;
 import com.elab.mq.model.MessageModel;
 import com.elab.mq.model.SendResultModel;
 import com.elab.mq.msg.IMsgProducerFacade;
@@ -29,7 +29,7 @@ public class MsgProducerImpl extends ProducerBean implements IMsgProducerFacade
     private Logger logger = LoggerFactory.getLogger(MsgProducerImpl.class);
 
     @Autowired(required = false)
-    private ProducerInterceptor producerInterceptor = new LoggerConsumerInterceptor();
+    private ProducerInterceptor producerInterceptor = new LoggerProducerInterceptor();
 
     private final String MQ_PRODUCER = "MQ_PRODUCER";
 

elab-redis/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>elab-parent</artifactId>
         <groupId>com.elab.core</groupId>
-        <version>2.0.5.3-SNAPSHOT</version>
+        <version>3.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

elab-rocketMQ/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>elab-parent</artifactId>
         <groupId>com.elab.core</groupId>
-        <version>2.0.5.3-SNAPSHOT</version>
+        <version>3.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

elab-spring/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>elab-parent</artifactId>
         <groupId>com.elab.core</groupId>
-        <version>2.0.5.3-SNAPSHOT</version>
+        <version>3.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

elab-spring/src/test/java/com/elab/spring/utils/SpringCase.java

@@ -1,19 +1,15 @@
 package com.elab.spring.utils;
 
 import com.elab.spring.utils.event.SourceModel;
-import com.xiaoleilu.hutool.lang.ClassScaner;
 import org.junit.Test;
 import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
 import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.core.io.DefaultResourceLoader;
 import org.springframework.core.io.Resource;
 import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
 import org.springframework.core.io.support.PropertiesLoaderUtils;
-import org.springframework.core.io.support.ResourcePatternResolver;
 import org.springframework.core.io.support.ResourcePatternUtils;
 import org.springframework.core.type.filter.AnnotationTypeFilter;
 import org.springframework.core.type.filter.AssignableTypeFilter;
@@ -21,7 +17,6 @@ import org.springframework.util.AntPathMatcher;
 import org.springframework.util.PatternMatchUtils;
 import org.springframework.util.ResourceUtils;
 
-import javax.xml.bind.SchemaOutputResolver;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
@@ -55,7 +50,7 @@ public class SpringCase {
         PathMatchingResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
         Resource[] resources = resourcePatternResolver.getResources("classpath:*.yml");
         System.out.println(resources);
-        Set<Class<?>> classes = ClassScaner.scanPackage("com.elab.spring.utils.event");
+//        Set<Class<?>> classes = ClassScaner.scanPackage("com.elab.spring.utils.event");
 
         Resource[] resources1 =
             ResourcePatternUtils.getResourcePatternResolver(new DefaultResourceLoader()).getResources("mapper/*");

elab-test/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>elab-parent</artifactId>
         <groupId>com.elab.core</groupId>
-        <version>2.0.5.3-SNAPSHOT</version>
+        <version>3.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

pom.xml

@@ -7,7 +7,7 @@
     <groupId>com.elab.core</groupId>
     <artifactId>elab-parent</artifactId>
     <packaging>pom</packaging>
-    <version>2.0.5.3-SNAPSHOT</version>
+    <version>3.0.0-SNAPSHOT</version>
     <modules>
         <module>elab-core</module>
         <module>elab-cache</module>