Ao discutir o conteúdo do objeto Request, uma das coleções a ser estudada é a coleção ServerVariables. Este conjunto contém uma combinação do valor no cabeçalho HTTP enviado do cliente para o servidor com a solicitação da página e o valor fornecido pelo próprio servidor quando recebe a solicitação.
O valor retornado pela
página "autorreferencial"
na coleção ServerVariables contém os detalhes do servidor web e as informações do caminho da página atual.Essas informações podem ser usadas em qualquer lugar onde você criar uma página. Por exemplo, para criar uma página de "auto-referência" que possa chamar a si mesma novamente para completar outra tarefa, podemos usar o seguinte código:
＜FORM ACTION="＜% = Request.ServerVariables("PATH_INFO") %＞" METHOD= "POST ”>
O mesmo efeito pode ser obtido com o valor HTTP “SCRIPT_NAME”:
＜FORM ACTION="＜% = Request.ServerVariables(“SCRIPT_NAME”) %＞” METHOD="POST”>
Use o elemento <A> para abra uma página diferente, você pode usar:
...
<%
strFullPath = Request.ServerVariables("PATH_INFO")
'Retire o nome do arquivo
strPathOnly = Esquerda(strFullPath, InStrRev(strFullPath, “/”))
strNextPage = strPathOnly & “páginas/next_page.asp”
%>
...
＜A HREF=”＜% = strNextPage %＞”＞Próxima página＜/A＞
...
esses exemplos funcionam mesmo se o nome ou local da página original for alterado, porque as informações do caminho da página atual são usadas (é claro, o segundo exemplo falha quando o nome da página de destino desanexada é alterado).
Em outras palavras, se a URL for construída automaticamente para a subsessão do mecanismo de busca, alguns valores de ServerVariable podem ser coletados:
strFullURL = http:// & Request.ServerVariables("LOCAL_ADDR") _
& ":" & Request.ServerVariables("SERVER_PORT") _
& Request.ServerVariables("PATH_INFO")
Isso criará uma URL completa incluindo o número da porta (neste caso, não o valor padrão de 80). Por exemplo, o resultado pode ser:
http://194.74.60.254:1768/thispath/thispage.asp
Detectando a versão do navegador
Outro valor útil na coleção ServerVariables é a string do agente do usuário do navegador do usuário. Na página "Detectando o tipo de navegador" (browsertype.asp), o valor "HTTP_USER_AGENT" na coleção ServerVariables é usado para obter a string do agente do usuário. Alguns scripts são usados para analisar essas informações e localizar o nome do fabricante e a versão do navegador.
<%
strUA = Request.ServerVariables("HTTP_USER_AGENT")
Response.Write “A string do agente do usuário é ＜B＞” & strUA & “＜/B＞
"
Se InStr(strUA, “MSIE”) Então
Response.Write “Para atualizar seu navegador, vá para “_
& “＜A HREF=” & Chr(34) & http://www.microsoft.com/ie/ ”_
& Chr(34) & “＞ http://www.microsoft.com/ie/ ＜A＞
"
intVersion = Cint(Mid(strUA, InStr(strUA, “MSIE”) + 5, 1))
Se intVersion ＞=4 Então
Response.Write “Você pode usar o Microsoft Dynamic HTML”
Terminar se
Outro
Se InStr(strUA, “Mozilla”) Então
Se InStr(strUA, “compatível;”) = 0 Então
Response.Write “Seu navegador provavelmente é o Navigator. Você pode “_.
& “baixe a versão mais recente do Navigator em “_
& “＜A HREF=” & Chr(34) & http://home.netscape.com/ ”_
& “download/”& Chr(34) & “＞ http://home.netscape.com ”_
& “/baixar/＜/A＞
"
intVersion = Cint(Mid(strUA, InStr(strUA, “/”) +1, 1))
Se intVersion ＞= 4 Então
Response.Write “Você provavelmente pode usar Netscape Dynamic HTML”
Terminar se
Outro
strVersion = Mid(strUA, InStr(strUA, “compatível;”) + 12)
strProduto = Esquerda(strVersão, InStr(strVersão, ““))
Resposta.Escreva “Seu navegador é compatível com o Navigator, você pode”_
& “pesquise o fabricante usando um mecanismo de busca, como”_
& “＜A HREF=" & Chr(34) _
& “http://www.altavista.digital.com/cgi-bin/query?q=”_
&strProduto_
& Chr(34) & “＞ http://www.altavista.com/ ＜/A＞
"
Terminar se
Terminar se
Terminar se
%>
Os resultados da pesquisa para IE 5.0 e Navigator 4.61 são diferentes respectivamente. Para navegadores de outros fabricantes, você pode obter um link para iniciar automaticamente a pesquisa pelo nome do fabricante no site da Alta Vista.
Observe que o Netscape não fornece o nome do fabricante na string do agente do usuário, portanto não há garantia absoluta de que um navegador seja Navigator.
Detectando o idioma do navegador
Outro valor útil na coleção ServerVariables é "HTTP_ACCEPT_LANGUAGE", que contém um código de idioma especificado quando o navegador é instalado ou é codificado na versão regional do usuário. Exemplos de códigos de idioma são en-us (Reino Unido, EUA), de-at (Alemanha, Austrália) e es-pe (Espanha, Peru).
Os códigos de idioma podem ser genéricos e omitir identificadores de dialeto: por exemplo, em nosso site Wrox, um grande número de visitantes usa en (inglês) como código de idioma.
Portanto, o código do idioma pode ser detectado e uma versão da página específica da região ou do idioma apropriada pode ser carregada automaticamente.
StrLocale = Lcase(Left(Request.ServerVariables("HTTP_ACCEPT_LANGUAGE"),2))
Selecione Caso strLocale
Caso “en”: 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/”
'...etc.
Caso contrário: Response.Redirect “http://us_sitel.com/”
End Selecione
ou redirecione a página com base em um dialeto específico:
strLocale = Lcase(Request.ServerVariables("HTTP_ACCEPT_LANGUAGE"))
Selecione Caso strLocale
Caso “en-gb”: Response.Redirect “http://uk_site.co.uk/”
Caso “en-us”: Response.Redirect “http://us_site.com/”
Caso “es-pe”: Response.Redirect “http://es_site2.co.pe/”
'...
Caso contrário: Response.Redirect “http://us_site1.com/”
End Select
Outros valores úteis da coleção ServerVariables
podem acessar e usar qualquer membro da coleção ServerVariables para controlar a maneira como a página ASP responde a uma solicitação. Você pode verificar se um visitante acessou o site usando a porta padrão 80 ou outra. Neste exemplo, procure o acesso pela porta 443 – que fornece acesso Secure Socket Layer (SSI) (e outros protocolos) – e redirecione-os para uma página apropriada.
Se Request.ServerVariables("SERVER_PORT") = "443") Então
Response.Redirect "/securesite/default.asp" 'Usuário seguro
Outro
Response.Redirect “/normalsite/default.asp” 'Usuário não seguro
Fim
Se for necessário que o navegador se registre e seja verificado pelo servidor (em vez de permitir que ele acesse anonimamente na conta IUSER do servidor web, esse problema será discutido em detalhes em um capítulo posterior), o nome do usuário poderá ser consultado para determinar o usuário que está lidando conosco, quem é e se deve carregar a página para esse usuário. Por exemplo, o código a seguir exibirá o link de administração apenas para usuários denominados Administrador.
...
＜A HREF=”dispcnfg.asp”＞Alterar configuração de exibição＜/A＞
＜A HREF=”dispcolr.asp”＞Alterar cores de exibição＜/A＞
＜A HREF=”keyboard.asp”＞Alterar configuração de teclado＜/A >
＜%
Se Request.ServerVariables("AUTH_USER") _
= Ucase(Request.ServerVariables(“SERVER_NAME”)) & “Administrador” Então
%>
＜A HREF=”allusers.asp”＞Administrar todos os usuários＜/A＞
＜A HREF=”usrlogon.asp”＞Administrar informações de logon＜/A＞
<%
Terminar se
%>
...
observe que o ASP não preenche a coleção ServerVariables até que você acesse um de seus membros. Acessar um membro desta coleção pela primeira vez fará com que o IIS obtenha tudo isso; a coleção ServerVariables deve ser usada apenas quando necessário.
Outras técnicas de solicitação e resposta
Agora, vamos examinar algumas técnicas úteis para usar os objetos Solicitação e Resposta, incluindo:
· Gerenciamento de conexões, buffer e redirecionamentos de páginas.
· Operação de cabeçalhos HTTP, cache e páginas de “expiração”.
· Utilize certificados de cliente.
· Crie mensagens de arquivo de log personalizadas.
1. Gerenciamento de conexões, buffer e redirecionamentos de página
Um recurso muito útil do ASP é permitir que os usuários redirecionem de uma página da web ASP para outra página da web (ASP ou HTML) ou para outro arquivo de origem (como um arquivo ZIP ou texto arquivo) ). Isso é transparente para o usuário, na verdade é o navegador que faz o trabalho. Ao usar o método Response.Redirect para carregar uma nova página da web, um cabeçalho HTTP especial é enviado de volta ao cliente. Este cabeçalho é:
HTTP/1.1 302 Objeto movido
Location /newpath/newpage.asp
O navegador lê essas informações de cabeçalho e carrega a página conforme indicado pelo valor Location. Funcionalmente, isso é o mesmo que usar a tag HTML <META> do lado do cliente em uma página da Web, por exemplo:
<META HTTP-EQUIV="REFRESH" CONTENT="0;URL=/newpath/newpage.asp">
Isso traz a O problema é que o servidor proxy entre o servidor e o usuário pode fornecer sua própria mensagem contendo um link para a nova página, em vez de carregar a nova página diretamente. E os navegadores podem fazer o mesmo trabalho dependendo do fabricante e da versão. Isso elimina a suposta transparência e torna o acesso ao seu site mais complicado para o usuário, pois ele continua recebendo mensagens de erro.
Após enviar qualquer conteúdo da página, como texto ou HTML, não podemos mais usar o método Redirect. No entanto, uma forma que parece limitar o "impacto do servidor proxy" é primeiro garantir que nenhuma saída (incluindo cabeçalhos HTTP) seja enviada ao cliente. No ASP 2.0, você deve ativar o buffer e usar o método Clear para limpar o buffer:
Response.Buffer = True
'Alguma condição para selecionar a página apropriada:
Se Request.ServerVariables("SERVER_PORT") = 1856 Então
StrNewPage = “/newpath/esta_página.asp”
Outro
StrNewPage = “/newpath/the_other_page.asp”
Terminar se
Resposta.Limpar
Response.Redirect strNewPage
No ASP 3.0, o buffer está ativado por padrão, portanto a primeira linha pode ser ignorada, mas é inofensiva e garante que nossa página da Web ainda funcionará mesmo em um ambiente ASP 2.0.
Em vez de usar esse tipo de redirecionamento de cabeçalho HTTP, é melhor usar um novo recurso do ASP 3.0, que nos permite converter para executar outra página web através do método Transfer do objeto Server. Estudaremos esse assunto mais detalhadamente no futuro. .
1) Buffer de página ASP
Como você viu, o buffer de página ASP 3.0 está ativado por padrão no IIS 5.0 e desativado por padrão em versões anteriores. A Microsoft nos diz que o buffer fornece entrega de páginas da Web mais eficiente no IIS 5.0, e é por isso que o estado padrão do buffer foi alterado. Na maioria dos casos, isso não tem efeito sobre nós. No entanto, se você tiver uma página da web muito grande, ou uma página da web que demora um pouco para ser criada usando ASP ou outro código e componentes do lado do servidor, à medida que suas partes são concluídas, podemos atualizá-las em lotes para o cliente:
.. .
... Código para criar a primeira parte da página
...
Resposta.Flush
...
... Código para criar a próxima parte da página
...
Resposta.Flush
...
às vezes você pode desejar interromper a execução do código em algum momento antes do final da página, chamando o método End para atualizar todo o conteúdo atual para o cliente e abortar qualquer processamento adicional.
...
... Código para criar a primeira parte da página
Se strUserName = "" Então Response.Clear
...
... Código para criar uma nova versão desta parte da página
...
Aqui estão dois exemplos de páginas da web que demonstram buffer e redirecionamento, que podem ser baixados da página principal "Objeto de resposta" (sow_response.asp). A primeira página da web de exemplo Response.Redirect é chamada de redireccionamento.asp. Ela insere algum conteúdo na página em buffer, limpa o buffer e redireciona para outra página da web:
For intLoop = 1 To 1000000.
Resposta.Escreva "."
Próximo
Resposta.Limpar
Resposta.Redirect "show_redirect.asp"
Response.End
show_response.asp faz o mesmo trabalho, mas o redirecionamento volta para a página inicial do "Objeto de Resposta". Como essas páginas são armazenadas em buffer e todas as saídas devem ser limpas antes do redirecionamento, não há saída visível no navegador. Porém, cada redirecionamento ocorrido pode ser visto observando o status do navegador. Conforme mostrado na figura abaixo:
<img src=/u/info_img/2009-06/25/asp14.jpg>
Na página inicial "Response Object", clique no link "Response.Flush" para abrir a segunda página da web de exemplo usebuffer.asp. Ele simplesmente itera cada caractere de uma string e os libera para o cliente com um certo atraso. Embora esse seja um uso muito ineficiente de servidores Web e ASP, ele demonstra como funciona o buffer.
<img src=/u/info_img/2009-06/25/asp15.jpg>
A seguir está o código ASP mínimo necessário. Observe que atualizamos cada caractere no navegador separadamente, caso contrário ele será armazenado no buffer até o momento. a página da web está completa:
strText = “Este texto foi liberado para o navegador usando“ & _
"＜B＞Resposta.Flush＜/B＞
"
Para intChar =1 para Len(strText)
Para intWrite = 1 a 100.000
Próximo
Response.Write Mid(strText,intChar,1)
Resposta.Flush
Próximo
2) Propriedade Response.IsClientConnected
A propriedade IsClientConnected já existe no ASP 2.0, mas não é confiável. Alguma saída deve ser enviada ao cliente antes de retornar um resultado preciso. Este problema foi resolvido no ASP 3.0. Esta propriedade agora pode ser usada livremente.
IsClientConnected é uma forma útil de observar se o usuário ainda está conectado ao servidor e carregando a página web criada pelo ASP. Se o usuário desconectar ou parar de baixar, não precisaremos mais desperdiçar recursos do servidor criando a página web porque o conteúdo do buffer será descartado pelo IIS. Portanto, para páginas web que exigem muito tempo de cálculo ou utilizam muitos recursos, vale a pena verificar em todas as etapas se o navegador está offline:
...
... Código para criar a primeira parte da página
...
Se Response.IsClientConnected então
Resposta.Flush
Outro
Resposta.Fim
Terminar se
...
... Código para criar a próxima parte da página...