Why does the @PostConstruct of the subclass work in this case?

Question

I have the following Spring Bean structure:

public abstract class XmlBaseChild {
    protected Integer value;
    protected String text;

@Autowired
transient protected MasterCodeService masterCodeService;



    public XmlBaseChild(Integer value) {
        setValue(value);
    }

    /**
     * Set the Numeric value of the ChildView.
     * This code is common for all childViews and handles a null value.
     * @param value Numeric value of the ChildView
     */
    @JsonProperty(value="id")
    public void setValue(Integer value) {
        if (value == null) {
                this.value = null;
                this.text = null;
                return;
        }
        setConcreteValue(value);
    }

    /**
     * Set the Numeric value of the ChildView.
     * This code must be overridden by the concrete childViews.
     * @param value Numeric value of the ChildView
     */
    protected void setConcreteValue(Integer value){
        boolean keyNotFound = true;
        if (value != null && value > -1) {
            this.value = value;
            String messageKey = getValueFromMap(value, GetMasterCodeMapForChildView());
            if (messageKey != null) {
                this.text = LocalizeString(messageKey, null, getLocale);
                keyNotFound = false;
            }
        }
        if (keyNotFound){
            throw new NotFoundException();
        }
    }

    protected abstract Map<String, MasterCodeView> GetMasterCodeMapForChildView();
}

And the subclass:

@Component
@XmlRootElement(name=XmlDeployTool.VIEW_NAME)
public class XmlDeployTool extends XmlBaseChild {

    public static Map<String, MasterCodeView> toolTypeCodes = new HashMap<String, MasterCodeView>();


    /**
     * Constructor for creating this object and preparing for marchalling (from java objects to xml/json).
     * @param value         Numeric value of the ChildView
     * @param request       HttpServletRequest
     * @param includeSelf   Include SELF link
     * @param includeUP     Include UP link
     */
    public XmlDeployTool(Integer value) {
        super(value);
    }

    /**
     * Initialize the Tool Type codes after the component is wired (postconstruct),
     * so that they are available in the constructor when an XmlDeploy object is created.
    */
    @PostConstruct
    protected void initializeDeployToolTypeCodes() {
    toolTypeCodes = convertListToMap(masterCodeService.getToolTypeCodes());
    }
    @Override
    protected Map<String, MasterCodeView> GetMasterCodeMapForChildView() {
        return toolTypeCodes;
    }
}

However, from what I understand from other posts like Order of @PostConstruct and inheritance, the @PostConstruct here normally executes AFTER the constructor is called. Then why is the toolTypeCodes map populated during the constructor? Is this part of the @Component annotation of Spring?

I also tried doing this with the masterCodeView map defined in the XmlBaseChild and only the PostConstruct method defined in the XmlDeployTool class, but that didn't work, the list didn't get initialized in that case. Why is this?

Answer 1

After checking the documentation and reading up some more, I figured out what's going on here:

1. Because my subclass is annotated with @Component, the PostConstruct triggers as part of the Spring startup process, even before any invocations of the normal constructor. Because of this, the static Map with MasterCodeViews gets populated, and since this is static, it stays populated as part of the subclass static properties. Because of this, this map has the proper usable data during construction.

2. When I tried to move the Map to the base class, In effect I turned this from a static property of the subclass to a static property of the subclass, which meant each constructor in turn populated it with the separate properties, leading to the map having the wrong data most of the time. When after that I tried to do this with a non-static map, the data wasn't retained when I invoked the constructor from code because this was effectively a new object with no initialized components.