Åpen kildekode · Ata
Gi WordPress-pluginen din et løft.
Med MVC-S-struktur.
ATA hjelper utviklere av WordPress-plugins å holde voksende kodebaser ryddige og vedlikeholdbare med designmønsteret MVC.
For utviklere av WordPress-plugins
En mappe for alt.
ATA gir hver plugin den samme forutsigbare strukturen, slik at voksende kodebaser forblir ryddige og vedlikeholdbare.
ATA Folder STRUCTURE
your-plugin-name/
├── app/
│ ├── apis/ # REST API endpoint classes
│ ├── controllers/ # Controller classes
│ ├── helpers/ # Global helper functions
│ ├── models/ # Data logic (database interaction)
│ │ └── structures/ # Optional: DTOs/data structure classes
│ ├── routes/ # API and custom URL definitions
│ ├── services/ # Business logic layer
│ └── views/ # View files (HTML/PHP templates)
│
├── base/ # Base classes your app classes extend
├── config/ # Plugin-wide configuration
├── constants/ # Custom constant definitions
├── inc/ # Bootstrapping and initialization files
├── vendor/ # Composer dependencies (includes the core ATA framework)
│
└── your-plugin-name.php # The main plugin entry file
Kjerneprinsippene i Ata.
Strukturert som standard
ATA gir deg en forhåndsdefinert mappestruktur som skiller de ulike delene av pluginen din på en logisk måte.
Objektorientert først
Den oppmuntrer til å skrive kode i klasser i stedet for prosedyrebaserte funksjoner, noe som gir bedre gjenbruk og organisering av koden.
Tydelig ansvarsdeling
Den bruker en variant av MVC-mønsteret for å holde logikk, data og presentasjon i separate lag.
Forenklet ruting
ATA har en innebygd router som gjør det enkelt og deklarativt å registrere egne REST API-endepunkter eller egne URL-er.
Viktige forskjeller
Hva er MVC-S?
ATA bygger på en variant av Model-View-Controller-mønsteret (MVC), som vi kaller MVC-S (Model-View-Controller-Services).
Controller (den sentrale motoren)
Controlleren er kjernen i hvordan pluginen din fungerer. Den håndterer innkommende forespørsler, registrerer alle WordPress-hooks og -filtre og styrer flyten i applikasjonen. I enkle plugins kan Controlleren håndtere all logikk og datatilgang direkte. I mer komplekse applikasjoner blir rollen dens å orkestrere: Den kaller en Service for forretningslogikk eller en Model for data, og sender deretter resultatet videre til en View for visning.
View (presentasjonslaget)
View er et valgfritt lag for å generere HTML. Det mottar data fra Controlleren og viser dem. En View bør inneholde minimalt med PHP-logikk og bare konsentrere seg om å vise dataene den får.
Model (datalaget)
Modellens eneste ansvar er direkte samhandling med databasen. I en Model-klasse får du tilgang til WordPress-databaseobjektet via $this->db (f.eks. $this->db->get_results(...)). Dette laget er valgfritt; bruker ikke pluginen din databasen, trenger du det ikke.
Service (logikklaget)
Service-laget er et valgfritt, men anbefalt sted for kjernelogikken i pluginen din. Når logikken blir for kompleks for en Controller, bør du trekke den ut i en Service. Slik holdes Controllerne slanke og fokusert på å håndtere forespørsler.
Eksempel-plugin
Polylang RestAPI Helper
Pluginen polylang-restapi-helper er et perfekt, fokusert eksempel på ATA-rammeverket.
Slik gir du WordPress-pluginen din ATA MVC
Dokumentasjon
Kom i gang med ATA i pluginen din, raskt og enkelt
Pluginens livssyklus & hovedcontrolleren
Hver ATA-plugin styres av en sentral rot-Controller. Denne hovedcontrolleren er inngangspunktet for all funksjonalitet i pluginen og har ansvaret for pluginens livssyklus.
1. Hovedfilen for pluginen (your-plugin-name.php) Denne filen er svært minimal. Den skal bare definere nødvendige konstanter, laste ATA-rammeverket og instansiere hovedcontrolleren din.
// in your-plugin-name.php
namespace YourPluginNamespace;
// ... define constants ...
// Load the framework and all its dependencies
require_once PLUGIN_PATH . '/inc/main.php';
// Instantiate the one and only root controller
$my_plugin = new MainController();
// Hook into WordPress's activation/deactivation events
register_activation_hook(PLUGIN_FILE, [$my_plugin, 'activate']);
register_deactivation_hook(PLUGIN_FILE, [$my_plugin, 'deactivate']);
2. Hovedcontrolleren (app/controllers/main-controller.php) Denne controlleren inneholder logikken for aktivering og deaktivering, og, viktigst av alt, laster alle de andre controllerne. Her kan du laste funksjoner betinget, avhengig av om andre plugins er aktive, noe som sparer minne og forhindrer feil.
// in app/controllers/main-controller.php
namespace YourPluginNamespace;
class MainController extends Controller
{
public function __construct()
{
parent::__construct();
$this->load_features();
}
// Load other controllers for specific features
private function load_features()
{
// Always load the admin UI and asset controllers
(new AdminUiController())->main();
(new AssetsController())->main();
// **Conditionally load features**
// Only load the WooCommerce compatibility layer if WooCommerce is active
if (is_plugin_active('woocommerce/woocommerce.php')) {
(new WooCommerceController())->main();
}
}
// Logic for when the plugin is activated (e.g., create DB tables)
public function activate()
{
// ... your activation code ...
}
// Logic for when the plugin is deactivated (e.g., remove DB tables)
public function deactivate()
{
// ... your deactivation code ...
}
}
Legge til en side eller fane i WordPress-adminpanelet
ATA har et flytende grensesnitt for enkelt å lage adminsider med flere faner. Dette styres fra en controller.
// in app/controllers/admin-ui-controller.php
namespace YourPluginNamespace;
class AdminUiController extends Controller
{
public function main()
{
$this->add_wp_admin_pages();
}
private function add_wp_admin_pages()
{
// Create a top-level page titled "My Plugin"
$this->admin_page('My Plugin')
// Only users who can 'manage_options' can see it
->permission('manage_options')
// Add a "Dashboard" tab (calls the 'dashboard_page' method)
->add_tab('Dashboard', 'dashboard_page')
// Add a "Settings" tab (calls the 'settings_page' method)
->add_tab('Settings', 'settings_page')
// Register the page and all its tabs
->register();
}
// This method is called when the 'Dashboard' tab is active
public function dashboard_page()
{
$this->view = 'dashboard'; // Renders views/dashboard-view.php
}
// This method is called when the 'Settings' tab is active
public function settings_page()
{
$this->view = 'settings'; // Renders views/settings-view.php
}
}
Koble seg på en WordPress-hook (Action)
ATA har en praktisk hjelpemetode, on(), i basecontrolleren for å registrere action-hooks. Konstruktøren eller en main()-metode i controlleren din er det ideelle stedet å registrere alle hooks.
// in app/controllers/footer-message-controller.php
namespace YourPluginNamespace;
class FooterMessageController extends Controller
{
public function main()
{
// Hook into 'wp_footer' to call the 'add_message' method
$this->on('wp_footer', 'add_message');
}
public function add_message()
{
echo "";
}
}
Bruke WordPress-filtre
På samme måte som med actions kan du bruke hjelpemetoden filter() til å endre data.
// in app/controllers/content-controller.php
namespace YourPluginNamespace;
class ContentController extends Controller
{
public function main()
{
// Hook into 'the_content' to modify post content
$this->filter('the_content', 'add_author_bio');
}
public function add_author_bio($content)
{
if (is_single() && in_the_loop() && is_main_query()) {
$author_bio = '';
return $content . $author_bio;
}
return $content;
}
}
Legge til et endepunkt i WordPress REST API
Steg 1: Registrer ruten i app/routes/main-routes.php. Dette forteller WordPress at URL-en din finnes, og hvilken metode som skal håndtere den.
// in app/routes/main-routes.php
namespace YourPluginNamespace;
$ata_router->api_version('my-plugin/v1');
$ata_router->api_method('GET')->api('/products')->call('ProductsApi::get_all_products');
Steg 2: Lag en API-klasse i app/apis/ som inneholder logikken for endepunktet.
// in app/apis/products-api.php
namespace YourPluginNamespace;
class ProductsApi extends Api {
public function get_all_products() {
// ... logic to get products ...
return $this->send_success('Products retrieved.', ['products' => '...']);
}
}
Hvordan fungerer ruting?
Rutefilen (app/routes/main-routes.php) er en kraftig, men valgfri funksjon. Den har bare én jobb: å fungere som et sentralbord som forteller WordPress hvordan bestemte egendefinerte URL-er skal håndteres. Trenger ikke pluginen din egne URL-er eller et REST API, trenger du ikke bruke den.
- For REST API-er: Bruk metoden
api(). Den registrerer et nytt endepunkt under/wp-json/.// Registers: example.com/wp-json/my-plugin/v1/orders $ata_router->api_version('my-plugin/v1'); $ata_router->api('/orders')->call('MyOrdersApi::get_orders'); - For egne frontend-URL-er: Bruk metoden
page(). Den lager en virtuell side uten at du trenger et WordPress-sideinnlegg.// Registers: example.com/my-custom-url/ $ata_router->page('/my-custom-url')->call('MyPageController::show_page');
Hva er de valgfrie kjernemappene til?
app/views
Denne mappen inneholder HTML-malene dine. Den er bare nødvendig hvis pluginen din lager et brukergrensesnitt, for eksempel en innstillingsside i admin eller en egen frontend-side. Plugins som bare tilbyr bakgrunnsfunksjonalitet eller et REST API, vil sannsynligvis ikke ha en views-mappe.
models/structures (DTO-er)
Denne mappen er for Data Transfer Objects (DTO-er). En DTO er en enkel klasse som definerer formen på dataene som sendes rundt. Mappen er valgfri og er kanskje ikke nødvendig for mange plugins. Den er mest nyttig når du må håndheve en streng datastruktur, særlig i kommunikasjon med et eksternt API.
Neste suksesshistorie kan være din.
Har du spørsmål? Vi hjelper deg å ta det riktige valget.