Vimos em vários lugares como o ASP cria ou modifica os cabeçalhos HTTP que são enviados ao cliente em resposta às solicitações de página. Existem diversas propriedades e métodos no objeto Response que podem nos ajudar a fazer isso. Aqui estão alguns métodos de cabeçalho:
· Controle de cache e expiração.
· Crie status e cabeçalhos HTTP personalizados.
· Especifique o tipo MIME ou tipo de conteúdo.
· Adicione tags PICS.
Cada um desses aspectos será brevemente examinado a seguir. Você pode verificar as propriedades e métodos dos quais estamos falando clicando no nome da propriedade relevante ou no nome do método na página inicial do "Objeto de Resposta" (show_response.asp).
1. Armazenando em cache e "expirando" páginas da Web ASP
Os navegadores dos usuários, bem como qualquer servidor proxy entre eles e o servidor, podem armazenar em cache HTML e páginas da Web criadas com ASP. Quando o usuário solicita a página posteriormente, o navegador envia uma solicitação de "última modificação" ao servidor (usando um cabeçalho HTTP_IF_MODIFIED_SINCE contendo a data da versão em cache) para perguntar se a página foi modificada.
Se não tiver sido modificado, o servidor deverá responder com um código de status e a mensagem “304 Not Modified” e o navegador usará o conteúdo em cache sem baixar uma cópia pela rede. Se já existir uma versão modificada, ela será enviada junto com o código de status e a mensagem "200 OK".
1) Atributo Response.CacheContol
Outros fatores também afetarão este processo de processamento. No entanto, qualquer servidor proxy dentro da rota de rede usada pela página da web (geralmente localizada no lado do cliente) pode ser impedido de armazenar a página da web em cache definindo a propriedade Response.CacheControl como Private. No ASP 3.0, esse é o padrão para páginas da Web ASP e não precisa ser definido. Mas é especialmente útil quando uma página da web é personalizada especificamente para visitantes individuais. Isso evita que outros usuários da mesma rede acessem a mesma página. Quando o valor do atributo CacheControl é definido como Público, o servidor tem permissão para armazenar páginas da web em cache. Observe que alguns servidores proxy podem se comportar de maneira diferente e ignorar ou ignorar esse cabeçalho.
No IE4, é possível receber uma mensagem falsa "Esta página expirou" quando o cache do servidor proxy está disponível. Fornecemos uma página web (expiretest_form.asp) que pode ser testada na rede através do seu próprio servidor proxy para verificar o impacto deste atributo. Esta página pode ser exibida clicando no link "Response. CacheControl" na página inicial "Response Object". Conforme mostrado na figura abaixo:
Quando esta página é enviada para a página expiratest_result.asp, a propriedade Response.CacheControl pode ser definida e, em seguida, o valor e a hora em que o script é executado são inseridos na página web:
<%
Se Request.Form(“public”) = “on” Então a caixa de seleção 'Cache-Control foi marcada
Response.CacheControl = "Público"
Outro
Response.CacheControl = "Privado"
Terminar se
%>
<HTML>
...
O controle de cache é: ＜B＞＜% = Response.CacheControl %＞＜/B＞＜P＞
O valor na caixa de texto é: ＜B＞＜% Response.Write Request.Form(“caixa de texto”) %＞
<%
Response.Write Right (“0” & Hora (Agora), 2) & “:” & Right (“0” & Minuto (Agora),_
& 2) & “:” & Direita (“0” & Segundo (Agora),2)
%＞＜/B＞
Ao clicar em "Voltar" e "Avançar" no navegador, você pode ver se o código é executado automaticamente ou usa uma cópia em cache.
2) Propriedades Response.Expires e Response.ExpiresAbsolute
As duas propriedades que controlam o tempo de armazenamento de páginas da web em cache são as propriedades Expires e ExpriesAbsolute do objeto Response. Response.Expires define o período de tempo, expresso em minutos desde a criação, que uma página deve permanecer válida antes de ser descartada do cache. O atributo ExpiresAbsolute define uma data e hora absolutas para expiração.
Fornecemos um exemplo de página da Web chamada addheaders_form.asp para demonstrar como usar esses atributos. Clique no link para ambas as propriedades na página inicial do Objeto de Resposta.
Na página resultante, você pode adicionar seus próprios cabeçalhos HTTP personalizados e definir vários atributos dos cabeçalhos HTTP que afetam a resposta. Quando o botão "Enviar conteúdo da consulta" é clicado, a página show_headers.asp adiciona os cabeçalhos selecionados ao fluxo de dados retornado e então exibe o código usado para fazer isso, exibindo o tempo de execução correspondente, que pode ser usado para verificar se a página was O cache ainda é executado novamente.
O código na página da web show_headers.asp cria e adiciona cabeçalhos HTTP. O procedimento é o seguinte:
<%.
'Escreve cabeçalhos HTTP antes de qualquer outra saída
Se Request.Form(“expira”) = “on” Então _
Response.Expires = Request.Form("expires_value")
Se Request.Form(“expiresabs”) = “on” Então _
Response.ExpiresAbsolute = Request.Form("expiresabs_value")
Se Request.Form("lastmod") = "on" Então _
Response.AddHeader “ÚLTIMA MODIFICAÇÃO”, Cstr(Request.Form(“lastmod_value”))
Se Request.Form(“pragma”) = “on” Então _
Response.AddHeader “PRAGMA”, CStr(Request.Form(“pragma_value”))
Se Request.Form("atualizar") = "on" Então _
Response.AddHeader “REFRESH”, CStr(Request.Form(“refresh_value”))
Se Request.Form(“addheader”) = “on” And Len(Request.Form(“addheader_name”)) Então _
Response.AddHeader CStr(Request.Form(“addheader_name”)), _
CStr(Request.Form(“addheader_value”))
Se Request.Form("status") = "on" Então _
Response.Status = Request.Form("status_value")
%>
<HTML>
...
...Mostrar código e tempo de execução
...
o resto mostra apenas o código que foi executado e quando foi executado. Os leitores notarão o cabeçalho personalizado “PRAGMA” incluído na página web (que não discutimos até agora). Alguns (antigos) servidores proxy usam isso como uma indicação se os discos da web devem ser armazenados em cache. O padrão é que as páginas sejam armazenadas em cache, a menos que o cabeçalho HTTP "PRAGMA=NO-CACHE" seja recebido.
2. Crie códigos de status e cabeçalhos HTTP personalizados
Você pode usar o método AddHeader do objeto Response que viu anteriormente na página da Web de exemplo para criar seus próprios códigos de status ou cabeçalhos personalizados de sua preferência. Este método requer dois parâmetros: o nome do cabeçalho HTTP ou uma string contendo seu valor ou o valor atribuído a ele. Como exemplo, o código a seguir adiciona um cabeçalho REFRESH à página:
Response.AddHeader "REFRESH", "60;URL=newpath/newpage.asp"
Isso é equivalente ao elemento <META> do lado do cliente:
<META HTTP- EQUIV=" REFRESH", "60;URL=newpath/newpage.asp">
Em outras palavras, você também pode usar o método AddHeader com o atributo Status para fazer o navegador carregar uma nova página:
Response.Status = "302 Object Moved "
Response.Addheader “Location”, “newpath/newpage.asp”
Isso é equivalente a usar o método Response.Redirect:
Response.Redirect “newpath/newpage.asp”
A propriedade Response.Status pode ser usada para enviar algumas mensagens de status necessárias, por exemplo, adicione as seguintes linhas:
Response.Status= “401 Unauthorized”
Response.Addheader “WWW-Authenticate”, “BASIC”
força o navegador a exibir uma caixa de diálogo de nome de usuário/senha e depois enviá-los de volta ao servidor usando autenticação BASIC (que serão abordados neste artigo. Consulte os métodos de verificação posteriormente na série).
3. Tipo MIME e tipo de conteúdo
Quando queremos enviar uma string criada dinamicamente para o navegador, e eles não indicam diretamente o tipo de conteúdo quando são fornecidos ao navegador, mas fornecem uma extensão indicando se é um arquivo de disco, Resposta .ContentType é muito útil. A menos que especificado de outra forma, todas as páginas da web criadas por ASP têm como padrão "texto/tipo". O identificador do tipo de conteúdo é o tipo MIME (MIME significa Multi-purpose Internet Multimedia Extension ou Multi-purpose Internet Mail Extension, geralmente dependendo do contexto).
Por exemplo, se a anotação de dados enviada ao cliente for uma imagem criada pela leitura de valores binários de um banco de dados, você precisará adicionar o cabeçalho CONTENT-TYPE apropriado antes de enviar qualquer conteúdo:
Response.ContentType = "image/jpeg"
If você cria uma imagem a partir de um banco de dados. Para arquivos XML, use o tipo MIEM "text/xml" e se você estiver criando um arquivo de texto que pode ser exibido em um editor de arquivos ou armazenado como um arquivo de disco no cliente, use "texto"; /texto".
4. Adicionando uma tag PICS
A propriedade Respnse.Pics simplesmente adiciona uma tag PICS (Platform for Internet Content system) à página da mesma forma que a tag <META> usual:
QUOT = Chr(34)
StrPicsLabel = “(PICS-1.0” & QUOT & “http://www.rsac.org/ratingsv01.html”_
& QUOT & “comentário verdadeiro de 1 geração “ & QUOT _
& “Servidor RSACi América do Norte” & QUOT & “ para “ & QUOT _
& “http://seusite.com” & QUOT & “em “ & QUOT _
& “1999.08.01T03:04-0500” & QUOT & “ r (n 0 s 0 v 2 l 3))”
Response.Pics(strPicsLabel)
Este código adiciona o seguinte rótulo PICS:
(PICS-1.0 “http://www.rsac.org/ratingsv01.html” 1 gen true comment “RSACi
Servidor da América do Norte” para “http://yoursite.com” em “1999.08.01T03:04-0500”
r (n 0 s 0 v 2 l 3))
Para obter mais informações sobre PICS ou para saber mais sobre como definir o conteúdo da página, pesquise no site http://www.rsac.org/ .
Definindo cabeçalhos no Internet Service Manager
Na primeira parte desta série de artigos, foi explicado como definir as propriedades de cada site e diretório do IIS 5.0 no aplicativo Internet Service Manage (plug-in MMC), que define o uso deste site ou recursos do diretório são enviados ao cliente nos cabeçalhos HTTP de todas as solicitações, fornecendo uma alternativa para definir essas propriedades usando código de script ASP em cada página da web.
Clique com o botão direito no site ou diretório e selecione "Propriedades". Na guia "Cabeçalhos HTTP" de sua caixa de diálogo, você pode definir a hora relativa ou a data absoluta para o período de validade do conteúdo da página, definir cabeçalhos personalizados e criar rótulos de nível de conteúdo PICS, os tipos de conteúdo também podem ser definidos por meio do mapeamento de tipo MIME.
Você pode ver que um cabeçalho HTTP REFRESH personalizado foi criado e aplicado a todas as páginas da web carregadas deste diretório. Ou seja, ele recarrega (atualiza) automaticamente a cada minuto (ideal para mostrar os últimos resultados de jogos de beisebol, mas é uma carga muito pesada no servidor).
Para adicionar mapeamentos de tipo de conteúdo personalizados na caixa “Mapa MIME”, basta clicar no botão “Tipos de arquivo” na caixa de diálogo principal “Propriedades” para adicioná-los à lista.
Ao começar a experimentar cabeçalhos HTTP, você descobrirá rapidamente que nem todos os navegadores se comportam da mesma forma e muitos navegadores respondem a diferentes cabeçalhos HTTP de maneiras diferentes, tornando às vezes extremamente difícil estabelecer com segurança um princípio geralmente aplicável.
2. Use certificados de cliente
Se você configurar um site seguro ou um site com uma parte segura de seu conteúdo, poderá instalar um certificado de servidor digital para autenticar o servidor, permitindo que os visitantes usem os detalhes criptografados no certificado. A cada solicitação de página ao site ou diretório, o servidor envia uma cópia do certificado, que o navegador pode examinar para determinar com quem está se comunicando.
Da mesma forma, o servidor também pode ser configurado para exigir que os usuários forneçam um certificado digital válido ao entrar no site. Eles podem obter este certificado de várias fontes, como Verisign ( http://www.verisign.com ) ou Thawte Consulting ( http://www.thawte.com ). O leitor verá os detalhes desse processo no Capítulo 25.
Todas essas situações usam os valores da coleção ClientCertificate do objeto Request. O código de exemplo neste capítulo inclui uma página que mostra como os usuários usam alguns dos métodos desses valores de coleção.
Esta página é chamada showcert.asp e tudo o que ela faz é percorrer a coleção ClientCertificate e exibir todos os valores que ela contém. Isso pode ser feito usando o mesmo código simples que você sempre usou antes, a única diferença é construir uma tabela HTML para armazenar os resultados e truncá-los em grupos de 60 caracteres.
＜TABEL CELLPADDING=0 CELLSPACING=0＞
<%
Para cada keyItem em Request.ClientCertificate()
StrItemValue = Request.ClientCertificate(keyItem)
Se Len(strItemValue) > 90 Então strItemValue = Left(strItemValue, 60) & “..etc.”
Resposta.Escreva “＜TR＞＜TD＞” & keyItem & “ = “ & strItemValue & “＜/TD＞＜/TR＞”
Próximo
%>
＜/TABLE＞
Usando o redirecionamento de certificado de cliente
Depois que todos os visitantes de um site ou parte de um site forem solicitados a fornecer seu certificado de cliente, as informações nele contidas poderão ser usadas para criar as páginas da Web que criamos para esse usuário. Por exemplo, você pode usar a entrada Organização do certificado para redirecioná-los automaticamente para uma parte específica do site e redirecionar outros visitantes para outro lugar:
If Request.ClientCertificate("SubjectO") = "Wrox Press Inc" Then
Response.Redirect "/wrox_staff/default.asp" 'Site da equipe Wrox
Outro
Response.Redirect "/public/Default.asp" 'Site público normal
End If
Consequentemente, a entrada País pode ser usada para redirecionar o visitante para um site correspondente:
Selecione Case Request.ClientCertificate("SubjectC")
Caso “Reino Unido”: Response.Redirect “http://uk_site.co.uk/”
Caso “DE”: Response.Redirect “http://de_site.co.de/”
Caso “FR”: Response.Redirect “http://fr_site.co.fr/”
'... ect.
Caso contrário: Response.Redirect “http://us_site.com/”
End Select
3. Lendo e gravando dados binários
Existem dois métodos que fornecem acesso de dados binários ao fluxo de dados HTTP enviado do navegador para o servidor e ao fluxo de dados retornado do servidor para o navegador. O método Request.BinaryRead pode obter um parâmetro que especifica o número de bytes a serem lidos e retornar um array do tipo variante que contém os bytes obtidos do segmento POST solicitado (como dados na coleção Form do ASP). O programa a seguir lê os primeiros 64 bytes de dados:
varContent = Request.BinaryRead(64)
Se você usar o método BinaryRead, não poderá acessar a coleção Request.Form do ASP no futuro. Da mesma forma, uma vez que fizermos referência à coleção Request.Form de alguma forma, não poderemos usar o método BinaryRead.
Também é possível gravar dados binários no fluxo de resposta criado pelo ASP, utilizando o método BinaryWrite. Você precisa fornecer uma matriz variante dos bytes que deseja gravar no cliente:
Response.BinaryWrite(varContent)
Esses métodos raramente são usados, a menos que você crie uma fonte não-HTML a partir de um banco de dados. Um exemplo de utilização é ler os bytes que compõem a imagem do banco de dados e enviá-la ao cliente através do método BinaryWrite.
4. Crie uma mensagem de log personalizada
Se o servidor estiver configurado para registrar solicitações em um arquivo de texto no formato de arquivo de log estendido W3C, você poderá usar o método Response.AppendToLog para adicionar uma sequência de mensagens ao final da entrada do arquivo de log. Este método é muito útil se você deseja armazenar alguns valores ou mensagens para uma página web específica, ou quando ocorre uma situação específica no script.
Por exemplo, por meio de um aplicativo de "pedido estacionário" da intranet, você pode registrar os números dos departamentos de funcionários que excedem um número específico de entradas:
...
Se intItemCount > 25 Então
Response.AppendToLog "Pedido grande de '" & strDept & departamento."
Terminar se
...
configurando o log estendido
Para usar o método AppendToLog, a configuração de log do W3C Extended Log File Format deve ser ativada. O método de configuração é entrar na guia Site na caixa de diálogo Propriedades, selecionar a caixa de seleção Habilitar Log, selecionar Formato de Arquivo de Log Estendido W3C e clicar no botão Propriedades, conforme mostrado na figura a seguir:
Na caixa de diálogo Propriedades de Log Estendido que aparece, você pode selecionar as entradas que deseja incluir no arquivo de log. Certifique-se de que URI Stem esteja marcado, caso contrário, o método AppendToLog falhará.
Fornecemos uma página de exemplo simples que tenta gravar uma entrada no arquivo de log, que pode ser aberta no link do método AppendToLog na página inicial do Objeto de Solicitação (show_request.asp). Tudo o que esta página faz é criar uma string simples contendo a data e hora atuais e, em seguida, executar o método AppendToLog:
strToAppend = “Página executada em” & Now
Response.AppendToLog strToAppend
Resumo
Este artigo iniciou o estudo do ASP 3.0 e também vimos como o ASP 3.0 funciona junto com o Internet Information Server 5.0 para fornecer um método eficiente e fácil de usar para criar páginas e aplicativos da Web dinâmicos. . Claro, ainda existem alguns lugares que precisam ser estudados. Este capítulo apenas aprendeu os dois objetos mais básicos incorporados ao ASP.
Os dois objetos mais básicos são os objetos Request e Response, que nos permitem acessar e utilizar valores como parte de uma sessão cliente/servidor, que ocorre sempre que um usuário solicita e carrega uma página ou recurso de um site, ou seja. que o objeto Request pode fornecer acesso a todo o conteúdo solicitado pelo usuário, enquanto o objeto Response permite a criação e modificação da resposta enviada de volta pelo servidor.
Esses objetos expõem diversas partes da sessão por meio de coleções e propriedades e fornecem vários métodos para recuperar e modificar segmentos individuais. Se você pensar neles como ferramentas para analisar a solicitação de um usuário e criar uma resposta com o conteúdo apropriado, isso poderá ajudá-lo a entender o que está acontecendo. Também ajudará a entender como vários métodos afetam o cliente, o servidor e a página da web que está sendo criada.