我是灼灼,一只初学Java的大一金渐层。
向往余秀华和狄兰·托马斯的疯狂,时常沉溺于将情感以诗相寄;追逐过王尔德、王小波的文字,后陷于毛姆和斯蒂芬·金不可自拔;热爱文学的浪潮,白日梦到底却总在现实里清醒;艳羡平静又极度渴盼奔跑的力量。
欢迎与我交流鸭· QQ:1517526827;
个人博客:https://blog.csdn.net/weixin_52777510?spm=1001.2101.3001.5343
使用Filter
内容来自廖雪峰官方Java教程~
在一个比较复杂的Web应用程序中,通常都有很多URL映射,对应的也会有多个Servlet来处理URL。
参考一下某论坛的各个Servlet设计功能:
IndexServlet:浏览帖子;
SignInServlet:登录;
SignOutServlet:退出登录;
ProfileServlet:修改用户资料;
PostServlet:发帖;
ReplyServlet:回复。
JavaEE的Servlet规范提供了一种Filter组件,即过滤器,它的作用是,把一些公用逻辑从各个Servlet中抽离出来,在HTTP请求到达Servlet之前,可以被一个或多个Filter预处理,类似打印日志、登录检查等逻辑,完全可以放到Filter中。
例如编写一个最简单的EncodingFilter,它强制把输入和输出的编码设置为UTF-8:
@WebFilter(urlPatterns = "/*")//用注解标注该filter需要过滤的URL,这里的/*表示所有路径
public class EncodingFilter implements Filter { //实现filter接口
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {
System.out.println("EncodingFilter:doFilter");
request.setCharacterEncoding("UTF-8");
response.setCharacterEncoding("UTF-8");
chain.doFilter(request, response);//调用方法处理请求
}
}
还可以继续添加其他Filter,例如LogFilter;(固定的重复代码依然是存在的)
多个Filter会组成一个链,每个请求都被链上的Filter依次处理;
有多个Filter的时候,Filter的顺序对处理的结果有影响。但是,Servlet规范并没有对@WebFilter注解标注的Filter规定顺序。
如果一定要给每个Filter指定顺序,就必须在web.xml文件中对这些Filter再配置一遍。
可以编写只对特定路径进行过滤的Filter,例如AuthFilter:
@WebFilter("/user/*")
public class AuthFilter implements Filter {
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {
System.out.println("AuthFilter: check authentication");
HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse resp = (HttpServletResponse) response;
if (req.getSession().getAttribute("user") == null) {
// 未登录,自动跳转到登录页:
System.out.println("AuthFilter: not signin!");
resp.sendRedirect("/signin");
} else {
// 已登录,继续处理:
chain.doFilter(request, response);
}
}
}
AuthFilter只过滤以/user/开头的路径,
- 如果一个请求路径类似/user/profile,那么它会被所有Filter依次处理;
- 如果一个请求路径类似/test,那么它会被除AuthFilter以外的Filter依次处理。
AuthFilter中,当用户没有登录时,在AuthFilter内部,直接调用resp.sendRedirect()发送重定向,且没有调用chain.doFilter(),因此,当用户没有登录时,请求到达AuthFilter后,不再继续处理,即后续的Filter和任何Servlet都没有机会处理该请求了。
重定向是什么?
重定向(Redirect)就是通过各种方法将各种网络请求重新定个方向转到其它位置(如:网页重定向、域名的重定向、路由选择的变化也是对数据报文经由路径的一种重定向)。
在网站建设中,时常会遇到需要网页重定向的情况:
1.网站调整(如改变网页目录结构);
2.网页被移到一个新地址;
3.网页扩展名改变(如应用需要把.php改成.Html或.shtml)。 这种情况下,如果不做重定向,则用户收藏夹或搜索引擎数据库中旧地址只能让访问客户得到一个404页面错误信息,访问流量白白丧失;再者某些注册了多个域名的网站,也需要通过重定向让访问这些域名的用户自动跳转到主站点等。
Filter可以有针对性地拦截或者放行HTTP请求
如果一个Filter在当前请求中生效,但什么都没有做:
@WebFilter("/*")
public class MyFilter implements Filter {
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {
// TODO
}
}
那么,用户将看到一个空白页,因为请求没有继续处理,默认响应是200+空白输出。
如果Filter要使请求继续被处理,就一定要调用chain.doFilter()。
如果使用一个统一的DispatcherServlet入口,加上多个Controller,这种模式下Filter仍然是正常工作的。例如,一个处理/user/*的Filter实际上作用于那些处理/user/开头的Controller方法之前。
小结
Filter是一种对HTTP请求进行预处理的组件,它可以构成一个处理链,使得公共处理代码能集中到一起;
Filter适用于日志、登录检查、全局设置等;
设计合理的URL映射可以让Filter链更清晰。
修改请求
Filter可以对请求进行预处理,因此可以把很多公共预处理逻辑放到Filter中完成。
例如一种在Web应用中处理用户上传文件的需求:一个UploadServlet可以简单地编写如下:
@WebServlet(urlPatterns = "/upload/file")
public class UploadServlet extends HttpServlet {
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 读取Request Body:
InputStream input = req.getInputStream();//输入流
ByteArrayOutputStream output = new ByteArrayOutputStream();//字节输出流
byte[] buffer = new byte[1024];
for (;;) {
int len = input.read(buffer);
if (len == -1) {
break;
}
output.write(buffer, 0, len);
}
// TODO: 写入文件:
// 显示上传结果:
String uploadedText = output.toString(StandardCharsets.UTF_8);
PrintWriter pw = resp.getWriter();
pw.write("<h1>Uploaded:</h1>");
pw.write("<pre><code>");
pw.write(uploadedText);
pw.write("</code></pre>");
pw.flush();
}
}
Q:如何保证文件上传的完整性?
A:如果在上传文件的同时,把文件的哈希也传过来,服务器端做一个验证,就可以确保用户上传的文件一定是完整的。
这个验证逻辑非常适合写在ValidateUploadFilter中,因为它可以复用。
快速实现ValidateUploadFilter逻辑:
@WebFilter("/upload/*")
public class ValidateUploadFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse resp = (HttpServletResponse) response;
// 获取客户端传入的签名方法和签名:
String digest = req.getHeader("Signature-Method");
String signature = req.getHeader("Signature");
if (digest == null || digest.isEmpty() || signature == null || signature.isEmpty()) {
sendErrorPage(resp, "Missing signature.");
return;
}
// 读取Request的Body并验证签名:
MessageDigest md = getMessageDigest(digest);
InputStream input = new DigestInputStream(request.getInputStream(), md);
byte[] buffer = new byte[1024];
for (;;) {
int len = input.read(buffer);
if (len == -1) {
break;
}
}
String actual = toHexString(md.digest());
if (!signature.equals(actual)) {
sendErrorPage(resp, "Invalid signature.");
return;
}
// 验证成功后继续处理:
chain.doFilter(request, response);
}
// 将byte[]转换为hex string:
private String toHexString(byte[] digest) {
StringBuilder sb = new StringBuilder();
for (byte b : digest) {
sb.append(String.format("%02x", b));
}
return sb.toString();
}
// 根据名称创建MessageDigest:
**private** MessageDigest getMessageDigest(String name) throws ServletException {
try {
return MessageDigest.getInstance(name);
} catch (NoSuchAlgorithmException e) {
throw new ServletException(e);
}
}
// 发送一个错误响应:
**private** void sendErrorPage(HttpServletResponse resp, String errorMessage) throws IOException {
resp.setStatus(HttpServletResponse.SC_BAD_REQUEST);
PrintWriter pw = resp.getWriter();
pw.write("<html><body><h1>");
pw.write(errorMessage);
pw.write("</h1></body></html>");
pw.flush();
}
}
这个ValidateUploadFilter的逻辑可以用curl命令测试:
$ curl http://localhost:8080/upload/file -v -d 'test-data' \
-H 'Signature-Method: SHA-1' \
-H 'Signature: 7115e9890f5b5cc6914bdfa3b7c011db1cdafedb' \
-H 'Content-Type: application/octet-stream'
- Trying ::1…
- TCP_NODELAY set
- Connected to localhost (::1) port 8080 (#0)
POST /upload/file HTTP/1.1
Host: localhost:8080
User-Agent: curl/7.64.1 Accept: */* Signature-Method: SHA-1
Signature: 7115e9890f5b5cc6914bdfa3b7c011db1cdafedb Content-Type: application/octet-stream Content-Length: 9
- upload completely sent off: 9 out of 9 bytes
< HTTP/1.1 200
< Transfer-Encoding: chunked
< Date: Thu, 30 Jan 2020 13:56:39 GMT
< - Connection #0 to host localhost left intact
<h1>Uploaded:</h1><pre><code></code></pre>
- Closing connection 0
ValidateUploadFilter对签名进行验证的逻辑是没有问题的,but UploadServlet并未读取到任何数据!
Q:对HttpServletRequest进行读取时,只能读取一次。如果Filter调用getInputStream()读取了一次数据,后续Servlet处理时,再次读取,将无法读到任何数据。
A:需要一个“伪造”的HttpServletRequest,具体做法是使用代理模式,对getInputStream()和getReader()返回一个新的流:
class ReReadableHttpServletRequest extends HttpServletRequestWrapper {
private byte[] body;
private boolean open = false;
public ReReadableHttpServletRequest(HttpServletRequest request, byte[] body) {
super(request);
this.body = body;
}
// 返回InputStream:
public ServletInputStream getInputStream() throws IOException {
if (open) {
throw new IllegalStateException("Cannot re-open input stream!");
}
open = true;
return new ServletInputStream() {
private int offset = 0;
public boolean isFinished() {
return offset >= body.length;
}
public boolean isReady() {
return true;
}
public void setReadListener(ReadListener listener) {
}
public int read() throws IOException {
if (offset >= body.length) {
return -1;
}
int n = body[offset] & 0xff;
offset++;
return n;
}
};
}
// 返回Reader:
public BufferedReader getReader() throws IOException {
if (open) {
throw new IllegalStateException("Cannot re-open reader!");
}
open = true;
return new BufferedReader(new InputStreamReader(new ByteArrayInputStream(body), "UTF-8"));
}
}
ReReadableHttpServletRequest的构造方法保存了ValidateUploadFilter读取的byte[]内容,并在调用getInputStream()时通过byte[]构造了一个新的ServletInputStream。
然后,在ValidateUploadFilter中,把doFilter()调用时传给下一个处理者的HttpServletRequest替换为自己“伪造”的ReReadableHttpServletRequest:
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {
...
chain.doFilter(new ReReadableHttpServletRequest(req, output.toByteArray()), response);
}
编写ReReadableHttpServletRequest时,是从HttpServletRequestWrapper继承,而不是直接实现HttpServletRequest接口。
原因是Servlet的每个新版本都会对接口增加一些新方法,从HttpServletRequestWrapper继承可以确保新方法被正确地覆写了,因为HttpServletRequestWrapper是由Servlet的jar包提供的,目的就是为了方便地实现对HttpServletRequest接口的代理。
对HttpServletRequest接口进行代理的步骤:
- 从HttpServletRequestWrapper继承一个XxxHttpServletRequest,需要传入原始的HttpServletRequest实例;
- 覆写某些方法,使得新的XxxHttpServletRequest实例看上去“改变”了原始的HttpServletRequest实例;
- 在doFilter()中传入新的XxxHttpServletRequest实例。
虽然整个Filter的代码比较复杂,但好处在于:这个Filter在整个处理链中实现了灵活的“可插拔”特性,即是否启用对Web应用程序的其他组件(Filter、Servlet)完全没有影响。
小结
借助HttpServletRequestWrapper,可以在Filter中实现对原始HttpServletRequest的修改。
修改响应
能通过Filter修改HttpServletRequest,也能修改HttpServletResponse,这两者都是接口。
Q:在什么情况下需要修改HttpServletResponse?
A:假设编写了一个Servlet,但由于业务逻辑比较复杂,处理该请求需要耗费很长的时间:
@WebServlet(urlPatterns = "/slow/hello")
public class HelloServlet extends HttpServlet {
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setContentType("text/html");
// 模拟耗时1秒:
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
PrintWriter pw = resp.getWriter();
pw.write("<h1>Hello, world!</h1>");
pw.flush();
}
}
每次返回的响应内容是固定的,因此,如果能使用缓存将结果缓存起来,就可以大大提高Web应用程序的运行效率。
缓存逻辑最好不要在Servlet内部实现,因为希望能复用缓存逻辑。
编写一个CacheFilter最合适:
@WebFilter("/slow/*")
public class CacheFilter implements Filter {
// Path到byte[]的缓存:
private Map<String, byte[]> cache = new ConcurrentHashMap<>();
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse resp = (HttpServletResponse) response;
// 获取Path:
String url = req.getRequestURL();
// 获取缓存内容:
byte[] data = this.cache.get(url);
resp.setHeader("X-Cache-Hit", data == null ? "No" : "Yes");
if (data == null) {
// 缓存未找到,构造一个伪造的Response:
CachedHttpServletResponse wrapper = new CachedHttpServletResponse(resp);
// 让下游组件写入数据到伪造的Response(名为wrapper):
chain.doFilter(request, wrapper);
// 从伪造的Response中**读取写入的内容**并放入缓存:
data = wrapper.getContent();
cache.put(url, data);
}
// 写入到原始的Response:
ServletOutputStream output = resp.getOutputStream();
output.write(data);
output.flush();
}
}
实现缓存的关键在于,调用doFilter()时,不能传入原始的HttpServletResponse,如果这样的话就会写入Socket,也就无法获取下游组件写入的内容。
如果传入的是“伪造”的HttpServletResponse,让下游组件写入到预设的ByteArrayOutputStream,这样就“截获”了下游组件写入的内容,于是,就可以把内容缓存起来,再通过原始的HttpServletResponse实例写入到网络。
CachedHttpServletResponse实现如下:
class CachedHttpServletResponse extends HttpServletResponseWrapper {
private boolean open = false;
private ByteArrayOutputStream output = new ByteArrayOutputStream();
public CachedHttpServletResponse(HttpServletResponse response) {
super(response);
}
// 获取Writer:
public PrintWriter getWriter() throws IOException {
if (open) {
throw new IllegalStateException("Cannot re-open writer!");
}
open = true;
return new PrintWriter(output, false, StandardCharsets.UTF_8);
}
// 获取OutputStream:
public ServletOutputStream getOutputStream() throws IOException {
if (open) {
throw new IllegalStateException("Cannot re-open output stream!");
}
open = true;
return new ServletOutputStream() {
public boolean isReady() {
return true;
}
public void setWriteListener(WriteListener listener) {
}
// 实际写入ByteArrayOutputStream:
public void write(int b) throws IOException {
output.write(b);
}
};
}
// 返回写入的byte[]:
public byte[] getContent() {
return output.toByteArray();
}
}
如果想要修改响应,可以通过HttpServletResponseWrapper构造一个“伪造”的HttpServletResponse,这样就能拦截到写入的数据。
修改响应时,最后不要忘记把数据写入原始的HttpServletResponse实例。
CacheFilter同样是一个“可插拔”组件,它是否启用不影响Web应用程序的其他组件(Filter、Servlet)。
小结
借助HttpServletResponseWrapper,可以在Filter中实现对原始HttpServletResponse的修改。
有关filter使用的全部内容结束啦~
可以看到,要学会正确地应用他,弄懂IO和servlet基础是必要的。
如果对你有帮助的话不要忘记一键三连噢~
谢谢鸭~
初次编写于2021/2/20日;