MapStruct is a compile-time code generator that simplifies mapping between Java Beans. 1. It automatically generates implementation classes by defining interfaces to avoid manually writing lengthy set/get mapping code; 2. It has type-safe, no runtime overhead, supports automatic mapping of the same name fields, custom expressions, nested objects and collection mapping; 3. It can be integrated with Spring and injects mapper into Spring beans using @Mapper(componentModel = "spring"); 4. It has simple configuration, just introduce mapstruct dependencies and annotationProcessorPaths plug-in; 5. It supports @Named and other annotations to implement reusable custom mapping logic, improving the neatness and maintainability of the code, which is one of the best practices for handling object mapping in Java.

If you've ever found yourself writing endless boilerplate code to copy data from one Java object (like a DTO) to another (like an entity), you know how tedious and error-prone it can be. That's where MapStruct comes in — a compile-time code generator that makes bean mapping in Java not just easier, but practically painful.

What Is MapStruct?

MapStruct is a code generator that simplifies mapping between Java beans (eg, from a JPA entity to a REST DTO). Instead of manually writing setX(getX()) for every field, you define an interface, and MapStruct generates the implementation at compile time — no reflection, no runtime overhead, just fast, clean, readable code.

Why MapStruct Over Manual Mapping or Other Libraries?

• ? Type-safe : Errors caught at compile time, not runtime.
• ? No runtime overhead : Generated code is plain Java — no reflection or proxies.
• ? Minimal boilerplate : Write an interface, get an implementation.
• ? Smart defaults : Automatically maps fields with the same name.
• ? Customizable : Handle name mismatches, nested objects, collections, and even custom logic.

Quick Example

Say you have:

 public class User {
    private Long id;
    private String firstName;
    private String lastName;
    private String email;
    // getters setters
}

public class UserDto {
    private String fullName; // maps firstName lastName
    private String email;
}

With MapStruct, create a mapper interface:

 @Mapper
public interface UserMapper {
    UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);

    @Mapping(target = "fullName", expression = "java(user.getFirstName() \" \" user.getLastName())")
    UserDto toDto(User user);
}

Then use it:

 User user = new User();
user.setFirstName("John");
user.setLastName("Doe");
user.setEmail("john@example.com");

UserDto dto = UserMapper.INSTANCE.toDto(user);
// dto.getFullName() → "John Doe"

Key Features You'll Love

1. Auto-Mapping by Name

If field names match (like email ), no extra config needed.

2. Custom Mapping Logic

Use @Mapping with:

• expression for inline Java expressions
• qualifiedByName for reusable custom methods
• @AfterMapping for post-processing logic

3. Nested Objects & Collections

MapStruct handles List<User> ? List<UserDto> automatically — no extra code.

4. Integration with Spring

Just add componentModel = "spring" :

 @Mapper(componentModel = "spring")
public interface UserMapper {
    UserDto toDto(User user);
}

Now it's a Spring bean — inject it like any other.

Setup (Maven)

Add to pom.xml :

 <dependency>
    <groupId>org.mastruct</groupId>
    <artifactId>mastruct</artifactId>
    <version>1.5.5.Final</version>
</dependency>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
        <annotationProcessorPaths>
            <path>
                <groupId>org.mastruct</groupId>
                <artifactId>mastruct-processor</artifactId>
                <version>1.5.5.Final</version>
            </path>
        </annotationProcessorPaths>
    </configuration>
</plugin>

Pro Tip: Use @Named for Reusable Logic

 @Mapper
public interface UserMapper {
    @Mapping(target = "fullName", qualifiedByName = "toFullName")
    UserDto toDto(User user);

    @Named("toFullName")
    default String toFullName(User user) {
        return user.getFirstName() " " user.getLastName();
    }
}

This keeps your mappings clean and reusable across multiple mappers.

MapStruct removes the friction from object mapping — no more manual copying, no more runtime surprises. Once you start using it, you'll wonder how you ever lived without it.
Basically, if you're doing bean mapping in Java and not using MapStruct, you're doing it the hard way.

The above is the detailed content of Using MapStruct for Painless Bean Mapping in Java. For more information, please follow other related articles on the PHP Chinese website!