docs: protected void createServletWrappers() throws Exception {
          // NOTE: namespace preinvoke/postinvoke not necessary as the only
          // external
          // code being run is the servlet's init() and that is handled in the
          // ServletWrapper
  
          // check if an extensionFactory is present for *.jsp:
          // We do this by constructing an arbitrary mapping which
          // will only match the *.xxx extension pattern
          //
          if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE))
              logger.entering(CLASS_NAME, "createServletWrappers");
  
          WebExtensionProcessor jspProcessor = (WebExtensionProcessor) requestMapper.map("/dummyPath.jsp");
  
          if (jspProcessor == null) {
              // No extension processor present to handle this kind of
              // target. Hence warn, skip.
              // pk435011
              // LIBERTY: changing log level to debug as this is valid if there's no JSP support configured
              if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE))
                  logger.logp(Level.FINE, CLASS_NAME, "createServletWrappers", "No Extension Processor found for handling JSPs");
              //logger.logp(Level.WARNING, CLASS_NAME, "createServletWrappers", "no.jsp.extension.handler.found");
  
          }
  
          Iterator<IServletConfig> sortedServletConfigIterator = sortNamesByStartUpWeight(config.getServletInfos());
          Map<String, List<String>> mappings = config.getServletMappings();
          String path = null;
          IServletConfig servletConfig;
          IServletWrapper wrapper = null;
          while (sortedServletConfigIterator.hasNext() && !com.ibm.ws.webcontainer.osgi.WebContainer.isServerStopping()) {
              wrapper = null; // 248871: reset wrapper to null
              servletConfig = sortedServletConfigIterator.next();
              String servletName = servletConfig.getServletName();
              List<String> mapList = mappings.get(servletConfig.getServletName());
              servletConfig.setServletContext(this.getFacade());
  
              // Begin 650884
              // WARNING!!! We shouldn't map by name only as there is
              // no way to configure a security constraint
              // for a dynamically added path.
  
              //Consolidate the code to setup a single entry map list when its mapped by name only
              // if (mapList==null){
              // //WARNING!!! We shouldn't map by name only as there is
              // //no way to configure a security constraint
              // //for a dynamically added path.
              // //Also, if there was nothing mapped to the servlet
  //                              //in web.xml, we would have never called WebAppConfiguration.addServletMapping
  //                              //which sets the mappings on sconfig. Adding the list directly to the hashMap short
  //                              //circuits that logic so future calls to addMapping on the ServletConfig wouldn't work
              // //unless there was at least one mapping in web.xml
              //                  
              //                  
              // // hardcode the path, since it had no mappings
              // String byNamePath = BY_NAME_ONLY + servletName;
              //
              // // Add this to the config, because we will be looking at
              // // the mappings in order to get to the servlet through the
              // // mappings in the config.
              // mapList = new ArrayList<String>();
              // mapList.add(byNamePath);
              // mappings.put(servletName, mapList);
              // }
              // End 650884
  
              if (mapList == null || mapList.isEmpty()) {
                  wrapper = jspAwareCreateServletWrapper(jspProcessor,
                                                         servletConfig, servletName);
              }
              else {
                  for (String urlPattern : mapList) {
                      path = urlPattern;
  
                      if (path == null) {
                          // shouldn't happen since there is a mapping specified
                          // but too bad the user can never hit the servlet
                          // pk435011
                          // Begin 650884
                          logger.logp(Level.SEVERE, CLASS_NAME, "createServletWrappers", "illegal.servlet.mapping", servletName); // PK33511
                          // path = "/" + BY_NAME_ONLY + "/" + servletName;
                          // End 650884
                      } else if (path.equals("/")) {
                          path = "/*";
                      }
  
                      if (wrapper == null) { // 248871: Check to see if we've
                          // already found wrapper for
                          // servletName
  
                          wrapper = jspAwareCreateServletWrapper(jspProcessor,
                                                                 servletConfig, servletName);
  
                          if (wrapper == null)
                              continue;
                      }
                      try {
                          // Begin:248871: Check to see if we found the wrapper
                          // before adding
                          if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE))
                              logger.logp(Level.FINE, CLASS_NAME, "createServletWrappers"
                                          , "determine whether to add mapping for path[{0}] wrapper[{1}] isEnabled[{2}]"
                                          , new Object[] { path, wrapper, servletConfig.isEnabled() });
                          if (path != null && servletConfig.isEnabled()) {
                              requestMapper.addMapping(path, wrapper);
                          }
                          // End:248871
                      } catch (Exception e) {
                          //TODO: ???? extension processor used to call addMappingTarget after the wrappers had been added.
                          //Now it is done before, and you can get this exception here in the case they call addMappingTarget
                          //and add the mapping to the servletConfig because we'll try to add it again, but it will
                          //already be mapped. You could add a list of paths to ignore and not try to add again. So any
                          //path added via addMappingTarget will be recorded and addMapping can be skipped. It is preferrable
                          //to just have them not call addMappingTarget any more instead of adding the extra check.
                          // pk435011
                          logger.logp(Level.WARNING, CLASS_NAME, "createServletWrappers", "error.while.adding.servlet.mapping.for.path", new Object[] {
                                      path, wrapper, getApplicationName() });
                          if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) {
                              com.ibm.wsspi.webcontainer.util.FFDCWrapper.processException(e, CLASS_NAME + ".createServletWrappers", "455", this);
                              // pk435011
                              logger.logp(Level.SEVERE, CLASS_NAME, "createServletWrappers", "error.adding.servlet.mapping.for.servlet", new Object[] {
                                          servletName, getApplicationName(), e }); // PK33511
                          }
                      }
                  }
              }
  
              servletConfig.setServletWrapper(wrapper);
  
              this.initializeNonDDRepresentableAnnotation(servletConfig);
              // set the servlet wrapper on the
              // servlet config so
              // ServletConfig.addMapping
              // can put it in the
              // requestMapper
  
          }
      }