对以上的StandardWrapperValve#invoke进行说解
- if (!unavailable) {
- //servlet行行在这一步
- servlet = wrapper.allocate();
- }
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) {
synchronized (this) {
//在实例为空时才创建
if (instance == null) {
try {
if (log.isDebugEnabled())
log.debug("Allocating non-STM instance");
//创建实例
instance = loadServlet();
// For non-STM, increment here to prevent a race
// condition with unload. Bug 43683, test case #3
if (!singleThreadModel) {
newInstance = true;
//
countAllocated.incrementAndGet();
}
} catch (ServletException e) {
throw e;
} catch (Throwable e) {
throw new ServletException
(sm.getString("standardWrapper.allocate"), e);
}
}
}
}
if (!singleThreadModel) {
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);
}
}
//每一次都返回一个实例存放在instancePool中
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) {
throw new ServletException
(sm.getString("standardWrapper.allocate"), e);
}
} else {
try {
instancePool.wait();
} catch (InterruptedException e) {
;
}
}
}
if (log.isTraceEnabled())
log.trace(" Returning allocated STM instance");
countAllocated.incrementAndGet();
return (Servlet) instancePool.pop();
}
}
以上这一步在我们平时使用时会经常遇到,,servlet的创建是一个多线程单实例的,所以共享全局变量,所以在使用servlet
时应尽量避免定义全局变量
对#loadServlet进行详解
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();
// If this "servlet" is really a JSP file, get the right class.
// HOLD YOUR NOSE - this is a kludge that avoids having to do special
// case Catalina-specific code in Jasper - it also requires that the
// servlet path be replaced by the <jsp-file> element content in
// order to be completely effective
//所访问的servlet的类路径名
String actualClass = servletClass;
if ((actualClass == null) && (jspFile != null)) {
Wrapper jspWrapper = (Wrapper)
((Context) getParent()).findChild(Constants.JSP_SERVLET_NAME);
if (jspWrapper != null) {
actualClass = jspWrapper.getServletClass();
// Merge init parameters
String paramNames[] = jspWrapper.findInitParameters();
for (int i = 0; i < paramNames.length; i++) {
if (parameters.get(paramNames[i]) == null) {
parameters.put
(paramNames[i],
jspWrapper.findInitParameter(paramNames[i]));
}
}
}
}
// Complain if no servlet class has been specified
if (actualClass == null) {
unavailable(null);
throw new ServletException
(sm.getString("standardWrapper.notClass", getName()));
}
// Acquire an instance of the class loader to be used
Loader loader = getLoader();
if (loader == null) {
unavailable(null);
throw new ServletException
(sm.getString("standardWrapper.missingLoader", getName()));
}
//获取werbappclassloader
ClassLoader classLoader = loader.getClassLoader();
// Special case class loader for a container provided servlet
//
if (isContainerProvidedServlet(actualClass) &&
! ((Context)getParent()).getPrivileged() ) {
// If it is a priviledged context - using its own
// class loader will work, since it's a child of the container
// loader
classLoader = this.getClass().getClassLoader();
}
// Load the specified servlet class from the appropriate class loader
Class classClass = null;
try {
if (SecurityUtil.isPackageProtectionEnabled()){
final ClassLoader fclassLoader = classLoader;
final String factualClass = actualClass;
try{
classClass = (Class)AccessController.doPrivileged(
new PrivilegedExceptionAction(){
public Object run() throws Exception{
if (fclassLoader != null) {
//进行类加载
return fclassLoader.loadClass(factualClass);
} else {
return Class.forName(factualClass);
}
}
});
} catch(PrivilegedActionException pax){
Exception ex = pax.getException();
if (ex instanceof ClassNotFoundException){
throw (ClassNotFoundException)ex;
} else {
getServletContext().log( "Error loading "
+ fclassLoader + " " + factualClass, ex );
}
}
} else {
if (classLoader != null) {
classClass = classLoader.loadClass(actualClass);
} else {
classClass = Class.forName(actualClass);
}
}
} catch (ClassNotFoundException e) {
unavailable(null);
getServletContext().log( "Error loading " + classLoader + " " + actualClass, e );
throw new ServletException
(sm.getString("standardWrapper.missingClass", actualClass),
e);
}
if (classClass == null) {
unavailable(null);
throw new ServletException
(sm.getString("standardWrapper.missingClass", actualClass));
}
// Instantiate and initialize an instance of the servlet class itself
try {
servlet = (Servlet) classClass.newInstance();
// Annotation processing
if (!((Context) getParent()).getIgnoreAnnotations()) {
if (getParent() instanceof StandardContext) {
((StandardContext)getParent()).getAnnotationProcessor().processAnnotations(servlet);
((StandardContext)getParent()).getAnnotationProcessor().postConstruct(servlet);
}
}
} catch (ClassCastException e) {
unavailable(null);
// Restore the context ClassLoader
throw new ServletException
(sm.getString("standardWrapper.notServlet", actualClass), e);
} catch (Throwable e) {
unavailable(null);
// Added extra log statement for Bugzilla 36630:
// http://issues.apache.org/bugzilla/show_bug.cgi?id=36630
if(log.isDebugEnabled()) {
log.debug(sm.getString("standardWrapper.instantiate", actualClass), e);
}
// Restore the context ClassLoader
throw new ServletException
(sm.getString("standardWrapper.instantiate", actualClass), e);
}
// Check if loading the servlet in this web application should be
// allowed
if (!isServletAllowed(servlet)) {
throw new SecurityException
(sm.getString("standardWrapper.privilegedServlet",
actualClass));
}
// Special handling for ContainerServlet instances
if ((servlet instanceof ContainerServlet) &&
(isContainerProvidedServlet(actualClass) ||
((Context)getParent()).getPrivileged() )) {
((ContainerServlet) servlet).setWrapper(this);
}
classLoadTime=(int) (System.currentTimeMillis() -t1);
// Call the initialization method of this servlet
//该Servlet的初始化,只实现一次
try {
instanceSupport.fireInstanceEvent(InstanceEvent.BEFORE_INIT_EVENT,
servlet);
if( Globals.IS_SECURITY_ENABLED) {
Object[] args = new Object[]{((ServletConfig)facade)};
SecurityUtil.doAsPrivilege("init",
servlet,
classType,
args);
args = null;
} else {
servlet.init(facade);
}
// Invoke jspInit on JSP pages
//jsp转换成servlet的初始化
if ((loadOnStartup >= 0) && (jspFile != null)) {
// Invoking jspInit
DummyRequest req = new DummyRequest();
req.setServletPath(jspFile);
req.setQueryString(Constants.PRECOMPILE + "=true");
DummyResponse res = new DummyResponse();
if( Globals.IS_SECURITY_ENABLED) {
Object[] args = new Object[]{req, res};
SecurityUtil.doAsPrivilege("service",
servlet,
classTypeUsedInService,
args);
args = null;
} else {
servlet.service(req, res);
}
}
instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
servlet);
} catch (UnavailableException f) {
instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
servlet, f);
unavailable(f);
throw f;
} catch (ServletException f) {
instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
servlet, f);
// If the servlet wanted to be unavailable it would have
// said so, so do not call unavailable(null).
throw f;
} catch (Throwable f) {
getServletContext().log("StandardWrapper.Throwable", f );
instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
servlet, f);
// If the servlet wanted to be unavailable it would have
// said so, so do not call unavailable(null).
throw new ServletException
(sm.getString("standardWrapper.initException", getName()), f);
}
// Register our newly initialized instance
singleThreadModel = servlet instanceof SingleThreadModel;
if (singleThreadModel) {
if (instancePool == null)
instancePool = new Stack();
}
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;
}
从以上步骤可得到该servlet的实例,并用已经初始化过
现在对StandardWrapperValve#invoke
- //这里面开始对过滤器进行处理
- filterChain.doFilter(request.getRequest(),
- response.getResponse());
这里面对过滤器进行了执行ApplicationFilterChain#doFilter
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() {
public Object 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(rquest,response)
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++];
Filter filter = null;
try {
//获取过滤器
filter = filterConfig.getFilter();
support.fireInstanceEvent(InstanceEvent.BEFORE_FILTER_EVENT,
filter, request, response);
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);
args = null;
} else {
//进行过滤
filter.doFilter(request, response, this);
}
support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT,
filter, request, response);
} catch (IOException e) {
if (filter != null)
support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT,
filter, request, response, e);
throw e;
} catch (ServletException e) {
if (filter != null)
support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT,
filter, request, response, e);
throw e;
} catch (RuntimeException e) {
if (filter != null)
support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT,
filter, request, response, e);
throw e;
} catch (Throwable e) {
if (filter != null)
support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT,
filter, request, response, e);
throw new ServletException
(sm.getString("filterChain.filter"), e);
}
return;
}
// We fell off the end of the chain -- call the servlet instance
try {
if (Globals.STRICT_SERVLET_COMPLIANCE) {
lastServicedRequest.set(request);
lastServicedResponse.set(response);
}
support.fireInstanceEvent(InstanceEvent.BEFORE_SERVICE_EVENT,
servlet, request, response);
if ((request instanceof HttpServletRequest) &&
(response instanceof HttpServletResponse)) {
if( 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);
args = null;
} else {
servlet.service((HttpServletRequest) request,
(HttpServletResponse) response);
}
} else {
//有过滤器,先过滤再执行servlet的service的方法
servlet.service(request, response);
}
support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT,
servlet, request, response);
} catch (IOException e) {
support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT,
servlet, request, response, e);
throw e;
} catch (ServletException e) {
support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT,
servlet, request, response, e);
throw e;
} catch (RuntimeException e) {
support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT,
servlet, request, response, e);
throw e;
} catch (Throwable e) {
support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT,
servlet, request, response, e);
throw new ServletException
(sm.getString("filterChain.servlet"), e);
} finally {
if (Globals.STRICT_SERVLET_COMPLIANCE) {
lastServicedRequest.set(null);
lastServicedResponse.set(null);
}
}
}
这样的过滤器已经执行,servlet也已经执行....接下来做些释放工程
相关推荐
9. **错误处理与日志系统**：Tomcat使用自定义的日志框架，源码中`logging`目录下的类定义了如何记录和处理错误信息。 10. **网络编程**：Tomcat底层使用NIO（非阻塞I/O）和BIO（阻塞I/O）模型，这在`java/org/...
3-5Tomcat响应请求源码与nio处理请求源码实现.mp4
通过对`apache-tomcat-9.0.8-src`源码的深入研究，我们可以了解到Tomcat如何处理网络请求，怎样管理Web应用，以及如何实现各种高级特性。这对于开发者来说是一份宝贵的学习资料，可以帮助他们更好地优化应用程序，...
`mod_jk`负责在HTTPD服务器端接收请求，然后将这些请求转发到Tomcat，而`jk`则在Tomcat端处理这些请求，并返回响应给`mod_jk`，再由`mod_jk`转发给客户端。 2. **版本兼容性** `tomcat-connectors-1.2.48-src`特别...
2. **HTTP链接**：Tomcat作为HTTP服务器，处理HTTP请求和响应。它通过解析HTTP协议来与客户端进行通信。lib目录下的httpcore.jar和httpclient.jar包含Apache HttpClient库，提供了高效的HTTP协议处理能力，使得...
这个压缩包包含了两个版本的Tomcat源码：apache-tomcat-7.0.62-src和apache-tomcat-6.0.39-src，这两个版本分别代表了Tomcat在不同时间点的开发状态和技术特性。 首先，让我们从Apache Tomcat 6.0.39源码开始分析。...
2. ** Coyote**：负责处理HTTP请求和响应。Coyote是Tomcat的网络连接器，它包含一个或多个处理器，如`Http11Processor`，这些处理器处理HTTP协议细节。`org.apache.coyote`包下的类与网络通信密切相关。 3. ** ...
深入研究Tomcat源码有助于开发者理解Web应用服务器的内部运作机制，提升系统设计和优化能力，同时也有助于自定义扩展和调试，实现更高效、安全的Web服务。 总之，从Tomcat 6.0到9.0，每个版本都带来了技术的进步和...
通过分析源码，开发者可以学习到如何遵循Servlet和JSP规范进行服务器端开发，理解Tomcat如何处理请求、管理会话、调度线程等。此外，源码还便于开发者修复已知问题，优化性能，或添加特定的功能。 总之，`tomcat6-...
7. **线程池**：Tomcat使用线程池模型处理并发请求，提高性能和响应速度。线程池大小可以在`server.xml`中调整。 8. **安全管理**：Tomcat支持角色基础的访问控制（RBAC），可以设置不同用户的访问权限，通过`...
在源码分析中，开发者可以深入了解Tomcat如何处理请求、响应，以及它如何管理Web应用程序的生命周期。此外，对于性能优化、自定义行为或解决特定问题，源码阅读也是非常有价值的。 7.0.59和7.0.69之间的差异可能...
对于初次接触Tomcat源码的开发者，可以从阅读`src/main/java`目录下的源码开始，重点关注`org.apache.catalina`包下的类，以及`org.apache.coyote`和`org.apache.jasper`等包。同时，`conf/server.xml`是配置整个...
Eclipse是一个广泛使用的Java集成开发环境（IDE），它支持直接导入和管理Tomcat源码。在Eclipse中，开发者可以通过导入“Existing Projects into Workspace”来加载Tomcat源码。然后，可以利用Eclipse的强大功能，如...
源码解析部分则是对Tomcat源码的深度剖析，涵盖了关键类和方法的作用、设计模式的运用以及性能优化技巧。这有助于开发者理解Tomcat内部的工作流程，例如，如何处理HTTP请求的生命周期，以及线程池是如何调度和管理的...
Tomcat作为Servlet和JSP容器，负责处理HTTP请求，解析请求到相应的Servlet或JSP页面，执行其中的Java代码，并将结果返回给客户端。 Apache Tomcat 6.0.37 版本是在2013年发布的一个稳定版本，支持Java EE 5规范。这...
通过研究Tomcat源码，开发者可以了解到HTTP请求的处理流程、Servlet容器的工作方式、以及如何高效地管理Web应用。此外，了解Tomcat源码还可以帮助开发者借鉴其设计模式和架构，以便在日常开发中构建更稳定、高效的...
《深入理解Tomcat源码与Servlet-API》 Tomcat，作为Apache软件基金会的顶级项目，是Java Servlet和JavaServer Pages（JSP）的开源Web应用服务器，被广泛应用于中小型企业的Web服务部署。7.0.59版本是Tomcat的一个...
在Tomcat中，Servlet用于处理HTTP请求并返回响应。 - **JSP**：JavaServer Pages是Java平台上的动态网页技术，允许开发者将HTML代码与Java代码混合编写，以实现动态内容的生成。 2. **Tomcat的结构**： - **conf*...
Apache Tomcat源码分析 Apache Tomcat是一款广泛应用的开源Java Servlet容器，它是Java EE Web应用程序的标准实现。Tomcat源码的深入理解对于Java Web开发者来说是至关重要的，它可以帮助我们了解HTTP服务器的工作...
7. **Eclipse集成**：在Eclipse中导入Tomcat源码，可以方便地进行调试、代码分析和自定义修改。这需要配置Tomcat插件，设置源代码路径，以及正确配置项目的构建路径。 8. **部署与调试**：在Eclipse中如何部署Web...