PHP – MVC CRUD y conexión a MySQL usando PDO

El conocimiento básico siempre es muy importante, en este artículo te introduciré a cómo utilizar el modelo PHP – MVC, usando PDO para conectarte a MySQL.

¿Qué es PDO?

Es un acrónimo de ‘PHP Data Objects’ (Objetos de Datos de PHP). Hasta ahora, las funciones utilizadas estaban divididas según el tipo de base de datos.

Por ejemplo:

  • Cuando se conectaba a MySQL, solía hacerlo con la función ‘mysql_connect’.
  • En el caso de PostgreSQL, se conectaba con la función ‘pg_connect’.

No hay problema si la base de datos está fija, pero si cambias o migras a una base de datos diferente en el futuro, tendrás que reescribir todo.

Pero si usas la clase PDO, la misma función puede ser usada independientemente de la base de datos que se utilice, por lo que si cambias la base de datos en el futuro, solo necesitarás cambiar los parámetros que especificaste al crear la clase PDO (parece que hay algunas diferencias dependiendo de la base de datos…)

Aprendamos cómo conectarnos a una base de datos usando la clase PDO en este artículo.

Procederemos con las siguientes condiciones:

  • PHP es PHP 5.3.6 o superior.
  • La base de datos es MySQL.
  • La codificación de caracteres es UTF-8.

I. Conectar a la base de datos con PDO


Supongo, por ejemplo, que tienes una base de datos con la siguiente información:

Name: YOUR_DB_NAME,
Username: root
Password: 123456
Port: 3306
Table: users (id, first_name, last_name, age)

«Crear una clase DB y utilizar PDO para conectarte a tu base de datos de la siguiente manera. Especifica la codificación de caracteres. Ten en cuenta que es utf8, no UTF-8.

Crea el archivo connection.php en tu directorio raíz:»

connection.php

class DB
{
/**
* Static variable DB Name
*/
public function config()
{
return [
‘db_name’ => ‘YOUR_DB_NAME’,
];
}

/**
* Connect to Database
*/
public static function getInstance()
{
$db = new DB();
$db_name = $db->config()[‘db_name’];

try {
$pdo = new PDO(‘mysql:host=localhost; port=3306; dbname=’ . $db_name, ‘root’, ‘123456’);
$pdo->exec(“SET NAMES ‘utf8′”);
} catch (PDOException $ex) {
$pdo = $ex->getMessage();
}

return $pdo;
}
}

«Usando la declaración de PDO anterior, pudimos conectarnos a la base de datos exitosamente.

Al ejecutar declaraciones SQL con PDO, se pueden usar los siguientes dos tipos de métodos:

  • query
  • prepare

A continuación, veamos más de cerca cada método.

Además, crearemos Controlador, Modelo, Vista para obtener datos a través de PDO.

II. Controlador, Modelo, Vista

  1. Crea IndexController.php en la carpeta /root/controllers

controllers/UsersController.php»

require_once (‘controllers/BaseController.php’);
require_once (‘models/user.php’);

class UsersController extends BaseController
{
/**
* Construct
*/
public function __construct()
{
$this->folder = ‘users’;

// Call perpage of pagination setting
$this->status_success = 1;
$this->status_error = 0;
$this->per_page = 10;

$this->save_success = ‘Data has been saved successfuly’;
$this->save_error = ‘Data has been saved failed’;
$this->delete_success = ‘Data has been deleted successfuly’;
$this->delete_error = Data has been deleted failed;
}

/**
* Index
*/
public function index()
{
// Set default perpage
$per_page = $this->per_page

[$users, $pagination, $page_total] = User::all($per_page);

$data = [‘users’ => $users, ‘pagination’ => $pagination, ‘per_page’ => $per_page, ‘page_total’ => $page_total];

$this->render(‘index’, $data);
}
}

2. Crea BaseController.php en la carpeta /root/controllers

controllers/BaseController.php

/**
* Base Controller
*/
class BaseController
{
// variable folder name in to access views folder
protected $folder;

/**
* Show result to views
*/
function render($file, $data = array()) {
// Check exist current file
$view_file = ‘views/’ . $this->folder . ‘/’ . $file . ‘.php’;

if (is_file($view_file)) {
// if exist file, create variable and add to call function
extract($data);

// Save data and show with variable to views
ob_start();
require_once($view_file);
$content = ob_get_clean();

// use common template
require_once(‘views/layouts.php’);
} else {
// if file not exist, show error page
header(‘Location: index.php?controller=pages&action=error’);
}
}
}

  1. A continuación, cree el archivo user.php en la carpeta /root/models.

modelos/usuario.php

/**
* User Model
*/
Class User
{
/**
* List all
*/
public function all($per_page)
{
$db = DB::getInstance();
if (isset($_GET[‘page’])) {
$page = (int)$_GET[‘page’];
} else {
$page = 1;
}

if ($page > 1) {
$start = ($page * $per_page) – $per_page;
} else {
$start = 0;
}

// query get pagination, page_total
$page_num = $db->prepare(“SELECT count(*) FROM users WHERE ‘last_name’ = ? AND age = ?”);
$page_num->execute();
$page_total = $page_num->fetchColumn();
$pagination = ceil($page_total / $per_page);

// query get list data
// your query is select all of them (SELECT * FROM users LIMIT {$start}, $per_page)
// or add conditions with last_name and age value

$last_name = ‘John’;
$age = 20;
$request = $db->prepare(“SELECT * FROM users WHERE ‘last_name’ = ? AND age = ? LIMIT {$start}, $per_page “);

$lists = [];
if ($request->execute([$last_name, $age]) {
foreach ($request->fetchAll() as $item) {
$list = [];
$list[‘first_name’] = $item[‘first_name’];
$list[‘last_name’] = $item[‘last_name’];
$list[‘age’] = $item[‘age’];

$lists[] = $list;
}
}

return [$lists, $pagination, $page_total];
}
}

Nota: Para el método Select con PDO, puedes usar uno de los dos métodos a continuación. En el ejemplo anterior, utilicé el método 1 por el código más corto.

// Pattern 1
$request = $db->prepare(“SELECT * FROM users WHERE ‘last_name’ = ? AND age = ?”);
$request->execute([‘John’, 20]);

// Pattern 2
$request = $dbh->prepare(“SELECT * FROM users WHERE last_name = :last_name AND age = :age”);
$request->bindValue(‘:last_name’, ‘John’);
$request->bindValue(‘:age’, 20, PDO::PARAM_INT);
$request->execute();

4. A continuación, crea el archivo de vista en la carpeta /root/views/users

views/users/index.php

   // Display form data in your template
var_dump($users);
echo $patination;
echo $page_total;
?>

5. Crea el archivo de diseño de plantilla en la carpeta /root/views

views/layouts.php

Este es un diseño muy simple.

6. Por último, creamos los archivos index.php y routes.php en el directorio raíz. El archivo de enrutamiento para la navegación.

  • index.php

 require_once(‘connection.php’);

if (isset($_GET[‘controller’])) {
$controller = $_GET[‘controller’];
if (isset($_GET[‘action’])) {
$action = $_GET[‘action’];
} else {
$action = ‘index’;
}
} else {
$controller = ‘pages’;
$action = ‘home’;
}

require_once(‘routes.php’);
?>

– routes.php

$controllers = array(
‘users’ => [‘index’, ‘create’, ‘edit’, ‘store’, ‘update’, ‘delete’],
);

if (!array_key_exists($controller, $controllers) || !in_array($action, $controllers[$controller])) {
$controller = ‘pages’;
$action = ‘error’;
}

if (strpos($controller, ‘users’) !== false) {
include_once(‘controllers/’ . $controller . ‘Controller.php’);
}

$class = str_replace(‘_’, ”, ucwords($controller)) . ‘Controller’;
$controller = new $class;
$controller->$action();
?>

Hemos completado el modelo básico PHP-MVC, con la consulta de selección de datos utilizando PDO. A continuación, implementaremos los modelos de inserción, actualización y eliminación. El contenido se editará en los archivos que creamos anteriormente.

  1. Editar UsersController

En UsersController.php, agrega las funciones create, edit, store, update y delete.

require_once (‘controllers/BaseController.php’);
require_once (‘models/user.php’);

class UsersController extends BaseController
{
/**
* Create view
*/
public function create()
{
// It return add view in views/users/create.php
$this->render(‘add’);
}

/**
* Store Action
*/
public function store()
{
$result = User::store();

if ($result == $this->status_success) {
$_SESSION[‘alert_success’] = $this->save_success;
echo ”;
} else {
$_SESSION[‘alert_danger’] = $this->save_error;
echo ”;
}
}

/**
* Edit view
*/
public function edit()
{
// It return add view in views/users/edit.php
$user = User::find($id);
$data = [‘user’ => $user];
$this->render(‘edit’, $data);
}

/**
* Update Action
*/
public function update()
{
$result = User::update();

if ($result == $this->status_success) {
$_SESSION[‘alert_success’] = $this->save_success;
echo ”;
} else {
$_SESSION[‘alert_danger’] = $this->save_error;
echo ”;
}
}

/**
* Delete Action
*/
public function delete()
{
$result = User::delete();

if ($result == $this->status_success) {
$_SESSION[‘alert_success’] = $this->delete_success;
echo ”;
} else {
$_SESSION[‘alert_danger’] = $this->delete_error;
echo ”;
}
}
}

8. En el archivo del modelo models/user.php, añade las funciones find, store, update y delete.

/**
* Find
*/
public function find(int $id)
{
$db = DB::getInstance();
$sql = $db->prepare(“SELECT * FROM users WHERE id = ? “);
$sql->execute([$id]);
$list = [];
if ($item = $sql->fetch()) {
// code …
}

return $list;
}

/**
* Store Action
*/
public function store()
{
try {
$db = DB::getInstance();
// insert to users table
$sql = “INSERT INTO users (first_name, last_name, age) VALUES (?, ?, ?)”;
$row = $db->prepare($sql);

if ($row->execute([$first_name, $last_name, $age])) {
$result = 1; // successful
} else {
$result = 0; // failed
}
} catch (PDOException $ex) {
$result = $ex->getMessage();
}
return $result;
}

/**
* Update Action
*/
public function update()
{
try {
$db = DB::getInstance();
// update to users table
$sql = “UPDATE users SET first_name = ?, last_name = ?, age = ? WHERE id = ?”;
$row = $db->prepare($sql);

if ($row->execute([$first_name, $last_name, $age, $id])) {
$result = 1; // successful
} else {
$result = 0; // failed
}
} catch (PDOException $ex) {
$result = $ex->getMessage();
}
return $result;
}

/**
* Delete Action
*/
public function delete(int $id)
{
try {
$db = DB::getInstance();
// delete to users table
$sql = “DELETE FROM users WHERE id = ?”;
$row = $db->prepare($sql);

if ($row->execute([$id])) {
$result = 1; // successful
} else {
$result = 0; // failed
}
} catch (PDOException $ex) {
$result = $ex->getMessage();
}
return $result;

}

9. En la carpeta views/users/

Crea create.php, edit.php y edit index.php

  • create.php y edit.php, el código simple está abajo

// Open form

form id=”frmAction” method=”post” action=”index.php?controller=users&action=store” enctype=”multipart/form-data”>

// Input element

// Close form

– index.php

III. Conclusión

Nuestro código MVC se ve así:»

– controllers
+ UsersController.php
– models
+ user.php
– views
+ users/create.php
+ users/edit.php
+ users/index.php
+ layouts.php
– connection.php
– routes.php

Arriba tienes un ejemplo sencillo de PHP-MVC, usando PDO para manipular MySQL. PDO también te ayuda a evitar algunos errores de inyección SQL. Por lo tanto, si no estás utilizando ningún framework de PHP, probar PDO es una excelente opción.

Muchas gracias por leer esta publicación.

1 comentario en «PHP – MVC CRUD y conexión a MySQL usando PDO»

Deja un comentario