Devo usar spl_autoload_register () no meu plugin?

10

Quando uso o spl_autoload_register no meu plugin, recebo:

    Fatal error: Uncaught exception 'LogicException' with message
   'Class wp_atom_server could not be loaded'

    wp-includes\pluggable-deprecated.php on line 182

Eu fiz algumas leituras e encontrei várias correções. Um sobre SO disse não usar spl_autoload_register com o WordPress.

Isso é preciso?

Tenho certeza de que posso encontrar uma "correção" para o erro, mas não tenho certeza se quero fazer isso com cada versão do WP.

Se eu não usar a função de carregamento automático, como devo carregar minhas aulas? Aqui está o que quebra agora:

spl_autoload_extensions(".php");
spl_autoload_register();

use MyPluginClasses\Student as MS;

$student = new MS\Student();

echo $student->sayHello();

No aluno:

<?PHP
namespace MyPluginClasses\Student
{
    class Student{
        public function __Construct(){
            echo "Hello Johnny";
        }
        public function sayHello(){
            echo "Hello Johnny's Method";

        }

    }
}

Esse design funciona bem fora do WordPress.

    
por johnny 21.08.2014 / 21:46

2 respostas

1

Eu realmente não tenho certeza se é bom ou ruim praticar o carregamento automático de classes no plugin WP. Para mim, não vejo efeitos colaterais do uso de spl_autoload_register (desempenho não testado)

Então, para responder à sua pergunta, eu gostaria de compartilhar uma classe do meu próximo plug-in que estou usando para carregar automaticamente as classes de um único diretório sem problemas e até agora isso é bom para mim.

/**
 * Annframe Class Autoloader.
 *
 * @package Annframe
 * @since 0.1.0
 */
class Annframe_Autoloader {
    /**
     * Singleton.
     *
     * @since 0.1.0
     * @var Annframe_Autoloader - Single instance.
     */
    private static $_instance = null;

    /**
     * Private Construct.
     *
     * @package Annframe
     * @since 0.1.0
     */
    private function __construct() {
        spl_autoload_register( array( $this, 'load' ) );
    }

    /**
     * Singleton method.
     *
     * @package Annframe
     * @since 0.1.0
     */
    public static function _instance() {
        if ( ! self::$_instance ) {
            self::$_instance = new Annframe_Autoloader();
        }
        return self::$_instance;
    }

    /**
     * Class Loader.
     *
     * @package Annframe
     * @since 0.1.0
     *
     * @param string $class_name - Class name to load.
     * @return null - Do not return anything.
     */
    public function load( $class_name ) {
        $file = str_replace( '_', '-', strtolower( $class_name ) );
        $file = 'class-' . $file;
        if ( is_readable( trailingslashit( YOUR_PLUGIN_PATH. '/classes-dir' ) . $file . '.php' ) ) {
            include_once trailingslashit( YOUR_PLUGIN_PATH. '/classes-dir' ) . $file . '.php';
        }
        return;
    }
}

Annframe_Autoloader::_instance();

Para quebrar essa classe simples em partes, como você pode ver, estou usando o padrão Singleton. Constructor é privado e instance() & $_instance pertence ao padrão. Construtor tem spl_autoload_register function.

spl_autoload_register( array( $this, 'load' ) );

que está chamando o método load da classe própria. As duas primeiras linhas deste método são:

$file = str_replace( '_', '-', strtolower( $class_name ) );
$file = 'class-' . $file;

que é bem direto. Se você seguir o WPCS , ele o encoraja a seguir uma convenção de nomenclatura de classe prefixada com a palavra class e, em seguida, o nome da classe. É claro que qualquer sublinhado (_) é substituído por (-) traço.

para que um nome de arquivo da classe WPSE_Post seja class-wpse-post.php

Reduza os nomes das classes de maiúsculas e minúsculas com strtolower e use str_replace para substituir os sublinhados por traços. então WPSE_Post agora se torna wpse-post . finalmente adicionando um prefixo class- na próxima linha.

Estou usando is_readable na instrução condicional que pode ser trocada com file_exists . supondo YOUR_PLUGIN_PATH é o caminho base do plugin e classes-dir está sob o diretório principal do plugin, contendo todas as suas classes que precisam de autoloading.

include_once é usado para carregar o arquivo real na chamada.

Uso:

você só precisa incluir a classe de auto loader acima no arquivo base do seu plugin

/**
 * Class autoloader.
 */
if ( ! class_exists( 'Annframe_Autoloader' ) ) {
    include_once YOUR_PLUGIN_PATH/class-annframe-autoloader.php';
}

e, em seguida, ligue para suas aulas sob demanda.

new XYX_Class();
Another_Class::instance(); // etc

Observação: não estou usando o método de namespace na minha solução para que ele possa ou não se encaixar de acordo com as suas necessidades, mas postado aqui na esperança de que alguém obtenha benefícios de carregar classes dinamicamente.

    
por Anwer AR 24.02.2018 / 23:58
-1
    function MyPluginClasses_autoloader( $class_name ) {
  if ( false !== strpos( $class_name, 'MyPluginClasses' ) ) {
    $parts = explode('\', $class_name);
    require_once RoothPath . DIRECTORY_SEPARATOR .'lib'.DIRECTORY_SEPARATOR.end($parts) . '.php';
  }
}
spl_autoload_register( 'MyPluginClasses_autoloader' );
use MyPluginClasses\Student as MS;
$student = new MS\Student();
echo $student->sayHello();
    
por Meldin Xavier 22.02.2017 / 09:54