Optimierung des mehrstufigen Verteilungs-Docking-API-Datenerfassungssystems eines Drittanbieters

Vor kurzem arbeite ich an einem mehrstufigen Vertriebsmanagementsystem, das auf Youzan basiert und die Youzan-API verwendet, um ihre Leistung zu erhalten. Allerdings bietet Youzan nur eine Vertriebsebene, daher war dieses System erstellt. Um den Arbeitsaufwand zu reduzieren und hierarchische Beziehungen zu klären, wurden OOP-Entwurfsmethoden übernommen, um Datenbanken und Tabellen in Basisklassen, Verteilungsmitgliedern, Storefronts und anderen Vererbungstabellen zu kapseln.

Bei der Auflistung von Verkaufsberichten und Händlern traten jedoch schwerwiegende Leistungsprobleme auf. Da die Leistungsbelohnungen von Händlern mit ihren untergeordneten Händlern verknüpft sind, wurde bei der Kapselung der Datenbank eine DFS-Durchquerung durchgeführt, um den Beziehungsbaum aller Händler zu erhalten Eine solche Beziehung ist jedoch nicht erforderlich, wenn DFS viel Zeit mit der PHP-Sprache verbringt, was dazu führt, dass das Öffnen einer Seite mehr als 10 Sekunden dauert. Daher muss dies festgelegt werden der DFS-Schalter in der Datenbankkapselungsfunktion:

Dies ist eine Teilimplementierung der Datenbankklasse, in der einige sensible Daten ausgeblendet wurden.

<?php
namespace System;
require_once(&#39;KdtApiClient.php&#39;);
class Database
{
	const db_adr="";
	const db_usr="";
	const db_pwd="";
	const db_db="";
	public $member=array();
	public function init($dfs=true,$store=true)
	{
		$mysqli=new \mysqli(self::db_adr,self::db_usr,self::db_pwd,self::db_db);
		if($mysqli->connect_error) throw new Exception('Connect Error (' . $mysqli->connect_errno . ') ' . $mysqli->connect_error);
		$result=$mysqli->query("select `id` from member_new");
		$row=$result->fetch_array();		
		$i=0;
		while($row)
		{
			$this->member[$i]=new Member($row[0],$dfs,$store);
			$row=$result->fetch_array();
			$i++;
		}
		$mysqli->close();
	}
	static public function doQuery($string)
	{
		$mysqli=new \mysqli(self::db_adr,self::db_usr,self::db_pwd,self::db_db);
		if($mysqli->connect_error) throw new Exception('Connect Error (' . $mysqli->connect_errno . ') ' . $mysqli->connect_error);
		return $mysqli->query($string);
	}
	static public function querySell($start,$end)
        {}
}

Die Mitgliedsklasse wird von der Tabelle geerbt:

class Table
{
	public $data=array();
	protected $table_name;
	public function __construct($id)
	{
		$this->data['id']=$id;
		$mysqli=new \mysqli(Database::db_adr,Database::db_usr,Database::db_pwd,Database::db_db);
		if($mysqli->connect_error) throw new Exception('Connect Error (' . $mysqli->connect_errno . ') ' . $mysqli->connect_error);
		$result=$mysqli->query("select * from ".$this->table_name." where `id`=$id");
		$row=$result->fetch_assoc();
		$this->data=$row;
		$mysqli->close();
	}
	public function updateAll()				//Do NOT CHANGE ID!!!
	{
		reset($this->data);
		while($data=each($this->data))
		{
			$querystring="update ".$this->table_name." set `".$data[0]."`='$data[1]' where `id`='".$this->data['id']."'";
			Database::doQuery($querystring);
		}
		reset($this->data);
	}
	public function update($key)
	{
		$querystring="update ".$this->table_name." set `$key`='".$this->data[$key]."' where `id`='".$this->data['id']."'";
		Database::doQuery($querystring);
	}
	public function set($key,$data)		//recommended
	{
		$this->data[$key]=$data;
		$this->update($key);
	}
	public function get($key)				//recommended
	{
		return $this->data[$key];
	}

}

kapselt die grundlegenden Operationen in der Tabelle und vereinfacht so das Schreiben von zukünftigem Code Mitglied Der Konstruktor der Klasse kann die DFS-Funktion vervollständigen. Nach dem Hinzufügen von Schalterparametern kann die Effizienz in einigen Situationen erheblich verbessert werden, ohne DFS zu verwenden:

class Member extends Table
{
	protected $table_name="member_new";
	public $infer=array();
	public $store=array();
	public function __construct($id,$dfs=true,$store=true)
	{
		parent::__construct($id);
		$mysqli=new \mysqli(Database::db_adr,Database::db_usr,Database::db_pwd,Database::db_db);
		if($mysqli->connect_error) throw new Exception('Connect Error (' . $mysqli->connect_errno . ') ' . $mysqli->connect_error);
		if($dfs){
			$result=$mysqli->query("select `id` from ".$this->table_name." where `super`=".$this->data['id']);
			if($result){
				$row=$result->fetch_array();
				$i=0;
				while($row)
				{
					$this->infer[$i]=new Member($row[0]);
					$row=$result->fetch_array();
					$i++;
				}
			}
		}
		if($store)
		{
			$result=$mysqli->query("select `id` from store_new where `member`=".$this->data['id']);
			if($result){
				$row=$result->fetch_array();
				$i=0;
				while($row)
				{
					$this->store[$i]=new Store($row[0]);
					$row=$result->fetch_array();
					$i++;
				}
			}
		}
		$mysqli->close();
	}

(Einige sensible Funktionen wurden ausgeblendet)

Darüber hinaus wird dem PHP-Skript, das auf das Front-End-AJAX reagiert, Caching-Unterstützung hinzugefügt. Da die API-Aufrufgeschwindigkeit von Youzan jedoch langsam ist, haben die Daten dieser Art von Distributionszentren keine hohe Real-. Zeitbedarf, daher wird Server-Caching verwendet, um die durch die Kommunikation mit Youzan verursachte Verlangsamung zu reduzieren. Darüber hinaus ersetzen lokalisierte Objekte das Lesen von Informationen aus der Remote-Datenbank, was auch die Kosten für die Abfrage der Cache-Objekte reduziert lautet wie folgt: Serialisieren des Objekts Der Code wird lokal auf dem Server gespeichert:

<?php
	namespace System;
    class Cache
    {
        public function __construct()
        {
        }
        
        static public function readCache($string)
        {
			error_reporting(1);
            $file=fopen($string.".ser","r");
            if(!$file)return false;
            $ser=fread($file,filesize($string.".ser"));
            fclose($file);
            $array=array();
            $array=unserialize($ser);
            if(time()-$array[&#39;time&#39;]>3600*24)return false;
            return $array['data'];
        }

        static public function updateCache($string,$data)
        {
            $array=array();
            $array['time']=time();
            $array['data']=$data;
            $file=fopen($string.".ser","w");
            fwrite($file,serialize($array));
            fclose($file);
        }
    }

Die Back-End-AJAX-Antwortseite wählt den Erhalt lokaler Daten basierend auf dem Feedback der Cache-Klasse oder fordert den Server auf, lokale Daten zu aktualisieren:

<?php
require_once(&#39;System/db.php&#39;);
require_once(&#39;System/cache.php&#39;);
use \System\Database;
use \System\Cache;

switch($_GET[&#39;action&#39;])
{
	case &#39;num&#39;:
		$result=Database::doQuery("select count(*) from member_new");
		$row=$result->fetch_array();
		echo $row[0];
		exit(0);
	case 'get':
		if($array=Cache::readCache("member"))
		{
			echo json_encode($array);
		}
		else
		{
			$db=new Database();
			$db->init(false,true);
			$arr=array();
			for($i=0;$i<count($db->member);$i++)
			{
				$arr[$i]=array();
				$arr[$i]=$db->member[$i]->data;
				$arr[$i]['password']=null;
				$arr[$i]['name']=iconv("GBK","utf-8",$arr[$i]['name']);
				$arr[$i]['nickname']=iconv("GBK","utf-8",$arr[$i]['nickname']);
				$arr[$i]['sell']=$db->member[$i]->getSell();
			}
			Cache::updateCache("member",$arr);
			echo json_encode($arr);
		}
		exit(0);

Nach der oben genannten Optimierung hat die Seite, die ursprünglich eine Antwortzeit von etwa 15 Sekunden hatte, jetzt eine Antwortzeit von etwa 0,5 Sekunden.

Urheberrechtserklärung: Dieser Artikel ist ein Originalartikel des Bloggers und wurde nicht vom Blogger autorisiert. Eine Vervielfältigung ist nicht gestattet.

Das Obige stellt die Optimierung des Mehrebenen-Verteilungs-Docking-API-Datenerfassungssystems eines Drittanbieters vor, einschließlich Aspekten des Inhalts. Ich hoffe, dass es für Freunde hilfreich sein wird, die an PHP-Tutorials interessiert sind.