docs: @Override
      protected void initialize(boolean reactivate) throws RemoteException, InvocationTargetException {
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
          if (isTraceOn && tc.isEntryEnabled())
              Tr.entry(tc, "initialize");
  
          //---------------------------------------------------------
          // Set state to PRE_CREATE so only methods that we permitted
          // to be called setSessionContext or dependency injection
          // (e.g. getEJBHome) are allowed and those methods that are
          // not allowed (e.g. getEJBObject) result in IllegalStateException.
          //---------------------------------------------------------
          state = PRE_CREATE;
  
          // d367572.1 start
          allowRollbackOnly = false;
          ivNumberOfBeansLimited = false; // PK20648
  
          CallbackContextHelper contextHelper = null; // d399469
          try // d399469
          {
              // Create the interceptor instances if there are interceptor
              // classes for this bean instance.
              BeanMetaData bmd = null;
              if (home == null) {
                  // This SLSB must a home bean, so there is no InterceptorMetaData
                  // to process.  Also, no need to ensure unspecified TX context since
                  // a home is not required to be a EJB by EJB specs. Thus, we can
                  // implement it however we desire to implement it.
              } else {
                  // Note that the local transaction surrounds injection methods
                  // and PostConstruct lifecycle callbacks.
                  bmd = home.beanMetaData;
                  contextHelper = new CallbackContextHelper(this); // d630940
                  contextHelper.begin(CallbackContextHelper.Tx.CompatLTC,
                                      CallbackContextHelper.Contexts.CallbackBean);
  
                  // Not a home bean, so set the BeanId for the SLSB.
                  setId(home.ivStatelessId); // d140003.12
  
                  // Cache whether or not the number of beans are limited.   PK20648
                  if (home.beanMetaData.ivMaxCreation > 0) {
                      ivNumberOfBeansLimited = true;
                  }
  
                  createInterceptorsAndInstance(contextHelper);
  
                  // Now set the SessionContext and/or do the dependency injection.
                  // Note that dependency injection must occur while in PRE_CREATE state.
                  injectInstance(ivManagedObject, ivEjbInstance, this);
              }
  
              //---------------------------------------------------------
              // Now that the SessionContext is set and/or dependencies
              // injection has occurred, change state to CREATING state to allow
              // additional methods to be called by the ejbCreate or
              // PostConstruct interceptor methods (e.g. getEJBObject).
              // This ensures CMVC defect 70091 is not reintroduced.
              //---------------------------------------------------------
              setState(CREATING);
  
              //-------------------------------------------------------------------
              // Call ejbCreate on PostConstruct interceptor method.
              // In EJB 3, the ejbCreate method is considered a PostContruct method
              // for Stateless session bean (which is not true for Stateful session
              // bean).  Also, for any given class, regardless of whether class
              // is the bean class or not, only 1 PostConstruct is allowed.
              //-------------------------------------------------------------------
  
              // Determine of life cycle callback to make if any.
              if (ivCallbackKind == CallbackKind.SessionBean) {
                  // This is not a home bean since CallbackKind would be NONE for homes.
                  // Therefore, the bmd variables should be set.
                  Method m = bmd.ivEjbCreateMethod; //d453778
                  if (m != null) //d453778
                  {
                      // This is a 1.x/2.x SLSB that has a ejbCreate method in it.
                      try {
                          if (isTraceOn && // d527372
                              TEBeanLifeCycleInfo.isTraceEnabled()) {
                              TEBeanLifeCycleInfo.traceEJBCallEntry("ejbCreate"); // d161864
                          }
                          m.invoke(ivEjbInstance, new Object[] {});
                      } catch (InvocationTargetException itex) {
                          FFDCFilter.processException(itex, CLASS_NAME + ".StatelessBeanO",
                                                      "110", 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;
  
                          // This kind of SLSB 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.
                          throw new CreateFailureException(targetEx);
                      } catch (Throwable ex) {
                          // This kind of SLSB 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.
                          FFDCFilter.processException(ex, CLASS_NAME + ".StatelessBeanO", "401", this);
                          throw new CreateFailureException(ex);
                      } finally {
                          if (isTraceOn && // d527372
                              TEBeanLifeCycleInfo.isTraceEnabled()) {
                              TEBeanLifeCycleInfo.traceEJBCallExit("ejbCreate"); // d161864
                          }
                      }
                  }
              } else if (ivCallbackKind == CallbackKind.InvocationContext) {
                  // This is a 3.x SLSB that may have one or more PostConstruct interceptors
                  // methods. Invoke PostContruct interceptors if there is atleast 1
                  // PostConstruct interceptor.
  
                  InterceptorMetaData imd = bmd.ivInterceptorMetaData;
  
                  if (imd != null) // d402681
                  {
                      InterceptorProxy[] proxies = imd.ivPostConstructInterceptors;
                      if (proxies != null) {
                          callLifecycleInterceptors(proxies, LifecycleInterceptorWrapper.MID_POST_CONSTRUCT); // F743-1751
                      }
                  }
              }
  
              //---------------------------------------------------------
              // Now that create has completed, allow setRollbackOnly to
              // be called on the SessionContext and change state to the
              // POOLED state to indicate the SLSB is in the method-ready
              // pool state and business methods are now allowed to be
              // invoked on this session bean.
              //---------------------------------------------------------
              allowRollbackOnly = true;
              setState(POOLED);
              // d367572.1 end of change.
          } finally // d399469
          {
              // Resume the TX context if it was suspended.
              if (contextHelper != null) // d399469
              {
                  contextHelper.complete(true);
              }
              if (isTraceOn && tc.isEntryEnabled())
                  Tr.exit(tc, "initialize : " + this);
          }
      }