So erstellen Sie ein objektorientiertes Blog mit PHP

In diesem Artikel werden wir unser Wissen über PHP und MySQL weiter ausbauen, indem wir einen einfachen Blog erstellen. Obwohl es unzählige hervorragende kostenlose Blogging-Plattformen auf dem Markt gibt, besteht der Zweck dieses Tutorials darin, den Prozess der Erstellung einer Blogging-Website zu erkunden, fortgeschrittene Datenbankstrukturtechniken zu erlernen und Daten mithilfe der objektorientierten Programmierung in PHP effizienter zu nutzen.

Für dieses Tutorial gehe ich davon aus, dass Sie über grundlegende Kenntnisse von PHP, MySQL und XHTML verfügen.

Durchsuchen Sie die Datenbankstruktur

Bevor wir in den MySQL-Client springen und mit der Erstellung von Tabellen beginnen, sollten wir im Blog darlegen, was wir wollen. Die offensichtlichsten Dinge, die wir einbeziehen müssen, sind Blog-Beiträge. Jeder Beitrag sollte einen Titel, den Beitrag selbst, den Autor und das Datum seiner Veröffentlichung enthalten.

Jetzt müssen wir nur noch eine Tabelle erstellen, um diese Informationen zu speichern und höchstwahrscheinlich erfolgreich einen einfachen Blog erstellen. Wenn es jedoch nur eine Tabelle gibt, haben wir nicht so viel Kontrolle über die Daten. Wir könnten beispielsweise den Namen des Autors in derselben Tabelle wie den Blog-Beitrag speichern, aber was wäre, wenn wir auch die E-Mail-Adresse des Autors speichern möchten? Das Hinzufügen eines weiteren Feldes zu unserer Tabelle wäre die naheliegende Lösung.

Das Problem entsteht, wenn Sie später die E-Mail-Adresse dieses Autors ändern möchten. Jetzt müssen Sie es für jeden Blog-Beitrag ändern, den diese Person erstellt.

Was wir also tun werden, ist, eine Beziehung namens people 的单独表，其中可以存储有关作者的所有信息，例如电子邮件、URL、姓名和唯一 ID。然后，在我们的 blog_posts 表中，我们将通过该人的唯一 ID 来引用该人。该 ID 称为外键，people 表和 blog_posts zu erstellen. Die Beziehung zwischen den Tabellen wird Eins-zu-viele-Beziehung genannt, da dieselbe Person mehrere Blogbeiträge erstellen kann.

Darüber hinaus möchten wir auch die Möglichkeit bieten, jedem Blog-Beitrag Tags hinzuzufügen. An einen Blog-Beitrag können mehrere Tags angehängt sein, es handelt sich also um eine Eins-zu-viele-Beziehung. Dazu müssen wir eine weitere Tabelle erstellen, deren Name etwa blog_post_tags。该表将包含两个外键：一个用于博客文章的 ID，另一个用于与博客文章关联的标签的 ID。通过这种方式，我们可以为博客文章分配任意数量的标签，并且仍然能够使用简单的 MySQL 查询在所有帖子中编辑有关该特定标签的信息。当然，我们还需要 tags Tabelle sein kann, die die eigentlichen Tags enthält und zwei Felder enthält: id und name.

Da wir nun einen Überblick darüber haben, wie die Datenbankstruktur aussehen sollte, beginnen wir mit der Erstellung. Ich werde PhpMyAdmin verwenden, da es der am weitesten verbreitete MySQL-Verwaltungsclient ist und einfach zu verwenden ist. Beim Erstellen von Datenbank-, Tabellen- und Feldnamen können Sie verschiedene Namenskonventionen verwenden. Ich verwende gerne ausschließlich Kleinbuchstaben und Unterstriche anstelle von Leerzeichen. Sie sollten die Verwendung von Großbuchstaben vermeiden, da dies zu den Best Practices zählt.

Wenn Sie PHP und MySQL nicht auf Ihrem System oder einen Server haben, der diese ausführen kann, empfehle ich den Download eigenständiger Installationen von Apache, PHP und MySQL. MAMP ist für Mac und WAMP ist für PC.

Datenbank und Tabellen erstellen

In diesem Abschnitt erstellen wir weiterhin die Datenbank und die erforderlichen Tabellen für unsere Blog-Site.

Lassen Sie uns fortfahren und eine neue Datenbank namens code_tutsplus_blog erstellen. Sie können eine neue Datenbank mit den folgenden MySQL-Befehlen in PHPMyAdmin oder der MySQL-CLI erstellen:

CREATE DATABASE code_tutsplus_blog;

Nachdem wir die Datenbank erstellt haben, können wir mit der Erstellung der erforderlichen Tabellen fortfahren.

Erstellen Sie eine blog_postsTabelle

Fahren Sie fort und führen Sie den folgenden Befehl aus, um die blog_posts-Tabelle zu erstellen.

CREATE TABLE blog_posts (
  id INT PRIMARY KEY AUTO_INCREMENT,
  title VARCHAR(255),
  post TEXT,
  author_id INT,
  date_posted DATE
);

blog_posts 表有五个字段：id、title、post、author_id 和 date_posted-Tabelle hat fünf Felder:

idWir haben das Feld

id 字段设置为 INT （整数的缩写）类型，因为它应该只存储数值，并且我们将最大长度设置为 11。 title 字段定义为 VARCHAR 类型，最大长度为255。 post 字段定义为 TEXT 类型。 author_id 字段与 id 字段具有相同的数据类型。最后，date_posted 字段被定义为 DATEAls nächstes müssen wir auch den Datentyp jedes Feldes definieren.

创建 people 表

让我们继续创建下一个表，名为 people。我们不称其为作者，因为将来我们可能希望创建注册和发表评论的功能，而这些人不会被视为作者。

继续运行以下命令来创建 people 表。

CREATE TABLE people (
  id INT PRIMARY KEY AUTO_INCREMENT,
  first_name VARCHAR(255),
  last_name VARCHAR(255),
  url VARCHAR(255),
  email VARCHAR(255)
);

id字段定义为INT，设置为主键，并配置为自增，类似于blog_posts表中的id字段。 first_name、last_name、url、email字段设置为VARCHAR，最大长度为255。

创建 tags 表

继续运行以下命令来创建 tags 表。

CREATE TABLE tags (
  id INT PRIMARY KEY AUTO_INCREMENT,
  name VARCHAR(255)
);

和之前一样，id字段定义为INT，设置为主键，并配置为自增。 name 字段定义为 VARCHAR，最大长度为 255。

创建 blog_post_tags 表

继续运行以下命令来创建 blog_post_tags 表。

CREATE TABLE blog_post_tags (
  blog_post_id INT,
  tag_id INT
);

两个字段都定义为 INT 类型。

这就是创建数据库和表的过程。从下一节开始，我们将开始使用 PHP 实现我们的博客网站。

对象如何在 PHP OOP 中工作

在本节中，我们将简要讨论 PHP 中的 OOP。

面向对象的编程（通常称为 OOP）是一种帮助您以易于长期扩展和维护的方式开发复杂应用程序的方法。在 OOP 的世界中，现实世界的实体（例如 Person、Car 或 Animal）被视为对象。在面向对象的编程中，您通过使用对象与应用程序交互。这与过程式编程形成鲜明对比，在过程式编程中，您主要与函数和全局变量交互。

在 OOP 中，有类的概念，它用于将现实世界的实体建模或映射到数据（属性）和功能（< em>方法）。 对象是类的实例，您可以创建同一类的多个实例。例如，有一个 Person 类，但许多 person 对象可以是该类的实例 — dan, zainab, hector 等

该类定义属性。例如，对于 Person 类，我们可能有 name、age 和 phoneNumber。然后，每个 person 对象都会有自己的这些属性值。

您还可以在类中定义方法，以允许您操纵对象属性的值并对对象执行操作。例如，您可以定义 save 方法，将对象信息保存到数据库中。

在深入研究 PHP 代码之前，我们需要建立文件和文件夹结构。在本教程中，我们将在根文件夹中创建一个 index.php 文件。此外，我们将创建一个 includes 文件夹来存储 CSS 样式表、JavaScript 文件、connection.php 文件和 blogpost.php 文件。

创建 BlogPost 类

在本节中，我们将创建 BlogPost 类，它是我们博客应用程序的支柱。

继续并在 includes 文件夹中创建包含以下内容的 blogpost.php 文件。

<?php
class BlogPost 
{
    private $conn;

    public function __construct($conn) 
    {
        $this->conn = $conn;
    }

    public function getBlogPosts() 
    {
        $query = "SELECT blog_posts.id, blog_posts.title, blog_posts.post, people.first_name, people.last_name, blog_posts.date_posted
                  FROM blog_posts
                  INNER JOIN people ON blog_posts.author_id = people.id";

        $result = $this->conn->query($query);
        $blogPosts = $result->fetch_all(MYSQLI_ASSOC);

        return $blogPosts;
    }

    public function getTagsForBlogPost($blogPostId)
    {
        $query = "SELECT tags.name
                  FROM tags
                  INNER JOIN blog_post_tags ON tags.id = blog_post_tags.tag_id
                  WHERE blog_post_tags.blog_post_id = ?";

        $stmt = $this->conn->prepare($query);
        $stmt->bind_param('i', $blogPostId);
        $stmt->execute();

        $result = $stmt->get_result();
        $tags = [];
        while ($row = $result->fetch_assoc()) {
            $tags[] = $row['name'];
        }

        return $tags;
    }

    public function getBlogPostById($blogPostId) 
    {
        $query = "SELECT blog_posts.id, blog_posts.title, blog_posts.post, people.first_name, people.last_name, blog_posts.date_posted
                  FROM blog_posts
                  INNER JOIN people ON blog_posts.author_id = people.id
                  WHERE blog_posts.id = ?";

        $stmt = $this->conn->prepare($query);
        $stmt->bind_param('i', $blogPostId);
        $stmt->execute();

        $result = $stmt->get_result();
        $blogPost = $result->fetch_assoc();

        return $blogPost;
    }
}
?>

在本课程中，我们将使用 mysqli 扩展来连接 MySQL 数据库，稍后我们将看到该扩展。构造函数需要一个 mysqli 连接对象。 __construct 方法称为构造函数，每当我们创建 BlogPost 对象的新实例时，都会自动调用它。接下来，我们为不同的目的定义了一些方法。

getBlogPosts 方法从 blog_posts 表中检索所有博客文章，加入 people 表以检索作者信息。

getTagsForBlogPost 方法检索与特定博客文章关联的标签，使用准备好的语句和参数绑定来防止 SQL 注入。

最后，getBlogPostById 方法允许您通过 ID 检索特定博客文章。它使用附加的 WHERE 子句扩展了现有的 blog_posts 和 people 表连接查询，以根据提供的 $blogPostId 过滤结果。

因此，我们创建了 BlogPost 类，我们可以使用它从数据库中检索博客文章并显示它，这就是我们下一节的内容。

显示博客文章

设置数据库连接

继续并在 includes 文件夹中创建包含以下内容的 connection.php 文件。

<?php
$servername = "localhost";
$username = "your_username";
$password = "your_password";
$database = "your_database";


$conn = new mysqli($servername, $username, $password, $database);

if ($conn->connect_error) {
    die("Connection failed: " . $conn->connect_error);
}

将 localhost、your_username、your_password 和 your_database 替换为您的实际数据库凭据。它建立与 MySQL 服务器的连接并将其存储在 $conn 对象中。

创建 index.php 文件

继续创建包含以下内容的 index.php 文件。

<?php
require "includes/connection.php";
require "includes/blogpost.php";

$objBlogPost = new BlogPost($conn);
$arrPosts = $objBlogPost->getBlogPosts();
?>
<div id="main">
    <h1>My Simple Blog</h1>
    <div id="blogPosts">
        <?php
            if (count($arrPosts)) {
                foreach ($arrPosts as $post) {
                    $tags = implode(",", $objBlogPost->getTagsForBlogPost($post['id']));

                    echo "<div class='post'>";
                    echo "<h1>" . $post['title'] . "</h1>";
                    echo "<p>" . $post['post'] . "</h1>";
                    echo "<span class='footer'>Posted By: " . $post['first_name'] . " Posted On: " . $post['date_posted'] . " Tags: " . $tags . "</span>";
                    echo "</div>";
                }
            }
        ?>
	</div>
</div>

首先，我们使用 require 语句添加两个必需的文件，connection.php 和 blogpost.php。

然后，我们通过传递 $conn 对象（数据库连接）作为参数来创建 BlogPost 类的实例。它允许我们使用 BlogPost 类中定义的方法与博客文章数据进行交互。

接下来，我们使用了 BlogPost 类的 getBlogPosts 方法，该方法从数据库中获取博客文章并将其作为关联数组返回。

最后，我们使用 foreach 构造迭代数组记录，并通过使用 XHTML 格式化记录来显示记录。

这就是如何在 BlogPost 类的帮助下构建列表页面。

Das obige ist der detaillierte Inhalt vonSo erstellen Sie ein objektorientiertes Blog mit PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!