Class annotation used to assist in the creation of map constructors in classes. If the class is also annotated with @ImmutableBase, then the generated constructor will contain additional code needed for immutable classes.

It allows you to write classes in this shortened form:

import groovy.transform.*

@TupleConstructor
class Person {
    String first, last
}

@CompileStatic // optional
@ToString(includeSuperProperties=true)
@MapConstructor(pre={ super(args?.first, args?.last); args = args ?: [:] }, post = { first = first?.toUpperCase() })
class Author extends Person {
    String bookName
}

assert new Author(first: 'Dierk', last: 'Koenig', bookName: 'ReGinA').toString() == 'Author(ReGinA, DIERK, Koenig)'
assert new Author().toString() == 'Author(null, null, null)'

The @MapConstructor annotation instructs the compiler to execute an AST transformation which adds the necessary constructor method to your class.

A map constructor is created which sets properties, and optionally fields and super properties if the property/field name is a key within the map.

For the above example, the generated constructor will be something like:

public Author(java.util.Map args) {
    super(args?.first, args?.last)
    args = args ? args : [:]
    if (args.containsKey('bookName')) {
        this.bookName = args['bookName']
    }
    first = first?.toUpperCase()
}

Custom visibility:

• The @MapConstructor annotation generates a public constructor unless an applicable VisibilityOptions annotation is also present. It can be useful to change the visibility if you want to also create a builder or provide your own static factory method for object creation. You can make the constructor private and access it from the builder or your factory method. (Note: you'll probably want to use @CompileStatic in conjunction with such an approach since dynamic Groovy currently gives the ability to access even private constructors.)
• An optional visibilityId attribute can be specified. If present, it must match the optional id attribute of an applicable VisibilityOptions annotation. This can be useful if multiple VisibilityOptions annotations are needed.

Custom property handling:

• The @MapConstructor annotation supports customization using @PropertyOptions which allows a custom property handler to be defined. This is most typically used behind the scenes by the @Immutable meta-annotation but you can also define your own handler. If a custom handler is present, it will determine the code generated when initializing any property (or field).

Known limitations/special cases:

• The generated map constructor will have an argument of type Map unless a single property (or field) is included and the type of that property (or field) is Object, AbstractMap, Map or HashMap. In this case, the generated constructor will be of type LinkedHashMap. This allows the possibility of also adding a tuple constructor without conflict, although no such constructor is added automatically. You can disable this behavior by setting the specialNamedArgHandling annotation attribute to false. This means that for the special case mentioned above, you will not be able to also add a tuple constructor with a single Map argument but you can supply any kind of map as your argument. We'd also recommend not having both a map constructor and a tuple constructor with a single Object, AbstractMap or HashMap since it can cause confusion as to which will be called.