窥探：属性HttpResponse.Filter和方法 HttpResponse.SwitchWriter

于 2019-09-25 00:47:01 发布
阅读量213 收藏
点赞数
文章标签： 测试
原文链接：http://www.cnblogs.com/buaaboyi/archive/2011/08/18/2144820.html
版权

　　wap站由于浏览器的原因，只能依赖url来做用户标识了，如此我们就必须对输出页面中的url做处理了。就是说要截住response的内容，然后对其进行处理。

　　

　　首先来看段源码：

     internal  TextWriter SwitchWriter(TextWriter writer)
    {
        TextWriter writer2  =   this ._writer;
         this ._writer  =  writer;
         return  writer2;
    }

　　原来的代码里用此方法来替换HttpResponse的输出对象。留意了，是替换，把原有的替换了。接下来看看原有的writer是什么东东。

　　

 

　　

     internal   void  InitResponseWriter()
    {
         if  ( this ._httpWriter  ==   null )
        {
             this ._httpWriter  =   new  HttpWriter( this );
             this ._writer  =   this ._httpWriter;
        }
    }

默认情况writer的东东都写到httpwriter里面去了。

HttpResponse.Writer:

     public   void  Write( char  ch)
    {
         this ._writer.Write(ch);
    }

注：SwitchWriter的方法返回的是老的response._writer的对象，如果咱们在输出前通过SwithchiWriter获取默认的_htppWriter对象来进行处理的话，我们得到的只能是空串，原因是httpWriter对象默认直接将流输出到客户端了。

所以原来的代码调用了2次SwitchWriter，在OnActionExecuting中把默认的_htppWriter用HtmlTextWriter的实例替换掉，待action执行完成，再在OnResultExecuted中再一次调用SwitchWriter将先前替换进去的对象取出来。（不明白，再看看SwitchWriter的定义）。

SwitchWriter方法是internal的，我们只能靠反射干它了。

哈哈，其实现在的实现也挺好。问题出现在有bug的时候，什么叫有bug的时候就有问题，岂不是废话，有bug当然有问题了，呵，别着急，慢慢来。

在MVC中，如果咱们自己写的Action代码出现了异常，其是不会走OnResultExecuted事件的，直接跳转到OnException 里去处理了，也就是要想把Resopnse 对应的输出去出来，让程序员看到“黄页”那还得在OnException里去进行一次SwitchWriter来取错误信息。也罢也罢。关键也不知道写着代码的人知道其中逻辑，目前OnException只做了跳转，“黄页”永远都告别了程序员和用户。“黄页”对debug来说有多重要就不说了。

　　因为这个问题，我们不得不想起HttpResponse.Filter。

     public  Stream Filter
    {
         get
        {
             if  ( this .UsingHttpWriter)
            {
                 return   this ._httpWriter.GetCurrentFilter();
            }
             return   null ;
        }
         set
        {
             if  ( ! this .UsingHttpWriter)
            {
                 throw   new  HttpException(SR.GetString( " Filtering_not_allowed " ));
            }
             this ._httpWriter.InstallFilter(value);
            IIS7WorkerRequest request  =   this ._wr  as  IIS7WorkerRequest;
             if  (request  !=   null )
            {
                request.ResponseFilterInstalled();
            }
        }
    }

看到这里应该知道为啥人家把SwitchWriter方法给internal起来了。

 

     internal   void  InstallFilter(Stream filter)
    {
         if  ( this ._filterSink  ==   null )
        {
             throw   new  HttpException(SR.GetString( " Invalid_response_filter " ));
        }
         this ._installedFilter  =  filter;
    }

 

算看出来了，filter的功能是HttpWriter 提供的filter方法实现的：

 

     internal   void  Filter( bool  finalFiltering)
    {
         if  ( this ._installedFilter  !=   null )
        {
             if  ( this ._charBufferLength  !=   this ._charBufferFree)
            {
                 this .FlushCharBuffer( true );
            }
             this ._lastBuffer  =   null ;
             if  ( this ._buffers.Count  !=   0 )
            {
                ArrayList list  =   this ._buffers;
                 this ._buffers  =   new  ArrayList();
                 this ._filterSink.Filtering  =   true ;
                 try
                {
                     int  count  =  list.Count;
                     for  ( int  i  =   0 ; i  <  count; i ++ )
                    {
                        IHttpResponseElement element  =  (IHttpResponseElement) list[i];
                         long  size  =  element.GetSize();
                         if  (size  >   0L )
                        {
                             this ._installedFilter.Write(element.GetBytes(),  0 , Convert.ToInt32(size));
                        }
                    }
                     this ._installedFilter.Flush();
                }
                 finally
                {
                     try
                    {
                         if  (finalFiltering)
                        {
                             this ._installedFilter.Close();
                        }
                    }
                     finally
                    {
                         this ._filterSink.Filtering  =   false ;
                    }
                }
            }
        }
    }

　　filter在输出前做过滤筛选，方便。

　　有一个不太好的地方是，MS公布出来个Stream类型的filter，很不让人好理解。强烈要求放出个delegate，意思明了多了。

 

 想起来了，之前在action里面用 Response.End();返回的却是空的页面。

那就再偷窥下end方法。我们在actionexcuting中用SwithWrite方法把 默认的httpwriter换成了TextWriter的实例，我们来看看End方法。

 

     public   void  End()
    {
         if  ( this ._context.IsInCancellablePeriod)
        {
            InternalSecurityPermissions.ControlThread.Assert();
            Thread.CurrentThread.Abort( new  HttpApplication.CancelModuleException( false ));
        }
         else   if  ( ! this ._flushing)
        {
             this .Flush();
             this ._ended  =   true ;
             if  ( this ._context.ApplicationInstance  !=   null )
            {
                 this ._context.ApplicationInstance.CompleteRequest();
            }
        }
    }

我们发现，我们得跟Flush()方法。

 

     public   void  Flush()
    {
         if  ( this ._completed)
        {
             throw   new  HttpException(SR.GetString( " Cannot_flush_completed_response " ));
        }
         this .Flush( false );
    }

     private   void  Flush( bool  finalFlush)
    {
         if  ( ! this ._completed  &&   ! this ._flushing)
        {
             if  ( this ._httpWriter  ==   null )
            {
                 this ._writer.Flush();
            }
             else
            {
                 this ._flushing  =   true ;
                 try
                {
                    IIS7WorkerRequest request  =   this ._wr  as  IIS7WorkerRequest;
                     if  (request  !=   null )
                    {
                         this .GenerateResponseHeadersForHandler();
                         this .UpdateNativeResponse( true );
                        request.ExplicitFlush();
                         this ._headersWritten  =   true ;
                    }
                     else
                    {
                         long  contentLength  =   0L ;
                         if  ( ! this ._headersWritten)
                        {
                             if  ( ! this ._suppressHeaders  &&   ! this ._clientDisconnected)
                            {
                                 if  (finalFlush)
                                {
                                    contentLength  =   this ._httpWriter.GetBufferedLength();
                                     if  (( ! this ._contentLengthSet  &&  (contentLength  ==   0L ))  &&  ( this ._httpWriter  !=   null ))
                                    {
                                         this ._contentType  =   null ;
                                    }
                                     if  ((( this ._cachePolicy  !=   null )  &&  ( this ._cookies  !=   null ))  &&  ( this ._cookies.Count  !=   0 ))
                                    {
                                         this ._cachePolicy.SetHasSetCookieHeader();
                                         this .DisableKernelCache();
                                    }
                                     this .WriteHeaders();
                                    contentLength  =   this ._httpWriter.GetBufferedLength();
                                     if  ( ! this ._contentLengthSet  &&  ( this ._statusCode  !=   0x130 ))
                                    {
                                         this ._wr.SendCalculatedContentLength(contentLength);
                                    }
                                }
                                 else
                                {
                                     if  (( ! this ._contentLengthSet  &&   ! this ._transferEncodingSet)  &&  ( this ._statusCode  ==   200 ))
                                    {
                                         string  httpVersion  =   this ._wr.GetHttpVersion();
                                         if  ((httpVersion  !=   null )  &&  httpVersion.Equals( " HTTP/1.1 " ))
                                        {
                                             this .AppendHeader( new  HttpResponseHeader( 6 ,  " chunked " ));
                                             this ._chunked  =   true ;
                                        }
                                        contentLength  =   this ._httpWriter.GetBufferedLength();
                                    }
                                     this .WriteHeaders();
                                }
                            }
                             this ._headersWritten  =   true ;
                        }
                         else
                        {
                            contentLength  =   this ._httpWriter.GetBufferedLength();
                        }
                         if  ( ! this ._filteringCompleted)
                        {
                             this ._httpWriter.Filter( false );
                            contentLength  =   this ._httpWriter.GetBufferedLength();
                        }
                         if  (( ! this ._suppressContentSet  &&  ( this .Request  !=   null ))  &&  ( this .Request.HttpVerb  ==  HttpVerb.HEAD))
                        {
                             this ._suppressContent  =   true ;
                        }
                         if  ( this ._suppressContent  ||   this ._ended)
                        {
                             this ._httpWriter.ClearBuffers();
                            contentLength  =   0L ;
                        }
                         if  ( ! this ._clientDisconnected)
                        {
                             if  (( this ._context  !=   null )  &&  ( this ._context.ApplicationInstance  !=   null ))
                            {
                                 this ._context.ApplicationInstance.RaiseOnPreSendRequestContent();
                            }
                             if  ( this ._chunked)
                            {
                                 if  (contentLength  >   0L )
                                {
                                     byte [] bytes  =  Encoding.ASCII.GetBytes(Convert.ToString(contentLength,  0x10 )  +   " \r\n " );
                                     this ._wr.SendResponseFromMemory(bytes, bytes.Length);
                                     this ._httpWriter.Send( this ._wr);
                                     this ._wr.SendResponseFromMemory(s_chunkSuffix, s_chunkSuffix.Length);
                                }
                                 if  (finalFlush)
                                {
                                     this ._wr.SendResponseFromMemory(s_chunkEnd, s_chunkEnd.Length);
                                }
                            }
                             else
                            {
                                 this ._httpWriter.Send( this ._wr);
                            }
                             this ._wr.FlushResponse(finalFlush);
                             this ._wr.UpdateResponseCounters(finalFlush, ( int ) contentLength);
                             if  ( ! finalFlush)
                            {
                                 this ._httpWriter.ClearBuffers();
                            }
                        }
                    }
                }
                 finally
                {
                     this ._flushing  =   false ;
                     if  (finalFlush)
                    {
                         this ._completed  =   true ;
                    }
                }
            }
        }
    }

 

 这才发现，这个end 依赖于_writer的法律flush方法，而TextWrter的实现是：

 

[MethodImpl(MethodImplOptions.Synchronized)]
 public   override   void  Flush()
{
     this ._out.Flush();
}

 

 

所以，默认情况下end方法依赖于默认的httpwriter的flush实现，或者自己重写textwriter的flush方法。

 

转载于:https://www.cnblogs.com/buaaboyi/archive/2011/08/18/2144820.html

diaoxiangsi1087
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Filter 处理 request 和 response
V_Junk的博客
11-30 1070
Filter 处理 request 和 response 背景：在 Filter 根据请求参数，判断用户登陆是否有效。后来是想就请求参数和返回值之间的关系做一个缓存。至于为什么不用 Spring … 因为公司不用。所以项目都是 Servlet + Filter … session： 关于这个，有必要提一下：所谓的 session 失效是在一定时间内没有 session 活动，然后 sess...
node.js中的http.response.end方法使用说明
01-02
方法说明： 结束响应，告诉客户端所有消息已经发送。当所有要返回的内容发送完毕时，该函数必须被调用一次。 如何不调用该函数，客户端将永远处于等待状态。 语法： 代码如下: response.end([data], [encoding]) ...
HttpResponse.Filter
weixin_30909575的博客
07-15 629
MSDN：获取或设置一个包装筛选器对象，该对象用于在传输之前修改 HTTP 实体主体。 这个的关键在于实现筛选器对像，查看Filter接受的类型是Stream。所以可以自定义一个Stream类，当创建 Stream 对象并将 Filter 属性设置为 Stream 对象时，所有发送的 HTTP 输出将通过筛选器。 自定义Stream类 public class ChangeStrea...
Response.Filter属性：网站内容的GZIP压缩
weixin_30372371的博客
05-22 113
Response.Filter属性：在数据发送出去前通过绑定的Filter来修改HTTP实体数据 应用场景（网站内容的GZIP压缩，多语言实现等等。。。） 定义：public Stream Filter{get;set;} 例如，实现网页压缩传输： string str = Request.Headers.Get("Accept-Encoding"); if (str !=...
使用 HttpResponse.Filter 实现简繁/繁简转换
orain的专栏
12-13 2553
HttpResponse.Filter 属性，类似于 HttpRequest.Filter（参见使用 HttpRequest.Filter 来过滤或转换 Http 输入流），只不过一个是出口，一个是入口（想像一下停车场），在这两个点之间的数据由服务器端处理，在这两点之外的，则由用户浏览器处理。那么，在出口处能做些什么呢？当然是对数据进行一些统一的处理，比如说简繁转换、过滤非法词汇等等。在这里说
自定义HttpResponse的Filter修改Http Entity Body
weixin_33989780的博客
08-11 245
HttpResponse的Filter属性允许开发人员定义一个派生于Stream的类型，修改Http Entity Body。比如原来的Web应用程序并没有添加兼容性标记，许多页面也并没有使用Master，各处修改增加了许多工作量。编写一个HttpModule，在Init函数中订阅HttpApplication的ReleaseRequestState事件。 1 // &lt;summary&...
python 零基础学习篇python课程django框架django请求和响应16 HttpResponse .mp4
04-21
python 零基础学习篇
Python开发工程师学会用 Django 框架实现功能：理解 HTTP.zip
05-21
在IT行业中，Python是一种广泛应用的高级编程语言，尤其在Web开发领域，Django框架因其高效、安全和可扩展性而备受推崇。本压缩包“Python开发工程师学会用 Django 框架实现功能：理解 HTTP.zip”显然是为了帮助...
Django的HttpRequest和HttpResponse对象详解
09-20
了解这两个对象的工作原理和属性能够帮助开发者更好地控制Web应用程序的行为。 #### 二、HttpRequest对象 `HttpRequest`对象代表了一个HTTP请求，它包含了用户的请求数据以及元数据。当用户发起请求时，Django会...
asp.net mvc 下使用 HttpResponse.Filter
weixin_30954607的博客
04-11 71
HttpResponse 的 Filter 属性是一个 Stream，通过重写这个流的方法，可以对 response 对象的输出进行修改。自定义 filter 时，如果直接从 Stream 派生新类，则必须要实现 Stream 的全部抽象方法，而实际应用中，只有 Write 方法才是创建过滤器时最关心的。这里的 HttpResponseFilter抽象类可以提供一点方便。 /// &...
使用Response.Filter过滤非法词汇
菜菜专栏
03-11 1756
    一般信息发布网站，论坛等均具有实现非法词汇过滤功能，即当用户录入非法词汇时，进行替换，使其无法显示到页面上，针对此种功能，通常采用的时，在读取时，在读到非法词汇后，进行替换。这样做的好处是不用将非法词汇存入数据库，缺点是要在每次读取时都要进行替换。另一种解决方案是在输出时过滤掉非常词汇，优点是只要写一次就好了，可以过滤整站的非法词汇，缺点是，非法词汇仍然存入到了数据库中，呵呵，大家
使用Response.Filter 过滤非法词汇
ygyangguang的专栏
03-05 553
使用Response.Filter 过滤非法词汇 一般信息发布网站，论坛等均具有实现非法词汇过滤功能，即当用户录入非法词汇时，进行替换，使其无法显示到页面上，针对此种功能，通常采用的时，在读取时，在读到非法词汇后，进行替换。另一种解决方案是在输出时过滤掉非常词汇，优点是只要写一次就好了，可以过滤整站的非法词汇，缺点是，非法词汇仍然存入到了数据库中，呵呵，大家可以有针对性的选择，本例用的是后
HttpResponse的Output与OutputStream、Filter关系
dz45693的专栏
05-05 5713
在网上经常看见有这样的代码   HttpResponse response = HttpContext.Current.Response;                 response.Filter = new PageFilter(response.Filter); 来拦截输出流，自己也做个类似的东东，如asp.net中 js 合并 压缩，现在我也来说说这几个东东是什么吧，需要大家对a
java使用Filter过滤器对Response返回值进行修改
热门推荐
Gogym的博客
08-18 4万+
有时候在开发过程中会有这样一个场景，有时需要对返回的数据进行处理。比如加密啊，添加某些标记啊等等。这种情况我们可以通过过滤器去处理。 过滤器是什么就不介绍了，百度一下，你就知道。 看看代码吧： 返回值输出代理类：这个类主要是为了吧Response里面的返回值获取到，因为直接Response没有提供直接拿到返回值的方法。所以要通过代理来取得返回值 package co
使用Filter包装response修改响应内容
岁月静好
10-12 2万+
关键是要重写response和PirntWriter（或者OutputStream） 重写PirntWriter：package com.xs.servlet.changeresponse; import java.io.PrintWriter; import java.io.Writer; public class MyWriter extends PrintWriter{ privat
在过滤器Filter中获取Response中的内容
binlixia的博客
02-16 1万+
第一步：创建一个类继承PrintWriter package demo; import java.io.PrintWriter; import java.io.Writer; public class MyWriter extends PrintWriter{     private StringBuilder buffer;     public MyWriter(Wri
HttpResponse.getFirstHeader与HttpResponse.getHeaders的区别
最新发布
07-24
`HttpResponse.getFirstHeader` 方法用于获取响应中指定名称的第一个头部信息。 `HttpResponse.getHeaders` 方法用于获取响应中指定名称的所有头部信息。 区别在于 `getFirstHeader` 方法只返回指定名称的第一个头部信息，而 `getHeaders` 方法返回一个 Header 数组，其中包含了所有指定名称的头部信息。如果指定名称的头部信息不存在，`getFirstHeader` 方法会返回 null，而 `getHeaders` 方法会返回一个空的 Header 数组。 需要注意的是，即使 `getHeaders` 方法返回了多个头部信息，仍然可以使用 `getFirstHeader` 方法来获取第一个头部信息。但如果需要获取所有的头部信息，应该使用 `getHeaders` 方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值