diff --git a/mapstruct-plus/src/main/java/io/github/linpeilie/BaseCycleAvoidingMapper.java b/mapstruct-plus/src/main/java/io/github/linpeilie/BaseCycleAvoidingMapper.java
deleted file mode 100644
index 48c7773a946001b55fcc91e0bddbdac195bf034e..0000000000000000000000000000000000000000
--- a/mapstruct-plus/src/main/java/io/github/linpeilie/BaseCycleAvoidingMapper.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package io.github.linpeilie;
-
-import java.util.List;
-import java.util.stream.Collectors;
-import org.mapstruct.Context;
-import org.mapstruct.MappingTarget;
-
-public interface BaseCycleAvoidingMapper<S, T> extends BaseMapper<S, T> {
-
-    T convert(S source, @Context CycleAvoidingMappingContext context);
-
-    T convert(S source, @MappingTarget T target, @Context CycleAvoidingMappingContext context);
-
-    default List<T> convert(List<S> sourceList, @Context CycleAvoidingMappingContext context) {
-        return sourceList.stream()
-            .map(item -> convert(item, context))
-            .collect(Collectors.toList());
-    }
-
-    @Override
-    default T convert(S source) {
-        return convert(source, new CycleAvoidingMappingContext());
-    }
-
-    @Override
-    default T convert(S source, @MappingTarget T target) {
-        return convert(source, new CycleAvoidingMappingContext());
-    }
-
-
-    @Override
-    default List<T> convert(List<S> sourceList) {
-        return convert(sourceList, new CycleAvoidingMappingContext());
-    }
-
-}
diff --git a/mapstruct-plus/src/main/java/io/github/linpeilie/BaseMapMapper.java b/mapstruct-plus/src/main/java/io/github/linpeilie/BaseMapMapper.java
index f9ca9597d90508db34b0133931258adb2b89b861..57a47938753d1e9ed5af91c248a6e60bc765f20c 100644
--- a/mapstruct-plus/src/main/java/io/github/linpeilie/BaseMapMapper.java
+++ b/mapstruct-plus/src/main/java/io/github/linpeilie/BaseMapMapper.java
@@ -1,9 +1,19 @@
 package io.github.linpeilie;
 
 import java.util.Map;
+import java.util.Objects;
+import java.util.function.Consumer;
 
 public interface BaseMapMapper<T> {
 
     T convert(Map<String, Object> map);
 
+    default T convert(Map<String, Object> map, Consumer<T> beanConsumer) {
+        T bean = convert(map);
+        if (Objects.nonNull(bean) && Objects.nonNull(beanConsumer)) {
+            beanConsumer.accept(bean);
+        }
+        return bean;
+    }
+
 }
diff --git a/mapstruct-plus/src/main/java/io/github/linpeilie/BaseMapper.java b/mapstruct-plus/src/main/java/io/github/linpeilie/BaseMapper.java
index eec5536c2b627fa7d60ef2d13485c21abd8271a8..7090769a2dafe53b31d5f1e3a55acd2588a0b2de 100644
--- a/mapstruct-plus/src/main/java/io/github/linpeilie/BaseMapper.java
+++ b/mapstruct-plus/src/main/java/io/github/linpeilie/BaseMapper.java
@@ -1,22 +1,53 @@
 package io.github.linpeilie;
 
 import io.github.linpeilie.utils.CollectionUtils;
+import org.mapstruct.MappingTarget;
+
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
+import java.util.function.Consumer;
 import java.util.stream.Collectors;
-import org.mapstruct.MappingTarget;
 
 public interface BaseMapper<S, T> {
 
     T convert(S source);
 
+    default T convert(S source, Consumer<T> beanConsumer) {
+        T bean = convert(source);
+        if (Objects.nonNull(bean) && Objects.nonNull(beanConsumer)) {
+            beanConsumer.accept(bean);
+        }
+        return bean;
+    }
+
     T convert(S source, @MappingTarget T target);
 
+    default T convert(S source, @MappingTarget T target, Consumer<T> beanConsumer) {
+        T bean = convert(source, target);
+        if (Objects.nonNull(bean) && Objects.nonNull(beanConsumer)) {
+            beanConsumer.accept(bean);
+        }
+        return bean;
+    }
+
     default List<T> convert(List<S> sourceList) {
+        return convert(sourceList, null);
+    }
+
+    default List<T> convert(List<S> sourceList, Consumer<T> beanConsumer) {
         if (CollectionUtils.isEmpty(sourceList)) {
             return new ArrayList<>();
         }
-        return sourceList.stream().map(this::convert).collect(Collectors.toList());
+        // 如果 beanConsumer 本来就为 null，则不再调用带 Consumer 参数的 convert 方法，避免在循环中进行不必要的非空判断
+        if (Objects.nonNull(beanConsumer)) {
+            return sourceList.stream()
+                .map(source -> convert(source, beanConsumer))
+                .collect(Collectors.toList());
+        }
+        return sourceList.stream()
+            .map(this::convert)
+            .collect(Collectors.toList());
     }
 
 }
diff --git a/mapstruct-plus/src/main/java/io/github/linpeilie/Converter.java b/mapstruct-plus/src/main/java/io/github/linpeilie/Converter.java
index 92ae3a717d708e25fde2c0cae008f7f32c8c1344..8da2ef0fb4c90d439561aa7d4e3e4b83220692bf 100644
--- a/mapstruct-plus/src/main/java/io/github/linpeilie/Converter.java
+++ b/mapstruct-plus/src/main/java/io/github/linpeilie/Converter.java
@@ -4,7 +4,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.stream.Collectors;
+import java.util.function.Consumer;
 
 public class Converter {
 
@@ -18,79 +18,113 @@ public class Converter {
         this.converterFactory = converterFactory;
     }
 
-    @SuppressWarnings("unchecked")
     public <S, T> T convert(S source, Class<T> targetType) {
+        return convert(source, targetType, (Consumer<T>) null);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <S, T> T convert(S source, Class<T> targetType, Consumer<T> beanConsumer) {
         if (source == null) {
             return null;
         }
         BaseMapper<S, T> mapper = (BaseMapper<S, T>) converterFactory.getMapper(source.getClass(), targetType);
         if (mapper != null) {
-            return mapper.convert(source);
+            return mapper.convert(source, beanConsumer);
         }
         throw new ConvertException(
             "cannot find converter from " + source.getClass().getSimpleName() + " to " + targetType.getSimpleName());
     }
 
-    @SuppressWarnings("unchecked")
     public <S, T> T convert(S source, T target) {
+        return convert(source, target, null);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <S, T> T convert(S source, T target, Consumer<T> beanConsumer) {
         if (source == null) {
             return null;
         }
         if (target == null) {
             return null;
         }
-        BaseMapper<S, T> mapper = (BaseMapper<S, T>) converterFactory.getMapper(source.getClass(), target.getClass());
+        Class<?> sourceClass = source.getClass();
+        BaseMapper<S, T> mapper = (BaseMapper<S, T>) converterFactory.getMapper(sourceClass, target.getClass());
         if (mapper != null) {
-            return mapper.convert(source, target);
+            return mapper.convert(source, target, beanConsumer);
         }
-        throw new ConvertException("cannot find converter from " + source.getClass().getSimpleName() + " to " +
-                                   target.getClass().getSimpleName());
+        throw new ConvertException("cannot find converter from " + sourceClass.getSimpleName() + " to " +
+            target.getClass().getSimpleName());
     }
 
-    public <S, T> List<T> convert(List<S> source, Class<T> targetType) {
-        if (source == null || source.isEmpty()) {
+    public <S, T> List<T> convert(List<S> sourceList, Class<T> targetType) {
+        return convert(sourceList, targetType, (Consumer<T>) null);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <S, T> List<T> convert(List<S> sourceList, Class<T> targetType, Consumer<T> beanConsumer) {
+        if (sourceList == null || sourceList.isEmpty()) {
             return new ArrayList<>();
         }
-        return source.stream().map(item -> convert(item, targetType)).collect(Collectors.toList());
+        Class<?> sourceType = sourceList.getFirst().getClass();
+        BaseMapper<S, T> mapper = (BaseMapper<S, T>) converterFactory.getMapper(sourceType, targetType);
+        if (mapper != null) {
+            return mapper.convert(sourceList, beanConsumer);
+        }
+        throw new ConvertException("cannot find converter from " + sourceType.getSimpleName() + " to " +
+            targetType.getSimpleName());
     }
 
+    public <S, T> T convert(S source, Class<T> target, CycleAvoidingMappingContext context) {
+        return convert(source, target, context, null);
+    }
 
     @SuppressWarnings("unchecked")
-    public <S, T> T convert(S source, Class<T> target, CycleAvoidingMappingContext context) {
+    public <S, T> T convert(S source, Class<T> targetType, CycleAvoidingMappingContext context, Consumer<T> beanConsumer) {
         if (source == null) {
             return null;
         }
-        BaseCycleAvoidingMapper<S, T> mapper =
-            (BaseCycleAvoidingMapper<S, T>) converterFactory.getCycleAvoidingMapper(source.getClass(), target);
+        BaseCycleAvoidingMapper<S, T> mapper = (BaseCycleAvoidingMapper<S, T>) converterFactory.getCycleAvoidingMapper(source.getClass(), targetType);
         if (mapper != null) {
-            return mapper.convert(source, context);
+            return mapper.convert(source, context, beanConsumer);
         }
         throw new ConvertException("cannot find converter from " + source.getClass().getSimpleName() + " to " +
-                                   target.getSimpleName());
+            targetType.getSimpleName());
+    }
+
+    public <S, T> List<T> convert(List<S> sourceList, Class<T> targetType, CycleAvoidingMappingContext context) {
+        return convert(sourceList, targetType, context, null);
     }
 
-    public <S, T> List<T> convert(List<S> source, Class<T> targetType, CycleAvoidingMappingContext context) {
-        if (source == null || source.isEmpty()) {
+    @SuppressWarnings("unchecked")
+    public <S, T> List<T> convert(List<S> sourceList, Class<T> targetType, CycleAvoidingMappingContext context, Consumer<T> beanConsumer) {
+        if (sourceList == null || sourceList.isEmpty()) {
             return new ArrayList<>();
         }
-        return source.stream().map(item -> convert(item, targetType, context)).collect(Collectors.toList());
+        Class<?> sourceType = sourceList.getFirst().getClass();
+        BaseCycleAvoidingMapper<S, T> mapper = (BaseCycleAvoidingMapper<S, T>) converterFactory.getCycleAvoidingMapper(sourceType, targetType);
+        if (mapper != null) {
+            return mapper.convert(sourceList, context, beanConsumer);
+        }
+        throw new ConvertException("cannot find converter from " + sourceType.getSimpleName() + " to " + targetType.getSimpleName());
     }
 
+    public <T> T convert(Map<String, Object> map, Class<T> targetType) {
+        return convert(map, targetType, (Consumer<T>) null);
+    }
 
-
-    public <T> T convert(Map<String, Object> map, Class<T> target) {
+    public <T> T convert(Map<String, Object> map, Class<T> targetType, Consumer<T> beanConsumer) {
         if (map == null || map.isEmpty()) {
             return null;
         }
         if (map.values().stream().allMatch(Objects::isNull)) {
             return null;
         }
-        final BaseMapMapper<T> mapper = converterFactory.getMapMapper(target);
+        final BaseMapMapper<T> mapper = converterFactory.getMapMapper(targetType);
         if (mapper != null) {
-            return mapper.convert(map);
+            return mapper.convert(map, beanConsumer);
         }
         throw new ConvertException("cannot find converter from " + map.getClass().getName() + " to " +
-                                   target.getSimpleName());
+            targetType.getSimpleName());
     }
 
 }