Crear una URL corta usando el acortador de URL de PHP


La URL corta siempre es una forma recomendada de compartir la URL de la página web. Es fácil de recordar y se puede compartir fácilmente en la web. Hay muchos servicios de acortador de URL disponibles que le permiten convertir una URL larga en una URL corta en línea. Pero las principales desventajas de estos servicios son que no podrá usar su propio dominio en la URL corta. Si desea crear una URL corta con su propio nombre de dominio, debe usar un acortador de URL personalizado .
El servicio de acortador de URL toma una URL larga y la comprime en un enlace corto que es más fácil de compartir. Puede crear URLs cortas mediante programación usando PHP sin ninguna API de acortador de URL de terceros En este tutorial, le mostraremos cómo crear una biblioteca de acortadores de URL y crear una URL corta con PHP y MySQL . Con la biblioteca de PHP URL Shortener puede acortar las URL largas y usar su propio dominio en las URL cortas.
En el ejemplo, el script muestra el proceso para crear un enlace limpio, corto y pequeño que se puede compartir fácilmente a través del correo electrónico o las redes sociales. La base de datos se utiliza para almacenar la información sobre la URL larga y corta. Además, puede hacer un seguimiento del número de visitas que obtiene la URL corta por parte de los visitantes.

Crear tabla de base de datos

Usaremos la base de datos para manejar la redirección basada en el código corto. El siguiente SQL crea una short_urlstabla en la base de datos MySQL para almacenar información de URL (URL larga, código corto, visitas y tiempo de creación).
CREATE  TABLE  `short_urls` (
  ` id`  int ( 11 ) NOT  NULL AUTO_INCREMENT,
  `long_url`  varchar ( 255 ) COLLATE utf8_unicode_ci NOT  NULL ,
  ` short_code`  varchar ( 25 ) COLLATE utf8_unicode_ci NOT  NULL ,
  `hits`  int ( 11 ) NOT  NULL ,
  `created` datetime NOT  NULL ,LLAVE 
 PRIMARIA ( `id` )
) MOTOR = InnoDB  DEFAULT  CHARSET = utf8 COLLATE = utf8_unicode_ci;

Biblioteca de acortadores de URL (Shortener.class.php)

La clase de acortador de URL permite crear mediante programación una URL corta mediante PHP y MySQL. Esta clase utiliza la extensión PDO para trabajar con la base de datos MySQL, por lo que se requiere una instancia de objeto PDO en la inicialización de la clase Shortener.
Variables estáticas:
  • $chars- Caracteres permitidos para el código corto. (El grupo de caracteres está separado por |)
  • $table - Nombre de la tabla de la base de datos para almacenar la URL y la información del código corto.
  • $checkUrlExists - Establecido en VERDADERO, para verificar si existe la URL larga.
  • $codeLength - La longitud de los caracteres del código corto.
Funciones:
  • __construct () - Establece la referencia del objeto PDO y la marca de tiempo.
  • urlToShortCode () : valida la URL y crea un código corto.
  • validateUrlFormat () : validar el formato de la URL.
  • verifyUrlExists () : verifique si la URL existe o no utilizando cURL en PHP.
  • urlExistsInDB () : compruebe si la URL larga existe en la base de datos. Si existe, devuelva el código de disparo, de lo contrario, devuelva FALSO.
  • createShortCode () : crea un código corto para la URL larga e inserta la URL larga y el código corto en la base de datos.
  • generateRandomString () : genera una cadena aleatoria (código corto) con los caracteres especificados en la variable $ chars.
  • insertUrlInDB () : inserte información de URL en la base de datos utilizando PDO Extension y MySQL y devuelva el ID de fila.
  • shortCodeToUrl () : convierte el código corto en una URL larga e inserta el recuento de hits en la base de datos.
  • validateShortCode () : valida el código corto en función de los caracteres permitidos.
  • getUrlFromDB () : recupera la URL larga de la base de datos basada en el código corto.
  • incrementCounter () - Incrementa el contador de visitas de URL en la base de datos para un registro particular.
<? php
 / ** 
 * Clase para crear URLs cortas y decodificar URLs abreviadas
 * 
 * @author CodexWorld.com <contact@codexworld.com> 
 * @ copyright Copyright (c) 2018, CodexWorld.com
 * @url https://www.codexworld.com
 * / 
acortador de
 clase  {
    estática protegida  $ chars  "abcdfghjkmnpqrstvwxyz | ABCDFGHJKLMNPQRSTVWXYZ | 0123456789" ;
    protegido  $ table  "short_urls" ;
    protegido  $ checkUrlExists  falso ;
    estática protegida  $ codeLength  7 ;

    protegido  $ pdo ;
    protegido  $ timestamp ;

    función pública  __construct ( PDO $ pdo ) {
         $ this -> pdo  $ pdo ;
        $ this -> timestamp  date ( "Ymd H: i: s" );
    }

    función pública  urlToShortCode ( $ url ) {
        if (vacío ( $ url )) {
            lanzar una nueva  excepción ( "No se suministró ninguna URL" );
        }

        if ( $ this -> validateUrlFormat ( $ url ) ==  false ) {
            lanzar una nueva  excepción ( "la URL no tiene un formato válido." );
        }

        if ( self :: $ checkUrlExists ) {
            if (! $ this -> verifyUrlExists ( $ url )) {
                lanzar una nueva  excepción ( "la URL no parece existir" );
            }
        }

        $ shortCode  $ this -> urlExistsInDB ( $ url );
        if ( $ shortCode  ==  false ) {
             $ shortCode  $ this -> createShortCode ( $ url );
        }

        devuelve  $ shortCode ;
    }

    función protegida  validateUrlFormat ( $ url ) {
        return  filter_var ( $ url FILTER_VALIDATE_URL FILTER_FLAG_HOST_REQUIRED );
    }

    función protegida  verifyUrlExists ( $ url ) {
         $ ch  curl_init ();
        curl_setopt ( $ ch CURLOPT_URL $ url );
        curl_setopt ( $ ch CURLOPT_NOBODY true );
        curl_setopt ( $ ch ,   CURLOPT_RETURNTRANSFER true );
        curl_exec ( $ ch );
        $ respuesta  curl_getinfo ( $ ch CURLINFO_HTTP_CODE );
        curl_close ( $ ch );

        return (! empty ( $ response ) &&  $ response  ! =  404 );
    }

    función protegida  urlExistsInDB ( $ url ) {
         $ query  "SELECT short_code FROM" . self :: $ table . "WHERE long_url =: long_url LIMIT 1" ;
        $ stmt  $ this -> pdo -> prepare ( $ query );
        $ params  = array (
             "long_url"  =>  $ url
         );
        $ stmt -> execute ( $ params );

        $ resultado  $ stmt -> fetch ();
        retorno (vacío ( $ resultado ))? false  $ result [ "short_code" ];
    }

    función protegida  createShortCode ( $ url ) {
         $ shortCode  $ this -> generateRandomString ( self :: $ codeLength );
        $ id  $ this -> insertUrlInDB ( $ url $ shortCode );
        devuelve  $ shortCode ;
    }
    
    función protegida  genera RandomString ( $ length  6 ) {
         $ sets  explode ( '|' self :: $ chars );
        $ all  '' ;
        $ randString  '' ;
        foreach ( $ sets  as  $ set ) {
             $ randString  . =  $ set [ array_rand ( str_split ( $ set ))];
            $ todo  . =  $ conjunto ;
        }
        $ all  str_split ( $ all );
        para ( $ i  0 $ i  $ length  count ( $ sets );  $ i ++) {
             $ randString  . =  $ all [ array_rand ( $ all )];
        }
        $ randString  str_shuffle ( $ randString );
        devuelve  $ randString ;
    }

    función protegida  insertUrlInDB ( $ url $ code ) {
         $ query  "INSERT INTO" . self :: $ table . "(long_url, short_code, created) VALUES (: long_url,: short_code,: timestamp)" ;
        $ stmnt  $ this -> pdo -> prepare ( $ query );
        $ params  = array (
             "long_url"  =>  $ url ,
             "short_code"  =>  $ code ,
             "timestamp"  => $ esto -> marca de tiempo
         );
        $ stmnt -> execute ( $ params );

        devuelve  $ this -> pdo -> lastInsertId ();
    }
    
    función pública  shortCodeToUrl ( $ code $ increment  true ) {
        si (vacío ( $ código )) {
            lanzar nueva  excepción ( "No se suministró ningún código corto" );
        }

        if ( $ this -> validateShortCode ( $ code ) ==  false ) {
            lanzar una nueva  excepción ( "El código corto no tiene un formato válido." );
        }

        $ urlRow  $ this -> getUrlFromDB ( $ code );
        if (vacío ( $ urlRow )) {
            lanzar una nueva  excepción ( "El código corto no parece existir" );
        }

        if ( $ increment  ==  true ) {
             $ this -> incrementCounter ( $ urlRow [ "id" ]);
        }

        devuelve  $ urlRow [ "long_url" ];
    }

    función protegida  validateShortCode ( $ code ) {
         $ rawChars  str_replace ( '|' '' self :: $ chars );
        devuelve  preg_match ( "| [" . $ rawChars . "] + |" $ code );
    }

    función protegida  getUrlFromDB ( $ code ) {
         $ query  "SELECT id, long_url FROM" . self :: $ table . "WHERE short_code =: short_code LIMIT 1" ;
        $ stmt  $ this -> pdo -> prepare ( $ query );
        $ params = array (
             "short_code"  =>  $ code
         );
        $ stmt -> execute ( $ params );

        $ resultado  $ stmt -> fetch ();
        retorno (vacío ( $ resultado ))? falso  $ resultado ;
    }

    función protegida  incrementCounter ( $ id ) {
         $ query  "UPDATE" . self :: $ table . "SET hits = hits + 1 WHERE id =: id" ;
        $ stmt  $ this -> pdo -> prepare ( $ query );
        $ params  = array (
             "id"  =>  $ id
         );
        $ stmt -> execute ( $ params );
    }
}

Configuración de la base de datos (dbConfig.php)

En el dbConfig.phparchivo, PDO (Objetos de datos PHP) se utiliza para conectar y seleccionar la base de datos. Especifique el host de la base de datos ( $dbHost), el nombre de usuario ( $dbUsername), la contraseña ( $dbPassword) y el nombre ( $dbName) según sus credenciales de servidor de base de datos MySQL.
<? php
 // Configuración de la base de datos
 $ dbHost      "localhost" ;
$ dbUsername  "root" ;
$ dbPassword  "root" ;
$ dbName      "codexworld" ;

// Crear conexión de base de datos
 intente {
     $ db  = new  PDO ( "mysql: host = $ dbHost ; dbname = $ dbName " $ dbUsername $ dbPassword );
} catch ( PDOException $ e ) {
    echo  "Conexión fallida:"  $ e -> getMessage ();
}

Crear URL corta con PHP

El siguiente código crea un código corto y genera una URL corta con una clase de acortador de URL personalizada usando PHP y MySQL.
  • Inicialice la clase Shortener y pase el objeto DOP.
  • Especifique la URL larga que desea convertir en un enlace corto.
  • Especifique el prefijo de URL corto. Si desea utilizar RewriteEngine para reescribir la URL, especifique solo el URI base. De lo contrario, especifique el URI base con una cadena de consulta para pasar el código corto.
  • Llame a la urlToShortCode()función para obtener el código corto de la URL larga.
  • Crea una URL corta con el prefijo URI y el código corto.
// Incluir el archivo de configuración de la base de datos
 require_once  'dbConfig.php' ;

// Incluir el archivo de biblioteca del acortador de URL
 require_once  'Shortener.class.php' ;

// Inicialice la clase Shortener y pase el objeto PDO
 $ shortener  = new  Shortener ( $ db );

// URL larga
 $ longURL  'https://www.codexworld.com/tutorials/php/' ;

// Prefijo de la URL corta 
 $ shortURL_Prefix  'https://xyz.com/' // con la URL reescribir
 $ shortURL_Prefix  'https://xyz.com/?c=' // sin reescritura de URL

intente {
     // Obtenga el código corto de la URL
     $ shortCode  $ shortener -> urlToShortCode ( $ longURL );
    
    // Crear una URL corta
     $ shortURL  $ shortURL_Prefix . $ shortCode ;
    
    // Mostrar URL corta
     echo  'Corta URL:' . $ shortURL ;
} catch ( Exception $ e ) {
     // Mostrar error
     echo  $ e -> getMessage ();
}

Redireccionar a URL larga

El siguiente código maneja la redirección de la URL corta a la URL original.
  • Recupere el código corto de la cadena de consulta de la URL, o del segmento URI.
  • Llame a la shortCodeToUrl()función para obtener la URL larga por el código corto.
  • Redirigir al usuario a la URL original.
// Incluir el archivo de configuración de la base de datos
 require_once  'dbConfig.php' ;

// Incluir el archivo de biblioteca del acortador de URL
 require_once  'Shortener.class.php' ;

// Inicialice la clase Shortener y pase el objeto PDO
 $ shortener  = new  Shortener ( $ db );

// Recuperar el código corto de la URL
 $ shortCode  $ _GET [ "c" ];

tratar{
    // Obtener la URL por el código corto
     $ url  $ shortener -> shortCodeToUrl ( $ shortCode );
    
    // Redirigir al encabezado de la URL original
     ( "Ubicación:" . $ Url );
    salida;
} catch ( Exception $ e ) {
     // Mostrar error
     echo  $ e -> getMessage ();
}

Reescritura de URL con HTACCESS

Si desea que la URL sea fácil de usar, use HTACCESS con RewriteEngine. Crea un .htaccessarchivo y agrega el siguiente código.
<IfModule mod_rewrite.c>
 RewriteEngine On
 RewriteCond % {REQUEST_FILENAME}!
 -F RewriteCond % {REQUEST_FILENAME}!
 -D RewriteRule ^ ([a-zA-Z0-9] +) /? $ Redirect.php? C = $ 1 [L ]
</IfModule>

Conclusión

Nuestra clase Shortener lo ayuda a crear una URL corta fácilmente usando PHP. Puede usar esta biblioteca para crear su propio URL Shortener con PHP y MySQL. Use el código de ejemplo para acortar la URL al vuelo sin usar ningún servicio de terceros. Además, la clase de acortador de URL de PHP se puede ampliar fácilmente para personalizar la funcionalidad de acortamiento de URL.

Acerca de: Programator

Somos Instinto Programador

0 comentarios:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Con tecnología de Blogger.