Example tutorial of using data class in PHP class_PHP tutorial-PHP Tutorial-php.cn

Example tutorial of using data class in PHP class_PHP tutorial

WBOY

Release： 2016-07-13 10:58:21

Original

859 people have browsed it

In this section we are going to kill two birds with one stone. Not only will we learn how to combine object orientation with PHP and MySQL, but we will learn how to group objects. In this case, you will create a first-class UsersGroup which will contain a series of User objects. Each user object will be built continuously using queries from MySQL. To try this practical example, you first need to create a users table in the MySQL database. I am using a MySQL database named 'kirupa_oop`. Use the query below to create a table and insert sample data.

/* Create Users table */
CREATE TABLE `users` (
`user_id` INT NOT NULL AUTO_INCREMENT,
`user_name` TEXT NOT NULL,
PRIMARY KEY (`user_id`)
);

/* Insert sample data into Users table */
INSERT INTO `users`
(`user_id`, `user_name` )
VALUES
( '', 'kirupa' ),
( '', 'bwh2' );

This is a very simple table with just two columns: `user_id' and 'username'. You might as well add your own name to this table for the spice thing.

As promised, we will create a UsersGroup class. The workgroup will contain a series of User objects, each of which is created using data from our MySQL table. The database name for all my tables is `kirupa_oop`. If your database is not named 'kirupa_oop', you must change the database name in the settings class as shown. Here is our UsersGroup class in action:

$group = new UsersGroup;

/* loop through our group, echo user names */
foreach( $group->getUsers() as $user ) {
echo $user->getName().'
';
}

/* User class, same as before */
class User {
private $name;

function __construct( $attribs ) {
$this->name = $attribs['name'];
}

/* name methods */
function setName( $val ) {
$this->name = $val;
Return;
}

function getName() {
Return $this->name;
}
}

/* Contains a group of User objects */
class UsersGroup {
private $name; // name of group
private $group = array(); // group of User objects

function __construct() {
/* Connect to DB using Settings */
$link = mysql_connect(
Settings::$DATABASE['host'],
Settings::$DATABASE['username'],
Settings::$DATABASE['password']
);
mysql_select_db ( Settings::$DATABASE['database'], $link );

/* Get table names from Settings class */
$tbl_users = Settings::$TABLES['tbl_users'];

/* Query */
$sql = "SELECT user_id AS ID,
User_name AS name
FROM $tbl_users";
$result = mysql_query( $sql ) or die(mysql_error());

/* Adds user to group with each row of data */
while( $row = mysql_fetch_array($result) ) {
$this->addUser( $row );
}
}

/*
Add a user to Group
Does simple check to see if we pass an array (like $attribs)
or if we pass an object (like a User object)
*/
function addUser( $user ) {
if( is_object( $user ) ) {
array_push( $this->group, $user );
}
if( is_array( $user ) ) {
$noob = new User( $user );
array_push( $this->group, $noob );
}
return;
}

/* Returns the group (which is an array) */
function getUsers() {
Return $this->group;
}
}

/* Holds our site settings */
class Settings {
static $DATABASE = array(
// change these as needed 'database' => 'kirupa

The first thing to note is that we hold our database connection and table name in our settings class, in static variables. If we need to change our database name, table name, database username, etc., we will only be able to do that in the first class we set (which is best in a separate, included file). What's new about our user level - not only does it have the names of the properties, it still gets a bunch of data via the _construct.

Let's take a look at the code of the UsersGroup class. If you have connected to a MySQL database with PHP before, the connection should be nothing new. The only difference is that we use static variables for our connection settings. We do this because of the double quotes inside our name, and our set class static variable cannot be parsed. That is, only using the setting: :$tables['tbl_users'] directly in our double-quoted SQL query will result in an error.

Our SQL query produces a series of rows, which we specify as results. Using a while loop, we pass our $result array. Each element of the $ result is a sequence of values (eg number and name). Again, this should look familiar to anyone who uses PHP to access MySQL databases. Now for the OO part: we then pass each row (column) from our MySQL query to our addUser method. First, the addUser method checks if it is passed a series of data (such as $rows) or the entire user object. In this case, we're going through a series of data. Using the array data, addUser creates a user object ($noob) and then adds the user object to the group array ($group).

Pay attention to column names: When our user goal is to create an array of data, the constructor is looking for the name of the so-called array element. To fulfill this requirement, we use SQL aliases that can see the USD database. If we didn't alias username the $name continuous variable would not hold the name of the array element called, but instead the username. Therefore, it won't correctly populate the variable name in our user object. I'd rather have my custom SQL instead of my PHP class methods because I'm more likely to reuse PHP class methods than SQL queries. For example, if I create a dog class, I also want the getName method and constructor. Rather than modifying a few PHP methods to support instead of dog users, I'd rather modify a SQL query. Alternatively, you can rename your username field to just the name. This will maximize reuse, but may hurt your ability to understand more complex SQL queries and database designs.

You may consider this category to be overly complex. After all, you could probably code all this within 15 lines of a regular PHP page. So where's the advantage? Well, let’s see how we utilize our objects:

/* instantiate group */
$group = new UsersGroup;

/* loop through our group, echo user names */
foreach( $group->getUsers as $user ) {
echo $user->getName().'
';
}