login  Naam:   Wachtwoord: 
Registreer je!
 Nota's op tutorial:
Tutorials > PHP > Server Side Caching
Pagina:

Reacties op de tutorial Server Side Caching


Offline  Dennisvb
Gepost op: 28 januari 2005 - 09:53
MySQL ver gevorderde
graag variabelen buiten quotes

Offline  Addow
Gepost op: 28 januari 2005 - 13:26
Gouden medaille

PHP beginner
Correctomundo!

// edita 

Offline  Wijnand
Gepost op: 03 februari 2005 - 09:09
Moderator
Misschien handig om het updaten van de gegevens iets duidelijker naar voren te laten komen. Ik las er zelf overheen dus misschien even wat vet gedrukt maken of zoiets.

Offline  Addow
Gepost op: 03 februari 2005 - 09:16
Gouden medaille

PHP beginner
Citaat:
[I][B]Wijnand[/B] schreef op 03 Februari 2005 - 09:09[/I]

Misschien handig om het updaten van de gegevens iets duidelijker naar voren te laten komen. Ik las er zelf overheen dus misschien even wat vet gedrukt maken of zoiets.

Thx 4 the tip!

Ge hebt inderdaad gelijk, want dit is een essentieel punt in het gebruik van die SSC. Dank voor 5! Appreciate that! 

Offline  Tibbeh
Gepost op: 13 februari 2005 - 22:19
Lid
Handige tut 

Offline  Tibbeh
Gepost op: 21 juli 2005 - 10:49
Lid
Nu ik de tut nog eens goed lees merk ik iets,
op de pagina van de functies staat er:
php code - Bekijk de code zonder highlighting - Klap code in 
  1. $cache = fopen("cache.inc.php","w");

en op de include page heb je
php code - Bekijk de code zonder highlighting - Klap code in 
  1. if (!file_exists("cache.php")) {
  2.      script_top10();
  3. }
  4.  
  5. include("cache.php");


Moet dit dan ook niet met cache.inc.php zijn?
php code - Bekijk de code zonder highlighting - Klap code in 
  1. if (!file_exists("cache.inc.php")) {
  2.      script_top10();
  3. }
  4.  
  5. include("cache.inc.php");


Of ben ik verkeerd?

Offline  Addow
Gepost op: 23 juli 2005 - 13:52
Gouden medaille

PHP beginner
Correctomundo! Soms gebruik .inc erbij in m'n pages, soms niet, en hier zie je de reden waarom ik ze beter niet dooreen zou gebruiken ;)

aangepast!

Offline  raza
Gepost op: 09 september 2005 - 02:02
HTML beginner
Interessant idee voor server-side caching!

Maar ik zie niet wat je precies "cached" bij client-side-caching? Je voert toch gewoon je query uit wat in principe niets cached.

Offline  xSc
Gepost op: 12 oktober 2005 - 13:04
Onbekend
Smarty heeft al een eigen cache.

Offline  Roland
Gepost op: 04 januari 2006 - 18:56
PHP expert
Beetje simpel en totaal niet effectief ;) Maar om mee te beginnen is het zeer geschikt hoor.

Op ons forum project gebruiken we hier een class voor.
Elke query (SQL class) kan door een extra argument in het cache gezet worden.

Dus dan krijg je zoiets:
$db->sql_query ( "SELECT * FROM een_tabel", 3600 );

Deze query zal dus het komende uur (3600 sec) in het cache staan, en de query zal dat uur niet uitgevoerd worden maar wordt volledig automatisch opgehaald uit een cache bestand (sql_{random_code}.php).

En de regel onder een INSERT query die dus data toevoegt aan een tabel die gecached "kan" zijn, daar legen we dan het cache weer:

$db->sql_query ( "INSERT INTO een_tabel" );
$cache->destroy_cache ( 'een_tabel' );

En de volgende keer wordt weer de "real-time" gegevens opgehaald en in het cache gezet.

Deze manier zorgt dus voor een enorme vermindering van het aantal SQL queries. 

Offline  Addow
Gepost op: 16 januari 2006 - 11:24
Gouden medaille

PHP beginner
Op zich een schitterende methode, shorty073!
Nu zou ik het ook eerder zo aanpakken, aangezien je kennis over php uiteraard progressief _vooruit_ gaat ;) Ik ben momenteel ook bezig aan m'n eigen forummodule, en dan zie je dat het ook vaak een stuk effectiever kan.

Maar met deze tutorial wil in feite vooral aantonen dat deze manier bestaat, en zo kan je het ook eens anders aanpakken.

@ Henri: mogelijkheden zat dus 

@ raza: client-side-cache komt gewoon neer op browser-cache, gecombineerd met een shitload aan query's 

Offline  Wim
Gepost op: 06 juni 2007 - 22:10
Crew algemeen
Citaat:
[I][B]shorty073[/B] schreef op 04 januari 2006 - 18:56[/I]

Beetje simpel en totaal niet effectief ;) Maar om mee te beginnen is het zeer geschikt hoor.

Op ons forum project gebruiken we hier een class voor.
Elke query (SQL class) kan door een extra argument in het cache gezet worden.

Dus dan krijg je zoiets:
$db->sql_query ( "SELECT * FROM een_tabel", 3600 );

Deze query zal dus het komende uur (3600 sec) in het cache staan, en de query zal dat uur niet uitgevoerd worden maar wordt volledig automatisch opgehaald uit een cache bestand (sql_{random_code}.php).

En de regel onder een INSERT query die dus data toevoegt aan een tabel die gecached "kan" zijn, daar legen we dan het cache weer:

$db->sql_query ( "INSERT INTO een_tabel" );
$cache->destroy_cache ( 'een_tabel' );

En de volgende keer wordt weer de "real-time" gegevens opgehaald en in het cache gezet.

Deze manier zorgt dus voor een enorme vermindering van het aantal SQL queries. 


dit doet toch hetzelfde?

Je slaat een bestand op, en als er iets veranderd wordt op je website laat je het automatisch verwijderen, net zoals bij jou.

Enkel zit dit niet in een classe, wat logisch is! Om 1 functie in een classe te steken is dom. However, de check of een bestand bestaat zit bij miij ook in een classe.

ik heb zoiets:
$cache->start('filename'); //./cache/filename.cache
//code
$cache->write();

start() controleerd dan of filename.cache bestaat, bestaat het? dan echo'ed hij het, en sluit hij de pagina met exit();. Bestaat het niet begint hij een nieuw object (ob_start). Bij $cache->write leest hij het object dan uit (ob_get_contents) en sluit hij het (ob_end_clean()). Hierna schrijft hij alles naar filename.cache.

Mijn classe:
php code - Bekijk de code zonder highlighting - Klap code in 
  1. <?php
  2. class cache extends templatevars
  3. {
  4. 	// door Wim Mariën
  5. 	// http://www.gdx.be/
  6.  
  7.  
  8. 	// VARS                                                   /
  9. 	// directory with .cache files
  10. 	private $dir = './cache/';
  11. 	private $filename = NULL;
  12.  
  13. 	protected $caching = false;
  14.  
  15.  
  16. 	// __construct                                             /	
  17. 	// PUBLIC (duh!)
  18. 	// cache::__construct()
  19. 	// AUTOMATIC
  20. 	public function __construct ($dir=NULL)
  21. 	{
  22. 		if(isset($dir))
  23. 			$this->dir = $dir;
  24.  
  25. 		if(substr($this->dir, -1) != '/')
  26. 			$this->dir .= '/';
  27. 	}
  28.  
  29.  
  30. 	// __destruct                                             /	
  31. 	// PUBLIC (duh!)
  32. 	// cache::__destruct()
  33. 	// AUTOMATIC
  34. 	public function __destruct ()
  35. 	{
  36. 		$this->dir = NULL;
  37. 	}
  38.  
  39.  
  40. 	// start                                                  /
  41. 	// PUBLIC
  42. 	// cache::start([string] filename)
  43. 	public function start ($filename)
  44. 	{
  45.  
  46. 		$this->filename = $filename;
  47. 		if(isset($filename) && !is_file($this->dir.$filename.'.cache'))
  48. 		{
  50. 			$this->caching = true;
  51. 		}
  52. 		else
  53. 		{
  54. 			$output = $this->readCache($filename);
  55. 			echo $this->parse($output);
  56. 			exit();
  57. 		}
  58. 	}
  59.  
  60.  
  61. 	// write                                                  /
  62. 	// PUBLIC
  63. 	// cache::write ([string] filename)
  64. 	public function write ($file='')
  65. 	{
  66. 		if(empty($file) && !empty($this->filename))
  67. 			$file = $this->filename;
  68. 		elseif(empty($file) && empty($this->filename))
  69. 			return false;
  70.  
  71. 		if($this->caching)
  72. 		{
  73. 			$content = ob_get_contents();
  75. 			$this->updateCache($file, $content);
  76. 			echo $this->parse($content);
  77. 		}
  78. 	}
  79.  
  80.  
  81. 	// updateCache                                            /
  82. 	// PRIVATE
  83. 	// cache::updateCache ([string] filename, [string] content)
  84. 	// write a .cache file (by update)
  85. 	private function updateCache ($file, $content)
  86. 	{
  87. 		$cachefile = fopen($this->dir.$file.'.cache', 'w');
  88. 		fwrite($cachefile, $content);
  89. 		fclose($cachefile);
  90. 		return true;
  91. 	}
  92.  
  93.  
  94. 	// readCache                                              /
  95. 	// PUBLIC
  96. 	// cache::readCache([string] filename)
  97. 	// read a .cache file
  98. 	public function readCache($file)
  99. 	{
  100. 		$cachefile = fopen($this->dir.$file.'.cache', "r");
  101.  
  102. 		while(!feof($cachefile))
  103. 		{
  104. 			$content .= fgets($cachefile, 4096);
  105. 		}
  106. 		fclose($cachefile);
  107.  
  108. 		return $this->parse($content);
  109. 	}
  110.  
  111. 	// deleteCache
  112. 	// PUBLIC
  113. 	// cache::deleteCache([string] filename)
  114. 	// delete a .cache file
  115. 	public function deleteCache($file)
  116. 	{
  117. 		if(unlink($this->dir.$file.'.cache'))
  118. 			return true;
  119. 		else
  120. 			return false;
  121. 	}
  122.  
  123. }
  124. ?>

Offline  smoos
Gepost op: 09 juli 2007 - 20:22
PHP gevorderde
Heel slim 

Pagina:

Enkel aanvullende informatie is welkom. Geen prijzende of afkeurende reacties.
 
© 2002-2024 Sitemasters.be - Regels - Laadtijd: 0.062s