URL de WordPress sem postagens

Estamos trabalhando em um sistema maior, baseado em WordPress, mas o WordPress é usado apenas para conteúdo “estático”, a parte principal do sistema deve estar consumindo a API externa e exibindo os dados.

Meu ponto é: eu posso dizer de alguma forma a reescrita de URL para não usar o sistema interno do WordPress para alguns URLs e usar outra coisa?

Por exemplo, mysite.com/news/news-title mostraria a postagem, mas mysite.com/customcontent/anotherlink chamaria algum mecanismo para carregar dados da API e exibi-lo.

Não sei se isso é possível com o WordPress .. Obrigado por seus pontos.

Solutions Collecting From Web of "URL de WordPress sem postagens"

Sim, é possível.

O stream de trabalho do WordPress em frente pode ser resumido da seguinte forma:

  1. Uma url é visitada
  2. Ao verificar o URL atual contra todos os padrões e regras de reescrita personalizadas, a url é “convertida” para um conjunto de argumentos para WP_Query . Isso é feito pelo método parse_request de uma instância da class WP armazenada na variável $wp global
  3. Uma instância de WP_Query (salva na variável global $wp_query ) é usada para consultar o database e obter as postagens relacionadas aos argumentos recuperados no ponto 2. Isso é referenciado como a “consulta principal”
  4. Com base nos argumentos da consulta, um modelo é escolhido de acordo com a hierarquia do modelo e é carregado e usado para exibir os resultados

Então, mesmo se você registrar um conjunto de regras de reescrita personalizadas, elas serão usadas para consultar postagens.

No entanto, se você olhar para a fonte do método parse_request , nas primeiras linhas você vê isso:

 if ( ! apply_filters( 'do_parse_request', true, $this, $extra_query_vars ) ) return; 

Então, ao ativar um retorno de chamada para o filtro ‘do_parse_request’, você poderá parar o processo de análise do WordPress e fazer o que for necessário.

Há uma maneira diferente de fazer esta tarefa, aqui por causa da simplicidade, vou dar-lhe um exemplo aproximado.

Como dito, precisamos fazer uma correspondência de url personalizada para … algo , provavelmente um retorno de chamada que recupera alguns dados e uma visualização para exibi-lo.

Para tornar o código reutilizável, podemos usar uma class que aceite configurações de URL personalizadas por meio de um filtro e use essas configurações de URLs personalizadas para mostrar o que precisamos, usando um retorno de chamada para obter alguns dados e uma visualização para exibi-los.

 class MyCustomUrlParser { private $matched = array(); /** * Run a filter to obtain some custom url settings, compare them to the current url * and if a match is found the custom callback is fired, the custom view is loaded * and request is stopped. * Must run on 'do_parse_request' filter hook. */ public function parse( $result ) { if ( current_filter() !== 'do_parse_request' ) { return $result; } $custom_urls = (array) apply_filters( 'my_custom_urls', array() ); if ( $this->match( $custom_urls ) && $this->run() ) { exit(); // stop WordPress workflow } return $result; } private function match( Array $urls = array() ) { if ( empty( $urls ) ) { return FALSE; } $current = $this->getCurrentUrl(); $this->matched = array_key_exists( $current, $urls ) ? $urls[$current] : FALSE; return ! empty( $this->matched ); } private function run() { if ( is_array( $this->matched ) && isset( $this->matched['callback'] ) && is_callable( $this->matched['callback'] ) && isset( $this->matched['view'] ) && is_readable( $this->matched['view'] ) ) { $GLOBALS['wp']->send_headers(); $data = call_user_func( $this->matched['callback'] ); require_once $this->matched['view']; return TRUE; } } private function getCurrentUrl() { $home_path = rtrim( parse_url( home_url(), PHP_URL_PATH ), '/' ); $path = rtrim( substr( add_query_arg( array() ), strlen( $home_path ) ), '/' ); return ( $path === '' ) ? '/' : $path; } } 

Esta é uma class difícil que permite aos usuários definir configurações de URL personalizadas por meio de um filtro (‘my_custom_urls’). As configurações de url personalizadas devem ser uma matriz onde as chaves são URLs relativas e cada valor é uma matriz contendo dois valores com chave: um com a chave ‘retorno de chamada’ e um com a ‘visão’ de chave.

O retorno de chamada é um callable (qualquer coisa para a qual is_callable retorna true) e a exibição é um arquivo usado para renderizar os dados retornados pelo callable e acessível no arquivo de exibição na variável $data .

Aqui, um exemplo sobre como usar a class.

 // first of all let's set custom url settings add_filter( 'my_custom_urls', 'set_my_urls' ); function set_my_urls( $urls = array() ) { $my_urls = array( '/customcontent/alink' => array( 'callback' => 'my_first_content_callback', 'view' => get_template_directory() . '/views/my_first_view.php' ), '/customcontent/anotherlink' => array( 'callback' => 'my_second_content_callback', 'view' => get_template_directory() . '/views/my_second_view.php' ) ); return array_merge( (array) $urls, $my_urls ); } // require the file that contain the MyCustomUrlParser class require '/path/to/MyCustomUrlParser'; // attach MyCustomUrlParser::parse() method to 'do_parse_request' filter hook add_filter( 'do_parse_request', array( new MyCustomUrlParser, 'parse' ) ); 

Claro, precisamos escrever my_second_content_callback e my_second_content_callback e também my_second_view.php e my_second_view.php .

Como exemplo, o retorno de chamada seria algo assim:

 function my_first_content_callback() { $content = get_transient( 'my_first_content' ); if ( empty( $content ) ) { $api = a_method_to_get_an_external_api_object(); $json = $api->fetch_some_json_data(); $content = json_decode( $json ); // cache content for 1 hour set_transient( 'my_first_content', $content, HOUR_IN_SECONDS ); } return $content; } 

Observe que qualquer retorno de retorno de retorno é armazenado na variável de $data acessível na exibição. Nos fatos, um arquivo de exibição apareceria assim:

 < ?php get_header(); ?> 

My Content from API

< ?php print_r( $data ); ?>

< ?php get_footer() ?>

Isso funciona e é bastante reutilizável, você pode definir todas as URLs personalizadas que você deseja, usando o filtro 'my_custom_urls' .

No entanto, há desvantagens: toda a correspondência contra a url atual é feita por meio de uma correspondência exata , mas usando um sistema de correspondência de regex seria muito melhor para grandes projetos porque você pode usar as URL para passar algumas variables ​​para callbacks.

Por exemplo, se você tiver uma configuração de URL como esta:

 '/customcontent/alink/page/{page}' => array( 'callback' => 'my_first_content_callback', 'view' => get_template_directory() . '/views/my_first_view.php' ) 

Usar um sistema regex é possível fazer a variável de peça {page} e o valor correspondente pode ser passado para o retorno de chamada para recuperar dados diferentes.

Isso é o que é comumente chamado de sistema de roteamento , e existem algumas bibliotecas PHP úteis, como FastRoute , Pux e Symfony Routing Component, que podem ajudá-lo a usar o stream de trabalho que expliquei e crie seu próprio sistema de roteamento baseado em regex no WordPress.

Se você tem PHP 5.4+ (que é realmente recomendado), há um plugin que escrevi chamado Cortex que implementa o Symfony Routing Component e torná-lo utilizável dentro do WordPress tanto para consultas padrão do WordPress (mostrando posts) quanto para conteúdo personalizado, como você precisa.