Czy istnieje sposób korzystania z użytkowników Wordpress, ale bez ładowania całego rdzenia Wordpress?

Mam witrynę Wordpress i aplikację internetową, z której mogą korzystać tylko zarejestrowani użytkownicy (Wordpress).

Teraz ładuję, wp-blog-header.phpaby sprawdzić, czy użytkownik jest zalogowany. Wszystko działa dobrze, ale ponieważ na każde żądanie (w tym AJAX) muszę również załadować rdzeń Wordpress, wyraźnie spowalnia moją aplikację (ponad 70% z całości czas ładowania).

Czy istnieje prosty sposób korzystania z użytkowników Wordpress, ale bez ładowania całego rdzenia Wordpress?

Aktualizacja: muszę wiedzieć, który użytkownik jest zalogowany, a także bezpieczeństwo jest ważne.

Dziękuję Ci!

Gdybym musiał to zrobić, użyłbym własnego pliku cookie w celu ustalenia loginu i załadowałem WordPress tylko w razie potrzeby.

Plik cookie wordpress_logged_in_ {some-hash} może służyć do określania użytkownika, a WordPress używa go do określania tego samego. Nie możesz tego łatwo ponownie zaimplementować, ale możesz go użyć bez ładowania WordPressa na wiele żądań.

Na przykład, oto mój skrót do plików cookie (całkowicie złożone dane, ale realistyczne):

key: wordpress_logged_in_1234567890abcdef1234567890abcdef
value: admin|1234567890|abcdef1234567890abcdef1234567890

Sposób, w jaki WordPress wie, jak ważny jest ten plik cookie, jest nieistotny, wszystko, co musisz wiedzieć, to czy jest on ważny raz, a następnie podpisujesz go w tajemnicy.

Po raz pierwszy użytkownik nie został jeszcze sprawdzony. Wczytujesz wp-load.php, a WP sprawdza poprawność pliku cookie i loguje użytkownika. Teraz robisz wszystko, aby udowodnić sobie, że użytkownik jest zalogowany, a następnie ustawiasz własny plik cookie. Klucz może być dowolny dla Ciebie, wartość jaką tworzysz w skrócie wiadomości za pomocą tajnego klucza za pomocą funkcji hash_hmac.

$key = ... // the key from the WP cookie
$value = ... // the value from the WP cookie
$hash = hash_hmac ( 'md5' , $key.$value , 'some secret key' );

Wrócisz bełkotem, który odeślesz im za pomocą setcookie (). W przypadku przyszłych wniosków wyślą z powrotem ten plik cookie. Możesz to najpierw sprawdzić i zweryfikować, używając tej samej funkcji skrótu i ​​tajnego klucza.

Tylko Ty możesz wygenerować skrót, ponieważ tylko Ty znasz tajny klucz. Więc jeśli odeślą poprawny skrót, który również pasuje do tego, co wysyłają dla jego pliku cookie WP, to wiesz, że zostały sprawdzone za pomocą WP, za pomocą Twojego kodu, i możesz uzyskać nazwę użytkownika bezpośrednio z tej wartości (jest to pierwsza część ciasteczka, oczywiście). Wtedy nie musisz ładować WP.

Tajny klucz, BTW, powinien być długi i losowy . Nie krótkie hasło. Nie słownika. Po prostu duży bezsensowny bełkot. Hałas na linii i wiele innych. Przykładowy klucz: 'GHY5hFNqq4Ntdu=3:SUp8#/+_W!- @@^@xslN*L|N+Vn;(1xo8jNyp,au$v9Ki5*'

Ponieważ używam również niektórych funkcji Wordpress oprócz zarządzania użytkownikami, postanowiłem kontynuować ładowanie rdzenia WP, ale utworzyłem niestandardowy plik, który ładuje tylko to, czego potrzebuję i bez ładowania wtyczek. Nowy czas ładowania jest satysfakcjonujący (skrócił się z 1,5 s przy pełnym obciążeniu WP do 0,3 s)

Utworzyłem plik o nazwie „wp-load-minimum.php” i nazywam ten plik zamiast „wp-blog-header.php”

To działa na WP 3.3. Oto treść pliku, jeśli okaże się przydatna:

<?php

//this stops wp-settings from load everything
define ('SHORTINIT',true);

error_reporting( E_CORE_ERROR | E_CORE_WARNING | E_COMPILE_ERROR | E_ERROR | E_WARNING | E_PARSE | E_USER_ERROR | E_USER_WARNING | E_RECOVERABLE_ERROR );

/** Define ABSPATH as this files directory */
define( 'ABSPATH', dirname(__FILE__) . '/' );

//WP config file
require ('wp-config.php');

if (SHORTINIT):

// Load the l18n library.
require( ABSPATH . WPINC . '/l10n.php' );

// Run the installer if WordPress is not installed.
wp_not_installed();


// Load most of WordPress.
require( ABSPATH . WPINC . '/class-wp-walker.php' );
//require( ABSPATH . WPINC . '/class-wp-ajax-response.php' );
require( ABSPATH . WPINC . '/formatting.php' );
require( ABSPATH . WPINC . '/capabilities.php' );
require( ABSPATH . WPINC . '/query.php' );
require( ABSPATH . WPINC . '/theme.php' );
require( ABSPATH . WPINC . '/user.php' );
require( ABSPATH . WPINC . '/meta.php' );
require( ABSPATH . WPINC . '/general-template.php' );
require( ABSPATH . WPINC . '/link-template.php' );
//require( ABSPATH . WPINC . '/author-template.php' );
require( ABSPATH . WPINC . '/post.php' );
//require( ABSPATH . WPINC . '/post-template.php' );
//require( ABSPATH . WPINC . '/category.php' );
//require( ABSPATH . WPINC . '/category-template.php' );
require( ABSPATH . WPINC . '/comment.php' );
//require( ABSPATH . WPINC . '/comment-template.php' );
require( ABSPATH . WPINC . '/rewrite.php' );
//require( ABSPATH . WPINC . '/feed.php' );
//require( ABSPATH . WPINC . '/bookmark.php' );
//require( ABSPATH . WPINC . '/bookmark-template.php' );
require( ABSPATH . WPINC . '/kses.php' );
require( ABSPATH . WPINC . '/cron.php' );
//require( ABSPATH . WPINC . '/deprecated.php' );
require( ABSPATH . WPINC . '/script-loader.php' );
require( ABSPATH . WPINC . '/taxonomy.php' );
//require( ABSPATH . WPINC . '/update.php' );
//require( ABSPATH . WPINC . '/canonical.php' );
require( ABSPATH . WPINC . '/shortcodes.php' );
require( ABSPATH . WPINC . '/media.php' );
require( ABSPATH . WPINC . '/http.php' );
require( ABSPATH . WPINC . '/class-http.php' );
require( ABSPATH . WPINC . '/widgets.php' );
require( ABSPATH . WPINC . '/nav-menu.php' );
//require( ABSPATH . WPINC . '/nav-menu-template.php' );
//require( ABSPATH . WPINC . '/admin-bar.php' );

// Load multisite-specific files.
if ( is_multisite() ) {
    require( ABSPATH . WPINC . '/ms-functions.php' );
    require( ABSPATH . WPINC . '/ms-default-filters.php' );
    require( ABSPATH . WPINC . '/ms-deprecated.php' );
}

// Define constants that rely on the API to obtain the default value.
// Define must-use plugin directory constants, which may be overridden in the sunrise.php drop-in.
wp_plugin_directory_constants( );

// Load must-use plugins.
/*foreach ( wp_get_mu_plugins() as $mu_plugin ) {
    include_once( $mu_plugin );
}
unset( $mu_plugin );*/

// Load network activated plugins.
if ( is_multisite() ) {
    foreach( wp_get_active_network_plugins() as $network_plugin ) {
        include_once( $network_plugin );
    }
    unset( $network_plugin );
}

do_action( 'muplugins_loaded' );

if ( is_multisite() )
    ms_cookie_constants(  );

// Define constants after multisite is loaded. Cookie-related constants may be overridden in ms_network_cookies().
wp_cookie_constants( );

// Define and enforce our SSL constants
wp_ssl_constants( );

// Create common globals.
require( ABSPATH . WPINC . '/vars.php' );

// Make taxonomies and posts available to plugins and themes.
// @plugin authors: warning: these get registered again on the init hook.
create_initial_taxonomies();
create_initial_post_types();

// Register the default theme directory root
//register_theme_directory( get_theme_root() );

// Load active plugins.
/*foreach ( wp_get_active_and_valid_plugins() as $plugin )
    include_once( $plugin );
unset( $plugin );*/

// Load pluggable functions.
require( ABSPATH . WPINC . '/pluggable.php' );
//require( ABSPATH . WPINC . '/pluggable-deprecated.php' );

// Set internal encoding.
wp_set_internal_encoding();

// Run wp_cache_postload() if object cache is enabled and the function exists.
if ( WP_CACHE && function_exists( 'wp_cache_postload' ) )
    wp_cache_postload();

do_action( 'plugins_loaded' );

// Define constants which affect functionality if not already defined.
wp_functionality_constants( );

// Add magic quotes and set up $_REQUEST ( $_GET + $_POST )
wp_magic_quotes();

do_action( 'sanitize_comment_cookies' );

/**
 * WordPress Query object
 * @global object $wp_the_query
 * @since 2.0.0
 */
$wp_the_query = new WP_Query();

/**
 * Holds the reference to @see $wp_the_query
 * Use this global for WordPress queries
 * @global object $wp_query
 * @since 1.5.0
 */
$wp_query =& $wp_the_query;

/**
 * Holds the WordPress Rewrite object for creating pretty URLs
 * @global object $wp_rewrite
 * @since 1.5.0
 */
$wp_rewrite = new WP_Rewrite();

/**
 * WordPress Object
 * @global object $wp
 * @since 2.0.0
 */
$wp = new WP();

/**
 * WordPress Widget Factory Object
 * @global object $wp_widget_factory
 * @since 2.8.0
 */
$GLOBALS['wp_widget_factory'] = new WP_Widget_Factory();

do_action( 'setup_theme' );

// Define the template related constants.
wp_templating_constants(  );

// Load the default text localization domain.
load_default_textdomain();

// Find the blog locale.
$locale = get_locale();
$locale_file = WP_LANG_DIR . "/$locale.php";
if ( ( 0 === validate_file( $locale ) ) && is_readable( $locale_file ) )
    require( $locale_file );
unset($locale_file);

// Pull in locale data after loading text domain.
require( ABSPATH . WPINC . '/locale.php' );

/**
 * WordPress Locale object for loading locale domain date and various strings.
 * @global object $wp_locale
 * @since 2.1.0
 */
$GLOBALS['wp_locale'] = new WP_Locale();

// Load the functions for the active theme, for both parent and child theme if applicable.
/*if ( ! defined( 'WP_INSTALLING' ) || 'wp-activate.php' === $pagenow ) {
    if ( TEMPLATEPATH !== STYLESHEETPATH && file_exists( STYLESHEETPATH . '/functions.php' ) )
        include( STYLESHEETPATH . '/functions.php' );
    if ( file_exists( TEMPLATEPATH . '/functions.php' ) )
        include( TEMPLATEPATH . '/functions.php' );
}*/

do_action( 'after_setup_theme' );

// Load any template functions the theme supports.
//require_if_theme_supports( 'post-thumbnails', ABSPATH . WPINC . '/post-thumbnail-template.php' );

// Set up current user.
$wp->init();

/**
 * Most of WP is loaded at this stage, and the user is authenticated. WP continues
 * to load on the init hook that follows (e.g. widgets), and many plugins instantiate
 * themselves on it for all sorts of reasons (e.g. they need a user, a taxonomy, etc.).
 *
 * If you wish to plug an action once WP is loaded, use the wp_loaded hook below.
 */
do_action( 'init' );

// Check site status
if ( is_multisite() ) {
    if ( true !== ( $file = ms_site_check() ) ) {
        require( $file );
        die();
    }
    unset($file);
}

/**
 * This hook is fired once WP, all plugins, and the theme are fully loaded and instantiated.
 *
 * AJAX requests should use wp-admin/admin-ajax.php. admin-ajax.php can handle requests for
 * users not logged in.
 *
 * @link http://codex.wordpress.org/AJAX_in_Plugins
 *
 * @since 3.0.0
 */
do_action('wp_loaded');

endif;

//require( ABSPATH . WPINC . '/pluggable.php' );

Dla Wordpress 4.9: Jak nie mogę komentować (nowy użytkownik). Ostatnia wersja (pojedyncza instalacja WP), której używam do tworzenia is_user_logged_in()i current_user_can()pracy, jest następująca. Mamy require('wp-load.php') pierwszy (pominąć WP () w obciążeniu-blog-header.php) i uzyskać ABSPATHstałą następnie ręcznie zawiera dokładnie wszystkie rzeczy potrzebne.

Ręczne używanie define('SHORTINIT', true)+ require('wp-load.php')+ obejmuje:

Ładowanie strony: 1,05 sek - dołączone pliki: 43 pliki

Porównywanie: TYLKO require('wp-load.php') :

Ładowanie strony: 1,35 sek - dołączone pliki: 419 plików

Różnica czasu (0,3 sek) może różnić się od instalacji i silników PHP, ale podczas sprawdzania poprawności wielu żądań na jednym ładowaniu strony sumuje się!

Pamiętaj, aby użyć względnego wywołania do zainstalowanego pakietu WP reż. Z niestandardowego katalogu wtyczek Wordpress, na poziomie jednego podkatalogu, podczas normalnej instalacji ścieżka powinna wyglądać tak:

$wordpress = '../../../../wp-load.php';

Następnie:

define('SHORTINIT', true);
include_once $wordpress;

require_once ( ABSPATH . WPINC . '/class-wp-user.php' );
require_once ( ABSPATH . WPINC . '/class-wp-roles.php' );
require_once ( ABSPATH . WPINC . '/class-wp-role.php' );
require_once ( ABSPATH . WPINC . '/class-wp-session-tokens.php' );
require_once ( ABSPATH . WPINC . '/class-wp-user-meta-session-tokens.php' );
require_once ( ABSPATH . WPINC . '/formatting.php' );
require_once ( ABSPATH . WPINC . '/capabilities.php' );
//require_once ( ABSPATH . WPINC . '/query.php' ); // - might be useful
require_once ( ABSPATH . WPINC . '/user.php' );
require_once ( ABSPATH . WPINC . '/meta.php' );

wp_cookie_constants();

require_once ( ABSPATH . WPINC . '/vars.php' );
require_once ( ABSPATH . WPINC . '/kses.php' );
require_once ( ABSPATH . WPINC . '/rest-api.php' );
require_once ( ABSPATH . WPINC . '/pluggable.php' );

Następnie można uzyskać dostęp do sprawdzania poprawności użytkownika. W przypadku innego zadania, podczas odczytywania jednego lub dwóch żądań , śledzenie innych potrzebnych plików może nie być warte 0,3 sek. Pomiń SHORTINITstały i ręcznie bałagan.

Sam Wordpress jest włączony lub wyłączony. Czasami, ale to tylko przypadek, a nie projekt, możesz to obejść. Ale w twoim przypadku nie jestem pewien, czy to możliwe.

Zamiast tego wp-blog-header.phpmożesz spróbować załadować tylko funkcje WP, dołącz wp-load.phpzamiast tego. Może to pomaga.

Możesz spróbować uzyskać dostęp do tabeli bezpośrednio. Jeśli znasz sól plików haseł, możesz poprosić ich o zalogowanie się za pomocą własnego systemu, sam posol hasło (zobacz, jak to robi wordpress) i sam je kontroluj. Jeśli chcesz mieć możliwość przechodzenia między własnym systemem a WordPress bez ponownego uwierzytelnienia, możesz utworzyć wtyczkę do WordPress, która przekazuje sesję bieżących użytkowników do twojego systemu.

Najszybsze, co możesz uzyskać dzięki WP, to tworzenie niestandardowych opakowań, które zdefiniują, SHORTINITa następnie załadują rdzeń. Spowoduje to zatrzymanie ładowania rdzenia zaraz po podłączeniu bazy danych i przed przetworzeniem większości interfejsów API i rozszerzeń (motywu i wtyczek).

Stamtąd możesz spróbować uzyskać dostęp do samej bazy danych lub selektywnie załadować potrzebne części rdzenia.

Jest to dość niechlujne podejście, ale jest tak blisko mniejszego obciążenia rdzenia, jak dzieje się w WP.

Wygląda na to, że już o tym dyskutowano. Sprawdź aktualizacje na stronie : https://core.trac.wordpress.org/ticket/37584

Jeśli chcesz zezwolić wszystkim użytkownikom Wordpress na korzystanie z aplikacji internetowej, możesz użyć systemu zarządzania użytkownikami Wordpress i po prostu sprawdzić, czy użytkownik jest zalogowany.

Aby to sprawdzić, musisz sprawdzić, czy plik cookie o nazwie wordpress_logged_in_{some-hash}jest obecny. Jeśli nie, przekieruj użytkownika na stronę logowania Wordpress. {some-hash}Część nazwy pliku cookie jest tylko ciągiem liter i cyfr.