Fork me on GitHub

framework/SpringSecurity/会话管理

会话管理

Session+cookie，token+存储(redis)

核心：

JWT

XSS核心就是 同源访问，就是正常用户的访问，原因在于 别的用户在提交表单时 写出了一些特殊js脚本，然后服务端没有转义，所以造成了， 当前用户再浏览到 哪个提交表单用户的提交内容是，自然的执行了脚本，很可怕，所以这种拦截，再一开始就必须杀死，处理：转义

展开全文 >>

framework/Elasticsearch/Elasticsearch概念

Elasticsearch概念

搜索：通过一个关键字或一段描述，得到想要的相关度高的结果

实现搜索功能：关系型数据库性能差，不可靠，结果不准确

倒排索引数据结构：1包含关键字的document list 2 关键字在每个doc中出现的次数 TF （词频term Frequency） 3关键字在整个索引中出现的次数IDF （inverse doc frequency） 4 关键字在当前doc中出现的次数 5 每个doc的长度，越长相关度越低 6包含这个关键字的所有doc的平均长度

TF 高 ，代表相关度高

IDF高，代表相关度低

展开全文 >>

操作系统/进程线程纤程

进程：OS分配资源的基本单位，一个进程的启动，os会为他分配属于它的内存空间

线程：cpu调度的基本单位，没有独立空间，共享进程的内存空间（1m）

纤程：就是线程中的线程，需要用户程序处理线程时模拟操作系统对线程的调度，Fiber(4k空间，切换快)(很短计算任务，不需要内核打交道)（IO资源还是要线程）

展开全文 >>

web/tomcat/tomcat配置解析

Tomcat配置解析

server.xml解析

1
2
3
4
5
6
7

catalina类下的load方法里面开始解析server.xml
由于使用的是SAX解析，所以只需要关注三个回调方法
    startElement
    characters
    endElement
    当然其他回调也需要关注一下

startElement

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

@Override
    public void startElement(String namespaceURI, String localName, String qName, Attributes list)
            throws SAXException {
        boolean debug = log.isDebugEnabled();

        if (saxLog.isDebugEnabled()) {
            saxLog.debug("startElement(" + namespaceURI + "," + localName + "," + qName + ")");
        }
        // 把一个标签的属性解析出来经过系统属性替换后返回
        // Parse system properties
        list = updateAttributes(list);

        // Save the body text accumulated for our surrounding element
        // 保存这个bodyText，用于弹出使用
        bodyTexts.push(bodyText);
        bodyText = new StringBuilder();

        // the actual element name is either in localName or qName, depending on whether the parser is namespace aware
        String name = localName;
        if ((name == null) || (name.length() < 1)) {
            name = qName;
        }

        // Compute the current matching rule
        StringBuilder sb = new StringBuilder(match);
        if (match.length() > 0) {
            sb.append('/');
        }
        sb.append(name);
        match = sb.toString();
        if (debug) {
            log.debug("  New match='" + match + "'");
        }

        // Fire "begin" events for all relevant rules
        // 根据初始化时给定了一些匹配规则，所以，它对应server标签的规则全部取出
        List<Rule> rules = getRules().match(namespaceURI, match);
        matches.push(rules);
        if ((rules != null) && (rules.size() > 0)) {
            for (Rule value : rules) {
                //使用规则开始解析
                try {
                    Rule rule = value;
                    if (debug) {
                        log.debug("  Fire begin() for " + rule);
                    }
                    rule.begin(namespaceURI, name, list);
                } catch (Exception e) {
                    log.error("Begin event threw exception", e);
                    throw createSAXException(e);
                } catch (Error e) {
                    log.error("Begin event threw error", e);
                    throw e;
                }
            }
        } else {
            if (debug) {
                log.debug("  No rules found matching '" + match + "'.");
            }
        }

    }

characters

1
2
3
4
5
6
7
8
9
10
@Override
public void characters(char buffer[], int start, int length) throws SAXException {

    if (saxLog.isDebugEnabled()) {
        saxLog.debug("characters(" + new String(buffer, start, length) + ")");
    }
//就是把标签中间的文本容放到指定的bodyText存储
    bodyText.append(buffer, start, length);

}

endElement

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
@Override
  public void endElement(String namespaceURI, String localName, String qName)
          throws SAXException {

      boolean debug = log.isDebugEnabled();

      if (debug) {
          if (saxLog.isDebugEnabled()) {
              saxLog.debug("endElement(" + namespaceURI + "," + localName + "," + qName + ")");
          }
          log.debug("  match='" + match + "'");
          log.debug("  bodyText='" + bodyText + "'");
      }

      // Parse system properties
      bodyText = updateBodyText(bodyText);

      // the actual element name is either in localName or qName, depending
      // on whether the parser is namespace aware
      String name = localName;
      if ((name == null) || (name.length() < 1)) {
          name = qName;
      }

      // Fire "body" events for all relevant rules
      List<Rule> rules = matches.pop();
      if ((rules != null) && (rules.size() > 0)) {
          String bodyText = this.bodyText.toString().intern();
          for (Rule value : rules) {
              try {
                  Rule rule = value;
                  if (debug) {
                      log.debug("  Fire body() for " + rule);
                  }
                  rule.body(namespaceURI, name, bodyText);
              } catch (Exception e) {
                  log.error("Body event threw exception", e);
                  throw createSAXException(e);
              } catch (Error e) {
                  log.error("Body event threw error", e);
                  throw e;
              }
          }
      } else {
          if (debug) {
              log.debug("  No rules found matching '" + match + "'.");
          }
          if (rulesValidation) {
              log.warn("  No rules found matching '" + match + "'.");
          }
      }

      // Recover the body text from the surrounding element
      bodyText = bodyTexts.pop();

      // Fire "end" events for all relevant rules in reverse order
      if (rules != null) {
          for (int i = 0; i < rules.size(); i++) {
              int j = (rules.size() - i) - 1;
              try {
                  Rule rule = rules.get(j);
                  if (debug) {
                      log.debug("  Fire end() for " + rule);
                  }
                  rule.end(namespaceURI, name);
              } catch (Exception e) {
                  log.error("End event threw exception", e);
                  throw createSAXException(e);
              } catch (Error e) {
                  log.error("End event threw error", e);
                  throw e;
              }
          }
      }

      // Recover the previous match expression
      int slash = match.lastIndexOf('/');
      if (slash >= 0) {
          match = match.substring(0, slash);
      } else {
          match = "";
      }

  }

web.xml解析

Engine – > Host–>content

HostConfig

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
protected void deployDirectory(ContextName cn, File dir) {


        long startTime = 0;
        // Deploy the application in this directory
        if( log.isInfoEnabled() ) {
            startTime = System.currentTimeMillis();
            log.info(sm.getString("hostConfig.deployDir",
                    dir.getAbsolutePath()));
        }

        Context context = null;
        File xml = new File(dir, Constants.ApplicationContextXml);
        File xmlCopy =
                new File(host.getConfigBaseFile(), cn.getBaseName() + ".xml");


        DeployedApplication deployedApp;
        boolean copyThisXml = isCopyXML();
        boolean deployThisXML = isDeployThisXML(dir, cn);

        try {
            if (deployThisXML && xml.exists()) {
                synchronized (digesterLock) {
                    try {
                        context = (Context) digester.parse(xml);
                    } catch (Exception e) {
                        log.error(sm.getString(
                                "hostConfig.deployDescriptor.error",
                                xml), e);
                        context = new FailedContext();
                    } finally {
                        digester.reset();
                        if (context == null) {
                            context = new FailedContext();
                        }
                    }
                }

                if (copyThisXml == false && context instanceof StandardContext) {
                    // Host is using default value. Context may override it.
                    copyThisXml = ((StandardContext) context).getCopyXML();
                }

                if (copyThisXml) {
                    Files.copy(xml.toPath(), xmlCopy.toPath());
                    context.setConfigFile(xmlCopy.toURI().toURL());
                } else {
                    context.setConfigFile(xml.toURI().toURL());
                }
            } else if (!deployThisXML && xml.exists()) {
                // Block deployment as META-INF/context.xml may contain security
                // configuration necessary for a secure deployment.
                log.error(sm.getString("hostConfig.deployDescriptor.blocked",
                        cn.getPath(), xml, xmlCopy));
                context = new FailedContext();
            } else {
                context = (Context) Class.forName(contextClass).getConstructor().newInstance();
            }

            Class<?> clazz = Class.forName(host.getConfigClass());
            LifecycleListener listener = (LifecycleListener) clazz.getConstructor().newInstance();
            context.addLifecycleListener(listener);

            context.setName(cn.getName());
            context.setPath(cn.getPath());
            context.setWebappVersion(cn.getVersion());
            context.setDocBase(cn.getBaseName());
            host.addChild(context);
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            log.error(sm.getString("hostConfig.deployDir.error",
                    dir.getAbsolutePath()), t);
        } finally {
            deployedApp = new DeployedApplication(cn.getName(),
                    xml.exists() && deployThisXML && copyThisXml);

            // Fake re-deploy resource to detect if a WAR is added at a later
            // point
            deployedApp.redeployResources.put(dir.getAbsolutePath() + ".war",
                    Long.valueOf(0));
            deployedApp.redeployResources.put(dir.getAbsolutePath(),
                    Long.valueOf(dir.lastModified()));
            if (deployThisXML && xml.exists()) {
                if (copyThisXml) {
                    deployedApp.redeployResources.put(
                            xmlCopy.getAbsolutePath(),
                            Long.valueOf(xmlCopy.lastModified()));
                } else {
                    deployedApp.redeployResources.put(
                            xml.getAbsolutePath(),
                            Long.valueOf(xml.lastModified()));
                    // Fake re-deploy resource to detect if a context.xml file is
                    // added at a later point
                    deployedApp.redeployResources.put(
                            xmlCopy.getAbsolutePath(),
                            Long.valueOf(0));
                }
            } else {
                // Fake re-deploy resource to detect if a context.xml file is
                // added at a later point
                deployedApp.redeployResources.put(
                        xmlCopy.getAbsolutePath(),
                        Long.valueOf(0));
                if (!xml.exists()) {
                    deployedApp.redeployResources.put(
                            xml.getAbsolutePath(),
                            Long.valueOf(0));
                }
            }
            addWatchedResources(deployedApp, dir.getAbsolutePath(), context);
            // Add the global redeploy resources (which are never deleted) at
            // the end so they don't interfere with the deletion process
            addGlobalRedeployResources(deployedApp);
        }

        deployed.put(cn.getName(), deployedApp);

        if( log.isInfoEnabled() ) {
            log.info(sm.getString("hostConfig.deployDir.finished",
                    dir.getAbsolutePath(), Long.valueOf(System.currentTimeMillis() - startTime)));
        }
    }

LifecycleBase

1
2
3
4
5
6
7
StandardContent
  protected void fireLifecycleEvent(String type, Object data) {
        LifecycleEvent event = new LifecycleEvent(this, type, data);
        for (LifecycleListener listener : lifecycleListeners) {
            listener.lifecycleEvent(event);
        }
    }

ContextConfig

lifecycleEvent

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
@Override
 public void lifecycleEvent(LifecycleEvent event) {

     // Identify the context we are associated with
     try {
         context = (Context) event.getLifecycle();
     } catch (ClassCastException e) {
         log.error(sm.getString("contextConfig.cce", event.getLifecycle()), e);
         return;
     }

     // Process the event that has occurred
     if (event.getType().equals(Lifecycle.CONFIGURE_START_EVENT)) {
         configureStart();
     } else if (event.getType().equals(Lifecycle.BEFORE_START_EVENT)) {
         beforeStart();
     } else if (event.getType().equals(Lifecycle.AFTER_START_EVENT)) {
         // Restore docBase for management tools
         if (originalDocBase != null) {
             context.setDocBase(originalDocBase);
         }
     } else if (event.getType().equals(Lifecycle.CONFIGURE_STOP_EVENT)) {
         configureStop();
     } else if (event.getType().equals(Lifecycle.AFTER_INIT_EVENT)) {
         init();
     } else if (event.getType().equals(Lifecycle.AFTER_DESTROY_EVENT)) {
         destroy();
     }

 }

configureStart

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/**
   * Process a "contextConfig" event for this Context.
   */
  protected synchronized void configureStart() {
      // Called from StandardContext.start()

      if (log.isDebugEnabled()) {
          log.debug(sm.getString("contextConfig.start"));
      }

      if (log.isDebugEnabled()) {
          log.debug(sm.getString("contextConfig.xmlSettings",
                  context.getName(),
                  Boolean.valueOf(context.getXmlValidation()),
                  Boolean.valueOf(context.getXmlNamespaceAware())));
      }

      webConfig();
      // 为了正常启动
      context.addServletContainerInitializer(new JasperInitializer(),null);
      if (!context.getIgnoreAnnotations()) {
          applicationAnnotationsConfig();
      }
      if (ok) {
          validateSecurityRoles();
      }

      // Configure an authenticator if we need one
      if (ok) {
          authenticatorConfig();
      }

      // Dump the contents of this pipeline if requested
      if (log.isDebugEnabled()) {
          log.debug("Pipeline Configuration:");
          Pipeline pipeline = context.getPipeline();
          Valve valves[] = null;
          if (pipeline != null) {
              valves = pipeline.getValves();
          }
          if (valves != null) {
              for (Valve valve : valves) {
                  log.debug("  " + valve.getClass().getName());
              }
          }
          log.debug("======================");
      }

      // Make our application available if no problems were encountered
      if (ok) {
          context.setConfigured(true);
      } else {
          log.error(sm.getString("contextConfig.unavailable"));
          context.setConfigured(false);
      }

  }

webConfig

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
protected void webConfig() {
       /*
        * Anything and everything can override the global and host defaults.
        * This is implemented in two parts
        * - Handle as a web fragment that gets added after everything else so
        *   everything else takes priority
        * - Mark Servlets as overridable so SCI configuration can replace
        *   configuration from the defaults
        */

       /*
        * The rules for annotation scanning are not as clear-cut as one might
        * think. Tomcat implements the following process:
        * - As per SRV.1.6.2, Tomcat will scan for annotations regardless of
        *   which Servlet spec version is declared in web.xml. The EG has
        *   confirmed this is the expected behaviour.
        * - As per http://java.net/jira/browse/SERVLET_SPEC-36, if the main
        *   web.xml is marked as metadata-complete, JARs are still processed
        *   for SCIs.
        * - If metadata-complete=true and an absolute ordering is specified,
        *   JARs excluded from the ordering are also excluded from the SCI
        *   processing.
        * - If an SCI has a @HandlesType annotation then all classes (except
        *   those in JARs excluded from an absolute ordering) need to be
        *   scanned to check if they match.
        */
       WebXmlParser webXmlParser = new WebXmlParser(context.getXmlNamespaceAware(),
               context.getXmlValidation(), context.getXmlBlockExternal());

       Set<WebXml> defaults = new HashSet<>();
       defaults.add(getDefaultWebXmlFragment(webXmlParser));

       WebXml webXml = createWebXml();

       // Parse context level web.xml
       InputSource contextWebXml = getContextWebXmlSource();
       if (!webXmlParser.parseWebXml(contextWebXml, webXml, false)) {
           ok = false;
       }

       ServletContext sContext = context.getServletContext();

       // Ordering is important here

       // Step 1. Identify all the JARs packaged with the application and those
       // provided by the container. If any of the application JARs have a
       // web-fragment.xml it will be parsed at this point. web-fragment.xml
       // files are ignored for container provided JARs.
       Map<String,WebXml> fragments = processJarsForWebFragments(webXml, webXmlParser);

       // Step 2. Order the fragments.
       Set<WebXml> orderedFragments = null;
       orderedFragments =
               WebXml.orderWebFragments(webXml, fragments, sContext);

       // Step 3. Look for ServletContainerInitializer implementations
       if (ok) {
           processServletContainerInitializers();
       }

       if  (!webXml.isMetadataComplete() || typeInitializerMap.size() > 0) {
           // Steps 4 & 5.
           processClasses(webXml, orderedFragments);
       }

       if (!webXml.isMetadataComplete()) {
           // Step 6. Merge web-fragment.xml files into the main web.xml
           // file.
           if (ok) {
               ok = webXml.merge(orderedFragments);
           }

           // Step 7. Apply global defaults
           // Have to merge defaults before JSP conversion since defaults
           // provide JSP servlet definition.
           webXml.merge(defaults);

           // Step 8. Convert explicitly mentioned jsps to servlets
           if (ok) {
               convertJsps(webXml);
           }

           // Step 9. Apply merged web.xml to Context
           if (ok) {
               configureContext(webXml);
           }
       } else {
           webXml.merge(defaults);
           convertJsps(webXml);
           configureContext(webXml);
       }

       if (context.getLogEffectiveWebXml()) {
           log.info("web.xml:\n" + webXml.toXml());
       }

       // Always need to look for static resources
       // Step 10. Look for static resources packaged in JARs
       if (ok) {
           // Spec does not define an order.
           // Use ordered JARs followed by remaining JARs
           Set<WebXml> resourceJars = new LinkedHashSet<>(orderedFragments);
           for (WebXml fragment : fragments.values()) {
               if (!resourceJars.contains(fragment)) {
                   resourceJars.add(fragment);
               }
           }
           processResourceJARs(resourceJars);
           // See also StandardContext.resourcesStart() for
           // WEB-INF/classes/META-INF/resources configuration
       }

       // Step 11. Apply the ServletContainerInitializer config to the
       // context
       if (ok) {
           for (Map.Entry<ServletContainerInitializer,
                   Set<Class<?>>> entry :
                       initializerClassMap.entrySet()) {
               if (entry.getValue().isEmpty()) {
                   context.addServletContainerInitializer(
                           entry.getKey(), null);
               } else {
                   context.addServletContainerInitializer(
                           entry.getKey(), entry.getValue());
               }
           }
       }
   }

getDefaultWebXmlFragment

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
private WebXml getDefaultWebXmlFragment(WebXmlParser webXmlParser) {

      // Host should never be null
      Host host = (Host) context.getParent();

      DefaultWebXmlCacheEntry entry = hostWebXmlCache.get(host);

      InputSource globalWebXml = getGlobalWebXmlSource();
      InputSource hostWebXml = getHostWebXmlSource();

      long globalTimeStamp = 0;
      long hostTimeStamp = 0;

      if (globalWebXml != null) {
          URLConnection uc = null;
          try {
              URL url = new URL(globalWebXml.getSystemId());
              uc = url.openConnection();
              globalTimeStamp = uc.getLastModified();
          } catch (IOException e) {
              globalTimeStamp = -1;
          } finally {
              if (uc != null) {
                  try {
                      uc.getInputStream().close();
                  } catch (IOException e) {
                      ExceptionUtils.handleThrowable(e);
                      globalTimeStamp = -1;
                  }
              }
          }
      }

      if (hostWebXml != null) {
          URLConnection uc = null;
          try {
              URL url = new URL(hostWebXml.getSystemId());
              uc = url.openConnection();
              hostTimeStamp = uc.getLastModified();
          } catch (IOException e) {
              hostTimeStamp = -1;
          } finally {
              if (uc != null) {
                  try {
                      uc.getInputStream().close();
                  } catch (IOException e) {
                      ExceptionUtils.handleThrowable(e);
                      hostTimeStamp = -1;
                  }
              }
          }
      }

      if (entry != null && entry.getGlobalTimeStamp() == globalTimeStamp &&
              entry.getHostTimeStamp() == hostTimeStamp) {
          InputSourceUtil.close(globalWebXml);
          InputSourceUtil.close(hostWebXml);
          return entry.getWebXml();
      }

      // Parsing global web.xml is relatively expensive. Use a sync block to
      // make sure it only happens once. Use the pipeline since a lock will
      // already be held on the host by another thread
      synchronized (host.getPipeline()) {
          entry = hostWebXmlCache.get(host);
          if (entry != null && entry.getGlobalTimeStamp() == globalTimeStamp &&
                  entry.getHostTimeStamp() == hostTimeStamp) {
              return entry.getWebXml();
          }

          WebXml webXmlDefaultFragment = createWebXml();
          webXmlDefaultFragment.setOverridable(true);
          // Set to distributable else every app will be prevented from being
          // distributable when the default fragment is merged with the main
          // web.xml
          webXmlDefaultFragment.setDistributable(true);
          // When merging, the default welcome files are only used if the app has
          // not defined any welcomes files.
          webXmlDefaultFragment.setAlwaysAddWelcomeFiles(false);

          // Parse global web.xml if present
          if (globalWebXml == null) {
              // This is unusual enough to log
              log.info(sm.getString("contextConfig.defaultMissing"));
          } else {
              if (!webXmlParser.parseWebXml(
                      globalWebXml, webXmlDefaultFragment, false)) {
                  ok = false;
              }
          }

          // Parse host level web.xml if present
          // Additive apart from welcome pages
          webXmlDefaultFragment.setReplaceWelcomeFiles(true);

          if (!webXmlParser.parseWebXml(
                  hostWebXml, webXmlDefaultFragment, false)) {
              ok = false;
          }

          // Don't update the cache if an error occurs
          if (globalTimeStamp != -1 && hostTimeStamp != -1) {
              entry = new DefaultWebXmlCacheEntry(webXmlDefaultFragment,
                      globalTimeStamp, hostTimeStamp);
              hostWebXmlCache.put(host, entry);
              // Add a Lifecycle listener to the Host that will remove it from
              // the hostWebXmlCache once the Host is destroyed
              host.addLifecycleListener(new HostWebXmlCacheCleaner());
          }

          return webXmlDefaultFragment;
      }
  }

标签解析

server

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

  public StandardServer() {

       super();

       globalNamingResources = new NamingResourcesImpl();
       globalNamingResources.setContainer(this);

       if (isUseNaming()) {
           namingContextListener = new NamingContextListener();
           addLifecycleListener(namingContextListener);
       } else {
           namingContextListener = null;
       }

   }

/**
    * Global naming resources context.
    */
   private javax.naming.Context globalNamingContext = null;


   /**
    * Global naming resources.
    */
   private NamingResourcesImpl globalNamingResources = null;


   /**
    * The naming context listener for this web application.
    */
   private final NamingContextListener namingContextListener;


   /**
    * The port number on which we wait for shutdown commands.
    */
   private int port = 8005;

   /**
    * The address on which we wait for shutdown commands.
    */
   private String address = "localhost";


   /**
    * A random number generator that is <strong>only</strong> used if
    * the shutdown command string is longer than 1024 characters.
    */
   private Random random = null;


   /**
   只需要关注这个
    * The set of Services associated with this Server.
    */
   private Service services[] = new Service[0];
   private final Object servicesLock = new Object();


   /**
    * The shutdown command string we are looking for.
    */
   private String shutdown = "SHUTDOWN";


   /**
    * The string manager for this package.
    */
   private static final StringManager sm =
       StringManager.getManager(Constants.Package);


   /**
    * The property change support for this component.
    */
   final PropertyChangeSupport support = new PropertyChangeSupport(this);

   private volatile boolean stopAwait = false;

   private Catalina catalina = null;

   private ClassLoader parentClassLoader = null;

   /**
    * Thread that currently is inside our await() method.
    */
   private volatile Thread awaitThread = null;

   /**
    * Server socket that is used to wait for the shutdown command.
    */
   private volatile ServerSocket awaitSocket = null;

   private File catalinaHome = null;

   private File catalinaBase = null;

   private final Object namingToken = new Object();

ObjectCreateRule

begin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public void begin(String namespace, String name, Attributes attributes)
           throws Exception {

       // Identify the name of the class to instantiate
    // classname 在初始化ObjectCreateRule对象时就指定好了
       String realClassName = className;
       if (attributeName != null) {
           //这里可以通过server标签指定 Server类
           String value = attributes.getValue(attributeName);
           if (value != null) {
               realClassName = value;
           }
       }
       if (digester.log.isDebugEnabled()) {
           digester.log.debug("[ObjectCreateRule]{" + digester.match +
                   "}New " + realClassName);
       }

       if (realClassName == null) {
           throw new NullPointerException("No class name specified for " +
                   namespace + " " + name);
       }

       // Instantiate the new object and push it on the context stack
       Class<?> clazz = digester.getClassLoader().loadClass(realClassName);
       Object instance = clazz.getConstructor().newInstance();
    //server的实例压栈
       digester.push(instance);
   }

body

1
2
3
4
  public void body(String namespace, String name, String text) throws Exception {
        // NO-OP by default.
    }
啥也不干

end

弹出当前对象

1
2
3
4
5
6
7
8
9
10
@Override
 public void end(String namespace, String name) throws Exception {

     Object top = digester.pop();
     if (digester.log.isDebugEnabled()) {
         digester.log.debug("[ObjectCreateRule]{" + digester.match +
                 "} Pop " + top.getClass().getName());
     }

 }

SetPropertiesRule

begin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

@Override
 public void begin(String namespace, String theName, Attributes attributes)
         throws Exception {

     // Populate the corresponding properties of the top object
     // 获取栈顶元素，但是不弹出
     Object top = digester.peek();
     if (digester.log.isDebugEnabled()) {
         if (top != null) {
             digester.log.debug("[SetPropertiesRule]{" + digester.match +
                                "} Set " + top.getClass().getName() +
                                " properties");
         } else {
             digester.log.debug("[SetPropertiesRule]{" + digester.match +
                                "} Set NULL properties");
         }
     }

     for (int i = 0; i < attributes.getLength(); i++) {
         String name = attributes.getLocalName(i);
         if ("".equals(name)) {
             name = attributes.getQName(i);
         }
         String value = attributes.getValue(i);

         if (digester.log.isDebugEnabled()) {
             digester.log.debug("[SetPropertiesRule]{" + digester.match +
                     "} Setting property '" + name + "' to '" +
                     value + "'");
         }
         if (!digester.isFakeAttribute(top, name)
             //设置属性，属性设置就是通过setter方法进行设置
                 && !IntrospectionUtils.setProperty(top, name, value)
                 && digester.getRulesValidation()) {
             digester.log.warn("[SetPropertiesRule]{" + digester.match +
                     "} Setting property '" + name + "' to '" +
                     value + "' did not find a matching property.");
         }
     }

 }

body

1
2
3
public void body(String namespace, String name, String text) throws Exception {
       // NO-OP by default.
   }

end

啥也不干

SetNextRule

1
2
3
begin啥也不干
    
 bodu啥也不干

end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Override
  public void end(String namespace, String name) throws Exception {

      // Identify the objects to be used
      Object child = digester.peek(0);
      Object parent = digester.peek(1);
      if (digester.log.isDebugEnabled()) {
          if (parent == null) {
              digester.log.debug("[SetNextRule]{" + digester.match +
                      "} Call [NULL PARENT]." +
                      methodName + "(" + child + ")");
          } else {
              digester.log.debug("[SetNextRule]{" + digester.match +
                      "} Call " + parent.getClass().getName() + "." +
                      methodName + "(" + child + ")");
          }
      }

      // Call the specified method
      IntrospectionUtils.callMethod1(parent, methodName,
              child, paramType, digester.getClassLoader());

  }

Listener

ObjectCreateRule

与server一样，不过这个对象的class是由标签指定的

SetPropertiesRule

SetNextRule

会给Server设置上监听器

展开全文 >>

xml/sax/DOM4J

XML

xml 是可扩展标识语言（Extensible Markup Luanguage）就是开发者符合xml命名规则的基础之上，可以根据自己的需求定义自定义标签

可读性强

XML的定义是必须只有一个根节点。 

1
2
3
4
5
6
7
8
9
10
11
12
13
<!-- 文件头，固定写法 -->
<?xml version = "1.0" encoding = "utf-8"?>
<A>
    666
    <B>
        哦哦
         <C>
             哈哈哈
         </C>
        嘿嘿
    </B>
    999
</A>

DOM4J

专门为java开发的 dom解析框架

是一次性读到内存，这样的好处可以随意的增上改查

缺点，只适合文件小的场景

对dom的封装，因为dom解析比较繁琐

使用步骤

创建解析器 SAXReader()

1
SAXReader saxReader = new SAXReader();

获取Document对象(树结构)

1
2
File file =new File("a.xml");
Document read = saxReader.read(file);

获取xml根节点

1
2

Element rootElement = read.getRootElement();

遍历树

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void main(String[] args) throws DocumentException {
        InputStream systemResourceAsStream = ClassLoader.getSystemResourceAsStream("a.xml");
        SAXReader saxReader = new SAXReader();
        Document read = saxReader.read(systemResourceAsStream);
        Element rootElement = read.getRootElement();
        recursionElement(rootElement);
    }

    static void recursionElement(Element node){
        System.out.println(node.getName()+"---开始处理");

        System.out.println("节点文本元素:"+node.getTextTrim());

        List<Element> elements = node.elements();
        for (int i = 0; i < elements.size(); i++) {
            recursionElement(elements.get(i));
        }
    }

XPATH

https://www.w3school.com.cn/xpath/xpath_intro.asp

展开全文 >>

xml/sax/SAX学习

SAX

边读边解析，大文件解析，但是不支持随意修改

使用工厂创建解析对象

1
2
SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
        SAXParser saxParser = saxParserFactory.newSAXParser();

创建回调的处理器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class MyHandler extends  DefaultHandler{
    Stack stack = new Stack();
    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        stack.push(new Object());
        System.out.println("start");
        System.out.println(qName);
        System.out.println(attributes); // 标签上的属性元素
    }

    @Override
    public synchronized void characters(char[] ch, int start, int length) throws SAXException {

        System.out.println(new String(ch,start,length));

    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        System.out.println("end");
        System.out.println(qName);
        stack.pop();
    }
}

展开全文 >>

web/tomcat/request执行流程

Request的执行流程

SocketProcessor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

@Override
      protected void doRun() {
          NioChannel socket = socketWrapper.getSocket();
          SelectionKey key = socket.getIOChannel().keyFor(socket.getPoller().getSelector());

          try {
              int handshake = -1;

              try {
                  if (key != null) {
                      if (socket.isHandshakeComplete()) {
                          // No TLS handshaking required. Let the handler
                          // process this socket / event combination.
                          handshake = 0;
                      } else if (event == SocketEvent.STOP || event == SocketEvent.DISCONNECT ||
                              event == SocketEvent.ERROR) {
                          // Unable to complete the TLS handshake. Treat it as
                          // if the handshake failed.
                          handshake = -1;
                      } else {
                          handshake = socket.handshake(key.isReadable(), key.isWritable());
                          // The handshake process reads/writes from/to the
                          // socket. status may therefore be OPEN_WRITE once
                          // the handshake completes. However, the handshake
                          // happens when the socket is opened so the status
                          // must always be OPEN_READ after it completes. It
                          // is OK to always set this as it is only used if
                          // the handshake completes.
                          event = SocketEvent.OPEN_READ;
                      }
                  }
              } catch (IOException x) {
                  handshake = -1;
                  if (log.isDebugEnabled()) log.debug("Error during SSL handshake",x);
              } catch (CancelledKeyException ckx) {
                  handshake = -1;
              }
              if (handshake == 0) {
                  SocketState state = SocketState.OPEN;
                  // Process the request from this socket
                  if (event == null) {
                      state = getHandler().process(socketWrapper, SocketEvent.OPEN_READ);
                  } else {
                      state = getHandler().process(socketWrapper, event);
                  }
                  if (state == SocketState.CLOSED) {
                      close(socket, key);
                  }
              } else if (handshake == -1 ) {
                  getHandler().process(socketWrapper, SocketEvent.CONNECT_FAIL);
                  close(socket, key);
              } else if (handshake == SelectionKey.OP_READ){
                  socketWrapper.registerReadInterest();
              } else if (handshake == SelectionKey.OP_WRITE){
                  socketWrapper.registerWriteInterest();
              }
          } catch (CancelledKeyException cx) {
              socket.getPoller().cancelledKey(key);
          } catch (VirtualMachineError vme) {
              ExceptionUtils.handleThrowable(vme);
          } catch (Throwable t) {
              log.error("", t);
              socket.getPoller().cancelledKey(key);
          } finally {
              socketWrapper = null;
              event = null;
              //return to cache
              if (running && !paused) {
                  processorCache.push(this);
              }
          }
      }
  }

ConnectionHandler

1
2
3
4
5
private final AbstractProtocol<S> proto;
      private final RequestGroupInfo global = new RequestGroupInfo();
      private final AtomicLong registerCount = new AtomicLong(0);
      private final Map<S,Processor> connections = new ConcurrentHashMap<>();
      private final RecycledProcessors recycledProcessors = new RecycledProcessors(this);

process

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
@Override
       public SocketState process(SocketWrapperBase<S> wrapper, SocketEvent status) {
           if (getLog().isDebugEnabled()) {
               getLog().debug(sm.getString("abstractConnectionHandler.process",
                       wrapper.getSocket(), status));
           }
           if (wrapper == null) {
               // Nothing to do. Socket has been closed.
               return SocketState.CLOSED;
           }
		//获取Socket
           S socket = wrapper.getSocket();
		//通过连接获取对应的执行器，一开始没有
           Processor processor = connections.get(socket);
           if (getLog().isDebugEnabled()) {
               getLog().debug(sm.getString("abstractConnectionHandler.connectionsGet",
                       processor, socket));
           }

           // 在专用线程上计算超时，然后进行调度。由于调度过程中的延迟，可能不再需要超时。请检查此处，避免不必要的处理
           if (SocketEvent.TIMEOUT == status &&
                   (processor == null ||
                   !processor.isAsync() && !processor.isUpgrade() ||
                   processor.isAsync() && !processor.checkAsyncTimeoutGeneration())) {
               // This is effectively a NO-OP
               return SocketState.OPEN;
           }

           if (processor != null) {
               // Make sure an async timeout doesn't fire
               getProtocol().removeWaitingProcessor(processor);
           } else if (status == SocketEvent.DISCONNECT || status == SocketEvent.ERROR) {
               // Nothing to do. Endpoint requested a close and there is no
               // longer a processor associated with this socket.
               return SocketState.CLOSED;
           }

           ContainerThreadMarker.set();

           try {
               if (processor == null) {
                   // 获取达成的协议
                   String negotiatedProtocol = wrapper.getNegotiatedProtocol();
                   // OpenSSL通常返回null，而JSSE通常在没有协商协议时返回“”
                   if (negotiatedProtocol != null && negotiatedProtocol.length() > 0) {
                       UpgradeProtocol upgradeProtocol = getProtocol().getNegotiatedProtocol(negotiatedProtocol);
                       if (upgradeProtocol != null) {
                           processor = upgradeProtocol.getProcessor(wrapper, getProtocol().getAdapter());
                           if (getLog().isDebugEnabled()) {
                               getLog().debug(sm.getString("abstractConnectionHandler.processorCreate", processor));
                           }
                       } else if (negotiatedProtocol.equals("http/1.1")) {
                           // 显式协商默认协议。获取下面的处理器。
                       } else {
                           // TODO:
                           // 如果没有协议可以协商，openssl1.0.2的ALPN回调不支持握手失败并出现错误。因此，我们需要在这里断开连接。一旦修复了这个问题，就用注释掉的块替换下面的代码。
                           if (getLog().isDebugEnabled()) {
                               getLog().debug(sm.getString("abstractConnectionHandler.negotiatedProcessor.fail",
                                       negotiatedProtocol));
                           }
                           return SocketState.CLOSED;
                           /*
                            * To replace the code above once OpenSSL 1.1.0 is
                            * used.
                           // Failed to create processor. This is a bug.
                           throw new IllegalStateException(sm.getString(
                                   "abstractConnectionHandler.negotiatedProcessor.fail",
                                   negotiatedProtocol));
                           */
                       }
                   }
               }
               if (processor == null) {
                   // recycledProcessors一个回收处理器进行处理
                   processor = recycledProcessors.pop();
                   if (getLog().isDebugEnabled()) {
                       getLog().debug(sm.getString("abstractConnectionHandler.processorPop", processor));
                   }
               }
               if (processor == null) {
                   processor = getProtocol().createProcessor();
                   register(processor);
                   if (getLog().isDebugEnabled()) {
                       getLog().debug(sm.getString("abstractConnectionHandler.processorCreate", processor));
                   }
               }

               processor.setSslSupport(
                       wrapper.getSslSupport(getProtocol().getClientCertProvider()));

               // Associate the processor with the connection
               connections.put(socket, processor);

               SocketState state = SocketState.CLOSED;
               do {
                   state = processor.process(wrapper, status);

                   if (state == SocketState.UPGRADING) {
                       // Get the HTTP upgrade handler
                       UpgradeToken upgradeToken = processor.getUpgradeToken();
                       // Retrieve leftover input
                       ByteBuffer leftOverInput = processor.getLeftoverInput();
                       if (upgradeToken == null) {
                           // Assume direct HTTP/2 connection
                           UpgradeProtocol upgradeProtocol = getProtocol().getUpgradeProtocol("h2c");
                           if (upgradeProtocol != null) {
                               // Release the Http11 processor to be re-used
                               release(processor);
                               // Create the upgrade processor
                               processor = upgradeProtocol.getProcessor(wrapper, getProtocol().getAdapter());
                               wrapper.unRead(leftOverInput);
                               // Associate with the processor with the connection
                               connections.put(socket, processor);
                           } else {
                               if (getLog().isDebugEnabled()) {
                                   getLog().debug(sm.getString(
                                       "abstractConnectionHandler.negotiatedProcessor.fail",
                                       "h2c"));
                               }
                               // Exit loop and trigger appropriate clean-up
                               state = SocketState.CLOSED;
                           }
                       } else {
                           HttpUpgradeHandler httpUpgradeHandler = upgradeToken.getHttpUpgradeHandler();
                           // Release the Http11 processor to be re-used
                           release(processor);
                           // Create the upgrade processor
                           processor = getProtocol().createUpgradeProcessor(wrapper, upgradeToken);
                           if (getLog().isDebugEnabled()) {
                               getLog().debug(sm.getString("abstractConnectionHandler.upgradeCreate",
                                       processor, wrapper));
                           }
                           wrapper.unRead(leftOverInput);
                           // Associate with the processor with the connection
                           connections.put(socket, processor);
                           // Initialise the upgrade handler (which may trigger
                           // some IO using the new protocol which is why the lines
                           // above are necessary)
                           // This cast should be safe. If it fails the error
                           // handling for the surrounding try/catch will deal with
                           // it.
                           if (upgradeToken.getInstanceManager() == null) {
                               httpUpgradeHandler.init((WebConnection) processor);
                           } else {
                               ClassLoader oldCL = upgradeToken.getContextBind().bind(false, null);
                               try {
                                   httpUpgradeHandler.init((WebConnection) processor);
                               } finally {
                                   upgradeToken.getContextBind().unbind(false, oldCL);
                               }
                           }
                       }
                   }
               } while ( state == SocketState.UPGRADING);

               if (state == SocketState.LONG) {
                   // In the middle of processing a request/response. Keep the
                   // socket associated with the processor. Exact requirements
                   // depend on type of long poll
                   longPoll(wrapper, processor);
                   if (processor.isAsync()) {
                       getProtocol().addWaitingProcessor(processor);
                   }
               } else if (state == SocketState.OPEN) {
                   // In keep-alive but between requests. OK to recycle
                   // processor. Continue to poll for the next request.
                   connections.remove(socket);
                   release(processor);
                   wrapper.registerReadInterest();
               } else if (state == SocketState.SENDFILE) {
                   // Sendfile in progress. If it fails, the socket will be
                   // closed. If it works, the socket either be added to the
                   // poller (or equivalent) to await more data or processed
                   // if there are any pipe-lined requests remaining.
               } else if (state == SocketState.UPGRADED) {
                   // Don't add sockets back to the poller if this was a
                   // non-blocking write otherwise the poller may trigger
                   // multiple read events which may lead to thread starvation
                   // in the connector. The write() method will add this socket
                   // to the poller if necessary.
                   if (status != SocketEvent.OPEN_WRITE) {
                       longPoll(wrapper, processor);
                       getProtocol().addWaitingProcessor(processor);
                   }
               } else if (state == SocketState.SUSPENDED) {
                   // Don't add sockets back to the poller.
                   // The resumeProcessing() method will add this socket
                   // to the poller.
               } else {
                   // Connection closed. OK to recycle the processor.
                   // Processors handling upgrades require additional clean-up
                   // before release.
                   connections.remove(socket);
                   if (processor.isUpgrade()) {
                       UpgradeToken upgradeToken = processor.getUpgradeToken();
                       HttpUpgradeHandler httpUpgradeHandler = upgradeToken.getHttpUpgradeHandler();
                       InstanceManager instanceManager = upgradeToken.getInstanceManager();
                       if (instanceManager == null) {
                           httpUpgradeHandler.destroy();
                       } else {
                           ClassLoader oldCL = upgradeToken.getContextBind().bind(false, null);
                           try {
                               httpUpgradeHandler.destroy();
                           } finally {
                               try {
                                   instanceManager.destroyInstance(httpUpgradeHandler);
                               } catch (Throwable e) {
                                   ExceptionUtils.handleThrowable(e);
                                   getLog().error(sm.getString("abstractConnectionHandler.error"), e);
                               }
                               upgradeToken.getContextBind().unbind(false, oldCL);
                           }
                       }
                   }
                   release(processor);
               }
               return state;
           } catch(java.net.SocketException e) {
               // SocketExceptions are normal
               getLog().debug(sm.getString(
                       "abstractConnectionHandler.socketexception.debug"), e);
           } catch (java.io.IOException e) {
               // IOExceptions are normal
               getLog().debug(sm.getString(
                       "abstractConnectionHandler.ioexception.debug"), e);
           } catch (ProtocolException e) {
               // Protocol exceptions normally mean the client sent invalid or
               // incomplete data.
               getLog().debug(sm.getString(
                       "abstractConnectionHandler.protocolexception.debug"), e);
           }
           // Future developers: if you discover any other
           // rare-but-nonfatal exceptions, catch them here, and log as
           // above.
           catch (OutOfMemoryError oome) {
               // Try and handle this here to give Tomcat a chance to close the
               // connection and prevent clients waiting until they time out.
               // Worst case, it isn't recoverable and the attempt at logging
               // will trigger another OOME.
               getLog().error(sm.getString("abstractConnectionHandler.oome"), oome);
           } catch (Throwable e) {
               ExceptionUtils.handleThrowable(e);
               // any other exception or error is odd. Here we log it
               // with "ERROR" level, so it will show up even on
               // less-than-verbose logs.
               getLog().error(sm.getString("abstractConnectionHandler.error"), e);
           } finally {
               ContainerThreadMarker.clear();
           }

           // Make sure socket/processor is removed from the list of current
           // connections
           connections.remove(socket);
           release(processor);
           return SocketState.CLOSED;
       }

AbstractProcessorLight

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
@Override
   public SocketState process(SocketWrapperBase<?> socketWrapper, SocketEvent status)
           throws IOException {

       SocketState state = SocketState.CLOSED;
       Iterator<DispatchType> dispatches = null;
       do {
           if (dispatches != null) {
               DispatchType nextDispatch = dispatches.next();
               if (getLog().isDebugEnabled()) {
                   getLog().debug("Processing dispatch type: [" + nextDispatch + "]");
               }
               state = dispatch(nextDispatch.getSocketStatus());
               if (!dispatches.hasNext()) {
                   state = checkForPipelinedData(state, socketWrapper);
               }
           } else if (status == SocketEvent.DISCONNECT) {
               // Do nothing here, just wait for it to get recycled
           } else if (isAsync() || isUpgrade() || state == SocketState.ASYNC_END) {
               state = dispatch(status);
               state = checkForPipelinedData(state, socketWrapper);
           } else if (status == SocketEvent.OPEN_WRITE) {
               // Extra write event likely after async, ignore
               state = SocketState.LONG;
           } else if (status == SocketEvent.OPEN_READ) {
               state = service(socketWrapper);
           } else if (status == SocketEvent.CONNECT_FAIL) {
               logAccess(socketWrapper);
           } else {
               // Default to closing the socket if the SocketEvent passed in
               // is not consistent with the current state of the Processor
               state = SocketState.CLOSED;
           }

           if (getLog().isDebugEnabled()) {
               getLog().debug("Socket: [" + socketWrapper +
                       "], Status in: [" + status +
                       "], State out: [" + state + "]");
           }

           if (isAsync()) {
               state = asyncPostProcess();
               if (getLog().isDebugEnabled()) {
                   getLog().debug("Socket: [" + socketWrapper +
                           "], State after async post processing: [" + state + "]");
               }
           }

           if (dispatches == null || !dispatches.hasNext()) {
               // Only returns non-null iterator if there are
               // dispatches to process.
               dispatches = getIteratorAndClearDispatches();
           }
       } while (state == SocketState.ASYNC_END ||
               dispatches != null && state != SocketState.CLOSED);

       return state;
   }

Http11Processor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
@Override
   public SocketState service(SocketWrapperBase<?> socketWrapper)
       throws IOException {
       RequestInfo rp = request.getRequestProcessor();
       rp.setStage(org.apache.coyote.Constants.STAGE_PARSE);

       // Setting up the I/O
       // 给inBuffer和outBuffer设置socket用于解析读取数据和数据返回
       setSocketWrapper(socketWrapper);

       // Flags
       keepAlive = true;
       openSocket = false;
       readComplete = true;
       boolean keptAlive = false;
       SendfileState sendfileState = SendfileState.DONE;

       while (!getErrorState().isError() && keepAlive && !isAsync() && upgradeToken == null &&
               sendfileState == SendfileState.DONE && !endpoint.isPaused()) {

           // Parsing the request header
           try {
               if (!inputBuffer.parseRequestLine(keptAlive)) {
                   if (inputBuffer.getParsingRequestLinePhase() == -1) {
                       return SocketState.UPGRADING;
                   } else if (handleIncompleteRequestLineRead()) {
                       break;
                   }
               }

               // 处理请求行的协议组件需要知道这是不是一个HTTP0.9请求，然后再尝试解析头。
               prepareRequestProtocol();

               if (endpoint.isPaused()) {
                   // 503 - Service unavailable
                   response.setStatus(503);
                   setErrorState(ErrorState.CLOSE_CLEAN, null);
               } else {
                   // 设置存活时间，读取超时时间
                   keptAlive = true;
                   // Set this every time in case limit has been changed via JMX
                   request.getMimeHeaders().setLimit(endpoint.getMaxHeaderCount());
                   // Don't parse headers for HTTP/0.9
                   if (!http09 && !inputBuffer.parseHeaders()) {
                       // We've read part of the request, don't recycle it
                       // instead associate it with the socket
                       openSocket = true;
                       readComplete = false;
                       break;
                   }
                   if (!disableUploadTimeout) {
                       socketWrapper.setReadTimeout(connectionUploadTimeout);
                   }
               }
           } catch (IOException e) {
               if (log.isDebugEnabled()) {
                   log.debug(sm.getString("http11processor.header.parse"), e);
               }
               setErrorState(ErrorState.CLOSE_CONNECTION_NOW, e);
               break;
           } catch (Throwable t) {
               ExceptionUtils.handleThrowable(t);
               UserDataHelper.Mode logMode = userDataHelper.getNextMode();
               if (logMode != null) {
                   String message = sm.getString("http11processor.header.parse");
                   switch (logMode) {
                       case INFO_THEN_DEBUG:
                           message += sm.getString("http11processor.fallToDebug");
                           //$FALL-THROUGH$
                       case INFO:
                           log.info(message, t);
                           break;
                       case DEBUG:
                           log.debug(message, t);
                   }
               }
               // 400 - Bad Request
               response.setStatus(400);
               setErrorState(ErrorState.CLOSE_CLEAN, t);
           }

           // Has an upgrade been requested?
           if (isConnectionToken(request.getMimeHeaders(), "upgrade")) {
               // Check the protocol
               String requestedProtocol = request.getHeader("Upgrade");

               UpgradeProtocol upgradeProtocol = protocol.getUpgradeProtocol(requestedProtocol);
               if (upgradeProtocol != null) {
                   if (upgradeProtocol.accept(request)) {
                       // TODO Figure out how to handle request bodies at this
                       // point.
                       response.setStatus(HttpServletResponse.SC_SWITCHING_PROTOCOLS);
                       response.setHeader("Connection", "Upgrade");
                       response.setHeader("Upgrade", requestedProtocol);
                       action(ActionCode.CLOSE,  null);
                       getAdapter().log(request, response, 0);

                       InternalHttpUpgradeHandler upgradeHandler =
                               upgradeProtocol.getInternalUpgradeHandler(
                                       getAdapter(), cloneRequest(request));
                       UpgradeToken upgradeToken = new UpgradeToken(upgradeHandler, null, null);
                       action(ActionCode.UPGRADE, upgradeToken);
                       return SocketState.UPGRADING;
                   }
               }
           }

           // ====上面不是重点==
           if (getErrorState().isIoAllowed()) {
               // Setting up filters, and parse some request headers
               rp.setStage(org.apache.coyote.Constants.STAGE_PREPARE);
               try {
                   //准备请求
                   prepareRequest();
               } catch (Throwable t) {
                   ExceptionUtils.handleThrowable(t);
                   if (log.isDebugEnabled()) {
                       log.debug(sm.getString("http11processor.request.prepare"), t);
                   }
                   // 500 - Internal Server Error
                   response.setStatus(500);
                   setErrorState(ErrorState.CLOSE_CLEAN, t);
               }
           }

           if (maxKeepAliveRequests == 1) {
               keepAlive = false;
           } else if (maxKeepAliveRequests > 0 &&
                   socketWrapper.decrementKeepAlive() <= 0) {
               keepAlive = false;
           }

           // Process the request in the adapter
           if (getErrorState().isIoAllowed()) {
               try {
                   rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
                   //使用适配器处理
                   getAdapter().service(request, response);
                   // 处理在发生严重错误之前提交响应的时间。抛出ServletException应该同时将status设置为500并设置errorException。如果我们在这里失败，那么响应可能已经提交，所以我们不能尝试设置头。
                   if(keepAlive && !getErrorState().isError() && !isAsync() &&
                           statusDropsConnection(response.getStatus())) {
                       setErrorState(ErrorState.CLOSE_CLEAN, null);
                   }
               } catch (InterruptedIOException e) {
                   setErrorState(ErrorState.CLOSE_CONNECTION_NOW, e);
               } catch (HeadersTooLargeException e) {
                   log.error(sm.getString("http11processor.request.process"), e);
                   // The response should not have been committed but check it
                   // anyway to be safe
                   if (response.isCommitted()) {
                       setErrorState(ErrorState.CLOSE_NOW, e);
                   } else {
                       response.reset();
                       response.setStatus(500);
                       setErrorState(ErrorState.CLOSE_CLEAN, e);
                       response.setHeader("Connection", "close"); // TODO: Remove
                   }
               } catch (Throwable t) {
                   ExceptionUtils.handleThrowable(t);
                   log.error(sm.getString("http11processor.request.process"), t);
                   // 500 - Internal Server Error
                   response.setStatus(500);
                   setErrorState(ErrorState.CLOSE_CLEAN, t);
                   getAdapter().log(request, response, 0);
               }
           }

           // Finish the handling of the request
           rp.setStage(org.apache.coyote.Constants.STAGE_ENDINPUT);
           if (!isAsync()) {
               // If this is an async request then the request ends when it has
               // been completed. The AsyncContext is responsible for calling
               // endRequest() in that case.
               endRequest();
           }
           rp.setStage(org.apache.coyote.Constants.STAGE_ENDOUTPUT);

           // If there was an error, make sure the request is counted as
           // and error, and update the statistics counter
           if (getErrorState().isError()) {
               response.setStatus(500);
           }

           if (!isAsync() || getErrorState().isError()) {
               request.updateCounters();
               if (getErrorState().isIoAllowed()) {
                   inputBuffer.nextRequest();
                   outputBuffer.nextRequest();
               }
           }

           if (!disableUploadTimeout) {
               int soTimeout = endpoint.getConnectionTimeout();
               if(soTimeout > 0) {
                   socketWrapper.setReadTimeout(soTimeout);
               } else {
                   socketWrapper.setReadTimeout(0);
               }
           }

           rp.setStage(org.apache.coyote.Constants.STAGE_KEEPALIVE);

           sendfileState = processSendfile(socketWrapper);
       }

       rp.setStage(org.apache.coyote.Constants.STAGE_ENDED);

       if (getErrorState().isError() || (endpoint.isPaused() && !isAsync())) {
           return SocketState.CLOSED;
       } else if (isAsync()) {
           return SocketState.LONG;
       } else if (isUpgrade()) {
           return SocketState.UPGRADING;
       } else {
           if (sendfileState == SendfileState.PENDING) {
               return SocketState.SENDFILE;
           } else {
               if (openSocket) {
                   if (readComplete) {
                       return SocketState.OPEN;
                   } else {
                       return SocketState.LONG;
                   }
               } else {
                   return SocketState.CLOSED;
               }
           }
       }
   }

CoyoteAdapter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
@Override
   public void service(org.apache.coyote.Request req, org.apache.coyote.Response res)
           throws Exception {
	// 获取要交给业务线程的request，response
       Request request = (Request) req.getNote(ADAPTER_NOTES);
       Response response = (Response) res.getNote(ADAPTER_NOTES);

       if (request == null) {
           //没有 就创建，一般是有的
           // Create objects
           request = connector.createRequest();
           request.setCoyoteRequest(req);
           response = connector.createResponse();
           response.setCoyoteResponse(res);

           // Link objects
           request.setResponse(response);
           response.setRequest(request);

           // Set as notes
           req.setNote(ADAPTER_NOTES, request);
           res.setNote(ADAPTER_NOTES, response);

           // Set query string encoding
           req.getParameters().setQueryStringCharset(connector.getURICharset());
       }

       if (connector.getXpoweredBy()) {
           response.addHeader("X-Powered-By", POWERED_BY);
       }

       boolean async = false;
       boolean postParseSuccess = false;

       req.getRequestProcessor().setWorkerThreadName(THREAD_NAME.get());

       try {
           // 解析并设置Catalina和配置特定的请求参数
           postParseSuccess = postParseRequest(req, request, res, response);
           if (postParseSuccess) {
               //check valves if we support async
               request.setAsyncSupported(
                       connector.getService().getContainer().getPipeline().isAsyncSupported());
               // Calling the container,调用Servlet容器
               connector.getService().getContainer().getPipeline().getFirst().invoke(
                       request, response);
           }
           if (request.isAsync()) {
               async = true;
               ReadListener readListener = req.getReadListener();
               if (readListener != null && request.isFinished()) {
                   // Possible the all data may have been read during service()
                   // method so this needs to be checked here
                   ClassLoader oldCL = null;
                   try {
                       oldCL = request.getContext().bind(false, null);
                       if (req.sendAllDataReadEvent()) {
                           req.getReadListener().onAllDataRead();
                       }
                   } finally {
                       request.getContext().unbind(false, oldCL);
                   }
               }

               Throwable throwable =
                       (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);

               // If an async request was started, is not going to end once
               // this container thread finishes and an error occurred, trigger
               // the async error process
               if (!request.isAsyncCompleting() && throwable != null) {
                   request.getAsyncContextInternal().setErrorState(throwable, true);
               }
           } else {
               request.finishRequest();
               response.finishResponse();
           }

       } catch (IOException e) {
           // Ignore
       } finally {
           AtomicBoolean error = new AtomicBoolean(false);
           res.action(ActionCode.IS_ERROR, error);

           if (request.isAsyncCompleting() && error.get()) {
               // Connection will be forcibly closed which will prevent
               // completion happening at the usual point. Need to trigger
               // call to onComplete() here.
               res.action(ActionCode.ASYNC_POST_PROCESS,  null);
               async = false;
           }

           // Access log
           if (!async && postParseSuccess) {
               // Log only if processing was invoked.
               // If postParseRequest() failed, it has already logged it.
               Context context = request.getContext();
               Host host = request.getHost();
               // If the context is null, it is likely that the endpoint was
               // shutdown, this connection closed and the request recycled in
               // a different thread. That thread will have updated the access
               // log so it is OK not to update the access log here in that
               // case.
               // The other possibility is that an error occurred early in
               // processing and the request could not be mapped to a Context.
               // Log via the host or engine in that case.
               long time = System.currentTimeMillis() - req.getStartTime();
               if (context != null) {
                   context.logAccess(request, response, time, false);
               } else if (response.isError()) {
                   if (host != null) {
                       host.logAccess(request, response, time, false);
                   } else {
                       connector.getService().getContainer().logAccess(
                               request, response, time, false);
                   }
               }
           }

           req.getRequestProcessor().setWorkerThreadName(null);

           // Recycle the wrapper request and response
           if (!async) {
               updateWrapperErrorCount(request, response);
               request.recycle();
               response.recycle();
           }
       }
   }

postParseRequest

获取servletClass 包装到wrapperData中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
protected boolean postParseRequest(org.apache.coyote.Request req, Request request,
           org.apache.coyote.Response res, Response response) throws IOException, ServletException {

       // If the processor has set the scheme (AJP does this, HTTP does this if
       // SSL is enabled) use this to set the secure flag as well. If the
       // processor hasn't set it, use the settings from the connector
       if (req.scheme().isNull()) {
           // Use connector scheme and secure configuration, (defaults to
           // "http" and false respectively)
           req.scheme().setString(connector.getScheme());
           request.setSecure(connector.getSecure());
       } else {
           // Use processor specified scheme to determine secure state
           request.setSecure(req.scheme().equals("https"));
       }

       // At this point the Host header has been processed.
       // Override if the proxyPort/proxyHost are set
       String proxyName = connector.getProxyName();
       int proxyPort = connector.getProxyPort();
       if (proxyPort != 0) {
           req.setServerPort(proxyPort);
       } else if (req.getServerPort() == -1) {
           // Not explicitly set. Use default ports based on the scheme
           if (req.scheme().equals("https")) {
               req.setServerPort(443);
           } else {
               req.setServerPort(80);
           }
       }
       if (proxyName != null) {
           req.serverName().setString(proxyName);
       }

       MessageBytes undecodedURI = req.requestURI();

       // Check for ping OPTIONS * request
       if (undecodedURI.equals("*")) {
           if (req.method().equalsIgnoreCase("OPTIONS")) {
               StringBuilder allow = new StringBuilder();
               allow.append("GET, HEAD, POST, PUT, DELETE, OPTIONS");
               // Trace if allowed
               if (connector.getAllowTrace()) {
                   allow.append(", TRACE");
               }
               res.setHeader("Allow", allow.toString());
               // Access log entry as processing won't reach AccessLogValve
               connector.getService().getContainer().logAccess(request, response, 0, true);
               return false;
           } else {
               response.sendError(400, "Invalid URI");
           }
       }

       MessageBytes decodedURI = req.decodedURI();

       if (undecodedURI.getType() == MessageBytes.T_BYTES) {
           // Copy the raw URI to the decodedURI
           decodedURI.duplicate(undecodedURI);

           // 解析（并去掉）路径参数
           parsePathParameters(req, request);

           // URI decoding
           // %xx decoding of the URL
           try {
               req.getURLDecoder().convert(decodedURI.getByteChunk(), connector.getEncodedSolidusHandlingInternal());
           } catch (IOException ioe) {
               response.sendError(400, "Invalid URI: " + ioe.getMessage());
           }
           // Normalization
           if (normalize(req.decodedURI())) {
               // Character decoding
               convertURI(decodedURI, request);
               // Check that the URI is still normalized
               if (!checkNormalize(req.decodedURI())) {
                   response.sendError(400, "Invalid URI");
               }
           } else {
               response.sendError(400, "Invalid URI");
           }
       } else {
           /* The URI is chars or String, and has been sent using an in-memory
            * protocol handler. The following assumptions are made:
            * - req.requestURI() has been set to the 'original' non-decoded,
            *   non-normalized URI
            * - req.decodedURI() has been set to the decoded, normalized form
            *   of req.requestURI()
            */
           decodedURI.toChars();
           // Remove all path parameters; any needed path parameter should be set
           // using the request object rather than passing it in the URL
           CharChunk uriCC = decodedURI.getCharChunk();
           int semicolon = uriCC.indexOf(';');
           if (semicolon > 0) {
               decodedURI.setChars(uriCC.getBuffer(), uriCC.getStart(), semicolon);
           }
       }

       // Request mapping.
       MessageBytes serverName;
       if (connector.getUseIPVHosts()) {
           serverName = req.localName();
           if (serverName.isNull()) {
               // well, they did ask for it
               res.action(ActionCode.REQ_LOCAL_NAME_ATTRIBUTE, null);
           }
       } else {
           serverName = req.serverName();
       }

       // Version for the second mapping loop and
       // Context that we expect to get for that version
       String version = null;
       Context versionContext = null;
       boolean mapRequired = true;

       if (response.isError()) {
           // An error this early means the URI is invalid. Ensure invalid data
           // is not passed to the mapper. Note we still want the mapper to
           // find the correct host.
           decodedURI.recycle();
       }

       while (mapRequired) {
           // This will map the the latest version by default
           connector.getService().getMapper().map(serverName, decodedURI,
                   version, request.getMappingData());

           // If there is no context at this point, either this is a 404
           // because no ROOT context has been deployed or the URI was invalid
           // so no context could be mapped.
           if (request.getContext() == null) {
               // Don't overwrite an existing error
               if (!response.isError()) {
                   response.sendError(404);
               }
               // Allow processing to continue.
               // If present, the error reporting valve will provide a response
               // body.
               return true;
           }

           // Now we have the context, we can parse the session ID from the URL
           // (if any). Need to do this before we redirect in case we need to
           // include the session id in the redirect
           String sessionID;
           if (request.getServletContext().getEffectiveSessionTrackingModes()
                   .contains(SessionTrackingMode.URL)) {

               // Get the session ID if there was one
               sessionID = request.getPathParameter(
                       SessionConfig.getSessionUriParamName(
                               request.getContext()));
               if (sessionID != null) {
                   request.setRequestedSessionId(sessionID);
                   request.setRequestedSessionURL(true);
               }
           }

           // Look for session ID in cookies and SSL session
           try {
               parseSessionCookiesId(request);
           } catch (IllegalArgumentException e) {
               // Too many cookies
               if (!response.isError()) {
                   response.setError();
                   response.sendError(400);
               }
               return true;
           }
           parseSessionSslId(request);

           sessionID = request.getRequestedSessionId();

           mapRequired = false;
           if (version != null && request.getContext() == versionContext) {
               // We got the version that we asked for. That is it.
           } else {
               version = null;
               versionContext = null;

               Context[] contexts = request.getMappingData().contexts;
               // Single contextVersion means no need to remap
               // No session ID means no possibility of remap
               if (contexts != null && sessionID != null) {
                   // Find the context associated with the session
                   for (int i = contexts.length; i > 0; i--) {
                       Context ctxt = contexts[i - 1];
                       if (ctxt.getManager().findSession(sessionID) != null) {
                           // We found a context. Is it the one that has
                           // already been mapped?
                           if (!ctxt.equals(request.getMappingData().context)) {
                               // Set version so second time through mapping
                               // the correct context is found
                               version = ctxt.getWebappVersion();
                               versionContext = ctxt;
                               // Reset mapping
                               request.getMappingData().recycle();
                               mapRequired = true;
                               // Recycle cookies and session info in case the
                               // correct context is configured with different
                               // settings
                               request.recycleSessionInfo();
                               request.recycleCookieInfo(true);
                           }
                           break;
                       }
                   }
               }
           }

           if (!mapRequired && request.getContext().getPaused()) {
               // Found a matching context but it is paused. Mapping data will
               // be wrong since some Wrappers may not be registered at this
               // point.
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   // Should never happen
               }
               // Reset mapping
               request.getMappingData().recycle();
               mapRequired = true;
           }
       }

       // Possible redirect
       MessageBytes redirectPathMB = request.getMappingData().redirectPath;
       if (!redirectPathMB.isNull()) {
           String redirectPath = URLEncoder.DEFAULT.encode(
                   redirectPathMB.toString(), StandardCharsets.UTF_8);
           String query = request.getQueryString();
           if (request.isRequestedSessionIdFromURL()) {
               // This is not optimal, but as this is not very common, it
               // shouldn't matter
               redirectPath = redirectPath + ";" +
                       SessionConfig.getSessionUriParamName(
                           request.getContext()) +
                   "=" + request.getRequestedSessionId();
           }
           if (query != null) {
               // This is not optimal, but as this is not very common, it
               // shouldn't matter
               redirectPath = redirectPath + "?" + query;
           }
           response.sendRedirect(redirectPath);
           request.getContext().logAccess(request, response, 0, true);
           return false;
       }

       // Filter trace method
       if (!connector.getAllowTrace()
               && req.method().equalsIgnoreCase("TRACE")) {
           Wrapper wrapper = request.getWrapper();
           String header = null;
           if (wrapper != null) {
               String[] methods = wrapper.getServletMethods();
               if (methods != null) {
                   for (String method : methods) {
                       if ("TRACE".equals(method)) {
                           continue;
                       }
                       if (header == null) {
                           header = method;
                       } else {
                           header += ", " + method;
                       }
                   }
               }
           }
           if (header != null) {
               res.addHeader("Allow", header);
           }
           response.sendError(405, "TRACE method is not allowed");
           // Safe to skip the remainder of this method.
           return true;
       }

       doConnectorAuthenticationAuthorization(req, request);

       return true;
   }

Pipeline的调用

Servlet调用流程

StandardEngineValve

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Override
  public final void invoke(Request request, Response response)
      throws IOException, ServletException {

      // Select the Host to be used for this Request
      Host host = request.getHost();
      if (host == null) {
          response.sendError
              (HttpServletResponse.SC_BAD_REQUEST,
               sm.getString("standardEngine.noHost",
                            request.getServerName()));
          return;
      }
      if (request.isAsyncSupported()) {
          request.setAsyncSupported(host.getPipeline().isAsyncSupported());
      }

      // Ask this Host to process this request
      host.getPipeline().getFirst().invoke(request, response);

  }

AbstractAccessLogValve

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Override
  public void invoke(Request request, Response response) throws IOException,
          ServletException {
      if (tlsAttributeRequired) {
          // The log pattern uses TLS attributes. Ensure these are populated
          // before the request is processed because with NIO2 it is possible
          // for the connection to be closed (and the TLS info lost) before
          // the access log requests the TLS info. Requesting it now causes it
          // to be cached in the request.
          request.getAttribute(Globals.CERTIFICATES_ATTR);
      }
      if (cachedElements != null) {
          for (CachedElement element : cachedElements) {
              element.cache(request);
          }
      }
      getNext().invoke(request, response);
  }

ErrorReportValve

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
@Override
  public void invoke(Request request, Response response) throws IOException, ServletException {

      // Perform the request
      getNext().invoke(request, response);

      if (response.isCommitted()) {
          if (response.setErrorReported()) {
              // Error wasn't previously reported but we can't write an error
              // page because the response has already been committed. Attempt
              // to flush any data that is still to be written to the client.
              try {
                  response.flushBuffer();
              } catch (Throwable t) {
                  ExceptionUtils.handleThrowable(t);
              }
              // Close immediately to signal to the client that something went
              // wrong
              response.getCoyoteResponse().action(ActionCode.CLOSE_NOW,
                      request.getAttribute(RequestDispatcher.ERROR_EXCEPTION));
          }
          return;
      }

      Throwable throwable = (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);

      // If an async request is in progress and is not going to end once this
      // container thread finishes, do not process any error page here.
      if (request.isAsync() && !request.isAsyncCompleting()) {
          return;
      }

      if (throwable != null && !response.isError()) {
          // Make sure that the necessary methods have been called on the
          // response. (It is possible a component may just have set the
          // Throwable. Tomcat won't do that but other components might.)
          // These are safe to call at this point as we know that the response
          // has not been committed.
          response.reset();
          response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
      }

      // One way or another, response.sendError() will have been called before
      // execution reaches this point and suspended the response. Need to
      // reverse that so this valve can write to the response.
      response.setSuspended(false);

      try {
          report(request, response, throwable);
      } catch (Throwable tt) {
          ExceptionUtils.handleThrowable(tt);
      }
  }

StandardHostValve

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
@Override
   public final void invoke(Request request, Response response)
       throws IOException, ServletException {

       // Select the Context to be used for this Request
       Context context = request.getContext();
       if (context == null) {
           return;
       }

       if (request.isAsyncSupported()) {
           request.setAsyncSupported(context.getPipeline().isAsyncSupported());
       }

       boolean asyncAtStart = request.isAsync();

       try {
           context.bind(Globals.IS_SECURITY_ENABLED, MY_CLASSLOADER);

           if (!asyncAtStart && !context.fireRequestInitEvent(request.getRequest())) {
               // 在异步处理期间不要激发侦听器（为调用startAsync（）的请求激发侦听器）。如果request init listener抛出异常，则请求被中止。
               return;
           }

           // 询问此上下文以处理此请求。已经出错的请求必须路由到此处以检查应用程序定义的错误页，因此不要将它们转发给应用程序进行处理。
           try {
               if (!response.isErrorReportRequired()) {
                   context.getPipeline().getFirst().invoke(request, response);
               }
           } catch (Throwable t) {
               ExceptionUtils.handleThrowable(t);
               container.getLogger().error("Exception Processing " + request.getRequestURI(), t);
               // If a new error occurred while trying to report a previous
               // error allow the original error to be reported.
               if (!response.isErrorReportRequired()) {
                   request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, t);
                   throwable(request, response, t);
               }
           }

           // 现在请求/响应对已经回到容器控制之下，请解除挂起，以便错误处理可以完成和/或容器可以刷新任何剩余的数据
           response.setSuspended(false);

           Throwable t = (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);

           // 如果上下文在长时间运行的请求期间被破坏，则提供保护以防止NPE。
           if (!context.getState().isAvailable()) {
               return;
           }

           // Look for (and render if found) an application level error page
           if (response.isErrorReportRequired()) {
               // 如果发生了阻止进一步I/O的错误，不要浪费时间生成永远不会被读取的错误报告
               AtomicBoolean result = new AtomicBoolean(false);
               response.getCoyoteResponse().action(ActionCode.IS_IO_ALLOWED, result);
               if (result.get()) {
                   if (t != null) {
                       throwable(request, response, t);
                   } else {
                       status(request, response);
                   }
               }
           }

           if (!request.isAsync() && !asyncAtStart) {
               context.fireRequestDestroyEvent(request.getRequest());
           }
       } finally {
           // Access a session (if present) to update last accessed time, based
           // on a strict interpretation of the specification
           if (ACCESS_SESSION) {
               request.getSession(false);
           }

           context.unbind(Globals.IS_SECURITY_ENABLED, MY_CLASSLOADER);
       }
   }

AuthenticatorBase

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
@Override
   public void invoke(Request request, Response response) throws IOException, ServletException {

       if (log.isDebugEnabled()) {
           log.debug("Security checking request " + request.getMethod() + " " +
                   request.getRequestURI());
       }

       // Have we got a cached authenticated Principal to record?
       if (cache) {
           Principal principal = request.getUserPrincipal();
           if (principal == null) {
               // 获取session
               Session session = request.getSessionInternal(false);
               if (session != null) {
                   principal = session.getPrincipal();
                   if (principal != null) {
                       if (log.isDebugEnabled()) {
                           log.debug("We have cached auth type " + session.getAuthType() +
                                   " for principal " + principal);
                       }
                       request.setAuthType(session.getAuthType());
                       request.setUserPrincipal(principal);
                   }
               }
           }
       }

       boolean authRequired = isContinuationRequired(request);

       Realm realm = this.context.getRealm();
       // Is this request URI subject to a security constraint?
       SecurityConstraint[] constraints = realm.findSecurityConstraints(request, this.context);

       AuthConfigProvider jaspicProvider = getJaspicProvider();
       if (jaspicProvider != null) {
           authRequired = true;
       }

       if (constraints == null && !context.getPreemptiveAuthentication() && !authRequired) {
           if (log.isDebugEnabled()) {
               log.debug("Not subject to any constraint");
           }
           getNext().invoke(request, response);
           return;
       }

       // Make sure that constrained resources are not cached by web proxies
       // or browsers as caching can provide a security hole
       if (constraints != null && disableProxyCaching &&
               !"POST".equalsIgnoreCase(request.getMethod())) {
           if (securePagesWithPragma) {
               // Note: These can cause problems with downloading files with IE
               response.setHeader("Pragma", "No-cache");
               response.setHeader("Cache-Control", "no-cache");
           } else {
               response.setHeader("Cache-Control", "private");
           }
           response.setHeader("Expires", DATE_ONE);
       }

       if (constraints != null) {
           // Enforce any user data constraint for this security constraint
           if (log.isDebugEnabled()) {
               log.debug("Calling hasUserDataPermission()");
           }
           if (!realm.hasUserDataPermission(request, response, constraints)) {
               if (log.isDebugEnabled()) {
                   log.debug("Failed hasUserDataPermission() test");
               }
               /*
                * ASSERT: Authenticator already set the appropriate HTTP status
                * code, so we do not have to do anything special
                */
               return;
           }
       }

       // Since authenticate modifies the response on failure,
       // we have to check for allow-from-all first.
       boolean hasAuthConstraint = false;
       if (constraints != null) {
           hasAuthConstraint = true;
           for (int i = 0; i < constraints.length && hasAuthConstraint; i++) {
               if (!constraints[i].getAuthConstraint()) {
                   hasAuthConstraint = false;
               } else if (!constraints[i].getAllRoles() &&
                       !constraints[i].getAuthenticatedUsers()) {
                   String[] roles = constraints[i].findAuthRoles();
                   if (roles == null || roles.length == 0) {
                       hasAuthConstraint = false;
                   }
               }
           }
       }

       if (!authRequired && hasAuthConstraint) {
           authRequired = true;
       }

       if (!authRequired && context.getPreemptiveAuthentication()) {
           authRequired =
                   request.getCoyoteRequest().getMimeHeaders().getValue("authorization") != null;
       }

       if (!authRequired && context.getPreemptiveAuthentication() &&
               HttpServletRequest.CLIENT_CERT_AUTH.equals(getAuthMethod())) {
           X509Certificate[] certs = getRequestCertificates(request);
           authRequired = certs != null && certs.length > 0;
       }

       JaspicState jaspicState = null;

       if ((authRequired || constraints != null) && allowCorsPreflightBypass(request)) {
           if (log.isDebugEnabled()) {
               log.debug("CORS Preflight request bypassing authentication");
           }
           getNext().invoke(request, response);
           return;
       }

       if (authRequired) {
           if (log.isDebugEnabled()) {
               log.debug("Calling authenticate()");
           }

           if (jaspicProvider != null) {
               jaspicState = getJaspicState(jaspicProvider, request, response, hasAuthConstraint);
               if (jaspicState == null) {
                   return;
               }
           }

           if (jaspicProvider == null && !doAuthenticate(request, response) ||
                   jaspicProvider != null &&
                           !authenticateJaspic(request, response, jaspicState, false)) {
               if (log.isDebugEnabled()) {
                   log.debug("Failed authenticate() test");
               }
               /*
                * ASSERT: Authenticator already set the appropriate HTTP status
                * code, so we do not have to do anything special
                */
               return;
           }

       }

       if (constraints != null) {
           if (log.isDebugEnabled()) {
               log.debug("Calling accessControl()");
           }
           if (!realm.hasResourcePermission(request, response, constraints, this.context)) {
               if (log.isDebugEnabled()) {
                   log.debug("Failed accessControl() test");
               }
               /*
                * ASSERT: AccessControl method has already set the appropriate
                * HTTP status code, so we do not have to do anything special
                */
               return;
           }
       }

       // Any and all specified constraints have been satisfied
       if (log.isDebugEnabled()) {
           log.debug("Successfully passed all security constraints");
       }
       getNext().invoke(request, response);

       if (jaspicProvider != null) {
           secureResponseJspic(request, response, jaspicState);
       }
   }

StandardContextValve

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public final void invoke(Request request, Response response)
       throws IOException, ServletException {

       // Disallow any direct access to resources under WEB-INF or META-INF
       MessageBytes requestPathMB = request.getRequestPathMB();
       if ((requestPathMB.startsWithIgnoreCase("/META-INF/", 0))
               || (requestPathMB.equalsIgnoreCase("/META-INF"))
               || (requestPathMB.startsWithIgnoreCase("/WEB-INF/", 0))
               || (requestPathMB.equalsIgnoreCase("/WEB-INF"))) {
           response.sendError(HttpServletResponse.SC_NOT_FOUND);
           return;
       }

       // Select the Wrapper to be used for this Request
       Wrapper wrapper = request.getWrapper();
       if (wrapper == null || wrapper.isUnavailable()) {
           response.sendError(HttpServletResponse.SC_NOT_FOUND);
           return;
       }

       // Acknowledge the request
       try {
           response.sendAcknowledgement();
       } catch (IOException ioe) {
           container.getLogger().error(sm.getString(
                   "standardContextValve.acknowledgeException"), ioe);
           request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, ioe);
           response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
           return;
       }

       if (request.isAsyncSupported()) {
           request.setAsyncSupported(wrapper.getPipeline().isAsyncSupported());
       }
       wrapper.getPipeline().getFirst().invoke(request, response);
   }

StandardWrapperValve

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
@Override
   public final void invoke(Request request, Response response)
       throws IOException, ServletException {

       // Initialize local variables we may need
       boolean unavailable = false;
       Throwable throwable = null;
       // This should be a Request attribute...
       long t1=System.currentTimeMillis();
       requestCount.incrementAndGet();
       StandardWrapper wrapper = (StandardWrapper) getContainer();
       Servlet servlet = null;
       Context context = (Context) wrapper.getParent();

       // Check for the application being marked unavailable
       if (!context.getState().isAvailable()) {
           response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                          sm.getString("standardContext.isUnavailable"));
           unavailable = true;
       }

       // Check for the servlet being marked unavailable
       if (!unavailable && wrapper.isUnavailable()) {
           container.getLogger().info(sm.getString("standardWrapper.isUnavailable",
                   wrapper.getName()));
           long available = wrapper.getAvailable();
           if ((available > 0L) && (available < Long.MAX_VALUE)) {
               response.setDateHeader("Retry-After", available);
               response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                       sm.getString("standardWrapper.isUnavailable",
                               wrapper.getName()));
           } else if (available == Long.MAX_VALUE) {
               response.sendError(HttpServletResponse.SC_NOT_FOUND,
                       sm.getString("standardWrapper.notFound",
                               wrapper.getName()));
           }
           unavailable = true;
       }

       // Allocate a servlet instance to process this request
       try {
           if (!unavailable) {
               servlet = wrapper.allocate();
           }
       } catch (UnavailableException e) {
           container.getLogger().error(
                   sm.getString("standardWrapper.allocateException",
                           wrapper.getName()), e);
           long available = wrapper.getAvailable();
           if ((available > 0L) && (available < Long.MAX_VALUE)) {
               response.setDateHeader("Retry-After", available);
               response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                          sm.getString("standardWrapper.isUnavailable",
                                       wrapper.getName()));
           } else if (available == Long.MAX_VALUE) {
               response.sendError(HttpServletResponse.SC_NOT_FOUND,
                          sm.getString("standardWrapper.notFound",
                                       wrapper.getName()));
           }
       } catch (ServletException e) {
           container.getLogger().error(sm.getString("standardWrapper.allocateException",
                            wrapper.getName()), StandardWrapper.getRootCause(e));
           throwable = e;
           exception(request, response, e);
       } catch (Throwable e) {
           ExceptionUtils.handleThrowable(e);
           container.getLogger().error(sm.getString("standardWrapper.allocateException",
                            wrapper.getName()), e);
           throwable = e;
           exception(request, response, e);
           servlet = null;
       }

       MessageBytes requestPathMB = request.getRequestPathMB();
       DispatcherType dispatcherType = DispatcherType.REQUEST;
       if (request.getDispatcherType()==DispatcherType.ASYNC) dispatcherType = DispatcherType.ASYNC;
       request.setAttribute(Globals.DISPATCHER_TYPE_ATTR,dispatcherType);
       request.setAttribute(Globals.DISPATCHER_REQUEST_PATH_ATTR,
               requestPathMB);
       
       
       
       // 终于找到了 filter的这一条链表
       // Create the filter chain for this request
       ApplicationFilterChain filterChain =
               ApplicationFilterFactory.createFilterChain(request, wrapper, servlet);

       // Call the filter chain for this request
       // NOTE: This also calls the servlet's service() method
       try {
           if ((servlet != null) && (filterChain != null)) {
               // Swallow output if needed
               if (context.getSwallowOutput()) {
                   try {
                       SystemLogHandler.startCapture();
                       if (request.isAsyncDispatching()) {
                           request.getAsyncContextInternal().doInternalDispatch();
                       } else {
                           // 开始进行链表执行
                           filterChain.doFilter(request.getRequest(),
                                   response.getResponse());
                       }
                   } finally {
                       String log = SystemLogHandler.stopCapture();
                       if (log != null && log.length() > 0) {
                           context.getLogger().info(log);
                       }
                   }
               } else {
                   if (request.isAsyncDispatching()) {
                       request.getAsyncContextInternal().doInternalDispatch();
                   } else {
                       filterChain.doFilter
                           (request.getRequest(), response.getResponse());
                   }
               }

           }
       } catch (ClientAbortException | CloseNowException e) {
           if (container.getLogger().isDebugEnabled()) {
               container.getLogger().debug(sm.getString(
                       "standardWrapper.serviceException", wrapper.getName(),
                       context.getName()), e);
           }
           throwable = e;
           exception(request, response, e);
       } catch (IOException e) {
           container.getLogger().error(sm.getString(
                   "standardWrapper.serviceException", wrapper.getName(),
                   context.getName()), e);
           throwable = e;
           exception(request, response, e);
       } catch (UnavailableException e) {
           container.getLogger().error(sm.getString(
                   "standardWrapper.serviceException", wrapper.getName(),
                   context.getName()), e);
           //            throwable = e;
           //            exception(request, response, e);
           wrapper.unavailable(e);
           long available = wrapper.getAvailable();
           if ((available > 0L) && (available < Long.MAX_VALUE)) {
               response.setDateHeader("Retry-After", available);
               response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                          sm.getString("standardWrapper.isUnavailable",
                                       wrapper.getName()));
           } else if (available == Long.MAX_VALUE) {
               response.sendError(HttpServletResponse.SC_NOT_FOUND,
                           sm.getString("standardWrapper.notFound",
                                       wrapper.getName()));
           }
           // Do not save exception in 'throwable', because we
           // do not want to do exception(request, response, e) processing
       } catch (ServletException e) {
           Throwable rootCause = StandardWrapper.getRootCause(e);
           if (!(rootCause instanceof ClientAbortException)) {
               container.getLogger().error(sm.getString(
                       "standardWrapper.serviceExceptionRoot",
                       wrapper.getName(), context.getName(), e.getMessage()),
                       rootCause);
           }
           throwable = e;
           exception(request, response, e);
       } catch (Throwable e) {
           ExceptionUtils.handleThrowable(e);
           container.getLogger().error(sm.getString(
                   "standardWrapper.serviceException", wrapper.getName(),
                   context.getName()), e);
           throwable = e;
           exception(request, response, e);
       } finally {
           // Release the filter chain (if any) for this request
           if (filterChain != null) {
               filterChain.release();
           }

           // Deallocate the allocated servlet instance
           try {
               if (servlet != null) {
                   wrapper.deallocate(servlet);
               }
           } catch (Throwable e) {
               ExceptionUtils.handleThrowable(e);
               container.getLogger().error(sm.getString("standardWrapper.deallocateException",
                                wrapper.getName()), e);
               if (throwable == null) {
                   throwable = e;
                   exception(request, response, e);
               }
           }

           // If this servlet has been marked permanently unavailable,
           // unload it and release this instance
           try {
               if ((servlet != null) &&
                   (wrapper.getAvailable() == Long.MAX_VALUE)) {
                   wrapper.unload();
               }
           } catch (Throwable e) {
               ExceptionUtils.handleThrowable(e);
               container.getLogger().error(sm.getString("standardWrapper.unloadException",
                                wrapper.getName()), e);
               if (throwable == null) {
                   exception(request, response, e);
               }
           }
           long t2=System.currentTimeMillis();

           long time=t2-t1;
           processingTime += time;
           if( time > maxTime) maxTime=time;
           if( time < minTime) minTime=time;
       }
   }

Filter责任链

ApplicationFilterChain

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

@Override
   public void doFilter(ServletRequest request, ServletResponse response)
       throws IOException, ServletException {

       if( Globals.IS_SECURITY_ENABLED ) {
           final ServletRequest req = request;
           final ServletResponse res = response;
           try {
               java.security.AccessController.doPrivileged(
                   new java.security.PrivilegedExceptionAction<Void>() {
                       @Override
                       public Void run()
                           throws ServletException, IOException {
                           internalDoFilter(req,res);
                           return null;
                       }
                   }
               );
           } catch( PrivilegedActionException pe) {
               Exception e = pe.getException();
               if (e instanceof ServletException)
                   throw (ServletException) e;
               else if (e instanceof IOException)
                   throw (IOException) e;
               else if (e instanceof RuntimeException)
                   throw (RuntimeException) e;
               else
                   throw new ServletException(e.getMessage(), e);
           }
       } else {
           internalDoFilter(request,response);
       }
   }

internalDoFilter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
private void internalDoFilter(ServletRequest request,
                                 ServletResponse response)
       throws IOException, ServletException {

       // Call the next filter if there is one
       if (pos < n) {
           //过滤器执行
           ApplicationFilterConfig filterConfig = filters[pos++];
           try {
               Filter filter = filterConfig.getFilter();

               if (request.isAsyncSupported() && "false".equalsIgnoreCase(
                       filterConfig.getFilterDef().getAsyncSupported())) {
                   request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR, Boolean.FALSE);
               }
               if( Globals.IS_SECURITY_ENABLED ) {
                   final ServletRequest req = request;
                   final ServletResponse res = response;
                   Principal principal =
                       ((HttpServletRequest) req).getUserPrincipal();

                   Object[] args = new Object[]{req, res, this};
                   SecurityUtil.doAsPrivilege ("doFilter", filter, classType, args, principal);
               } else {
                   // 执行过滤器
                   filter.doFilter(request, response, this);
               }
           } catch (IOException | ServletException | RuntimeException e) {
               throw e;
           } catch (Throwable e) {
               e = ExceptionUtils.unwrapInvocationTargetException(e);
               ExceptionUtils.handleThrowable(e);
               throw new ServletException(sm.getString("filterChain.filter"), e);
           }
           return;
       }

       // We fell off the end of the chain -- call the servlet instance
       try {
           if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
               lastServicedRequest.set(request);
               lastServicedResponse.set(response);
           }

           if (request.isAsyncSupported() && !servletSupportsAsync) {
               request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
                       Boolean.FALSE);
           }
           // Use potentially wrapped request from this point
           if ((request instanceof HttpServletRequest) &&
                   (response instanceof HttpServletResponse) &&
                   Globals.IS_SECURITY_ENABLED ) {
               final ServletRequest req = request;
               final ServletResponse res = response;
               Principal principal =
                   ((HttpServletRequest) req).getUserPrincipal();
               Object[] args = new Object[]{req, res};
               SecurityUtil.doAsPrivilege("service",
                                          servlet,
                                          classTypeUsedInService,
                                          args,
                                          principal);
           } else {
               servlet.service(request, response);
           }
       } catch (IOException | ServletException | RuntimeException e) {
           throw e;
       } catch (Throwable e) {
           e = ExceptionUtils.unwrapInvocationTargetException(e);
           ExceptionUtils.handleThrowable(e);
           throw new ServletException(sm.getString("filterChain.servlet"), e);
       } finally {
           if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
               lastServicedRequest.set(null);
               lastServicedResponse.set(null);
           }
       }
   }

Servlet分配

StandardWrapper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
@Override
   public Servlet allocate() throws ServletException {

       // If we are currently unloading this servlet, throw an exception
       if (unloading) {
           throw new ServletException(sm.getString("standardWrapper.unloading", getName()));
       }

       boolean newInstance = false;

       // If not SingleThreadedModel, return the same instance every time
       if (!singleThreadModel) {
           // Load and initialize our instance if necessary
           if (instance == null || !instanceInitialized) {
               synchronized (this) {
                   if (instance == null) {
                       try {
                           if (log.isDebugEnabled()) {
                               log.debug("Allocating non-STM instance");
                           }

                           // Note: We don't know if the Servlet implements
                           // SingleThreadModel until we have loaded it.
                           instance = loadServlet();
                           newInstance = true;
                           if (!singleThreadModel) {
                               // For non-STM, increment here to prevent a race
                               // condition with unload. Bug 43683, test case
                               // #3
                               countAllocated.incrementAndGet();
                           }
                       } catch (ServletException e) {
                           throw e;
                       } catch (Throwable e) {
                           ExceptionUtils.handleThrowable(e);
                           throw new ServletException(sm.getString("standardWrapper.allocate"), e);
                       }
                   }
                   if (!instanceInitialized) {
                       initServlet(instance);
                   }
               }
           }

           if (singleThreadModel) {
               if (newInstance) {
                   // Have to do this outside of the sync above to prevent a
                   // possible deadlock
                   synchronized (instancePool) {
                       instancePool.push(instance);
                       nInstances++;
                   }
               }
           } else {
               if (log.isTraceEnabled()) {
                   log.trace("  Returning non-STM instance");
               }
               // For new instances, count will have been incremented at the
               // time of creation
               if (!newInstance) {
                   countAllocated.incrementAndGet();
               }
               return instance;
           }
       }

       synchronized (instancePool) {
           while (countAllocated.get() >= nInstances) {
               // Allocate a new instance if possible, or else wait
               if (nInstances < maxInstances) {
                   try {
                       instancePool.push(loadServlet());
                       nInstances++;
                   } catch (ServletException e) {
                       throw e;
                   } catch (Throwable e) {
                       ExceptionUtils.handleThrowable(e);
                       throw new ServletException(sm.getString("standardWrapper.allocate"), e);
                   }
               } else {
                   try {
                       instancePool.wait();
                   } catch (InterruptedException e) {
                       // Ignore
                   }
               }
           }
           if (log.isTraceEnabled()) {
               log.trace("  Returning allocated STM instance");
           }
           countAllocated.incrementAndGet();
           return instancePool.pop();
       }
   }

loadServlet

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

public synchronized Servlet loadServlet() throws ServletException {

       // Nothing to do if we already have an instance or an instance pool
       if (!singleThreadModel && (instance != null))
           return instance;

       PrintStream out = System.out;
       if (swallowOutput) {
           SystemLogHandler.startCapture();
       }

       Servlet servlet;
       try {
           long t1=System.currentTimeMillis();
           // Complain if no servlet class has been specified
           if (servletClass == null) {
               unavailable(null);
               throw new ServletException
                   (sm.getString("standardWrapper.notClass", getName()));
           }

           InstanceManager instanceManager = ((StandardContext)getParent()).getInstanceManager();
           try {
               servlet = (Servlet) instanceManager.newInstance(servletClass);
           } catch (ClassCastException e) {
               unavailable(null);
               // Restore the context ClassLoader
               throw new ServletException
                   (sm.getString("standardWrapper.notServlet", servletClass), e);
           } catch (Throwable e) {
               e = ExceptionUtils.unwrapInvocationTargetException(e);
               ExceptionUtils.handleThrowable(e);
               unavailable(null);

               // Added extra log statement for Bugzilla 36630:
               // https://bz.apache.org/bugzilla/show_bug.cgi?id=36630
               if(log.isDebugEnabled()) {
                   log.debug(sm.getString("standardWrapper.instantiate", servletClass), e);
               }

               // Restore the context ClassLoader
               throw new ServletException
                   (sm.getString("standardWrapper.instantiate", servletClass), e);
           }

           if (multipartConfigElement == null) {
               MultipartConfig annotation =
                       servlet.getClass().getAnnotation(MultipartConfig.class);
               if (annotation != null) {
                   multipartConfigElement =
                           new MultipartConfigElement(annotation);
               }
           }

           // Special handling for ContainerServlet instances
           // Note: The InstanceManager checks if the application is permitted
           //       to load ContainerServlets
           if (servlet instanceof ContainerServlet) {
               ((ContainerServlet) servlet).setWrapper(this);
           }

           classLoadTime=(int) (System.currentTimeMillis() -t1);

           if (servlet instanceof SingleThreadModel) {
               if (instancePool == null) {
                   instancePool = new Stack<>();
               }
               singleThreadModel = true;
           }

           initServlet(servlet);

           fireContainerEvent("load", this);

           loadTime=System.currentTimeMillis() -t1;
       } finally {
           if (swallowOutput) {
               String log = SystemLogHandler.stopCapture();
               if (log != null && log.length() > 0) {
                   if (getServletContext() != null) {
                       getServletContext().log(log);
                   } else {
                       out.println(log);
                   }
               }
           }
       }
       return servlet;

   }

执行

1
2
3
4
5
6
7
8
9
10
11

@Override
   protected void service(HttpServletRequest req, HttpServletResponse resp)
           throws ServletException, IOException {

       if (req.getDispatcherType() == DispatcherType.ERROR) {
           doGet(req, resp);
       } else {
           super.service(req, resp);
       }
   }

展开全文 >>

web/tomcat/tomcat基础

tomcat源码编译： https://blog.csdn.net/qq_35262405/article/details/101780644

Tomcat

init

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

LifecycleBase
    所有的组件都继承这个抽象类
    
    public final synchronized void init() throws LifecycleException {
        if (!state.equals(LifecycleState.NEW)) {
            invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
        }

        try {
            setStateInternal(LifecycleState.INITIALIZING, null, false);
            //初始化内部
            initInternal();
            setStateInternal(LifecycleState.INITIALIZED, null, false);
        } catch (Throwable t) {
            handleSubClassException(t, "lifecycleBase.initFail", toString());
        }
    }

Server的初始化

initInternal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 @Override
    protected void initInternal() throws LifecycleException {

        super.initInternal();

        // Register global String cache
        // Note although the cache is global, if there are multiple Servers
        // present in the JVM (may happen when embedding) then the same cache
        // will be registered under multiple names
        onameStringCache = register(new StringCache(), "type=StringCache");

        // Register the MBeanFactory
        MBeanFactory factory = new MBeanFactory();
        factory.setContainer(this);
        onameMBeanFactory = register(factory, "type=MBeanFactory");

        // Register the naming resources
        globalNamingResources.init();

        // Populate the extension validator with JARs from common and shared
        // class loaders
        if (getCatalina() != null) {
            ClassLoader cl = getCatalina().getParentClassLoader();
            // Walk the class loader hierarchy. Stop at the system class loader.
            // This will add the shared (if present) and common class loaders
            while (cl != null && cl != ClassLoader.getSystemClassLoader()) {
                if (cl instanceof URLClassLoader) {
                    URL[] urls = ((URLClassLoader) cl).getURLs();
                    for (URL url : urls) {
                        if (url.getProtocol().equals("file")) {
                            try {
                                File f = new File (url.toURI());
                                if (f.isFile() &&
                                        f.getName().endsWith(".jar")) {
                                    ExtensionValidator.addSystemResource(f);
                                }
                            } catch (URISyntaxException e) {
                                // Ignore
                            } catch (IOException e) {
                                // Ignore
                            }
                        }
                    }
                }
                cl = cl.getParent();
            }
        }
        // Initialize our defined Services
        // 初始内部的service
        for (Service service : services) {
            service.init();
        }
    }
所以 一个Server里面有多个Service

Service初始化

initInternal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

@Override
  protected void initInternal() throws LifecycleException {

      super.initInternal();
// 一个Service中有一个引擎engine
      if (engine != null) {
          engine.init();
      }
// 一个Service中有多个执行器
      // Initialize any Executors
      for (Executor executor : findExecutors()) {
          if (executor instanceof JmxEnabled) {
              ((JmxEnabled) executor).setDomain(getDomain());
          }
          executor.init();
      }
//  一个Service中有一个映射监听器
      // Initialize mapper listener
      mapperListener.init();

      // 一个Service中有多个连接器
      // Initialize our defined Connectors
      synchronized (connectorsLock) {
          for (Connector connector : connectors) {
              try {
                  connector.init();
              } catch (Exception e) {
                  String message = sm.getString(
                          "standardService.connector.initFailed", connector);
                  log.error(message, e);

                  if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE"))
                      throw new LifecycleException(message);
              }
          }
      }
  }

Engine初始化

initInternal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    @Override
    protected void initInternal() throws LifecycleException {
        // Ensure that a Realm is present before any attempt is made to start
        // one. This will create the default NullRealm if necessary.
        getRealm();
        super.initInternal();
    }
ContainerBase
    @Override
    protected void initInternal() throws LifecycleException {
        BlockingQueue<Runnable> startStopQueue = new LinkedBlockingQueue<>();
    //初始化一个启动或者停止的线程池
        startStopExecutor = new ThreadPoolExecutor(
                getStartStopThreadsInternal(),
                getStartStopThreadsInternal(), 10, TimeUnit.SECONDS,
                startStopQueue,
                new StartStopThreadFactory(getName() + "-startStop-"));
        startStopExecutor.allowCoreThreadTimeOut(true);
        super.initInternal();
    }

mapperListener初始化

initInternal

1
2
3
4
5
6
7
8
9
10
11

@Override
protected void initInternal() throws LifecycleException {
    // If oname is not null then registration has already happened via
    // preRegister().
    if (oname == null) {
        mserver = Registry.getRegistry(null, null).getMBeanServer();

        oname = register(this, getObjectNameKeyProperties());
    }
}

Connector初始化

initInternal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
protected void initInternal() throws LifecycleException {

       super.initInternal();

       // Initialize adapter
       adapter = new CoyoteAdapter(this);
       protocolHandler.setAdapter(adapter);

       // Make sure parseBodyMethodsSet has a default
       if (null == parseBodyMethodsSet) {
           setParseBodyMethods(getParseBodyMethods());
       }

       if (protocolHandler.isAprRequired() && !AprLifecycleListener.isInstanceCreated()) {
           throw new LifecycleException(sm.getString("coyoteConnector.protocolHandlerNoAprListener",
                   getProtocolHandlerClassName()));
       }
       if (protocolHandler.isAprRequired() && !AprLifecycleListener.isAprAvailable()) {
           throw new LifecycleException(sm.getString("coyoteConnector.protocolHandlerNoAprLibrary",
                   getProtocolHandlerClassName()));
       }
       if (AprLifecycleListener.isAprAvailable() && AprLifecycleListener.getUseOpenSSL() &&
               protocolHandler instanceof AbstractHttp11JsseProtocol) {
           AbstractHttp11JsseProtocol<?> jsseProtocolHandler =
                   (AbstractHttp11JsseProtocol<?>) protocolHandler;
           if (jsseProtocolHandler.isSSLEnabled() &&
                   jsseProtocolHandler.getSslImplementationName() == null) {
               // OpenSSL is compatible with the JSSE configuration, so use it if APR is available
               jsseProtocolHandler.setSslImplementationName(OpenSSLImplementation.class.getName());
           }
       }

       try {
           //一个连接器只有一个处理器
           protocolHandler.init();
       } catch (Exception e) {
           throw new LifecycleException(
                   sm.getString("coyoteConnector.protocolHandlerInitializationFailed"), e);
       }
   }

protocolHandler初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
  @Override
   public void init() throws Exception {
       // Upgrade protocols have to be configured first since the endpoint
       // init (triggered via super.init() below) uses this list to configure
       // the list of ALPN protocols to advertise
       for (UpgradeProtocol upgradeProtocol : upgradeProtocols) {
           configureUpgradeProtocol(upgradeProtocol);
       }

       super.init();
   }


public void init() throws Exception {
       if (getLog().isInfoEnabled()) {
           getLog().info(sm.getString("abstractProtocolHandler.init", getName()));
       }

       if (oname == null) {
           // Component not pre-registered so register it
           oname = createObjectName();
           if (oname != null) {
               Registry.getRegistry(null, null).registerComponent(this, oname, null);
           }
       }

       if (this.domain != null) {
           rgOname = new ObjectName(domain + ":type=GlobalRequestProcessor,name=" + getName());
           Registry.getRegistry(null, null).registerComponent(
                   getHandler().getGlobal(), rgOname, null);
       }

       String endpointName = getName();
       endpoint.setName(endpointName.substring(1, endpointName.length()-1));
       endpoint.setDomain(domain);
	// 一个协议处理器只有一个 远程连接对象
       endpoint.init();
   }

endpoint初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

   @Override
   public void init() throws Exception {
       testServerCipherSuitesOrderSupport();
       super.init();
   }

public void init() throws Exception {
       if (bindOnInit) {
           bind();
           bindState = BindState.BOUND_ON_INIT;
       }
       if (this.domain != null) {
           // Register endpoint (as ThreadPool - historical name)
           oname = new ObjectName(domain + ":type=ThreadPool,name=\"" + getName() + "\"");
           Registry.getRegistry(null, null).registerComponent(this, oname, null);

           ObjectName socketPropertiesOname = new ObjectName(domain +
                   ":type=SocketProperties,name=\"" + getName() + "\"");
           socketProperties.setObjectName(socketPropertiesOname);
           Registry.getRegistry(null, null).registerComponent(socketProperties, socketPropertiesOname, null);

           for (SSLHostConfig sslHostConfig : findSslHostConfigs()) {
               registerJmx(sslHostConfig);
           }
       }
   }

bind

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

  @Override
    public void bind() throws Exception {

        if (!getUseInheritedChannel()) {
            //NIO编程
            serverSock = ServerSocketChannel.open();
            socketProperties.setProperties(serverSock.socket());
            //获取网络地址
            InetSocketAddress addr = (getAddress()!=null?new InetSocketAddress(getAddress(),getPort()):new InetSocketAddress(getPort()));
           
 //指定连接数，默认100
  serverSock.socket().bind(addr,getAcceptCount());
        } else {
            // Retrieve the channel provided by the OS
            Channel ic = System.inheritedChannel();
            if (ic instanceof ServerSocketChannel) {
                serverSock = (ServerSocketChannel) ic;
            }
            if (serverSock == null) {
                throw new IllegalArgumentException(sm.getString("endpoint.init.bind.inherited"));
            }
        }
        // 注意看，接待Channel是阻塞的，
        serverSock.configureBlocking(true); //mimic APR behavior，模板ARP行为

        // Initialize thread count defaults for acceptor, poller
        //接待的线程数，默认为1个，也只需要一个
        if (acceptorThreadCount == 0) {
            // FIXME: Doesn't seem to work that well with multiple accept threads
            acceptorThreadCount = 1;
        }
        // poller的线程数，默认为两个
        if (pollerThreadCount <= 0) {
            //minimum one poller thread
            pollerThreadCount = 1;
        }
        //设置一把锁，CountDownLatch，数量为poll的线程数
        //猜一下就是两个线程都启动了，这把锁才打开
        setStopLatch(new CountDownLatch(pollerThreadCount));

        //初始化SSL
        // Initialize SSL if needed
        initialiseSsl();

        selectorPool.open();
    }

//----
selectorPool
    public void open() throws IOException {
        enabled = true;
    //就是去获取一个共享Seletor。NIO编程
        getSharedSelector();
        if (SHARED) {
            //把这个 获取到的Selector给到blockingSelector
            blockingSelector = new NioBlockingSelector();
            blockingSelector.open(getSharedSelector());
        }

    }

NioBlockingSelector

1
2
3
4
5
6
7
8
9

public void open(Selector selector) {
     sharedSelector = selector;
     poller = new BlockPoller();
     poller.selector = sharedSelector;
     poller.setDaemon(true);
     poller.setName("NioBlockingSelector.BlockPoller-"+(threadCounter.getAndIncrement()));
     poller.start();
 }

BlockPoller

1
2
3
4
5
6
7
8
9
10
11
12
protected static class BlockPoller extends Thread {
    //是一个线程
    
     protected volatile boolean run = true;
        protected Selector selector = null;
        protected final SynchronizedQueue<Runnable> events = new SynchronizedQueue<>();
        public void disable() { run = false; selector.wakeup();}
        protected final AtomicInteger wakeupCounter = new AtomicInteger(0);
    
    
    
}
run
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
public void run() {
          while (run) {
              try {
                  //从队列中取事件进行调用
                  events();
                  int keyCount = 0;
                  try {
                      // 使用selector进行对感兴趣io事件选择
                      int i = wakeupCounter.get();
                      if (i>0)
                          keyCount = selector.selectNow();
                      else {
                          wakeupCounter.set(-1);
                          keyCount = selector.select(1000);
                      }
                      wakeupCounter.set(0);
                      if (!run) break;
                  }catch ( NullPointerException x ) {
                      //sun bug 5076772 on windows JDK 1.5
                      if (selector==null) throw x;
                      if ( log.isDebugEnabled() ) log.debug("Possibly encountered sun bug 5076772 on windows JDK 1.5",x);
                      continue;
                  } catch ( CancelledKeyException x ) {
                      //sun bug 5076772 on windows JDK 1.5
                      if ( log.isDebugEnabled() ) log.debug("Possibly encountered sun bug 5076772 on windows JDK 1.5",x);
                      continue;
                  } catch (Throwable x) {
                      ExceptionUtils.handleThrowable(x);
                      log.error("",x);
                      continue;
                  }
			
                  Iterator<SelectionKey> iterator = keyCount > 0 ? selector.selectedKeys().iterator() : null;

                  // Walk through the collection of ready keys and dispatch
                  // any active event.
                  while (run && iterator != null && iterator.hasNext()) {
                      SelectionKey sk = iterator.next();
                      NioSocketWrapper attachment = (NioSocketWrapper)sk.attachment();
                      try {
                          iterator.remove();
                          //拿出sk
                          sk.interestOps(sk.interestOps() & (~sk.readyOps()));
                          if ( sk.isReadable() ) {
                              //把读锁减-
                              countDown(attachment.getReadLatch());
                          }
                          if (sk.isWritable()) {
                              //把写锁减-
                              countDown(attachment.getWriteLatch());
                          }
                      }catch (CancelledKeyException ckx) {
                          sk.cancel();
                          countDown(attachment.getReadLatch());
                          countDown(attachment.getWriteLatch());
                      }
                  }//while
              }catch ( Throwable t ) {
                  log.error("",t);
              }
          }
    
    // 正常执行结束
          events.clear();
          // If using a shared selector, the NioSelectorPool will also try and
          // close the selector. Try and avoid the ClosedSelectorException
          // although because multiple threads are involved there is always
          // the possibility of an Exception here.
          if (selector.isOpen()) {
              try {
                  // Cancels all remaining keys
                  selector.selectNow();
              }catch( Exception ignore ) {
                  if (log.isDebugEnabled())log.debug("",ignore);
              }
          }
          try {
              selector.close();
          }catch( Exception ignore ) {
              if (log.isDebugEnabled())log.debug("",ignore);
          }
      }

start

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
@Override
   public final synchronized void start() throws LifecycleException {

       if (LifecycleState.STARTING_PREP.equals(state) || LifecycleState.STARTING.equals(state) ||
               LifecycleState.STARTED.equals(state)) {

           if (log.isDebugEnabled()) {
               Exception e = new LifecycleException();
               log.debug(sm.getString("lifecycleBase.alreadyStarted", toString()), e);
           } else if (log.isInfoEnabled()) {
               log.info(sm.getString("lifecycleBase.alreadyStarted", toString()));
           }

           return;
       }

       if (state.equals(LifecycleState.NEW)) {
           init();
       } else if (state.equals(LifecycleState.FAILED)) {
           stop();
       } else if (!state.equals(LifecycleState.INITIALIZED) &&
               !state.equals(LifecycleState.STOPPED)) {
           invalidTransition(Lifecycle.BEFORE_START_EVENT);
       }

       try {
           setStateInternal(LifecycleState.STARTING_PREP, null, false);
           startInternal();
           if (state.equals(LifecycleState.FAILED)) {
               // This is a 'controlled' failure. The component put itself into the
               // FAILED state so call stop() to complete the clean-up.
               stop();
           } else if (!state.equals(LifecycleState.STARTING)) {
               // Shouldn't be necessary but acts as a check that sub-classes are
               // doing what they are supposed to.
               invalidTransition(Lifecycle.AFTER_START_EVENT);
           } else {
               setStateInternal(LifecycleState.STARTED, null, false);
           }
       } catch (Throwable t) {
           // This is an 'uncontrolled' failure so put the component into the
           // FAILED state and throw an exception.
           handleSubClassException(t, "lifecycleBase.startFail", toString());
       }
   }

Server的启动

startInternal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@Override
   protected void startInternal() throws LifecycleException {
	//发射声明周期的事件
       fireLifecycleEvent(CONFIGURE_START_EVENT, null);
       setState(LifecycleState.STARTING);

       globalNamingResources.start();

       // Start our defined Services
       synchronized (servicesLock) {
           for (Service service : services) {
               service.start();
           }
       }
   }

globalNamingResources启动

1
2
3
4
5
6

@Override
protected void startInternal() throws LifecycleException {
    fireLifecycleEvent(CONFIGURE_START_EVENT, null);
    setState(LifecycleState.STARTING);
}

Service启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@Override
   protected void startInternal() throws LifecycleException {

       if(log.isInfoEnabled())
           log.info(sm.getString("standardService.start.name", this.name));
       setState(LifecycleState.STARTING);
	//引擎启动
       // Start our defined Container first
       if (engine != null) {
           synchronized (engine) {
               engine.start();
           }
       }
	// 执行器启动
       synchronized (executors) {
           for (Executor executor: executors) {
               executor.start();
           }
       }
	//mapperListener启动
       
       mapperListener.start();

       // Start our defined Connectors second
       synchronized (connectorsLock) {
           for (Connector connector: connectors) {
               try {
                   // If it has already failed, don't try and start it
                   if (connector.getState() != LifecycleState.FAILED) {
                       //连接器启动
                       connector.start();
                   }
               } catch (Exception e) {
                   log.error(sm.getString(
                           "standardService.connector.startFailed",
                           connector), e);
               }
           }
       }
   }

Engine启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

 protected synchronized void startInternal() throws LifecycleException {

        // Log our server identification information
        if(log.isInfoEnabled())
            log.info( "Starting Servlet Engine: " + ServerInfo.getServerInfo());

        // Standard container startup
        super.startInternal();
    }


@Override
    protected synchronized void startInternal() throws LifecycleException {

        // Start our subordinate components, if any
        logger = null;
        getLogger();
        Cluster cluster = getClusterInternal();
        if (cluster instanceof Lifecycle) {
            ((Lifecycle) cluster).start();
        }
        Realm realm = getRealmInternal();
        if (realm instanceof Lifecycle) {
            ((Lifecycle) realm).start();
        }
		
        //Host交给线程池启动
        // Start our child containers, if any
        Container children[] = findChildren();
        List<Future<Void>> results = new ArrayList<>();
        for (Container child : children) {
            results.add(startStopExecutor.submit(new StartChild(child)));
        }

        MultiThrowable multiThrowable = null;

        for (Future<Void> result : results) {
            try {
                result.get();
            } catch (Throwable e) {
                log.error(sm.getString("containerBase.threadedStartFailed"), e);
                if (multiThrowable == null) {
                    multiThrowable = new MultiThrowable();
                }
                multiThrowable.add(e);
            }

        }
        if (multiThrowable != null) {
            throw new LifecycleException(sm.getString("containerBase.threadedStartFailed"),
                    multiThrowable.getThrowable());
        }

        // Start the Valves in our pipeline (including the basic), if any
        if (pipeline instanceof Lifecycle) {
            ((Lifecycle) pipeline).start();
        }


        setState(LifecycleState.STARTING);

        // Start our thread
        threadStart();
    }

threadStart

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

protected class ContainerBackgroundProcessor implements Runnable {

        @Override
        public void run() {
            Throwable t = null;
            String unexpectedDeathMessage = sm.getString(
                    "containerBase.backgroundProcess.unexpectedThreadDeath",
                    Thread.currentThread().getName());
            try {
                while (!threadDone) {
                    try {
                        Thread.sleep(backgroundProcessorDelay * 1000L);
                    } catch (InterruptedException e) {
                        // Ignore
                    }
                    if (!threadDone) {
                        processChildren(ContainerBase.this);
                    }
                }
            } catch (RuntimeException|Error e) {
                t = e;
                throw e;
            } finally {
                if (!threadDone) {
                    log.error(unexpectedDeathMessage, t);
                }
            }
        }

        protected void processChildren(Container container) {
            ClassLoader originalClassLoader = null;

            try {
                if (container instanceof Context) {
                    Loader loader = ((Context) container).getLoader();
                    // Loader will be null for FailedContext instances
                    if (loader == null) {
                        return;
                    }

                    // Ensure background processing for Contexts and Wrappers
                    // is performed under the web app's class loader
                    originalClassLoader = ((Context) container).bind(false, null);
                }
                container.backgroundProcess();
                Container[] children = container.findChildren();
                for (Container child : children) {
                    if (child.getBackgroundProcessorDelay() <= 0) {
                        processChildren(child);
                    }
                }
            } catch (Throwable t) {
                ExceptionUtils.handleThrowable(t);
                log.error("Exception invoking periodic operation: ", t);
            } finally {
                if (container instanceof Context) {
                    ((Context) container).unbind(false, originalClassLoader);
               }
            }
        }
    }

pipeline启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Override
    protected synchronized void startInternal() throws LifecycleException {

        // Start the Valves in our pipeline (including the basic), if any
        Valve current = first;
        if (current == null) {
            current = basic;
        }
        while (current != null) {
            if (current instanceof Lifecycle)
                ((Lifecycle) current).start();
            current = current.getNext();
        }

        setState(LifecycleState.STARTING);
    }

MapperListener启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public void startInternal() throws LifecycleException {

        setState(LifecycleState.STARTING);

        Engine engine = service.getContainer();
        if (engine == null) {
            return;
        }

        findDefaultHost();

        addListeners(engine);

        Container[] conHosts = engine.findChildren();
        for (Container conHost : conHosts) {
            Host host = (Host) conHost;
            if (!LifecycleState.NEW.equals(host.getState())) {
                // Registering the host will register the context and wrappers
                registerHost(host);
            }
        }
    }

findDefaultHost

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

private void findDefaultHost() {

     Engine engine = service.getContainer();
     String defaultHost = engine.getDefaultHost();

     boolean found = false;

     if (defaultHost != null && defaultHost.length() >0) {
         Container[] containers = engine.findChildren();

         for (Container container : containers) {
             Host host = (Host) container;
             if (defaultHost.equalsIgnoreCase(host.getName())) {
                 found = true;
                 break;
             }

             String[] aliases = host.findAliases();
             for (String alias : aliases) {
                 if (defaultHost.equalsIgnoreCase(alias)) {
                     found = true;
                     break;
                 }
             }
         }
     }

     if(found) {
         mapper.setDefaultHostName(defaultHost);
     } else {
         log.warn(sm.getString("mapperListener.unknownDefaultHost",
                 defaultHost, service));
     }
 }

addListeners

1
2
3
4
5
6
7
private void addListeners(Container container) {
    container.addContainerListener(this);
    container.addLifecycleListener(this);
    for (Container child : container.findChildren()) {
        addListeners(child);
    }
}

registerHost

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
private void registerHost(Host host) {

       String[] aliases = host.findAliases();
       mapper.addHost(host.getName(), aliases, host);

       for (Container container : host.findChildren()) {
           if (container.getState().isAvailable()) {
               registerContext((Context) container);
           }
       }
       if(log.isDebugEnabled()) {
           log.debug(sm.getString("mapperListener.registerHost",
                   host.getName(), domain, service));
  
       }
   }

registerContext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
private void registerContext(Context context) {

      String contextPath = context.getPath();
      if ("/".equals(contextPath)) {
          contextPath = "";
      }
      Host host = (Host)context.getParent();

      WebResourceRoot resources = context.getResources();
      String[] welcomeFiles = context.findWelcomeFiles();
      List<WrapperMappingInfo> wrappers = new ArrayList<>();

      for (Container container : context.findChildren()) {
          prepareWrapperMappingInfo(context, (Wrapper) container, wrappers);

          if(log.isDebugEnabled()) {
              log.debug(sm.getString("mapperListener.registerWrapper",
                      container.getName(), contextPath, service));
          }
      }

      mapper.addContextVersion(host.getName(), host, contextPath,
              context.getWebappVersion(), context, welcomeFiles, resources,
              wrappers);

      if(log.isDebugEnabled()) {
          log.debug(sm.getString("mapperListener.registerContext",
                  contextPath, service));
      }
  }
prepareWrapperMappingInfo
1
2
3
4
5
6
7
8
9
10
11
12
private void prepareWrapperMappingInfo(Context context, Wrapper wrapper,
           List<WrapperMappingInfo> wrappers) {
       String wrapperName = wrapper.getName();
       boolean resourceOnly = context.isResourceOnlyServlet(wrapperName);
       String[] mappings = wrapper.findMappings();
       for (String mapping : mappings) {
           boolean jspWildCard = (wrapperName.equals("jsp")
                                  && mapping.endsWith("/*"));
           wrappers.add(new WrapperMappingInfo(mapping, wrapper, jspWildCard,
                   resourceOnly));
       }
   }

Connector启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Override
protected void startInternal() throws LifecycleException {

    // Validate settings before starting
    if (getPort() < 0) {
        throw new LifecycleException(sm.getString(
                "coyoteConnector.invalidPort", Integer.valueOf(getPort())));
    }

    setState(LifecycleState.STARTING);

    try {
        protocolHandler.start();
    } catch (Exception e) {
        throw new LifecycleException(
                sm.getString("coyoteConnector.protocolHandlerStartFailed"), e);
    }
}

protocolHandler启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

@Override
   public void start() throws Exception {
       if (getLog().isInfoEnabled()) {
           getLog().info(sm.getString("abstractProtocolHandler.start", getName()));
       }

       endpoint.start();

       // Start timeout thread
       asyncTimeout = new AsyncTimeout();
       Thread timeoutThread = new Thread(asyncTimeout, getNameInternal() + "-AsyncTimeout");
       int priority = endpoint.getThreadPriority();
       if (priority < Thread.MIN_PRIORITY || priority > Thread.MAX_PRIORITY) {
           priority = Thread.NORM_PRIORITY;
       }
       timeoutThread.setPriority(priority);
       timeoutThread.setDaemon(true);
       timeoutThread.start();
   }

AsyncTimeout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

protected class AsyncTimeout implements Runnable {

      private volatile boolean asyncTimeoutRunning = true;

      /**
       * The background thread that checks async requests and fires the
       * timeout if there has been no activity.
       */
      @Override
      public void run() {

          // Loop until we receive a shutdown command
          while (asyncTimeoutRunning) {
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  // Ignore
              }
              long now = System.currentTimeMillis();
              for (Processor processor : waitingProcessors) {
                 processor.timeoutAsync(now);
              }

              // Loop if endpoint is paused
              while (endpoint.isPaused() && asyncTimeoutRunning) {
                  try {
                      Thread.sleep(1000);
                  } catch (InterruptedException e) {
                      // Ignore
                  }
              }
          }
      }


      protected void stop() {
          asyncTimeoutRunning = false;

          // Timeout any pending async request
          for (Processor processor : waitingProcessors) {
              processor.timeoutAsync(-1);
          }
      }
  }

endpoint启动

1
2
3
4
5
6
7
public final void start() throws Exception {
      if (bindState == BindState.UNBOUND) {
          bind();
          bindState = BindState.BOUND_ON_START;
      }
      startInternal();
  }

startInternal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public void startInternal() throws Exception {

       if (!running) {
           running = true;
           paused = false;

           processorCache = new SynchronizedStack<>(SynchronizedStack.DEFAULT_SIZE,
                   socketProperties.getProcessorCache());
           eventCache = new SynchronizedStack<>(SynchronizedStack.DEFAULT_SIZE,
                           socketProperties.getEventCache());
           nioChannels = new SynchronizedStack<>(SynchronizedStack.DEFAULT_SIZE,
                   socketProperties.getBufferPool());

           // Create worker collection
           if ( getExecutor() == null ) {
               createExecutor();
           }

           initializeConnectionLatch();

           // Start poller threads
           // 两个poller的启动
           pollers = new Poller[getPollerThreadCount()];
           for (int i=0; i<pollers.length; i++) {
               pollers[i] = new Poller();
               Thread pollerThread = new Thread(pollers[i], getName() + "-ClientPoller-"+i);
               pollerThread.setPriority(threadPriority);
               pollerThread.setDaemon(true);
               pollerThread.start();
           }

           startAcceptorThreads();
       }
   }

createExecutor

1
2
3
4
5
6
7
8
public void createExecutor() {
    internalExecutor = true;
    TaskQueue taskqueue = new TaskQueue();
    TaskThreadFactory tf = new TaskThreadFactory(getName() + "-exec-", daemon, getThreadPriority());
    //这个线程就是业务线程
    executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), 60, TimeUnit.SECONDS,taskqueue, tf);
    taskqueue.setParent( (ThreadPoolExecutor) executor);
}

initializeConnectionLatch

1
2
3
4
5
6
7
protected LimitLatch initializeConnectionLatch() {
    if (maxConnections==-1) return null;
    if (connectionLimitLatch==null) {
        connectionLimitLatch = new LimitLatch(getMaxConnections());
    }
    return connectionLimitLatch;
}

Poller

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class Poller implements Runnable {
 private Selector selector;
      private final SynchronizedQueue<PollerEvent> events =
              new SynchronizedQueue<>();

      private volatile boolean close = false;
      private long nextExpiration = 0;//optimize expiration handling

      private AtomicLong wakeupCounter = new AtomicLong(0);

      private volatile int keyCount = 0;   

    //poller的selector是新的
         public Poller() throws IOException {
          this.selector = Selector.open();
      }

}
run
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
@Override
      public void run() {
          // Loop until destroy() is called
          while (true) {

              boolean hasEvents = false;

              try {
                  if (!close) {
                      //取出所有事件并执行
                      hasEvents = events();
                      if (wakeupCounter.getAndSet(-1) > 0) {
                          //if we are here, means we have other stuff to do
                          //do a non blocking select
                          keyCount = selector.selectNow();
                      } else {
                          keyCount = selector.select(selectorTimeout);
                      }
                      wakeupCounter.set(0);
                  }
                  if (close) {
                      events();
                      timeout(0, false);
                      try {
                          selector.close();
                      } catch (IOException ioe) {
                          log.error(sm.getString("endpoint.nio.selectorCloseFail"), ioe);
                      }
                      break;
                  }
              } catch (Throwable x) {
                  ExceptionUtils.handleThrowable(x);
                  log.error("",x);
                  continue;
              }
              //either we timed out or we woke up, process events first
              if ( keyCount == 0 ) hasEvents = (hasEvents | events());

              Iterator<SelectionKey> iterator =
                  keyCount > 0 ? selector.selectedKeys().iterator() : null;
              // Walk through the collection of ready keys and dispatch
              // any active event.
              while (iterator != null && iterator.hasNext()) {
                  SelectionKey sk = iterator.next();
                  NioSocketWrapper attachment = (NioSocketWrapper)sk.attachment();
                  // Attachment may be null if another thread has called
                  // cancelledKey()
                  if (attachment == null) {
                      iterator.remove();
                  } else {
                      iterator.remove();
                      processKey(sk, attachment);
                  }
              }//while

              //process timeouts
              timeout(keyCount,hasEvents);
          }//while

          getStopLatch().countDown();
      }
processKey
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
protected void processKey(SelectionKey sk, NioSocketWrapper attachment) {
            try {
                if ( close ) {
                    cancelledKey(sk);
                } else if ( sk.isValid() && attachment != null ) {
                    if (sk.isReadable() || sk.isWritable() ) {
                        if ( attachment.getSendfileData() != null ) {
                            processSendfile(sk,attachment, false);
                        } else {
                            unreg(sk, attachment, sk.readyOps());
                            boolean closeSocket = false;
                            // Read goes before write
                            if (sk.isReadable()) {
                                //交给业务线程处理
                                if (!processSocket(attachment, SocketEvent.OPEN_READ, true)) {
                                    closeSocket = true;
                                }
                            }
                            if (!closeSocket && sk.isWritable()) {
                                if (!processSocket(attachment, SocketEvent.OPEN_WRITE, true)) {
                                    closeSocket = true;
                                }
                            }
                            if (closeSocket) {
                                cancelledKey(sk);
                            }
                        }
                    }
                } else {
                    //invalid key
                    cancelledKey(sk);
                }
            } catch ( CancelledKeyException ckx ) {
                cancelledKey(sk);
            } catch (Throwable t) {
                ExceptionUtils.handleThrowable(t);
                log.error("",t);
            }
        }

startAcceptorThreads

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    protected final void startAcceptorThreads() {
        int count = getAcceptorThreadCount();
        acceptors = new Acceptor[count];

        for (int i = 0; i < count; i++) {
            acceptors[i] = createAcceptor();
            String threadName = getName() + "-Acceptor-" + i;
            acceptors[i].setThreadName(threadName);
            Thread t = new Thread(acceptors[i], threadName);
            t.setPriority(getAcceptorThreadPriority());
            t.setDaemon(getDaemon());
            t.start();
        }
    }

NioEndpoint
   @Override
    protected AbstractEndpoint.Acceptor createAcceptor() {
        return new Acceptor();
    }
Acceptor
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
protected class Acceptor extends AbstractEndpoint.Acceptor {

       @Override
       public void run() {

           int errorDelay = 0;

           // Loop until we receive a shutdown command
           while (running) {

               // Loop if endpoint is paused
               while (paused && running) {
                   state = AcceptorState.PAUSED;
                   try {
                       Thread.sleep(50);
                   } catch (InterruptedException e) {
                       // Ignore
                   }
               }

               if (!running) {
                   break;
               }
               state = AcceptorState.RUNNING;

               try {
                   //if we have reached max connections, wait
                   countUpOrAwaitConnection();

                   SocketChannel socket = null;
                   try {
                       // Accept the next incoming connection from the server
                       // socket
                       socket = serverSock.accept();
                   } catch (IOException ioe) {
                       // We didn't get a socket
                       countDownConnection();
                       if (running) {
                           // Introduce delay if necessary
                           errorDelay = handleExceptionWithDelay(errorDelay);
                           // re-throw
                           throw ioe;
                       } else {
                           break;
                       }
                   }
                   // Successful accept, reset the error delay
                   errorDelay = 0;

                   // Configure the socket
                   if (running && !paused) {
                       // setSocketOptions() will hand the socket off to
                       // an appropriate processor if successful
                       if (!setSocketOptions(socket)) {
                           closeSocket(socket);
                       }
                   } else {
                       closeSocket(socket);
                   }
               } catch (Throwable t) {
                   ExceptionUtils.handleThrowable(t);
                   log.error(sm.getString("endpoint.accept.fail"), t);
               }
           }
           state = AcceptorState.ENDED;
       }
setSocketOptions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
protected boolean setSocketOptions(SocketChannel socket) {
      // Process the connection
      try {
          //disable blocking, APR style, we are gonna be polling it
          socket.configureBlocking(false);
          Socket sock = socket.socket();
          //给socket设置参数
          socketProperties.setProperties(sock);

          NioChannel channel = nioChannels.pop();
          if (channel == null) {
              SocketBufferHandler bufhandler = new SocketBufferHandler(
                      socketProperties.getAppReadBufSize(),
                      socketProperties.getAppWriteBufSize(),
                      socketProperties.getDirectBuffer());
              if (isSSLEnabled()) {
                  channel = new SecureNioChannel(socket, bufhandler, selectorPool, this);
              } else {
                  channel = new NioChannel(socket, bufhandler);
              }
          } else {
              channel.setIOChannel(socket);
              channel.reset();
          }
          getPoller0().register(channel);
      } catch (Throwable t) {
          ExceptionUtils.handleThrowable(t);
          try {
              log.error("",t);
          } catch (Throwable tt) {
              ExceptionUtils.handleThrowable(tt);
          }
          // Tell to close the socket
          return false;
      }
      return true;
  }
Poller注册
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public void register(final NioChannel socket) {
           socket.setPoller(this);
           NioSocketWrapper ka = new NioSocketWrapper(socket, NioEndpoint.this);
           socket.setSocketWrapper(ka);
           ka.setPoller(this);
           ka.setReadTimeout(getSocketProperties().getSoTimeout());
           ka.setWriteTimeout(getSocketProperties().getSoTimeout());
           ka.setKeepAliveLeft(NioEndpoint.this.getMaxKeepAliveRequests());
           ka.setReadTimeout(getConnectionTimeout());
           ka.setWriteTimeout(getConnectionTimeout());
           PollerEvent r = eventCache.pop();
           ka.interestOps(SelectionKey.OP_READ);//this is what OP_REGISTER turns into.
           if ( r==null) r = new PollerEvent(socket,ka,OP_REGISTER);
           else r.reset(socket,ka,OP_REGISTER);
           addEvent(r);
       }
PollerEvent
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public static class PollerEvent implements Runnable {

      private NioChannel socket;
      private int interestOps;
      private NioSocketWrapper socketWrapper;

      public PollerEvent(NioChannel ch, NioSocketWrapper w, int intOps) {
          reset(ch, w, intOps);
      }

      public void reset(NioChannel ch, NioSocketWrapper w, int intOps) {
          socket = ch;
          interestOps = intOps;
          socketWrapper = w;
      }

      public void reset() {
          reset(null, null, 0);
      }

      @Override
      public void run() {
          if (interestOps == OP_REGISTER) {
              try {
                  socket.getIOChannel().register(
                          socket.getPoller().getSelector(), SelectionKey.OP_READ, socketWrapper);
              } catch (Exception x) {
                  log.error(sm.getString("endpoint.nio.registerFail"), x);
              }
          } else {
              final SelectionKey key = socket.getIOChannel().keyFor(socket.getPoller().getSelector());
              try {
                  if (key == null) {
                      // The key was cancelled (e.g. due to socket closure)
                      // and removed from the selector while it was being
                      // processed. Count down the connections at this point
                      // since it won't have been counted down when the socket
                      // closed.
                      socket.socketWrapper.getEndpoint().countDownConnection();
                      ((NioSocketWrapper) socket.socketWrapper).closed = true;
                  } else {
                      final NioSocketWrapper socketWrapper = (NioSocketWrapper) key.attachment();
                      if (socketWrapper != null) {
                          //we are registering the key to start with, reset the fairness counter.
                          int ops = key.interestOps() | interestOps;
                          socketWrapper.interestOps(ops);
                          key.interestOps(ops);
                      } else {
                          socket.getPoller().cancelledKey(key);
                      }
                  }
              } catch (CancelledKeyException ckx) {
                  try {
                      socket.getPoller().cancelledKey(key);
                  } catch (Exception ignore) {}
              }
          }
      }

      @Override
      public String toString() {
          return "Poller event: socket [" + socket + "], socketWrapper [" + socketWrapper +
                  "], interestOps [" + interestOps + "]";
      }
  }

展开全文 >>

framework/Netty/Netty编码器

Netty编码器解码器

这里以Http协议来阅读

ByteToMessageDecoder

：这是netty提供的一个解码器的抽象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

public abstract class ByteToMessageDecoder extends ChannelInboundHandlerAdapter {
 //发现是一个入站处理器，那么就可以获取到读事件
    
    
    // 有数据进来肯定要走这里
     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof ByteBuf) {
            // 只对消息为ByteBuf的消息进行编码
            
            //获取一个编码输出集合
            CodecOutputList out = CodecOutputList.newInstance();
            try {
                //这里获取一个累加器，就是累加byteBuf
                first = cumulation == null;
                cumulation = cumulator.cumulate(ctx.alloc(),
                        first ? Unpooled.EMPTY_BUFFER : cumulation, (ByteBuf) msg);
                callDecode(ctx, cumulation, out);
            } catch (DecoderException e) {
                throw e;
            } catch (Exception e) {
                throw new DecoderException(e);
            } finally {
                try {
                    if (cumulation != null && !cumulation.isReadable()) {
                        numReads = 0;
                        cumulation.release();
                        cumulation = null;
                    } else if (++numReads >= discardAfterReads) {
                        // We did enough reads already try to discard some bytes so we not risk to see a OOME.
                        // See https://github.com/netty/netty/issues/4275
                        numReads = 0;
                        discardSomeReadBytes();
                    }

                    int size = out.size();
                    firedChannelRead |= out.insertSinceRecycled();
                    fireChannelRead(ctx, out, size);
                } finally {
                    out.recycle();
                }
            }
        } else {
            ctx.fireChannelRead(msg);
        }
    }

    
}

callDecode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
       try {
           while (in.isReadable()) {
               //是否有可读的
               
               //如果out里面有内容，那么就直接发射读事件
               int outSize = out.size();

               if (outSize > 0) {
                   fireChannelRead(ctx, out, outSize);
                   out.clear();

                   // Check if this handler was removed before continuing with decoding.
                   // If it was removed, it is not safe to continue to operate on the buffer.
                   //
                   // See:
                   // - https://github.com/netty/netty/issues/4635
                   if (ctx.isRemoved()) {
                       break;
                   }
                   outSize = 0;
               }
			// 获取可读长度
               int oldInputLength = in.readableBytes();
               decodeRemovalReentryProtection(ctx, in, out);

               // Check if this handler was removed before continuing the loop.
               // If it was removed, it is not safe to continue to operate on the buffer.
               if (ctx.isRemoved()) {
                   break;
               }

               if (outSize == out.size()) {
                   if (oldInputLength == in.readableBytes()) {
                       break;
                   } else {
                       continue;
                   }
               }

               if (oldInputLength == in.readableBytes()) {
                   throw new DecoderException(
                           StringUtil.simpleClassName(getClass()) +
                                   ".decode() did not read anything but decoded a message.");
               }

               if (isSingleDecode()) {
                   break;
               }
           }
       } catch (DecoderException e) {
           throw e;
       } catch (Exception cause) {
           throw new DecoderException(cause);
       }
   }


  final void decodeRemovalReentryProtection(ChannelHandlerContext ctx, ByteBuf in, List<Object> out)
           throws Exception {
       decodeState = STATE_CALLING_CHILD_DECODE;
       try {
           decode(ctx, in, out); //模板方法，子类实现
       } finally {
           boolean removePending = decodeState == STATE_HANDLER_REMOVED_PENDING;
           decodeState = STATE_INIT;
           if (removePending) {
               fireChannelRead(ctx, out, out.size());
               out.clear();
               handlerRemoved(ctx);
           }
       }
   }

HttpRequestDecoder

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202

 @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf buffer, List<Object> out) throws Exception {
        if (resetRequested) {
            resetNow();
        }
状态机
        switch (currentState) {
        case SKIP_CONTROL_CHARS:
            // Fall-through
        case READ_INITIAL: try {
            AppendableCharSequence line = lineParser.parse(buffer);
            if (line == null) {
                return;
            }
            String[] initialLine = splitInitialLine(line);
            if (initialLine.length < 3) {
                // Invalid initial line - ignore.
                currentState = State.SKIP_CONTROL_CHARS;
                return;
            }

            message = createMessage(initialLine);
            currentState = State.READ_HEADER;
            // fall-through
        } catch (Exception e) {
            out.add(invalidMessage(buffer, e));
            return;
        }
        case READ_HEADER: try {
            State nextState = readHeaders(buffer);
            if (nextState == null) {
                return;
            }
            currentState = nextState;
            switch (nextState) {
            case SKIP_CONTROL_CHARS:
                // fast-path
                // No content is expected.
                out.add(message);
                out.add(LastHttpContent.EMPTY_LAST_CONTENT);
                resetNow();
                return;
            case READ_CHUNK_SIZE:
                if (!chunkedSupported) {
                    throw new IllegalArgumentException("Chunked messages not supported");
                }
                // Chunked encoding - generate HttpMessage first.  HttpChunks will follow.
                out.add(message);
                return;
            default:
                /**
                 * <a href="https://tools.ietf.org/html/rfc7230#section-3.3.3">RFC 7230, 3.3.3</a> states that if a
                 * request does not have either a transfer-encoding or a content-length header then the message body
                 * length is 0. However for a response the body length is the number of octets received prior to the
                 * server closing the connection. So we treat this as variable length chunked encoding.
                 */
                long contentLength = contentLength();
                if (contentLength == 0 || contentLength == -1 && isDecodingRequest()) {
                    out.add(message);
                    out.add(LastHttpContent.EMPTY_LAST_CONTENT);
                    resetNow();
                    return;
                }

                assert nextState == State.READ_FIXED_LENGTH_CONTENT ||
                        nextState == State.READ_VARIABLE_LENGTH_CONTENT;

                out.add(message);

                if (nextState == State.READ_FIXED_LENGTH_CONTENT) {
                    // chunkSize will be decreased as the READ_FIXED_LENGTH_CONTENT state reads data chunk by chunk.
                    chunkSize = contentLength;
                }

                // We return here, this forces decode to be called again where we will decode the content
                return;
            }
        } catch (Exception e) {
            out.add(invalidMessage(buffer, e));
            return;
        }
        case READ_VARIABLE_LENGTH_CONTENT: {
            // Keep reading data as a chunk until the end of connection is reached.
            int toRead = Math.min(buffer.readableBytes(), maxChunkSize);
            if (toRead > 0) {
                ByteBuf content = buffer.readRetainedSlice(toRead);
                out.add(new DefaultHttpContent(content));
            }
            return;
        }
        case READ_FIXED_LENGTH_CONTENT: {
            int readLimit = buffer.readableBytes();

            // Check if the buffer is readable first as we use the readable byte count
            // to create the HttpChunk. This is needed as otherwise we may end up with
            // create an HttpChunk instance that contains an empty buffer and so is
            // handled like it is the last HttpChunk.
            //
            // See https://github.com/netty/netty/issues/433
            if (readLimit == 0) {
                return;
            }

            int toRead = Math.min(readLimit, maxChunkSize);
            if (toRead > chunkSize) {
                toRead = (int) chunkSize;
            }
            ByteBuf content = buffer.readRetainedSlice(toRead);
            chunkSize -= toRead;

            if (chunkSize == 0) {
                // Read all content.
                out.add(new DefaultLastHttpContent(content, validateHeaders));
                resetNow();
            } else {
                out.add(new DefaultHttpContent(content));
            }
            return;
        }
        /**
         * everything else after this point takes care of reading chunked content. basically, read chunk size,
         * read chunk, read and ignore the CRLF and repeat until 0
         */
        case READ_CHUNK_SIZE: try {
            AppendableCharSequence line = lineParser.parse(buffer);
            if (line == null) {
                return;
            }
            int chunkSize = getChunkSize(line.toString());
            this.chunkSize = chunkSize;
            if (chunkSize == 0) {
                currentState = State.READ_CHUNK_FOOTER;
                return;
            }
            currentState = State.READ_CHUNKED_CONTENT;
            // fall-through
        } catch (Exception e) {
            out.add(invalidChunk(buffer, e));
            return;
        }
        case READ_CHUNKED_CONTENT: {
            assert chunkSize <= Integer.MAX_VALUE;
            int toRead = Math.min((int) chunkSize, maxChunkSize);
            toRead = Math.min(toRead, buffer.readableBytes());
            if (toRead == 0) {
                return;
            }
            HttpContent chunk = new DefaultHttpContent(buffer.readRetainedSlice(toRead));
            chunkSize -= toRead;

            out.add(chunk);

            if (chunkSize != 0) {
                return;
            }
            currentState = State.READ_CHUNK_DELIMITER;
            // fall-through
        }
        case READ_CHUNK_DELIMITER: {
            final int wIdx = buffer.writerIndex();
            int rIdx = buffer.readerIndex();
            while (wIdx > rIdx) {
                byte next = buffer.getByte(rIdx++);
                if (next == HttpConstants.LF) {
                    currentState = State.READ_CHUNK_SIZE;
                    break;
                }
            }
            buffer.readerIndex(rIdx);
            return;
        }
        case READ_CHUNK_FOOTER: try {
            LastHttpContent trailer = readTrailingHeaders(buffer);
            if (trailer == null) {
                return;
            }
            out.add(trailer);
            resetNow();
            return;
        } catch (Exception e) {
            out.add(invalidChunk(buffer, e));
            return;
        }
        case BAD_MESSAGE: {
            // Keep discarding until disconnection.
            buffer.skipBytes(buffer.readableBytes());
            break;
        }
        case UPGRADED: {
            int readableBytes = buffer.readableBytes();
            if (readableBytes > 0) {
                // Keep on consuming as otherwise we may trigger an DecoderException,
                // other handler will replace this codec with the upgraded protocol codec to
                // take the traffic over at some point then.
                // See https://github.com/netty/netty/issues/2173
                out.add(buffer.readBytes(readableBytes));
            }
            break;
        }
        }
    }

HttpServerCodec

展开全文 >>

理财/理财入门

理财

理财只是为了让你的钱用到具体的某个地方，不要乱用，不要想着这个能赚大钱

投资理财几条知识

投资理财的元规则是用自己用不到的钱来投资：务必要使用自己用不到的钱（这些钱丢了不会造成对生活的实质性影响，只是心疼，如果这些钱用来买房，结婚，孩子上学有明确的指向性用途，那么绝对不能用来投资）

投资理财的核心三原则，安全性—>流动性—>盈利性

安全性，钱不能交给没有法律保障的地方

流动性，资产变现的能力

盈利性，不要看的太重

投资要风险分摊，不要纠结于单一标的(底)，把资金分散到不同的投资标的，是控制风险的有效手段 （一部分放在银行理财，一部分放在银行存款，一部分放在基金，千万不要把钱分散放在同一领域，例如：一部分团贷，一部分e租宝，都是p2p领域，这不叫风险分摊）

不要投资看不懂的东西：懂了就是 明确直到产品是怎么运作的，知道是怎么赚钱的，知道是怎么赔钱的

投资就投资，不要加杠杆：什么交杠杆，把信用卡透支出来的钱来炒股（就是1块钱 你能赚10快。那么1000 你就能赚一万，注意这一千可能会打水漂，不是百分百收益的，自己要根据上面几点，特别是第一点来看待具体用多少） 能够承受住意外的 阈值

不要盲目相信高回报率的东西：还是要搞懂它怎么盈利的，还要想自己凭什么拿这么高的收益

也不要学专业人士的操作：不要轻易去学

没有人是靠投资理财致富的

不犯错比激进更重要

克制贪欲，控制风险，分散投资标的，然后就是慢慢的试错（找到让自己舒适的平衡点）

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发
开源爱好者、Linux

联系QQ:2960571342

很惭愧

只做了一点微小的工作
谢谢大家