在filter中可以得到代表用户请求和响应的request、response对象,因此在编程中可以使用Decorator(装饰器)模式对request、response对象进行包装,再把包装对象传给目标资源,从而实现一些特殊需求。

一、Decorator设计模式

1.1、Decorator设计模式介绍

  当某个对象的方法不适应业务需求时,通常有2种方式可以对方法进行增强:

  1. 编写子类,覆盖需增强的方法。
  2. 使用Decorator设计模式对方法进行增强。

  在阎宏博士的《JAVA与模式》一书中开头是这样描述装饰(Decorator)模式的:装饰模式又名包装(Wrapper)模式。装饰模式以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案。装饰模式是在不必改变原类文件和使用继承的情况下,动态的扩展一个对象的功能。它是通过创建一个包装对象,也就是装饰来包裹真实的对象。

  那么在实际应用中遇到需增强对象的方法时,到底选用哪种方式比较好呢?这个没有具体的定式,只能是根据具体的需求来采用具体的方式,不过有一种情况下,必须使用Decorator设计模式:即被增强的对象,开发人员只能得到它的对象,无法得到它的class文件。比如request、response对象,开发人员之所以在servlet中能通过sun公司定义的HttpServletRequest\response接口去操作这些对象,是因为Tomcat服务器厂商编写了request、response接口的实现类。web服务器在调用servlet时,会用这些接口的实现类创建出对象,然后传递给servlet程序。此种情况下,由于开发人员根本不知道服务器厂商编写的request、response接口的实现类是哪个?在程序中只能拿到服务器厂商提供的对象,因此就只能采用Decorator设计模式对这些对象进行增强。

1.2、Decorator设计模式的实现

  1.首先看需要被增强对象继承了什么接口或父类,编写一个类也去继承这些接口或父类。
  2.在类中定义一个变量,变量类型即需增强对象的类型。
  3.在类中定义一个构造函数,接收需增强的对象。
  4.覆盖需增强的方法,编写增强的代码。

二、使用Decorator设计模式增强request对象

  Servlet API 中提供了一个request对象的Decorator设计模式的默认实现类HttpServletRequestWrapper,HttpServletRequestWrapper 类实现了request 接口中的所有方法,但这些方法的内部实现都是仅仅调用了一下所包装的的 request 对象的对应方法,以避免用户在对request对象进行增强时需要实现request接口中的所有方法。

2.1、使用Decorator模式包装request对象解决get和post请求方式下的中文乱码问题

  编写一个用于处理中文乱码的过滤器CharacterEncodingFilter,代码如下:

  1. 1 package me.gacl.web.filter;
  2. 2
  3. 3 import java.io.IOException;
  4. 4
  5. 5 import javax.servlet.Filter;
  6. 6 import javax.servlet.FilterChain;
  7. 7 import javax.servlet.FilterConfig;
  8. 8 import javax.servlet.ServletException;
  9. 9 import javax.servlet.ServletRequest;
  10. 10 import javax.servlet.ServletResponse;
  11. 11 import javax.servlet.http.HttpServletRequest;
  12. 12 import javax.servlet.http.HttpServletRequestWrapper;
  13. 13 import javax.servlet.http.HttpServletResponse;
  14. 14
  15. 15 /**
  16. 16 * @ClassName: CharacterEncodingFilter
  17. 17 * @Description: 此过滤器用来解决解决get、post请求方式下的中文乱码问题
  18. 18 * @author: 孤傲苍狼
  19. 19 * @date: 2014-8-31 下午11:09:37
  20. 20 *
  21. 21 */
  22. 22 public class CharacterEncodingFilter implements Filter {
  23. 23
  24. 24 private FilterConfig filterConfig = null;
  25. 25 //设置默认的字符编码
  26. 26 private String defaultCharset = "UTF-8";
  27. 27
  28. 28 public void doFilter(ServletRequest req, ServletResponse resp,
  29. 29 FilterChain chain) throws IOException, ServletException {
  30. 30
  31. 31 HttpServletRequest request = (HttpServletRequest) req;
  32. 32 HttpServletResponse response = (HttpServletResponse) resp;
  33. 33 //得到在web.xml中配置的字符编码
  34. 34 String charset = filterConfig.getInitParameter("charset");
  35. 35 if(charset==null){
  36. 36 charset = defaultCharset;
  37. 37 }
  38. 38 request.setCharacterEncoding(charset);
  39. 39 response.setCharacterEncoding(charset);
  40. 40 response.setContentType("text/html;charset="+charset);
  41. 41
  42. 42 MyCharacterEncodingRequest requestWrapper = new MyCharacterEncodingRequest(request);
  43. 43 chain.doFilter(requestWrapper, response);
  44. 44 }
  45. 45
  46. 46 public void init(FilterConfig filterConfig) throws ServletException {
  47. 47 //得到过滤器的初始化配置信息
  48. 48 this.filterConfig = filterConfig;
  49. 49 }
  50. 50
  51. 51 public void destroy() {
  52. 52
  53. 53 }
  54. 54 }
  55. 55
  56. 56 /**
  57. 57 * @ClassName: MyCharacterEncodingRequest
  58. 58 * @Description: Servlet API中提供了一个request对象的Decorator设计模式的默认实现类HttpServletRequestWrapper,
  59. 59 * (HttpServletRequestWrapper类实现了request接口中的所有方法,但这些方法的内部实现都是仅仅调用了一下所包装的的 request对象的对应方法)
  60. 60 * 以避免用户在对request对象进行增强时需要实现request接口中的所有方法。
  61. 61 * 所以当需要增强request对象时,只需要写一个类继承HttpServletRequestWrapper类,然后在重写需要增强的方法即可
  62. 62 * @author: 孤傲苍狼
  63. 63 * @date: 2014-9-2 下午10:42:57
  64. 64 * 1.实现与被增强对象相同的接口
  65. 65 2、定义一个变量记住被增强对象
  66. 66 3、定义一个构造函数,接收被增强对象
  67. 67 4、覆盖需要增强的方法
  68. 68 5、对于不想增强的方法,直接调用被增强对象(目标对象)的方法
  69. 69 */
  70. 70 class MyCharacterEncodingRequest extends HttpServletRequestWrapper{
  71. 71 //定义一个变量记住被增强对象(request对象是需要被增强的对象)
  72. 72 private HttpServletRequest request;
  73. 73 //定义一个构造函数,接收被增强对象
  74. 74 public MyCharacterEncodingRequest(HttpServletRequest request) {
  75. 75 super(request);
  76. 76 this.request = request;
  77. 77 }
  78. 78 /* 覆盖需要增强的getParameter方法
  79. 79 * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
  80. 80 */
  81. 81 @Override
  82. 82 public String getParameter(String name) {
  83. 83 try{
  84. 84 //获取参数的值
  85. 85 String value= this.request.getParameter(name);
  86. 86 if(value==null){
  87. 87 return null;
  88. 88 }
  89. 89 //如果不是以get方式提交数据的,就直接返回获取到的值
  90. 90 if(!this.request.getMethod().equalsIgnoreCase("get")) {
  91. 91 return value;
  92. 92 }else{
  93. 93 //如果是以get方式提交数据的,就对获取到的值进行转码处理
  94. 94 value = new String(value.getBytes("ISO8859-1"),this.request.getCharacterEncoding());
  95. 95 return value;
  96. 96 }
  97. 97 }catch (Exception e) {
  98. 98 throw new RuntimeException(e);
  99. 99 }
  100. 100 }
  101. 101 }

  在web.xml文件中配置CharacterEncodingFilter

  1. 1 <!--配置字符过滤器,解决getpost请求方式下的中文乱码问题-->
  2. 2 <filter>
  3. 3 <filter-name>CharacterEncodingFilter</filter-name>
  4. 4 <filter-class>me.gacl.web.filter.CharacterEncodingFilter</filter-class>
  5. 5 </filter>
  6. 6
  7. 7 <filter-mapping>
  8. 8 <filter-name>CharacterEncodingFilter</filter-name>
  9. 9 <url-pattern>/*</url-pattern>
  10. 10 </filter-mapping>

  编写jsp测试页面,如下:

  1. 1 <%@ page language="java" pageEncoding="UTF-8"%>
  2. 2 <%--引入jstl标签库 --%>
  3. 3 <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
  4. 4 <!DOCTYPE HTML>
  5. 5 <html>
  6. 6 <head>
  7. 7 <title>使用字符过滤器解决解决getpost请求方式下的中文乱码问题</title>
  8. 8 </head>
  9. 9
  10. 10 <body>
  11. 11 <%--使用c:url标签构建url,构建好的url存储在servletDemo1变量中--%>
  12. 12 <c:url value="/servlet/ServletDemo1" scope="page" var="servletDemo1">
  13. 13 <%--构建的url的附带的中文参数 ,参数名是:username,值是:孤傲苍狼--%>
  14. 14 <c:param name="username" value="孤傲苍狼"></c:param>
  15. 15 </c:url>
  16. 16 <%--使用get的方式访问 --%>
  17. 17 <a href="${servletDemo1}">超链接(get方式请求)</a>
  18. 18 <hr/>
  19. 19 <%--使用post方式提交表单 --%>
  20. 20 <form action="${pageContext.request.contextPath}/servlet/ServletDemo1" method="post">
  21. 21 用户名:<input type="text" name="username" value="孤傲苍狼" />
  22. 22 <input type="submit" value="post方式提交">
  23. 23 </form>
  24. 24
  25. 25 </body>
  26. 26 </html>

  编写处理用户请求的ServletDemo1

  1. 1 package me.gacl.web.controller;
  2. 2
  3. 3 import java.io.IOException;
  4. 4 import java.io.PrintWriter;
  5. 5
  6. 6 import javax.servlet.ServletException;
  7. 7 import javax.servlet.http.HttpServlet;
  8. 8 import javax.servlet.http.HttpServletRequest;
  9. 9 import javax.servlet.http.HttpServletResponse;
  10. 10
  11. 11 public class ServletDemo1 extends HttpServlet {
  12. 12
  13. 13 public void doGet(HttpServletRequest request, HttpServletResponse response)
  14. 14 throws ServletException, IOException {
  15. 15 //接收参数
  16. 16 String username = request.getParameter("username");
  17. 17 //获取请求方式
  18. 18 String method = request.getMethod();
  19. 19 //获取输出流
  20. 20 PrintWriter out = response.getWriter();
  21. 21 out.write("请求的方式:"+method);
  22. 22 out.write("<br/>");
  23. 23 out.write("接收到的参数:"+username);
  24. 24 }
  25. 25
  26. 26 public void doPost(HttpServletRequest request, HttpServletResponse response)
  27. 27 throws ServletException, IOException {
  28. 28 doGet(request, response);
  29. 29 }
  30. 30
  31. 31 }

  测试结果如下:

  

  从运行结果中可以看到,无论是get请求方式还是post请求方式,中文乱码问题都可以完美解决了。

2.2、使用Decorator模式包装request对象实现html标签转义功能

  编写一个html转义过滤器,代码如下:

  1. 1 package me.gacl.web.filter;
  2. 2
  3. 3 import java.io.IOException;
  4. 4
  5. 5 import javax.servlet.Filter;
  6. 6 import javax.servlet.FilterChain;
  7. 7 import javax.servlet.FilterConfig;
  8. 8 import javax.servlet.ServletException;
  9. 9 import javax.servlet.ServletRequest;
  10. 10 import javax.servlet.ServletResponse;
  11. 11 import javax.servlet.http.HttpServletRequest;
  12. 12 import javax.servlet.http.HttpServletRequestWrapper;
  13. 13 import javax.servlet.http.HttpServletResponse;
  14. 14
  15. 15 /**
  16. 16 * @ClassName: HtmlFilter
  17. 17 * @Description: html转义过滤器
  18. 18 * @author: 孤傲苍狼
  19. 19 * @date: 2014-9-2 下午11:28:41
  20. 20 *
  21. 21 */
  22. 22 public class HtmlFilter implements Filter {
  23. 23
  24. 24 public void doFilter(ServletRequest req, ServletResponse resp,
  25. 25 FilterChain chain) throws IOException, ServletException {
  26. 26
  27. 27 HttpServletRequest request = (HttpServletRequest) req;
  28. 28 HttpServletResponse response = (HttpServletResponse) resp;
  29. 29
  30. 30 MyHtmlRequest myrequest = new MyHtmlRequest(request);
  31. 31 chain.doFilter(myrequest, response);
  32. 32
  33. 33 }
  34. 34
  35. 35
  36. 36 public void destroy() {
  37. 37
  38. 38 }
  39. 39
  40. 40
  41. 41 public void init(FilterConfig filterConfig) throws ServletException {
  42. 42
  43. 43 }
  44. 44 }
  45. 45
  46. 46 /**
  47. 47 * @ClassName: MyHtmlRequest
  48. 48 * @Description: 使用Decorator模式包装request对象,实现html标签转义功能
  49. 49 * @author: 孤傲苍狼
  50. 50 * @date: 2014-9-2 下午11:29:09
  51. 51 *
  52. 52 */
  53. 53 class MyHtmlRequest extends HttpServletRequestWrapper {
  54. 54
  55. 55 private HttpServletRequest request;
  56. 56
  57. 57 public MyHtmlRequest(HttpServletRequest request) {
  58. 58 super(request);
  59. 59 this.request = request;
  60. 60 }
  61. 61
  62. 62 /* 覆盖需要增强的getParameter方法
  63. 63 * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
  64. 64 */
  65. 65 @Override
  66. 66 public String getParameter(String name) {
  67. 67 String value = this.request.getParameter(name);
  68. 68 if (value == null) {
  69. 69 return null;
  70. 70 }
  71. 71 //调用filter转义value中的html标签
  72. 72 return filter(value);
  73. 73 }
  74. 74
  75. 75 /**
  76. 76 * @Method: filter
  77. 77 * @Description: 过滤内容中的html标签
  78. 78 * @Anthor:孤傲苍狼
  79. 79 * @param message
  80. 80 * @return
  81. 81 */
  82. 82 public String filter(String message) {
  83. 83 if (message == null){
  84. 84 return null;
  85. 85 }
  86. 86 char content[] = new char[message.length()];
  87. 87 message.getChars(0, message.length(), content, 0);
  88. 88 StringBuffer result = new StringBuffer(content.length + 50);
  89. 89 for (int i = 0; i < content.length; i++) {
  90. 90 switch (content[i]) {
  91. 91 case '<':
  92. 92 result.append("&lt;");
  93. 93 break;
  94. 94 case '>':
  95. 95 result.append("&gt;");
  96. 96 break;
  97. 97 case '&':
  98. 98 result.append("&amp;");
  99. 99 break;
  100. 100 case '"':
  101. 101 result.append("&quot;");
  102. 102 break;
  103. 103 default:
  104. 104 result.append(content[i]);
  105. 105 }
  106. 106 }
  107. 107 return result.toString();
  108. 108 }
  109. 109 }

  在web.xml文件中配置HtmlFilter

  1. 1 <!--配置Html过滤器,转义内容中的html标签-->
  2. 2 <filter>
  3. 3 <filter-name>HtmlFilter</filter-name>
  4. 4 <filter-class>me.gacl.web.filter.HtmlFilter</filter-class>
  5. 5 </filter>
  6. 6
  7. 7 <filter-mapping>
  8. 8 <filter-name>HtmlFilter</filter-name>
  9. 9 <url-pattern>/*</url-pattern>
  10. 10 </filter-mapping>

  编写jsp测试页面,如下:

  1. 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2. 2 <!DOCTYPE HTML>
  3. 3 <html>
  4. 4 <head>
  5. 5 <title>html过滤器测试</title>
  6. 6 </head>
  7. 7
  8. 8 <body>
  9. 9 <form action="${pageContext.request.contextPath}/servlet/ServletDemo2" method="post">
  10. 10 留言:
  11. 11 <textarea rows="8" cols="70" name="message">
  12. 12 <script type="text/javascript">
  13. 13 while(true){
  14. 14 alert("死循环了,我会不停地弹出了");
  15. 15 }
  16. 16 </script>
  17. 17 <a href="http://www.cnblogs.com">访问博客园</a>
  18. 18 </textarea>
  19. 19 <input type="submit" value="发表">
  20. 20 </form>
  21. 21 </body>
  22. 22 </html>

  编写处理用户请求的ServletDemo2

  1. 1 package me.gacl.web.controller;
  2. 2
  3. 3 import java.io.IOException;
  4. 4
  5. 5 import javax.servlet.ServletException;
  6. 6 import javax.servlet.http.HttpServlet;
  7. 7 import javax.servlet.http.HttpServletRequest;
  8. 8 import javax.servlet.http.HttpServletResponse;
  9. 9
  10. 10 public class ServletDemo2 extends HttpServlet {
  11. 11
  12. 12 public void doGet(HttpServletRequest request, HttpServletResponse response)
  13. 13 throws ServletException, IOException {
  14. 14 //获取用户输入的内容
  15. 15 String message = request.getParameter("message");
  16. 16 response.getWriter().write("您上次的留言是:<br/>" + message);
  17. 17 }
  18. 18
  19. 19 public void doPost(HttpServletRequest request, HttpServletResponse response)
  20. 20 throws ServletException, IOException {
  21. 21 doGet(request, response);
  22. 22 }
  23. 23 }

测试结果如下:

  

  从运行结果中可以看到,所有的html标签都被转义输出了。

2.3、使用Decorator模式包装request对象实现敏感字符过滤功能

  编写一个敏感字符过滤器,代码如下:

  1. 1 package me.gacl.web.filter;
  2. 2
  3. 3 import java.io.BufferedReader;
  4. 4 import java.io.IOException;
  5. 5 import java.io.InputStream;
  6. 6 import java.io.InputStreamReader;
  7. 7 import java.io.UnsupportedEncodingException;
  8. 8 import java.util.ArrayList;
  9. 9 import java.util.List;
  10. 10 import javax.servlet.Filter;
  11. 11 import javax.servlet.FilterChain;
  12. 12 import javax.servlet.FilterConfig;
  13. 13 import javax.servlet.ServletException;
  14. 14 import javax.servlet.ServletRequest;
  15. 15 import javax.servlet.ServletResponse;
  16. 16 import javax.servlet.http.HttpServletRequest;
  17. 17 import javax.servlet.http.HttpServletRequestWrapper;
  18. 18 import javax.servlet.http.HttpServletResponse;
  19. 19
  20. 20 /**
  21. 21 * @ClassName: DirtyFilter
  22. 22 * @Description: 敏感词过滤器
  23. 23 * @author: 孤傲苍狼
  24. 24 * @date: 2014-9-6 上午10:43:11
  25. 25 *
  26. 26 */
  27. 27 public class DirtyFilter implements Filter {
  28. 28
  29. 29 private FilterConfig config = null;
  30. 30
  31. 31 @Override
  32. 32 public void init(FilterConfig filterConfig) throws ServletException {
  33. 33 this.config = filterConfig;
  34. 34 }
  35. 35
  36. 36 @Override
  37. 37 public void doFilter(ServletRequest req, ServletResponse resp,
  38. 38 FilterChain chain) throws IOException, ServletException {
  39. 39
  40. 40 HttpServletRequest request = (HttpServletRequest) req;
  41. 41 HttpServletResponse response = (HttpServletResponse) resp;
  42. 42 DirtyRequest dirtyrequest = new DirtyRequest(request);
  43. 43
  44. 44 chain.doFilter(dirtyrequest, response);
  45. 45 }
  46. 46
  47. 47 @Override
  48. 48 public void destroy() {
  49. 49
  50. 50 }
  51. 51
  52. 52 /**
  53. 53 * @Method: getDirtyWords
  54. 54 * @Description: 获取敏感字符
  55. 55 * @Anthor:孤傲苍狼
  56. 56 *
  57. 57 * @return
  58. 58 */
  59. 59 private List<String> getDirtyWords(){
  60. 60 List<String> dirtyWords = new ArrayList<String>();
  61. 61 String dirtyWordPath = config.getInitParameter("dirtyWord");
  62. 62 InputStream inputStream = config.getServletContext().getResourceAsStream(dirtyWordPath);
  63. 63 InputStreamReader is = null;
  64. 64 try {
  65. 65 is = new InputStreamReader(inputStream,"UTF-8");
  66. 66 } catch (UnsupportedEncodingException e2) {
  67. 67 e2.printStackTrace();
  68. 68 }
  69. 69 BufferedReader reader = new BufferedReader(is);
  70. 70 String line;
  71. 71 try {
  72. 72 while ((line = reader.readLine())!= null) {//如果 line为空说明读完了
  73. 73 dirtyWords.add(line);
  74. 74 }
  75. 75 } catch (IOException e) {
  76. 76 e.printStackTrace();
  77. 77 }
  78. 78 return dirtyWords;
  79. 79 }
  80. 80
  81. 81 /**
  82. 82 * @ClassName: DirtyRequest
  83. 83 * @Description: 使用Decorator模式包装request对象,实现敏感字符过滤功能
  84. 84 * @author: 孤傲苍狼
  85. 85 * @date: 2014-9-6 上午11:56:35
  86. 86 *
  87. 87 */
  88. 88 class DirtyRequest extends HttpServletRequestWrapper{
  89. 89
  90. 90 private List<String> dirtyWords = getDirtyWords();
  91. 91 private HttpServletRequest request;
  92. 92 public DirtyRequest(HttpServletRequest request) {
  93. 93 super(request);
  94. 94 this.request = request;
  95. 95 }
  96. 96 /* 重写getParameter方法,实现对敏感字符的过滤
  97. 97 * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
  98. 98 */
  99. 99 @Override
  100. 100 public String getParameter(String name) {
  101. 101
  102. 102 String value = this.request.getParameter(name);
  103. 103 if(value==null){
  104. 104 return null;
  105. 105 }
  106. 106
  107. 107 for(String dirtyWord : dirtyWords){
  108. 108 if(value.contains(dirtyWord)){
  109. 109 System.out.println("内容中包含敏感词:"+dirtyWord+",将会被替换成****");
  110. 110 //替换敏感字符
  111. 111 value = value.replace(dirtyWord, "****");
  112. 112 }
  113. 113 }
  114. 114 return value;
  115. 115 }
  116. 116 }
  117. 117 }

  在web.xml文件中配置DirtyFilter

  1. 1 <!--配置敏感字符过滤器-->
  2. 2 <filter>
  3. 3 <filter-name>DirtyFilter</filter-name>
  4. 4 <filter-class>me.gacl.web.filter.DirtyFilter</filter-class>
  5. 5 <!-- 配置要过滤的敏感字符文件 -->
  6. 6 <init-param>
  7. 7 <param-name>dirtyWord</param-name>
  8. 8 <param-value>/WEB-INF/DirtyWord.txt</param-value>
  9. 9 </init-param>
  10. 10 </filter>
  11. 11
  12. 12 <filter-mapping>
  13. 13 <filter-name>DirtyFilter</filter-name>
  14. 14 <url-pattern>/*</url-pattern>
  15. 15 </filter-mapping>

  当用户填写的内容包含一些敏感字符时,在DirtyFilter过滤器中就会将这些敏感字符替换掉。

  我们如果将上述的CharacterEncodingFilter、HtmlFilter、DirtyFilter这三个过滤器联合起来使用,那么就相当于是把request对象包装了3次,request对象的getParameter方法经过3次重写,使得getParameter方法的功能大大增强,可以同时解决中文乱码,html标签转义,敏感字符过滤这些需求。

  在实际开发中完全可以将上述的三个过滤器合并成一个,让合并后的过滤器具有解决中文乱码,html标签转义,敏感字符过滤这些功能,例如:

  1. 1 package me.gacl.web.filter;
  2. 2
  3. 3 import java.io.BufferedReader;
  4. 4 import java.io.IOException;
  5. 5 import java.io.InputStream;
  6. 6 import java.io.InputStreamReader;
  7. 7 import java.io.UnsupportedEncodingException;
  8. 8 import java.util.ArrayList;
  9. 9 import java.util.List;
  10. 10
  11. 11 import javax.servlet.Filter;
  12. 12 import javax.servlet.FilterChain;
  13. 13 import javax.servlet.FilterConfig;
  14. 14 import javax.servlet.ServletException;
  15. 15 import javax.servlet.ServletRequest;
  16. 16 import javax.servlet.ServletResponse;
  17. 17 import javax.servlet.http.HttpServletRequest;
  18. 18 import javax.servlet.http.HttpServletRequestWrapper;
  19. 19 import javax.servlet.http.HttpServletResponse;
  20. 20
  21. 21 /**
  22. 22 * @ClassName: AdvancedFilter
  23. 23 * @Description: 这个过滤器是用来解决中文乱码,转义内容中的html标签,过滤内容中的敏感字符的
  24. 24 * @author: 孤傲苍狼
  25. 25 * @date: 2014-9-6 下午6:17:37
  26. 26 *
  27. 27 */
  28. 28 public class AdvancedFilter implements Filter {
  29. 29
  30. 30 private FilterConfig filterConfig = null;
  31. 31 //设置默认的字符编码
  32. 32 private String defaultCharset = "UTF-8";
  33. 33
  34. 34 @Override
  35. 35 public void init(FilterConfig filterConfig) throws ServletException {
  36. 36 //得到过滤器的初始化配置信息
  37. 37 this.filterConfig = filterConfig;
  38. 38 }
  39. 39
  40. 40 @Override
  41. 41 public void doFilter(ServletRequest req, ServletResponse resp,
  42. 42 FilterChain chain) throws IOException, ServletException {
  43. 43 HttpServletRequest request = (HttpServletRequest) req;
  44. 44 HttpServletResponse response = (HttpServletResponse) resp;
  45. 45 //得到在web.xml中配置的字符编码
  46. 46 String charset = filterConfig.getInitParameter("charset");
  47. 47 if(charset==null){
  48. 48 charset = defaultCharset;
  49. 49 }
  50. 50 request.setCharacterEncoding(charset);
  51. 51 response.setCharacterEncoding(charset);
  52. 52 response.setContentType("text/html;charset="+charset);
  53. 53
  54. 54 AdvancedRequest requestWrapper = new AdvancedRequest(request);
  55. 55 chain.doFilter(requestWrapper, response);
  56. 56 }
  57. 57
  58. 58 @Override
  59. 59 public void destroy() {
  60. 60
  61. 61 }
  62. 62
  63. 63 class AdvancedRequest extends HttpServletRequestWrapper{
  64. 64
  65. 65 private List<String> dirtyWords = getDirtyWords();
  66. 66
  67. 67 //定义一个变量记住被增强对象(request对象是需要被增强的对象)
  68. 68 private HttpServletRequest request;
  69. 69 //定义一个构造函数,接收被增强对象
  70. 70 public AdvancedRequest(HttpServletRequest request) {
  71. 71 super(request);
  72. 72 this.request = request;
  73. 73 }
  74. 74 /* 覆盖需要增强的getParameter方法
  75. 75 * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
  76. 76 */
  77. 77 @Override
  78. 78 public String getParameter(String name) {
  79. 79 try{
  80. 80 //获取参数的值
  81. 81 String value= this.request.getParameter(name);
  82. 82 if(value==null){
  83. 83 return null;
  84. 84 }
  85. 85 //如果不是以get方式提交数据的,就直接返回获取到的值
  86. 86 if(!this.request.getMethod().equalsIgnoreCase("get")) {
  87. 87 //调用filter转义value中的html标签
  88. 88 value= filter(value);
  89. 89 }else{
  90. 90 //如果是以get方式提交数据的,就对获取到的值进行转码处理
  91. 91 value = new String(value.getBytes("ISO8859-1"),this.request.getCharacterEncoding());
  92. 92 //调用filter转义value中的html标签
  93. 93 value= filter(value);
  94. 94 }
  95. 95
  96. 96 for(String dirtyWord : dirtyWords){
  97. 97 if(value.contains(dirtyWord)){
  98. 98 System.out.println("内容中包含敏感词:"+dirtyWord+",将会被替换成****");
  99. 99 //替换敏感字符
  100. 100 value = value.replace(dirtyWord, "****");
  101. 101 }
  102. 102 }
  103. 103 return value;
  104. 104 }catch (Exception e) {
  105. 105 throw new RuntimeException(e);
  106. 106 }
  107. 107 }
  108. 108 }
  109. 109
  110. 110 /**
  111. 111 * @Method: filter
  112. 112 * @Description: 过滤内容中的html标签
  113. 113 * @Anthor:孤傲苍狼
  114. 114 * @param value
  115. 115 * @return
  116. 116 */
  117. 117 public String filter(String value) {
  118. 118 if (value == null){
  119. 119 return null;
  120. 120 }
  121. 121 char content[] = new char[value.length()];
  122. 122 value.getChars(0, value.length(), content, 0);
  123. 123 StringBuffer result = new StringBuffer(content.length + 50);
  124. 124 for (int i = 0; i < content.length; i++) {
  125. 125 switch (content[i]) {
  126. 126 case '<':
  127. 127 result.append("&lt;");
  128. 128 break;
  129. 129 case '>':
  130. 130 result.append("&gt;");
  131. 131 break;
  132. 132 case '&':
  133. 133 result.append("&amp;");
  134. 134 break;
  135. 135 case '"':
  136. 136 result.append("&quot;");
  137. 137 break;
  138. 138 default:
  139. 139 result.append(content[i]);
  140. 140 }
  141. 141 }
  142. 142 return (result.toString());
  143. 143 }
  144. 144
  145. 145 /**
  146. 146 * @Method: getDirtyWords
  147. 147 * @Description: 获取敏感字符
  148. 148 * @Anthor:孤傲苍狼
  149. 149 *
  150. 150 * @return
  151. 151 */
  152. 152 private List<String> getDirtyWords(){
  153. 153 List<String> dirtyWords = new ArrayList<String>();
  154. 154 String dirtyWordPath = filterConfig.getInitParameter("dirtyWord");
  155. 155 InputStream inputStream = filterConfig.getServletContext().getResourceAsStream(dirtyWordPath);
  156. 156 InputStreamReader is = null;
  157. 157 try {
  158. 158 is = new InputStreamReader(inputStream,defaultCharset);
  159. 159 } catch (UnsupportedEncodingException e2) {
  160. 160 e2.printStackTrace();
  161. 161 }
  162. 162 BufferedReader reader = new BufferedReader(is);
  163. 163 String line;
  164. 164 try {
  165. 165 while ((line = reader.readLine())!= null) {//如果 line为空说明读完了
  166. 166 dirtyWords.add(line);
  167. 167 }
  168. 168 } catch (IOException e) {
  169. 169 e.printStackTrace();
  170. 170 }
  171. 171 return dirtyWords;
  172. 172 }
  173. 173 }

  在web.xml文件中配置AdvancedFilter

  1. 1 <filter>
  2. 2 <filter-name>AdvancedFilter</filter-name>
  3. 3 <filter-class>me.gacl.web.filter.AdvancedFilter</filter-class>
  4. 4 <init-param>
  5. 5 <param-name>charset</param-name>
  6. 6 <param-value>UTF-8</param-value>
  7. 7 </init-param>
  8. 8 <init-param>
  9. 9 <param-name>dirtyWord</param-name>
  10. 10 <param-value>/WEB-INF/DirtyWord.txt</param-value>
  11. 11 </init-param>
  12. 12 </filter>
  13. 13
  14. 14 <filter-mapping>
  15. 15 <filter-name>AdvancedFilter</filter-name>
  16. 16 <url-pattern>/*</url-pattern>
  17. 17 </filter-mapping>

  AdvancedFilter过滤器同时具有解决中文乱码,转义内容中的html标签,过滤内容中的敏感字符这些功能。

三、使用Decorator设计模式增强response对象

  Servlet  API 中提供了response对象的Decorator设计模式的默认实现类HttpServletResponseWrapper ,HttpServletResponseWrapper类实现了response接口中的所有方法,但这些方法的内部实现都是仅仅调用了一下所包装的的 response对象的对应方法,以避免用户在对response对象进行增强时需要实现response接口中的所有方法。

3.1、response增强案例——压缩响应正文内容

  应用HttpServletResponseWrapper对象,压缩响应正文内容。

  具体思路:通过filter向目标页面传递一个自定义的response对象。在自定义的response对象中,重写getOutputStream方法和getWriter方法,使目标资源调用此方法输出页面内容时,获得的是我们自定义的ServletOutputStream对象。在我们自定义的ServletOuputStream对象中,重写write方法,使写出的数据写出到一个buffer中。当页面完成输出后,在filter中就可得到页面写出的数据,从而我们可以调用GzipOuputStream对数据进行压缩后再写出给浏览器,以此完成响应正文件压缩功能。

  编写压缩过滤器,代码如下:

  1. 1 package me.gacl.web.filter;
  2. 2
  3. 3 import java.io.ByteArrayOutputStream;
  4. 4 import java.io.IOException;
  5. 5 import java.io.OutputStreamWriter;
  6. 6 import java.io.PrintWriter;
  7. 7 import java.util.zip.GZIPOutputStream;
  8. 8
  9. 9 import javax.servlet.Filter;
  10. 10 import javax.servlet.FilterChain;
  11. 11 import javax.servlet.FilterConfig;
  12. 12 import javax.servlet.ServletException;
  13. 13 import javax.servlet.ServletOutputStream;
  14. 14 import javax.servlet.ServletRequest;
  15. 15 import javax.servlet.ServletResponse;
  16. 16 import javax.servlet.http.HttpServletRequest;
  17. 17 import javax.servlet.http.HttpServletResponse;
  18. 18 import javax.servlet.http.HttpServletResponseWrapper;
  19. 19
  20. 20 /**
  21. 21 * @ClassName: GzipFilter
  22. 22 * @Description: 压缩过滤器,将web应用中的文本都经过压缩后再输出到浏览器
  23. 23 * @author: 孤傲苍狼
  24. 24 * @date: 2014-9-7 上午10:52:42
  25. 25 *
  26. 26 */
  27. 27 public class GzipFilter implements Filter {
  28. 28
  29. 29 public void doFilter(ServletRequest req, ServletResponse resp,
  30. 30 FilterChain chain) throws IOException, ServletException {
  31. 31
  32. 32 HttpServletRequest request = (HttpServletRequest) req;
  33. 33 HttpServletResponse response = (HttpServletResponse) resp;
  34. 34
  35. 35 BufferResponse myresponse = new BufferResponse(response);
  36. 36 chain.doFilter(request, myresponse);
  37. 37 //拿出缓存中的数据,压缩后再打给浏览器
  38. 38 byte out[] = myresponse.getBuffer();
  39. 39 System.out.println("原始大小:" + out.length);
  40. 40
  41. 41 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  42. 42 //压缩输出流中的数据
  43. 43 GZIPOutputStream gout = new GZIPOutputStream(bout);
  44. 44 gout.write(out);
  45. 45 gout.close();
  46. 46
  47. 47 byte gzip[] = bout.toByteArray();
  48. 48 System.out.println("压缩后的大小:" + gzip.length);
  49. 49
  50. 50 response.setHeader("content-encoding", "gzip");
  51. 51 response.setContentLength(gzip.length);
  52. 52 response.getOutputStream().write(gzip);
  53. 53 }
  54. 54
  55. 55 public void destroy() {
  56. 56
  57. 57 }
  58. 58
  59. 59 public void init(FilterConfig filterConfig) throws ServletException {
  60. 60
  61. 61 }
  62. 62 }
  63. 63
  64. 64 class BufferResponse extends HttpServletResponseWrapper{
  65. 65
  66. 66 private ByteArrayOutputStream bout = new ByteArrayOutputStream();
  67. 67 private PrintWriter pw;
  68. 68 private HttpServletResponse response;
  69. 69 public BufferResponse(HttpServletResponse response) {
  70. 70 super(response);
  71. 71 this.response = response;
  72. 72 }
  73. 73 @Override
  74. 74 public ServletOutputStream getOutputStream() throws IOException {
  75. 75 return new MyServletOutputStream(bout);
  76. 76 }
  77. 77 @Override
  78. 78 public PrintWriter getWriter() throws IOException {
  79. 79 pw = new PrintWriter(new OutputStreamWriter(bout,this.response.getCharacterEncoding()));
  80. 80 return pw;
  81. 81 }
  82. 82
  83. 83 public byte[] getBuffer(){
  84. 84 try{
  85. 85 if(pw!=null){
  86. 86 pw.close();
  87. 87 }
  88. 88 if(bout!=null){
  89. 89 bout.flush();
  90. 90 return bout.toByteArray();
  91. 91 }
  92. 92
  93. 93
  94. 94 return null;
  95. 95 }catch (Exception e) {
  96. 96 throw new RuntimeException(e);
  97. 97 }
  98. 98 }
  99. 99 }
  100. 100
  101. 101 class MyServletOutputStream extends ServletOutputStream{
  102. 102
  103. 103 private ByteArrayOutputStream bout;
  104. 104 public MyServletOutputStream(ByteArrayOutputStream bout){
  105. 105 this.bout = bout;
  106. 106 }
  107. 107
  108. 108 @Override
  109. 109 public void write(int b) throws IOException {
  110. 110 this.bout.write(b);
  111. 111 }
  112. 112 }

  在web.xml中配置压缩过滤器

  1. 1 <filter>
  2. 2 <description>配置压缩过滤器</description>
  3. 3 <filter-name>GzipFilter</filter-name>
  4. 4 <filter-class>me.gacl.web.filter.GzipFilter</filter-class>
  5. 5 </filter>
  6. 6
  7. 7 <!--jsp文件的输出的内容都经过压缩过滤器压缩后才输出 -->
  8. 8 <filter-mapping>
  9. 9 <filter-name>GzipFilter</filter-name>
  10. 10 <url-pattern>*.jsp</url-pattern>
  11. 11 <!-- 配置过滤器的拦截方式-->
  12. 12 <!-- 对于在Servlet中通过
  13. 13 request.getRequestDispatcher("jsp页面路径").forward(request, response)
  14. 14 方式访问的Jsp页面的要进行拦截 -->
  15. 15 <dispatcher>FORWARD</dispatcher>
  16. 16 <!--对于直接以URL方式访问的jsp页面进行拦截,过滤器的拦截方式默认就是 REQUEST-->
  17. 17 <dispatcher>REQUEST</dispatcher>
  18. 18 </filter-mapping>
  19. 19 <!--js文件的输出的内容都经过压缩过滤器压缩后才输出 -->
  20. 20 <filter-mapping>
  21. 21 <filter-name>GzipFilter</filter-name>
  22. 22 <url-pattern>*.js</url-pattern>
  23. 23 </filter-mapping>
  24. 24 <!--css文件的输出的内容都经过压缩过滤器压缩后才输出 -->
  25. 25 <filter-mapping>
  26. 26 <filter-name>GzipFilter</filter-name>
  27. 27 <url-pattern>*.css</url-pattern>
  28. 28 </filter-mapping>
  29. 29 <!--html文件的输出的内容都经过压缩过滤器压缩后才输出 -->
  30. 30 <filter-mapping>
  31. 31 <filter-name>GzipFilter</filter-name>
  32. 32 <url-pattern>*.html</url-pattern>
  33. 33 </filter-mapping>

3.2、response增强案例——缓存数据到内存

  对于页面中很少更新的数据,例如商品分类,为避免每次都要从数据库查询分类数据,因此可把分类数据缓存在内存或文件中,以此来减轻数据库压力,提高系统响应速度。

  编写缓存数据的过滤器,代码如下:

  1. 1 package me.gacl.web.filter;
  2. 2
  3. 3 import java.io.ByteArrayOutputStream;
  4. 4 import java.io.IOException;
  5. 5 import java.io.OutputStreamWriter;
  6. 6 import java.io.PrintWriter;
  7. 7 import java.util.HashMap;
  8. 8 import java.util.Map;
  9. 9
  10. 10 import javax.servlet.Filter;
  11. 11 import javax.servlet.FilterChain;
  12. 12 import javax.servlet.FilterConfig;
  13. 13 import javax.servlet.ServletException;
  14. 14 import javax.servlet.ServletOutputStream;
  15. 15 import javax.servlet.ServletRequest;
  16. 16 import javax.servlet.ServletResponse;
  17. 17 import javax.servlet.http.HttpServletRequest;
  18. 18 import javax.servlet.http.HttpServletResponse;
  19. 19 import javax.servlet.http.HttpServletResponseWrapper;
  20. 20
  21. 21 /**
  22. 22 * @ClassName: WebResourceCachedFilter
  23. 23 * @Description: Web资源缓存过滤器
  24. 24 * @author: 孤傲苍狼
  25. 25 * @date: 2014-9-8 上午12:20:16
  26. 26 *
  27. 27 */
  28. 28 public class WebResourceCachedFilter implements Filter {
  29. 29 /**
  30. 30 * @Field: map
  31. 31 * 缓存Web资源的Map容器
  32. 32 */
  33. 33 private Map<String,byte[]> map = new HashMap<String,byte[]>();
  34. 34
  35. 35 @Override
  36. 36 public void init(FilterConfig filterConfig) throws ServletException {
  37. 37
  38. 38 }
  39. 39
  40. 40 @Override
  41. 41 public void doFilter(ServletRequest req, ServletResponse resp,
  42. 42 FilterChain chain) throws IOException, ServletException {
  43. 43 HttpServletRequest request = (HttpServletRequest) req;
  44. 44 HttpServletResponse response = (HttpServletResponse) resp;
  45. 45 //1.得到用户请求的uri
  46. 46 String uri = request.getRequestURI();
  47. 47 //2.看缓存中有没有uri对应的数据
  48. 48 byte b[] = map.get(uri);
  49. 49 //3.如果缓存中有,直接拿缓存的数据打给浏览器,程序返回
  50. 50 if(b!=null){
  51. 51 //根据字节数组和指定的字符编码构建字符串
  52. 52 String webResourceHtmlStr = new String(b,response.getCharacterEncoding());
  53. 53 System.out.println(webResourceHtmlStr);
  54. 54 response.getOutputStream().write(b);
  55. 55 return;
  56. 56 }
  57. 57 //4.如果缓存没有,让目标资源执行,并捕获目标资源的输出
  58. 58 BufferResponse myresponse = new BufferResponse(response);
  59. 59 chain.doFilter(request, myresponse);
  60. 60 //获取缓冲流中的内容的字节数组
  61. 61 byte out[] = myresponse.getBuffer();
  62. 62 //5.把资源的数据以用户请求的uri为关键字保存到缓存中
  63. 63 map.put(uri, out);
  64. 64 //6.把数据打给浏览器
  65. 65 response.getOutputStream().write(out);
  66. 66 }
  67. 67
  68. 68 @Override
  69. 69 public void destroy() {
  70. 70
  71. 71 }
  72. 72
  73. 73 class BufferResponse extends HttpServletResponseWrapper{
  74. 74 private ByteArrayOutputStream bout = new ByteArrayOutputStream(); //捕获输出的缓存
  75. 75 private PrintWriter pw;
  76. 76 private HttpServletResponse response;
  77. 77 public BufferResponse(HttpServletResponse response) {
  78. 78 super(response);
  79. 79 this.response = response;
  80. 80 }
  81. 81 @Override
  82. 82 public ServletOutputStream getOutputStream() throws IOException {
  83. 83 return new MyServletOutputStream(bout);
  84. 84 }
  85. 85 @Override
  86. 86 public PrintWriter getWriter() throws IOException {
  87. 87 pw = new PrintWriter(new OutputStreamWriter(bout,this.response.getCharacterEncoding()));
  88. 88 return pw;
  89. 89 }
  90. 90
  91. 91 public byte[] getBuffer(){
  92. 92 try{
  93. 93 if(pw!=null){
  94. 94 pw.close();
  95. 95 }
  96. 96 return bout.toByteArray();
  97. 97 }catch (Exception e) {
  98. 98 throw new RuntimeException(e);
  99. 99 }
  100. 100 }
  101. 101 }
  102. 102
  103. 103 class MyServletOutputStream extends ServletOutputStream{
  104. 104 private ByteArrayOutputStream bout;
  105. 105 public MyServletOutputStream(ByteArrayOutputStream bout){ //接收数据写到哪里
  106. 106 this.bout = bout;
  107. 107 }
  108. 108 @Override
  109. 109 public void write(int b) throws IOException {
  110. 110 bout.write(b);
  111. 111 }
  112. 112 }
  113. 113 }

  在web.xml中配置Web资源缓存过滤器

  1. 1 <filter>
  2. 2 <description>Web资源缓存过滤器</description>
  3. 3 <filter-name>WebResourceCachedFilter</filter-name>
  4. 4 <filter-class>me.gacl.web.filter.WebResourceCachedFilter</filter-class>
  5. 5 </filter>
  6. 6
  7. 7 <filter-mapping>
  8. 8 <filter-name>WebResourceCachedFilter</filter-name>
  9. 9 <!-- 映射需要缓存输出的JSP页面,这几个页面都只是单纯作为输入UI,不会有太多的变化,因此可以缓存输出 -->
  10. 10 <url-pattern>/login.jsp</url-pattern>
  11. 11 <url-pattern>/test.jsp</url-pattern>
  12. 12 <url-pattern>/test2.jsp</url-pattern>
  13. 13 </filter-mapping>

filter 开发的更多相关文章

  1. DirectShow Filter 开发典型例子分析 ——字幕叠加 (FilterTitleOverlay)1

    本文分析一下<DirectShow开发指南>中的一个典型的Transform Filter的例子:字幕叠加(FilterTitleOverlay).通过分析该例子,我们可以学习到Direc ...

  2. 【转载】Servlet Filter(过滤器)、Filter是如何实现拦截的、Filter开发入门

    Servlet Filter(过滤器).Filter是如何实现拦截的.Filter开发入门 Filter简介 Filter也称之为过滤器,它是Servlet技术中最激动人心的技术,WEB开发人员通过F ...

  3. Servlet Filter(过滤器)、Filter是如何实现拦截的、Filter开发入门

    Servlet Filter(过滤器).Filter是如何实现拦截的.Filter开发入门 Filter简介 Filter也称之为过滤器,它是Servlet技术中最激动人心的技术,WEB开发人员通过F ...

  4. JavaWeb学习笔记--filter开发

    介绍自定义的Filter类必须实现Filter接口,并且实现Filter接口定义的init() doFilter() destory()方法.其中init为初始化,destory为销毁 doFilte ...

  5. filter 过滤器(监听)

    Filter 过滤器 1.简介 Filter也称之为过滤器,它是Servlet技术中最实用的技术,WEB开发人员通过Filter技术,对web服务器管理的所有web资源:例如Jsp, Servlet, ...

  6. Java 中的 Filter 过滤器详解

    Filter简介 Filter也称之为过滤器,它是Servlet技术中最实用的技术,WEB开发人员通过Filter技术,对web服务器管理的所有web资源:例如Jsp, Servlet, 静态图片文件 ...

  7. Filter(过滤器)学习

    一.Filter简介 Filter也称之为过滤器,它是Servlet技术中最激动人心的技术,WEB开发人员通过Filter技术,对web服务器管理的所有web资源:例如Jsp, Servlet, 静态 ...

  8. Filter

    一.Filter简介 Filter也称之为过滤器,它是Servlet技术中最激动人心的技术,WEB开发人员通过Filter技术,对web服务器管理的所有 web资源:例如Jsp, Servlet, 静 ...

  9. spring filter过滤器

    1.简介 Filter也称之为过滤器,它是Servlet技术中最实用的技术,WEB开发人员通过Filter技术,对web服务器管理的所有web资源:例如Jsp, Servlet, 静态图片文件或静态 ...

随机推荐

  1. springboot对shiro进行mock单元测试

    环境:junit-5.Spring5.0.x.Spring Boot 2.0.x 以下是用来权限测试的接口: @ApiOperation("[可接入]分页查询管理员") @ApiR ...

  2. jq向元素附加数据

    --------data() 方法向被选元素附加数据,或者从被选元素获取数据.--------- --------removeData() 方法删除之前通过 data() 方法设置的数据.------ ...

  3. @总结 - 2@ 位运算卷积/子集卷积 —— FWT/FMT

    目录 @0 - 参考资料@ @1 - 异或卷积概念及性质@ @2 - 快速沃尔什正变换(异或)@ @3 - 快速沃尔什逆变换(异或)@ @4 - 与卷积.或卷积@ @5 - 参考代码实现@ @6 - ...

  4. 微信小程序 mode 的几种模式

    mode="aspectFill" mode 有效值: mode 有 13 种模式,其中 4 种是缩放模式,9 种是裁剪模式. 模式 值 说明缩放 scaleToFill 不保持纵 ...

  5. Transformer的PyTorch实现

    Google 2017年的论文 Attention is all you need 阐释了什么叫做大道至简!该论文提出了Transformer模型,完全基于Attention mechanism,抛弃 ...

  6. E - Count on a tree 树上第K小

    主席树的入门题目,这道题的题意其实就是说,给你一棵树,询问在两个节点之间的路径上的区间第K小 我们如何把树上问题转换为区间问题呢? 其实DFS就可以,我们按照DFS的顺序,对线段树进行建树,那么这个树 ...

  7. 分布式TensorFlow集群local server使用详解

    通过local server理解分布式TensorFlow集群的应用与实现. ​​简介 TensorFlow从0.8版本开始,支持分布式集群,并且自带了local server方便测试. Local ...

  8. java方法里的属性

    访问控制符:访问控制符限定方法的可见范围,或者说是方法被调用的范围.方法的访问控制符有四种,按可见范围从大到小依次是:public.protected,无访问控制符,private.其中无访问控制符不 ...

  9. sdk uncaught third Error Cannot assign to read only property 'constructor' of object '#<V>' (小程序)

    sdk uncaught third Error Cannot assign to read only property 'constructor' of object '#<V>' 在a ...

  10. SQL2008 R2安装完成后开启services服务指引和 sa账号启用、数据类型