Condividi tramite

Uso delle mappe di riscrittura nel modulo di riscrittura URL

di Ruslan Kashšev

Questa procedura dettagliata illustra il concetto di riscrittura delle mappe nel modulo di riscrittura URL e illustra come creare regole di riscrittura che usano le mappe di riscrittura. In questa procedura dettagliata verranno create due mappe di riscrittura: una mappa di riscrittura verrà usata dalla regola che esegue la riscrittura url e un'altra mappa di riscrittura verrà usata dalla regola che esegue reindirizzamenti a un dominio diverso.

Sfondo

Una mappa di riscrittura è una raccolta arbitraria di coppie nome e valore che possono essere usate all'interno di regole di riscrittura per generare un URL di sostituzione durante la riscrittura. Le mappe di riscrittura sono particolarmente utili quando si dispone di un ampio set di regole di riscrittura e tutte queste regole usano stringhe statiche, ovvero quando non viene usata alcuna corrispondenza di criteri. In questi casi, invece di definire un ampio set di regole di riscrittura semplici, è possibile inserire tutti i mapping nella mappa di riscrittura, come chiavi e valori, tra l'URL di input e l'URL di sostituzione. Quindi, per cercare l'URL di sostituzione in base all'URL di input, si avrà una regola di riscrittura che fa riferimento a questa mappa di riscrittura.

Prerequisiti

Questa procedura dettagliata richiede i prerequisiti seguenti:

  1. IIS 7.0 o versione successiva con servizio ruolo ASP.NET abilitato
  2. Rilascio live della riscrittura URL installato

Configurazione di una pagina Web di test

Per dimostrare la funzionalità di riscrittura della mappa, verrà usata una semplice pagina di test asp.net. Questa pagina legge le variabili del server Web e ne restituisce i valori nel browser.

Copiare il codice ASP.NET seguente e inserirlo nella %SystemDrive%\inetpub\wwwroot\ cartella in un file denominato article.aspx:

<%@ Page Language="C#" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>URL Rewrite Module Test</title>
</head>
<body>
      <h1>URL Rewrite Module Test Page</h1>
      <table>
            <tr>
                  <th>Server Variable</th>
                  <th>Value</th>
            </tr>
            <tr>
                  <td>Original URL: </td>
                  <td><%= Request.ServerVariables["HTTP_X_ORIGINAL_URL"] %></td>
            </tr>
            <tr>
                  <td>Final URL: </td>
                  <td><%= Request.ServerVariables["SCRIPT_NAME"] + "?" + Request.ServerVariables["QUERY_STRING"] %></td>
            </tr>
      </table>
</body>
</html>

Dopo aver copiato questo file, passare a http://localhost/article.aspx e verificare che il rendering della pagina sia stato eseguito correttamente in un browser.

Screenshot che mostra la pagina di test di cui è stato eseguito il rendering in un browser.

Creazione di una mappa per la riscrittura

Prima di tutto, creeremo una mappa di riscrittura e una regola di riscrittura che verrà usata per eseguire la riscrittura degli URL in base a un set di mapping statici tra GLI URL originali e gli URL riscritti. Per creare una mappa di riscrittura, seguire questa procedura:

  1. Passare a Gestione IIS

  2. Selezionare "Sito Web predefinito"

  3. Nella visualizzazione funzionalità fare clic su "Riscrittura URL"
    Screenshot che mostra la riscrittura di U R L nella visualizzazione funzionalità.

  4. Nel riquadro "Azioni" sul lato destro fare clic su "Visualizza riscrivere le mappe...":
    Screenshot che mostra Visualizza mappe di riscrittura...

  5. Nel riquadro "Azioni" sul sito di destra fare clic su "Aggiungi mappa di riscrittura..." quindi immettere il nome della mappa di riscrittura come "StaticRewrites":
    Screenshot che mostra la casella nome della mappa di riscrittura.

  6. Nella pagina della mappa di riscrittura appena creata, nel riquadro "Azioni" sul lato destro, fare clic su "Aggiungi voce di mapping..." e quindi immettere "/article" e "/article.aspx?id=1&title=some-title" nei campi di testo rispettivamente come "Valore originale:" e "Nuovo valore:". Il valore originale specifica il percorso URL da cui si vuole riscrivere; il nuovo valore specifica il percorso URL in cui si vuole riscrivere.
    Screenshot che mostra le caselle Valore originale e Nuovo valore.

  7. Ripetere il passaggio 6 per aggiungere i mapping seguenti alla mappa di riscrittura:

    Valore originale: Nuovo valore:
    /some-title /article.aspx?id=1&title=some-title
    /post/some-title.html /article.aspx?id=1&title=some-title

Aprire ora il file di web.config per il sito Web (se si usa il sito Web predefinito, è possibile trovare il web.config all'indirizzo %SystemDrive%\inetpub\wwwroot). Verrà visualizzata la sezione seguente:

<rewrite>
    <rewriteMaps>
        <rewriteMap name="StaticRewrites" defaultValue="">
            <add key="/article1" value="/article.aspx?id=1&amp;title=some-title" />
            <add key="/some-title" value="/article.aspx?id=1&amp;title=some-title" />
            <add key="/post/some-title.html" value="/article.aspx?id=1&amp;title=some-title" />
        </rewriteMap>
    </rewriteMaps>
</rewrite>

Questa mappa di riscrittura, denominata "StaticRewrites", verrà usata per riscrivere gli URL in ingresso (definiti come chiavi nella mappa di riscrittura) nelle relative rappresentazioni interne (definite come valori). L'attributo defaultValue specifica il valore da usare se non è stato definito un URL in ingresso nella mappa. In questo caso verrà restituita una stringa vuota.

Si noti che non esiste un modello comune ovvio nelle chiavi e la relativa relazione ai valori. Ciò significa che non è possibile usare espressioni regolari o caratteri jolly per definire la logica di trasformazione degli URL. Inoltre, ciò significa che se non avessimo usato riscrivere le mappe avremmo dovuto creare tre regole di riscrittura. Con le mappe di riscrittura è possibile creare una sola regola di riscrittura. Nella sezione successiva viene illustrato come creare una regola di riscrittura che usa questa mappa di riscrittura.

Facciamo riferimento a una mappa di riscrittura partendo da una regola di riscrittura

Per creare una regola di riscrittura che usa le mappe di riscrittura, copiare e incollare il codice XML seguente nella <rewrite> sezione di web.config file per il sito Web:

<rules>
    <rule name="Rewrite Rule">
        <match url=".*" />
        <conditions>
            <add input="{StaticRewrites:{REQUEST_URI}}" pattern="(.+)" />
        </conditions>
        <action type="Rewrite" url="{C:1}" />
    </rule>
</rules>

Esaminiamo ogni elemento della regola per comprendere le operazioni che esegue:
<match url=".*" /> - Questo elemento indica al modulo di riscrittura URL in modo che corrisponda a qualsiasi URL in ingresso (usando il carattere speciale dell'espressione regolare ".")

<add input="{StaticRewrites:{REQUEST\_URI}}" pattern="(.+)"> - Questa condizione controlla il valore restituito dalla riscrittura della mappa StaticRewrites non è una stringa vuota. Per eseguire questo controllo, il valore della variabile server REQUEST_URI viene passato come parametro alla mappa di riscrittura. Se la mappa di riscrittura contiene una voce con chiave, uguale a REQUEST_URI, verrà restituito il valore corrispondente a tale chiave. Il criterio di espressione regolare corrisponderà solo a stringhe non vuote, quindi se la stringa vuota è stata restituita dalla mappa, la condizione restituirà false, pertanto non verrà eseguita alcuna riscrittura. Se è stata restituita una stringa non vuota, tale stringa verrà acquisita in un back-reference, a causa delle parentesi usate nel modello.

<action type="Rewrite" url="{C:1}" /> - Questo elemento specifica che il modulo di riscrittura URL deve riscrivere la stringa url corrente con quella nuova estratta dalla mappa di riscrittura. Si noti che l'attributo URL fa riferimento al retro-riferimento della condizione {C:1}, che è stato impostato quando il modello nella condizione è stato confrontato.

Test della regola per la riscrittura

Per testare la regola di riscrittura che usa la mappa "StaticRewrites", aprire il Web browser e richiedere uno degli URL seguenti:

http://localhost/article1
http://localhost/some-title
http://localhost/post/some-title.html

Qualsiasi URL precedente deve causare la riscrittura dell'URL in base ai mapping definiti nella mappa di riscrittura. I risultati dovrebbero essere simili alla pagina seguente:

Screenshot che mostra i risultati del test.

Uso delle mappe di riscrittura per il reindirizzamento

Verrà ora creata un'altra mappa di riscrittura che verrà usata per definire mapping statici tra GLI URL di origine e gli URL di reindirizzamento. Per creare una mappa di riscrittura, seguire la stessa procedura descritta nella sezione "Creazione di una mappa per la riscrittura", ma denominare la mappa di riscrittura come "StaticRedirects" e usare i valori seguenti per le voci di mapping:

Valore originale: Nuovo valore:
/old-article.aspx?id=1 /article.aspx?id=1
/posts/default.aspx?id=1 /article.aspx?id=1
/old-title.html /article.aspx?id=1

Il file di web.config per il sito Web ora dovrebbe contenere queste due mappe di riscrittura:

<rewriteMaps>
    <rewriteMap name="StaticRewrites">
        <add key="/article1" value="/article.aspx?id=1&amp;title=some-title" />
        <add key="/some-title" value="/article.aspx?id=1&amp;title=some-title" />
        <add key="/post/some-title.html" value="/article.aspx?id=1&amp;title=some-title" />
    </rewriteMap>
    <rewriteMap name="StaticRedirects">
        <add key="/old-article.aspx?id=1" value="/article.aspx?id=1" />
        <add key="/posts/default.aspx?id=1" value="/article.aspx?id=1" />
        <add key="/old-title.html" value="/article.aspx?id=1" />
    </rewriteMap>
</rewriteMaps>

Per creare una regola che usa la mappa di riscrittura StaticRedirects, copiare e incollare la definizione di regola seguente nel file web.config per il sito Web:

<rules>
    <rule name="Redirect Rule" stopProcessing="true">
        <match url=".*" />
        <conditions>
            <add input="{StaticRedirects:{REQUEST_URI}}" pattern="(.+)" />
        </conditions>
        <action type="Redirect" url="http://localhost{C:1}" appendQueryString="False" redirectType="Permanent" />
    </rule>
</rules>

Anche in questo caso, esaminiamo ogni elemento della regola per capire cosa fa:
<match url=".*" /> - Questo elemento indica al modulo di riscrittura URL in modo che corrisponda a qualsiasi URL in ingresso (usando il carattere speciale dell'espressione regolare ".")

<add input="{StaticRedirects:{REQUEST\_URI}}" pattern="(.+)"> - Questa condizione controlla il valore restituito dalla riscrittura della mappa StaticRedirects non è una stringa vuota. Per eseguire questo controllo, il valore della variabile server REQUEST_URI viene passato come parametro alla mappa di riscrittura. Se la mappa di riscrittura contiene una voce con chiave, uguale a REQUEST_URI, verrà restituito il valore corrispondente a tale chiave. Il criterio di espressione regolare corrisponderà solo a stringhe non vuote, quindi se la stringa vuota è stata restituita dalla mappa, la condizione restituirà false, pertanto non verrà eseguita alcuna riscrittura. Se è stata restituita una stringa non vuota, tale stringa verrà acquisita in un back-reference, a causa delle parentesi usate nel modello.

<action type="Redirect" url="http://localhost{C:1}" appendQueryString="False" redirectType="Permanent" /> - Questo elemento specifica che il modulo di riscrittura URL deve reindirizzare il client Web a un nuovo URL costruito concatenando il nuovo nome di dominio (in questo caso è lo stesso dominio a scopo di semplicità) e il percorso URL di reindirizzamento restituito dalla mappa StaticRedirects.

Test della regola per il reindirizzamento

Per testare la regola di riscrittura che usa la mappa "StaticRedirects", aprire il Web browser e richiedere uno degli URL seguenti:

http://localhost/old-article
http://localhost/posts/default.aspx?id=1
http://localhost/old-title.html

Uno degli URL precedenti dovrebbe causare il reindirizzamento del browser a http://localhost/article.aspx?id=1.

Uso delle mappe di riscrittura per i parametri della stringa di query

L'utilizzo delle mappe di riscrittura non è limitato agli esempi indicati in precedenza. La mappa di riscrittura è una raccolta generica di coppie chiave-valore che possono essere usate ovunque nella regola di riscrittura. Per illustrare questo, creiamo una mappa di riscrittura da usare per la modifica dei parametri della stringa di query.

Creare una terza mappa di riscrittura seguendo la stessa procedura descritta nella sezione "Creazione di una mappa per la riscrittura". Denominare la mappa di riscrittura come "IDtoTitleMap" e usare i valori seguenti per le voci di mapping:

Valore originale: Nuovo valore:
1 some-title-1
2 some-title-2
3 some-title-3

Il file di web.config per il sito Web ora dovrebbe contenere queste due mappe di riscrittura:

<rewriteMaps>
    <rewriteMap name="StaticRewrites">
        <add key="/article1" value="/article.aspx?id=1&amp;title=some-title" />
        <add key="/some-title" value="/article.aspx?id=1&amp;title=some-title" />
        <add key="/post/some-title.html" value="/article.aspx?id=1&amp;title=some-title" />
    </rewriteMap>
    <rewriteMap name="StaticRedirects">
        <add key="/old-article.aspx?id=1" value="/article.aspx?id=1" />
        <add key="/posts/default.aspx?id=1" value="/article.aspx?id=1" />
        <add key="/old-title.html" value="/article.aspx?id=1" />
    </rewriteMap>
    <rewriteMap name="IDtoTitleMap">
        <add key="1" value="some-title-1" />
        <add key="2" value="some-title-2" />
        <add key="3" value="some-title-3" />
    </rewriteMap>
</rewriteMaps>

Per creare una regola che usa la mappa di riscrittura IDtoTitleMap, copiare e incollare la definizione di regola seguente nel file web.config per il sito Web:

<rules>
    <rule name="Query String Rule" stopProcessing="true">
        <match url="^article\.aspx$" />
        <conditions>
            <add input="{QUERY_STRING}" pattern="(?:^|&)id=([0-9]+)(?:&|$)" />
            <add input="{IDtoTitleMap:{C:1}}" pattern="(.+)" />
        </conditions>
        <action type="Redirect" url="article.aspx?title={C:1}" appendQueryString="False" 
                                                            redirectType="Permanent" />
    </rule>
</rules>

Esaminiamo ogni elemento della regola per comprendere le operazioni che esegue:
<match url="^article\.aspx$" /> : questo elemento indica al modulo di riscrittura URL di eseguire la regola quando viene richiesto article.aspx file.

<add input="{QUERY\_STRING}" pattern="(?:^|&amp;)id=([0-9]+)(?:&amp;|$)" /> : questa condizione controlla se la stringa di query contiene un ID parametro con un valore numerico. Il valore effettivo viene acquisito come riferimento di ritorno della condizione. Si noti che questo modello funzionerà anche se sono presenti altri parametri nella stringa di query.

<add input="{IDtoTitleMap:{C:1}}" pattern="(.+)" /> - Questa condizione controlla se il valore restituito dalla mappa di riscrittura IDtoTitleMap non è una stringa vuota. La condizione utilizza il "back-reference" del modello di condizione precedente come input per la mappa di riscrittura.

<action type="Redirect" url="article.aspx?title={C:1}" appendQueryString="False" redirectType="Permanent" /> - Questo elemento specifica che il modulo di riscrittura URL deve reindirizzare il client web al file article.aspx, ma con un parametro della stringa di query title diverso, con un valore che è stato cercato nella mappa di riscrittura.

Test della regola per la stringa di query

Per testare la regola di riscrittura che usa la mappa "IDtoTitleMap", aprire il Web browser e richiedere uno degli URL seguenti:

http://localhost/article.aspx?id=1. Verrà reindirizzato a http://localhost/article.aspx?title=some-title-1. http://localhost/article.aspx?someparam=somevalue&id=2. Verrà reindirizzato a http://localhost/article.aspx?title=some-title-2

Sommario

In questa procedura dettagliata si è appreso come usare le mappe di riscrittura per definire i mapping degli URL per la riscrittura e le regole di reindirizzamento. Si è anche appreso come usare le mappe di riscrittura per modificare i parametri della stringa di query.

Le mappe di riscrittura consentono di ridurre il numero di regole di riscrittura quando le riscritture e gli URL di reindirizzamento sono statici e la logica di riscrittura non può essere espressa utilizzando tecniche di corrispondenza dei modelli.

  • Last updated on