.

1. En primer vistazo

Antes de sumergirse directamente en los primeros ejemplos de código fuente que vamos a conocer algunos conceptos básicos.

1.1. El motor de db4o

El motor de base de datos de objeto db4o consta de un archivo JAR de un solo núcleo. Además es posible que desee utilizar la biblioteca de cliente / servidor o

componentes opcionales. También puede conseguir todo en un solo frasco "db4o-todo":

db4o- 8,0-core-java1.1.jar

funcionará con la mayoría de los JDK de Java que suministran funcionalidad JDK 1.1.x como la reflexión y el manejo de excepciones. Eso

incluye muchas configuraciones de IBM J9, Symbian y Savaje.

db4o- 8,0-core-java1.2.jar

se construye para todos los JDK de Java entre 1,2 y 1,4.

db4o- 8,0-core-java5.jar está construido para

Java JDK 5 y 6 JDK

Si tiene intención de utilizar la versión cliente / servidor de db4o que, además, necesita biblioteca de cliente / servidor que coincidan con su versión de

JDK:

db4o- 8,0-CS-java1.1.jar

db4o- 8,0-CS-java1.2.jar

db4o- 8,0-CS-java5.jar

Parte de la funcionalidad avanzada, como apoyo a las agrupaciones, los adaptadores IO específicas de la plataforma, herramientas estadísticas, etc se

puede añadir mediante la inclusión de la biblioteca opcional db4o:

db4o- 8,0-opcional-java1.1.jar

db4o- 8,0-opcional-java1.2.jar

db4o- 8,0-opcional-java5.jar

También puede obtener todo lo anterior en un solo frasco:

db4o- 8,0-all-java1.1.jar

db4o- 8,0-all-java1.2.jar

db4o- 8,0-all-java5.jar

www.db4o.com
1.2. Instalación

Si se agrega una de las db4o anterior -. * Archivos jar a su db4o CLASSPATH está instalado. Para los principiantes, se recomienda utilizar

"todo-db4o" biblioteca para evitar la confusión con la ubicación de ciertas clases. En caso de que se trabaja con un entorno de desarrollo

integrado como Eclipse que copia la db4o - *. jar en el directorio / lib / carpeta en su proyecto y añadir db4o a su proyecto como una biblioteca.

1.3. Objeto de instalación de Enterprise Manager

Objeto encargado de la empresa (OME) es un explorador de objetos de bases de datos db4o. OME instalación se puede encontrar en la carpeta / ome de

la distribución. El archivo zip en esta carpeta contiene la versión plug-in de Eclipse de la OME.

Para instalar el plugin, es necesario tener una versión de Eclipse> = 3.3 instalado. Descomprimir el archivo en una carpeta de su elección. A continuación, abra

Eclipse, seleccione 'Ayuda' -> 'Actualizaciones de software ...' -> 'Software disponible' en el menú. Elija 'Añadir sitio ...' -> 'Local ...' y seleccione la carpeta

descomprimida. Siga las instrucciones del Administrador de actualizaciones de Eclipse para la función de la OME de aquí en adelante.

La estructura del menú real puede variar con respecto a versiones de Eclipse. (Lo anterior se aplica a Eclipse 3.4 Ganymede.) En caso de duda,

consulte la documentación de Eclipse en Actualizaciones de software. Como alternativa, puede instalar el plugin manualmente simplemente

copiando el contenido de los 'plugins' y carpetas 'Características' de la carpeta descomprimida en las subcarpetas correspondientes en la

carpeta raíz de la instalación de Eclipse.

www.db4o.com
1.4. Descripción general de API

No se olvide de la documentación de la API durante la lectura a través de este tutorial. Proporciona una vista organizada de la API, mirando

desde una perspectiva paquete de Java y puede que la funcionalidad relacionada con el tema que está leyendo actualmente sobre.

Para empezar, los paquetes de Java com.db4o y com.db4o.query son todo lo que usted necesita preocuparse.

com.db4o

El paquete com.db4o java contiene casi toda la funcionalidad que comúnmente se necesita cuando se utiliza db4o. Dos objetos de la nota son

com.db4o.Db4oEmbedded, y la interfaz com.db4o.ObjectContainer.

La fábrica com.db4o.Db4o es su punto de partida. Los métodos estáticos en esta clase le permiten abrir un archivo de base de datos y crear una

configuración inicial. Para entorno cliente / servidor en el que tendrá que utilizar com.db4o.cs.Db4oClientServer clase de fábrica para iniciar un

servidor, o conectarse a un servidor existente, pero esto se discutirá luego , Iniciar un servidor, o conectarse a un servidor existente. La interfaz

más importante, y la que se va a utilizar el 99% de las veces es com.db4o.ObjectContainer: Esta es la base de datos db4o.

- Un ObjectContainer puede ser una base de datos en modo de un solo usuario o una conexión de cliente a un servidor db4o.

- Cada ObjectContainer posee una transacción. Todo el trabajo es transaccional. Al abrir un ObjectContainer, usted está en una

transacción, cuando se comprometa () o rollback (), la siguiente transacción se inicia inmediatamente.

- Cada ObjectContainer mantiene su propias referencias a los objetos almacenados y instanciados. De este modo, se logra oponerse identidades,

y es capaz de alcanzar un alto nivel de rendimiento.

- ObjectContainers están destinados a ser mantenido abierto todo el tiempo que trabaja en contra de ellos. Cuando se cierra una ObjectContainer, se descartarán

todas las referencias a objetos de base de datos en la memoria RAM.

com.db4o.ext

En caso de que usted se pregunta por qué sólo se ven muy pocos métodos en un ObjectContainer, aquí es por qué: La interfaz db4o se

suministra en dos etapas en dos paquetes java, com.db4o y com.db4o.ext por las siguientes razones:

- Es más fácil para empezar, porque se hace hincapié en los métodos importantes.

- Será más fácil para otros productos para copiar la interfaz básica db4o.

- Es un ejemplo de cómo una versión ligera de db4o podía mirar.

Cada objeto com.db4o.ObjectContainer es también un com.db4o.ext.ExtObjectContainer. Puede echarlo a ExtObjectContainer o puede utilizar el

método para llegar a las funciones avanzadas.

com.db4o.config

www.db4o.com
El paquete contiene java com.db4o.config tipos y clases necesarias para configurar db4o. Los objetos y las interfaces dentro se discuten en las Configuración

sección.

com.db4o.query

El paquete com.db4o.query java contiene la clase de predicados para construir Las consultas nativas . La interfaz nativa de consulta es la interfaz

db4o consulta primaria y se prefiere en la API Soda consulta.

www.db4o.com
.

2. Primeros pasos

Vamos a empezar lo más simple posible. Vamos a demostrar cómo almacenar, recuperar, actualizar y borrar instancias de una sola clase que sólo

contiene miembros primitivos y String. En nuestro ejemplo, este será un Uno (F1) piloto de Fórmula cuyos atributos son su nombre y los puntos en

F1 que ya ha ganado esta temporada.

Primero creamos una clase para mantener nuestros datos. Se parece a esto:

com.db4odoc.f1.chapter1 paquete;

Piloto public class {

private String nombre; int puntos

privadas;

Piloto pública (String nombre, int puntos) {

this.name = nombre; this.points

= puntos; }

getPoints public int () {

puntos de retorno; }

addPoints public void () {int puntos

this.points + = puntos; }

Public String getName () {

Nombre del retorno; }

public String toString () {

Volver Nombre de puntos + + "/"; }}

www.db4o.com
Tenga en cuenta que esta clase no contiene ningún código relacionado con db4o.

2.1. La apertura de la base de datos

Para acceder a un archivo de base de datos db4o o crear uno nuevo, llame Db4oEmbedded.openFile () y proporcionar

Db4oEmbedded.newConfiguration () como una plantilla de configuración y la ruta al archivo de base de datos como el segundo parámetro, para

obtener una instancia ObjectContainer. ObjectContainer representa "La base de datos", y será su interfaz principal a db4o. El cierre de la

ObjectContainer con el método #Cerrar () cerrará el archivo de base de datos y liberar todos los recursos asociados a ella.

// accessDb4o

ObjectContainer db = Db4oEmbedded.openFile (Db4oEmbedded

. newConfiguration (), DB4OFILENAME);

tratar {

// hacer algo con db4o} finally {

db.close (); }

DB4OFILENAME es sólo un valor de cadena que representa cualquier nombre de archivo. Si el archivo con este nombre ya existe, se le abrirá

como base de datos db4o, de lo contrario se creará una nueva base de datos db4o. Para los siguientes ejemplos vamos a suponer que nuestro

entorno se encarga de abrir y cerrar la ObjectContainer automágicamente, y almacena la referencia en una variable denominada 'db'.

2.2. El almacenamiento de objetos

Para almacenar un objeto, simplemente llamamos #store () en nuestra base de datos, cualquier objeto que pasa como parámetro.

// storeFirstPilot

Piloto PILOT1 = new Pilot ( "Michael Schumacher", 100); db.store (PILOT1);

System.out.println ( "almacenado" + PILOT1);

www.db4o.com
 SALIDA:

Almacenado Michael Schumacher / 100

Vamos a necesitar un segundo piloto, también.

// storeSecondPilot

Piloto pilot2 = new Pilot ( "Rubens Barrichello", 99); db.store (pilot2);

System.out.println ( "almacenado" + pilot2);

SALIDA:

Almacenado Rubens Barrichello / 99

2.3. Recuperando objetos

La forma más fácil de ver el contenido de la base de datos es utilizar el Administrador corporativo de objetos, que será introducido en el Siguiente

capítulo . Por ahora vamos a continuar con la visión general de la API y aprender cómo construir consultas db4o.

db4o suministra varios sistemas de Consulta de diferentes, Consulta por ejemplo ( QBE),, Las consultas nativas ( NQ) y la SODA API de consulta ( SODA). En

este primer ejemplo vamos a introducir QBE. Una vez que esté familiarizado con el almacenamiento de objetos, le recomendamos que utilice Las consultas

nativas .

Al utilizar Consulta por ejemplo, se crea un objeto prototípico de db4o para usar como un ejemplo de lo que desea recuperar. db4o recuperará

todos los objetos del tipo dado que contienen los mismos valores de campo (no predeterminada) como el ejemplo. Los resultados se devuelven

como una instancia ObjectSet. Vamos a utilizar un método de conveniencia #listResult () para mostrar el contenido de nuestra ObjectSet resultado:

pública listResult static void (List <?> resultado) {

System.out.println (result.size ()); for (Object o: resultado)

www.db4o.com
 System.out.println (o); }}

Para recuperar todos los pilotos de nuestra base de datos, proporcionamos un prototipo de 'vacío':

// retrieveAllPilotQBE

Piloto proto = new Pilot (null, 0); resultado ObjectSet =

db.queryByExample (proto); listResult (resultado);

SALIDA:

Michael Schumacher / 100 Rubens

Barrichello / 99

Obsérvese que se especifique 0 puntos, pero nuestros resultados no fueron limitados a sólo aquellos pilotos con 0 puntos; 0 es el valor por defecto para los

campos int.

db4o también suministra un acceso directo para recuperar todas las instancias de una clase:

// retrieveAllPilots

resultado ObjectSet = db.queryByExample (Pilot.class); listResult (resultado);

SALIDA:

Michael Schumacher / 100 Rubens

Barrichello / 99

www.db4o.com
Para JDK 5 también hay un acceso directo genéricos, utilizando el método de consulta:

Lista <> piloto pilotos = db.query (Pilot.class);

Para realizar una consulta para un piloto por su nombre:

// retrievePilotByName

Piloto proto = nuevo piloto ( "Michael Schumacher", 0); resultado ObjectSet =

db.queryByExample (proto); listResult (resultado);

SALIDA:

Michael Schumacher / 100

Y para consultar los pilotos con un número determinado de puntos:

// retrievePilotByExactPoints

Piloto proto = new Pilot (null, 100); resultado ObjectSet =

db.queryByExample (proto); listResult (resultado);

SALIDA:

Michael Schumacher / 100

www.db4o.com
Por supuesto hay mucho más a db4o consultas. Ellos serán cubiertos con más detalle en los capítulos siguientes.

2.4. Actualización de objetos

Actualización de objetos es tan fácil como almacenarlos. De hecho, se utiliza el método mismo #store () para actualizar sus objetos: sólo llame #store () de

nuevo después de modificar cualquier objeto.

// updatePilot

resultado ObjectSet = db

. queryByExample (nuevo piloto ( "Michael Schumacher", 0));

Piloto encontró = result.next (Pilot) (); found.addPoints (11);

db.store (encontrado);

System.out.println ( "Agregado 11 puntos para" + hallado); retrieveAllPilots (dB);

SALIDA:

Agregó 11 puntos para Michael Schumacher / 111 2

Michael Schumacher / 111 Rubens

Barrichello / 99

Tenga en cuenta que consultamos para el objeto en primer lugar. Este es un punto importaint. Cuando se llama a #store () para modificar un objeto

almacenado, si el objeto no se 'conoce' (después de haber sido almacenada o recuperada durante la sesión actual con anterioridad), db4o insertará un

nuevo objeto. db4o tiene esto porque no coincide automáticamente objetos a almacenar, con los objetos almacenados previamente. Se supone que usted

está insertando un segundo objeto que pasa a tener los mismos valores de campo.

Para asegurarse de que haya actualizado el piloto, por favor volver a cualquiera de los ejemplos anteriores de recuperación y ejecutar de nuevo.

2.5. eliminación de objetos

www.db4o.com
Los objetos se eliminan de la base de datos utilizando el método #delete ().

// deleteFirstPilotByName

resultado ObjectSet = db

. queryByExample (nuevo piloto ( "Michael Schumacher", 0));

Piloto encontró = result.next (Pilot) (); db.delete (encontrado);

System.out.println ( "eliminado" + encontrado); retrieveAllPilots

(dB);

SALIDA:

Eliminado Michael Schumacher / 111 1

Rubens Barrichello / 99

Vamos a borrar el otro también.

// deleteSecondPilotByName

resultado ObjectSet = db

. queryByExample (nuevo Pilot ( "Rubens Barrichello", 0));

Piloto encontró = result.next (Pilot) (); db.delete (encontrado);

System.out.println ( "eliminado" + encontrado); retrieveAllPilots

(dB);

SALIDA:

Eliminado Rubens Barrichello / 99 0

www.db4o.com
Por favor, compruebe la deleción con los ejemplos de recuperación anteriores.

Al igual que con la actualización de los objetos, el objeto se va a eliminar tiene que ser 'conocido' a db4o. No es suficiente para proporcionar un objeto

prototipo con los mismos valores de campo.

2.6. Conclusión

Eso fue fácil, ¿verdad? Hemos almacenar, recuperar, actualizada y eliminada objetos con unas pocas líneas de código. Ahora usted está probablemente

interesado en ver cómo la base de datos se parece. Vamos a echar un vistazo utilizando db4o herramienta gráfica - Administrador de objetos en el Siguiente

capítulo .

2.7. fuente completo

com.db4odoc.f1.chapter1 paquete;

import java.io. *;

importar com.db4o. *; importar

com.db4odoc.f1. *;

FirstStepsExample clase pública se extiende Util {

última DB4OFILENAME static String =

System.getProperty ( "user.home")

+ "/Formula1.db4o";

principales (args String []) {public static void

nuevo archivo (DB4OFILENAME) .Delete ();

accessDb4o ();

nuevo archivo (DB4OFILENAME) .Delete ();

ObjectContainer db = Db4oEmbedded.openFile (Db4oEmbedded

. newConfiguration (), DB4OFILENAME);

tratar {

storeFirstPilot (db); storeSecondPilot (db);

retrieveAllPilots (dB); retrievePilotByName (db);

retrievePilotByExactPoints (dB); updatePilot (db);

deleteFirstPilotByName (db);

www.db4o.com
 deleteSecondPilotByName (db); } finalmente {

db.close (); }}

pública accessDb4o static void () {

ObjectContainer db = Db4oEmbedded.openFile (Db4oEmbedded

. newConfiguration (), DB4OFILENAME);

tratar {

// hacer algo con db4o} finally {

db.close (); }}

pública storeFirstPilot static void (db ObjectContainer) {

Piloto PILOT1 = new Pilot ( "Michael Schumacher", 100); db.store (PILOT1);

System.out.println ( "almacenado" + PILOT1); }

pública storeSecondPilot static void (db ObjectContainer) {

Piloto pilot2 = new Pilot ( "Rubens Barrichello", 99); db.store (pilot2);

System.out.println ( "almacenado" + pilot2); }

pública retrieveAllPilotQBE static void (db ObjectContainer) {

Piloto proto = new Pilot (null, 0); resultado ObjectSet =

db.queryByExample (proto); listResult (resultado); }

retrieveAllPilots public void () {db ObjectContainer

resultado ObjectSet = db.queryByExample (Pilot.class); listResult (resultado); }

pública retrievePilotByName static void (db ObjectContainer) {

Piloto proto = nuevo piloto ( "Michael Schumacher", 0);

www.db4o.com
 resultado ObjectSet = db.queryByExample (proto); listResult (resultado); }

retrievePilotByExactPoints public void () {db ObjectContainer

Piloto proto = new Pilot (null, 100); resultado ObjectSet =

db.queryByExample (proto); listResult (resultado); }

pública updatePilot static void (db ObjectContainer) {

resultado ObjectSet = db

. queryByExample (nuevo piloto ( "Michael Schumacher", 0));

Piloto encontró = result.next (Pilot) (); found.addPoints (11);

db.store (encontrado);

System.out.println ( "Agregado 11 puntos para" + hallado); retrieveAllPilots (dB); }

pública deleteFirstPilotByName static void (db ObjectContainer) {

resultado ObjectSet = db

. queryByExample (nuevo piloto ( "Michael Schumacher", 0));

Piloto encontró = result.next (Pilot) (); db.delete (encontrado);

System.out.println ( "eliminado" + encontrado); retrieveAllPilots

(dB); }

pública deleteSecondPilotByName static void (db ObjectContainer) {

resultado ObjectSet = db

. queryByExample (nuevo Pilot ( "Rubens Barrichello", 0));

Piloto encontró = result.next (Pilot) (); db.delete (encontrado);

System.out.println ( "eliminado" + encontrado); retrieveAllPilots

(dB); }}

www.db4o.com
www.db4o.com