[This blog was syndicated from http://nitschinger.at/]
Esta entrada de blog te ofrece una introducción sobre cómo puedes acelerar tu capa ORM de Doctrine utilizando Couchbase Server 2.0 como una caché simple, rápida y elástica delante de tus entidades.
Motivación
Como parte de nuestros continuos esfuerzos para hacer que Couchbase esté más integrado con frameworks y librerías, hemos añadido soporte de caché para la librería
Doctrina ORM. Recientemente, el pull request se ha fusionado en la rama maestra y está previsto que se publique junto con la versión 2.4.
El almacenamiento en caché puede utilizarse de forma independiente (a través de la API proporcionada por
doctrina/común) o integrado con la funcionalidad ORM. Veremos ambas variantes a través de ejemplos sencillos, también se puede encontrar una buena documentación
aquí. Tenga en cuenta que, en el momento de escribir esto, CouchbaseCache no se menciona como controlador de caché porque la documentación aún debe actualizarse.
Dado que la versión 2.4 aún no se ha publicado, tenemos que trabajar con la versión
2.4.x-dev rama. Utilizaremos
Compositor para obtener nuestras dependencias, por lo que sólo tiene que cambiar el número de versión si desea fijarlo a 2.4 más tarde.
Almacenamiento en caché simple
Nuestro primer ejemplo muestra cómo se puede utilizar directamente la API de caché. Si estás familiarizado con la API de Couchbase, puedes pensar que es más o menos sólo una API diferente con la misma (y tal vez menos) semántica, pero el punto es que utiliza la interfaz Doctrine Cache API y como resultado puedes cambiar entre diferentes implementaciones de almacenamiento en caché muy fácilmente.
Cree un directorio llamado couchbase-doctrina-simple con lo siguiente composer.json dentro:
{
"requerir": {
"doctrina/común": "2.4.x-dev",
"ext-couchbase": "1.1.x"
}
}
Esto instala el
doctrina/común y también se asegura de que tenemos el
couchbase.so en su lugar. Si aún no ha instalado la extensión PHP de Couchbase, diríjase a la página
sitio web oficial e instalarlo siguiendo el tutorial y la documentación.
Crear un index.php con el siguiente contenido (dividiremos el código después):
// 0: Compositor Autoloader
requiere vendor/autoload.php;
// 1: Abrir la conexión Couchbase
$couchbase = nuevo Couchbase(“127.0.0.1”, “”, “”, "por defecto");
// 2: Instanciar el controlador e inyectar la conexión
$cacheDriver = nuevo DoctrineCommonCacheCouchbaseCache();
$cacheDriver->setCouchbase($couchbase);
// 3: ¡Ejecuta tus órdenes!
$key = "my-cache-item";
si(!$cacheDriver->contiene($key)) {
$cacheDriver->guardar($key, "mis_datos");
} si no {
echo $cacheDriver->buscar($key);
}
?>
En primer lugar, tenemos que arrancar el compositor autoloader por lo que no tenemos que escribir todos los requiere por nuestra cuenta. Lo siguiente que tenemos que hacer es conectarnos al clúster de Couchbase:
// 1: Abrir la conexión Couchbase
$couchbase = nuevo Couchbase(“127.0.0.1”, “”, “”, "por defecto");
Aquí, nos estamos conectando a un nodo del cluster que apunta a localhostpero también puedes pasar un array de nodos. Nos conectamos al por defecto que no tiene contraseña. Ahora que tenemos nuestra conexión establecida, podemos instanciar el controlador de caché e inyectar nuestro cliente Couchbase:
// 2: Instanciar el controlador e inyectar la conexión
$cacheDriver = nuevo DoctrineCommonCacheCouchbaseCache();
$cacheDriver->setCouchbase($couchbase);
A partir de aquí, la API es la misma para todos los controladores de caché. El siguiente código comprueba si la caché contiene una clave. Si está presente, imprime el documento pero si no lo está crea uno nuevo. ¡Este es un ejemplo muy simple pero muestra cómo puedes empezar a usar la caché de Couchbase en tus propios proyectos con sólo unas pocas líneas de bootstrapping!
Además de estos tres métodos, también existe un borrar disponible. Por último, puede pasar un tercer parámetro opcional en guardar con un $lifeTime para que el elemento de caché desaparezca automáticamente.
Como a Couchbase Server no le importa lo que almacenes, también puedes guardar y recuperar cualquier tipo de dato (aparte de recursos):
$cacheDriver->guardar($key, matriz("foo => bar));
var_dump($cacheDriver->buscar($key));
Tenga en cuenta que cuando utilice el controlador a este nivel, intente almacenar cadenas JSON siempre que pueda (utilice json_encode/json_decode en tus datastructures) De esta forma puedes aprovechar el nuevo motor de vistas dentro de Couchbase Server 2.0. Siempre puedes almacenar objetos serializados también (como necesitamos hacer con la integración ORM) ya que para Couchbase Server es sólo un flujo de bytes.
Ahora podemos construir sobre esta base y ver cómo funciona con la integración de ORM.
Integración de ORM
Cree un nuevo directorio llamado couchbase-doctrine-orm con lo siguiente composer.json:
{
"requerir": {
"doctrina/forma": "2.4.x-dev",
"doctrina/dbal": "2.4.x-dev",
"doctrina/común": "2.4.x-dev",
"ext-couchbase": "1.1.x"
},
"autoload": {
"psr-0": {
"Entidades: "src/"
}
}
}
Esta vez nuestro composer.json es un poco más largo, porque necesitamos definir todas nuestras dependencias a mano (ya que no queremos trabajar contra la versión estable). Dado que necesitamos definir Entidades Doctrine, le pasamos al compositor autoloader el directorio personalizado (src/).
Lo siguiente que necesitamos es nuestra entidad real que queremos gestionar a través de Doctrine. Sigue adelante y crea un Persona.php dentro del archivo src/Entidades con el siguiente contenido:
espacio de nombres Entidades;
/** @Entidad */
clase Persona {
/**
* @Id @Column(type="integer") @GeneratedValue(strategy="AUTO")
*/
privado $id;
/** @Column(type="string") */
privado $nombre;
/** @Column(type="string") */
privado 1TP4Nombre;
público función setNombre($nombre) {
$esto->nombre = $nombre;
}
público función getFirstname() {
devolver $esto->nombre;
}
público función setLastname(1TP4Nombre) {
$esto->apellido = 1TP4Nombre;
}
público función getApellido() {
devolver $esto->apellido;
}
}
?>
Esta es una Entidad Doctrine muy simple que tiene algunas propiedades y también una autogenerada
ID campo. Voy a utilizar
SQLite en el siguiente ejemplo, pero siéntase libre de utilizar MySQL o cualquier otra base de datos relacional que tenga disponible.
Para conectarlo todo, vamos a crear un archivo index.php en el directorio raíz del proyecto. Una vez más, aquí está el contenido completo y vamos a romperlo aparte después:
// Compositor autoloader.
$loader = requiere vendor/autoload.php;
/**
* Inicializar Couchbase y la caché.
*/
$couchbase = nuevo Couchbase(“127.0.0.1”, “”, “”, "por defecto");
$cacheDriver = nuevo DoctrineCommonCacheCouchbaseCache();
$cacheDriver->setCouchbase($couchbase);
/**
* Inicializar el Gestor de Entidades.
*/
$paths = matriz(__DIR__ . '/src/Entidades/');
$isDevMode = verdadero;
$dbParámetros = matriz(
conductor => pdo_sqlite,
usuario => raíz,
contraseña => ”,
camino => __DIR__ . '/cbexample.sqlite'
);
$config = DoctrineORMToolsSetup::createAnnotationMetadataConfiguration($paths, $isDevMode, null, $cacheDriver);
$em = DoctrineORMEntityManager::crear($dbParámetros, $config);
/**
* Trabajar con nuestras Entidades.
*/
$persona = nuevo EntidadesPersona();
$persona->setNombre("Michael");
$persona->setLastname("Nitschinger");
$em->persistir($persona);
$em->descarga();
// Consulta con caché de resultados
$query = $em->createQuery('select p from EntidadesPersona p');
$query->useResultCache(verdadero);
1TP4Resultados = $query->obtenerResultado();
?>
Como esto puede ser muy difícil de entender, vamos a dividirlo en trozos más pequeños.
$couchbase = nuevo Couchbase(“127.0.0.1”, “”, “”, "por defecto");
$cacheDriver = nuevo DoctrineCommonCacheCouchbaseCache();
$cacheDriver->setCouchbase($couchbase);
Después de arrancar el autoloader, estamos inicializando el controlador de caché. Ya sabes lo que esto significa porque hemos utilizado el mismo código en el ejemplo simple antes.
$paths = matriz(__DIR__
. '/src/Entidades/');
$isDevMode = verdadero;
$dbParámetros = matriz(
conductor => pdo_sqlite,
usuario => raíz,
contraseña => ”,
camino => __DIR__
. '/cbexample.sqlite'
);
$config = DoctrineORMToolsSetup::createAnnotationMetadataConfiguration($paths, $isDevMode, null, $cacheDriver);
$em = DoctrineORMEntityManager::crear($dbParámetros, $config);
En DoctrineORMEntityManager es uno de los principales bloques de construcción dentro de Doctrine y necesita ser inicializado en consecuencia. Por lo tanto, necesitamos proporcionarle una configuración válida. Aquí vamos a utilizar anotaciones (como se ve en la entidad Doctrine, pero también se puede hacer a través de XML o YAML). También necesitamos proporcionar nuestra conexión a la base de datos y la ruta a las entidades. La parte importante aquí es que pasamos el $cacheDriver al método de fábrica. Esto inicializa automáticamente nuestro CouchbaseCache para todos los tipos de caché (caché de consultas, de metadatos y de resultados).
Ahora podemos seguir adelante y crear un registro:
$persona = nuevo EntidadesPersona
();
$persona->setNombre("Michael");
$persona->setLastname("Nitschinger");
$em->persistir($persona);
$em->descarga();
Después, podemos recuperarlo mediante una consulta:
$query = $em->createQuery('select p from EntidadesPersona p');
$query->useResultCache(verdadero);
1TP4Resultados = $query->obtenerResultado();
Ten en cuenta que le decimos explícitamente que guarde en caché este resultado de consulta por nosotros (por defecto, el almacenamiento en caché de resultados no se utilizará). Si abres el navegador y lo diriges a tu interfaz de administración de Couchbase Server 2.0, podrás ver que Doctrine ha creado un montón de documentos entre bastidores. Estos se utilizan posteriormente para aumentar el rendimiento de su aplicación.
Resumen
Como puedes ver, usar Couchbase como Cache para Doctrine no es difícil. Sólo necesitas inicializarlo y pasarlo a la configuración. A partir de este punto, todo sucede entre bastidores. Y no olvides que no sólo obtienes un rendimiento excepcional, sino también persistencia, escalabilidad y todas las cosas interesantes que Couchbase Server proporciona fuera de la caja.
Si tienes alguna pregunta o comentario, házmelo saber en los comentarios. Por último, gracias a
Marco Pivetta por ayudarme a depurar un problema con la integración de ORM.
