docs: @Override
      protected void initialize(boolean reactivate) throws RemoteException, InvocationTargetException {
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
          if (isTraceOn && tc.isEntryEnabled()) {
              Tr.entry(tc, "initialize");
          }
  
          BeanMetaData bmd = home.beanMetaData;
          ivCallbackKind = bmd.ivCallbackKind;
  
          state = PRE_CREATE; // d159152
  
          CallbackContextHelper contextHelper = new CallbackContextHelper(this); // d630940
          try {
              // Disallow setRollbackOnly until create is done.
              allowRollbackOnly = false;
  
              // Set the BeanId for this MDB. Just like we do for SLSB,
              // we use the BeanId for the home bean so that the same ID
              // is used for all MDB instances. Note the ivStatelessId is
              // for the home bean, which is implemented as a SLSB.
              if (home != null) {
                  setId(home.ivStatelessId); // d140003.12
              }
  
              // Note that the local transaction surrounds injection methods and
              // PostConstruct lifecycle callbacks.
              contextHelper.begin(CallbackContextHelper.Tx.CompatLTC,
                                  CallbackContextHelper.Contexts.CallbackBean); // d630940
  
              InterceptorMetaData imd = bmd.ivInterceptorMetaData;
              createInterceptorsAndInstance(contextHelper);
  
              // Now set the MessageDrivenContext and/or do the dependency injection.
              // Note that dependency injection must occur while in PRE_CREATE state.
              injectInstance(ivManagedObject, ivEjbInstance, this);
  
              //---------------------------------------------------------
              // Now that the MessageDrivenContext is set and/or dependencies
              // injection has occured, change state to CREATING state to allow
              // additional methods to be called by the ejbCreate or
              // PostConstruct interceptor methods (e.g. getEJBObject).
              //---------------------------------------------------------
              setState(CREATING); //d399469.2
  
              // Determine of life cycle callback to make if any.
              if (ivCallbackKind == CallbackKind.MessageDrivenBean) {
                  Method m = bmd.ivEjbCreateMethod; //d453778
                  if (m != null) //d453778
                  {
                      // This is a 2.x MDB that has a ejbCreate method in it.
                      try {
                          if (isTraceOn && // d527372
                              TEBeanLifeCycleInfo.isTraceEnabled()) {
                              TEBeanLifeCycleInfo.traceEJBCallEntry("ejbCreate");
                          }
                          m.invoke(ivEjbInstance, new Object[] {});
                      } catch (InvocationTargetException itex) {
                          //FFDCFilter.processException(itex, CLASS_NAME + ".MessageDrivenBeanO", "96", this);
  
                          // All exceptions returned through a reflect method call
                          // are wrapped... making it difficult to debug a problem
                          // since InovcationTargetException does not print the root
                          // exception. Unwrap the 'target' exception so that the
                          // client will see it as the cause of the
                          // CreateFailureException.                        d534353.1
                          Throwable targetEx = itex.getCause();
                          if (targetEx == null)
                              targetEx = itex;
  
                          // MDB 2.x is allowed to throw application exceptions as well as
                          // javax.ejb.CreateException. Continue to wrap with a CreateFailureException
                          // to ensure no behavior change with prior releases.
                          if (isTraceOn && tc.isDebugEnabled()) {
                              Tr.debug(tc, "MDB ejbCreate failure", targetEx);
                          }
                          throw new CreateFailureException(targetEx);
                      } catch (Throwable ex) {
                          //FFDCFilter.processException(ex, CLASS_NAME + ".MessageDrivenBeanO", "96", this);
  
                          // MDB 2.x is allowed to throw application exceptions as well as
                          // javax.ejb.CreateException. Continue to wrap with a CreateFailureException
                          // to ensure no behavior change with prior releases.
                          if (isTraceOn && tc.isDebugEnabled()) {
                              Tr.debug(tc, "MDB ejbCreate failure", ex);
                          }
                          throw new CreateFailureException(ex);
                      } finally {
                          if (isTraceOn && // d527372
                              TEBeanLifeCycleInfo.isTraceEnabled()) {
                              TEBeanLifeCycleInfo.traceEJBCallExit("ejbCreate");
                          }
                      }
                  }
              } else if (ivCallbackKind == CallbackKind.InvocationContext) {
                  // This is a MDB 3 that may have one or more PostConstruct interceptors
                  // methods. Invoke PostContruct interceptors if there is atleast 1
                  // PostConstruct interceptor.
                  try {
                      if (imd != null) // d402681
                      {
                          InterceptorProxy[] proxies = imd.ivPostConstructInterceptors;
                          if (proxies != null) {
                              if (isTraceOn && // d527372
                                  TEBeanLifeCycleInfo.isTraceEnabled()) {
                                  TEBeanLifeCycleInfo.traceEJBCallEntry("PostConstruct");
                              }
                              InvocationContextImpl<?> inv = getInvocationContext();
                              inv.doLifeCycle(proxies, bmd._moduleMetaData); //d450431, F743-14982
                          }
                      }
                  } catch (Throwable t) {
                      //FFDCFilter.processException(t, CLASS_NAME + ".MessageDrivenBeanO", "281", this);
  
                      // PostConstruct interceptors are allowed to throw system runtime exceptions,
                      // but NOT application exceptions. Therefore, wrap the caught Throwable
                      // in a javax.ejb.EJBException so that it gets handled as an unchecked
                      // exception.
                      if (isTraceOn && tc.isDebugEnabled()) {
                          Tr.debug(tc, "MDB PostConstruct failure", t);
                      }
                      throw ExceptionUtil.EJBException("MDB PostConstruct failure", t);
                  } finally {
                      if (isTraceOn && // d527372
                          TEBeanLifeCycleInfo.isTraceEnabled() &&
                          imd != null &&
                          imd.ivPostConstructInterceptors != null) {
                          TEBeanLifeCycleInfo.traceEJBCallExit("PostConstruct");
                      }
                  }
              } // d367572.1 end
  
              //---------------------------------------------------------
              // Now that create has completed, allow setRollbackOnly to
              // be called on the SessionContext and change state to the
              // POOLED state to indicate the MDB is in the method-ready
              // pool state and message listener methods are now allowed to be
              // invoked on this MDB.
              //---------------------------------------------------------
              allowRollbackOnly = true;
              setState(POOLED);
          } finally // d399469
          {
              contextHelper.complete(true);
          }
  
          if (isTraceOn && tc.isEntryEnabled()) {
              Tr.exit(tc, "initialize");
          }
      }