session_set_save_handler

Sets user-level session storage functions

bool **session_set_save_handler** callable $open callable $close callable $read callable $write callable $destroy callable $gc callable $create_sid callable $validate_sid callable $update_timestamp

It is possible to register the following prototype:

bool **session_set_save_handler** object $sessionhandler bool $register_shutdown

sets the user-level

session storage functions which are used for storing and retrieving data associated with a session. This is most useful when a storage method other than those supplied by PHP sessions is preferred, e.g. storing the session data in a local database. session_set_save_handler

This function has two prototypes.

sessionhandler An instance of a class implementing , and optionally and/or , such as , to register as the session handler. SessionHandlerInterface``SessionIdInterface``SessionUpdateTimestampHandlerInterface``SessionHandler

register_shutdown Register as a function. session_write_close``register_shutdown_function

open A callable with the following signature:

  ```php

bool **** string $savePath string $sessionName





       The open callback works like a constructor in classes and is
       executed when the session is being opened.  It is the first callback
       function executed when the session is started automatically or
       manually with .
       Return value is true for success, false for failure.
      `session_start`

`close`
       A callable with the following signature:
       
      ```php
bool ****

   The close callback works like a destructor in classes and is
   executed after the session write callback has been called. It is also invoked when
    is called.
   Return value should be true for success, false for failure.
  `session_write_close`

read A callable with the following signature:

  ```php

string **** string $sessionId





       The  callback must always return a session encoded (serialized)
       string, or an empty string if there is no data to read.
      `read`


       This callback is called internally by PHP when the session starts or
       when  is called.  Before this callback is invoked
       PHP will invoke the  callback.
      `session_start``open`


       The value this callback returns must be in exactly the same serialized format that was originally
       passed for storage to the  callback.  The value returned will be
       unserialized automatically by PHP and used to populate the  superglobal.
       While the data looks similar to  please note it is a different format
       which is specified in the  ini setting.
      `write``$_SESSION``serialize`session.serialize_handler

`write`
       A callable with the following signature:
       
      ```php
bool **** string $sessionId string $data

   The  callback is called when the session needs to be saved and closed. This
   callback receives the current session ID a serialized version the  superglobal.  The serialization
   method used internally by PHP is specified in the  ini setting.
  `write``$_SESSION`session.serialize_handler


   The serialized session data passed to this callback should be stored against the passed session ID. When retrieving
   this data, the  callback must return the exact value that was originally passed to
   the  callback.
  `read``write`


   This callback is invoked when PHP shuts down or explicitly when 
   is called.  Note that after executing this function PHP will internally execute the  callback.
   
  `session_write_close``close`> **Opmerking:** > The "write" handler is not executed until after the output stream is

     closed.  Thus, output from debugging statements in the "write"
     handler will never be seen in the browser.  If debugging output is
     necessary, it is suggested that the debug output be written to a
     file instead.

destroy A callable with the following signature:

  ```php

bool **** string $sessionId





       This callback is executed when a session is destroyed with  or with
        with the destroy parameter set to true.
       Return value should be true for success, false for failure.
      `session_destroy``session_regenerate_id`

`gc`
       A callable with the following signature:
       
      ```php
bool **** int $lifetime

   The garbage collector callback is invoked internally by PHP periodically in order to
   purge old session data.  The frequency is controlled by
    and .
   The value of lifetime which is passed to this callback can be set in .
   Return value should be true for success, false for failure.
  session.gc_probabilitysession.gc_divisorsession.gc_maxlifetime

create_sid A callable with the following signature:

  ```php

string ****




This callback is executed when a new session ID is required. No
       parameters are provided, and the return value should be a string that
       is a valid session ID for your handler.

`validate_sid`
       A callable with the following signature:
       
      ```php
bool **** string $key

   This callback is executed when a session is to be started, a session ID is supplied
   and  is enabled.
   The  is the session ID to validate.
   A session ID is valid, if a session with that ID already exists.
   The return value should be true for success, false for failure.
  session.use_strict_mode`key`

update_timestamp A callable with the following signature:

  ```php

bool **** string $key string $val





       This callback is executed when a session is updated.
        is the session ID,  is the session data.
       The return value should be true for success, false for failure.
      `key``val`



return.success


   
  **Voorbeeld: 
     Custom session handler: see full code in  synopsis.
    **


     We just show the invocation here, the full example can be
     seen in the  synopsis linked above.
    `SessionHandlerInterface`


     Note we use the OOP prototype with  and
     register the shutdown function using the function's parameter flag.  This is generally
     advised when registering objects as session save handlers.
    `session_set_save_handler`

```php
<?php
class MySessionHandler implements SessionHandlerInterface
{
    // implement interfaces here
}

$handler = new MySessionHandler();
session_set_save_handler($handler, true);
session_start();

// proceed to set and retrieve values by key from $_SESSION

Waarschuwing: > The and handlers are called after object destruction and therefore cannot use objects or throw exceptions. Exceptions are not able to be caught since will not be caught nor will any exception trace be displayed and the execution will just cease unexpectedly. The object destructors can however use sessions. write``close
It is possible to call  from the
destructor to solve this chicken and egg problem but the most reliable way is
to register the shutdown function as described above.
session_write_close

Waarschuwing: > Current working directory is changed with some SAPIs if session is closed in the script termination. It is possible to close the session earlier with . session_write_close

session.save_handlersession.serialize_handlerregister_shutdown_function``session_register_shutdownsave_handler.inc

Vorige ← session_set_cookie_params Volgende session_start →

session_set_save_handler

session_set_save_handler

Documentatie