In Magento 2, CRUD operations are essential for creating, reading, updating, and deleting records in the database. Whether you’re developing a custom module or working on an extension, understanding how to implement CRUD operations is fundamental. In this guide, we’ll walk you through the process of creating a simple CRUD model for managing custom data in your Magento 2 store.
Step 1: Create a Custom Module
Before creating a CRUD model, we first need to create a custom module in Magento 2. Let’s call our module Mavenbird_CrudExample. To begin:
- Navigate to the app/code directory in your Magento 2 installation.
- Create a directory structure:
app/code/Mavenbird/CrudExample.
Inside this folder, create the following files:
app/code/Mavenbird/CrudExample/registration.php
app/code/Mavenbird/CrudExample/etc/module.xml
The registration.php file registers the module with Magento:
<?php
\Magento\Framework\Component\ComponentRegistrar::register(
\Magento\Framework\Component\ComponentRegistrar::MODULE,
'Mavenbird_CrudExample',
__DIR__
);
And the module.xml file contains the module’s configuration:
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Module/etc/module.xsd">
<module name="Mavenbird_CrudExample" setup_version="1.0.0" />
Once these files are in place, the module is registered. Next, we can proceed with creating the CRUD model.
Step 2: Create the Model
Now that the module is set up, we’ll create the model that will handle the data. For our example, let’s say we’re managing "items" in the system.
Create the model file Item.php in the app/code/Mavenbird/CrudExample/Model directory:
<?php
namespace Mavenbird\CrudExample\Model;
use Magento\Framework\Model\AbstractModel;
use Mavenbird\CrudExample\Model\ResourceModel\Item as ResourceModel;
class Item extends AbstractModel
{
protected $_idFieldName = 'item_id'; // Primary key field
protected $_name = 'name'; // Field name for the item name
protected $_resourceModel = ResourceModel::class; // Reference to the resource model
// Constructor method to initialize resource model
protected function _construct()
{
$this->_init(\Mavenbird\CrudExample\Model\ResourceModel\Item::class);
}
// Getter method for item ID
public function getId()
{
return $this->_getData($this->_idFieldName);
}
// Getter method for item name
public function getName()
{
return $this->_getData($this->_name);
}
// Setter method for item name
public function setName($name)
{
return $this->setData($this->_name, $name);
}
}
This model defines two fields: item_id and name. We’re using Magento's AbstractModel as the base class, which provides methods for working with the database.
Step 3: Create the Resource Model
The resource model defines how the model interacts with the database table. Create the file Item.php in the app/code/Mavenbird/CrudExample/Model/ResourceModel directory:
<?php
namespace Mavenbird\CrudExample\Model\ResourceModel;
use Magento\Framework\Model\ResourceModel\Db\AbstractDb;
class Item extends AbstractDb
{
// Initialize resource model with table name and primary key
protected function _construct()
{
$this->_init('mavenbird_crudexample_item', 'item_id'); // Table name and primary key
}
}
In this resource model, the table name is mavenbird_crudexample_item (this table will need to exist in your database), and the primary key is item_id.
Step 4: Create the Collection Model
The collection model allows us to retrieve multiple records from the database. It extends the AbstractCollection class. Create the file Collection.php in the app/code/Mavenbird/CrudExample/Model/ResourceModel/Item directory:
<?php
namespace Mavenbird\CrudExample\Model\ResourceModel\Item\Collection;
use Magento\Framework\Model\ResourceModel\Db\Collection\AbstractCollection;
use Mavenbird\CrudExample\Model\Item as Model;
use Mavenbird\CrudExample\Model\ResourceModel\Item as ResourceModel;
class Collection extends AbstractCollection
{
// Define collection’s field names
protected $_idFieldName = 'item_id';
protected $_nameFieldName = 'name';
protected $_itemClass = Model::class;
protected $_resourceModel = ResourceModel::class;
// Constructor method to initialize collection
protected function _construct()
{
$this->_init(Model::class, ResourceModel::class);
}
}
The collection model allows you to fetch all items from the database and is crucial for operations like retrieving lists of records.
Step 5: Create the Controller
To demonstrate the CRUD operations, let’s create a simple controller that fetches and displays all items. Create a file Index.php inside app/code/Mavenbird/CrudExample/Controller/Index:
<?php
namespace Mavenbird\CrudExample\Controller\Index;
use Magento\Framework\App\Action\Action;
use Magento\Framework\App\Action\Context;
use Mavenbird\CrudExample\Model\ResourceModel\Item\CollectionFactory;
class Index extends Action
{
protected $collectionFactory;
public function __construct(Context $context, CollectionFactory $collectionFactory)
{
parent::__construct($context);
$this->collectionFactory = $collectionFactory;
}
// Fetch all items and display their names
public function execute()
{
$collection = $this->collectionFactory->create();
foreach ($collection as $item) {
echo $item->getName(); // Display the name of each item
}
}
}
This controller fetches all items using the collection model and displays their names on the page. You can extend this functionality to handle Create, Update, and Delete actions as needed.
Step 6: Enable the Module
Once the code is in place, enable the module by running the following commands from the Magento root directory:
php bin/magento module:enable Mavenbird_CrudExample
php bin/magento setup:upgrade
php bin/magento cache:flush
After running these commands, your custom module is ready to use. You can test the controller by accessing http://your-magento-site.com/crudexample/index/index to see the list of items.
Conclusion
Creating CRUD models in Magento 2 is a critical skill for building custom modules. By following this guide, you’ve learned how to create models, resource models, collections, and controllers to manage data in your Magento store. At Mavenbird, we focus on making Magento development easier and more efficient. With a solid understanding of CRUD operations, you can extend your Magento store with custom functionalities and integrations. Happy coding!
