Servlet3.0新特性——异步处理

Dear 丶 2021-06-22 15:37 451阅读 0赞

# 异步处理 #

## 一、Servlet3.0 新特性 概述 ##

Servlet3.0的主要新特性如下三部分：

*  使用`@WebServlet`、`@WebFilter`、`@WebListener`三个注解来替代web.xml文件中的Servlet、Filter、Listener的配置；
 *  Servlet异步处理：当Servlet处理比较费时的问题时，这会让客户感觉到很卡。当使用异常处理时可以把已经处理好的内容先一步响应给客户端浏览器，然后使用另一个线程来完成费时的操作，也就是把内容一部分一部分的显示出来；
 *  上传组件：不用再使用fileupload等第三方的上传组件，使用Servlet3.0的上传组件会更方便。

**这篇文章我们介绍一下异步处理的新特性。**

## 二、异步请求 ##

在此之前，我们先做一个实验。  
我们在servlet中写这么一段代码：

public class AServlet extends HttpServlet { 
    	@Override
    	protected void doGet(HttpServletRequest req,
    			HttpServletResponse resp) throws ServletException,
    			IOException { 
    		resp.getWriter().print("hello------11111");
    		try { 
    			Thread.sleep(3000);
    		} catch (InterruptedException e) { 
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		resp.getWriter().print("hello-----22222");
    	}
    }

我们在servlet中，让线程休眠3秒中，我们在浏览器中请求这个servlet，会明显的感觉到卡顿，这是因为，在服务器没有结束响应之前，浏览器是看不到响应内容的。只有响应结束时，浏览器才能显示结果。在应用场景中也是这样，如果我们处理的逻辑非常复杂，需要的时间比较长，那就会让浏览器卡住，给用户带来很不好的使用体验。这个时候怎么办呢？  
这就需要我们的异步处理方式，**Servlet异步处理就是让Servlet在处理费时的请求时不要阻塞，而是一部分一部分的显示。** 也就是说，在使用Servlet异步处理之后，页面可以一部分一部分的显示数据，而不是一直卡顿直到请求响应结束后一起显示。

那我们怎么样做到，让它先响应一部分，再响应另一部分呢，也就是异步处理？

1.  首先我们要给我们的Servlet添加一个注解，让我们的Servlet支持异步处理。  
    添加`asyncSupported`属性，值为`true`。  
    形成的代码如下：
    
        @WebServlet(urlPatterns = "/AServlet", asyncSupported = true)
        public class AServlet extends HttpServlet { 
        	...
        	...
        }
2.  然后，我们要先**得到一个异步上下文对象**。
    
        /* * 1. 得到异步上下文对象 */
        AsyncContext ac = request.startAsync(request, response);
3.  我们再**给上下文对象一个Runnable对象**，让它执行这个任务。
    
        /* * 2. 给上下文一个Runnable对象，让它执行任务。 */
        ac.start(new Runnable() { 
        	public void run() { 
        		/**************/
        		// 这里面添加代码
        		/**************/
        	}
        });
4.  我们在执行的代码中，添加以下的语句，注意输出万一部分之后，需要调用`flush()`方法来刷新页面。
    
        try { 
        	response.getWriter().print("11111111111111<br/>");
        	response.getWriter().flush();
        	try { 
        		Thread.sleep(2500);
        	} catch (InterruptedException e) { 
        		// TODO Auto-generated catch block
        		e.printStackTrace();
        	}
        	response.getWriter().print("222222222222222");
        	response.getWriter().flush();
        } catch (IOException e) { 
        	e.printStackTrace();
        }
    
    先输出字符串“11111111111111”，然后线程休眠2500ms，再输出“222222222222222”。
5.  最后我们不要忘记关闭这个线程。到了运行完所有的代码，我们要告诉tomcat，我们的程序已经执行完毕了。
    
        ac.complete();
    
    但是这个时候，我们要记得，我们在内部类中使用了外部的局部变量，要给局部变量添加final修饰符。

我们最终形成了以下的代码：

/** * 添加WebServlet注解 * * @author Veeja.Liu * @emial veejaliu@gmail.com * */
    @WebServlet(urlPatterns = "/AServlet", asyncSupported = true)
    public class AServlet extends HttpServlet { 
    	@Override
    	protected void doGet(final HttpServletRequest request,
    			final HttpServletResponse response)
    			throws ServletException, IOException { 
    
    		response.setContentType("text/html;charset=utf-8");
    
    		/* * 1. 得到异步上下文对象 */
    		final AsyncContext ac = request.startAsync(request, response);
    
    		/* * 2. 给上下文一个Runnable对象，让它执行任务。 */
    		ac.start(new Runnable() { 
    			public void run() { 
    				try { 
    					response.getWriter().print("11111111111111<br/>");
    					response.getWriter().flush();
    					try { 
    						Thread.sleep(2500);
    					} catch (InterruptedException e) { 
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    					response.getWriter().print("33333333333333");
    					response.getWriter().flush();
    
    					/* * 通知Tomcat程序执行完毕 */
    					ac.complete();
    
    				} catch (IOException e) { 
    					e.printStackTrace();
    				}
    			}
    		});
    	}
    }

我们在浏览器中访问AServlet，可以看到很明显的效果。

但是我们额外需要注意几点，如果执行以上的代码，效果并不明显，我们需要留意一个问题，就是编码的问题：  
**注意，响应类型必须是text/html，所以：`response.setContentType(“text/html;charset=utf-8”);`**  
另外，如果是在IE浏览器中，如果不能正常输出，这说明响应体大小不足 512B，那你需要多输出点，可以随意打一些内容上去。  
而且我在Chrome中做实验的时候，每次只输出一个字符，也会有一些问题，这个我还不太清楚为什么，估计也是跟响应体的大小太小有关系。

## 三、简单的封装 ##

我们在写上面的代码的时候，发现每次输出一些内容，都要刷新一下，而且每次让线程休眠的时候，我们都要try-catch一些异常。  
我们简单的封装一下这两个操作。  
**1. 输出并且刷新：**

public void println(String text, HttpServletResponse response) { 
    	try { 
    		response.getWriter().print(text);
    		response.getWriter().flush();
    	} catch (IOException e) { 
    	}
    }

**2.休眠**

public void sleep(long ms) { 
    	try { 
    		Thread.sleep(ms);
    	} catch (InterruptedException e) { 
    	}
    }

我们再利用这两个方法，写一段简单的代码，可以更好的展示异步的效果：

/** * 添加WebServlet注解 * * @author Veeja.Liu * @emial veejaliu@gmail.com * */
    @WebServlet(urlPatterns = "/AServlet", asyncSupported = true)
    public class AServlet extends HttpServlet { 
    	@Override
    	protected void doGet(final HttpServletRequest request,
    			final HttpServletResponse response)
    			throws ServletException, IOException { 
    
    		response.setContentType("text/html;charset=utf-8");
    		// 1. 得到异步对象
    		final AsyncContext ac = request.startAsync(request, response);
    		// 2. 给上下文一个Runnable对象，让它执行任务。
    		ac.start(new Runnable() { 
    			public void run() { 
    				for (int i = 0; i <= 20; i++) { 
    					println(i + "<br/>", response);
    					sleep(250);
    				}
    				// 通知Tomcat执行结束
    				ac.complete();
    			}
    		});
    	}
    
    	/** * 输出方法 * * @param text * @param response */
    	public void println(String text, HttpServletResponse response) { 
    		try { 
    			response.getWriter().print(text);
    			response.getWriter().flush();
    		} catch (IOException e) { 
    		}
    	}
    
    	/** * 线程休眠方法 * * @param ms */
    	public void sleep(long ms) { 
    		try { 
    			Thread.sleep(ms);
    		} catch (InterruptedException e) { 
    		}
    	}
    }

再每一次250毫秒之后，就会输出一个数字，从0到20，我们在浏览器中可以明显的看到这个效果。

--------------------

END.