Building a Simple Blog System in PHP

Table of Contents

• Introduction to Building a Blog System
• Key Features of a Blog System
• Setting Up the Database for the Blog System
• Creating the Blog Model and Database Operations
• Building the Blog Pages
• Creating the Blog Post Form
• Displaying Posts on the Blog Index Page
• Handling Post Creation and Edit Operations
• Conclusion

Introduction to Building a Blog System

A blog system is a perfect project for anyone looking to practice PHP and work with databases. In this module, we will guide you through the process of building a simple blog system using PHP and MySQL. The blog system will have basic features such as displaying posts, creating new posts, and editing existing posts.

By the end of this module, you will have built a functioning blog system with PHP, and you’ll understand how to manage blog posts in a dynamic and interactive way.

Key Features of a Blog System

Before diving into the code, let’s first define the key features that we will implement in this blog system:

1. Blog Post Creation: Users can create new blog posts by filling out a form.
2. Blog Post Display: The system will display a list of all blog posts on the index page.
3. Blog Post Editing: Users can edit existing posts after they are created.
4. Post Storage: All posts will be stored in a MySQL database.
5. Simple User Interface: The blog will have a minimal interface for managing posts.

Setting Up the Database for the Blog System

To begin, we need a MySQL database to store our blog posts. We will create a table to hold the information about each post, including the title, content, and creation date.

Here’s the SQL to create the blog posts table:

CREATE TABLE posts (
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    content TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

• id: A unique identifier for each post.
• title: The title of the blog post.
• content: The content of the blog post.
• created_at: The timestamp for when the post was created.

This will be our basic table structure, which we’ll expand on as needed.

Creating the Blog Model and Database Operations

In a real-world PHP application, it’s a good practice to separate the logic for interacting with the database into a model. Let’s create a simple model to handle blog post operations, such as creating, retrieving, and updating posts.

Database Connection

Create a file db.php to handle the database connection:

<?php
// db.php
$host = 'localhost';
$dbname = 'blog_system';
$username = 'root';
$password = '';

try {
    $pdo = new PDO("mysql:host=$host;dbname=$dbname", $username, $password);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $e) {
    die("Could not connect to the database $dbname :" . $e->getMessage());
}
?>

This file will establish a connection to the MySQL database using PDO.

Blog Model

Create a file BlogModel.php to handle the operations related to blog posts:

<?php
require_once 'db.php';

class BlogModel {
    public function createPost($title, $content) {
        global $pdo;
        $sql = "INSERT INTO posts (title, content) VALUES (?, ?)";
        $stmt = $pdo->prepare($sql);
        $stmt->execute([$title, $content]);
    }

    public function getPosts() {
        global $pdo;
        $sql = "SELECT * FROM posts ORDER BY created_at DESC";
        $stmt = $pdo->query($sql);
        return $stmt->fetchAll(PDO::FETCH_ASSOC);
    }

    public function getPostById($id) {
        global $pdo;
        $sql = "SELECT * FROM posts WHERE id = ?";
        $stmt = $pdo->prepare($sql);
        $stmt->execute([$id]);
        return $stmt->fetch(PDO::FETCH_ASSOC);
    }

    public function updatePost($id, $title, $content) {
        global $pdo;
        $sql = "UPDATE posts SET title = ?, content = ? WHERE id = ?";
        $stmt = $pdo->prepare($sql);
        $stmt->execute([$title, $content, $id]);
    }

    public function deletePost($id) {
        global $pdo;
        $sql = "DELETE FROM posts WHERE id = ?";
        $stmt = $pdo->prepare($sql);
        $stmt->execute([$id]);
    }
}
?>

The BlogModel class handles the basic CRUD operations:

• createPost(): Inserts a new blog post.
• getPosts(): Retrieves all blog posts, ordered by creation date.
• getPostById(): Retrieves a single post by its ID.
• updatePost(): Updates an existing blog post.
• deletePost(): Deletes a post.

Building the Blog Pages

Now that we have the model set up, we can create the front-end pages for our blog system.

Blog Index Page

Let’s create a page index.php to display all blog posts:

<?php
require_once 'BlogModel.php';

$blogModel = new BlogModel();
$posts = $blogModel->getPosts();
?>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Blog System</title>
</head>
<body>
    <h1>Welcome to the Blog</h1>
    <a href="create_post.php">Create New Post</a>
    <h2>Blog Posts</h2>
    <ul>
        <?php foreach ($posts as $post): ?>
            <li>
                <h3><a href="view_post.php?id=<?php echo $post['id']; ?>"><?php echo $post['title']; ?></a></h3>
                <p><?php echo substr($post['content'], 0, 100); ?>...</p>
                <a href="edit_post.php?id=<?php echo $post['id']; ?>">Edit</a> |
                <a href="delete_post.php?id=<?php echo $post['id']; ?>">Delete</a>
            </li>
        <?php endforeach; ?>
    </ul>
</body>
</html>

This page:

• Retrieves and displays all blog posts from the database.
• Links to a page for creating a new post (create_post.php).
• Provides links to view individual posts, edit, or delete them.

Creating the Blog Post Form

Next, let’s create a page where users can create a new blog post. Create create_post.php:

<?php
require_once 'BlogModel.php';

if ($_SERVER['REQUEST_METHOD'] == 'POST') {
    $title = $_POST['title'];
    $content = $_POST['content'];

    $blogModel = new BlogModel();
    $blogModel->createPost($title, $content);

    header('Location: index.php');
    exit();
}
?>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Create New Post</title>
</head>
<body>
    <h1>Create New Blog Post</h1>
    <form action="create_post.php" method="POST">
        <label for="title">Title:</label>
        <input type="text" id="title" name="title" required>
        <br>
        <label for="content">Content:</label>
        <textarea id="content" name="content" required></textarea>
        <br>
        <button type="submit">Create Post</button>
    </form>
</body>
</html>

This form collects the title and content for a new blog post and submits it to the server using a POST request. Upon successful submission, the user is redirected to the blog index page.

Handling Post Creation and Edit Operations

For editing blog posts, you would follow similar steps as the ones for creating posts. You can use getPostById() to retrieve the post you want to edit and display its current content in a form. After the user makes changes, you would update the post using the updatePost() method.

Conclusion

In this module, we walked through the steps to create a simple blog system using PHP and MySQL. We:

• Set up the MySQL database and PHP database connection.
• Created a model to handle CRUD operations for blog posts.
• Built the front-end pages to display posts, create new posts, and edit existing posts.

This simple blog system serves as a great starting point for understanding how PHP can interact with a database to create dynamic content. In real-world applications, you would likely add more advanced features like user authentication, comments, categories, and more.