modelmapper · kendarorg · Nov 2, 2025 · Nov 2, 2025 · Nov 2, 2025 · Nov 2, 2025
diff --git a/core/src/main/java/org/modelmapper/ConstructorParam.java b/core/src/main/java/org/modelmapper/ConstructorParam.java
@@ -0,0 +1,34 @@
+package org.modelmapper;
+
+/**
+ * Describe a constructor parameter
+ */
+public class ConstructorParam {
+  private final int index;
+  private final String name;
+  private final Class<?> type;
+
+  /**
+   *
+   * @param index the positional index of the constructor parameter
+   * @param name the literal name used for matchin
+   * @param type type of the parameter
+   */
+  public ConstructorParam(int index, String name, Class<?> type) {
+    this.index = index;
+    this.name = name;
+    this.type = type;
+  }
+
+  public int getIndex() {
+    return index;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public Class<?> getType() {
+    return type;
+  }
+}
diff --git a/core/src/main/java/org/modelmapper/config/Configuration.java b/core/src/main/java/org/modelmapper/config/Configuration.java
@@ -16,6 +16,7 @@
 package org.modelmapper.config;
 
 import org.modelmapper.Condition;
+import org.modelmapper.spi.ConstructorInjector;
 import org.modelmapper.PropertyMap;
 import org.modelmapper.Provider;
 import org.modelmapper.spi.*;
@@ -193,6 +194,13 @@ public enum AccessLevel {
    */
   List<ValueWriter<?>> getValueWriters();
 
+  /**
+   * Gets the constructor injector.
+   *
+   * @see #setConstructorInjector(ConstructorInjector)
+   */
+  ConstructorInjector getConstructorInjector();
+
   /**
    * Returns {@code true} if ambiguous properties are ignored or {@code false} if they will result
    * in an exception.
@@ -482,4 +490,11 @@ public enum AccessLevel {
    * @throws IllegalArgumentException if {@code namingConvention} is null
    */
   Configuration setSourceNamingConvention(NamingConvention namingConvention);
+
+  /**
+   * Allows adding a new constructor injector
+   *
+   * @throws IllegalArgumentException if {@code constructorInjector} is null
+   */
+  Configuration setConstructorInjector(ConstructorInjector constructorInjector);
 }
diff --git a/core/src/main/java/org/modelmapper/convention/ConstructorInjectors.java b/core/src/main/java/org/modelmapper/convention/ConstructorInjectors.java
@@ -0,0 +1,21 @@
+package org.modelmapper.convention;
+
+import org.modelmapper.ConstructorParam;
+import org.modelmapper.spi.ConstructorInjector;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ConstructorInjectors {
+  public static final ConstructorInjector NO_CONSTRUCTOR_INJECTORS = new ConstructorInjector() {
+    @Override
+    public List<ConstructorParam> getParameters(Class<?> destinationType) {
+      return new ArrayList<>();
+    }
+
+    @Override
+    public boolean isApplicable(Class<?> destinationType) {
+      return false;
+    }
+  };
+}
diff --git a/core/src/main/java/org/modelmapper/internal/InheritingConfiguration.java b/core/src/main/java/org/modelmapper/internal/InheritingConfiguration.java
@@ -18,8 +18,10 @@
 import java.util.List;
 
 import org.modelmapper.Condition;
+import org.modelmapper.spi.ConstructorInjector;
 import org.modelmapper.Provider;
 import org.modelmapper.config.Configuration;
+import org.modelmapper.convention.ConstructorInjectors;
 import org.modelmapper.convention.MatchingStrategies;
 import org.modelmapper.convention.NameTokenizers;
 import org.modelmapper.convention.NameTransformers;
@@ -45,6 +47,7 @@
  * @author Jonathan Halterman
  */
 public class InheritingConfiguration implements Configuration {
+  private ConstructorInjector constructorInjector;
   private final Configuration parent;
   public final TypeMapStore typeMapStore;
   public final ConverterStore converterStore;
@@ -96,6 +99,7 @@ public InheritingConfiguration() {
     skipNullEnabled = Boolean.FALSE;
     useOSGiClassLoaderBridging = Boolean.FALSE;
     collectionsMergeEnabled = Boolean.FALSE;
+    constructorInjector = ConstructorInjectors.NO_CONSTRUCTOR_INJECTORS;
   }
 
   /**
@@ -130,6 +134,7 @@ public InheritingConfiguration() {
       preferNestedProperties = source.preferNestedProperties;
       skipNullEnabled = source.skipNullEnabled;
       collectionsMergeEnabled = source.collectionsMergeEnabled;
+      constructorInjector = source.constructorInjector;
     }
   }
 
@@ -265,6 +270,13 @@ public NamingConvention getSourceNamingConvention() {
         : sourceNamingConvention;
   }
 
+  @Override
+  public ConstructorInjector getConstructorInjector() {
+    return constructorInjector == null
+        ? Assert.notNull(parent).getConstructorInjector()
+        : constructorInjector;
+  }
+
   @Override
   public List<ValueReader<?>> getValueReaders() {
     return valueAccessStore.getValueReaders();
@@ -288,6 +300,7 @@ public int hashCode() {
     result = prime * result + getFieldAccessLevel().hashCode();
     result = prime * result + getMethodAccessLevel().hashCode();
     result = prime * result + getSourceNamingConvention().hashCode();
+    result = prime * result + getConstructorInjector().hashCode();
     result = prime * result + getDestinationNamingConvention().hashCode();
     result = prime * result + (isFieldMatchingEnabled() ? 1231 : 1237);
     return result;
@@ -473,6 +486,12 @@ public Configuration setSourceNamingConvention(NamingConvention namingConvention
     return this;
   }
 
+  @Override
+  public Configuration setConstructorInjector(ConstructorInjector constructorInjector) {
+    this.constructorInjector = constructorInjector;
+    return this;
+  }
+
   @Override
   public Configuration setUseOSGiClassLoaderBridging(boolean useOSGiClassLoaderBridging) {
     this.useOSGiClassLoaderBridging = useOSGiClassLoaderBridging;

diff --git a/core/src/main/java/org/modelmapper/internal/MappingEngineImpl.java b/core/src/main/java/org/modelmapper/internal/MappingEngineImpl.java
@@ -17,6 +17,7 @@
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Type;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -42,7 +43,7 @@
 /**
  * MappingEngine implementation that caches ConditionalConverters by source and destination type
  * pairs.
- * 
+ *
  * @author Jonathan Halterman
  */
 public class MappingEngineImpl implements MappingEngine {
@@ -136,20 +137,43 @@ <S, D> D typeMap(MappingContextImpl<S, D> context, TypeMap<S, D> typeMap) {
 
     if (noSkip && typeMap.getConverter() != null)
       return convert(context, typeMap.getConverter());
-
-    if (context.getDestination() == null && Types.isInstantiable(context.getDestinationType())) {
-      D destination = createDestination(context);
-      if (destination == null)
-        return null;
+    if (!configuration.getConstructorInjector().isApplicable(typeMap.getDestinationType())) {
+      if (context.getDestination() == null && Types.isInstantiable(context.getDestinationType())) {
+        D destination = createDestination(context);
+        if (destination == null)
+          return null;
+      }
     }
 
     if (noSkip) {
       Converter<S, D> converter = typeMap.getPreConverter();
-      if (converter != null)
-        context.setDestination(convert(context, converter), true);
+      if (!configuration.getConstructorInjector().isApplicable(typeMap.getDestinationType())) {
+        if (converter != null)
+          context.setDestination(convert(context, converter), true);
+
+        for (Mapping mapping : typeMap.getMappings())
+          propertyMap(mapping, context);
+      } else {
+        List<Mapping> constructorMappings = new ArrayList<Mapping>();
+        List<Object> data = new ArrayList<>();
+        for (Mapping mapping : typeMap.getMappings()) {
+          if (mapping.isConstructor()) {
+            constructorMappings.add(mapping);
+            data.add(constructorMapResolve(mapping, context));
+          }
+        }
+        D destination = createDestination(context, constructorMappings, data);
+        for (Mapping mapping : typeMap.getMappings()) {
+          if (!mapping.isConstructor()) {
+            propertyMap(mapping, context);
+          }
+        }
 
-      for (Mapping mapping : typeMap.getMappings())
-        propertyMap(mapping, context);
+        if (converter != null)
+          context.setDestination(convert(context, converter), true);
+        if (destination == null)
+          return null;
+      }
 
       converter = typeMap.getPostConverter();
       if (converter != null)
@@ -380,4 +404,58 @@ void validateDestination(Class<?> destinationType, Object destination, Errors er
     if (destination != null && !destinationType.isAssignableFrom(destination.getClass()))
       errors.invalidProvidedDestinationInstance(destination, destinationType);
   }
+
+  private <D, S> D createDestination(MappingContext<S, D> context, List<Mapping> constructorMappings, List<Object> values) {
+    MappingContextImpl<S, D> contextImpl = (MappingContextImpl<S, D>) context;
+    D destination = contextImpl.createDestinationViaProvider();
+    if (destination == null) {
+      destination = instantiateWithMappings(context.getDestinationType(), contextImpl.errors, constructorMappings, values);
+    }
+
+    contextImpl.setDestination(destination, true);
+    return destination;
+  }
+
+  private <T> T instantiateWithMappings(Class<T> type, Errors errors, List<Mapping> mappings, List<Object> values) {
+    try {
+      Constructor<?>[] constructors = type.getConstructors();
+      Constructor<T> defaultCtor = null;
+      Constructor<T> otherConstructor = null;
+      for (Constructor<?> ctor : constructors) {
+        if (ctor.getParameterTypes().length == 0) {
+          defaultCtor = (Constructor<T>) ctor;
+          break;
+        } else if (ctor.getParameterTypes().length == values.size()) {
+          otherConstructor = (Constructor<T>) ctor;
+        }
+      }
+
+      if (otherConstructor != null && defaultCtor == null) {
+        if (!otherConstructor.isAccessible()) otherConstructor.setAccessible(true);
+        List<Object> realValues = new ArrayList<>();
+        for (int i = values.size() - 1; i >= 0; i--) {
+          realValues.add(values.get(i));
+        }
+        return otherConstructor.newInstance(realValues.toArray());
+      }
+      if (!defaultCtor.isAccessible()) defaultCtor.setAccessible(true);
+      return defaultCtor.newInstance();
+
+
+    } catch (Exception e) {
+      errors.errorInstantiatingDestination(type, e);
+      return null;
+    }
+  }
+
+  private <S, D> Object constructorMapResolve(Mapping mapping, MappingContextImpl<S, D> context) {
+
+    MappingImpl mappingImpl = (MappingImpl) mapping;
+    String propertyPath = context.destinationPath + mappingImpl.getPath();
+    if (context.isShaded(propertyPath)) return null;
+    if (mapping.getCondition() == null && mapping.isSkipped()) // skip()
+      return null;
+
+    return resolveSourceValue(context, mapping);
+  }
 }
diff --git a/core/src/main/java/org/modelmapper/internal/MappingImpl.java b/core/src/main/java/org/modelmapper/internal/MappingImpl.java
@@ -37,6 +37,20 @@ abstract class MappingImpl implements InternalMapping, Comparable<MappingImpl> {
   protected Provider<?> provider;
   protected Converter<?, ?> converter;
 
+  /**
+   * Check if has a constructor mutator
+   * @return
+   */
+  @Override
+  public boolean isConstructor() {
+      for(PropertyInfo destinationMutator : destinationMutators){
+          if(destinationMutator.getClass()== PropertyInfoImpl.ConstructorMutator.class ){
+              return true;
+          }
+      }
+      return false;
+  }
+
   /**
    * Creates an implicit mapping.
    */

diff --git a/core/src/main/java/org/modelmapper/internal/PropertyInfoImpl.java b/core/src/main/java/org/modelmapper/internal/PropertyInfoImpl.java
@@ -110,6 +110,32 @@ public TypeInfo<?> getTypeInfo(InheritingConfiguration configuration) {
     }
   }
 
+  static class ConstructorMutator extends PropertyInfoImpl<Method> implements Mutator, PropertyInfo {
+    ConstructorMutator(String name, Class<?> initialType) {
+      super(initialType,null, PropertyType.CONSTRUCTOR, name);
+    }
+
+    @Override
+    public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
+      return null;
+    }
+
+    @Override
+    public void setValue(Object subject, Object value) {
+
+    }
+
+    @Override
+    public TypeInfo<?> getTypeInfo(InheritingConfiguration configuration) {
+      return TypeInfoRegistry.typeInfoFor(type, configuration);
+    }
+
+    @Override
+    public Type getGenericType() {
+      return type;
+    }
+  }
+
   static class MethodMutator extends AbstractMethodInfo implements Mutator {
     MethodMutator(Class<?> initialType, Method method, String name) {
       super(initialType, method, name);

diff --git a/core/src/main/java/org/modelmapper/internal/PropertyInfoSetResolver.java b/core/src/main/java/org/modelmapper/internal/PropertyInfoSetResolver.java
@@ -19,7 +19,10 @@
 import java.lang.reflect.Member;
 import java.lang.reflect.Modifier;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
+import org.modelmapper.spi.ConstructorInjector;
+import org.modelmapper.ConstructorParam;
 import org.modelmapper.config.Configuration;
 import org.modelmapper.config.Configuration.AccessLevel;
 import org.modelmapper.internal.util.Types;
@@ -33,7 +36,7 @@
 
 /**
  * Resolves sets of PropertyInfo for a type's accessors or mutators.
- * 
+ *
  * @author Jonathan Halterman
  */
 final class PropertyInfoSetResolver {
@@ -132,6 +135,17 @@ private static <M extends AccessibleObject & Member, PI extends PropertyInfo> Ma
     if (superType != null && superType != Object.class && superType != Enum.class)
       properties.putAll(resolveProperties(initialType, superType, resolveRequest));
 
+    ConstructorInjector constructorInjector = resolveRequest.config.getConstructorInjector();
+    if (constructorInjector.isApplicable(type)) {
+      List<ConstructorParam> props = constructorInjector.getParameters(type);
+      for (ConstructorParam member : props) {
+        if (resolveRequest.namingConvention.applies(member.getName(), PropertyType.FIELD)) {
+          String name = resolveRequest.nameTransformer.transform(member.getName(), PropertyType.FIELD.equals(resolveRequest.propertyType) ? NameableType.FIELD : NameableType.METHOD);
+          properties.put(name, buildConstructorMutator(initialType, member, resolveRequest.config, name));
+        }
+      }
+    }
+
     for (M member : resolveRequest.propertyResolver.membersFor(type)) {
       if (canAccessMember(member, resolveRequest.accessLevel)
           && resolveRequest.propertyResolver.isValid(member)
@@ -156,6 +170,11 @@ private static <M extends AccessibleObject & Member, PI extends PropertyInfo> Ma
     return properties;
   }
 
+  @SuppressWarnings("unchecked")
+  private static <PI extends PropertyInfo> PI buildConstructorMutator(Class<?> initialType, ConstructorParam member, Configuration config, String name) {
+    return (PI) new PropertyInfoImpl.ConstructorMutator(name, initialType);
+  }
+
   @SuppressWarnings("unchecked")
   private static <M extends AccessibleObject & Member, PI extends PropertyInfo> ResolveRequest<M, PI> resolveRequest(
       Configuration configuration, boolean access, boolean field) {