Öppen källkod · Ata
Ge ditt WordPress-plugin mer kraft.
Med MVC-S-struktur.
ATA hjälper utvecklare av WordPress-plugins att hålla växande kodbaser organiserade och lätta att underhålla med designmönstret MVC.
För utvecklare av WordPress-plugins
En mapp för allt.
ATA ger varje plugin samma förutsägbara struktur, så att växande kodbaser förblir organiserade och lätta att underhålla.
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
Atas grundprinciper.
Strukturerat från början
ATA har en fördefinierad katalogstruktur som logiskt separerar pluginets olika delar.
Objektorienterat först
Det uppmuntrar till kod i klasser i stället för procedurella funktioner, vilket ger bättre återanvändning och organisation.
Tydlig ansvarsfördelning
Det använder en variant av MVC-mönstret så att logik, data och presentation hålls åtskilda.
Förenklad routing
ATA har en inbyggd router som gör det enkelt och deklarativt att registrera egna REST API-endpoints eller egna URL:er.
Viktiga skillnader
Vad är MVC-S?
ATA förespråkar en variant av mönstret Model-View-Controller (MVC), som vi kallar MVC-S (Model-View-Controller-Services).
Controller (motorn i centrum)
Controllern är kärnan i pluginets drift. Den tar emot inkommande anrop, registrerar alla WordPress-hooks och filter och styr applikationens flöde. I enkla plugins kan controllern sköta all logik och dataåtkomst direkt. I mer komplexa applikationer blir den i stället en dirigent: den anropar en Service för affärslogik eller en Model för data och skickar sedan resultatet vidare till en View för rendering.
View (presentationslagret)
View är ett valfritt lager för att generera HTML. Det tar emot data från controllern och renderar den. En View ska innehålla minimal PHP-logik och bara fokusera på att visa den data den får.
Model (datalagret)
Modellens enda ansvar är direkt interaktion med databasen. I en Model-klass når du WordPress databasobjekt via $this->db (t.ex. $this->db->get_results(...)). Lagret är valfritt; om ditt plugin inte använder databasen behöver du det inte.
Service (logiklagret)
Service-lagret är en valfri men rekommenderad plats för pluginets centrala affärslogik. När logiken blir för komplex för en controller bör du bryta ut den till en Service. Då hålls controllerna smala och fokuserade på att hantera anrop.
Exempelplugin
Polylang RestAPI Helper
Pluginet polylang-restapi-helper är ett perfekt, renodlat exempel på ramverket ATA.
Så bygger du ditt WordPress-plugin med ATA MVC
Dokumentation
Kom igång med ATA i ditt plugin, snabbt och enkelt
Pluginets livscykel & huvudcontroller
Varje ATA-plugin styrs av en central Controller i roten. Huvudcontrollern är ingången till all funktionalitet i pluginet och ansvarar för pluginets livscykel.
1. Pluginets huvudfil (your-plugin-name.php) Filen är mycket minimal. Dess enda uppgifter är att definiera nödvändiga konstanter, ladda ramverket ATA och instansiera din huvudcontroller.
// 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. Huvudcontrollern (app/controllers/main-controller.php) Controllern innehåller logiken för aktivering och inaktivering och, viktigast av allt, laddar alla andra controllers. Här kan du villkorligt ladda funktioner beroende på om andra plugins är aktiva, vilket sparar minne och förebygger fel.
// 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 ...
}
}
Lägg till en sida eller flik i WordPress adminpanel
ATA har ett flytande gränssnitt för att enkelt skapa adminsidor med flera flikar. Det styrs från 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
}
}
Koppla in dig på en WordPress-hook (Action)
ATA har en praktisk hjälpmetod, on(), i sin bascontroller för att registrera action-hooks. Konstruktorn eller en main()-metod i din controller är den perfekta platsen att registrera alla 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 "";
}
}
Använda WordPress-filter
Precis som med actions kan du använda hjälpmetoden filter() för att ändra 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;
}
}
Lägg till en endpoint i WordPress REST API
Steg 1: Registrera routen i app/routes/main-routes.php. Det talar om för WordPress att din URL finns och vilken metod som ska hantera 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: Skapa en API-klass i app/apis/ som innehåller logiken för endpointen.
// 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' => '...']);
}
}
Hur fungerar routing?
Route-filen (app/routes/main-routes.php) är en kraftfull men valfri funktion. Dess enda uppgift är att fungera som en växel som talar om för WordPress hur vissa egna URL:er ska hanteras. Om ditt plugin inte behöver egna URL:er eller ett REST API behöver du inte använda den.
- För REST API:er: Använd metoden
api(). Den registrerar en ny endpoint 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'); - För egna frontend-URL:er: Använd metoden
page(). Den skapar en virtuell sida utan att det behövs en WordPress-sida.// Registers: example.com/my-custom-url/ $ata_router->page('/my-custom-url')->call('MyPageController::show_page');
Vad används de valfria kärnkatalogerna till?
app/views
Här ligger dina HTML-mallar. Katalogen behövs bara om ditt plugin genererar ett användargränssnitt, till exempel en inställningssida i admin eller en egen frontendsida. Plugins som bara erbjuder bakgrundsfunktioner eller ett REST API har troligen ingen views-katalog.
models/structures (DTO:er)
Den här katalogen är till för Data Transfer Objects (DTO:er). En DTO är en enkel klass som definierar formen på data som skickas runt. Katalogen är valfri och behövs inte i många plugins. Den gör störst nytta när du behöver en strikt datastruktur, särskilt vid kommunikation med ett externt API.
Din framgångssaga kan bli nästa.
Har du frågor? Vi hjälper dig att ta rätt beslut.