El documento describe los contenidos de un curso sobre JDBC y URM. Incluye dos bloques: JDBC para el acceso a bases de datos, y URM para mapeadores de objetos relacionales. Detalla los conceptos clave de JDBC como drivers, operaciones con JDBC, y ejemplos de código para conectarse a una base de datos, enviar consultas y cerrar la conexión. También cubre procedimientos almacenados, transacciones y otras funcionalidades avanzadas de JDBC.

1. Contenido TOC \o \"
1-3\"
\h \z \u Contenidos del curso PAGEREF _Toc264988213 \h 2JDBC PAGEREF _Toc264988214 \h 3Drivers PAGEREF _Toc264988215 \h 3Operaciones con JDBC PAGEREF _Toc264988216 \h 4Carga de drivers PAGEREF _Toc264988217 \h 4Conectar/desconectar a BD PAGEREF _Toc264988218 \h 4Enviar órdenes a la BD. Sentencias PAGEREF _Toc264988219 \h 8Sentencias preparadas PAGEREF _Toc264988220 \h 12Procedimientos almacenados PAGEREF _Toc264988221 \h 13Tansaciones PAGEREF _Toc264988222 \h 14Optimizaciones y otras mejoras PAGEREF _Toc264988223 \h 15Porcentaje de carga: PAGEREF _Toc264988224 \h 15Actualizaciones en modo bach PAGEREF _Toc264988225 \h 15Nuevos tipos de resultSet PAGEREF _Toc264988226 \h 16No asistí a clase . PAGEREF _Toc264988227 \h 17EntityManager PAGEREF _Toc264988228 \h 18Creacción de las clases URM en un proyecto con un modelo de datos existente PAGEREF _Toc264988229 \h 18Queryes con nombre. Anotaciones PAGEREF _Toc264988230 \h 22Persistencia de relaciones entre clases PAGEREF _Toc264988231 \h 23Curiosidades PAGEREF _Toc264988232 \h 25<br />Lunes 14 Junio<br />Contenidos del curso<br />Dos bloques claramente distinguidos: JDBC (acceso a base d edatos) y URM (mapeadores de objeto relación)<br /> JDBC APLICACIÓN WEB<br /> <br />AD (acceso datos) A Web (aplicación web)<br />Clásica (desktop) Orientación objetos JSPServlet<br />Libro: “Web development with Java” que cubre la parte de aplicaciones Web<br />El blog del profe: http://formanntt.blogspot.com/<br />Sobre la tecnología del curso:<br />La herramienta sobre la que trabajaremos es NetBeans 6.8, que es la versión estable.<br />Guía de referencia rápida de JDBC: C:\MCSE\Lunes 14 de junio de 2010\Documentación\Manual Jdbc.htm<br />El directorio de los ejemplos se guardarán en: C:\MCSE\Lunes 14 de junio de 2010\Ejemplos<br />Necesitamos una base de datos que puede ser cualquiera por ejemplo: Derby, MySQL…<br />Para nosotros será MySQL que la encontramos en: Inicio> Progarmas > MySQL<br />Clave: root<br />Cuanto más actualizada este la versión que utilicemos de java podremos hacer el mismo trabajo pero trabajando menos. (JSE v6.0 Edición Standard java, JEE v.6.0 versión Enterprice de java y JME tecnología de móviles en java)<br />La primera tecnología que veremos en el curso que forma parte de la edición Estándar es la JDBC (Conectividad para bases de datos en java) y por tanto es aplicable a cualquier aplicación java.<br />JDBC es un API (interface para la creación de aplicaciones, biblioteca de clases para facilitarnos los accesos a datos), i.e, es una especificación de cómo se debe acceder a la base de datos y además es una implementación.<br />JDBC<br />[ver 2.1]<br />La arquitectura de esta herramienta sigue el siguiente esquema:<br />Este primer nivel es el código que nosotros escribimos<br />JBDC para el Acceso a datos<br />Los drivers son los únicos que saben que están “hablando” con una BD. Son los que nos van a dar la conexión a la BD.<br /> JDBCnapDrivers 1Drivers 2BD2BDOracleSon las BD a las que se accede<br />Drivers<br />[ver 2.3]<br />Para funcionar únicamente necesita java. Todas las aplicaciones que actualmente existen en java tiene los drivers para ejecutarlos de tipo 4.<br />Un driver es una clase java con la diferencia que el driver debe implementar la interface, DRIVER, para que java reconozca que es un driver.<br />Los drivers traducen cualquier sentencia SQl de forma que la BD a la que vaya a acceder sea capaz de entenderla.<br />Operaciones con JDBC<br />Los JBDC nos permite conectar/desconectar a la base de datos, obtener los datos y procesar los resultados que nos devuelva. [ver 3. Clases del API JDBC.]<br />Se utiliza la clase “Class” que es una metaclase, la diferencia entre una clase y una metaclase es que las instancias de esta metaclae definen o representan las características de otras clases<br />Carga de drivers<br />[Ver 3.1]<br />Para acceder la BD lo primero que se ha de hacer es cargar el driver en memoria con el que vamos a acceder a la BD.<br />Para ello, la forma más útil y que se usa en el día a día es usar el método de la metaclase llamado: forName. Se invocaría como class.forName y este método nos permite cargar en memoria el driver que indiquemos.<br />Por ejemplo:<br />Class.forName(“uno.A”); buscara en el disco duro la clase “A” que estará en el paquete “uno”, si no encuentra la clase “A” lanzará una excepción si la encuentra ya tendremos cargado el driver en memoria para su utilización. <br />Para encontrar la clase debe estar en el classpath (variable de entorno que contiene una serie de directorios donde hay clases java compiladas) del sistema.<br />Conectar/desconectar a BD<br />[Ver 3.2]<br />Conectar<br />Supongamos ya tenemos cargado el driver y ahora nos queremos conectar a la BD.<br />Debemos recurrir a la clase DriverManager, que se encarga de gestionar los driver que tenemos en memoria.<br />Definiremos un objeto de la clase : Connection con = new Conecction();<br />y después hay que utilizar el método getConection() que nos devolverá un objeto que implementará la clase DriverManager.<br />Este método necesita tres parámetros, todos ellos de tipo “string”:<br />url (localizador uniforme de parámetros). Tiene el siguiente formato:<br />protocolo : nombredriver : localización de la BD indicando máquina y puerto(opcional)<br />Ejemplo: para conectarme a la base de datos de “derby” escribiría la url:<br />jdbc:derby://localhost:1527/curso<br />usuario<br />clave<br />Desconectar<br />Se coge la clase con la que trabajemos y llamamos al método close().<br />Ejemplo: con.close();<br />Es importantísimo llamar al método close() porque si no se cierra explícitamente se podría quedar conectado al servidor remoto de la BD.<br />EJERCICIO 1: UN programa que nos conecte y desconecte de una Base de Datos<br />Conexiones con BD en NetBeans<br />Desplegamos APP:<br />Esto que obtenemos es un intérprete de la BD.<br />Nos hemos asegurado que tenemos BD en el ordenador.<br />Ese check nos permitirá importar tbn las librerías para que si arrancamos esta nueva clase en otro lugar no nos de error de no encontrar las librerías.<br />El código de programa es:<br />// Clase que conecta y desconecta de la base de datos<br /> try {<br /> System.out.println(\"
Invocamos al método forName\"
);<br /> Class.forName(\"
org.apache.derby.jdbc.ClientDriver\"
);<br /> System.out.println(\"
Creamos la conexión\"
);<br /> Connection con = DriverManager.getConnection(\"
jdbc:derby://localhost:1527/curso\"
, \"
app\"
, \"
app\"
);<br /> System.out.println(\"
Cerramos la conexión\"
);<br /> con.close();<br /> } catch (SQLException ex) {<br /> Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);<br /> }<br />Martes 15 Junio<br />Antes de ejecutar un programa debo conectarme a la base de datos para lo cual:<br />Enviar órdenes a la BD. Sentencias<br />[Ver 3.3]<br />Para crear una sentencia debemos crear una variable de tipo Statement, y escribir el código:<br />Statement stmt = con.createStatement(); con es la conexión que he abierto anteriormente<br />Y a continuación decirle la orden de SQL que queremos que ejecute.<br />Java distingue entre dos tipos de órdenes para ejecutar:<br />Queryes mediante la sentencia “select” stmt.executeQuery (“SELECT …”);<br />Todo lo demás: insert, delete, update,… stmt.executeUpdate (“INSERT | UPDATE | DELETE | CREATE | …”);<br />Todo lo que no sea sentencia<br />Donde stmt es la variable de tipo Statement que hemos declarado con anterioridad.<br />Estos métodos nos devuelven un número que será el número de filas que han sido “modificadas” con esta sentencia. No será obligatorio capturar este valor que devuelve salvo que lo queramos usar para algo.<br />Cuando se termina de trabajar con un Statement se debe cerrar con la instrucción:<br />Stmt.close();<br />Ej:<br />String x=”insert into…..”<br />stmt.executeUpdate(x);<br />stmt.close();<br />EJERCICIO: Creamos tabla en BD para poder realizar consultas a través de java.<br />Los Strings desde java los haremos con simples comillas simples.<br />La clase se llama Primera_1:<br />try {<br /> System.out.println(\"
Invocamos al método forName\"
);<br /> Class.forName(\"
org.apache.derby.jdbc.ClientDriver\"
);<br /> System.out.println(\"
Creamos la conexión\"
);<br /> Connection con = DriverManager.getConnection(\"
jdbc:derby://localhost:1527/curso\"
, \"
app\"
, \"
app\"
);<br /> java.sql.Statement stmt = con.createStatement();<br /> System.out.println(\"
Insert en la BD\"
);<br /> String i1 = \"
INSERT into personas (id,nombre) values (1,'nombre1')\"
;<br /> stmt.executeUpdate(i1);<br /> String i2 = \"
INSERT into personas (id,nombre) values (2,'nombre2')\"
;<br /> stmt.executeUpdate(i2);<br /> String i3 = \"
INSERT into personas (id,nombre) values (3,'nombre3')\"
;<br /> stmt.executeUpdate(i3);<br /> System.out.println(\"
Update en la BD\"
);<br /> String u2 = \"
UPDATE personas set nombre= 'nombreActualizado' where id=2\"
;<br /> stmt.executeUpdate(u2);<br /> System.out.println(\"
Delete en la BD\"
);<br /> String d3 = \"
DELETE from personas where id in(1,2,3)\"
;<br /> stmt.executeUpdate(d3);<br /> System.out.println(\"
Cerramos la conexión\"
);<br /> con.close();<br /> } catch (SQLException ex) {<br /> Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);<br /> }<br /> Sentencias<br />Para ejecutar sentencias utilizaríamos la sentencia:<br />String consulta= “Select….from…”<br />stmt.executeQuery (consulta);<br />Esto nos devolverá una colección de filas. EN java tenemos una colección (metaclase) especial para guardar las filas de una consulta:<br />ResultSet rs = stmt.executeQuery (consulta);<br />Supongamos que la consulta nos va a devolver un número enorme de resultados…entonces el servidor se quedará “frito” para ello y JDBC hace lo siguiente:<br />resultSet Jdbc BD<br />jdbc le dice a la BD que le devuelva un número adecuado de filas y esas son las que mete en el resultSet, entonces cuando vayamos recorriendo este resultSet las primeras N filas nos las devuelve del servidor de cliente y cuando se vayan acabando irá a la BD a buscar la otras N filas, de este modo nos aseguramos que se pueden obtener todas las filas sin dejar “colgado” el servidor. Lógicamente durante todo este proceso la conexión con la BD debe estar abierta, en cuanto se cierre el resultSet se invalida.<br />La relación entre los objetos … es jerárquica:<br />Connection puede tener cualquier número de St abiertos<br />Statement puede tener cualquier número de rs abiertos<br />resultSet<br />De forma que si cierro al “padre” de cualquiera de ellos invalidaré al que esté por debajo.<br /> Entonces para abrir las connection, Sattement o resultSet, lo haré de arriba abajo y para cerrarlos de abajo a arriba.<br />Nota: Se deben crear siempre para programar bien el número mínimo de conexiones necesarias.<br />Para recorrer el rs utilizaríamos por ejemplo un bucle while, cuya sintaxis será:<br />While (rs.next()) se ejecutará mientras haya filas que devolver.<br />Las columnas se numeran de izquierda a derecha de forma consecutiva comenzando por 1.<br />También se pueden recuperar indicando el nombre de la columna.<br />OJO algunos drivers no me permiten acceder por parémetro posicional para obtener los valores<br />Los pasos imprportantesson:<br />Se debe llamar al método next()<br />Acceder por parámetro posicional para obtener los valores<br />No leer más de dos veces cada línea<br />4…..cual es??<br />EJERCICIO: La clase se llama Ejercicio_2<br />Documentación para esto: http://java.sun.com/javase/6/docs/technotes/guides/jdbc/getstart/GettingStartedTOC.fm.html<br />Sentencias preparadas<br />[ver 3.4] ACADEMIA<br />El ejercicio es : ejemplo 3.1<br />Miércoles 16 Junio<br />Procedimientos almacenados<br />[Ver 3.5]<br />Para la ejecución en remoto de un procedimiento almacenado.<br />Debo definirme una variable de tipo:<br />CallableStatement cstmt = con.prepareCall (“{call ProcAlmacenado (?,?,?, …, ?)}”);<br />Donde “procAlmacenado” es el nombre del procedimiento almacenado que exista en la base de datos.<br />OJO HAY UN ERRRO EN LA SINTAXIS DE LOS APUNTES, LA CORRECTA LA INDICO AQUÍ.<br />La sintaxis correcta para llamar a PROC y a FUNC es: <br />Para PROC: {call f(?,?)}<br />Para FUNC: {? = call CrearPersona(?,?)}<br />Si el PROC tiene parámetros hay que definirlos. En BD tenemos para los PROC tres tipos de parámetros:<br />IN el servidor solo puede leer, no escribir el parámetro<br />OUT el servidor solo puede escribir, no leer el parámetro<br />IN/OUT el servidor puede leer y escribir el parámetro<br />Cuando un parámetro es de salida hay que decírselo a java y esto se hace mediante la el método:<br />Para PROC: cstmt.registerOutParameter (Types.INTEGER);<br />Para FUNC: cstmt.registerOutParameter (1, Types.INTEGER);<br />en el que se indica el parámetro que es de salida y el tipo de datos al que pertenece el parámetro de salida.<br />A continuación se dan valor a los parámetros al igual que ocn las sentencias predefinidas con los métodos ser.<br />Y finalmente se ejecutará el procedimiento teniendo en cuenta que si el PROC almacenado ejecuta a una sentencia o select se llamará al método “cstmt.executeUpdate();” y si no es una sentencia o select se utilizará: cstmt.executeQuery(); <br />Ejemplo:<br />CallableStatement cstmt = con.prepareCall (“? = call CrearPersona (?,?)”);<br />cstmt.registerOutParameter (1, Types.INTEGER);<br />cstmt.setInt (2, 13456789);<br />cstmt.setString (3, “Bart”);<br />cstmt.execute();<br />int n = cstmt.getInt(1);<br />OBSERVACIÓN: Con la BD de “ApacheDerby” todo esto no funciona, es decir, no se pueden manejar de este modo los PROC ni FUNC<br />El método: Execute(); se utiliza para ejecutar procedimientos mixtos, es decir, si en el PROC almacenado existen sentencias select peor tbn tiene otras instrcciones insert, update, delete… entonces debemos usar este método y no el executeQuery o executeUpdate.<br />Ejercicio: abrimos el proyecto “UsoJdbcMySql “ que está en la careta de apuntes del profesor del lunes 14 de Junio. <br />Recordemos que como vamos a utilizar la base de datos MYSQL, con lo que deben esar instalados los drivers de MySQL en el path de la máquina.<br />Este ejemplo nos da la sintaxis para crear un modelo de datos a través de un programa java.<br />No es lo más útil peor si nos da una herramienta o una ayuda por si alguna vez y por temas de portabilidad nos interesa crear así el modelo.<br /> Tansaciones<br />[ver 3.7]<br />El objetivo de una transacione es agrupar un conjunto de sentencias SQl en un mismo “paraguas”, es decir, que en el momento que una de ellas falle se desharán todas las acciones realizadas hasta entonces en la BD.<br />Si todas las sentencias han ido bien se realiza un commit(); y si falla se hace un rollback();.<br />Jdbc cada vez que se lanza una sentencia con éxito hace automáticamente un commit(),pero hay que indicarle que lo haga.<br />Para ello usamos el método: con.setAutoCommit (false);<br />False las transacciones serán controladas manualmente por el programador. En este caso tras la realización de la ssentencias de debe llamar además la método con.commit();<br />True las transacciones las hace automáticamente jdbc.<br />Ej:<br />Try{<br />Con.setautoCommit(false); //toma el control el programador<br />S1----<br />S2-----<br />S3----<br />Con.commit(); // todo ha ido bien<br />}catch (SQLException e){<br />Con.rollback(); //algo ha fallado<br />}finally{<br />//el código dentro de un finally se ejecuta siempre salten o no excepciones<br />Con.setAutocommit(true); //toma el control jdbc<br />}<br /> Un nivel de aislamiento o de transacción bloquea procesos sobre una sentencia hasta que la transacción correspondiente haya terminado.<br />Hay varios niveles de aislamientos, que se consultan en la API´s de java mejor.<br />Optimizaciones y otras mejoras<br />[ver 5]<br />Existen varias optimizaciones para la marcha de las aplicaciones:<br />1.- Sentencias preparadas que ya las conocemos<br />2.- Uso de PROC almacenados<br />Vamos a ver otras que se han comentado de pasada y ahora detallaremos.<br />Porcentaje de carga: <br />[ver 5.1]<br />setFechtSize() permite cambiar le procentaje de carga a nivel de resultSet o a nivel de Statement (en este caso todos los resulSet herdarán estas porcentaje de carga)<br />getFechtSize() nos dice el porcentaje de carga del que disponemos.<br />Se aconseja que el porcentaje de carga no se modifique, hasta que no sepamos a quién se la debemos aplicar, es decir, saber de “en que” gasta el tiempo la aplicación y “que hacen los usuarios finales” con la aplicación.<br />Actualizaciones en modo bach<br />[ver 5.2]<br />Lo que se hará es minimizar el tráfico cliente-servidor d elas aplicaciones.<br />Se tiene el método addBatch(), cuando se lanzan sentencias teniendo un addBatch() jdbc no envía la sentencia a BD sino que las guarda en un “cajón” hasta que encuentra el método executeBatch() que lanzará todas las sentencias en un mismo “round”, de una vez todas juntas y no con un round por cada sentencia.<br />Así en vez de tener N rounds tendré 1 round con todas las sentencias, con lo que habremos disminuido sustancialmente el tráfico.<br />Este modo no aumenta la carga en el servido en ningún caso, por lo que no se conocen “efectos negativos”.<br />Nuevos tipos de resultSet<br />[ver 5.3]<br />Con los nuevos tipo de result set podemos hacer:<br />Recorrerlo en ambos sentidos<br />Movimiento absoluto: xEj:“vete a la fila 14”<br />Movimiento relativo: xEj: “desde donde estas sube 5 filas, -5, y luego baja 14 filas, +14”<br />Insertar/borra/actualizar filas desde dentro del rs: xEj: “si me encuentro el valor 2 en el rs insertar una nueva fila en la tabla MiTabla..”<br />Para crearlos: <br />Statement st = con.createStatement(parametro1,prametro2)<br />A tener en cuenta: <br />Cuanto más nuevo sea un rs más lento será. Todo lo que se haga con los nuevos rs se puede hacer con los rs más simples de todos que son los que hemos expliacdo estos días atrás, puesto que todo será más rápido.<br />La mayoría de las operaciones de nuevos rs no las soportan muchas BD. Si el Apartado[6] nos lo deja como ejercicio para nosotros y no lo haremos aquí.<br />EJERCICIO: Prácticas del epígrafe 8. Están resueltas en el paquete UsoJdbcMySql “ que está en la careta de apuntes del profesor del lunes 14 de Junio.<br />Vamos a revisar el código <br />Jueves 17 Junio<br />No asistí a clase .<br />Se tocaron temas de persistencia [Ver …]<br />Comenzaron con JPA (Java persistence api)<br />Lunes 21 Junio<br />…Continuación del Jueves JPA…<br />EntityManager<br />Se crea un EntityManager por cada conexión a una base de datos que desee.<br />Intentar usar un único EntityManager por cada método. <br />Después abriré una transacción de forma obligatoria.<br />Ver ejemplo Miércoles 16 Junio del proyecto “JpaUnaClase0000” la clase Principal.<br />EL método merge():<br /> //Nota: la llamada al método merge es innecesaria<br />Se usa para actualizar versiones. Pero no es necesario pues cuando se opera con un objeto de tipo “EntityManager” al hacer el commit() se actualiza de forma automática todas las versiones. <br />El EntityManager debe estar abierto y debe conocer los objetos. <br />Sin embargo si le hago persistente al hacer el el commit() los actualizará de forma automática.<br />Si utilizase más de un entityManager y lo cierro cuando no lo utilice todas las actualizaciones se harán de forma automática. Si utilizase uno al pripio d elcódgio que siempre sestuviese abierto tendrái que controlar “su crecimiento” a través d elos métodos:<br />Flush: hará una actualización de tofo <br />clear: Borrar el caché de la BD<br />Por eso se aconseja utilizar solo uno.<br />Para crear un objeto EntityManager debo llamar al Método CreateEntityManager.<br />Creacción de las clases URM en un proyecto con un modelo de datos existente<br />Si en un proyecto ya existe un modelo de Datos pero no existen las clases.<br />Ver ejemplo: JavaApplication23<br />Creo una clase nueva para nosotros: JavaApplication23<br />Botón derecho para hacer “ingeniería Inversa”. Y selecciono opción: Entity Classes for database<br />Añado la tabla PERSONA sobre la que haremos IngenieriaInversa:<br />Este check tiene que estar marcado, porque si hay relaciones entre muchas tablas al hacer ingenieria inversa habrá que hacer a mano muchas cosas para dejarlo bien.<br />La ingeniería inversa por tanto con tablas aisladas o tablas relacionadas de 1 a n, si trabajan bien.<br />Al llegar a la pantalla:<br />Nos informa queno hay unidad de persistencia y nos indica si queremos que la herramienta nos ayude, para ello pulsamos el botón: Create persistence unit…<br />Sleccionamos como proveedor a Hibernate:<br />Lo aceptamos y seguimos el proceso llegando a esta pantalla, en la que marcamos los checks.<br />19570148<br />Nos crea en la carpeta META-INF el xml de persistence. (Que explicaron el jueves) y nos crea el código de java de las clase correspondiente a la tabla de la BD. Que justo es d elo que se trataba la Ingeniería Inversa.<br />Queryes con nombre. Anotaciones<br />[ver clase Personadel proyecto nuevo creado: JavaApplication23]<br />@Temporal: <br />@Lob: LargeObject<br />@NamedQuery (name= “Persona.findByNombre”, query = “SELECT P FROM PERSONA P”)<br />PRACTICA: montra un proyecto que tenga persistencia<br />Ver Ejemplo miércoles 16 : JpaUnaClase0002<br />Martes 22 Junio<br />Patrones de diseño. DAO<br />Si el código esta bajo JPA y cambiamos a hibérnate el código puede ser que no compile..<br />Para resolver esto existen los “Design Pattens” o patrones de diseño.<br />Los patrones de diseño, es una estrategia que se sabe que va a funcionar para resolver un escenario determinado, es decir, una solución estándar que se sabe por anticipado que va a funcionar para un escenario problemático determinado. Pero ojo no tiene por qué ser la solución óptima.<br />Los patrones de diseño más utilizados en la tecnología java son los GoF (Gangs of four). <br />Nota Si queremos información sobre esto solicitarla al profe por el foro<br />Nota: Recapitulando lo visto hasta hoy en curso tendremos la estructura: Jpa > ORM > Jdbc > BD.<br />El patrón de diseño más simple que hay es el DAO (objeto de acceso a datos).<br />Cliente (cliente ) DAO (interface que ve el cliente) JpaDaO (implementación de la interface DAO)<br />Si el día d emañana quiero utilizar Hibernate en vez de JPA bastará implementar una nueva interface en hibérnate y para el cliente será totalmente trasparente. Y lo mismo si nuevamente quisiera vambiar de tecnología y utilizar otra como por ejemplo Jdbc t tendría que implementar jdbcDAO.<br />Ejemplo: JpaUnaClase0002<br />El patrón DAO nos sirve para enumerar todos los métodos de una clase persistente de una sola “atacada” en el ejemplo será la clase PersonaDAO. Esta interface es publica peor su implementación no lo será.<br />Luego tendremos que tener una clase que nos implemente el DAO. En el ejemplo es la clase PersonaDAOImple.<br />En el ejemplo el main está en un paquete distinto a en el que está la implementación del DAO, para que se puedan utilizar se ha creado otro patrón de diseño llamado Singleton, y que en el ejemplo es la clase: PersonaManager.<br />En el escenario siguiente:<br />Solo una instancia de una clase: para o cual se llama <br />Que sea instanciada desde cualquier sitio: para ello el constructor se define como privado y los atributos se define como privado y estático<br />Es donde se suele utilizar justamente este patrón de diseño llamado singleton.<br />El método getInstance() es el que nos asegura que únicamente se va a instanciar el Personamanager una única vez puesto que el “if” del código tras haberlo instanciado mñas de una vez siempre nos devolverá el mismo objeto.<br />Si ahora quiero trabajar con los métodos del DAO, me creo el método getPersonaDao() que nos devolverá un objeto de tipo implementación de la clase PersonaDao.<br />Si quiero cambiar de tecnología lo que cambiaré es justamente este método:<br />En el ejemplo tenemos:<br />public PersonaDao getPersonaDao() {<br /> return new PersonaDaoImpl();<br /> }<br />Si quiero usar jdbc haré:<br />public PersonaDao getPersonaDao() {<br /> return new PersonajdbcImpl();<br /> }<br />Nota: En un escenario real de PROD cuanto menos nos “cueste” (rápido, fácil y barato) introducir cambios será un indicador de que la aplicación está bien programada, tal y como es el objetivo de la programación orientada a objetos.<br />Ver también ejemplo jueves 17 junio : JpaDosClases0001<br />Persistencia de relaciones entre clases<br />[Carpeta jueves 17 Junio. Ejemplo: JpaDosClases0001]<br />La relaciones que hay entre clase en java son muy similares a las que hay en UML.<br /> Ejemplo: <br /> La relación entre una Persona y su Afición puede tener distintas relaciones:<br />1----- 1 ( de una a una): Aficion A; Perosna p;<br />1 ---- * (de una a muchas): Persona p; List<Aficion> l;<br />*----*(de muchas a muchas) List<Persona> pl ; List<Aficion> la;<br /> En JPA esto se representa con las anotaciones:<br />@OneToOne<br />@ManyToMany<br />@OneToMany<br />@ManyToOne <br />En relaciones de 1 a muchos (1 *) necesitamos que se haga persistencia en objetos declarados en cascada. Podemos mandar a JPA que haga la persistencia en cascada. Una operación en cascada en JPA significa que cuando se le dice al urm que haga persistencia sobre un objeto también lo hará sobre todos los objetos que cuelguen de él.<br />En JPA se hace con el comando “cascade”.<br />Academia (18:00h 19:30h)<br />Curiosidades<br />http: protocolo trasferencia de hipertexto<br />www: worl wile web<br />Ley no escrita de la informática: “Todo programa se tira el 90% de su tiempo en el 10% del código.”<br />