JavaScript（94）
1、基本类型和引用类型
基本的数据类型有5个：undefined，boolean，number，string，null
typeof null;
typeof undefined;
typeof false
typeof "1"
（令人困惑的是，对null类型进行typeof操作得到的结果为“object”，然而，ECMAScript标准描述其为一个独特的类型。）
为了便于操作基本类型值，ECMAScript还提供了三个特殊的引用类型：Boolean、Number和String,标准库提供了构造函数来封装布尔值、数字和字符串作为对象。这些类型与其他引用类型相似，同时也具有与各自的基本包装类型相应的特殊行为。实际上，每当读取一个基本类型值时，后台就会创建一个对应的基本包装类型的对象，从而让我们能够调用一些方法来操作这些数据。
var s1 = "some text";
var s2 = s1.substring(2);
var s3 = new String("some text");
但是不同于原始的字符串，String对象是一个真正的对象。
typeof s1;
typeof s3;
这个例子中的变量s1包含一个字符串，字符串当然是基本类型值。而下一行调用了s1的substring()方法，并将返回的结果保存在s2中。我们知道，基本类型值不是对象，因此从逻辑上讲，它们不应该有方法（但是它们确实有方法）。其实，为了让我们实现这种直观的操作，后台已经自动完成了一系列的处理。当第二行代码访问s1时，访问过程处于一种读取模式，也就是从内存中读取这个字符串的值。而在读取模式中访问字符串时，后台都会自动完成下列处理：
（1）创建String类型的一个实例。
（2）在实例上调用指定方法。
（3）销毁这个实例。
可以使用以下代码表示：
var s1 = new String("some text");
var s2 = s1.substring(2);
s1 = null;
经过此番处理，基本的字符串值就变得跟对象一样了。而且，上面三个步骤也适用于Boolean和Number类型对应的布尔值和数字值。
2、生命周期
引用类型与基本包装类型的主要区别就是对象的生命周期。使用new操作符创建的引用类型的实例，在执行流离开当前作用域之前都一直保存在内存中。而自动创建的基本包装类型的对象，只存在于这一行代码的执行期(瞬间)，然后立即销毁。这就意味着我们不能在运行时为属性添加属性和方法。
var s1 = "some text";
s1.color = "red";
alert(s1.color);
当然，可以显示调用Boolean、Number和String来创建基本包装类型的对象，不过，不帮不建议这么做。对基本包装类型的实例调用typeof会返回”object”,而且所有基本包装类型的对象都会被转化为布尔值true。。
var obj = new Object("some text");
alert(obj instanceof String)
值得注意的是，使用new调用基本包装类型的构造函数，与直接调用同名的转型函数是不一样的。
var value = "25";
var number = Number(value);
alert(typeof number)
var obj = new Number(var);
alert(typeof obj)
3.基本类型特点
1.基本类型的值是不可变得：
任何方法都无法改变一个基本类型的值，比如一个字符串：
var name = 'jozo';
name.toUpperCase(); // 输出 'JOZO'
console.log(name); // 输出
会发现原始的name并未发生改变，而是调用了toUpperCase()方法后返回的是一个新的字符串。
再来看个：
var person = 'jozo';
person.age = 22;
person.method = function(){//...};
console.log(person.age); // undefined
console.log(person.method); // undefined
通过上面代码可知，我们不能给基本类型添加属性和方法，再次说明基本类型时不可变得；
2.基本类型的比较是值的比较：
只有在它们的值相等的时候它们才相等。
但你可能会这样：
var a = 1;
var b = true;
console.log(a == b);//true
它们不是相等吗？其实这是类型转换和 == 运算符的知识了，也就是说在用==比较两个不同类型的变量时会进行一些类型转换。像上面的比较先会把true转换为数字1再和数字1进行比较，结果就是true了。 这是当比较的两个值的类型不同的时候==运算符会进行类型转换，但是当两个值的类型相同的时候，即使是==也相当于是===。
var a = 'jozo';
var b = 'jozo';
console.log(a === b);//true
3.基本类型的变量是存放在栈区的（栈区指内存里的栈内存）
假如有以下几个基本类型的变量：
var name = 'jozo';
var city = 'guangzhou';
var age = 22;
那么它的存储结构如下图：
栈区包括了 变量的标识符和变量的值。
4.引用类型特点
引用类型会比较好玩有趣一些。
javascript中除了上面的基本类型(number,string,boolean,null,undefined)之外就是引用类型了，也可以说是就是对象了。对象是属性和方法的集合。也就是说引用类型可以拥有属性和方法，属性又可以包含基本类型和引用类型。来看看引用类型的一些特性：
1.引用类型的值是可变的
我们可为为引用类型添加属性和方法，也可以删除其属性和方法，如：
var person = {};
person.name = 'jozo';
person.age = 22;
person.sayName = function(){console.log(person.name);}
person.sayName();
delete person.
person.sayName();
上面代码说明引用类型可以拥有属性和方法，并且是可以动态改变的。
2.引用类型的值是同时保存在栈内存和堆内存中的对象
javascript和其他语言不同，其不允许直接访问内存中的位置，也就是说不能直接操作对象的内存空间，那我们操作啥呢？ 实际上，是操作对象的引用，所以引用类型的值是按引用访问的。
准确地说，引用类型的存储需要内存的栈区和堆区（堆区是指内存里的堆内存）共同完成，栈区内存保存变量标识符和指向堆内存中该对象的指针，也可以说是该对象在堆内存的地址。
假如有以下几个对象：
var person1 = {name:'jozo'};
var person2 = {name:'xiaom'};
var person3 = {name:'xiaoq'};
则这三个对象的在内存中保存的情况如下图：
3.引用类型的比较是引用的比较
var person1 = '{}';
var person2 = '{}';
console.log(person1 == person2); // true
上面讲基本类型的比较的时候提到了当两个比较值的类型相同的时候，相当于是用 === ，所以输出是true了。再看看：
var person1 = {};
var person2 = {};
console.log(person1 == person2); // false
可能你已经看出破绽了，上面比较的是两个字符串，而下面比较的是两个对象，为什么长的一模一样的对象就不相等了呢？
别忘了，引用类型时按引用访问的，换句话说就是比较两个对象的堆内存中的地址是否相同，那很明显，person1和person2在堆内存中地址是不同的：
所以这两个是完全不同的对象，所以返回
5.简单赋值
在从一个变量向另一个变量赋值基本类型时，会在该变量上创建一个新值，然后再把该值复制到为新变量分配的位置上：
var a = 10;
console.log(a);
console.log(b);
此时，a中保存的值为 10 ，当使用 a 来初始化 b 时，b 中保存的值也为10，但b中的10与a中的是完全独立的，该值只是a中的值的一个副本，此后，这两个变量可以参加任何操作而相互不受影响。
也就是说基本类型在赋值操作后，两个变量是相互不受影响的。
6.对象引用
当从一个变量向另一个变量赋值引用类型的值时，同样也会将存储在变量中的对象的值复制一份放到为新变量分配的空间中。前面讲引用类型的时候提到，保存在变量中的是对象在堆内存中的地址，所以，与简单赋值不同，这个值的副本实际上是一个指针，而这个指针指向存储在堆内存的一个对象。那么赋值操作后，两个变量都保存了同一个对象地址，则这两个变量指向了同一个对象。因此，改变其中任何一个变量，都会相互影响：
var a = {};
a.name = 'jozo';
console.log(a.name);
console.log(b.name);
b.age = 22;
console.log(b.age);
console.log(a.age);
console.log(a == b);
它们的关系如下图：
因此，引用类型的赋值其实是对象保存在栈区地址指针的赋值，因此两个变量指向同一个对象，任何的操作都会相互影响。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：527629次
积分：8654
积分：8654
排名：第1568名
原创：287篇
转载：53篇
评论：169条
文章：54篇
阅读：197416
文章：18篇
阅读：19253
阅读：6671
阅读：9950
文章：11篇
阅读：11646
文章：37篇
阅读：74087
(5)(10)(29)(16)(9)(2)(15)(8)(23)(44)(38)(56)(8)(22)(16)(8)(6)(11)(8)(1)(5)(7)你是我的小呀小平果，怎么爱你都不嫌多_南昌90后吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0可签7级以上的吧50个
本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：23,504贴子：
你是我的小呀小平果，怎么爱你都不嫌多
随后会放制作过程
此帖对国内两位新生代男...
一年一届的中国金鸡百花...
@丨周慧敏丨 大声告诉...
【ID】腐海无涯不回头 ...
万众期待的第33届大众百...
　　日，乔...
其实我觉得学历也就只有...
先总结: 上世纪九十年代...
最近微微一笑很倾城出来...
据说还要打遍全中国的初...
贯彻一贯拆开了、嚼烂了...
除了星座血型，来聊点深刻的好吗？
这图文配的！
加入贴吧妹子团获得,
哈哈你好啊
普京说的真好南京死了30万人，除了是鬼子太残暴，还有就是国人太聪明 。要知道去杀30万只猪或狗，一不小心还会弄个工伤事故、感染死亡什么的，难道30万南京人真的是猪狗不如？一个台湾老兵、南京大屠杀的幸存者回忆那段历史时写道：我们可能永远不懂5个日本鬼子就可以押着2000人去屠杀！2000人，像猪一样任凭5个人屠杀，多么可怕的事情啊！虽然那5个日本兵有枪，也有刀，但是那2000人并没有被捆着，完全可以动手反抗。可是他们没有，据某个幸存者口述，他曾经怂恿其他人一起冲上去，可惜回应他的除了沉默，还是沉默。因为大家都是聪明人，他们明白虽然2000人肯拼命肯定能赢，但是第一个冲上去的肯定会死，所以他们聪明地独善其身，把希望寄托在有其他人第一个冲上去。可惜的是，大家都是聪明人，没有蠢材，所以他们就只能像猪一样任凭屠杀。虽然每一个人都是聪明人，但是聚在一起却只是一群聪明的猪而已！普京说：原不原谅恐怖分子是上帝的事，我的任务是送他们见上帝！云南昆明的暴行发生后，网上到处都是逃生技巧，自救举措。有文章教你第一诀窍是“不能激怒歹徒”！有人在教维语的“朋友，住手，自己人”……向暴徒乞求，和暴徒称朋道友，不可耻吗？我在想，这个社会是怎么了？这个国家是怎么了？难道没有人再崇尚英雄主义了？媒体也不再支持挺身而出了？先不说当晚昆明火车站有多少人，当我看到新闻上说一家餐馆里面躲了200多人的时候我想哭又想笑！10几个暴徒而已！拿的只是刀不是枪！只需要30个人操起桌椅冲出去！几把砍刀就可以让100多号人倒在血泊里？现在已经击毙的，加上抓了的，一共不过8个人，还有2个女的，没有枪，只有长刀，居然砍死29个，砍伤130个？他们还当场跑了5个？难道所有的人第一意识都是逃命？难道没有人站出来跟他们搏斗？有媒体提到，一个饭店老板娘救了200多人，讲到所有躲进小饭店的男人都不知所措。我想问，躲在女人庇护下发懵的男人们，不感到到悲哀吗？这一次是暴徒，如果是侵略者，是不是又要上演几个日本兵就可以屠杀一个村子的事情？我觉得，我们的教育需要反思，我们的媒体需要反思，所有媒体除了对恐怖分子的谴责就是对逝者的祈福，为什么不反思？我们的男人的血性都去哪儿了？最好的防守是进攻，以暴制暴！他的目标是砍死你，你跑是跑不掉的！你跑了，被砍死的肯定是跑不动的老弱病残！如果遇到这种事情，每个人都反抗呢？每个男人都拼死
贴吧热议榜
使用签名档&&
保存至快速回贴1312人阅读
JavaWeb（54）
在filter中可以得到代表用户请求和响应的request、response对象，因此在编程中可以使用Decorator(装饰器)模式对request、response对象进行包装，再把包装对象传给目标资源，从而实现一些特殊需求。
一、Decorator设计模式
1.1、Decorator设计模式介绍
　　当某个对象的方法不适应业务需求时，通常有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，代码如下：
package me.gacl.web.
import java.io.IOE
import javax.servlet.F
import javax.servlet.FilterC
import javax.servlet.FilterC
import javax.servlet.ServletE
import javax.servlet.ServletR
import javax.servlet.ServletR
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletRequestW
import javax.servlet.http.HttpServletR
*: CharacterEncodingFilter
*: 此过滤器用来解决解决get、post请求方式下的中文乱码问题
*: 孤傲苍狼
下午11:09:37
public class CharacterEncodingFilter implements Filter {
private FilterConfig filterConfig = null;
private String defaultCharset = "UTF-8";
public void doFilter(ServletRequest req, ServletResponse resp,
FilterChain chain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest)
HttpServletResponse response = (HttpServletResponse)
String charset = filterConfig.getInitParameter("charset");
if(charset==null){
charset = defaultC
request.setCharacterEncoding(charset);
response.setCharacterEncoding(charset);
response.setContentType("text/charset="+charset);
MyCharacterEncodingRequest requestWrapper = new MyCharacterEncodingRequest(request);
chain.doFilter(requestWrapper, response);
public void init(FilterConfig filterConfig) throws ServletException {
this.filterConfig = filterC
public void destroy() {
*: MyCharacterEncodingRequest
*: Servlet API中提供了一个request对象的Decorator设计模式的默认实现类HttpServletRequestWrapper,
* (HttpServletRequestWrapper类实现了request接口中的所有方法，但这些方法的内部实现都是仅仅调用了一下所包装的的 request对象的对应方法)
* 以避免用户在对request对象进行增强时需要实现request接口中的所有方法。
* 所以当需要增强request对象时，只需要写一个类继承HttpServletRequestWrapper类，然后在重写需要增强的方法即可
*: 孤傲苍狼
下午10:42:57
1.实现与被增强对象相同的接口
2、定义一个变量记住被增强对象
3、定义一个构造函数，接收被增强对象
4、覆盖需要增强的方法
5、对于不想增强的方法，直接调用被增强对象（目标对象）的方法
class MyCharacterEncodingRequest extends HttpServletRequestWrapper{
private HttpServletR
public MyCharacterEncodingRequest(HttpServletRequest request) {
super(request);
this.request =
public String getParameter(String name) {
String value= this.request.getParameter(name);
if(value==null){
return null;
if(!this.request.getMethod().equalsIgnoreCase("get")) {
value = new String(value.getBytes("ISO8859-1"),this.request.getCharacterEncoding());
}catch (Exception e) {
throw new RuntimeException(e);
　　在web.xml文件中配置CharacterEncodingFilter
&CharacterEncodingFilter&
&me.gacl.web.filter.CharacterEncodingFilter&
&CharacterEncodingFilter&
　　编写jsp测试页面，如下：
&%@ page language="java" pageEncoding="UTF-8"%&
&%--引入jstl标签库 --%&
&%@taglib uri="/jsp/jstl/core" prefix="c"%&
&!DOCTYPE HTML&
&使用字符过滤器解决解决get、post请求方式下的中文乱码问题&
&%--使用c:url标签构建url，构建好的url存储在servletDemo1变量中--%&
value="/servlet/ServletDemo1" scope="page" var="servletDemo1"&
&%--构建的url的附带的中文参数 ，参数名是：username，值是：孤傲苍狼--%&
name="username" value="孤傲苍狼"&&
&%--使用get的方式访问 --%&
href="${servletDemo1}"&超链接(get方式请求)&
&%--使用post方式提交表单 --%&
action="${pageContext.request.contextPath}/servlet/ServletDemo1" method="post"&
用户名： type="text" name="username" value="孤傲苍狼" /&
type="submit" value="post方式提交"&
　　编写处理用户请求的ServletDemo1
package me.gacl.web.
import java.io.IOE
import java.io.PrintW
import javax.servlet.ServletE
import javax.servlet.http.HttpS
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletR
public class ServletDemo1 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String username = request.getParameter("username");
String method = request.getMethod();
PrintWriter out = response.getWriter();
out.write("请求的方式："+method);
out.write("&br/&");
out.write("接收到的参数："+username);
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
　　测试结果如下：
　　从运行结果中可以看到，无论是get请求方式还是post请求方式，中文乱码问题都可以完美解决了。
2.2、使用Decorator模式包装request对象实现html标签转义功能
　　编写一个html转义过滤器，代码如下：
package me.gacl.web.
import java.io.IOE
import javax.servlet.F
import javax.servlet.FilterC
import javax.servlet.FilterC
import javax.servlet.ServletE
import javax.servlet.ServletR
import javax.servlet.ServletR
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletRequestW
import javax.servlet.http.HttpServletR
*: HtmlFilter
*: html转义过滤器
*: 孤傲苍狼
下午11:28:41
public class HtmlFilter implements Filter {
public void doFilter(ServletRequest req, ServletResponse resp,
FilterChain chain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest)
HttpServletResponse response = (HttpServletResponse)
MyHtmlRequest myrequest = new MyHtmlRequest(request);
chain.doFilter(myrequest, response);
public void destroy() {
public void init(FilterConfig filterConfig) throws ServletException {
*: MyHtmlRequest
*: 使用Decorator模式包装request对象，实现html标签转义功能
*: 孤傲苍狼
下午11:29:09
class MyHtmlRequest extends HttpServletRequestWrapper {
private HttpServletR
public MyHtmlRequest(HttpServletRequest request) {
super(request);
this.request =
public String getParameter(String name) {
String value = this.request.getParameter(name);
if (value == null) {
return null;
return filter(value);
*: 过滤内容中的html标签
*:孤傲苍狼
public String filter(String message) {
if (message == null){
return null;
char content[] = new char[message.length()];
message.getChars(0, message.length(), content, 0);
StringBuffer result = new StringBuffer(content.length + 50);
for (int i = 0; i & content. i++) {
switch (content[i]) {
result.append("&");
result.append("&");
result.append("&");
result.append("&");
result.append(content[i]);
return result.toString();
　　在web.xml文件中配置HtmlFilter
&HtmlFilter&
&me.gacl.web.filter.HtmlFilter&
&HtmlFilter&
　　编写jsp测试页面，如下：
&%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%&
&!DOCTYPE HTML&
&html过滤器测试&
action="${pageContext.request.contextPath}/servlet/ServletDemo2" method="post"&
rows="8" cols="70" name="message"&
type="text/javascript"&
while(true){
alert("死循环了，我会不停地弹出了");
href=""&访问博客园&
type="submit" value="发表"&
　　编写处理用户请求的ServletDemo2
package me.gacl.web.
import java.io.IOE
import javax.servlet.ServletE
import javax.servlet.http.HttpS
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletR
public class ServletDemo2 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String message = request.getParameter("message");
response.getWriter().write("您上次的留言是：&br/&" + message);
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
测试结果如下：
　　从运行结果中可以看到，所有的html标签都被转义输出了。
2.3、使用Decorator模式包装request对象实现敏感字符过滤功能
　　编写一个敏感字符过滤器，代码如下：
package me.gacl.web.
import java.io.BufferedR
import java.io.IOE
import java.io.InputS
import java.io.InputStreamR
import java.io.UnsupportedEncodingE
import java.util.ArrayL
import java.util.L
import javax.servlet.F
import javax.servlet.FilterC
import javax.servlet.FilterC
import javax.servlet.ServletE
import javax.servlet.ServletR
import javax.servlet.ServletR
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletRequestW
import javax.servlet.http.HttpServletR
*: DirtyFilter
*: 敏感词过滤器
*: 孤傲苍狼
上午10:43:11
public class DirtyFilter implements Filter {
private FilterConfig config = null;
public void init(FilterConfig filterConfig) throws ServletException {
this.config = filterC
public void doFilter(ServletRequest req, ServletResponse resp,
FilterChain chain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest)
HttpServletResponse response = (HttpServletResponse)
DirtyRequest dirtyrequest = new DirtyRequest(request);
chain.doFilter(dirtyrequest, response);
public void destroy() {
*: getDirtyWords
*: 获取敏感字符
*:孤傲苍狼
private List&String& getDirtyWords(){
List&String& dirtyWords = new ArrayList&String&();
String dirtyWordPath = config.getInitParameter("dirtyWord");
InputStream inputStream = config.getServletContext().getResourceAsStream(dirtyWordPath);
InputStreamReader is = null;
is = new InputStreamReader(inputStream,"UTF-8");
} catch (UnsupportedEncodingException e2) {
e2.printStackTrace();
BufferedReader reader = new BufferedReader(is);
while ((line = reader.readLine())!= null) {
dirtyWords.add(line);
} catch (IOException e) {
e.printStackTrace();
return dirtyW
*: DirtyRequest
*: 使用Decorator模式包装request对象，实现敏感字符过滤功能
*: 孤傲苍狼
上午11:56:35
class DirtyRequest extends HttpServletRequestWrapper{
private List&String& dirtyWords = getDirtyWords();
private HttpServletR
public DirtyRequest(HttpServletRequest request) {
super(request);
this.request =
public String getParameter(String name) {
String value = this.request.getParameter(name);
if(value==null){
return null;
for(String dirtyWord : dirtyWords){
if(value.contains(dirtyWord)){
System.out.println("内容中包含敏感词："+dirtyWord+"，将会被替换成****");
value = value.replace(dirtyWord, "****");
　　在web.xml文件中配置DirtyFilter
&DirtyFilter&
&me.gacl.web.filter.DirtyFilter&
&dirtyWord&
&/WEB-INF/DirtyWord.txt&
&DirtyFilter&
　　当用户填写的内容包含一些敏感字符时，在DirtyFilter过滤器中就会将这些敏感字符替换掉。
　　我们如果将上述的CharacterEncodingFilter、HtmlFilter、DirtyFilter这三个过滤器联合起来使用，那么就相当于是把request对象包装了3次，request对象的getParameter方法经过3次重写，使得getParameter方法的功能大大增强，可以同时解决中文乱码，html标签转义，敏感字符过滤这些需求。
　　在实际开发中完全可以将上述的三个过滤器合并成一个，让合并后的过滤器具有解决中文乱码，html标签转义，敏感字符过滤这些功能，例如：
package me.gacl.web.
import java.io.BufferedR
import java.io.IOE
import java.io.InputS
import java.io.InputStreamR
import java.io.UnsupportedEncodingE
import java.util.ArrayL
import java.util.L
import javax.servlet.F
import javax.servlet.FilterC
import javax.servlet.FilterC
import javax.servlet.ServletE
import javax.servlet.ServletR
import javax.servlet.ServletR
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletRequestW
import javax.servlet.http.HttpServletR
*: AdvancedFilter
*: 这个过滤器是用来解决中文乱码，转义内容中的html标签，过滤内容中的敏感字符的
*: 孤傲苍狼
下午6:17:37
public class AdvancedFilter implements Filter {
private FilterConfig filterConfig = null;
private String defaultCharset = "UTF-8";
public void init(FilterConfig filterConfig) throws ServletException {
this.filterConfig = filterC
public void doFilter(ServletRequest req, ServletResponse resp,
FilterChain chain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest)
HttpServletResponse response = (HttpServletResponse)
String charset = filterConfig.getInitParameter("charset");
if(charset==null){
charset = defaultC
request.setCharacterEncoding(charset);
response.setCharacterEncoding(charset);
response.setContentType("text/charset="+charset);
AdvancedRequest requestWrapper = new AdvancedRequest(request);
chain.doFilter(requestWrapper, response);
public void destroy() {
class AdvancedRequest extends HttpServletRequestWrapper{
private List&String& dirtyWords = getDirtyWords();
private HttpServletR
public AdvancedRequest(HttpServletRequest request) {
super(request);
this.request =
public String getParameter(String name) {
String value= this.request.getParameter(name);
if(value==null){
return null;
if(!this.request.getMethod().equalsIgnoreCase("get")) {
value= filter(value);
value = new String(value.getBytes("ISO8859-1"),this.request.getCharacterEncoding());
value= filter(value);
for(String dirtyWord : dirtyWords){
if(value.contains(dirtyWord)){
System.out.println("内容中包含敏感词："+dirtyWord+"，将会被替换成****");
value = value.replace(dirtyWord, "****");
}catch (Exception e) {
throw new RuntimeException(e);
*: 过滤内容中的html标签
*:孤傲苍狼
public String filter(String value) {
if (value == null){
return null;
char content[] = new char[value.length()];
value.getChars(0, value.length(), content, 0);
StringBuffer result = new StringBuffer(content.length + 50);
for (int i = 0; i & content. i++) {
switch (content[i]) {
result.append("&");
result.append("&");
result.append("&");
result.append("&");
result.append(content[i]);
return (result.toString());
*: getDirtyWords
*: 获取敏感字符
*:孤傲苍狼
private List&String& getDirtyWords(){
List&String& dirtyWords = new ArrayList&String&();
String dirtyWordPath = filterConfig.getInitParameter("dirtyWord");
InputStream inputStream = filterConfig.getServletContext().getResourceAsStream(dirtyWordPath);
InputStreamReader is = null;
is = new InputStreamReader(inputStream,defaultCharset);
} catch (UnsupportedEncodingException e2) {
e2.printStackTrace();
BufferedReader reader = new BufferedReader(is);
while ((line = reader.readLine())!= null) {
dirtyWords.add(line);
} catch (IOException e) {
e.printStackTrace();
return dirtyW
　　在web.xml文件中配置AdvancedFilter
&filter-name&AdvancedFilter&/filter-name&
&filter-class&me.gacl.web.filter.AdvancedFilter&/filter-class&
&init-param&
&param-name&charset&/param-name&
&param-value&UTF-8&/param-value&
&/init-param&
&init-param&
&param-name&dirtyWord&/param-name&
&param-value&/WEB-INF/DirtyWord.txt&/param-value&
&/init-param&
&filter-mapping&
&filter-name&AdvancedFilter&/filter-name&
&url-pattern&
　　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对数据进行压缩后再写出给浏览器，以此完成响应正文件压缩功能。
　　编写压缩过滤器，代码如下：
package me.gacl.web.
import java.io.ByteArrayOutputS
import java.io.IOE
import java.io.OutputStreamW
import java.io.PrintW
import java.util.zip.GZIPOutputS
import javax.servlet.F
import javax.servlet.FilterC
import javax.servlet.FilterC
import javax.servlet.ServletE
import javax.servlet.ServletOutputS
import javax.servlet.ServletR
import javax.servlet.ServletR
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletResponseW
*: GzipFilter
*: 压缩过滤器，将web应用中的文本都经过压缩后再输出到浏览器
*: 孤傲苍狼
上午10:52:42
public class GzipFilter implements Filter {
public void doFilter(ServletRequest req, ServletResponse resp,
FilterChain chain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest)
HttpServletResponse response = (HttpServletResponse)
BufferResponse myresponse = new BufferResponse(response);
chain.doFilter(request, myresponse);
byte out[] = myresponse.getBuffer();
System.out.println("原始大小:" + out.length);
ByteArrayOutputStream bout = new ByteArrayOutputStream();
GZIPOutputStream gout = new GZIPOutputStream(bout);
gout.write(out);
gout.close();
byte gzip[] = bout.toByteArray();
System.out.println("压缩后的大小:" + gzip.length);
response.setHeader("content-encoding", "gzip");
response.setContentLength(gzip.length);
response.getOutputStream().write(gzip);
public void destroy() {
public void init(FilterConfig filterConfig) throws ServletException {
class BufferResponse extends HttpServletResponseWrapper{
private ByteArrayOutputStream bout = new ByteArrayOutputStream();
private PrintW
private HttpServletR
public BufferResponse(HttpServletResponse response) {
super(response);
this.response =
public ServletOutputStream getOutputStream() throws IOException {
return new MyServletOutputStream(bout);
public PrintWriter getWriter() throws IOException {
pw = new PrintWriter(new OutputStreamWriter(bout,this.response.getCharacterEncoding()));
public byte[] getBuffer(){
if(pw!=null){
pw.close();
if(bout!=null){
bout.flush();
return bout.toByteArray();
return null;
}catch (Exception e) {
throw new RuntimeException(e);
class MyServletOutputStream extends ServletOutputStream{
private ByteArrayOutputS
public MyServletOutputStream(ByteArrayOutputStream bout){
this.bout =
public void write(int b) throws IOException {
this.bout.write(b);
　　在web.xml中配置压缩过滤器
&配置压缩过滤器&
&GzipFilter&
&me.gacl.web.filter.GzipFilter&
&GzipFilter&
&GzipFilter&
&GzipFilter&
&GzipFilter&
3.2、response增强案例——缓存数据到内存
　　对于页面中很少更新的数据，例如商品分类，为避免每次都要从数据库查询分类数据，因此可把分类数据缓存在内存或文件中，以此来减轻数据库压力，提高系统响应速度。
　　编写缓存数据的过滤器，代码如下：
package me.gacl.web.
import java.io.ByteArrayOutputS
import java.io.IOE
import java.io.OutputStreamW
import java.io.PrintW
import java.util.HashM
import java.util.M
import javax.servlet.F
import javax.servlet.FilterC
import javax.servlet.FilterC
import javax.servlet.ServletE
import javax.servlet.ServletOutputS
import javax.servlet.ServletR
import javax.servlet.ServletR
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletResponseW
*: WebResourceCachedFilter
*: Web资源缓存过滤器
*: 孤傲苍狼
上午12:20:16
public class WebResourceCachedFilter implements Filter {
缓存Web资源的Map容器
private Map&String,byte[]& map = new HashMap&String,byte[]&();
public void init(FilterConfig filterConfig) throws ServletException {
public void doFilter(ServletRequest req, ServletResponse resp,
FilterChain chain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest)
HttpServletResponse response = (HttpServletResponse)
String uri = request.getRequestURI();
byte b[] = map.get(uri);
if(b!=null){
String webResourceHtmlStr = new String(b,response.getCharacterEncoding());
System.out.println(webResourceHtmlStr);
response.getOutputStream().write(b);
BufferResponse myresponse = new BufferResponse(response);
chain.doFilter(request, myresponse);
byte out[] = myresponse.getBuffer();
map.put(uri, out);
response.getOutputStream().write(out);
public void destroy() {
class BufferResponse extends HttpServletResponseWrapper{
private ByteArrayOutputStream bout = new ByteArrayOutputStream();
private PrintW
private HttpServletR
public BufferResponse(HttpServletResponse response) {
super(response);
this.response =
public ServletOutputStream getOutputStream() throws IOException {
return new MyServletOutputStream(bout);
public PrintWriter getWriter() throws IOException {
pw = new PrintWriter(new OutputStreamWriter(bout,this.response.getCharacterEncoding()));
public byte[] getBuffer(){
if(pw!=null){
pw.close();
return bout.toByteArray();
}catch (Exception e) {
throw new RuntimeException(e);
class MyServletOutputStream extends ServletOutputStream{
private ByteArrayOutputS
public MyServletOutputStream(ByteArrayOutputStream bout){
this.bout =
public void write(int b) throws IOException {
bout.write(b);
　　在web.xml中配置Web资源缓存过滤器
&Web资源缓存过滤器&
&WebResourceCachedFilter&
&me.gacl.web.filter.WebResourceCachedFilter&
&WebResourceCachedFilter&
&/login.jsp&
&/test.jsp&
&/test2.jsp&
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：527631次
积分：8654
积分：8654
排名：第1568名
原创：287篇
转载：53篇
评论：169条
文章：54篇
阅读：197416
文章：18篇
阅读：19253
阅读：6671
阅读：9950
文章：11篇
阅读：11646
文章：37篇
阅读：74087
(5)(10)(29)(16)(9)(2)(15)(8)(23)(44)(38)(56)(8)(22)(16)(8)(6)(11)(8)(1)(5)(7)