Advertisement
  1. Code
  2. WordPress

Objektorientierte Programmierung in WordPress: Erstellen des Plugins II

Scroll to top
Read Time: 11 min
This post is part of a series called Object-Oriented Programming in WordPress.
Object-Oriented Programming in WordPress: Building the Plugin I
Object-Oriented Programming in WordPress: Document the Plugin I

German (Deutsch) translation by Tatsiana Bochkareva (you can also view the original English article)

Im vorherigen Artikel dieser Reihe haben wir endlich damit begonnen, die Grundlage für das Plugin vorzubereiten, das wir schreiben werden.

Insbesondere haben wir uns die Dateiorganisation, die Komponenten und die tatsächlichen Details der Funktionen des Plugins angesehen. Wir haben auch den Code gelöscht, den wir in diesem Tutorial ausfüllen werden.

Wir werden unser Plugin nicht nur dazu bringen, etwas zu tun, sondern wir werden auch über eine Reihe verschiedener objektorientierter Prinzipien, Techniken und Ideen sprechen, während wir das Plugin durcharbeiten.

Beachten Sie, dass wir in diesem Tutorial nur sehr wenig Dokumentation machen werden. Wir haben die Details dazu im vorherigen Artikel behandelt. Wir werden jedoch in dem folgenden Artikel mehr darüber sprechen.

Wie bei den übrigen Artikeln dieser Reihe sollten Sie sich auch hier über alles informieren, was wir bisher in der Reihe behandelt haben, da alles, was wir tun, auf den vorherigen Themen aufbaut.

Als Referenz haben wir behandelt:

  1. Eine Einleitung
  2. Klassen
  3. Typen
  4. Kontrollstrukturen: Bedingte Anweisungen
  5. Kontrollstrukturen: Schleifen
  6. Funktionen und Attribute
  7. Umfang
  8. Erstellung von dem Plugin I

Nachdem machen wir uunsere Arbeit weiter, wo wir aufgehört haben.

Wo fangen wir an?

Wenn es darum geht, Software zu schreiben - unabhängig vom verwendeten Paradigma -, geschieht dies nicht linear. Das heißt, wir schreiben nicht unbedingt am Startpunkt des Programms. Oft - wenn auch nicht immer - ist dies einer der letzten Teile, die wir korrigieren.

Nachdem dies gesagt ist, werden wir beginnen, an jeder Datei, aus der das Plugin besteht, auf eine Weise zu arbeiten, die beim Durcharbeiten des Plugins sinnvoll ist. Damit meine ich, dass die Dinge während der Arbeit an diesem Artikel zunächst verstreut erscheinen, aber hoffentlich etwas klarer werden sollten, wenn wir uns jede Datei ansehen.

Der Lader

Die erste Klasse, die wir abschließen werden, befindet sich in includes/class-single-post-meta-manager-loader.php. Wenn Sie sich an den vorherigen Artikel erinnern, ist diese Klasse für die Koordination von Aktionen und Filtern zwischen dem Kern-Plugin und der Administrationsklasse verantwortlich.

In gewisser Weise bietet es einen Wrapper um die nativen Hook-APIs von WordPress. Es ermöglicht uns jedoch, unsere Klassen zu entkoppeln (und damit eine Trennung der Bedenken zu erzwingen), so dass sich jeder auf einen bestimmten Zweck spezialisieren kann.

Schauen wir uns zunächst die Klasse an:

1
<?php
2
3
class Single_Post_Meta_Manager_Loader {
4
5
    protected $actions;
6
7
    protected $filters;
8
9
    public function __construct() {
10
11
        $this->actions = array();
12
        $this->filters = array();
13
    
14
    }
15
16
    public function add_action( $hook, $component, $callback ) {
17
	    $this->actions = $this->add( $this->actions, $hook, $component, $callback );
18
    }
19
20
    public function add_filter( $hook, $component, $callback ) {
21
	    $this->filters = $this->add( $this->filters, $hook, $component, $callback );
22
    }
23
24
    private function add( $hooks, $hook, $component, $callback ) {
25
26
	    $hooks[] = array(
27
		    'hook'      => $hook,
28
		    'component' => $component,
29
		    'callback'  => $callback
30
	    );
31
32
	    return $hooks;
33
34
    }
35
36
    public function run() {
37
38
        foreach ( $this->filters as $hook ) {
39
		    add_filter( $hook['hook'], array( $hook['component'], $hook['callback'] ) );
40
	    }
41
42
	    foreach ( $this->actions as $hook ) {
43
		    add_action( $hook['hook'], array( $hook['component'], $hook['callback'] ) );
44
	    }
45
46
    }
47
48
}

An diesem Punkt der Serie sollten Sie einige wichtige Dinge über die Klasse bemerken, die auf den Diskussionen basieren, die wir bisher in der Serie geführt haben.

  • Es gibt zwei protected-Attributionen, die sich jeweils auf arrays beziehen, wie sie im Konstruktor definiert sind. Einer ist für Aktionen vorgesehen, der andere für Filter.
  • Es gibt zwei public-Funktionen. Eine dient zum einfachen Hinzufügen von Aktionen, die andere zum einfachen Hinzufügen von Filtern. Beachten Sie, dass jede Komponente drei Komponenten akzeptiert: den Hook-Namen, das Hauptobjekt mit der aufzurufenden Funktion und die Funktion, die während der tatsächlichen Ausführung des Hooks aufgerufen werden soll. Weitere Informationen zu Aktionen und Filtern finden Sie in dieser Referenz.
  • Als nächstes haben wir eine private Funktion, die verwendet wird, um die beiden vorherigen public Funktionen so zu vereinfachen, dass wir einen einzigen Ort haben, an dem der Hook dem richtigen Array hinzugefügt werden kann.
  • Schließlich haben wir eine run-Funktion, mit der alle definierten Hooks verkabelt werden. Dadurch werden alle unsere benutzerdefinierten Funktionen bei WordPress registriert.

Während wir den Rest des Plugins weiter erstellen, wird diese bestimmte Klasse verwendet.

Das Administrations-Dashboard

Dieser Teil des Plugins enthält alle Dateien, die sich im admin-Verzeichnis befinden. Wenn Sie sich an den vorherigen Artikel erinnern, haben wir eine Primärklasse, ein Stylesheet und eine einzelne Datei, die zum Rendern der Ansicht des Inhalts verwendet werden.

Wir werden uns jede dieser Dateien ansehen, damit sie ab der Core-Admin-Klasse verwendet werden.

Single Post Meta Manager Admin

Dies ist die Kernklasse, die für die Registrierung der Stylesheets, der Meta-Box und der Datei verantwortlich ist, die den Inhalt der Meta-Box rendert.

Werfen wir einen Blick auf den vollständigen Code und überprüfen dann, was er tut.

1
<?php
2
3
class Single_Post_Meta_Manager_Admin {
4
5
    private $version;
6
7
    public function __construct( $version ) {
8
        $this->version = $version;
9
    }
10
11
    public function enqueue_styles() {
12
13
        wp_enqueue_style(
14
            'single-post-meta-manager-admin',
15
            plugin_dir_url( __FILE__ ) . 'css/single-post-meta-manager-admin.css',
16
            array(),
17
            $this->version,
18
            FALSE
19
        );
20
21
    }
22
23
    public function add_meta_box() {
24
25
        add_meta_box(
26
            'single-post-meta-manager-admin',
27
            'Single Post Meta Manager',
28
            array( $this, 'render_meta_box' ),
29
            'post',
30
            'normal',
31
            'core'
32
        );
33
34
    }
35
36
    public function render_meta_box() {
37
        require_once plugin_dir_path( __FILE__ ) . 'partials/single-post-meta-manager.php';
38
    }
39
40
}

Dies ist eine relativ einfache Klasse, die davon ausgeht, dass Sie mit wp_enqueue_style und add_meta_box vertraut sind. Wenn nicht, überprüfen Sie die verlinkten Artikel und kehren Sie dann zu diesem Beitrag zurück.

Schauen wir uns als nächstes an, was der Rest der Klasse tut:

  • Beachten Sie, dass es ein private-Attribut gibt, mit dem die Version des Plugins verfolgt wird. Dieser Wert wird an den Konstruktor der Klasse übergeben und hauptsächlich verwendet, um sicherzustellen, dass wir die neueste Version des Plugins in die Warteschlange einbeziehen, um sicherzustellen, dass alle Dateien, die beim Ausführen zwischengespeichert werden, beschädigt werden dieses Plugin.
  • Dann haben wir eine public-Funktion, mit der das mit dem Dashboard verknüpfte Stylesheet registriert wird, und eine öffentliche Funktion, mit der dem post-Type-Dashboard ein Meta-Feld hinzugefügt wird.
  • Schließlich haben wir eine weitere öffentliche Funktion (die technisch aus dieser Klasse heraus aufgerufen wird), um den Inhalt der Meta-Box zu rendern. Der Inhalt dieser Datei befindet sich in einer externen Datei, die wir uns kurz ansehen werden.

Obwohl wir später alles genauer sehen werden, werden Sie möglicherweise feststellen, dass die Funktion, mit der die Stylesheets in die Warteschlange gestellt werden, nirgendwo anders referenziert wird. Hier kommt schließlich die Loader-Klasse ins Spiel.

Single Post Meta Manager Teilweise

Einige Entwickler schreiben gerne das Markup für Meta-Box-Ansichten in PHP und speichern sie in wirklich langen Zeichenfolgen.

Ich bin kein Fan dieses Ansatzes, da Ansichten (oder Teilvorlagen oder Vorlagen oder wie auch immer Sie sie nennen möchten) normalerweise zum Anzeigen von Daten verwendet werden und daher aus mehr Markups als alles andere bestehen. Zu diesem Zweck denke ich, dass sie ihre eigene Datei sein sollten.

In diesem Fall möchten wir eine Datei haben, die alle mit dem aktuellen Beitrag verknüpften Metadaten in einem table-Element rendert, das in der Meta-Box enthalten ist.

Das Markup für diese Datei sieht folgendermaßen aus:

1
<div id="single-post-meta-manager">
2
3
    <?php $post_meta = get_post_meta( get_the_ID() ); ?>
4
    <table id="single-post-meta-manager-data">
5
    <?php foreach ( $post_meta as $post_meta_key => $post_meta_value ) { ?>
6
        <tr>
7
            <td class="key"><?php echo $post_meta_key; ?></td>
8
            <td class="value"><?php print_r( $post_meta_value[0] ); ?></td>
9
        </tr>
10
    <?php } ?>
11
    </table>
12
13
</div><!-- #single-post-meta-manager -->

Obwohl das Markup und das minimale PHP, das in dieser Datei enthalten ist, relativ selbsterklärend sein sollten, hängt es von Ihrem Wissen über die Funktionen get_post_meta und get_the_ID ab.

Sobald alle Metadaten des Beitrags abgerufen wurden, durchlaufen wir die Informationen (unter Verwendung eines der Schleifenkonstrukte, die wir viel früher behandelt haben) und zeigen dann sowohl den Metaschlüssel als auch den Wert an.

Die einfachen Post-Meta-Admin-Stile

Das Letzte, was wir für den Inhalt in der Meta-Box tun müssen, ist, die Stile im Stylesheet bereitzustellen, die wir in der Kern-Admin-Klasse in die Warteschlange gestellt haben.

Dazu bearbeiten wir css/simple-post-meta-manager.css.

1
#single-post-meta-manager-data {
2
    width:  100%;
3
}
4
5
#single-post-meta-manager-data .key {
6
    font-weight: bold;
7
}

Das ist natürlich sehr einfach. Es bietet nichts Besonderes als das Festlegen der Breite der Tabelle auf 100% des Containers und Fettdruck der Metaschlüsselwerte.

Aber das ist genug für das, was wir jetzt tun wollen.

Die Core Plugin Datei

An dieser Stelle müssen wir die Kern-Plugin-Datei definieren. Dies ist die Datei, die die Version des Plugins definiert, den Slug des Plugins (der normalerweise bei der Internationalisierung und anderen Funktionen verwendet wird), den Loader instanziiert und alle erforderlichen Hooks bei WordPress registriert.

Werfen wir einen Blick auf den Code und überprüfen ihn, sobald wir alles definiert haben:

1
<?php
2
3
class Single_Post_Meta_Manager {
4
5
    protected $loader;
6
7
    protected $plugin_slug;
8
9
    protected $version;
10
11
    public function __construct() {
12
13
        $this->plugin_slug = 'single-post-meta-manager-slug';
14
        $this->version = '0.2.0';
15
16
        $this->load_dependencies();
17
        $this->define_admin_hooks();
18
19
    }
20
21
    private function load_dependencies() {
22
23
        require_once plugin_dir_path( dirname( __FILE__ ) ) . 'admin/class-single-post-meta-manager-admin.php';
24
25
        require_once plugin_dir_path( __FILE__ ) . 'class-single-post-meta-manager-loader.php';
26
        $this->loader = new Single_Post_Meta_Manager_Loader();
27
28
    }
29
30
    private function define_admin_hooks() {
31
32
        $admin = new Single_Post_Meta_Manager_Admin( $this->get_version() );
33
        $this->loader->add_action( 'admin_enqueue_scripts', $admin, 'enqueue_styles' );
34
        $this->loader->add_action( 'add_meta_boxes', $admin, 'add_meta_box' );
35
36
    }
37
38
    public function run() {
39
        $this->loader->run();
40
    }
41
42
    public function get_version() {
43
        return $this->version;
44
    }
45
46
}

Die Klasse enthält die folgenden Attribute:

  • Die Version, die im gesamten Plugin weitergegeben wird, um nicht nur die aktuelle Arbeitsversion zu definieren, sondern auch Funktionen wie Cache-Busting-Funktionen für unsere Stylesheets bereitzustellen.
  • Es gibt einen Plugin-Slug, der für Internationalisierungszwecke sowie zu anderen Zeiten verwendet werden kann, wenn eine eindeutige Kennung benötigt wird.
  • Ein Verweis auf den Loader, den wir zuvor in dieser Datei definiert haben.

Die obigen Attribute werden alle im Konstruktor festgelegt, es werden jedoch auch mehrere andere Funktionen aufgerufen.

  • load_dependencies wird verwendet, um alle Dateien zu importieren, die in diesem Plugin verwendet werden, z. B. den Admin Manager und den Loader.
  • Mit define_admin_hooks nutzen wir den Loader, um die in unserer Admin-Klasse definierten Funktionen zu koordinieren, die unsere Stile und unsere Meta-Box mit WordPress in die Warteschlange stellen. Auf diese Weise trennen wir die Anliegen unseres Plugins und stellen sicher, dass jede Klasse einen einzigen Zweck hat.
  • run ist die Funktion, die alles in Bewegung setzt, sodass alle Funktionen des Plugins ausgeführt werden, wenn es in WordPress aktiviert wird.

Nur dass uns noch ein letztes Stück fehlt: Wie instanziieren wir tatsächlich die Kern-Plugin-Klasse und starten den Prozess?

Der Plugin Boot Loader

Dazu nutzen wir eine Datei im Stammverzeichnis des Plugin-Verzeichnisses. Einige Leute nennen dies eine Plugin-Bootstrap-Datei, andere einen Bootloader und andere die Haupt-Plugin-Datei.

Wie auch immer Sie es nennen, dies ist die Datei, die sich bei WordPress registriert und alles in Bewegung setzt. Werfen wir einen Blick auf den Code und überprüfen anschließend, was er anschließend tut:

1
<?php
2
/*

3
 * Plugin Name:       Single Post Meta Manager

4
 * Plugin URI:        http://github.com/tommcfarlin/post-meta-manager

5
 * Description:       Single Post Meta Manager displays the post meta data associated with a given post.

6
 * Version:           0.2.0

7
 * Author:            Tom McFarlin

8
 * Author URI:        http://tommcfarlin.com

9
 * Text Domain:       single-post-meta-manager-locale

10
 * License:           GPL-2.0+

11
 * License URI:       http://www.gnu.org/licenses/gpl-2.0.txt

12
 * Domain Path:       /languages

13
 */
14
15
if ( ! defined( 'WPINC' ) ) {
16
    die;
17
}
18
19
require_once plugin_dir_path( __FILE__ ) . 'includes/class-single-post-meta-manager.php';
20
21
function run_single_post_meta_manager() {
22
23
    $spmm = new Single_Post_Meta_Manager();
24
    $spmm->run();
25
26
}
27
28
run_single_post_meta_manager();

Der Codekommentar oben in der Datei ist dafür verantwortlich, WordPress mitzuteilen, dass das Plugin vorhanden ist, und ihm genügend Informationen über das Plugin zu geben, damit es im Dashboard angezeigt werden kann.

Die erste Bedingung, die Sie sehen, verhindert, dass direkt auf die Plugin-Datei zugegriffen wird. Dies ist nichts weiter als eine einfache Sicherheitsmaßnahme.

Schließlich rufen wir require_once auf, um die oben betrachtete Kern-Plugin-Datei einzuschließen. Anschließend definieren wir eine Funktion und instanziieren den Single_Post_Meta_Manager. Anschließend rufen wir run auf, wodurch alles in Bewegung gesetzt wird.

Schließlich rufen wir die Funktion auf, die wir ganz am Ende der Datei definiert haben. Dies startet den Prozess und erweckt das Plugin zum Leben.

Was ist weiter?

Zu diesem Zeitpunkt haben wir die Funktionalität unseres Plugins abgeschlossen. Wir sind jedoch immer noch nicht fertig. Es gibt noch eine weitere Sache, die wir tun müssen, um sicherzustellen, dass wir alle Best Practices befolgen, die in einem Plugin enthalten sind und die Dokumentation bereitstellen.

Im nächsten Beitrag machen wir eine Pause von den Artikeln in längerer Form, in denen Code geschrieben wird, überprüfen die WordPress-Dokumentationsstandards und dokumentieren dann das Plugin, damit wir alle Funktionen vollständig abrunden können.

Laden Sie das Beispiel-Plugin herunter, untersuchen Sie, wie alles zusammenpasst, und hinterlassen Sie Kommentare oder Fragen zu unserer bisherigen Arbeit.

Advertisement
Did you find this post useful?
Want a weekly email summary?
Subscribe below and we’ll send you a weekly email summary of all new Code tutorials. Never miss out on learning about the next big thing.
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.